put some raytracing stuff about

TODO

@@ -1,3 +1,3 @@
-[ ] The main thread is constantly polling for changes in the render texture, consider using a notification mechanism instead. For example, you could use a callback function that the renderer registers with the render texture, which is called whenever the texture is updated.
+[x] The main thread is constantly polling for changes in the render texture, consider using a notification mechanism instead. For example, you could use a callback function that the renderer registers with the render texture, which is called whenever the texture is updated.
 [ ] 
 

libhart/scene/camera.hpp

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

libhart/tracing/ray.hpp

@@ -1,14 +0,0 @@
-#pragma once
-
-#include <hart_graphics.hpp>
-
-namespace inferno {
-
-struct Ray
-{
-    glm::vec3 Origin;
-    glm::vec3 Direction;
-    uint32_t Reference;
-};
-
-}

src/graphics.hpp

@@ -21,6 +21,8 @@ extern "C"
 
 #include <vector>
 namespace inferno {
+namespace graphics::rays {
 class Ray;
-using RayField = std::vector<Ray*>;
+}
+using RayField = std::vector<graphics::rays::Ray*>;
 }

src/inferno.cpp

@@ -94,22 +94,28 @@ InfernoApp* inferno_create()
     graphics::shader_link(basicShader);
     basicMaterial->setGlShader(basicShader);
 
-    scene::Mesh* mesh = new scene::Mesh;
+    // scene::Mesh* mesh = new scene::Mesh;
-    mesh->loadOBJ("res/lucy.obj");
+    // mesh->loadOBJ("res/dragon-cornell-size.obj");
-    mesh->ready();
+    // mesh->ready();
-    mesh->setMaterial(basicMaterial);
+    // mesh->setMaterial(basicMaterial);
+    // scene::SceneObject* object = scene::scene_object_create();
+    // scene::scene_object_add_mesh(object, mesh);
+    // scene::scene_add_object(app->Scene, object);
 
-    scene::SceneObject* object = scene::scene_object_create();
+    scene::Mesh* box = new scene::Mesh;
-    scene::scene_object_add_mesh(object, mesh);
+    box->loadOBJ("res/cornell-box.obj");
+    box->ready();
+    box->setMaterial(basicMaterial);
+    scene::SceneObject* box_object = scene::scene_object_create();
+    scene::scene_object_add_mesh(box_object, box);
+    scene::scene_add_object(app->Scene, box_object);
 
-    scene::scene_add_object(app->Scene, object);
 
     app->PreviewRenderer = graphics::preview_create();
     graphics::preview_set_viewport(app->PreviewRenderer, app->Scene->Camera);
     app->RayRenderer = graphics::rayr_create(app->Scene);
     graphics::rayr_set_viewport(app->RayRenderer, app->Scene->Camera);
 
-
     return app;
 }
 

src/renderer/hit.hpp

@@ -2,15 +2,13 @@
 
 #include <hart_graphics.hpp>
 
