main.cpp

Go to the documentation of this file.

#include "mxvk/argz.hpp"
#include "mxvk/mxvk.hpp"
#include "mxvk/mxvk_exception.hpp"
#include "mxvk/mxvk_stopwatch.hpp"
#if defined(MXVK_USE_EIGEN_MATH)
#include "mxvk/mxvk_math_eigen.hpp"
#else
#include "mxvk/mxvk_math.h"
#endif
#include "mxvk/mxvk_png.hpp"
 
#include <SDL3/SDL.h>
 
#include <algorithm>
#include <array>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <filesystem>
#include <format>
#include <iostream>
#include <limits>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace {
#if defined(MXVK_OBJ_LOADER)
    constexpr std::string_view APP_NAME = "3dmath_obj_loader";
    constexpr std::string_view MODEL_FORMAT = "OBJ";
    constexpr std::string_view DEFAULT_MODEL = "sphere.obj";
    constexpr std::string_view WINDOW_TITLE = "MXVK 3D Math OBJ Loader";
    constexpr float MODEL_FIT_RADIUS = 1.6f;
    constexpr mxvk::MXCOLOR BACKGROUND_COLOR = mxvk::MXVK_RGB(15, 22, 35);
#else
    constexpr std::string_view APP_NAME = "3dmath_plg_loader";
    constexpr std::string_view MODEL_FORMAT = "PLG";
    constexpr std::string_view DEFAULT_MODEL = "sphere.plg";
    constexpr std::string_view WINDOW_TITLE = "MXVK 3D Math PLG Loader";
    constexpr float MODEL_SCALE = 2.0f;
    constexpr mxvk::MXCOLOR BACKGROUND_COLOR = mxvk::MXVK_RGB(3, 4, 8);
