Rendering models based on noise values.

The last step is to do so using marching cubes.

data/shaders/vertex.glsl

@@ -26,6 +26,7 @@ void main()
    data_out.texCoord = aTexCoord;
    data_out.camProj = MVP;
    data_out.modelProj = Model;
-   data_out.lightPos = vec3( (sin(tick / 1000.0)*2),  1 + sin(tick / 600.0)*2, 2.0);
+   //data_out.lightPos = vec3( (sin(tick / 1000.0)*2),  1 + sin(tick / 600.0)*2, 2.0);
+   data_out.lightPos = CameraPos;
    data_out.camPos = CameraPos;
 };

src/MarchingCubeChunkRenderer.cpp

@@ -1,13 +1,26 @@
 #include "MarchingCubeChunkRenderer.h"
 
 MarchingCubeChunkRenderer::MarchingCubeChunkRenderer(
-    std::vector<Chunk> &chunks, std::vector<Model> models) {
+    std::vector<Chunk> &chunks, std::vector<Model *> models) {
   this->chunks = &chunks;
   this->models = models;
 }
 
 void MarchingCubeChunkRenderer::draw(ShaderLoader &shader) {
   for (int i = 0; i < chunks->size(); i++) {
+    Chunk *chunk = &chunks->at(i);
+    TerrainInfo ti = chunk->getTerrainInfo();
+    // TerrainInfo ti = this->chunks[i].getTerrainInfo();
     // Render Chunk
+    for (int x = ti.xRange[0]; x < ti.xRange[1]; x++) {
+      for (int y = ti.yRange[0]; y < ti.yRange[1]; y++) {
+        for (int z = ti.zRange[0]; z < ti.zRange[1]; z++) {
+          if (chunk->getNoise(x, y, z) > 0) {
+            models.at(0)->setPosition(glm::vec3(x, y, z));
+            models.at(0)->draw(shader);
+          }
+        }
+      }
+    }
   }
 }

src/MarchingCubeChunkRenderer.h

@@ -2,6 +2,7 @@
 #include "Chunk.h"
 #include "Error.h"
 #include "Model.h"
+#include <glm/glm.hpp>
 #include <vector>
 
 class MarchingCubeChunkRenderer {
@@ -15,10 +16,10 @@ private:
   // Here we will store a model corresponding to ease polygon of the marching
   // cubes algorithm plus maybe more if models become orientation specific:
   // https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.545.613
-  std::vector<Model> models;
+  std::vector<Model *> models;
 
 public:
   MarchingCubeChunkRenderer(std::vector<Chunk> &chunks,
-                            std::vector<Model> models);
+                            std::vector<Model *> models);
   void draw(ShaderLoader &shader);
 };

src/Terrain.cpp

@@ -15,8 +15,8 @@ Terrain::Terrain() : renderer(nullptr) {
   chunks.push_back(Chunk(fnGenerator, ti));
 
   // Create chunks renderer.
-  std::vector<Model> models = {
+  models = {new Model(
-      Model(ROOT_DIR "data/models/wooden_boxbarrel/wooden_box_and_barrel.obj")};
+      ROOT_DIR "data/models/wooden_boxbarrel/wooden_box_and_barrel.obj")};
 
   renderer = new MarchingCubeChunkRenderer(this->chunks, models);
 }
@@ -26,6 +26,11 @@ Terrain::~Terrain() {
   // nullptr before being updated to the created object, which means it's
   // lifecycle needs to be managed by this class.
   delete renderer;
+  // Creating models here for OPENGL purposes means that we can't duplicate the
+  // data, so we need to delete them after creating them as pointers.
+  for (int i = 0; i < models.size(); i++) {
+    delete models.at(i);
+  }
 }
 
 void Terrain::draw(ShaderLoader &shader) {

src/Terrain.h

@@ -19,6 +19,8 @@ private:
   // Currently used chunks
   std::vector<Chunk> chunks;
 
+  std::vector<Model *> models;
+
   MarchingCubeChunkRenderer *renderer;
 
 public:

src/main.cpp

@@ -78,10 +78,10 @@ int main(int argc, char **argv) {
   //             std::string("data/models/backpack/backpack.obj"));
   // Model cube(ROOT_DIR "data/models/cube/cube.obj");
   // Model gun(ROOT_DIR "data/models/gun/Cerberus_LP.FBX");
-  Model boxbarrel(ROOT_DIR
+  // Model boxbarrel(ROOT_DIR
-                  "data/models/wooden_boxbarrel/wooden_box_and_barrel.obj");
+  //               "data/models/wooden_boxbarrel/wooden_box_and_barrel.obj");
   // boxbarrel.translate(glm::vec3(0.0f, -1.0f, 0.0f));
-  boxbarrel.setPosition(glm::vec3(0.0f, -1.0f, 0.0f));
+  // boxbarrel.setPosition(glm::vec3(0.0f, -1.0f, 0.0f));
   // cube.translate(glm::vec3(3.0f, 0.0f, -1.0f));
   // backpack.translate(glm::vec3(-3.0f, 0.0f, 0.0f));
   // gun.translate(glm::vec3(0.0f, 1.0f, 0.0f));
@@ -131,14 +131,16 @@ int main(int argc, char **argv) {
     shader.setMat4("MVP", camera.getMVP());
 
     shader.setVec3("CameraPos", camera.getCameraPosition());
-    shader.setInt("tick", SDL_GetTicks());
+    // shader.setInt("tick", SDL_GetTicks());
     // boxbarrel.rotate(0.001, glm::vec3(0, 1, 0));
 
+    terrain.draw(shader);
+
     // Draw Meshes
     // cube.draw(shader);
     // backpack.draw(shader);
     // gun.draw(shader);
-    boxbarrel.draw(shader);
+    // boxbarrel.draw(shader);
     // Finally render everything
     shader.use();