MathUtils.h

Go to the documentation of this file.

 
#pragma once
#include <glm/glm.hpp>
#include <vector>
#include <optional>
#include "graphics/core/IPickable.h"
 
struct ObjectSnapshot;
 
namespace Math {
    inline std::optional<float> intersectTriangle(
        const Ray& ray,
        const glm::vec3& v0,
        const glm::vec3& v1,
        const glm::vec3& v2
    ) {
        constexpr float EPSILON = std::numeric_limits<float>::epsilon();
 
        glm::vec3 edge1 = v1 - v0;
        glm::vec3 edge2 = v2 - v0;
 
        glm::vec3 pvec = glm::cross(ray.dir, edge2);
        float det = glm::dot(edge1, pvec);
 
        // If the determinant is near zero, ray lies in plane of triangle or is backfacing
        if (det > -EPSILON && det < EPSILON) return std::nullopt;
 
        float invDet = 1.0f / det;
 
        glm::vec3 tvec = ray.origin - v0;
        float u = glm::dot(tvec, pvec) * invDet;
        if (u < 0.0f || u > 1.0f) return std::nullopt;
 
        glm::vec3 qvec = glm::cross(tvec, edge1);
        float v = glm::dot(ray.dir, qvec) * invDet;
        if (v < 0.0f || u + v > 1.0f) return std::nullopt;
 
        // compute t to find out where the intersection point is on the line
        float t = glm::dot(edge2, qvec) * invDet;
        if (t < EPSILON) return std::nullopt;  // intersection is behind the ray origin
 
        return t;
    }
 
    inline glm::vec3 screenToWorldRayDirection(
        double mouseX,
        double mouseY,
        int fbWidth,
        int fbHeight,
        const glm::mat4 &view,
        const glm::mat4 &projection
    ) {
        float x = (2.0f * mouseX) / fbWidth - 1.0f;
        float y = 1.0f - (2.0f * mouseY) / fbHeight;
 
        glm::vec4 clip = glm::vec4(x, y, -1.0f, 1.0f);
        glm::mat4 invProj = glm::inverse(projection);
        glm::vec4 eye = invProj * clip;
        eye.z = -1.0f;
        eye.w = 0.0f;
 
        glm::mat4 invView = glm::inverse(view);
        glm::vec4 worldDir4 = invView * eye;
 
        return glm::normalize(glm::vec3(worldDir4));
    }
 
    struct HitResult {
        IPickable* object; 
        float distance; 
    };
 
    inline std::optional<HitResult> findFirstHit(
        const std::vector<IPickable*>& objects,
        const Ray& ray,
        IPickable* priority = nullptr
    ) {
        float distance = std::numeric_limits<float>::infinity();
        IPickable* best = nullptr;
 
        for (IPickable* obj : objects) {
            auto t = obj->intersectsRay(ray);
            if (!t)
                continue;
 
            // If this is the priority object, take it immediately
            if (obj == priority) {
                distance = *t;
                return HitResult{obj, distance};
            }
 
            if (*t < distance) {
                distance = *t;
                best = obj;
            }
        }
 
        return HitResult{best, distance};
    }
}