-Basic use of the density field to position vertices

-Space key to toggle updating -Unsuccessful attempts at solving manifold stitching problems

Author: Lin

BinaryMeshFitting/Chunk.hpp

@@ -38,7 +38,7 @@ class Chunk
 virtual ~Chunk() = 0;
 virtual void init(glm::vec3 pos, float size, int level, Sampler& sampler, bool produce_quads);
 virtual void generate_samples(ResourceAllocator<BinaryBlock>* binary_allocator, ResourceAllocator<FloatBlock>* float_allocator) = 0;
-virtual void generate_dual_vertices(ResourceAllocator<VerticesIndicesBlock>* vi_allocator, ResourceAllocator<CellsBlock>* cell_allocator, ResourceAllocator<IndexesBlock>* inds_allocator) = 0;
+virtual void generate_dual_vertices(ResourceAllocator<VerticesIndicesBlock>* vi_allocator, ResourceAllocator<CellsBlock>* cell_allocator, ResourceAllocator<IndexesBlock>* inds_allocator, ResourceAllocator<FloatBlock>* float_allocator) = 0;
 virtual bool calculate_dual_vertex(glm::uvec3 xyz, uint32_t next_index, DualVertex* result, bool force, uint8_t mask, glm::vec3 pos_override) = 0;
 
 virtual uint32_t encode_vertex(glm::uvec3 xyz);

BinaryMeshFitting/ChunkGenerator.cpp

@@ -132,7 +132,7 @@ void ChunkGenerator::extract_dual_vertices(SmartContainer<WorldOctreeNode*>& bat
 for (int i = 0; i < count; i++)
 {
 if (batch[i]->generation_stage == GENERATION_STAGES_GENERATING)
-batch[i]->chunk->generate_dual_vertices(&vi_allocator, &cell_allocator, &inds_allocator);
+batch[i]->chunk->generate_dual_vertices(&vi_allocator, &cell_allocator, &inds_allocator, &float_allocator);
 }
 }
 

BinaryMeshFitting/CubicChunk.cpp

@@ -9,6 +9,8 @@ using namespace glm;
 
 #define MORTON_CODING 0
 
+#define USE_DENSITIES true
+
 #define DC_LINE(ox,oy,oz,m) \
 s0 = encode_vertex(xyz.x + (ox), xyz.y + (oy), xyz.z + (oz), dimp1, z_per_y, y_per_x, s0_mask); \
 if (samples[s0] & s0_mask) \
@@ -29,12 +31,14 @@ else if (z_block > 0) \
 CubicChunk::CubicChunk() : Chunk()
 {
 cell_block = 0;
+float_block = 0;
 }
 
 CubicChunk::CubicChunk(glm::vec3 pos, float size, int level, Sampler& sampler,
 bool produce_quads) : Chunk(pos, size, level, sampler, produce_quads)
 {
 cell_block = 0;
+float_block = 0;
 }
 
 CubicChunk::~CubicChunk()