#endif
 
    class SurfaceDeleter {
      public:
        void operator()(SDL_Surface *surface) const {
            SDL_DestroySurface(surface);
        }
    };
 
    using SurfacePtr = std::unique_ptr<SDL_Surface, SurfaceDeleter>;
 
    [[nodiscard]] mxvk::MXCOLOR pack_color(std::uint32_t red, std::uint32_t green, std::uint32_t blue, std::uint32_t alpha) {
        return ((alpha & 0xFFU) << 24U) |
               ((red & 0xFFU) << 16U) |
               ((green & 0xFFU) << 8U) |
               (blue & 0xFFU);
    }
 
    [[nodiscard]] mxvk::MXCOLOR interpolate_color(mxvk::MXCOLOR first, mxvk::MXCOLOR second, float fraction) {
        const std::uint32_t second_weight = static_cast<std::uint32_t>(
            std::clamp(static_cast<int>(fraction * 256.0f + 0.5f), 0, 256));
        const std::uint32_t first_weight = 256U - second_weight;
        const auto interpolate_channel = [first_weight, second_weight](std::uint8_t first_channel, std::uint8_t second_channel) {
            return (static_cast<std::uint32_t>(first_channel) * first_weight +
                    static_cast<std::uint32_t>(second_channel) * second_weight +
                    128U) >>
                   8U;
        };
        return pack_color(
            interpolate_channel(mxvk::color_r(first), mxvk::color_r(second)),
            interpolate_channel(mxvk::color_g(first), mxvk::color_g(second)),
            interpolate_channel(mxvk::color_b(first), mxvk::color_b(second)),
            interpolate_channel(mxvk::color_a(first), mxvk::color_a(second)));
    }
 
    struct MipLevel {
        int width = 0;
        int height = 0;
        std::vector<mxvk::MXCOLOR> pixels;
 
        [[nodiscard]] mxvk::MXCOLOR sample_bilinear(float u, float v, bool repeat_horizontal) const {
            u = repeat_horizontal ? u - std::floor(u) : std::clamp(u, 0.0f, 1.0f);
            v = std::clamp(v, 0.0f, 1.0f);
            const float texture_x = u * static_cast<float>(repeat_horizontal ? width : width - 1);
            const float texture_y = v * static_cast<float>(height - 1);
            const int first_x = static_cast<int>(std::floor(texture_x));
            const int first_y = static_cast<int>(std::floor(texture_y));
            const int second_x = repeat_horizontal ? (first_x + 1) % width : std::min(first_x + 1, width - 1);
            const int second_y = std::min(first_y + 1, height - 1);
            const float x_fraction = texture_x - static_cast<float>(first_x);
            const float y_fraction = texture_y - static_cast<float>(first_y);
            const auto texel = [this](int x, int y) {
                return pixels[static_cast<std::size_t>(y) * static_cast<std::size_t>(width) + static_cast<std::size_t>(x)];
            };
            const mxvk::MXCOLOR top = interpolate_color(texel(first_x, first_y), texel(second_x, first_y), x_fraction);
            const mxvk::MXCOLOR bottom = interpolate_color(texel(first_x, second_y), texel(second_x, second_y), x_fraction);
            return interpolate_color(top, bottom, y_fraction);
        }
    };
 
    struct Texture {
        std::vector<MipLevel> levels;
 
        [[nodiscard]] bool empty() const {
            return levels.empty() || levels.front().width <= 0 || levels.front().height <= 0 || levels.front().pixels.empty();
        }
 
        [[nodiscard]] int width() const {
            return empty() ? 0 : levels.front().width;
        }
 
        [[nodiscard]] int height() const {
            return empty() ? 0 : levels.front().height;
        }
 
        [[nodiscard]] mxvk::MXCOLOR sample(float u, float v, float level, bool repeat_horizontal) const {
            level = std::clamp(level, 0.0f, static_cast<float>(levels.size() - 1));
            const std::size_t first_level = static_cast<std::size_t>(std::floor(level));
            const std::size_t second_level = std::min(first_level + 1, levels.size() - 1);
            const float fraction = level - static_cast<float>(first_level);
            const mxvk::MXCOLOR first_color = levels[first_level].sample_bilinear(u, v, repeat_horizontal);
            if (first_level == second_level) {
                return first_color;
            }
            return interpolate_color(first_color, levels[second_level].sample_bilinear(u, v, repeat_horizontal), fraction);
        }
    };
 
    [[nodiscard]] SurfacePtr create_frame_surface(int width, int height) {
        SurfacePtr surface(SDL_CreateSurface(width, height, SDL_PIXELFORMAT_RGBA32));
        if (!surface) {
            throw mxvk::Exception(std::format("{}: failed to create frame surface: {}", APP_NAME, SDL_GetError()));
        }
        return surface;
    }
 
    [[nodiscard]] std::filesystem::path model_path(const std::string &filename, const std::string &asset_path) {
        if (!filename.empty()) {
            return filename;
        }
        return std::filesystem::path(asset_path) / "data" / DEFAULT_MODEL;
    }
 
    [[nodiscard]] std::filesystem::path texture_path(const std::string &filename, const std::string &asset_path) {
        const std::filesystem::path requested(filename);
        if (requested.is_absolute() || std::filesystem::exists(requested)) {
            return requested;
        }
 
        const std::filesystem::path from_asset_path = std::filesystem::path(asset_path) / requested;
        if (std::filesystem::exists(from_asset_path)) {
            return from_asset_path;
        }
        return requested;
    }
 
    [[nodiscard]] Texture load_texture(const std::string &filename, const std::string &asset_path, bool generate_mipmaps) {
        if (filename.empty()) {
            return {};
        }
 
        const std::filesystem::path path = texture_path(filename, asset_path);
        SurfacePtr loaded(mxvk::LoadPNG(path.string().c_str()));
        if (!loaded) {
            throw mxvk::Exception(std::format("{}: failed to load texture '{}'", APP_NAME, path.string()));
        }
 
        SurfacePtr rgba(SDL_ConvertSurface(loaded.get(), SDL_PIXELFORMAT_RGBA32));
        if (!rgba) {
            throw mxvk::Exception(std::format("{}: failed to convert texture '{}': {}", APP_NAME, path.string(), SDL_GetError()));
        }
 
        const SDL_PixelFormatDetails *format = SDL_GetPixelFormatDetails(rgba->format);
        if (format == nullptr) {
            throw mxvk::Exception(std::format("{}: failed to query texture format '{}': {}", APP_NAME, path.string(), SDL_GetError()));
        }
 
        Texture texture;
        MipLevel base_level;
        base_level.width = rgba->w;
        base_level.height = rgba->h;
        base_level.pixels.resize(static_cast<std::size_t>(base_level.width) * static_cast<std::size_t>(base_level.height));
        for (int y = 0; y < base_level.height; ++y) {
            const auto *row = static_cast<const std::uint8_t *>(rgba->pixels) + static_cast<std::size_t>(y) * static_cast<std::size_t>(rgba->pitch);
            const auto *source = reinterpret_cast<const std::uint32_t *>(row);
            for (int x = 0; x < base_level.width; ++x) {
                std::uint8_t red = 0;
                std::uint8_t green = 0;
                std::uint8_t blue = 0;
                std::uint8_t alpha = 0;
                SDL_GetRGBA(source[x], format, nullptr, &red, &green, &blue, &alpha);
                base_level.pixels[static_cast<std::size_t>(y) * static_cast<std::size_t>(base_level.width) + static_cast<std::size_t>(x)] =
                    pack_color(red, green, blue, alpha);
            }
        }
        texture.levels.push_back(std::move(base_level));
 
        while (generate_mipmaps && (texture.levels.back().width > 1 || texture.levels.back().height > 1)) {
            const MipLevel &source = texture.levels.back();
            MipLevel destination;
            destination.width = std::max(1, (source.width + 1) / 2);
            destination.height = std::max(1, (source.height + 1) / 2);
            destination.pixels.resize(static_cast<std::size_t>(destination.width) * static_cast<std::size_t>(destination.height));
            for (int y = 0; y < destination.height; ++y) {
                for (int x = 0; x < destination.width; ++x) {
                    const int first_x = std::min(x * 2, source.width - 1);
                    const int second_x = std::min(first_x + 1, source.width - 1);
                    const int first_y = std::min(y * 2, source.height - 1);
                    const int second_y = std::min(first_y + 1, source.height - 1);
                    const auto texel = [&source](int source_x, int source_y) {
                        return source.pixels[static_cast<std::size_t>(source_y) * static_cast<std::size_t>(source.width) + static_cast<std::size_t>(source_x)];
                    };
                    const std::array<mxvk::MXCOLOR, 4> colors = {
                        texel(first_x, first_y),
                        texel(second_x, first_y),
                        texel(first_x, second_y),
                        texel(second_x, second_y),
                    };
                    const auto average_channel = [&colors](auto component) {
                        std::uint32_t sum = 0;
                        for (const mxvk::MXCOLOR color : colors) {
                            sum += component(color);
                        }
                        return (sum + 2U) / 4U;
                    };
                    destination.pixels[static_cast<std::size_t>(y) * static_cast<std::size_t>(destination.width) + static_cast<std::size_t>(x)] =
                        pack_color(
                            average_channel(mxvk::color_r),
                            average_channel(mxvk::color_g),
                            average_channel(mxvk::color_b),
                            average_channel(mxvk::color_a));
                }
            }
            texture.levels.push_back(std::move(destination));
        }
 
        std::cout << std::format(
            "{}: loaded texture '{}' ({}x{}, {} mip levels)\n",
            APP_NAME,
            path.string(),
            texture.width(),
            texture.height(),
            texture.levels.size());
        return texture;
    }
 
    struct FaceDraw {
        std::array<mxvk::vec4D, 3> points{};
        std::array<mxvk::vec2D, 3> texcoords{};
        mxvk::MXCOLOR material_color = mxvk::MXVK_RGB(255, 255, 255);
        int material_index = -1;
        bool repeat_horizontal = false;
        float intensity = 1.0f;
    };
 
    [[nodiscard]] bool crosses_horizontal_texture_seam(const std::array<mxvk::vec2D, 3> &texcoords) {
        const auto [minimum, maximum] = std::minmax_element(
            texcoords.begin(),
            texcoords.end(),
            [](const mxvk::vec2D &first, const mxvk::vec2D &second) {
                return first.x < second.x;
            });
        const float span = maximum->x - minimum->x;
        return span > 0.5f && span < 1.0f - mxvk::EPSILON;
    }
 
    [[nodiscard]] std::array<mxvk::vec2D, 3> unwrap_horizontal_texcoords(std::array<mxvk::vec2D, 3> texcoords) {
        if (!crosses_horizontal_texture_seam(texcoords)) {
            return texcoords;
        }
 
        for (mxvk::vec2D &texcoord : texcoords) {
            if (texcoord.x < 0.5f) {
                texcoord.x += 1.0f;
            }
        }
 
        for (std::size_t index = 0; index < texcoords.size(); ++index) {
            if (texcoords[index].y > mxvk::EPSILON && texcoords[index].y < 1.0f - mxvk::EPSILON) {
                continue;
            }
 
            const std::size_t next = (index + 1) % texcoords.size();
            const std::size_t previous = (index + texcoords.size() - 1) % texcoords.size();
            texcoords[index].x = (texcoords[next].x + texcoords[previous].x) * 0.5f;
        }
        return texcoords;
    }
 
    constexpr float MIN_CAMERA_DISTANCE = 2.5f;
    constexpr float MAX_CAMERA_DISTANCE = 12.0f;
    constexpr float CAMERA_ZOOM_STEP = 0.45f;
    constexpr float MOUSE_ROTATION_SENSITIVITY = 0.35f;
    constexpr float MAX_PITCH_DEGREES = 89.0f;
