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);
-//    map_transform(affectedSphere, tg, 0, 0, 1.2f);
-//    calculate_normals(*affectedSphere.get());
+    shared_ptr<mesh> affectedSphere = mesh_generator::sphere(50, 50);
+    map_transform(affectedSphere, tg, 0, 0, 1.2f);
+    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");
-    black_plane->mesh_ = demo_data::meshes[2];
-    black_plane->material_ = demo_data::materials[1];
-    black_plane->position = glm::vec3(0, 5, -5);
-    black_plane->scale = glm::vec3(10);
-    black_plane->rotation = angleAxis(3.141529f, glm::vec3(1.0f, 0.0f, 0.0f));
+    auto back_plane = std::make_shared<mesh_node>("back plane");
+    back_plane->mesh_ = demo_data::meshes[2];
+    back_plane->material_ = demo_data::materials[1];
+    back_plane->position = glm::vec3(0, 5, -5);
+    back_plane->scale = glm::vec3(10);
+    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,148 +2,145 @@
 
 BEGIN_NAMESPACE
 
-constexpr char *BUFFER_OFFSET(int i) {
-    return (char *) NULL + i * sizeof(float);
-}
-
-constexpr int componentsInVertex() {
-    return 3 + 3 + 2; // position, normal, uv
-}
-
-constexpr int sizeOfVertexInBytes() {
-    return componentsInVertex() * sizeof(float);
-}
-
-mesh::mesh() {
-
-}
-
-mesh::~mesh() {
-    if (initialized) {
-        glDeleteVertexArrays(1, &vao_id);
-        glDeleteBuffers(1, &vbo_id);
-    }
-}
-
-void mesh::render(bool flat_shaded) {
-    if (!initialized) {
-        glGenVertexArrays(1, &vao_id);
-        glGenBuffers(1, &vbo_id);
-        initialized = true;
+    constexpr char *BUFFER_OFFSET(int i) {
+        return (char *) NULL + i * sizeof(float);
     }
 
-    // construct data
-    if ((facets.size() * 3) > vbo_size_in_elements) {
+    constexpr int componentsInVertex() {
+        return 3 + 3 + 2; // position, normal, uv
+    }
 
-        if (vbo_data != nullptr)
+    constexpr int sizeOfVertexInBytes() {
+        return componentsInVertex() * sizeof(float);
+    }
+
+    mesh::mesh() {
+
+    }
+
+    mesh::~mesh() {
+        if (initialized) {
+            glDeleteVertexArrays(1, &vao_id);
+            glDeleteBuffers(1, &vbo_id);
+        }
+    }
+
+    void mesh::render(bool flat_shaded) {
+        if (!initialized) {
+            glGenVertexArrays(1, &vao_id);
+            glGenBuffers(1, &vbo_id);
+            initialized = true;
+        }
+
+        // construct data
+        if ((facets.size() * 3) > vbo_size_in_elements) {
             delete[] vbo_data;
 
-        vbo_data = new float[componentsInVertex() * facets.size() * 3];
-        vbo_size_in_elements = facets.size() * 3;
-    }
+            vbo_data = new float[componentsInVertex() * facets.size() * 3];
+            vbo_size_in_elements = facets.size() * 3;
+        }
 
-    // fill in buffer
-    size_t i = 0;
-    for (size_t face_index = 0; i < facets.size(); i++) {
-        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;
-            vbo_data[i++] = vertices[f.vertices[j]].position.z;
-            if (flat_shaded) {
-                vbo_data[i++] = f.normal.x;
-                vbo_data[i++] = f.normal.y;
-                vbo_data[i++] = f.normal.z;
-            } else {
-                vbo_data[i++] = vertices[f.vertices[j]].normal.x;
-                vbo_data[i++] = vertices[f.vertices[j]].normal.y;
-                vbo_data[i++] = vertices[f.vertices[j]].normal.z;
+        // fill in buffer
+        size_t i = 0;
+        for (auto& f: facets) {
+            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;
+                vbo_data[i++] = vertices[f.vertices[j]].position.z;
+                if (flat_shaded) {
+                    vbo_data[i++] = f.normal.x;
+                    vbo_data[i++] = f.normal.y;
+                    vbo_data[i++] = f.normal.z;
+                } else {
+                    vbo_data[i++] = vertices[f.vertices[j]].normal.x;
+                    vbo_data[i++] = vertices[f.vertices[j]].normal.y;
+                    vbo_data[i++] = vertices[f.vertices[j]].normal.z;
+                }
+                vbo_data[i++] = f.text_coords[j].x;
+                vbo_data[i++] = f.text_coords[j].y;
             }
-            vbo_data[i++] = f.text_coords[j].x;
-            vbo_data[i++] = f.text_coords[j].y;
+        }
+
+        glBindVertexArray(vao_id);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo_id);
+        glBufferData(GL_ARRAY_BUFFER, sizeOfVertexInBytes() * facets.size() * 3, vbo_data, GL_DYNAMIC_DRAW);
+
+        glEnableVertexAttribArray(0); // vertices on stream 0
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeOfVertexInBytes(), BUFFER_OFFSET(0));
+
+        glEnableVertexAttribArray(1); // normals on stream 1
+        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeOfVertexInBytes(), BUFFER_OFFSET(3));
+
+        glEnableVertexAttribArray(2); // text coords on stream 2
+        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeOfVertexInBytes(), BUFFER_OFFSET(6));
+
+        glDrawArrays(GL_TRIANGLES, 0, facets.size() * 3);
+
+        glDisableVertexAttribArray(2);
+        glDisableVertexAttribArray(1);
+        glDisableVertexAttribArray(0);
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+        glBindVertexArray(0);
+    }
+
+    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) {
+            facet new_f = f;
+            new_f.a += original_facet_count;
+            new_f.b += original_facet_count;
+            new_f.c += original_facet_count;
+            facets.push_back(new_f);
+        }
+
+        size_t original_edge_count = edges.size();
+        edges.reserve(edges.size() + mesh.edges.size());
+        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);
         }
     }
 