@@ -70,7 +74,7 @@ void CubicChunk::generate_samples(ResourceAllocator<BinaryBlock>* binary_allocat
 //memset(samples, 0, sizeof(uint32_t) * real_count);
 float delta = size / (float)dim;
 const float res = sampler.world_size;
-FloatBlock* float_block = float_allocator->new_element();
+float_block = float_allocator->new_element();
 float_block->init(dimp1 * 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);
@@ -131,10 +135,14 @@ void CubicChunk::generate_samples(ResourceAllocator<BinaryBlock>* binary_allocat
 else
 contains_mesh = mesh;
 
-float_allocator->free_element(float_block);
+if (!USE_DENSITIES || !contains_mesh)
+{
+float_allocator->free_element(float_block);
+float_block = 0;
+}
 }
 
-void CubicChunk::generate_dual_vertices(ResourceAllocator<VerticesIndicesBlock>* vi_allocator, ResourceAllocator<CellsBlock>* cell_allocator, ResourceAllocator<IndexesBlock>* inds_allocator)
+void CubicChunk::generate_dual_vertices(ResourceAllocator<VerticesIndicesBlock>* vi_allocator, ResourceAllocator<CellsBlock>* cell_allocator, ResourceAllocator<IndexesBlock>* inds_allocator, ResourceAllocator<FloatBlock>* float_allocator)
 {
 if (!vi)
 {
@@ -412,7 +420,7 @@ void CubicChunk::generate_dual_vertices(ResourceAllocator<VerticesIndicesBlock>*
 line_masks[0] |= local_masks[0];
 if (local_masks[1] != 0)
 line_masks[1] |= local_masks[1];
- if (local_masks[2] != 0)
+if (local_masks[2] != 0)
 line_masks[2] |= local_masks[2];
 if (local_masks[3] != 0)
 line_masks[3] |= local_masks[3];
@@ -474,6 +482,18 @@ void CubicChunk::generate_dual_vertices(ResourceAllocator<VerticesIndicesBlock>*
 //cells.shrink();
 
 free(masks);
+if (USE_DENSITIES)
+{
+float_allocator->free_element(float_block);
+float_block = 0;
+}
+}
+
+__forceinline void _get_intersection(vec3& v0, vec3& v1, float s0, float s1, float isolevel, vec3& out)
+{
+float mu = (isolevel - s0) / (s1 - s0);
+vec3 delta_v = (v1 - v0) * mu;
+out = delta_v + v0;
 }
 
 __forceinline void CubicChunk::calculate_cell(glm::uvec3 xyz, uint32_t next_index, Cell* result, bool force, uint8_t mask)
@@ -490,6 +510,19 @@ __forceinline void CubicChunk::calculate_cell(glm::uvec3 xyz, uint32_t next_inde
 result->v_map[3] = -1;
 
 uint16_t edge_mask = 0;
+glm::vec3 edge_crossings[12];
+float corners[8];
+float dv = size / (float)dim;
+
+if (USE_DENSITIES)
+{
+int dimp1 = dim + 1;
+for (int i = 0; i < 8; i++)
+{
+corners[i] = float_block->data[(xyz.x + Tables::TDX[i]) * dimp1 * dimp1 + (xyz.y + Tables::TDY[i]) * dimp1 + xyz.z + Tables::TDZ[i]];
+}
+}
+
 for (int i = 0; i < 12; i++)
 {
 int v0 = Tables::TEdgePairs[i][0];
@@ -501,40 +534,61 @@ __forceinline void CubicChunk::calculate_cell(glm::uvec3 xyz, uint32_t next_inde
 continue;
 
 edge_mask |= 1 << i;
+
+if (USE_DENSITIES)
+{
+vec3 e0(dv * (Tables::TDX[v0] + xyz.x), dv * (Tables::TDY[v0] + xyz.y), dv * (Tables::TDZ[v0] + xyz.z));
+vec3 e1(dv * (Tables::TDX[v1] + xyz.x), dv * (Tables::TDY[v1] + xyz.y), dv * (Tables::TDZ[v1] + xyz.z));
+_get_intersection(e0, e1, corners[v0], corners[v1], 0, edge_crossings[i]);
+}
 }
+
 result->edge_mask = edge_mask;
 
 int v_index = 0;
 uint32_t edge_map = 0;
 bool boundary = force || xyz.x <= 0 || xyz.y <= 0 || xyz.z <= 0 || xyz.x >= dim - 1 || xyz.y >= dim - 1 || xyz.z >= dim - 1;
-for (int i = 0; i < 22; i++)
+int v_count = 0;
+glm::vec3 v_pos[4] = { vec3(0,0,0), vec3(0,0,0), vec3(0,0,0), vec3(0,0,0) };
+
+for (int i = 0; i < 16; i++)
 {
 int e = Tables::EdgeTable[mask][i];
-if (e == -1)
+if (e == -1 || e == -2)
 {
+if (v_count > 0)
+{
+v_pos[v_index] /= (float)v_count;
+v_pos[v_index] += pos;
+v_count = 0;
+}
 v_index++;
-if (boundary)
+if (e == -2)
 break;
 continue;
 }
-if (e == -2)
-{
-v_index++;
-//assert(v_index == n_verts);
-break;
-}
 assert(((edge_map >> (e * 2)) & 3) == 0);
 if (((edge_map >> (e * 2)) & 3) != 0)
 printf("Hmm\n");
 edge_map |= (v_index) << (e * 2);
+assert((edge_mask & (1 << e)) != 0);
+if (USE_DENSITIES)
+{
+if (!v_count)
+v_pos[v_index] = edge_crossings[e];
+else
+v_pos[v_index] += edge_crossings[e];
+v_count++;
+
+}
 }
 
 //assert(v_index == n_verts);
 
 for (int i = 0; i < v_index; i++)
 {
 DualVertex v;
-calculate_dual_vertex(xyz, (uint32_t)vi->vertices.count, &v, false, mask, glm::vec3(0, 0, 0));
+calculate_dual_vertex(xyz, (uint32_t)vi->vertices.count, &v, USE_DENSITIES, mask, v_pos[i]);
 result->v_map[i] = (uint32_t)vi->vertices.count;
 vi->vertices.push_back(v);
 }

BinaryMeshFitting/CubicChunk.hpp

@@ -8,6 +8,7 @@
 class CubicChunk : public Chunk
 {
 public:
+FloatBlock* float_block;
 BinaryBlock* binary_block;
 CellsBlock* cell_block;
 DualNode octree;
@@ -18,7 +19,7 @@ class CubicChunk : public Chunk
 ~CubicChunk();
 void init(glm::vec3 pos, float size, int level, Sampler& sampler, bool produce_quads) override;
 void generate_samples(ResourceAllocator<BinaryBlock>* binary_allocator, ResourceAllocator<FloatBlock>* float_allocator) final override;
-void generate_dual_vertices(ResourceAllocator<VerticesIndicesBlock>* vi_allocator, ResourceAllocator<CellsBlock>* cell_allocator, ResourceAllocator<IndexesBlock>* inds_allocator) final override;
+void generate_dual_vertices(ResourceAllocator<VerticesIndicesBlock>* vi_allocator, ResourceAllocator<CellsBlock>* cell_allocator, ResourceAllocator<IndexesBlock>* inds_allocator, ResourceAllocator<FloatBlock>* float_allocator) final override;
 __forceinline void calculate_cell(glm::uvec3 xyz, uint32_t next_index, Cell* result, bool force, uint8_t mask);
 __forceinline bool calculate_dual_vertex(glm::uvec3 xyz, uint32_t next_index, DualVertex* result, bool force, uint8_t mask, glm::vec3 pos_override) final override;
 

BinaryMeshFitting/DebugScene.cpp

@@ -51,7 +51,7 @@ DebugScene::DebugScene(RenderInput* render_input)
 this->flat_quads = FLAT_QUADS;
 this->cull = true;
 this->gui_visible = true;
-this->update_focus = true;
+this->update_focus = false;
 this->line_width = 1.0f;
 this->specular_power = SPECULAR_POWER;
 
@@ -606,6 +606,10 @@ void DebugScene::key_callback(int key, int scancode, int action, int mods)
 {
 camera.v_position = world.focus_point;
 }
+if (key == GLFW_KEY_SPACE)
+{
+update_focus = !update_focus;
+}
 
 if (key == GLFW_KEY_PAGE_UP)
 {
@@ -742,7 +746,7 @@ void DebugScene::render_gui()
 
 ImGui::Text("Group mult.:");
 ImGui::NextColumn();
-ImGui::SliderFloat("##lbl_octree_group", &world.properties.group_multiplier, 1.0f, 4.0f, 0, 0.5f);
+ImGui::SliderFloat("##lbl_octree_group", &world.properties.group_multiplier, 1.0f, 4.0f);
 ImGui::NextColumn();
 
 ImGui::Text("Threads:");

BinaryMeshFitting/FPSCamera.cpp

@@ -18,7 +18,7 @@ void FPSCamera::init(uint32_t width, uint32_t height, RenderInput* render_input)
 this->speed = 0.1f;
 this->smoothness = DEFAULT_SMOOTHNESS;
 this->rot_sensitivity = DEFAULT_ROTATION_SENSITIVITY;
-this->v_position = vec3(0, 0, 0);
+this->v_position = vec3(-3.12f, 306.58f, -412.99f);
 this->v_rot = vec3(0, 0, 0);
 this->v_velocity = vec3(0, 0, 0);
 this->v_turn_velocity = vec3(0, 0, 0);

BinaryMeshFitting/ImplicitSampler.cpp

@@ -44,7 +44,7 @@ namespace ImplicitFunctions
 
 const float sphere(const float resolution, const glm::vec3& p)
 {
-const float r = resolution * 0.35f;
+const float r = resolution * 0.25f;
 return -(glm::length(p) - r);
 }
 
@@ -60,7 +60,7 @@ namespace ImplicitFunctions
 
 const float plane_y(const float resolution, const glm::vec3 & p)
 {
-return -p.y;
+return -p.y + p.x + p.z;
 }
 
 glm::vec3 get_intersection(glm::vec3 v0, glm::vec3 v1, float s0, float s1)

BinaryMeshFitting/NoiseSampler.cpp

@@ -140,13 +140,13 @@ const void NoiseSamplers::terrain2d_block(const Sampler & sampler, const float r
 const void NoiseSamplers::terrain2d_pert_block(const Sampler & sampler, const float resolution, const glm::vec3& p, const glm::ivec3& size, const float scale, float ** out, FastNoiseVectorSet * vectorset_out, float* dest_noise)
 {
 const float g_scale = 1.0f;
-const float ym = 0.5f;
+const float nm = 128.0f;
 NOISE_BLOCK(size.x, 1, size.z, p.x * g_scale, 0, p.z * g_scale, scale * g_scale, &dest_noise, vectorset_out);
 
-sampler.noise_sampler->SetNoiseType(FastNoiseSIMD::NoiseType::ValueFractal);
-sampler.noise_sampler->SetPerturbType(FastNoiseSIMD::PerturbType::GradientFractal);
-sampler.noise_sampler->SetPerturbFractalOctaves(20);
-sampler.noise_sampler->SetPerturbAmp(0.707f);
+sampler.noise_sampler->SetNoiseType(FastNoiseSIMD::NoiseType::PerlinFractal);
+sampler.noise_sampler->SetPerturbType(FastNoiseSIMD::PerturbType::None);
+sampler.noise_sampler->SetPerturbFractalOctaves(4);
+sampler.noise_sampler->SetPerturbAmp(1.0f);
 sampler.noise_sampler->SetPerturbFrequency(0.5f);
 sampler.noise_sampler->SetFractalType(FastNoiseSIMD::FractalType::RigidMulti);
 sampler.noise_sampler->FillNoiseSet(dest_noise, vectorset_out);
@@ -159,11 +159,11 @@ const void NoiseSamplers::terrain2d_pert_block(const Sampler & sampler, const fl
 {
 for (int iy = 0; iy < size.y; iy++)
 {
-dy = ((float)iy * scale + p.y) * g_scale * ym;
+dy = ((float)iy * scale + p.y) * g_scale;
 for (int iz = 0; iz < size.z; iz++)
 {
-float n = dest_noise[ix * size.z + iz] * resolution * 0.125f;
-(*out)[ix * size.y * size.z + iy * size.z + iz] = -dy - n;
+float n = dest_noise[ix * size.z + iz];
+(*out)[ix * size.y * size.z + iy * size.z + iz] = -dy - n * nm;
 }
 }
 }
@@ -210,10 +210,10 @@ const void NoiseSamplers::terrain3d_pert_block(const Sampler & sampler, const fl
 
 sampler.noise_sampler->SetNoiseType(FastNoiseSIMD::NoiseType::ValueFractal);
 sampler.noise_sampler->SetPerturbType(FastNoiseSIMD::PerturbType::GradientFractal);
-sampler.noise_sampler->SetFractalOctaves(8);
-sampler.noise_sampler->SetPerturbAmp(0.707f);
-sampler.noise_sampler->SetPerturbFrequency(0.25f);
-sampler.noise_sampler->SetFractalType(FastNoiseSIMD::FractalType::RigidMulti);
+sampler.noise_sampler->SetFractalOctaves(6);
+sampler.noise_sampler->SetPerturbAmp(1.0f);
+sampler.noise_sampler->SetPerturbFrequency(0.5f);
+sampler.noise_sampler->SetFractalType(FastNoiseSIMD::FractalType::FBM);
 sampler.noise_sampler->FillNoiseSet(dest_noise, vectorset_out);
 
 if (!(*out))

BinaryMeshFitting/WorldOctree.cpp

@@ -34,11 +34,11 @@ __declspec(noinline) WorldProperties::WorldProperties()
 WorldOctree::WorldOctree()
 {
 using namespace std;
-//sampler = ImplicitFunctions::create_sampler(ImplicitFunctions::cuboid);
+//sampler = ImplicitFunctions::create_sampler(ImplicitFunctions::sphere);
 //sampler.block = ImplicitFunctions::cuboid_block;
 NoiseSamplers::create_sampler_terrain_pert_3d(&sampler);
 sampler.world_size = 256;
-focus_point = glm::vec3(0, 0, 0);
+focus_point = glm::vec3(-5.88f, 357.70f, -465.41f);
 generator_shutdown = false;
 
 this->properties = WorldProperties();

BinaryMeshFitting/WorldStitcher.cpp

@@ -272,18 +272,28 @@ void WorldStitcher::stitch_indexes(OctreeNode* nodes[4], int direction, SmartCon
 int m1 = (n->cell.mask >> c1) & 1;
 int m2 = (n->cell.mask >> c2) & 1;
 
-if (d_nodes[i]->size < min_size)
+if (n->size < min_size)
 {
-min_size = d_nodes[i]->size;
+min_size = n->size;
 min_index = i;
 flip = m1 == 1;
 sign_changed = (n->cell.edge_mask >> edge) & 1; //((m1 == 0 && m2 != 0) || (m1 != 0 && m2 == 0));
 }
+else if (n->size == min_size && n != d_nodes[i-1])
+{
+/*assert(((n->cell.edge_mask >> edge) & 1) == sign_changed);
+if (((n->cell.edge_mask >> edge) & 1) != sign_changed)
+{
+return;
+}*/
+}
 }
 
 if (!sign_changed)
 return;
 
+int indx = 0;
+bool connected[4] = { false, false, false, false };
 
 for (int i = 0; i < 4; i++)
 {
@@ -305,9 +315,11 @@ void WorldStitcher::stitch_indexes(OctreeNode* nodes[4], int direction, SmartCon
 inds[i] = n->root->vi->vertices[ind + n->root->mesh_offset];
 else
 inds[i] = n->root->vi->vertices[ind & 0x3FFFFFFF];
+connected[i] = true;
 }
 else
 {
+connected[i] = false;
 int new_index = -1;
 for (int k = 0; k < 4; k++)
 {
@@ -337,6 +349,7 @@ void WorldStitcher::stitch_indexes(OctreeNode* nodes[4], int direction, SmartCon
 n->cell.edge_map |= new_index << (2 * edge);
 n->cell.edge_mask |= 1 << edge;
 }
+
 }
 
 if (QUADS)