#if defined(MXVK_USE_EIGEN_MATH)
    constexpr std::string_view BACKEND_NAME = "Eigen";
#else
    constexpr std::string_view BACKEND_NAME = "native";
#endif
} // namespace
 
namespace example {
    class Math3DModelLoaderWindow : public mxvk::VK_Window {
      public:
        Math3DModelLoaderWindow(const std::string &filename, const std::string &texture_filename, const std::string &asset_path, const std::string &title, int width, int height, bool fullscreen, bool enable_vsync, bool repeat_texture, bool disable_warp_fix, bool disable_mipmap, float mip_bias, const FramebufferDimensions &framebuffer, bool benchmark, bool wireframe)
            : mxvk::VK_Window(title, width, height, fullscreen, MXVK_VALIDATION, enable_vsync),
              override_texture(wireframe ? Texture{} : load_texture(texture_filename, asset_path, !disable_mipmap)),
              frame_width(framebuffer.width),
              frame_height(framebuffer.height),
              fallback_width(width),
              fallback_height(height),
              warp_fix_enabled(!disable_warp_fix),
              mipmapping_enabled(!disable_mipmap),
              mip_level_bias(mip_bias),
              texture_repeat_enabled(repeat_texture),
              benchmark_enabled(benchmark),
              wireframe_enabled(wireframe) {
            setClearColor(0.012f, 0.015f, 0.022f, 1.0f);
            mxvk::BuildTables();
 
            const std::filesystem::path path = model_path(filename, asset_path);
#if defined(MXVK_OBJ_LOADER)
            const mxvk::vec4D scale(1.0f, 1.0f, 1.0f);
#else
            const mxvk::vec4D scale(MODEL_SCALE, MODEL_SCALE, MODEL_SCALE);
#endif
#if defined(MXVK_OBJ_LOADER)
            const bool model_loaded = model.LoadOBJ(path.string(), scale, mxvk::vec4D(0.0f, 0.0f, 4.5f), mxvk::vec4D());
#else
            const bool model_loaded = model.LoadPLG(path.string(), scale, mxvk::vec4D(0.0f, 0.0f, 4.5f), mxvk::vec4D());
#endif
            if (!model_loaded) {
                throw mxvk::Exception(std::format("{}: failed to load {} model '{}'", APP_NAME, MODEL_FORMAT, path.string()));
            }
#if defined(MXVK_OBJ_LOADER)
            filter_auxiliary_objects();
            fit_model_to_view();
            if (!wireframe_enabled) {
                load_material_textures(asset_path, !disable_mipmap);
            }
#endif
#if defined(MXVK_USE_EIGEN_MATH)
            local_vertex_batch.resize(4, static_cast<Eigen::Index>(model.local.size()));
            camera_vertex_batch.resize(4, static_cast<Eigen::Index>(model.local.size()));
            projected_vertex_batch.resize(4, static_cast<Eigen::Index>(model.local.size()));
            inverse_vertex_depth.resize(static_cast<Eigen::Index>(model.local.size()));
#if !defined(MXVK_OBJ_LOADER)
            local_face_center_batch.resize(4, static_cast<Eigen::Index>(model.vlist.size()));
            camera_face_center_batch.resize(4, static_cast<Eigen::Index>(model.vlist.size()));
#endif
            local_face_normal_batch.resize(4, static_cast<Eigen::Index>(model.vlist.size()));
            camera_face_normal_batch.resize(4, static_cast<Eigen::Index>(model.vlist.size()));
            triangle_intensity.resize(static_cast<Eigen::Index>(model.vlist.size()));
#if !defined(MXVK_OBJ_LOADER)
            triangle_visible.resize(static_cast<Eigen::Index>(model.vlist.size()));
#endif
            for (std::size_t index = 0; index < model.local.size(); ++index) {
                local_vertex_batch.col(static_cast<Eigen::Index>(index)) =
                    Eigen::Vector4f(model.local[index].x, model.local[index].y, model.local[index].z, model.local[index].w);
            }
#else
            camera_vertices.resize(model.local.size());
            projected_vertices.resize(model.local.size());
#endif
            initialize_face_geometry();
            visible_faces.reserve(model.vlist.size());
            std::cout << std::format("{}: loaded '{}' ({} vertices, {} triangles, {} materials)\n", APP_NAME, path.string(), model.num_vertices, model.num_polys, model.materials.size());
        }
 
