rays are tracing but triangles aren't winding

libhart/scene/camera.hpp

@@ -15,7 +15,7 @@ typedef struct _CameraImpl {
 
 typedef struct Viewport {
     glm::ivec2 Raster = {1920, 1080};
-    glm::ivec2 Ray = {200, 200};
+    glm::ivec2 Ray = {50, 50};
 } Viewports;
 
 typedef struct Camera {

src/renderer/hit.hpp

@@ -9,6 +9,7 @@ class Ray;
 struct HitInfo
 {
     Ray* Caller;
+    bool Did;
     glm::vec2 UV;
     glm::vec3 SurfaceNormal;
     float Distance;

src/renderer/object_tracer.cpp

@@ -36,7 +36,9 @@ bool triangle_ray_collide(Ray* ray, float* t, glm::vec3 vertex0, glm::vec3 verte
 
 HitInfo* object_ray_collide(scene::SceneObject* object, Ray* ray)
 {
-    HitInfo* info = nullptr;
+    HitInfo* info = new HitInfo;
+    info->Distance = INFINITY;
+    info->Did = false;
     for (auto* mesh : scene::scene_object_get_meshs(object)) {
         // extract triangles and loop over them, if there is a hit - we return
         const uint32_t* ind;
@@ -46,11 +48,21 @@ HitInfo* object_ray_collide(scene::SceneObject* object, Ray* ray)
         mesh->getVerticies(&verts, &norms);
 
         float t = INFINITY;
-        for (int i = 0; i < mesh->getIndexCount(); i += 3) {
+        for (int i = 0; i < mesh->getIndexCount(); i++) {
             uint32_t index = ind[i];
-            glm::vec3 a = {  };
+            glm::vec3 a = { verts[3 * index + 0], verts[3 * index + 1], verts[3 * index + 2] };
-            glm::vec3 b = {  };
+            glm::vec3 b = { verts[3 * index + 3], verts[3 * index + 4], verts[3 * index + 5] };
-            glm::vec3 c = {  };
+            glm::vec3 c = { verts[3 * index + 6], verts[3 * index + 7], verts[3 * index + 8] };
+
+            float temp_t;
+            if (!triangle_ray_collide(ray, &temp_t, a, b, c))
+                continue;
+
+            info->Did = true;
+            if (temp_t < t) {
+                t = temp_t;
+                info->Distance = t;
+            }
         }
     }
     return info;

src/renderer/renderer.cpp

@@ -16,6 +16,7 @@
 #include <scene/camera.hpp>
 
 #include <iostream>
+#include <cstring>
 
 namespace inferno::graphics {
 
@@ -31,6 +32,7 @@ RayRenderer* rayr_create(scene::Scene* scene)
 
     yolo::debug("Raytracing Rendering {}x{} viewport", renderer->Viewport.x, renderer->Viewport.y);
     renderer->RenderData = new glm::fvec4[renderer->Viewport.x * renderer->Viewport.y];
+    memset(renderer->RenderData, 0, renderer->Viewport.x * renderer->Viewport.y * sizeof(glm::fvec4));
 
     glGenTextures(1, &renderer->RenderTargetTexture);
     glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
@@ -94,6 +96,9 @@ glm::fvec4* rayr_get_render_data(RayRenderer* renderer)
 
 void rayr_prepare(RayRenderer* renderer)
 {
+    // TODO: This is TEMP
+    memset(renderer->RenderData, 0, renderer->Viewport.x * renderer->Viewport.y * sizeof(glm::fvec4));
+
     assert(renderer->Scene != nullptr);
     if (scene::scene_did_update(renderer->Scene)) {
         yolo::debug("Scene updated, rebuilding acceleration structure");
@@ -113,11 +118,16 @@ void rayr_draw(RayRenderer* renderer)
     for (int x = 0; x < renderer->Viewport.x; x++) {
         for (int y = 0; y < renderer->Viewport.y; y++) {
             rays::Ray* ray = startRays.Field[x * renderer->Viewport.y + y];
-            renderer->RenderData[y * renderer->Viewport.x + x] = { ray->Direction.x + 0.5, ray->Direction.y + 0.5, ray->Direction.z + 0.5, 1.0f };
 
             // we want to iterate over every object in the scene and then ask that object for an intersection
             for (auto& obj : scene::scene_get_renderables(renderer->Scene)) {
-                rays::object_ray_collide(obj, ray);
+                rays::HitInfo* hit = rays::object_ray_collide(obj, ray);
+                if (hit->Did) {
+                    glm::vec3 hit_distance = glm::vec3{ hit->Distance };
+                    hit_distance /= 10;
+                    renderer->RenderData[y * renderer->Viewport.x + x] = { hit_distance, 1.0 };
+                }
+                delete hit;
             }
         }
     }

src/scene/mesh.cpp

@@ -84,7 +84,6 @@ int Mesh::getVerticies(const float** v, const float** n)
 int Mesh::getIndicies(const uint32_t** i)
 {
     *i = &mObjLoader->getFaces()[0];
-    yolo::debug("{}", &mObjLoader->getFaces()[0]);
     return mObjLoader->getIndexCount();
 }