Naive stitching before redoing the watcher to be managed. Stitches currently flicker and in the rare case, the program crashes.

Author: Lin

BinaryMeshFitting.sln

@@ -73,4 +73,7 @@ Global
 GlobalSection(Performance) = preSolution
 HasPerformanceSessions = true
 EndGlobalSection
+GlobalSection(Performance) = preSolution
+HasPerformanceSessions = true
+EndGlobalSection
 EndGlobal

BinaryMeshFitting/BinaryMeshFitting.vcxproj

@@ -157,6 +157,7 @@
  <ClCompile Include="CubicChunk.cpp" />
  <ClCompile Include="DebugScene.cpp" />
  <ClCompile Include="DualChunk.cpp" />
+ <ClCompile Include="DynamicGLChunk.cpp" />
  <ClCompile Include="Entry.cpp" />
  <ClCompile Include="FPSCamera.cpp" />
  <ClCompile Include="GLChunk.cpp" />
@@ -185,6 +186,7 @@
  </ClCompile>
  <ClCompile Include="WorldOctree.cpp" />
  <ClCompile Include="WorldOctreeNode.cpp" />
+ <ClCompile Include="WorldStitcher.cpp" />
  <ClCompile Include="WorldWatcher.cpp" />
  <ClInclude Include="BinaryChunk.hpp" />
  <ClInclude Include="Chunk.hpp" />
@@ -195,6 +197,7 @@
  <ClInclude Include="Debug.h" />
  <ClInclude Include="DefaultOptions.h" />
  <ClInclude Include="DualChunk.hpp" />
+ <ClInclude Include="DynamicGLChunk.hpp" />
  <ClInclude Include="ResourceAllocator.hpp" />
  <ClInclude Include="GLChunk.hpp" />
  <ClInclude Include="GUI\imconfig.h" />
@@ -227,6 +230,7 @@
  </ClInclude>
  <ClInclude Include="WorldOctree.hpp" />
  <ClInclude Include="WorldOctreeNode.hpp" />
+ <ClInclude Include="WorldStitcher.hpp" />
  <ClInclude Include="WorldWatcher.hpp" />
  </ItemGroup>
  <ItemGroup>

BinaryMeshFitting/BinaryMeshFitting.vcxproj.filters

@@ -81,6 +81,12 @@
  <ClCompile Include="ChunkGenerator.cpp">
  <Filter>Source Files</Filter>
  </ClCompile>
+ <ClCompile Include="WorldStitcher.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="DynamicGLChunk.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
  </ItemGroup>
  <ItemGroup>
  <ClInclude Include="Core.hpp">
@@ -203,6 +209,12 @@
  <ClInclude Include="ChunkBlocks.hpp">
  <Filter>Header Files</Filter>
  </ClInclude>
+ <ClInclude Include="WorldStitcher.hpp">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="DynamicGLChunk.hpp">
+ <Filter>Header Files</Filter>
+ </ClInclude>
  </ItemGroup>
  <ItemGroup>
  <None Include="MemoryPool.tcc">

BinaryMeshFitting/ChunkGenerator.cpp

@@ -19,6 +19,8 @@ ChunkGenerator::~ChunkGenerator()
 void ChunkGenerator::init(WorldOctree* _world)
 {
 this->world = _world;
+this->stitcher.init();
+this->generating = false;
 _thread = std::thread(std::bind(&ChunkGenerator::update, this));
 }
 
@@ -35,7 +37,8 @@ void ChunkGenerator::update()
 {
 auto now = std::chrono::system_clock::now();
 
-process_queue();
+//if (!generating)
+process_queue();
 
 End:
 auto elapsed = std::chrono::system_clock::now() - now;
@@ -68,6 +71,10 @@ void ChunkGenerator::process_queue()
 local_queue = queue;
 queue.clear();
 }
+if (local_queue.size() == 0)
+{
+return;
+}
 
 // Trim the local queue
 int count = (int)local_queue.size();
@@ -118,12 +125,24 @@ void ChunkGenerator::process_queue()
 {
 local_queue[i]->generation_stage = GENERATION_STAGES_NEEDS_UPLOAD;
 }