        void event(SDL_Event &e) override {
            if (e.type == SDL_EVENT_KEY_DOWN && e.key.key == SDLK_ESCAPE) {
                exit();
            }
            if (e.type == SDL_EVENT_KEY_DOWN && e.key.key == SDLK_SPACE && !e.key.repeat) {
                automatic_rotation = !automatic_rotation;
                return;
            }
            if (e.type == SDL_EVENT_MOUSE_BUTTON_DOWN && e.button.button == SDL_BUTTON_LEFT) {
                mouse_dragging = true;
                last_mouse_x = e.button.x;
                last_mouse_y = e.button.y;
                return;
            }
            if (e.type == SDL_EVENT_MOUSE_BUTTON_UP && e.button.button == SDL_BUTTON_LEFT) {
                mouse_dragging = false;
                return;
            }
            if (e.type == SDL_EVENT_WINDOW_FOCUS_LOST) {
                mouse_dragging = false;
                return;
            }
            if (e.type == SDL_EVENT_MOUSE_MOTION && mouse_dragging) {
                const float delta_x = e.motion.x - last_mouse_x;
                const float delta_y = e.motion.y - last_mouse_y;
                yaw_degrees = std::fmod(yaw_degrees + delta_x * MOUSE_ROTATION_SENSITIVITY, 360.0f);
                pitch_degrees = std::clamp(
                    pitch_degrees + delta_y * MOUSE_ROTATION_SENSITIVITY,
                    -MAX_PITCH_DEGREES,
                    MAX_PITCH_DEGREES);
                last_mouse_x = e.motion.x;
                last_mouse_y = e.motion.y;
                return;
            }
            if (e.type == SDL_EVENT_MOUSE_WHEEL) {
                const float delta = e.wheel.y != 0.0f ? e.wheel.y : static_cast<float>(e.wheel.integer_y);
                camera_distance = std::clamp(camera_distance - delta * CAMERA_ZOOM_STEP, MIN_CAMERA_DISTANCE, MAX_CAMERA_DISTANCE);
            }
        }
 
        void proc() override {
            const int output_width = swapchain_extent.width > 0U ? static_cast<int>(swapchain_extent.width) : fallback_width;
            const int output_height = swapchain_extent.height > 0U ? static_cast<int>(swapchain_extent.height) : fallback_height;
 
            ensure_framebuffer();
            if (frame_sprite == nullptr || frame_surface == nullptr || frame_format == nullptr) {
                return;
            }
 
            clear_frame(BACKGROUND_COLOR);
            std::ranges::fill(depth_buffer, std::numeric_limits<float>::infinity());
 
            const std::uint64_t current_ticks = SDL_GetTicks();
            const float elapsed_seconds = previous_frame_ticks == 0
                                              ? 0.0f
                                              : static_cast<float>(current_ticks - previous_frame_ticks) * 0.001f;
            previous_frame_ticks = current_ticks;
            if (automatic_rotation && !mouse_dragging) {
                yaw_degrees = std::fmod(yaw_degrees + elapsed_seconds * 42.0f, 360.0f);
            }
 
            if (benchmark_enabled && benchmark_frame_count == 0) {
                benchmark_stopwatch =
                    std::make_unique<StopWatch<HighResolutionClockPolicy>>(benchmark_name);
            }
 
            mxvk::Mat4D rotation;
            rotation.BuildXYZ(pitch_degrees, yaw_degrees, 0.0f);
            transform_and_project_vertices(rotation);
 
            mxvk::vec4D light_direction(-0.35f, -0.55f, -1.0f, 0.0f);
            light_direction.Normalize();
            visible_faces.clear();
            build_visible_faces(rotation, light_direction);
 
            for (const FaceDraw &face : visible_faces) {
                if (wireframe_enabled) {
                    wireframe_pipeline.DrawWireframeTriangle(
                        face.points[0],
                        face.points[1],
                        face.points[2],
                        mxvk::shade_color(face.material_color, face.intensity),
                        depth_buffer);
                } else {
                    draw_gradient_triangle(face);
                }
            }
 
            if (benchmark_stopwatch != nullptr) {
                ++benchmark_frame_count;
                if (benchmark_frame_count == BENCHMARK_FRAME_COUNT) {
                    benchmark_stopwatch->Stop();
                    benchmark_stopwatch.reset();
                    exit();
                }
            }
 
            frame_sprite->updateTexture(frame_surface->pixels, frame_width, frame_height, frame_surface->pitch);
            frame_sprite->drawSpriteRect(0, 0, output_width, output_height);
        }
 
      private:
        mxvk::mxObject model;
        mxvk::PipeLine wireframe_pipeline;
        Texture override_texture;
        std::vector<Texture> material_textures;
        SurfacePtr frame_surface;
#if defined(MXVK_USE_EIGEN_MATH)
        using VertexBatch = Eigen::Matrix<float, 4, Eigen::Dynamic, Eigen::RowMajor>;
        VertexBatch local_vertex_batch;
        VertexBatch camera_vertex_batch;
        VertexBatch projected_vertex_batch;
        Eigen::RowVectorXf inverse_vertex_depth;
        VertexBatch local_face_center_batch;
        VertexBatch camera_face_center_batch;
        VertexBatch local_face_normal_batch;
        VertexBatch camera_face_normal_batch;
        Eigen::RowVectorXf triangle_intensity;
        Eigen::Array<bool, 1, Eigen::Dynamic> triangle_visible;
#else
        std::vector<mxvk::vec4D> camera_vertices;
        std::vector<mxvk::vec4D> projected_vertices;
        std::vector<mxvk::vec4D> local_face_centers;
        std::vector<mxvk::vec4D> camera_face_centers;
        std::vector<mxvk::vec4D> local_face_normals;
        std::vector<mxvk::vec4D> camera_face_normals;
#endif
        std::vector<FaceDraw> visible_faces;
        std::vector<float> depth_buffer;
        const SDL_PixelFormatDetails *frame_format = nullptr;
        mxvk::VK_Sprite *frame_sprite = nullptr;
        int frame_width = 1280;
        int frame_height = 720;
        int fallback_width = 1280;
        int fallback_height = 720;
        float camera_distance = 4.25f;
        float pitch_degrees = 0.0f;
        float yaw_degrees = 0.0f;
        float last_mouse_x = 0.0f;
        float last_mouse_y = 0.0f;
        bool mouse_dragging = false;
        bool automatic_rotation = true;
        std::uint64_t previous_frame_ticks = 0;
        bool warp_fix_enabled = true;
        bool mipmapping_enabled = true;
        float mip_level_bias = 0.0f;
        bool texture_repeat_enabled = false;
        bool benchmark_enabled = false;
        bool wireframe_enabled = false;
        std::size_t benchmark_frame_count = 0;
        std::string benchmark_name =
            std::format("{} geometry draw ({} backend, {} frames)", MODEL_FORMAT, BACKEND_NAME, BENCHMARK_FRAME_COUNT);
        std::unique_ptr<StopWatch<HighResolutionClockPolicy>> benchmark_stopwatch;
 
