implement positioned rendering

source/game/engine.cpp

@@ -196,6 +196,31 @@ engine::add_level_bounds_to_render_request(render::request request) const {
   return request;
 }
 
+render::request
+engine::add_playing_bounds_to_render_request(render::request request) const {
+  auto lines = std::vector<glm::vec3>();
+  const float xmin = area_origin.x - area_size.x;
+  const float xmax = area_origin.x + area_size.x;
+  const float zmin = area_origin.z - area_size.z;
+  const float zmax = area_origin.z + area_size.z;
+
+  const auto p1 = glm::vec3(xmin, 0.0f, zmin);
+  const auto p2 = glm::vec3(xmax, 0.0f, zmin);
+  const auto p3 = glm::vec3(xmax, 0.0f, zmax);
+  const auto p4 = glm::vec3(xmin, 0.0f, zmax);
+
+  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);
+}
+
 void engine::calculate_game_plane_size() {
   const auto &game_plane_mesh = [&]() {
     for (const auto &mesh : models.boundary.meshes) {
@@ -214,20 +239,14 @@ void engine::calculate_game_plane_size() {
     return glm::vec3(game_plane_mesh.transform * glm::vec4(p, 1.0f));
   };
 
-  area_height = 0.0f;
-  auto total_found = 0.0f;
   for (const auto &v : game_plane_mesh.vertices) {
-    total_found += 1.0f;
-    area_height += v.position.y;
     min = glm::min(transform(v.position), min);
     max = glm::max(transform(v.position), max);
   }
 
-  area_height /= total_found;
-  area_min = {min.x, min.z};
-  area_max = {max.x, max.z};
-  area_min *= 0.85f;
-  area_max *= 0.85f;
+  area_origin = min + (max - min) * 0.5f;
+  area_size = (max - min) * 0.5f;
+  area_size *= 0.85f;
 }
 
 render::request engine::add_level_to_render_request(render::request request,
@@ -238,14 +257,31 @@ render::request engine::add_level_to_render_request(render::request request,
   for (const auto [eid, position] :
        level->get_entities()->view<components::tile_position>()->each()) {
     request = request.add_mesh(static_cast<std::uint32_t>(wall_tile_render_id))
-                  .with_transform(glm::translate(glm::mat4(1.0f),
-                                                 glm::vec3(0.0f, 0.0f, 0.0f)))
+                  .with_transform(transform_given_coordinate(position))
                   .commit();
   }
 
   return request;
 }
 
+glm::mat4 engine::transform_given_coordinate(glm::uvec2 coordinate) const {
+  const glm::vec3 full_dimensions = area_size * 2.0f;
+
+  const float cell_width = full_dimensions.x / 22.0f;
+  const float cell_depth = full_dimensions.z / 16.0f;
+
+  const auto start_point = area_origin - area_size;
+
+  float world_x = start_point.x +
+                  (static_cast<float>(coordinate.x) * cell_width) +
+                  (cell_width * 0.5f);
+  float world_z = start_point.z +
+                  (static_cast<float>(coordinate.y) * cell_depth) +
+                  (cell_depth * 0.5f);
+
+  return glm::translate(glm::mat4(1.0f), glm::vec3(world_x, 0.1f, world_z));
+}
+
 engine::engine()
     : display(&input, {1920, 1080}, "Tanks Reborn"), renderer(&display),
       models(load_models("../assets/models")),
@@ -261,7 +297,7 @@ void engine::run() {
     try {
       const auto [map_min, map_max] = ::bounds_of(models.boundary);
       const auto [view, projection] = ::calculate_camera_matrices(
-          map_min, map_max, 1920.0f / 1080.0f, 2.6f, true, glfwGetTime());
+          map_min, map_max, 1920.0f / 1080.0f, 3.0f);
 
       auto request = render::request();
 
@@ -269,24 +305,7 @@ void engine::run() {
       if (current_level.has_value()) {
         request = add_level_to_render_request(request, &(*current_level));
       }
-
-      auto lines = std::vector<glm::vec3>();
-      const auto offset = 0.0f;
-      auto p1 = glm::vec3(area_min.x, offset, area_min.y);
-      auto p2 = glm::vec3(area_max.x, offset, area_min.y);
-      auto p3 = glm::vec3(area_max.x, offset, area_max.y);
-      auto p4 = glm::vec3(area_min.x, offset, area_max.y);
-
-      lines.emplace_back(p1);
-      lines.emplace_back(p2);
-      lines.emplace_back(p2);
-      lines.emplace_back(p3);
-      lines.emplace_back(p3);
-      lines.emplace_back(p4);
-      lines.emplace_back(p4);
-      lines.emplace_back(p1);
-
-      request.add_lines(lines);
+      request = add_playing_bounds_to_render_request(request);
 
       renderer.render(request, view, projection);
     } catch (const vuk::VkException &ex) {

source/game/engine.hpp

@@ -27,10 +27,10 @@ private:
   };
   game_models models;
 
-  glm::vec2 area_min;
-  glm::vec2 area_max;
-  float area_height;
+  glm::vec3 area_origin;
+  glm::vec3 area_size;
   std::vector<std::uint32_t> level_border_entity_ids = {};
+  glm::mat4 wall_transform;
 
   struct map_boxes {
     std::uint32_t solid_full;
@@ -57,8 +57,14 @@ private:
   [[nodiscard]] render::request
   add_level_to_render_request(render::request request, level *level) const;
 
+  [[nodiscard]] render::request
+  add_playing_bounds_to_render_request(render::request request) const;
+
   void calculate_game_plane_size();
 
+  [[nodiscard]] glm::mat4
+  transform_given_coordinate(glm::uvec2 coordinate) const;
+
 public:
   engine();
 

source/game/level.cpp

@@ -10,12 +10,13 @@ void level::create_wall_at(glm::uvec2 tile) {
                                               components::tile_position{tile});
 }
 
+// 22x16 probably
 level::level() {
   create_wall_at({0, 0});
-  /*create_wall_at({2, 2});
+  create_wall_at({2, 2});
   create_wall_at({4, 4});
   create_wall_at({10, 4});
-  create_wall_at({4, 0});*/
+  create_wall_at({4, 0});
 }
 
 entt::basic_registry<std::uint32_t> *level::get_entities() { return &entities; }

source/render/renderer.cpp

@@ -317,7 +317,7 @@ void renderer::render(request req, glm::mat4 view, glm::mat4 projection) {
 
     auto matrices = std::vector<glm::mat4>();
     for (const auto &transform : transforms) {
-      const auto model_matrix = mesh.transform * transform;
+      const auto model_matrix = transform * mesh.transform;
       const auto normal_matrix =
           glm::mat4(glm::transpose(glm::inverse(glm::mat3(model_matrix))));
       matrices.push_back(normal_matrix);