create more details for rendering boxes properly

source/game/engine.cpp

@@ -224,6 +224,41 @@ engine::add_playing_bounds_to_render_request(render::request request) const {
   return request.add_lines(lines);
 }
 
+render::request
+engine::add_tiles_to_render_request(render::request request) const {
+  auto lines = std::vector<glm::vec3>();
+
+  const auto full_dimensions = area_size * 2.0f;
+  const auto cell_size = full_dimensions.x / 22.0f;
+
+  const auto start = area_origin - area_size;
+
+  for (int x = 0; x < 22; x++) {
+    for (int y = 0; y < 16; y++) {
+      const auto min_x = start.x + (static_cast<float>(x) * cell_size);
+      const auto min_y = start.z + (static_cast<float>(y) * cell_size);
+      const auto max_x = start.x + (static_cast<float>(x + 1) * cell_size);
+      const auto max_y = start.z + (static_cast<float>(y + 1) * cell_size);
+
+      const auto p1 = glm::vec3(min_x, 0.0f, min_y);
+      const auto p2 = glm::vec3(max_x, 0.0f, min_y);
+      const auto p3 = glm::vec3(max_x, 0.0f, max_y);
+      const auto p4 = glm::vec3(min_x, 0.0f, max_y);
+
+      lines.push_back(p1);
+      lines.push_back(p2);
+      lines.push_back(p2);
+      lines.push_back(p3);
+      lines.push_back(p3);
+      lines.push_back(p4);
+      lines.push_back(p4);
+      lines.push_back(p1);
+    }
+  }
+
+  return request.add_lines(lines);
+}
+
 engine::mesh_bounds engine::compute_size_of_mesh(const mesh_node &mesh) {
   auto bounds = mesh_bounds();
 
@@ -261,6 +296,11 @@ void engine::calculate_game_plane_size() {
   area_origin = min + (max - min) * 0.5f;
   area_size = (max - min) * 0.5f;
   area_size *= 0.85f;
+  tile_size = area_size / glm::vec3(22.0f, 1.0f, 16.0f);
+  auto normalized_ts = tile_size / glm::vec3(tile_size.x, 1.0f, tile_size.x);
+  area_size.z /= normalized_ts.z;
+  tile_size = area_size / glm::vec3(22.0f, 1.0f, 16.0f);
+  tile_size.y = 1.0f;
 }
 
 void engine::calculate_box_size() {
@@ -289,6 +329,9 @@ void engine::calculate_box_size() {
 
   full_box_size = full_size;
   half_box_size = half_size;
+  const auto scale_required = (tile_size * 1.8f) / full_box_size;
+  const auto s = glm::vec3(scale_required.x, 1.0f, scale_required.z);
+  box_transform = glm::scale(glm::mat4(1.0f), s);
 }
 
 render::request engine::add_level_to_render_request(render::request request,
@@ -328,7 +371,7 @@ render::request engine::add_level_to_render_request(render::request request,
 
       request =
           request.add_mesh(static_cast<std::uint32_t>(wall_tile_render_id))
-              .with_transform(coord_transform * height)
+              .with_transform(coord_transform * height * box_transform)
               .commit();
 
       current_height +=
@@ -414,6 +457,10 @@ void engine::run() {
         request = add_playing_bounds_to_render_request(request);
       }
 
+      if (debug_drawing.individual_tiles) {
+        request = add_tiles_to_render_request(request);
+      }
+
       renderer.render(request, view, projection);
     } catch (const vuk::VkException &ex) {
       if (ex.what() != std::string("Out of date.")) {

source/game/engine.hpp

@@ -29,10 +29,12 @@ private:
 
   glm::vec3 area_origin;
   glm::vec3 area_size;
+  glm::vec3 tile_size;
   std::vector<std::uint32_t> level_border_entity_ids = {};
 
   glm::vec3 full_box_size;
   glm::vec3 half_box_size;
+  glm::mat4 box_transform;
 
   struct map_boxes {
     std::uint32_t solid_full;
@@ -69,6 +71,9 @@ private:
   [[nodiscard]] render::request
   add_playing_bounds_to_render_request(render::request request) const;
 
+  [[nodiscard]] render::request
+  add_tiles_to_render_request(render::request request) const;
+
   struct mesh_bounds {
     glm::vec3 min;
     glm::vec3 max;

source/game/level.cpp

@@ -35,6 +35,7 @@ level::level() {
   // for (int x = 0; x < 22; x++) {
   //  for (int y = 0; y < 16; y++) {
   create_wall_at({0, 0});
+  create_wall_at({11, 8});
   //}
   //}
 }