        static constexpr std::size_t BENCHMARK_FRAME_COUNT = 60 * 10;
 
#if defined(MXVK_OBJ_LOADER)
        void fit_model_to_view() {
            if (model.vlist.empty()) {
                throw mxvk::Exception(std::format("{}: cannot fit an OBJ model with no triangles", APP_NAME));
            }
 
            mxvk::vec4D minimum(
                std::numeric_limits<float>::max(),
                std::numeric_limits<float>::max(),
                std::numeric_limits<float>::max());
            mxvk::vec4D maximum(
                std::numeric_limits<float>::lowest(),
                std::numeric_limits<float>::lowest(),
                std::numeric_limits<float>::lowest());
            for (const mxvk::Triangle &triangle : model.vlist) {
                for (const int vertex_index : triangle.vert) {
                    const mxvk::vec4D &vertex = model.local[static_cast<std::size_t>(vertex_index)];
                    minimum.x = std::min(minimum.x, vertex.x);
                    minimum.y = std::min(minimum.y, vertex.y);
                    minimum.z = std::min(minimum.z, vertex.z);
                    maximum.x = std::max(maximum.x, vertex.x);
                    maximum.y = std::max(maximum.y, vertex.y);
                    maximum.z = std::max(maximum.z, vertex.z);
                }
            }
 
            const mxvk::vec4D center(
                (minimum.x + maximum.x) * 0.5f,
                (minimum.y + maximum.y) * 0.5f,
                (minimum.z + maximum.z) * 0.5f);
            float source_radius = 0.0f;
            for (const mxvk::Triangle &triangle : model.vlist) {
                for (const int vertex_index : triangle.vert) {
                    const mxvk::vec4D &vertex = model.local[static_cast<std::size_t>(vertex_index)];
                    source_radius = std::max(
                        source_radius,
                        std::sqrt(
                            (vertex.x - center.x) * (vertex.x - center.x) +
                            (vertex.y - center.y) * (vertex.y - center.y) +
                            (vertex.z - center.z) * (vertex.z - center.z)));
                }
            }
            if (!std::isfinite(source_radius) || source_radius <= mxvk::EPSILON) {
                throw mxvk::Exception(std::format("{}: cannot fit OBJ model with degenerate bounds", APP_NAME));
            }
 
            const float fit_scale = MODEL_FIT_RADIUS / source_radius;
            for (mxvk::vec4D &vertex : model.local) {
                vertex.x = (vertex.x - center.x) * fit_scale;
                vertex.y = (vertex.y - center.y) * fit_scale;
                vertex.z = (vertex.z - center.z) * fit_scale;
            }
            model.ComputeRad();
            std::cout << std::format(
                "{}: centered model and scaled radius {:.3f} to {:.3f} (scale {:.6f})\n",
                APP_NAME,
                source_radius,
                MODEL_FIT_RADIUS,
                fit_scale);
        }
#endif
 
        void filter_auxiliary_objects() {
            std::unordered_map<std::string, std::size_t> triangle_counts;
            for (const mxvk::Triangle &triangle : model.vlist) {
                ++triangle_counts[triangle.source_object_name];
            }
            if (triangle_counts.size() <= 1) {
                return;
            }
 
            const auto dominant = std::max_element(
                triangle_counts.begin(),
                triangle_counts.end(),
                [](const auto &left, const auto &right) {
                    return left.second < right.second;
                });
            constexpr float DOMINANT_OBJECT_FRACTION = 0.95f;
            if (static_cast<float>(dominant->second) <
                static_cast<float>(model.vlist.size()) * DOMINANT_OBJECT_FRACTION) {
                return;
            }
 
            const std::size_t original_triangle_count = model.vlist.size();
            std::erase_if(model.vlist, [&dominant](const mxvk::Triangle &triangle) {
                return triangle.source_object_name != dominant->first;
            });
            model.num_polys = static_cast<int>(model.vlist.size());
            model.object_name = dominant->first;
            std::cout << std::format(
                "{}: selected dominant OBJ object '{}' ({} triangles); ignored {} auxiliary triangle(s)\n",
                APP_NAME,
                dominant->first,
                dominant->second,
                original_triangle_count - model.vlist.size());
        }
 
        void load_material_textures(const std::string &asset_path, bool generate_mipmaps) {
            if (!override_texture.empty()) {
                return;
            }
 
            material_textures.resize(model.materials.size());
            for (std::size_t index = 0; index < model.materials.size(); ++index) {
                const std::string &texture_path = model.materials[index].diffuse_map;
                if (!texture_path.empty()) {
                    material_textures[index] = load_texture(texture_path, asset_path, generate_mipmaps);
                }
            }
        }
 
        [[nodiscard]] const Texture *face_texture(int material_index) const {
            if (!override_texture.empty()) {
                return &override_texture;
            }
            if (material_index >= 0 &&
                static_cast<std::size_t>(material_index) < material_textures.size() &&
                !material_textures[static_cast<std::size_t>(material_index)].empty()) {
                return &material_textures[static_cast<std::size_t>(material_index)];
            }
            return nullptr;
        }
 
#if defined(MXVK_USE_EIGEN_MATH)
        static void transform_eigen_batch(const mxvk::Mat4D &matrix, const VertexBatch &input, VertexBatch &output) {
            for (int component = 0; component < 4; ++component) {
                output.row(component).array() =
                    input.row(0).array() * matrix.mat[0][component] +
                    input.row(1).array() * matrix.mat[1][component] +
                    input.row(2).array() * matrix.mat[2][component] +
                    input.row(3).array() * matrix.mat[3][component];
            }
        }
#endif
 
        void initialize_face_geometry() {
#if !defined(MXVK_USE_EIGEN_MATH)
            local_face_centers.resize(model.vlist.size());
            camera_face_centers.resize(model.vlist.size());
            local_face_normals.resize(model.vlist.size());
            camera_face_normals.resize(model.vlist.size());
#endif
            for (std::size_t index = 0; index < model.vlist.size(); ++index) {
                const mxvk::Triangle &triangle = model.vlist[index];
                const mxvk::vec4D &a = model.local[static_cast<std::size_t>(triangle.vert[0])];
                const mxvk::vec4D &b = model.local[static_cast<std::size_t>(triangle.vert[1])];
                const mxvk::vec4D &c = model.local[static_cast<std::size_t>(triangle.vert[2])];
#if !defined(MXVK_USE_EIGEN_MATH) || !defined(MXVK_OBJ_LOADER)
                const mxvk::vec4D center(
                    (a.x + b.x + c.x) * (1.0f / 3.0f),
                    (a.y + b.y + c.y) * (1.0f / 3.0f),
                    (a.z + b.z + c.z) * (1.0f / 3.0f),
                    1.0f);
#endif
                mxvk::vec4D normal = mxvk::vec4D().Build(a, b).CrossProduct(mxvk::vec4D().Build(a, c));
                normal.Normalize();
                normal.w = 0.0f;
#if defined(MXVK_USE_EIGEN_MATH)
                const Eigen::Index batch_index = static_cast<Eigen::Index>(index);
#if !defined(MXVK_OBJ_LOADER)
                local_face_center_batch.col(batch_index) = Eigen::Vector4f(center.x, center.y, center.z, center.w);
#endif
                local_face_normal_batch.col(batch_index) = Eigen::Vector4f(normal.x, normal.y, normal.z, normal.w);
#else
                local_face_centers[index] = center;
                local_face_normals[index] = normal;
#endif
            }
        }
 