+
+if (stitcher.stage == STITCHING_STAGES_READY)
+{
+std::unique_lock<std::mutex> stitcher_lock(stitcher._mutex);
+stitcher.stitch_all(&world->octree);
+stitcher.format();
+stitcher.stage = STITCHING_STAGES_NEEDS_UPLOAD;
+}
+
+//assert(stitcher.stage == STITCHING_STAGES_READY);
 }
 
 void ChunkGenerator::add_batch(SmartContainer<WorldOctreeNode*>& batch)
 {
 std::unique_lock<std::mutex> lock(_mutex);
 
+generating = true;
+
 int count = (int)batch.count;
 for (int i = 0; i < count; i++)
 {

BinaryMeshFitting/ChunkGenerator.hpp

@@ -10,6 +10,7 @@
 #include "SmartContainer.hpp"
 #include "ResourceAllocator.hpp"
 #include "ChunkBlocks.hpp"
+#include "WorldStitcher.hpp"
 
 class ChunkGenerator : public ThreadDebug
 {
@@ -32,6 +33,9 @@ class ChunkGenerator : public ThreadDebug
 ResourceAllocator<CellsBlock> cell_allocator;
 ResourceAllocator<IndexesBlock> inds_allocator;
 
+WorldStitcher stitcher;
+std::atomic<bool> generating;
+
 private:
 class WorldOctree* world;
 std::thread _thread;

BinaryMeshFitting/CubicChunk.cpp

@@ -71,7 +71,7 @@ void CubicChunk::generate_samples(ResourceAllocator<BinaryBlock>* binary_allocat
 float delta = size / (float)dim;
 const float res = sampler.world_size;
 FloatBlock* float_block = float_allocator->new_element();
-float_block->init(dimp1 * dimp1 * dimp1, dimp1 * dimp1 * dimp1);
+float_block->init(dimp1 * dimp1 * dimp1, dimp1 * dimp1);
 
 sampler.block(res, pos, ivec3(dimp1, dimp1, dimp1), delta * scale, &float_block->data, &float_block->vectorset, float_block->dest_noise);
 
@@ -151,6 +151,7 @@ void CubicChunk::generate_dual_vertices(ResourceAllocator<VerticesIndicesBlock>*
 }
 
 uint32_t dimp1 = dim + 1;
+
 uint32_t count = dim * dim * dim;
 uint32_t countp1 = dimp1 * dimp1 * dimp1;
 uint32_t z_per_y = ((dim + 32)) / 32;
@@ -755,7 +756,7 @@ void CubicChunk::generate_base_mesh(ResourceAllocator<VerticesIndicesBlock>* vi_
 Cell& c = cells[i];
 if (c.xyz.x == 27 && c.xyz.y == 5 && c.xyz.z == 0)
 {
-printf("F");
+//printf("F");
 }
 // TODO: Get xyz from cell vertices
 uvec3 xyz = c.xyz;

BinaryMeshFitting/CubicChunk.hpp

@@ -11,7 +11,7 @@ class CubicChunk : public Chunk
 BinaryBlock* binary_block;
 CellsBlock* cell_block;
 DualNode octree;
-MemoryPool<DualNode, 8192> node_pool;
+MemoryPool<DualNode> node_pool;
 
 CubicChunk();
 CubicChunk(glm::vec3 pos, float size, int level, Sampler& sampler, bool produce_quads);

BinaryMeshFitting/DebugScene.cpp

@@ -385,7 +385,7 @@ int DebugScene::update(RenderInput* input)
 if(update_focus)
 {
 std::unique_lock<std::mutex> l(world.watcher._mutex);
-world.watcher.focus_pos = camera.v_position;
+world.watcher.focus_pos = camera.v_position + camera.v_velocity * 0.0f;
 }
 
 return 0;
@@ -509,6 +509,12 @@ void DebugScene::render_world()
 n = n->renderable_next;
 }
 
+glBindVertexArray(world.watcher.generator.stitcher.gl_chunk.vao);
+if (!flat_quads || !QUADS)
+glDrawElements((QUADS ? GL_QUADS : GL_TRIANGLES), world.watcher.generator.stitcher.gl_chunk.p_count, GL_UNSIGNED_INT, 0);
+else
+glDrawArrays(GL_QUADS, 0, world.watcher.generator.stitcher.gl_chunk.p_count);
+
 //glDisable(GL_POLYGON_OFFSET_FILL);
 }
 if (fillmode == FILL_MODE_BOTH)
@@ -542,6 +548,12 @@ void DebugScene::render_world()
 }
 n = n->renderable_next;
 }
+
+glBindVertexArray(world.watcher.generator.stitcher.gl_chunk.vao);
+if (!flat_quads || !QUADS)
+glDrawElements((QUADS ? GL_QUADS : GL_TRIANGLES), world.watcher.generator.stitcher.gl_chunk.p_count, GL_UNSIGNED_INT, 0);
+else
+glDrawArrays(GL_QUADS, 0, world.watcher.generator.stitcher.gl_chunk.p_count);
 }
 
 glBindVertexArray(0);

