Simple Normals Rendering

RayTracer/applications/Rayt.cpp

@@ -4,6 +4,7 @@
 #include "Buffer.hpp"
 #include "RayTracer.hpp"
 #include "Strings.hpp"
+#include "Timing.hpp"
 #include "Vec.hpp"
 
 #include "OBJ_Loader.h"
@@ -71,13 +72,24 @@ void renderCommand(const String& scenePath, RayTracer::RenderBuffer::Index2D siz
 
   loadScene(scene, scenePath);
 
+  scene.mCamera.lookAtPoint({0, 0, 0}, {-3, -3, 3}, {1, 1, 1});
+  scene.mCamera.setFOV(3.14 / 4);
+  scene.mCamera.setRatio((halnf) size.y / (halnf) size.x);
+  scene.mCamera.setFar(100);
+
   RayTracer::RenderBuffer output;
   output.reserve(size);
 
   RayTracer rayt;
 
+  auto start = get_time();
+
   rayt.render(scene, output);
 
+  auto end = get_time();
+
+  printf("\n Render finished with average render time per sample - %i (ms)\n", end - start);
+
   writeImage(output);
 }
 
@@ -86,7 +98,7 @@ int main() {
   tp::ModuleManifest module("Rayt", nullptr, nullptr, deps);
 
   if (module.initialize()) {
-    renderCommand("scene.obj", {1000, 1000});
+    renderCommand("scene.obj", {600, 600});
 
     module.deinitialize();
   }

RayTracer/applications/rsc/scene.mtl

@@ -1,12 +1,10 @@
 # Blender MTL File: 'None'
 # Material Count: 1
 
-newmtl Material
-Ns 323.999994
-Ka 1.000000 1.000000 1.000000
-Kd 0.800000 0.800000 0.800000
-Ks 0.500000 0.500000 0.500000
-Ke 0.000000 0.000000 0.000000
-Ni 1.450000
-d 1.000000
+newmtl None
+Ns 500
+Ka 0.8 0.8 0.8
+Kd 0.8 0.8 0.8
+Ks 0.8 0.8 0.8
+d 1
 illum 2

RayTracer/private/RayTracer.cpp

@@ -1,9 +1,14 @@
 
+#include "MathCommon.hpp"
 #include "NewPlacement.hpp"
 
 #include "CommandLine.hpp"
 #include "Module.hpp"
+#include "Ray.hpp"
 #include "RayTracer.hpp"
+#include "TypeInfo.hpp"
+
+#include <cstdio>
 
 using namespace tp;
 
@@ -11,10 +16,79 @@ ModuleManifest* sDependencies[] = {&gModuleMath, &gModuleCommandLine, &gModuleCo
 
 ModuleManifest tp::gModuleRayTracer = ModuleManifest("RayTracer", nullptr, nullptr, sDependencies);
 
-void RayTracer::render(const Scene& scene, RayTracer::RenderBuffer& buff) {
-  for (RayTracer::RenderBuffer::Index i = 0; i < buff.size().x; i++) {
-    for (RayTracer::RenderBuffer::Index j = 0; j < buff.size().y; j++) {
-      buff.set({i, j}, RGBA(1.f, 1.f, 1.f, 1.f));
+void RayTracer::castRay(const Ray& ray, RayCastData& out, alnf far) {
+  out.hit = false;
+
+  far *= far;
+
+  for (auto obj : mScene->mObjects) {
+    for (auto trig : obj->getTrigs()) {
+      if (trig->castRay(ray)) {
+        // printf("Hit\n");
+
+        auto dist = (trig->getHitPos() - ray.pos).length2();
+
+        if (far > dist) {
+          out.trig = &trig.data();
+          out.hitPos = trig->getHitPos();
+          out.obj = &obj.data();
+          out.hit = true;
+
+          far = dist;
+        }
+      }
+    }
+  }
+}
+
+void RayTracer::render(const Scene& scene, RayTracer::RenderBuffer& buff) {
+  mScene = &scene;
+  mBuff = &buff;
+
+  auto pos = mScene->mCamera.getPos();
+  auto fov = mScene->mCamera.getFOV();
+  auto height = sqrt(mScene->mCamera.getRatio());
+  auto width = 1.f / height;
+  auto forward = mScene->mCamera.getForward();
+  auto up = mScene->mCamera.getUp();
+  auto right = forward.cross(up);
+  auto planeCenter = pos + (forward * halnf(width / (2.f * tan(fov / 2.f))));
+  auto planeCenterOffset = (up * (halnf) height / 2.f) - (right * (halnf) width / 2.f);
+
+  auto planeLeftTop = planeCenter + planeCenterOffset;
+
+  RayCastData castData;
+
+  Ray ray = {
+      {0, 0, 0},
+      pos
+  };
+
+  Vec3F iterPoint = {0, 0, 0};
+  Vec3F deltaX = right * halnf(width / (alnf) buff.size().x);
+  Vec3F deltaY = up * halnf(-height / (alnf) buff.size().y);
+
+  for (RayTracer::RenderBuffer::Index i = 0; i < buff.size().x; i++) {
+    for (RayTracer::RenderBuffer::Index j = 0; j < buff.size().y; j++) {
+      iterPoint = planeLeftTop + ((deltaX * (halnf) i) + (deltaY * (halnf) j));
+
+      ray.dir = (iterPoint - pos).unitV();
+
+      castRay(ray, castData, mScene->mCamera.getFar());
+
+      if (castData.hit) {
+        auto normal = castData.trig->getNormal();
+        normal.normalize();
+
+        RGBA col = {normal.x * 0.5f + 0.5f, normal.y * 0.5f + 0.5f, normal.z * 0.5f + 0.5f, 1.f};
+        auto depth = 1 - clamp((halnf) (castData.hitPos - ray.pos).length(), 0.f, mScene->mCamera.getFar()) / mScene->mCamera.getFar();
+
+        // buff.set({i, j}, {depth, depth, depth, 1.f});
+        buff.set({i, j}, col);
+
+      } else {
+        buff.set({i, j}, RGBA(0.f, 0.f, 0.f, 0.f));
+      }
     }
   }
 }

RayTracer/public/RayTracer.hpp

@@ -6,17 +6,21 @@
 #include "Color.hpp"
 #include "Module.hpp"
 #include "Topology.hpp"
+#include "Vec.hpp"
 
 namespace tp {
 
   extern ModuleManifest gModuleRayTracer;
 
   class Scene {
+  public:
+    typedef Topology Object;
+
   public:
     Scene() = default;
 
   public:
-    Buffer<Topology> mObjects;
+    Buffer<Object> mObjects;
     Camera mCamera;
   };
 
@@ -24,8 +28,28 @@ namespace tp {
   public:
     typedef Buffer2D<RGBA> RenderBuffer;
 
+    struct RenderSettings {
+      alni samplesiPerPixel = 1;
+      alni rayBounces = 1;
+    };
+
   public:
     RayTracer() = default;
     void render(const Scene& scene, RenderBuffer& buff);
+
+  private:
+    struct RayCastData {
+      const Scene::Object* obj = nullptr;
+      TrigCache* trig = nullptr;
+      Vec3F hitPos = {0, 0, 0};
+      bool hit = false;
+    };
+
+    void castRay(const Ray& ray, RayCastData& out, alnf far);
+
+  private:
+    RenderSettings mSettings;
+    const Scene* mScene = nullptr;
+    RenderBuffer* mBuff = nullptr;
   };
 }