        void transform_and_project_vertices(const mxvk::Mat4D &rotation) {
#if defined(MXVK_USE_EIGEN_MATH)
            transform_eigen_batch(rotation, local_vertex_batch, camera_vertex_batch);
            camera_vertex_batch.row(2).array() += camera_distance;
 
            const float scale = static_cast<float>(std::min(frame_width, frame_height)) * 0.52f;
            const float center_x = static_cast<float>(frame_width) * 0.5f;
            const float center_y = static_cast<float>(frame_height) * 0.5f;
            inverse_vertex_depth.array() =
                camera_vertex_batch.row(2).array().max(0.001f).inverse();
            projected_vertex_batch.row(0).array() =
                center_x + camera_vertex_batch.row(0).array() * inverse_vertex_depth.array() * scale;
            projected_vertex_batch.row(1).array() =
                center_y - camera_vertex_batch.row(1).array() * inverse_vertex_depth.array() * scale;
            projected_vertex_batch.row(2) = camera_vertex_batch.row(2);
            projected_vertex_batch.row(3).setOnes();
#else
            rotation.MulVec(model.local, camera_vertices);
            for (std::size_t index = 0; index < model.local.size(); ++index) {
                camera_vertices[index].z += camera_distance;
                projected_vertices[index] = project_to_screen(camera_vertices[index], frame_width, frame_height);
            }
#endif
        }
 
        [[nodiscard]] mxvk::vec4D projected_vertex(std::size_t index) const {
#if defined(MXVK_USE_EIGEN_MATH)
            const Eigen::Index batch_index = static_cast<Eigen::Index>(index);
            return {
                projected_vertex_batch(0, batch_index),
                projected_vertex_batch(1, batch_index),
                projected_vertex_batch(2, batch_index),
                projected_vertex_batch(3, batch_index),
            };
#else
            return projected_vertices[index];
#endif
        }
 
        void append_visible_face(const mxvk::Triangle &triangle, float intensity) {
            const auto first = static_cast<std::size_t>(triangle.vert[0]);
            const auto second = static_cast<std::size_t>(triangle.vert[1]);
            const auto third = static_cast<std::size_t>(triangle.vert[2]);
            std::array<mxvk::vec2D, 3> texcoords = {
                model.texcoords[first],
                model.texcoords[second],
                model.texcoords[third],
            };
#if defined(MXVK_OBJ_LOADER)
            for (mxvk::vec2D &texcoord : texcoords) {
                texcoord.y = 1.0f - texcoord.y;
            }
#endif
            const bool repeat_horizontal =
                face_texture(triangle.material_index) != nullptr &&
                texture_repeat_enabled;
            if (repeat_horizontal) {
                texcoords = unwrap_horizontal_texcoords(texcoords);
            }
            visible_faces.push_back({
                {projected_vertex(first), projected_vertex(second), projected_vertex(third)},
                texcoords,
                triangle.color,
                triangle.material_index,
                repeat_horizontal,
                intensity,
            });
        }
 
        void build_visible_faces(const mxvk::Mat4D &rotation_matrix, const mxvk::vec4D &light_direction) {
#if defined(MXVK_USE_EIGEN_MATH)
#if !defined(MXVK_OBJ_LOADER)
            transform_eigen_batch(rotation_matrix, local_face_center_batch, camera_face_center_batch);
            camera_face_center_batch.row(2).array() += camera_distance;
#endif
            transform_eigen_batch(rotation_matrix, local_face_normal_batch, camera_face_normal_batch);
#if !defined(MXVK_OBJ_LOADER)
            triangle_visible =
                (-camera_face_normal_batch.row(0).array() * camera_face_center_batch.row(0).array() -
                 camera_face_normal_batch.row(1).array() * camera_face_center_batch.row(1).array() -
                 camera_face_normal_batch.row(2).array() * camera_face_center_batch.row(2).array()) >
                0.0f;
#endif
 
            const auto diffuse =
                (camera_face_normal_batch.row(0).array() * light_direction.x +
                 camera_face_normal_batch.row(1).array() * light_direction.y +
                 camera_face_normal_batch.row(2).array() * light_direction.z)
                    .max(0.0f);
            triangle_intensity.array() = (0.35f + diffuse * 0.65f).min(1.0f);
 
            for (std::size_t index = 0; index < model.vlist.size(); ++index) {
                const Eigen::Index batch_index = static_cast<Eigen::Index>(index);
#if !defined(MXVK_OBJ_LOADER)
                if (!triangle_visible(batch_index)) {
                    continue;
                }
#endif
                const mxvk::Triangle &triangle = model.vlist[index];
                append_visible_face(triangle, triangle_intensity(batch_index));
            }
#else
            rotation_matrix.MulVec(local_face_centers, camera_face_centers);
            rotation_matrix.MulVec(local_face_normals, camera_face_normals);
            for (std::size_t index = 0; index < model.vlist.size(); ++index) {
                const mxvk::Triangle &triangle = model.vlist[index];
                mxvk::vec4D &center = camera_face_centers[index];
                center.z += camera_distance;
                const mxvk::vec4D &normal = camera_face_normals[index];
                const mxvk::vec4D view_direction(-center.x, -center.y, -center.z, 0.0f);
#if !defined(MXVK_OBJ_LOADER)
                if (normal.DotProduct(view_direction) <= 0.0f) {
                    continue;
                }
#endif
 
                const float diffuse = std::max(0.0f, normal.DotProduct(light_direction));
                append_visible_face(triangle, std::clamp(0.35f + diffuse * 0.65f, 0.0f, 1.0f));
            }
#endif
        }
 