-namespace inferno {
+namespace inferno::graphics::rays {
 
 class Ray;
 
 struct HitInfo
 {
     Ray* Caller;
-    // indicie of hit ^ mesh idx of hit
-    int Identifier;
     glm::vec2 UV;
     glm::vec3 SurfaceNormal;
     float Distance;

src/renderer/object_tracer.cpp

@@ -0,0 +1,18 @@
+#include "object_tracer.hpp"
+#include "scene/object.hpp"
+
+#include <yolo/yolo.hpp>
+
+namespace inferno::graphics::rays {
+
+HitInfo* object_ray_collide(scene::SceneObject* object, Ray* ray)
+{
+    HitInfo* info = nullptr;
+    for (auto* mesh : scene::scene_object_get_meshs(object)) {
+        // extract triangles and loop over them, if there is a hit - we return
+    }
+    return info;
+}
+
+}
+

src/renderer/object_tracer.hpp

@@ -0,0 +1,13 @@
+#pragma once 
+
+#include <scene/object.hpp>
+#include <scene/mesh.hpp>
+#include <renderer/hit.hpp>
+#include <renderer/ray.hpp>
+
+namespace inferno::graphics::rays {
+
+HitInfo*  object_ray_collide(scene::SceneObject* object, Ray* ray);
+
+}
+

src/renderer/ray.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <hart_graphics.hpp>
+
+namespace inferno::graphics::rays {
+
+struct Ray
+{
+    glm::vec3 Origin;
+    glm::vec3 Direction;
+    uint32_t Reference;
+};
+
+}

src/renderer/ray_source.cpp

@@ -1,70 +1,50 @@
-// #include "ray_source.hpp"
+#include "ray_source.hpp"
-//
+
-// #include <iostream>
+#include <iostream>
-//
+
-// #include <maths.hpp>
+#include <maths.hpp>
-//
+
-// #include <scene/camera.hpp>
+#include <scene/camera.hpp>
-//
+#include <renderer/ray.hpp>
-// #include <tracing/ray.hpp>
+
-//
+namespace inferno::graphics::rays {
-// using namespace inferno;
+
-//
+ReferencedRayField generate_initial_rays(graphics::Camera* camera, bool MSAA)
-// RaySource::RaySource(Camera* camera)
+{
-//     : mReferenceCamera(camera)
+    auto viewport = graphics::camera_ray_get_viewport(camera);
-// {
+
-//     this->generate();
+    RayField field;
-// }
+    field.reserve(viewport.x * viewport.y);
-//
+
-// RaySource::~RaySource()
+    const float aspect = static_cast<float>(viewport.x) / static_cast<float>(viewport.y);
-// {
+    float scale = tan(camera->FOV / 2.0f * helpers::PI / 180.0f);
-//
+
-// }
+    glm::mat4 cameraToWorld = graphics::camera_get_look(camera);
-//
+    glm::vec3 origin = camera->Position;
-// void RaySource::generate()
+
-// {
+    std::unordered_map<uint32_t, glm::ivec2> reference;
-//     // const float aspect =  mReferenceCamera->getRayViewport().x / mReferenceCamera->getRayViewport().y;
+
-//     // float scale = tan(mReferenceCamera->FOV / 2.0f * helpers::PI / 180.0f);
+    uint32_t i = 0;
-// }
+    for (int x = 0; x < viewport.x; x++)
-//
+        for (int y = 0; y < viewport.y; y++) {
-// ReferencedRayField RaySource::getInitialRays(bool MSAA)
+            float Px = (2.0f * ((x + 0.5f) / viewport.x) - 1.0f) * scale * aspect;
-// {
+            float Py = (2.0f * ((y + 0.5f) / viewport.y) - 1.0f) * scale;
-//     if (mReferenceCamera->didUpdate())
+
-//     {
+            Ray* ray = new Ray {};
-//         this->generate();
+
-//     }
+            glm::vec4 dir4 = glm::vec4(Px, Py, -1.0f, 1.0f) * cameraToWorld;
-//
+            glm::vec3 dir3 = glm::vec3(dir4) / dir4.w;
-//     RayField field;
+            ray->Direction = glm::normalize(dir3);
-//     field.reserve(mReferenceCamera->getRayViewport().x * mReferenceCamera->getRayViewport().y);
+
-//
+            ray->Origin = origin;
-//     const float aspect =  mReferenceCamera->getRayViewport().x / mReferenceCamera->getRayViewport().y;
+            ray->Reference = i;
-//     float scale = tan(mReferenceCamera->FOV / 2.0f * helpers::PI / 180.0f);
+            reference[i] = { x, y };
-//
+
-//     glm::mat4 cameraToWorld = mReferenceCamera->getCameraLook();
+            field.push_back(ray);
-//     glm::vec3 origin = mReferenceCamera->Position;
+            i++;
-//
+        }
-//     std::unordered_map<uint32_t, glm::ivec2> reference;
+
-//
+    return { field, reference };
-//     uint32_t i = 0;
+}
-//     for (int x = 0; x < mReferenceCamera->getRayViewport().x; x++)
+
-//     for (int y = 0; y < mReferenceCamera->getRayViewport().y; y++)
+} // namespace inferno::graphics::rays
-//     {
-//         float Px = (2.0f * ((x + 0.5f) / mReferenceCamera->getRayViewport().x) - 1.0f) * scale * aspect;
-//         float Py = (2.0f * ((y + 0.5f) / mReferenceCamera->getRayViewport().y) - 1.0f) * scale;
-//
-//         Ray* ray = new Ray{};
-//
-//         glm::vec4 dir4 = glm::vec4(Px, Py, -1.0f, 1.0f) * cameraToWorld;
-//         glm::vec3 dir3 = glm::vec3(dir4) / dir4.w;
-//         ray->Direction = glm::normalize(dir3);
-//
-//         ray->Origin = origin;
-//         ray->Reference = i;
-//         reference[i] = {x, y};
-//
-//         field.push_back(ray);
-//         i++;
-//     }
-//
-//     return { field, reference };
-// }

src/renderer/ray_source.hpp

@@ -1,33 +1,23 @@
-// #pragma once
+#pragma once
-//
+
-// #include <vector>
+#include <vector>
-// #include <unordered_map>
+#include <unordered_map>
-//
+
-// #include <graphics.hpp>
+#include <graphics.hpp>
-//
+
-// #include <tracing/ray.hpp>
+#include <renderer/ray.hpp>
-//
+
-// namespace inferno {
+namespace inferno::graphics {
-//
+    class Camera;
-// class Camera;
+}
-//
+
-// struct ReferencedRayField {
+namespace inferno::graphics::rays {
-//     RayField Field;
+
-//     std::unordered_map<uint32_t, glm::ivec2> Reference;
+struct ReferencedRayField {
-// };
+    RayField Field;
-//
+    std::unordered_map<uint32_t, glm::ivec2> Reference;
-//
+};
-// class RaySource
+
-// {
+ReferencedRayField generate_initial_rays(Camera* camera, bool MSAA);
-// public:
+
-//     RaySource(Camera* camera);
+}
-//     ~RaySource();
-//
-//     void generate();
-//     ReferencedRayField getInitialRays(bool MSAA);
-//
-// private:
-//     Camera* mReferenceCamera;
-// };
-//
-// }

src/renderer/renderer.cpp

@@ -2,11 +2,12 @@
 
 #include <graphics.hpp>
 
+#include <renderer/hit.hpp>
+#include <renderer/object_tracer.hpp>
+#include <renderer/ray.hpp>
 #include <scene/camera.hpp>
 #include <scene/mesh.hpp>
 #include <scene/scene.hpp>
-#include <tracing/hit.hpp>
-#include <tracing/ray.hpp>
 
 #include "ray_source.hpp"
 
@@ -102,14 +103,22 @@ void rayr_prepare(RayRenderer* renderer)
 
 void rayr_draw(RayRenderer* renderer)
 {
+    rayr_prepare(renderer);
+
     scene::scene_frame_tick(renderer->Scene);
     // TODO: Rays should definately be bump allocated if possible, this is KBs of
     // ray data and nothing else being reallocated every frame for no reason
-    // ReferencedRayField startRays = mRaySource->getInitialRays(true);
+    rays::ReferencedRayField startRays = rays::generate_initial_rays(scene::scene_get_camera(renderer->Scene), true);
 
     for (int x = 0; x < renderer->Viewport.x; x++) {
         for (int y = 0; y < renderer->Viewport.y; y++) {
-            renderer->RenderData[y * renderer->Viewport.x + x] = { 0.1f, 1.0f, 0.1f, 1.0f };
+            rays::Ray* ray = startRays.Field[x * renderer->Viewport.y + y];
+            renderer->RenderData[y * renderer->Viewport.x + x] = { ray->Direction.x, ray->Direction.y, ray->Direction.z, 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);
+            }
         }
     }
 }

src/renderer/triangle.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace inferno::graphics::rays {
+
+
+}
+
+