Can now generate and render meshes of sch_hull's!

src/sconvcol.h

@@ -166,9 +166,9 @@ bool sch_hull_sat(const sch_hull* hull_A, const sch_hull* hull_B, sch_manifold*
 
 int sch_hull_is_vertex_concave(const sch_hull* hull, const simd4f p);
 
-int sch_hull_is_closed (const sch_hull* hull);
+SchHullResult sch_hull_is_closed (const sch_hull* hull);
 
-int sch_hull_connect_face_edges(const sch_hull* hull, int face_index);
+SchHullResult sch_hull_connect_face_edges(const sch_hull* hull, int face_index);
 
 void sch_create_face(int num_vert, simd4f* vertices, sch_face* out_face);
 
@@ -232,8 +232,8 @@ void sch_create_face(int num_vert, simd4f* vertices, sch_face* out_face) {
   assert(out_face->edge == NULL);
 
   int i = 0;
-  sch_edge* f_edges = malloc(sizeof(sch_edge) * num_vert);
-  sch_vert* f_verts = malloc(sizeof(sch_vert) * num_vert);
+  sch_edge* f_edges = (sch_edge*) malloc(sizeof(sch_edge) * num_vert);
+  sch_vert* f_verts = (sch_vert*) malloc(sizeof(sch_vert) * num_vert);
 
   while (i < num_vert) {
     sch_vert* vert = &f_verts[i];
@@ -384,7 +384,7 @@ SchHullResult sch_builder_create_hull(sch_hull_builder* builder, sch_hull* out_h
       prev_edge = edge;
     }
 
-    int edge_add_result = sch_hull_connect_face_edges (out_hull, face_index);
+    SchHullResult edge_add_result = sch_hull_connect_face_edges (out_hull, face_index);
     if (edge_add_result != SchHullResultOK) {
       sch_hull_free_memory(out_hull);
       return edge_add_result;
@@ -555,7 +555,7 @@ float sch_query_edge_directions (const sch_hull* hull_A, const sch_hull* hull_B,
 }
 
 void sch_clip_faces (const sch_face* ref_face, const sch_face* inc_face, sch_manifold* manifold) {
-  simd4f* input_vertices = malloc(sizeof(simd4f) * manifold->num_vertices);
+  simd4f* input_vertices = (simd4f*) malloc(sizeof(simd4f) * manifold->num_vertices);
   assert (input_vertices != NULL);
 
   sch_edge* inc_start_edge = inc_face->edge;
@@ -722,7 +722,7 @@ int sch_hull_is_vertex_concave(const sch_hull* hull, const simd4f v) {
   return 0;
 }
 
-int sch_hull_connect_face_edges(const sch_hull* hull, int new_face_index) {
+SchHullResult sch_hull_connect_face_edges(const sch_hull* hull, int new_face_index) {
   sch_face* new_face = &hull->faces[new_face_index];
 
   sch_edge* new_face_edge0 = new_face->edge;
@@ -771,7 +771,7 @@ int sch_hull_connect_face_edges(const sch_hull* hull, int new_face_index) {
   return SchHullResultOK;
 }
 
-int sch_hull_is_closed (const sch_hull* hull) {
+SchHullResult sch_hull_is_closed (const sch_hull* hull) {
   for (int ei = 0; ei < hull->num_edges; ei++) {
     if (hull->edges[ei].twin == NULL) {
       return SchHullResultOpenHull;

src/srender.h

@@ -6,25 +6,45 @@ extern "C" {
 #endif
 
 #include <stdbool.h>
+#include <stdio.h>
 
 #include "vectorial/simd4x4f.h"
 
 typedef struct srndr srndr;
 typedef struct srview srview;
 typedef struct srcmdbuf srcmdbuf;
+typedef union srvrtxdata srvrtxdata;
+typedef struct srmeshdata srmeshdata;
+extern GLuint* srDefaultVAId;
 
 typedef enum {
   SRndrCmdTypeFrame = 0,
   SRndrCmdTypeGrid,
   SRndrCmdTypeCube,
   SRndrCmdTypeSphere,
-  SrndrCmdTypePoint,
+  SrndrCmdTypeMesh,
 } SRndrCmdType;
 
+//
+// Simple Mesh Data
+//
+typedef struct srmeshdata {
+  int nvertices;
+  int nindices;
+
+  GLuint vao_id;
+  GLuint vb_id;
+  GLuint idb_id;
+
+  GLuint count;
+  GLenum mode;
+} srmeshdata;
+
 typedef struct srcmd {
   simd4x4f mat;
   simd4f color;
   SRndrCmdType type;
+  srmeshdata* meshdata;
 } srcmd;
 
 //
@@ -56,6 +76,112 @@ srcmd* srcmd_create(srcmdbuf* cmdbuf);
 
 void srndr_render(srndr* srndr, srview* sview, srcmdbuf* scmdbuf);
 
+//
+// Vertex Data
+//
+typedef union srvrtxdata {
+  struct {
+    float x, y, z, w;
+    float nx, ny, nz;
+    float s, t;
+    GLubyte r, g, b, a;
+  };
+  struct {
+    float pos[4];
+    float n[3];
+    float uv[2];
+    GLubyte color[4];
+  };
+} srvrtxdata;
+
+inline srmeshdata* srmesh_create(
+    srvrtxdata* vrtxdata,
+    int nvertices,
+    GLuint* idxdata,
+    int nindices,
+    GLenum prim_mode,
+    GLuint count) {
+  srmeshdata* result = (srmeshdata*)calloc(sizeof(srmeshdata), 1);
+
+  result->nvertices = nvertices;
+  result->nindices = nindices;
+  result->mode = prim_mode;
+  result->count = count;
+
+  glGenVertexArrays(1, &result->vao_id);
+  glBindVertexArray(result->vao_id);
+
+  glGenBuffers(1, &result->vb_id);
+  glBindBuffer(GL_ARRAY_BUFFER, result->vb_id);
+
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(
+      0,
+      4,
+      GL_FLOAT,
+      GL_FALSE,
+      (sizeof(srvrtxdata)),
+      (void*)0);
+
+  glEnableVertexAttribArray(1);
+  glVertexAttribPointer(
+      1,
+      3,
+      GL_FLOAT,
+      GL_FALSE,
+      (sizeof(srvrtxdata)),
+      (void*)(sizeof(float) * 4));
+
+  // Attribute 2: texture coordinates
+  glEnableVertexAttribArray(2);
+  glVertexAttribPointer(
+      2,
+      2,
+      GL_FLOAT,
+      GL_FALSE,
+      (sizeof(srvrtxdata)),
+      (void*)(sizeof(float) * 7));
+
+  // Attribute 3: color
+  glEnableVertexAttribArray(3);
+  glVertexAttribPointer(
+      3,
+      4,
+      GL_UNSIGNED_BYTE,
+      GL_TRUE,
+      (sizeof(srvrtxdata)),
+      (void*)(sizeof(float) * 9));
+
+  glBufferData(
+      GL_ARRAY_BUFFER,
+      sizeof(srvrtxdata) * nvertices,
+      vrtxdata,
+      GL_DYNAMIC_DRAW);
+
+  glGenBuffers(1, &result->idb_id);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, result->idb_id);
+  for (int i = 0; i < nindices; i++) {
+    printf ("idx %2d: %d\n", i, idxdata[i]);
+  }
+  glBufferData(
+      GL_ELEMENT_ARRAY_BUFFER,
+      sizeof(GLuint) * nindices,
+      idxdata,
+      GL_STATIC_DRAW);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+  glBindVertexArray(0);
+
+  return result;
+}
+
+inline void srmesh_destroy(srmeshdata* mesh) {
+  glDeleteVertexArrays(1, &mesh->vao_id);
+  glDeleteBuffers(1, &mesh->vb_id);
+  glDeleteBuffers(1, &mesh->idb_id);
+  free(mesh);
+}
+
 //
 // srender Implementation
 //
@@ -94,45 +220,12 @@ typedef struct srcmdbuf {
   srcmd* cmds;
 } srcmdbuf;
 
-//
-// Vertex Data
-//
-typedef union srvrtxdata {
-  struct {
-    float x, y, z, w;
-    float nx, ny, nz;
-    float s, t;
-    GLubyte r, g, b, a;
-  };
-  struct {
-    float pos[4];
-    float n[4];
-    float uv[2];
-    GLubyte color[4];
-  };
-} srvrtxdata;
-
 //
 // Vertex Buffer Object for all debug objects (coord frame, grid, cube, ...)
 //
 const GLint DEBUG_VBO_SIZE = 1024;
-GLuint gDebugShapesVBOId = 0;
 GLuint gDebugShapesVAId = 0;
-
-//
-// Simple Mesh Data
-//
-typedef struct srmeshdata {
-  int nvertices;
-  int nindices;
-
-  GLuint vao_id;
-  GLuint vb_id;
-  GLuint idb_id;
-
-  GLuint count;
-  GLenum mode;
-} srmeshdata;
+GLuint gDebugShapesVBOId = 0;
 
 static srmeshdata gCoordFrameMesh = {0};
 static srmeshdata gGridMesh = {0};
@@ -422,7 +515,7 @@ void init_debug_meshes() {
   glBufferSubData(
       GL_ARRAY_BUFFER,
       dbg_vbuf_offset,
-      sizeof(srvrtxdata) * 44,
+      sizeof(union srvrtxdata) * 44,
       grid_vertices);
   dbg_vbuf_offset += sizeof(srvrtxdata) * 44;
 
@@ -494,9 +587,9 @@ void init_debug_meshes() {
   glBufferSubData(
       GL_ARRAY_BUFFER,
       dbg_vbuf_offset,
-      sizeof(srvrtxdata) * 24,
+      sizeof(srvrtxdata) * gCubeMesh.nvertices,
       cube_vertices);
-  dbg_vbuf_offset += sizeof(srvrtxdata) * 24;
+  dbg_vbuf_offset += sizeof(srvrtxdata) * gCubeMesh.nvertices;
 
   GLuint cube_indices[] = {
       // clang-format off
@@ -551,7 +644,7 @@ void init_debug_meshes() {
       float theta = -M_PI + j * sector_step;
       float x = cos(theta) * cos(phi);
       float z = -sin(theta) * cos(phi);
-//      gLog ("idx: %d # phi: %f, theta %f, p = %f, %f, %f", vert_index, phi * 180 / M_PI, theta * 180 / M_PI, x, y, z);
+      //      gLog ("idx: %d # phi: %f, theta %f, p = %f, %f, %f", vert_index, phi * 180 / M_PI, theta * 180 / M_PI, x, y, z);
 
       srvrtxdata* vertex = &uvsphere_vertices[vert_index++];
       vertex->x = x * 0.5;
@@ -624,8 +717,6 @@ void init_debug_meshes() {
   gUVSphereMesh.count = gUVSphereMesh.nindices;
 
   glBindVertexArray(0);
-
-  gLog ("Debug Mesh Vertices: %d", dbg_vbuf_offset / sizeof(union srvrtxdata));
 };
 
 //
@@ -807,6 +898,22 @@ void srndr_run_sphere_command(const srcmd* cmd) {
   glBindVertexArray(0);
 }
 
+void srndr_run_mesh_command(const srcmd* cmd) {
+  glBindVertexArray(cmd->meshdata->vao_id);
+
+  glBindBuffer(GL_ARRAY_BUFFER, cmd->meshdata->vb_id);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cmd->meshdata->idb_id);
+  glDrawElements(
+      cmd->meshdata->mode,
+      cmd->meshdata->count,
+      GL_UNSIGNED_INT,
+      (void*)0);
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+  glBindVertexArray(0);
+}
+
 void srndr_render(srndr* srndr, srview* sview, srcmdbuf* scmdbuf) {
   glBindFramebuffer(GL_DRAW_FRAMEBUFFER, sview->mFrameBufferId);
 
@@ -817,7 +924,7 @@ void srndr_render(srndr* srndr, srview* sview, srcmdbuf* scmdbuf) {
   glFrontFace(GL_CCW);
   glEnable(GL_CULL_FACE);
   glCullFace(GL_BACK);
-//  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+  //  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
   glUseProgram(gDefaultShader.program_id);
   GLint view_mat_loc =
@@ -851,6 +958,9 @@ void srndr_render(srndr* srndr, srview* sview, srcmdbuf* scmdbuf) {
       case SRndrCmdTypeSphere:
         srndr_run_sphere_command(cmd);
         break;
+      case SrndrCmdTypeMesh:
+        srndr_run_mesh_command(cmd);
+        break;
       default:
         gLog("Invalid command type %d at index %d", cmd->type, i);
         break;

src/vissim.cc

@@ -11,20 +11,25 @@
 #include <cstdio>
 #include <iostream>
 
-#include "backends/imgui_impl_glfw.h"
-#include "backends/imgui_impl_opengl3.h"
-#include "imgui.h"
-#include "ImGuizmo.h"
-
+// clang-format off
 #ifndef IMGUI_DEFINE_MATH_OPERATORS
 #define IMGUI_DEFINE_MATH_OPERATORS
 #endif
+#include "backends/imgui_impl_glfw.h"
+#include "backends/imgui_impl_opengl3.h"
+#include "ImGuizmo.h"
 #include "imgui_internal.h"
+#include "imgui.h"
+// clang-format on
+
 #include "render_utils.h"
 #include "simulator.h"
 #include "srender.h"
 #include "utils.h"
 
+#define SCONVCOL_IMPLEMENTATION
+#include "sconvcol.h"
+
 GLFWwindow* gWindow = nullptr;
 GuiInputState* gGuiInputState = nullptr;
 CameraState* gCameraState = nullptr;
@@ -87,38 +92,74 @@ static void opengl_error_callback(
     const GLchar* message,
     const void* userParam) {
   const char* source_str;
-  switch (source)
-  {
-    case GL_DEBUG_SOURCE_API:             source_str = "API"; break;
-    case GL_DEBUG_SOURCE_WINDOW_SYSTEM:   source_str = "Window System"; break;
-    case GL_DEBUG_SOURCE_SHADER_COMPILER: source_str = "Shader Compiler"; break;
-    case GL_DEBUG_SOURCE_THIRD_PARTY:     source_str = "3rd Party"; break;
-    case GL_DEBUG_SOURCE_APPLICATION:     source_str = "Application"; break;
-    default:           source_str = "Other"; break;
+  switch (source) {
+    case GL_DEBUG_SOURCE_API:
+      source_str = "API";
+      break;
+    case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
+      source_str = "Window System";
+      break;
+    case GL_DEBUG_SOURCE_SHADER_COMPILER:
+      source_str = "Shader Compiler";
+      break;
+    case GL_DEBUG_SOURCE_THIRD_PARTY:
+      source_str = "3rd Party";
+      break;
+    case GL_DEBUG_SOURCE_APPLICATION:
+      source_str = "Application";
+      break;
+    default:
+      source_str = "Other";
+      break;
   }
 
   const char* type_str;
-  switch (type)
-  {
-    case GL_DEBUG_TYPE_ERROR:               type_str = "Error"; break;
-    case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: type_str = "Deprecated Behaviour"; break;
-    case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:  type_str = "Undefined Behaviour"; break;
-    case GL_DEBUG_TYPE_PORTABILITY:         type_str = "Portability"; break;
-    case GL_DEBUG_TYPE_PERFORMANCE:         type_str = "Performance"; break;
-    case GL_DEBUG_TYPE_MARKER:              type_str = "Marker"; break;
-    case GL_DEBUG_TYPE_PUSH_GROUP:          type_str = "Push Group"; break;
-    case GL_DEBUG_TYPE_POP_GROUP:           type_str = "Pop Group"; break;
-    default:               type_str = "Other"; break;
+  switch (type) {
+    case GL_DEBUG_TYPE_ERROR:
+      type_str = "Error";
+      break;
+    case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
+      type_str = "Deprecated Behaviour";
+      break;
+    case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
+      type_str = "Undefined Behaviour";
+      break;
+    case GL_DEBUG_TYPE_PORTABILITY:
+      type_str = "Portability";
+      break;
+    case GL_DEBUG_TYPE_PERFORMANCE:
+      type_str = "Performance";
+      break;
+    case GL_DEBUG_TYPE_MARKER:
+      type_str = "Marker";
+      break;
+    case GL_DEBUG_TYPE_PUSH_GROUP:
+      type_str = "Push Group";
+      break;
+    case GL_DEBUG_TYPE_POP_GROUP:
+      type_str = "Pop Group";
+      break;
+    default:
+      type_str = "Other";
+      break;
   }
 
   const char* severity_str;
-  switch (severity)
-  {
-    case GL_DEBUG_SEVERITY_HIGH:         severity_str = "high"; break;
-    case GL_DEBUG_SEVERITY_MEDIUM:       severity_str = "medium"; break;
-    case GL_DEBUG_SEVERITY_LOW:          severity_str = "low"; break;
-    case GL_DEBUG_SEVERITY_NOTIFICATION: severity_str = "notification"; break;
-    default: severity_str = "unknown";
+  switch (severity) {
+    case GL_DEBUG_SEVERITY_HIGH:
+      severity_str = "high";
+      break;
+    case GL_DEBUG_SEVERITY_MEDIUM:
+      severity_str = "medium";
+      break;
+    case GL_DEBUG_SEVERITY_LOW:
+      severity_str = "low";
+      break;
+    case GL_DEBUG_SEVERITY_NOTIFICATION:
+      severity_str = "notification";
+      break;
+    default:
+      severity_str = "unknown";
   }
 
   gLog(
@@ -151,8 +192,8 @@ void handle_mouse() {
   glfwGetCursorPos(gWindow, &mouse_x, &mouse_y);
 
   if (gGuiInputState->mouseButton) {
-    gGuiInputState->mousedX = int32_t (mouse_x) - gGuiInputState->mouseX;
-    gGuiInputState->mousedY = int32_t (mouse_y) - gGuiInputState->mouseY;
+    gGuiInputState->mousedX = int32_t(mouse_x) - gGuiInputState->mouseX;
+    gGuiInputState->mousedY = int32_t(mouse_y) - gGuiInputState->mouseY;
   } else {
     gGuiInputState->mousedX = 0;
     gGuiInputState->mousedY = 0;
@@ -357,7 +398,8 @@ void ShowTransformManip(
         case ImGuizmo::SCALE:
           ImGui::InputFloat("Scale Snap", &snap[0]);
           break;
-        default: break;
+        default:
+          break;
       }
       ImGui::Checkbox("Bound Sizing", &boundSizing);
       if (boundSizing) {
@@ -410,7 +452,170 @@ void ShowTransformManip(
   }
 }
 
-void DoRender() {
+void SimulatorSceneRender(srcmdbuf* render_commands) {
+  // Populate render commands
+  srcmdbuf_clear(render_commands);
+
+  srcmd rcmd;
+  srcmd_clear(&rcmd);
+
+  rcmd.type = SRndrCmdTypeFrame;
+  srcmdbuf_add(render_commands, &rcmd);
+
+  simulator_draw(render_commands);
+
+  if (gDialogs->mSimulator) {
+    ImGui::Begin("Simulator", &gDialogs->mSimulator);
+    simulator_gui();
+    ImGui::End();
+  }
+}
+
+sch_hull box_hull;
+srmeshdata* box_hull_mesh;
+
+void SconvHUllSceneInit() {
+  sch_create_unitbox(&box_hull);
+
+  // create mesh for hull
+  static srvrtxdata mesh_buffer_data[1024];
+  static GLuint index_buffer_data[1024];
+  int vertex_index = -1;
+  int index_count = -1;
+  int triangle_count = 0;
+
+  sch_hull* hull = &box_hull;
+
+  int face_vert0_idx = 0;
+
+  for (int fi = 0; fi < hull->num_faces; fi++) {
+    sch_face* face = &hull->faces[fi];
+    sch_edge* edge0 = face->edge;
+    sch_vert* face_vert0 = edge0->vert;
+    sch_edge* cur_edge = edge0->next;
+    sch_vert* cur_vert = nullptr;
+    sch_edge* next_edge = nullptr;
+    sch_vert* next_vert = nullptr;
+
+    int tri_vert_0_idx = 0;
+    int tri_vert_1_idx = 0;
+    int tri_vert_2_idx = 0;
+
+    sch_plane plane;
+    sch_hull_calc_plane(hull, fi, &plane);
+
+    // add face_vert0 (later used as tri_vert_0)
+    vertex_index++;
+    face_vert0_idx = vertex_index;
+    tri_vert_0_idx = face_vert0_idx;
+    srvrtxdata* mesh_vert = &mesh_buffer_data[tri_vert_0_idx];
+    mesh_vert->x = simd4f_get_x(face_vert0->p);
+    mesh_vert->y = simd4f_get_y(face_vert0->p);
+    mesh_vert->z = simd4f_get_z(face_vert0->p);
+    mesh_vert->w = 1.f;
+    mesh_vert->nx = simd4f_get_x(plane.n);
+    mesh_vert->ny = simd4f_get_y(plane.n);
+    mesh_vert->nz = simd4f_get_z(plane.n);
+    mesh_vert->color[0] = fabs(mesh_vert->nx) * 255;
+    mesh_vert->color[1] = fabs(mesh_vert->ny) * 255;
+    mesh_vert->color[2] = fabs(mesh_vert->nz) * 255;
+    mesh_vert->color[3] = 255;
+
+    // add tri_vert_1
+    cur_vert = cur_edge->vert;
+    tri_vert_1_idx = ++vertex_index;
+    mesh_vert = &mesh_buffer_data[tri_vert_1_idx];
+    mesh_vert->x = simd4f_get_x(cur_vert->p);
+    mesh_vert->y = simd4f_get_y(cur_vert->p);
+    mesh_vert->z = simd4f_get_z(cur_vert->p);
+    mesh_vert->w = 1.f;
+    mesh_vert->nx = simd4f_get_x(plane.n);
+    mesh_vert->ny = simd4f_get_y(plane.n);
+    mesh_vert->nz = simd4f_get_z(plane.n);
+    mesh_vert->color[0] = fabs(mesh_vert->nx) * 255;
+    mesh_vert->color[1] = fabs(mesh_vert->ny) * 255;
+    mesh_vert->color[2] = fabs(mesh_vert->nz) * 255;
+    mesh_vert->color[3] = 255;
+
+    do {
+      // add face_vert0
+      index_buffer_data[++index_count] = tri_vert_0_idx;
+
+      // add face_vert1
+      index_buffer_data[++index_count] = tri_vert_1_idx;
+
+      next_edge = cur_edge->next;
+      next_vert = next_edge->vert;
+      tri_vert_2_idx = ++vertex_index;
+
+      mesh_vert = &mesh_buffer_data[tri_vert_2_idx];
+      mesh_vert->x = simd4f_get_x(next_vert->p);
+      mesh_vert->y = simd4f_get_y(next_vert->p);
+      mesh_vert->z = simd4f_get_z(next_vert->p);
+      mesh_vert->w = 1.f;
+      mesh_vert->nx = simd4f_get_x(plane.n);
+      mesh_vert->ny = simd4f_get_y(plane.n);
+      mesh_vert->nz = simd4f_get_z(plane.n);
+      mesh_vert->color[0] = fabs(mesh_vert->nx) * 255;
+      mesh_vert->color[1] = fabs(mesh_vert->ny) * 255;
+      mesh_vert->color[2] = fabs(mesh_vert->nz) * 255;
+      mesh_vert->color[3] = 255;
+      index_buffer_data[++index_count] = tri_vert_2_idx;
+
+      triangle_count++;
+      cur_edge = next_edge;
+      tri_vert_1_idx = tri_vert_2_idx;
+    } while (next_edge->next != edge0);
+  }
+
+  box_hull_mesh = srmesh_create(
+      mesh_buffer_data,
+      vertex_index + 1,
+      index_buffer_data,
+      index_count + 1,
+      GL_TRIANGLES,
+      index_count + 1);
+}
+
+void SconvHUllSceneCleanup() { srmesh_destroy(box_hull_mesh); }
+
+void SconvHUllSceneUpdate() {}
+
+void SconvHullSceneRender(srcmdbuf* render_commands) {
+  // Populate render commands
+  srcmdbuf_clear(render_commands);
+
+  srcmd rcmd;
+  srcmd_clear(&rcmd);
+
+  rcmd.type = SRndrCmdTypeFrame;
+  srcmdbuf_add(render_commands, &rcmd);
+
+  rcmd.type = SRndrCmdTypeGrid;
+  float origin[3] = {0.f, 0.f, 0.f};
+
+  for (int i = -1; i <= 1; i++) {
+    for (int j = -1; j <= 1; j++) {
+      simd4x4f_translation(
+          &rcmd.mat,
+          origin[0] + i * 10.0f,
+          origin[1],
+          origin[2] + j * 10.f);
+      srcmdbuf_add(render_commands, &rcmd);
+    }
+  }
+
+  // Render hull
+  srcmd cmd;
+  cmd.type = SrndrCmdTypeMesh;
+  cmd.color = simd4f_create(1.f, 1.f, 1.f, 1.f);
+  simd4x4f_identity(&cmd.mat);
+  cmd.meshdata = box_hull_mesh;
+
+  srcmdbuf_add(render_commands, &cmd);
+}
+
+void ImSRenderWidget(srndr* renderer, srview* view) {
   ZoneScoped;
 
   const ImGuiStyle& imgui_style = ImGui::GetStyle();
@@ -420,7 +625,7 @@ void DoRender() {
 
   // Update the gCameraState->mtxView
   const ImVec2 content_avail = ImGui::GetContentRegionAvail();
-  srview_set_size(gView, int(content_avail.x), int(content_avail.y));
+  srview_set_size(view, int(content_avail.x), int(content_avail.y));
 
   float view_width = content_avail.x / 50.f;
   float view_height = content_avail.y / 50.f;
@@ -439,34 +644,12 @@ void DoRender() {
       view_width / view_height,
       0.1f,
       50.f);
-  srview_set_view(gView, gCameraState->mtxView);
-  srview_set_proj(gView, gProjMatrix);
-
-  // Populate render commands
-  srcmdbuf_clear(gRndrCmds);
-
-  srcmd rcmd;
-  srcmd_clear(&rcmd);
-
-  rcmd.type = SRndrCmdTypeFrame;
-  srcmdbuf_add(gRndrCmds, &rcmd);
-
-  if (gViewMode == ViewModeSimulation) {
-    simulator_draw(gRndrCmds);
-
-    if (gDialogs->mSimulator) {
-      ImGui::Begin("Simulator", &gDialogs->mSimulator);
-      simulator_gui();
-      ImGui::End();
-    }
-  } else {
-    RenderGuizmoTest(gRndrCmds);
-  }
+  srview_set_view(view, gCameraState->mtxView);
+  srview_set_proj(view, gProjMatrix);
 
   // Perform the actual render
-  srndr_render(gRndr, gView, gRndrCmds);
   GLuint view_texture;
-  srview_get_output_texture(gView, &view_texture);
+  srview_get_output_texture(view, &view_texture);
 
   ImGui::Image(
       (void*)view_texture,
@@ -483,7 +666,7 @@ void DoRender() {
       (float*)(&gTransformMatrix));
 
   ImGui::End();
-}
+};
 
 int main() {
   gTimerInit();
@@ -574,7 +757,12 @@ int main() {
   gRndr = srndr_create();
   gView = srview_create();
   gRndrCmds = srcmdbuf_create(1024);
+
+  //
+  // Scene init
+  //
   simulator_init();
+  SconvHUllSceneInit();
 
   simd4x4f_translation(&gCameraState->mtxView, 0.1f, 0.1f, -0.5f);
   simd4f eye = simd4f_create(0.f, 0.f, 10.f, 1.f);
@@ -607,6 +795,7 @@ int main() {
       ImGui_ImplOpenGL3_NewFrame();
       ImGui_ImplGlfw_NewFrame();
       ImGui::NewFrame();
+      ShowDockspace(true);
       ImGuizmo::BeginFrame();
       ImGuizmo::Enable(gGizmoEnabled);
     }
@@ -710,19 +899,22 @@ int main() {
         if (changed) {
           CameraState_CalcToMatrix(gCameraState, &gCameraState->mtxView);
         }
+
+        if (gDialogs->mImGuiDemo) {
+          ImGui::ShowDemoWindow(&gDialogs->mImGuiDemo);
+        }
+
         ImGui::End();
       }
 
-      if (gDialogs->mImGuiDemo) {
-        ImGui::ShowDemoWindow(&gDialogs->mImGuiDemo);
-      }
-
-      ShowDockspace(true);
-
-      DoRender();
+      SconvHullSceneRender(gRndrCmds);
+      //      SimulatorSceneRender(gRndrCmds);
+      srndr_render(gRndr, gView, gRndrCmds);
+      ImSRenderWidget(gRndr, gView);
     }
 
     simulator_update(gTimer->mDeltaTime);
+    SconvHUllSceneUpdate();
 
     {
       ZoneNamedN(render_submit, "RenderSubmit", true);
@@ -772,6 +964,8 @@ int main() {
 
   gLog("Exiting application");
 
+  SconvHUllSceneCleanup();
+
   srview_destroy(gView);
   srndr_destroy(gRndr);