        void ensure_framebuffer() {
            if (frame_surface != nullptr) {
                return;
            }
 
            frame_surface = create_frame_surface(frame_width, frame_height);
            frame_format = SDL_GetPixelFormatDetails(frame_surface->format);
            if (frame_format == nullptr) {
                throw mxvk::Exception(std::format("{}: failed to query frame format: {}", APP_NAME, SDL_GetError()));
            }
 
            depth_buffer.resize(static_cast<std::size_t>(frame_width) * static_cast<std::size_t>(frame_height));
            clear_frame(BACKGROUND_COLOR);
            wireframe_pipeline.Begin(frame_width, frame_height, [this](int x, int y, mxvk::MXCOLOR color) {
                put_pixel(x, y, color);
            });
 
            frame_sprite = createSprite(frame_surface.get());
            frame_sprite->setTextureFilter(VK_FILTER_NEAREST);
        }
 
        [[nodiscard]] std::uint32_t map_color(mxvk::MXCOLOR color) const {
            return SDL_MapRGBA(frame_format, nullptr, mxvk::color_r(color), mxvk::color_g(color), mxvk::color_b(color), mxvk::color_a(color));
        }
 
        void clear_frame(mxvk::MXCOLOR color) {
            SDL_FillSurfaceRect(frame_surface.get(), nullptr, map_color(color));
        }
 
        void put_pixel(int x, int y, mxvk::MXCOLOR color) {
            if (x < 0 || y < 0 || x >= frame_width || y >= frame_height) {
                return;
            }
 
            auto *row = static_cast<std::uint8_t *>(frame_surface->pixels) + (static_cast<std::size_t>(y) * static_cast<std::size_t>(frame_surface->pitch));
            auto *pixel = reinterpret_cast<std::uint32_t *>(row) + x;
            *pixel = map_color(color);
        }
 
        [[nodiscard]] float texture_level_for_face(const FaceDraw &face, const Texture *texture, float area) const {
            if (texture == nullptr || !mipmapping_enabled) {
                return 0.0f;
            }
 
            const mxvk::vec4D &a = face.points[0];
            const mxvk::vec4D &b = face.points[1];
            const mxvk::vec4D &c = face.points[2];
            const float weight_a_dx = (c.y - b.y) / area;
            const float weight_a_dy = -(c.x - b.x) / area;
            const float weight_b_dx = (a.y - c.y) / area;
            const float weight_b_dy = -(a.x - c.x) / area;
            const float weight_c_dx = (b.y - a.y) / area;
            const float weight_c_dy = -(b.x - a.x) / area;
 
            float u_dx = 0.0f;
            float u_dy = 0.0f;
            float v_dx = 0.0f;
            float v_dy = 0.0f;
            if (warp_fix_enabled) {
                const float inverse_z_a = 1.0f / a.z;
                const float inverse_z_b = 1.0f / b.z;
                const float inverse_z_c = 1.0f / c.z;
                const float inverse_z = (inverse_z_a + inverse_z_b + inverse_z_c) / 3.0f;
                const float inverse_z_dx =
                    weight_a_dx * inverse_z_a +
                    weight_b_dx * inverse_z_b +
                    weight_c_dx * inverse_z_c;
                const float inverse_z_dy =
                    weight_a_dy * inverse_z_a +
                    weight_b_dy * inverse_z_b +
                    weight_c_dy * inverse_z_c;
                const auto corrected_derivatives = [&](float first, float second, float third) {
                    const float value_over_z =
                        (first * inverse_z_a + second * inverse_z_b + third * inverse_z_c) / 3.0f;
                    const float value_over_z_dx =
                        weight_a_dx * first * inverse_z_a +
                        weight_b_dx * second * inverse_z_b +
                        weight_c_dx * third * inverse_z_c;
                    const float value_over_z_dy =
                        weight_a_dy * first * inverse_z_a +
                        weight_b_dy * second * inverse_z_b +
                        weight_c_dy * third * inverse_z_c;
                    const float denominator = inverse_z * inverse_z;
                    return std::array<float, 2>{
                        (value_over_z_dx * inverse_z - value_over_z * inverse_z_dx) / denominator,
                        (value_over_z_dy * inverse_z - value_over_z * inverse_z_dy) / denominator,
                    };
                };
                const std::array<float, 2> u_derivatives = corrected_derivatives(
                    face.texcoords[0].x,
                    face.texcoords[1].x,
                    face.texcoords[2].x);
                const std::array<float, 2> v_derivatives = corrected_derivatives(
                    face.texcoords[0].y,
                    face.texcoords[1].y,
                    face.texcoords[2].y);
                u_dx = u_derivatives[0];
                u_dy = u_derivatives[1];
                v_dx = v_derivatives[0];
                v_dy = v_derivatives[1];
            } else {
                u_dx =
                    weight_a_dx * face.texcoords[0].x +
                    weight_b_dx * face.texcoords[1].x +
                    weight_c_dx * face.texcoords[2].x;
                u_dy =
                    weight_a_dy * face.texcoords[0].x +
                    weight_b_dy * face.texcoords[1].x +
                    weight_c_dy * face.texcoords[2].x;
                v_dx =
                    weight_a_dx * face.texcoords[0].y +
                    weight_b_dx * face.texcoords[1].y +
                    weight_c_dx * face.texcoords[2].y;
                v_dy =
                    weight_a_dy * face.texcoords[0].y +
                    weight_b_dy * face.texcoords[1].y +
                    weight_c_dy * face.texcoords[2].y;
            }
 
            const float horizontal_footprint = std::hypot(
                u_dx * static_cast<float>(texture->width()),
                v_dx * static_cast<float>(texture->height()));
            const float vertical_footprint = std::hypot(
                u_dy * static_cast<float>(texture->width()),
                v_dy * static_cast<float>(texture->height()));
            return std::log2(std::max({mxvk::EPSILON, horizontal_footprint, vertical_footprint})) + mip_level_bias;
        }
 
