WIP: bugfixing

main.cpp

@@ -25,9 +25,9 @@ int main() {
     acidrain::texture_generator tg(256, 256);
     tg.brick(0, 50, 20, 4, glm::vec4(1), glm::vec4(0));
 
-    shared_ptr<mesh> affectedSphere = mesh_generator::sphere(10, 10);
+    shared_ptr<mesh> affectedSphere = mesh_generator::sphere(50, 50);
-//    map_transform(affectedSphere, tg, 0, 0, 1.2f);
+    map_transform(affectedSphere, tg, 0, 0, 1.2f);
-//    calculate_normals(*affectedSphere.get());
+    calculate_normals(*affectedSphere.get());
 
 //    affectedSphere = mesh_generator::cog(0.2, 0.5, 50, 4, 0.1, 0.2, 0.2, 0.1);
 
@@ -125,12 +125,12 @@ int main() {
     ground_plane->scale = glm::vec3(10);
     ground_plane->rotation = glm::angleAxis(3.141529f / 2.0f, glm::vec3(1.0f, 0.0f, 0.0f));
 
-    auto black_plane = std::make_shared<mesh_node>("back plane");
+    auto back_plane = std::make_shared<mesh_node>("back plane");
-    black_plane->mesh_ = demo_data::meshes[2];
+    back_plane->mesh_ = demo_data::meshes[2];
-    black_plane->material_ = demo_data::materials[1];
+    back_plane->material_ = demo_data::materials[1];
-    black_plane->position = glm::vec3(0, 5, -5);
+    back_plane->position = glm::vec3(0, 5, -5);
-    black_plane->scale = glm::vec3(10);
+    back_plane->scale = glm::vec3(10);
-    black_plane->rotation = angleAxis(3.141529f, glm::vec3(1.0f, 0.0f, 0.0f));
+    back_plane->rotation = angleAxis(3.141529f, glm::vec3(1.0f, 0.0f, 0.0f));
 
     auto left_plane = std::make_shared<mesh_node>("left plane");
     left_plane->mesh_ = demo_data::meshes[2];
@@ -187,7 +187,7 @@ int main() {
     lightNode2->specular = glm::vec4(0.0, 0.8, 0.1, 1.0);
 
     scene1->tree->add(ground_plane);
-    scene1->tree->add(black_plane);
+    scene1->tree->add(back_plane);
     scene1->tree->add(left_plane);
     scene1->tree->add(right_plane);
 
@@ -210,7 +210,7 @@ int main() {
     timer timer1;
     while (!peripherals.should_close() && timer1.seconds_since_start() < DEMO_LENGTH_IN_SECONDS) {
         double elapsedSeconds = timer1.seconds_since_start();
-
+        LOG(INFO) << "frame start";
         bigSphere->mesh_ = mesh_generator::extrude(mesh_generator::sphere(50, 50), {200, 201, 100, 101, 400, 401}, 0.05,
                                                    (int) ((sin(elapsedSeconds) + 0.5) * 40));
 

src/mesh.cpp

@@ -2,30 +2,30 @@
 
 BEGIN_NAMESPACE
 
-constexpr char *BUFFER_OFFSET(int i) {
+    constexpr char *BUFFER_OFFSET(int i) {
         return (char *) NULL + i * sizeof(float);
-}
+    }
 
-constexpr int componentsInVertex() {
+    constexpr int componentsInVertex() {
         return 3 + 3 + 2; // position, normal, uv
-}
+    }
 
-constexpr int sizeOfVertexInBytes() {
+    constexpr int sizeOfVertexInBytes() {
         return componentsInVertex() * sizeof(float);
-}
+    }
 
-mesh::mesh() {
+    mesh::mesh() {
 
-}
+    }
 
-mesh::~mesh() {
+    mesh::~mesh() {
         if (initialized) {
             glDeleteVertexArrays(1, &vao_id);
             glDeleteBuffers(1, &vbo_id);
         }
-}
+    }
 
-void mesh::render(bool flat_shaded) {
+    void mesh::render(bool flat_shaded) {
         if (!initialized) {
             glGenVertexArrays(1, &vao_id);
             glGenBuffers(1, &vbo_id);
@@ -34,8 +34,6 @@ void mesh::render(bool flat_shaded) {
 
         // construct data
         if ((facets.size() * 3) > vbo_size_in_elements) {
-
-        if (vbo_data != nullptr)
             delete[] vbo_data;
 
             vbo_data = new float[componentsInVertex() * facets.size() * 3];
@@ -44,8 +42,7 @@ void mesh::render(bool flat_shaded) {
 
         // fill in buffer
         size_t i = 0;
-    for (size_t face_index = 0; i < facets.size(); i++) {
+        for (auto& f: facets) {
-        auto& f = facets[face_index];
             for (int j = 0; j < 3; j++) {
                 vbo_data[i++] = vertices[f.vertices[j]].position.x;
                 vbo_data[i++] = vertices[f.vertices[j]].position.y;
@@ -85,15 +82,15 @@ void mesh::render(bool flat_shaded) {
 
         glBindBuffer(GL_ARRAY_BUFFER, 0);
         glBindVertexArray(0);
-}
+    }
 
-void mesh::merge(mesh &mesh) {
+    void mesh::merge(mesh& mesh) {
         vertices.reserve(vertices.size() + mesh.vertices.size());
         vertices.insert(vertices.end(), mesh.vertices.begin(), mesh.vertices.end());
 
         auto original_facet_count = facets.size();
         facets.reserve(facets.size() + mesh.facets.size());
-    for (auto &f: mesh.facets) {
+        for (auto& f: mesh.facets) {
             facet new_f = f;
             new_f.a += original_facet_count;
             new_f.b += original_facet_count;
@@ -103,25 +100,25 @@ void mesh::merge(mesh &mesh) {
 
         size_t original_edge_count = edges.size();
         edges.reserve(edges.size() + mesh.edges.size());
-    for (auto &e: mesh.edges) {
+        for (auto& e: mesh.edges) {
             edge new_edge = e;
             new_edge.from += original_edge_count;
             new_edge.to += original_edge_count;
             edges.push_back(new_edge);
         }
-}
+    }
 
-void mesh::copy(mesh &mesh) {
+    void mesh::copy(mesh& mesh) {
         vertices = mesh.vertices;
         facets = mesh.facets;
         edges = mesh.edges;
-}
+    }
 
-void calculate_normals(mesh &mesh) {
+    void calculate_normals(mesh& mesh) {
-    for (auto &vertex: mesh.vertices)
+        for (auto& vertex: mesh.vertices)
             vertex.normal = glm::vec3(0);
 
-    for (auto &facet: mesh.facets) {
+        for (auto& facet: mesh.facets) {
             glm::vec3 a = mesh.vertices[facet.b].position - mesh.vertices[facet.a].position;
             glm::vec3 b = mesh.vertices[facet.c].position - mesh.vertices[facet.a].position;
             facet.normal = cross(a, b);
@@ -134,16 +131,16 @@ void calculate_normals(mesh &mesh) {
             mesh.vertices[facet.c].normal += facet.normal;
         }
 
-    for (auto &vertex: mesh.vertices)
+        for (auto& vertex: mesh.vertices)
             vertex.normal = normalize(vertex.normal);
-}
+    }
 
-void flip_normals(mesh &mesh) {
+    void flip_normals(mesh& mesh) {
-    for (auto &vertex: mesh.vertices)
+        for (auto& vertex: mesh.vertices)
             vertex.normal = -vertex.normal;
 
-    for (auto &facet: mesh.facets)
+        for (auto& facet: mesh.facets)
             facet.normal = -facet.normal;
-}
+    }
 
 END_NAMESPACE

src/mesh_node.cpp

@@ -7,6 +7,7 @@ mesh_node::mesh_node() {
 }
 
 mesh_node::mesh_node(std::string name_)  {
+    type = scene_node_type::mesh;
     name = name_;
 }
 

src/scene_renderer.cpp

@@ -305,26 +305,26 @@ void scene_renderer::attach_depth_texture(texture &text) const {
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
-void scene_renderer::render(const scene_tree &scene, const std::string &cameraName) {
+void scene_renderer::render(const scene_tree &tree, const std::string &cameraName) {
 //    for (auto &node: scene.lights) {
 //        light_node &light = node->as_light_node();
 //        glActiveTexture(GL_TEXTURE0);
 //        render_shadow_map(scene, light);
 //    }
 
-    std::shared_ptr<scene_node> camNode = scene.nodeByNameAndType(cameraName, scene_node_type::camera);
+std::shared_ptr<scene_node> camNode = tree.node_by_name_and_type(cameraName, scene_node_type::camera);
     camera_node &camera = camNode->as_camera_node();
 
     shader_consts.set(uniforms::ViewMatrix, camera.view_matrix);
     shader_consts.set(uniforms::ProjectionMatrix, camera.projection_matrix);
-    shader_consts.set(uniforms::NumberOfLights, (int) scene.lights.size());
+    shader_consts.set(uniforms::NumberOfLights, (int) tree.lights.size());
     // TODO: inject this from outside
     // shaderConstants.set(Uniforms::DemoPartNormalizedTime, normalizedTime);
 
     set_material(second_pass_shadow_material);
 
     int lightIndex = 0;
-    for (auto &node: scene.lights) {
+    for (auto &node: tree.lights) {
         light_node &light = node->as_light_node();
 
         shader_consts.set(uniforms::WorldToLightMatrix, light.world_to_light_matrix[0], lightIndex);
@@ -363,9 +363,10 @@ void scene_renderer::render(const scene_tree &scene, const std::string &cameraNa
     }
 
     // draw opaque nodes
-    for (auto &node: scene.nodes) {
+    for (auto &node: tree.nodes) {
         if (node->type == scene_node_type::mesh) {
             mesh_node &meshNode = node->as_mesh_node();
+            LOG(INFO) << "rendering mesh node " << meshNode.name;
 
             glm::mat3 normalMatrix = glm::inverseTranspose(
                     glm::mat3(camera.view_matrix * meshNode.model_to_world_space_matrix));

src/scene_renderer.h

@@ -17,7 +17,7 @@ public:
 
     scene_renderer();
 
-    void render(const scene_tree &scene, const std::string &cameraName);
+    void render(const scene_tree &tree, const std::string &cameraName);
 
 private:
     void attach_depth_texture(texture &text) const;

src/scene_tree.cpp

@@ -10,7 +10,7 @@ std::shared_ptr<scene_node> scene_tree::nodeById(int id) const {
     return std::shared_ptr<scene_node>(nullptr);
 }
 
-std::shared_ptr<scene_node> scene_tree::nodeByNameAndType(std::string name, scene_node_type type) const {
+std::shared_ptr<scene_node> scene_tree::node_by_name_and_type(std::string name, scene_node_type type) const {
     for (auto& node : nodes)
         if (node->name == name && node->type == type)
             return node;

src/scene_tree.h

@@ -9,7 +9,7 @@ class scene_tree {
 public:
 
     std::shared_ptr<scene_node> nodeById(int id) const;
-    std::shared_ptr<scene_node> nodeByNameAndType(std::string name, scene_node_type type) const;
+    std::shared_ptr<scene_node> node_by_name_and_type(std::string name, scene_node_type type) const;
 
     void add(std::shared_ptr<scene_node> node);
     void add(std::shared_ptr<scene_node> node, std::shared_ptr<scene_node> parent);