Merge pull request #6 from TolyaTalamanov/at/raytracer-tool

Raytracer tool initial version

Author: TolyaTalamanov

CMakeLists.txt

@@ -35,14 +35,21 @@ set(SRC_FILES
 
 set(Raytracer_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/include/")
 add_library(${PROJECT_NAME} SHARED ${SRC_FILES})
+
 # Set public API
 target_include_directories(${PROJECT_NAME}
                            PUBLIC ${Raytracer_INCLUDE_DIR}
                            PRIVATE "${PROJECT_SOURCE_DIR}/src")
 # Add dependencies
 find_package(PNG REQUIRED)
 find_package(JPEG REQUIRED)
-target_link_libraries(${PROJECT_NAME} ${PNG_LIBRARY} ${JPEG_LIBRARIES})
+target_link_libraries(${PROJECT_NAME} PRIVATE ${PNG_LIBRARY} ${JPEG_LIBRARIES})
+
+find_package(OpenMP)
+if(OpenMP_CXX_FOUND)
+    target_link_libraries(${PROJECT_NAME} PRIVATE OpenMP::OpenMP_CXX)
+endif()
+
 
 ########################################
 # Add thirdparty

include/raytracer/geometry.hpp

@@ -155,9 +155,20 @@ class Triangle : public Object {
     std::optional<ExplicitNormals> has_normals;
 };
 
-struct Scene {
-    Objects objects;
-    Lights  lights;
+class Scene {
+public:
+    Scene(Objects&&                     eobjects,
+          Lights&&                       lights,
+          std::vector<GeometricVertex>&& geom_vertices);
+
+    const Objects&                      GetObjects()           const;
+    const Lights&                       GetLights()            const;
+    const std::vector<GeometricVertex>& GetGeometricVertices() const;
+
+private:
+    Objects                      _objects;
+    Lights                       _lights;
+    std::vector<GeometricVertex> _geom_vertices;
 };
 
 Vec3f Refract(const Vec3f& I, const Vec3f& N, double ior);

include/raytracer/raytracer.hpp

@@ -1,3 +1,4 @@
 #include <raytracer/image.hpp>
 #include <raytracer/options.hpp>
 #include <raytracer/render.hpp>
+#include <raytracer/parser.hpp>

include/raytracer/render.hpp

@@ -3,5 +3,7 @@
 #include <raytracer/options.hpp>
 #include <raytracer/image.hpp>
 #include <raytracer/datatypes.hpp>
+#include <raytracer/geometry.hpp>
 
 Image Render(const std::string& filename, const CameraOptions& camera_options, const RenderOptions& render_options);
+Image Render(const Scene& scene, const CameraOptions& camera_options, const RenderOptions& render_options);

main.cpp

@@ -1,6 +1,39 @@
 #include <iostream>
+#include <chrono>
+
+#include <raytracer/raytracer.hpp>
+
+static Vec3f GetCenter(const Scene& scene) {
+    Vec3f c{0, 0, 0};
+    for (auto&& v : scene.GetGeometricVertices()) {
+        c = c + Vec3f{v.x, v.y, v.z};
+    }
+    return c / scene.GetGeometricVertices().size();
+}
+
+int main(int argc, const char** argv) {
+    CameraOptions camera_opts(500, 500);
+    RenderOptions render_opts{3};
+
+    const std::string obj_filename = argv[1];
+    const auto scene  = Parse(obj_filename);
+    const auto center = GetCenter(scene);
+
+    std::cout << "Object center is: " << center << std::endl;
+
+    camera_opts.look_from = std::array<double, 3>{std::stod(argv[2]),
+                                                  std::stod(argv[3]),
+                                                  std::stod(argv[4])};
+    camera_opts.look_to   = std::array<double, 3>{center.x, center.y, center.z};
+
+    using namespace std::chrono;
+    auto start   = high_resolution_clock::now();
+    auto image   = Render(obj_filename, camera_opts, render_opts);
+    auto end     = high_resolution_clock::now();
+    auto elapsed = duration_cast<milliseconds>(end-start).count();
+    image.Write("output.png");
+
+    std::cout << "Elapsed time: " << elapsed  << " ms" << std::endl;
 
-int main() {
-    std::cout << "Raytracing sample application" << std::endl;
     return 0;
 }

src/builder.cpp

@@ -38,16 +38,11 @@ SceneBuilder& SceneBuilder::Add(const SphereElement& s) {
 }
 
 SceneBuilder& SceneBuilder::Add(const FaceElement& f) {
-    if (f.vertices.size() != 3u && f.vertices.size() != 4u) {
-        throw std::logic_error("Only 3 or 4 vertex face elements are supported!");
-    }
-
     std::vector<int> indices;
     for (int i = 0; i < f.vertices.size(); ++i) {
         indices.push_back(GetNormalizedIndex(f.vertices[i].v, _state->geom_vertices.size()));
     }
 
-    // FIXME: 2 iteration maximum, reorganize this loop.
     for (int i = 0; i < f.vertices.size()-2; ++i) {
         std::array<GeometricVertex, 3> v = {_state->geom_vertices[indices[0  ]],
                                             _state->geom_vertices[indices[i+1]],
@@ -76,7 +71,9 @@ SceneBuilder& SceneBuilder::Add(const FaceElement& f) {
 }
 
 Scene SceneBuilder::Finalize() {
-    Scene scene{std::move(_state->objects), std::move(_state->lights)};
+    Scene scene{std::move(_state->objects),
+                std::move(_state->lights),
+                std::move(_state->geom_vertices)};
     _state.reset(new State{});
     return scene;
 }

src/geometry.cpp

@@ -1,5 +1,24 @@
 #include <raytracer/geometry.hpp>
-#include <iostream>
+
+Scene::Scene(Objects&&                      objects,
+             Lights&&                       lights,
+             std::vector<GeometricVertex>&& geom_vertices)
+    : _objects(std::move(objects)),
+      _lights(std::move(lights)),
+      _geom_vertices(std::move(geom_vertices)) {
+}
+
+const Objects& Scene::GetObjects() const {
+    return _objects;
+}
+
+const Lights& Scene::GetLights()  const {
+    return _lights;
+}
+
+const std::vector<GeometricVertex>& Scene::GetGeometricVertices() const {
+    return _geom_vertices;
+}
 
 Vec3f Ray::at(double t) const {
     return orig + dir * t;
@@ -127,7 +146,8 @@ std::optional<HitInfo> Triangle::intersect(const Ray& ray) {
     double t = v0v2.dot(qvec) * invDet;
     auto P = ray.at(t);
 
-    if (t < 0) {
+    // FIXME: From where this nan appears ???
+    if (t < 0 || std::isnan(t)) {
         return {};
     }
 
@@ -262,7 +282,7 @@ Vec3f Trace(const Ray&     ray,
     HitInfo info;
     double distance = std::numeric_limits<double>::max();
 
-    for (auto&& obj : scene.objects) {
+    for (auto&& obj : scene.GetObjects()) {
         auto has_hit = obj->intersect(ray);
         if (!has_hit) {
             continue;
@@ -329,12 +349,12 @@ Vec3f Trace(const Ray&     ray,
         Icomp += refrc * Tr;
     }
 
-    for (auto&& light : scene.lights) {
+    for (auto&& light : scene.GetLights()) {
         Vec3f new_p = info.position + ((ray.orig - info.position).normalize() * 0.00001);
         Vec3f newp2light = (light.position - new_p).normalize();
 
         bool no_intersect = false;
-        for (const auto& obj : scene.objects) {
+        for (const auto& obj : scene.GetObjects()) {
             auto has_hit = obj->intersect(Ray{new_p, newp2light});
             if (!has_hit) {
                 continue;

src/parser.cpp

@@ -1,5 +1,6 @@
 #include <unordered_set>
 #include <unordered_map>
+#include <iostream>
 
 #include <cassert>
 
@@ -186,6 +187,9 @@ static void ParseNewmtl(Tokenizer* tokenizer,
             mtl.map_Ka = std::make_optional(ParseImageFile(tokenizer, dir));
         } else if (param == "map_bump") {
             mtl.map_bump = std::make_optional(ParseImageFile(tokenizer, dir));
+        } else if (param == "bump") {
+            std::cout << "Ignore bump parameter in mtl file" << std::endl;
+            (void)ParseImageFile(tokenizer, dir);
         } else {
             throw std::logic_error("Unsupported newmtl parameter : " + param);
         }
@@ -312,9 +316,10 @@ Scene Parse(std::istream* stream, const std::string& mtldir) {
                 throw std::logic_error("Next token after usemtl should be Tokenizer::String");
             }
 
-            auto it = materials.find(std::get<Tokenizer::String>(tok).str);
+            const auto& mat_name = std::get<Tokenizer::String>(tok).str;
+            auto it = materials.find(mat_name);
             if (it == materials.end()) {
-                throw std::logic_error("Failed to find material with name: " + it->first);
+                throw std::logic_error("Failed to find material with name: " + mat_name);
             }
             builder.UseMaterial(it->second);
         } else if (keyword == "S") {

src/render.cpp

@@ -45,7 +45,8 @@ static void postprocessing(Matf& mat) {
     }
 }
 
-Image Render(const std::string& filename, const CameraOptions& camera_options,
+Image Render(const Scene& scene,
+             const CameraOptions& camera_options,
              const RenderOptions& render_options) {
     int width = camera_options.screen_width;
     int height = camera_options.screen_height;
@@ -64,15 +65,14 @@ Image Render(const std::string& filename, const CameraOptions& camera_options,
     Image img(width, height);
     Matf  mat(width, height);
 
-    const auto scene = Parse(filename);
-
     double scale = std::tan(fov * 0.5);
     double ratio = width / static_cast<double>(height);
 
     Vec3f forward = (from - to).normalize();
     Vec3f right = tmp.cross(forward).normalize();
     Vec3f up = forward.cross(right).normalize();
 
+#pragma omp parallel for
     for (int j = 0; j < height; ++j) {
         for (int i = 0; i < width; ++i) {
             // FIXME: Should it be without static_cast ???
@@ -112,3 +112,9 @@ Image Render(const std::string& filename, const CameraOptions& camera_options,
 
     return img;
 }
+
+Image Render(const std::string& filename, const CameraOptions& camera_options,
+             const RenderOptions& render_options) {
+    const auto scene = Parse(filename);
+    return Render(Parse(filename), camera_options, render_options);
+}

tests/test_tokenizer.cpp

@@ -121,3 +121,10 @@ TEST(TokenizerTests, NextLineBeforeEnd) {
 
     EXPECT_TRUE(t.IsEnd());
 }
+
+TEST(TokenizerTests, ParseStringStartsWithNumber) {
+    std::stringstream ss{"1212_foo"};
+    Tokenizer t(&ss);
+
+    EXPECT_EQ("1212_foo", std::get<Tokenizer::String>(t.GetToken()).str);
+}