        void draw_gradient_triangle(const FaceDraw &face) {
            const mxvk::vec4D &a = face.points[0];
            const mxvk::vec4D &b = face.points[1];
            const mxvk::vec4D &c = face.points[2];
            const auto edge = [](const mxvk::vec4D &first, const mxvk::vec4D &second, float x, float y) {
                return (x - first.x) * (second.y - first.y) - (y - first.y) * (second.x - first.x);
            };
 
            const float area = edge(b, c, a.x, a.y);
            if (std::abs(area) <= mxvk::EPSILON) {
                return;
            }
 
            const int min_x = std::clamp(static_cast<int>(std::floor(std::min({a.x, b.x, c.x}))), 0, frame_width - 1);
            const int max_x = std::clamp(static_cast<int>(std::ceil(std::max({a.x, b.x, c.x}))), 0, frame_width - 1);
            const int min_y = std::clamp(static_cast<int>(std::floor(std::min({a.y, b.y, c.y}))), 0, frame_height - 1);
            const int max_y = std::clamp(static_cast<int>(std::ceil(std::max({a.y, b.y, c.y}))), 0, frame_height - 1);
            const Texture *texture = face_texture(face.material_index);
            const float texture_level = texture_level_for_face(face, texture, area);
 
            for (int y = min_y; y <= max_y; ++y) {
                for (int x = min_x; x <= max_x; ++x) {
                    const float sample_x = static_cast<float>(x) + 0.5f;
                    const float sample_y = static_cast<float>(y) + 0.5f;
                    const float weight_a = edge(b, c, sample_x, sample_y) / area;
                    const float weight_b = edge(c, a, sample_x, sample_y) / area;
                    const float weight_c = edge(a, b, sample_x, sample_y) / area;
                    if (weight_a < -mxvk::EPSILON || weight_b < -mxvk::EPSILON || weight_c < -mxvk::EPSILON) {
                        continue;
                    }
 
                    const float reciprocal_depth =
                        weight_a / a.z +
                        weight_b / b.z +
                        weight_c / c.z;
                    if (reciprocal_depth <= mxvk::EPSILON) {
                        continue;
                    }
 
                    const float depth = 1.0f / reciprocal_depth;
                    const std::size_t pixel_index =
                        static_cast<std::size_t>(y) * static_cast<std::size_t>(frame_width) +
                        static_cast<std::size_t>(x);
                    if (depth >= depth_buffer[pixel_index]) {
                        continue;
                    }
                    depth_buffer[pixel_index] = depth;
 
                    const float texture_weight_a = warp_fix_enabled ? (weight_a / a.z) * depth : weight_a;
                    const float texture_weight_b = warp_fix_enabled ? (weight_b / b.z) * depth : weight_b;
                    const float texture_weight_c = warp_fix_enabled ? (weight_c / c.z) * depth : weight_c;
                    const float u =
                        face.texcoords[0].x * texture_weight_a +
                        face.texcoords[1].x * texture_weight_b +
                        face.texcoords[2].x * texture_weight_c;
                    const float v =
                        face.texcoords[0].y * texture_weight_a +
                        face.texcoords[1].y * texture_weight_b +
                        face.texcoords[2].y * texture_weight_c;
                    mxvk::MXCOLOR color = face.material_color;
                    if (texture != nullptr) {
                        color = texture->sample(u, v, texture_level, face.repeat_horizontal);
                    }
#if !defined(MXVK_OBJ_LOADER)
                    else {
                        color = gradient_color(u, v);
                    }
#endif
                    put_pixel(x, y, mxvk::shade_color(color, face.intensity));
                }
            }
        }
 
        [[nodiscard]] static mxvk::MXCOLOR gradient_color(float u, float v) {
            u = std::clamp(u, 0.0f, 1.0f);
            v = std::clamp(v, 0.0f, 1.0f);
 
            constexpr mxvk::MXCOLOR BOTTOM_LEFT = mxvk::MXVK_RGB(68, 214, 255);
            constexpr mxvk::MXCOLOR BOTTOM_RIGHT = mxvk::MXVK_RGB(92, 255, 142);
            constexpr mxvk::MXCOLOR TOP_LEFT = mxvk::MXVK_RGB(155, 105, 255);
            constexpr mxvk::MXCOLOR TOP_RIGHT = mxvk::MXVK_RGB(255, 82, 197);
            const auto bilinear_channel = [&](auto component) {
                const float bottom =
                    static_cast<float>(component(BOTTOM_LEFT)) +
                    (static_cast<float>(component(BOTTOM_RIGHT)) - static_cast<float>(component(BOTTOM_LEFT))) * u;
                const float top =
                    static_cast<float>(component(TOP_LEFT)) +
                    (static_cast<float>(component(TOP_RIGHT)) - static_cast<float>(component(TOP_LEFT))) * u;
                return std::clamp(static_cast<int>(std::lround(bottom + (top - bottom) * v)), 0, 255);
            };
 
            return mxvk::MXVK_RGB(
                bilinear_channel(mxvk::color_r),
                bilinear_channel(mxvk::color_g),
                bilinear_channel(mxvk::color_b));
        }
 
        [[nodiscard]] static mxvk::vec4D project_to_screen(const mxvk::vec4D &point, int width, int height) {
            const float scale = static_cast<float>(std::min(width, height)) * 0.52f;
            const float center_x = static_cast<float>(width) * 0.5f;
            const float center_y = static_cast<float>(height) * 0.5f;
            const float z = std::max(point.z, 0.001f);
            return {center_x + (point.x / z) * scale, center_y - (point.y / z) * scale, point.z, 1.0f};
        }
    };
} // namespace example
 
int main(int argc, char **argv) {
    try {
        Arguments args = proc_args(argc, argv);
        FramebufferDimensions framebuffer = args.framebuffer;
        if (args.benchmark && !args.framebufferSpecified) {
            framebuffer = {320, 180};
            std::cout << APP_NAME << ": benchmark framebuffer defaults to 320x180; use --framebuffer to override\n";
        }
        example::Math3DModelLoaderWindow window(args.filename, args.texture, args.path, std::string(WINDOW_TITLE), args.width, args.height, args.fullscreen, args.enable_vsync, args.repeat, args.nowarpfix, args.disable_mipmap, args.mip_bias, framebuffer, args.benchmark, args.wireframe);
        window.loop();
    } catch (mxvk::Exception &e) {
        std::cerr << std::format("mxvk: Exception: {}\n", e.text());
        return EXIT_FAILURE;
    } catch (ArgException<std::string> &e) {
        std::cerr << std::format("mxvk: Argument Exception: {}\n", e.text());
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}