[CORE] added mvx_convert_voxels_to_mesh function

Author: nickscha

mvx.h

@@ -300,7 +300,7 @@ MVX_API MVX_INLINE int mvx_triangle_box_overlap(
         float pmax = mvx_maxf(mvx_maxf(p0, p1), p2);
         float pmin = mvx_minf(mvx_minf(p0, p1), p2);
         float rad = boxhalf.y * f.z + boxhalf.z * f.y + SLOP;
-        
+
         if (pmax < -rad || pmin > rad)
         {
           return 0;
@@ -575,6 +575,220 @@ MVX_API MVX_INLINE int mvx_voxelize_mesh(
   return 1;
 }
 
+/* Get voxel value with boundary checks. */
+#define MVX_GET_VOXEL(voxels, x, y, z, gx, gy, gz)      \
+  (((x) >= 0 && (x) < (gx) &&                           \
+    (y) >= 0 && (y) < (gy) &&                           \
+    (z) >= 0 && (z) < (gz))                             \
+       ? (voxels)[(x) + (y) * (gx) + (z) * (gx) * (gy)] \
+       : 0)
+
+MVX_API MVX_INLINE int mvx_convert_voxels_to_mesh(
+    unsigned char *voxels,
+    int grid_x,
+    int grid_y,
+    int grid_z,
+    float voxel_size,
+    float *out_vertices,
+    unsigned long out_vertices_cap,
+    unsigned long *out_vert_count,
+    int *out_indices,
+    unsigned long out_indices_cap,
+    unsigned long *out_index_count)
+{
+  long x, y, z;
+  unsigned long current_vert_idx = 0;
+  unsigned long current_index_idx = 0;
+  float half_voxel_size = voxel_size * 0.5f;
+
+  /* A set of 4 vertices for each of the 6 faces.
+   * The order of vertices is chosen to provide consistent winding. */
+  float mvx_face_vertices[6][4][3] = {
+      /* +Z face */
+      {{-1.0f, -1.0f, 1.0f}, {1.0f, -1.0f, 1.0f}, {1.0f, 1.0f, 1.0f}, {-1.0f, 1.0f, 1.0f}},
+      /* -Z face */
+      {{-1.0f, -1.0f, -1.0f}, {-1.0f, 1.0f, -1.0f}, {1.0f, 1.0f, -1.0f}, {1.0f, -1.0f, -1.0f}},
+      /* +Y face */
+      {{-1.0f, 1.0f, -1.0f}, {-1.0f, 1.0f, 1.0f}, {1.0f, 1.0f, 1.0f}, {1.0f, 1.0f, -1.0f}},
+      /* -Y face */
+      {{-1.0f, -1.0f, -1.0f}, {1.0f, -1.0f, -1.0f}, {1.0f, -1.0f, 1.0f}, {-1.0f, -1.0f, 1.0f}},
+      /* +X face */
+      {{1.0f, -1.0f, -1.0f}, {1.0f, 1.0f, -1.0f}, {1.0f, 1.0f, 1.0f}, {1.0f, -1.0f, 1.0f}},
+      /* -X face */
+      {{-1.0f, -1.0f, -1.0f}, {-1.0f, -1.0f, 1.0f}, {-1.0f, 1.0f, 1.0f}, {-1.0f, 1.0f, -1.0f}}};
+
+  /* Indices for a quad (two triangles) from 4 vertices. */
+  int mvx_face_indices[6] = {0, 1, 2, 0, 2, 3};
+
+  /* Check for invalid input pointers. */
+  if (!voxels || !out_vertices || !out_indices || !out_vert_count || !out_index_count)
+  {
+    return 0;
+  }
+
+  *out_vert_count = 0;
+  *out_index_count = 0;
+
+  for (z = 0; z < grid_z; ++z)
+  {
+    for (y = 0; y < grid_y; ++y)
+    {
+      for (x = 0; x < grid_x; ++x)
+      {
+        long id = x + y * grid_x + z * grid_x * grid_y;
+
+        if (voxels[id] == 1)
+        {
+          /* Check for an empty neighbor in each direction. */
+
+          /* +X neighbor */
+          if (MVX_GET_VOXEL(voxels, x + 1, y, z, grid_x, grid_y, grid_z) == 0)
+          {
+            int i;
+
+            if (current_vert_idx + 12 > out_vertices_cap || current_index_idx + 6 > out_indices_cap)
+            {
+              return 0;
+            }
+
+            for (i = 0; i < 4; ++i)
+            {
+              out_vertices[current_vert_idx++] = (float)x * voxel_size + half_voxel_size + mvx_face_vertices[4][i][0] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)y * voxel_size + half_voxel_size + mvx_face_vertices[4][i][1] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)z * voxel_size + half_voxel_size + mvx_face_vertices[4][i][2] * half_voxel_size;
+            }
+
+            for (i = 0; i < 6; ++i)
+            {
+              out_indices[current_index_idx++] = (int)((current_vert_idx / 3) - 4) + mvx_face_indices[i];
+            }
+          }
+
+          /* -X neighbor */
+          if (MVX_GET_VOXEL(voxels, x - 1, y, z, grid_x, grid_y, grid_z) == 0)
+          {
+            int i;
+
+            if (current_vert_idx + 12 > out_vertices_cap || current_index_idx + 6 > out_indices_cap)
+            {
+              return 0;
+            }
+
+            for (i = 0; i < 4; ++i)
+            {
+              out_vertices[current_vert_idx++] = (float)x * voxel_size + half_voxel_size + mvx_face_vertices[5][i][0] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)y * voxel_size + half_voxel_size + mvx_face_vertices[5][i][1] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)z * voxel_size + half_voxel_size + mvx_face_vertices[5][i][2] * half_voxel_size;
+            }
+
+            for (i = 0; i < 6; ++i)
+            {
+              out_indices[current_index_idx++] = (int)((current_vert_idx / 3) - 4) + mvx_face_indices[i];
+            }
+          }
+
+          /* +Y neighbor */
+          if (MVX_GET_VOXEL(voxels, x, y + 1, z, grid_x, grid_y, grid_z) == 0)
+          {
+            int i;
+
+            if (current_vert_idx + 12 > out_vertices_cap || current_index_idx + 6 > out_indices_cap)
+            {
+              return 0;
+            }
+
+            for (i = 0; i < 4; ++i)
+            {
+              out_vertices[current_vert_idx++] = (float)x * voxel_size + half_voxel_size + mvx_face_vertices[2][i][0] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)y * voxel_size + half_voxel_size + mvx_face_vertices[2][i][1] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)z * voxel_size + half_voxel_size + mvx_face_vertices[2][i][2] * half_voxel_size;
+            }
+
+            for (i = 0; i < 6; ++i)
+            {
+              out_indices[current_index_idx++] = (int)((current_vert_idx / 3) - 4) + mvx_face_indices[i];
+            }
+          }
+
+          /* -Y neighbor */
+          if (MVX_GET_VOXEL(voxels, x, y - 1, z, grid_x, grid_y, grid_z) == 0)
+          {
+            int i;
+
+            if (current_vert_idx + 12 > out_vertices_cap || current_index_idx + 6 > out_indices_cap)
+            {
+              return 0;
+            }
+
+            for (i = 0; i < 4; ++i)
+            {
+              out_vertices[current_vert_idx++] = (float)x * voxel_size + half_voxel_size + mvx_face_vertices[3][i][0] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)y * voxel_size + half_voxel_size + mvx_face_vertices[3][i][1] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)z * voxel_size + half_voxel_size + mvx_face_vertices[3][i][2] * half_voxel_size;
+            }
+
+            for (i = 0; i < 6; ++i)
+            {
+              out_indices[current_index_idx++] = (int)((current_vert_idx / 3) - 4) + mvx_face_indices[i];
+            }
+          }
+
+          /* +Z neighbor */
+          if (MVX_GET_VOXEL(voxels, x, y, z + 1, grid_x, grid_y, grid_z) == 0)
+          {
+            int i;
+
+            if (current_vert_idx + 12 > out_vertices_cap || current_index_idx + 6 > out_indices_cap)
+            {
+              return 0;
+            }
+
+            for (i = 0; i < 4; ++i)
+            {
+              out_vertices[current_vert_idx++] = (float)x * voxel_size + half_voxel_size + mvx_face_vertices[0][i][0] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)y * voxel_size + half_voxel_size + mvx_face_vertices[0][i][1] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)z * voxel_size + half_voxel_size + mvx_face_vertices[0][i][2] * half_voxel_size;
+            }
+
+            for (i = 0; i < 6; ++i)
+            {
+              out_indices[current_index_idx++] = (int)((current_vert_idx / 3) - 4) + mvx_face_indices[i];
+            }
+          }
+
+          /* -Z neighbor */
+          if (MVX_GET_VOXEL(voxels, x, y, z - 1, grid_x, grid_y, grid_z) == 0)
+          {
+            int i;
+
+            if (current_vert_idx + 12 > out_vertices_cap || current_index_idx + 6 > out_indices_cap)
+            {
+              return 0;
+            }
+
+            for (i = 0; i < 4; ++i)
+            {
+              out_vertices[current_vert_idx++] = (float)x * voxel_size + half_voxel_size + mvx_face_vertices[1][i][0] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)y * voxel_size + half_voxel_size + mvx_face_vertices[1][i][1] * half_voxel_size;
+              out_vertices[current_vert_idx++] = (float)z * voxel_size + half_voxel_size + mvx_face_vertices[1][i][2] * half_voxel_size;
+            }
+
+            for (i = 0; i < 6; ++i)
+            {
+              out_indices[current_index_idx++] = (int)((current_vert_idx / 3) - 4) + mvx_face_indices[i];
+            }
+          }
+        }
+      }
+    }
+  }
+
+  *out_vert_count = current_vert_idx;
+  *out_index_count = current_index_idx;
+
+  return 1;
+}
+
 #endif /* MVX_H */
 
 /*

tests/mvx_test.c

@@ -225,11 +225,74 @@ void mvx_test_voxelize_pyramid(void)
   mvx_test_print_voxels(voxels, py_grid_x, py_grid_y, py_grid_z);
 }
 
+void mvx_test_convert_voxels_to_mesh(void)
+{
+  /* Example: A unit cube mesh */
+  float vertices[] = {
+      0.0f, 0.0f, 0.0f,
+      1.0f, 0.0f, 0.0f,
+      1.0f, 1.0f, 0.0f,
+      0.0f, 1.0f, 0.0f,
+      0.0f, 0.0f, 1.0f,
+      1.0f, 0.0f, 1.0f,
+      1.0f, 1.0f, 1.0f,
+      0.0f, 1.0f, 1.0f};
+
+  unsigned long vertices_size = sizeof(vertices) / sizeof(vertices[0]);
+
+  /* Example: A unit cube mesh indices (two per face) */
+  int indices[] = {
+      0, 1, 2, 0, 2, 3, /* bottom */
+      4, 5, 6, 4, 6, 7, /* top */
+      0, 1, 5, 0, 5, 4, /* front */
+      1, 2, 6, 1, 6, 5, /* right */
+      2, 3, 7, 2, 7, 6, /* back */
+      3, 0, 4, 3, 4, 7  /* left */
+  };
+
+  unsigned long indices_size = sizeof(indices) / sizeof(indices[0]);
+
+/* Define a grid size where the voxelized mesh should fit into */
+#define grid_x 10
+#define grid_y 5
+#define grid_z 5
+  unsigned char voxels[grid_x * grid_y * grid_z];
+
+#define vertices_capacity 30000UL
+#define indices_capacity 30000UL
+  float vox_vertices[vertices_capacity];
+  int vox_indices[indices_capacity];
+  unsigned long vox_vertices_size = 0;
+  unsigned long vox_indices_size = 0;
+
+  /* Voxelize the mesh with 1 cell padding */
+  mvx_voxelize_mesh(
+      vertices, vertices_size, /* Mesh Vertices     */
+      indices, indices_size,   /* Mesh Indices      */
+      grid_x, grid_y, grid_z,  /* Grid Size         */
+      1, 1, 1,                 /* Grid Cell Padding */
+      voxels                   /* Output Voxels     */
+  );
+
+  mvx_convert_voxels_to_mesh(voxels, grid_x, grid_y, grid_z, 1.0f, vox_vertices, vertices_capacity, &vox_vertices_size, vox_indices, indices_capacity, &vox_indices_size);
+
+  printf("vertices: %10lu\n", vox_vertices_size);
+  printf(" indices: %10lu\n", vox_indices_size);
+
+  printf("vertex: %10.6f\n", (double)vox_vertices[0]);
+  printf("vertex: %10.6f\n", (double)vox_vertices[1]);
+  printf("vertex: %10.6f\n", (double)vox_vertices[2]);
+  printf("vertex: %10.6f\n", (double)vox_vertices[4]);
+  printf("vertex: %10.6f\n", (double)vox_vertices[5]);
+  printf("vertex: %10.6f\n", (double)vox_vertices[6]);
+}
+
 int main(void)
 {
   mvx_test_voxelize_cube();
   mvx_test_voxelize_icosphere();
   mvx_test_voxelize_pyramid();
+  mvx_test_convert_voxels_to_mesh();
 
   return 0;
 }