-    glBindVertexArray(vao_id);
-    glBindBuffer(GL_ARRAY_BUFFER, vbo_id);
-    glBufferData(GL_ARRAY_BUFFER, sizeOfVertexInBytes() * facets.size() * 3, vbo_data, GL_DYNAMIC_DRAW);
-
-    glEnableVertexAttribArray(0); // vertices on stream 0
-    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeOfVertexInBytes(), BUFFER_OFFSET(0));
-
-    glEnableVertexAttribArray(1); // normals on stream 1
-    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeOfVertexInBytes(), BUFFER_OFFSET(3));
-
-    glEnableVertexAttribArray(2); // text coords on stream 2
-    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeOfVertexInBytes(), BUFFER_OFFSET(6));
-
-    glDrawArrays(GL_TRIANGLES, 0, facets.size() * 3);
-
-    glDisableVertexAttribArray(2);
-    glDisableVertexAttribArray(1);
-    glDisableVertexAttribArray(0);
-
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-    glBindVertexArray(0);
-}
-
-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) {
-        facet new_f = f;
-        new_f.a += original_facet_count;
-        new_f.b += original_facet_count;
-        new_f.c += original_facet_count;
-        facets.push_back(new_f);
+    void mesh::copy(mesh& mesh) {
+        vertices = mesh.vertices;
+        facets = mesh.facets;
+        edges = mesh.edges;
     }
 
-    size_t original_edge_count = edges.size();
-    edges.reserve(edges.size() + mesh.edges.size());
-    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 calculate_normals(mesh& mesh) {
+        for (auto& vertex: mesh.vertices)
+            vertex.normal = glm::vec3(0);
 
-void mesh::copy(mesh &mesh) {
-    vertices = mesh.vertices;
-    facets = mesh.facets;
-    edges = mesh.edges;
-}
+        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);
+            if (length(facet.normal) > 0.00001) {
+                facet.normal = normalize(facet.normal);
+            }
 
-void calculate_normals(mesh &mesh) {
-    for (auto &vertex: mesh.vertices)
-        vertex.normal = glm::vec3(0);
-
-    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);
-        if (length(facet.normal) > 0.00001) {
-            facet.normal = normalize(facet.normal);
+            mesh.vertices[facet.a].normal += facet.normal;
+            mesh.vertices[facet.b].normal += facet.normal;
+            mesh.vertices[facet.c].normal += facet.normal;
         }
 
-        mesh.vertices[facet.a].normal += facet.normal;
-        mesh.vertices[facet.b].normal += facet.normal;
-        mesh.vertices[facet.c].normal += facet.normal;
+        for (auto& vertex: mesh.vertices)
+            vertex.normal = normalize(vertex.normal);
     }
 
-    for (auto &vertex: mesh.vertices)
-        vertex.normal = normalize(vertex.normal);
-}
+    void flip_normals(mesh& mesh) {
+        for (auto& vertex: mesh.vertices)
+            vertex.normal = -vertex.normal;
 
-void flip_normals(mesh &mesh) {
-    for (auto &vertex: mesh.vertices)
-        vertex.normal = -vertex.normal;
-
-    for (auto &facet: mesh.facets)
-        facet.normal = -facet.normal;
-}
+        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);