BinaryMeshFitting/DynamicGLChunk.cpp

@@ -0,0 +1,58 @@
+#include "PCH.h"
+#include "DynamicGLChunk.hpp"
+
+#define DEFAULT_V_COUNT 524288
+
+DynamicGLChunk::DynamicGLChunk()
+{
+initialized = false;
+normals = true;
+
+vao = 0;
+v_vbo = 0;
+n_vbo = 0;
+ibo = 0;
+
+v_count = 0;
+p_count = 0;
+vbo_size = 0;
+ibo_size = 0;
+}
+
+DynamicGLChunk::~DynamicGLChunk()
+{
+destroy();
+}
+
+void DynamicGLChunk::init(bool _normals, bool _colors)
+{
+if (initialized)
+return;
+
+normals = _normals;
+colors = _colors;
+
+glGenBuffers(1, &v_vbo);
+if (normals)
+glGenBuffers(1, &n_vbo);
+if (colors)
+glGenBuffers(1, &c_vbo);
+
+glGenVertexArrays(1, &vao);
+glBindVertexArray(0);
+
+initialized = true;
+
+VertexRegion* base = region_pool.newElement(0, DEFAULT_V_COUNT);
+free_regions.push_back(base);
+}
+
+void DynamicGLChunk::destroy()
+{
+if (initialized)
+{
+glDeleteVertexArrays(1, &vao);
+glDeleteBuffers(4, &v_vbo);
+}
+initialized = 0;
+}

BinaryMeshFitting/DynamicGLChunk.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <gl/glew.h>
+#define GLFW_DLL
+#include <GLFW/glfw3.h>
+#include <glm/glm.hpp>
+#include "SmartContainer.hpp"
+#include "Vertices.hpp"
+#include "LinkedList.hpp"
+#include "MemoryPool.h"
+
+struct VertexRegion : public LinkedNode<VertexRegion>
+{
+uint32_t start;
+uint32_t count;
+
+inline VertexRegion()
+{
+start = 0;
+count = 0;
+}
+
+inline VertexRegion(uint32_t _start, uint32_t _count) : start(_start), count(_count)
+{
+}
+};
+
+class DynamicGLChunk
+{
+public:
+bool initialized;
+bool normals;
+bool colors;
+
+// Important -- Do not change structure!
+GLuint vao;
+GLuint v_vbo;
+GLuint n_vbo;
+GLuint c_vbo;
+GLuint ibo;
+
+uint32_t v_count;
+uint32_t p_count;
+uint32_t vbo_size;
+uint32_t ibo_size;
+
+SmartContainer<glm::vec3> p_data;
+SmartContainer<glm::vec3> n_data;
+SmartContainer<glm::vec3> c_data;
+
+DynamicGLChunk();
+~DynamicGLChunk();
+void init(bool _normals, bool _colors);
+void destroy();
+
+
+
+MemoryPool<VertexRegion> region_pool;
+LinkedList<VertexRegion> used_regions;
+LinkedList<VertexRegion> free_regions;
+};