Global targets (static class) spawned from level

Author: h4k1m0u

include/controls/mouse_handler.hpp

@@ -3,7 +3,6 @@
 
 #include "gui/window.hpp"
 #include "navigation/camera.hpp"
-#include "entities/target.hpp"
 #include "audio/audio.hpp"
 
 /**
@@ -14,7 +13,6 @@
 class MouseHandler {
 public:
   /* No need for instance constructor to init static private members */
-  // static void init(Window* window, Camera* camera, std::vector<Target *> targets, Audio* audio);
   static void init(Window* window, Camera* camera, Audio* audio);
 
   /* static methods can be passed as function pointers callbacks (no `this` argument) */
@@ -30,9 +28,6 @@ class MouseHandler {
   /* Needed to get 3d projection matrix for raycasting (mouse position to 3d position) */
   static Window* m_window;
 
-  /* Color cube to check for intersection with camera's line of sight */
-  static std::vector<Target *> m_targets;
-
   /* previous mouse xy-coords to compare to when moving (modified inside listeners below) */
   static int m_xmouse;
   static int m_ymouse;

include/entities/target.hpp

@@ -12,14 +12,15 @@ struct Target {
   // program declared first (i.e. init first) as it's needed by renderer
   // https://stackoverflow.com/a/41886567/2228912
   Program m_program;
+  glm::vec3 m_position;
 
 public:
   Renderer renderer;
 
   /* kill target on intersection with mouse cursor */
   bool is_dead;
 
-  Target();
+  Target(const glm::vec3& position);
   void draw(const Uniforms& uniforms={});
   void set_transform(const Transformation& t);
   void free();

include/globals/targets.hpp

@@ -0,0 +1,18 @@
+#ifndef TARGETS_HPP
+#define TARGETS_HPP
+
+#include "entities/target.hpp"
+
+/* static class */
+class Targets {
+public:
+  static std::vector<Target> cubes;
+  static void add(const Target& target);
+  static void free();
+
+private:
+  /* Cannot create class instances */
+  Targets();
+};
+
+#endif // TARGETS_HPP

include/render/level_renderer.hpp

@@ -15,13 +15,12 @@
 struct LevelRenderer {
   /* Used to block camera from going through walls */
   std::vector<glm::vec3> positions_walls;
-  /* Targets to kill by mouse cursor intersection */
-  // std::vector<Target> targets;
 
   LevelRenderer(const Program& program_tile, const Tilemap& tilemap, const glm::vec3& position, Assimp::Importer& importer);
   void draw(const Uniforms& u={});
   void draw_floor(const Uniforms& u);
   void draw_ceiling(const Uniforms& u);
+  void draw_targets(const Uniforms& u);
   void set_transform(const Transformation& t);
   void free();
 
@@ -30,8 +29,6 @@ struct LevelRenderer {
 private:
   /* same renderer for all ceiling/floor & walls */
   Renderer m_renderer;
-  /* same target rendered multiple times */
-  Target m_target;
   /* same grass prop rendered multiple times */
   Model m_tree;
 

src/controls/mouse_handler.cpp

@@ -3,11 +3,11 @@
 #include "controls/mouse_handler.hpp"
 #include "math/transformation.hpp"
 #include "globals/score.hpp"
+#include "globals/targets.hpp"
 
 /* Static class members require a declaration in *.cpp (to allocate space for them) */
 Camera* MouseHandler::m_camera;
 Window* MouseHandler::m_window;
-std::vector<Target *> MouseHandler::m_targets;
 int MouseHandler::m_xmouse;
 int MouseHandler::m_ymouse;
 Audio* MouseHandler::m_audio;
@@ -19,14 +19,12 @@ Audio* MouseHandler::m_audio;
  * @param cube Check for its intersection with camera's intersection
  * @param audio
  */
-// void MouseHandler::init(Window* window, Camera* camera, std::vector<Target *> targets, Audio* audio) {
 void MouseHandler::init(Window* window, Camera* camera, Audio* audio) {
   // init static members: initial mouse's xy-coords at center of screen
   m_camera = camera;
   m_window = window;
   m_xmouse = m_window->width / 2;
   m_ymouse = m_window->height / 2;
-  // m_targets = targets;
   m_audio = audio;
 }
 
@@ -39,13 +37,13 @@ void MouseHandler::on_mouse_click(GLFWwindow* window, int button, int action, in
     // play gun shot sound
     m_audio->play_2d("assets/audio/gun_shot.mp3");
 
-    for (Target* target : m_targets) {
-      BoundingBox bounding_box = target->renderer.bounding_box;
+    for (Target& target : Targets::cubes) {
+      BoundingBox bounding_box = target.renderer.bounding_box;
       bool is_intersecting = bounding_box.intersects(m_camera->position, m_camera->direction);
 
       // remove target & increase score on intersection
       if (is_intersecting) {
-        target->is_dead = true;
+        target.is_dead = true;
         score++;
         std::cout << "Intersecting!" << '\n';
       } else {

src/entities/target.cpp

@@ -1,3 +1,5 @@
+#include <glm/gtc/matrix_transform.hpp>
+
 #include "entities/target.hpp"
 #include "geometries/cube.hpp"
 #include "shaders/shader_exception.hpp"
@@ -7,11 +9,13 @@
  * TODO:
  *   1. pass ModelRenderer (like for Player)
  *   2. Both Target & Player inherit from Character class containing draw() & m_is_dead
+ * @param position Position extracted from tilemap
  */
-Target::Target():
+Target::Target(const glm::vec3& position):
   m_program("assets/shaders/color.vert", "assets/shaders/color.frag"),
   renderer(m_program, VBO(Cube{}), {{0, "position", 3, 12, 0}, {0, "color", 3, 12, 3}}),  // render colored cube
-  is_dead(false)
+  is_dead(false),
+  m_position(position)
 {
   // vertex or fragment shaders failed to compile
   if (m_program.has_failed()) {
@@ -28,9 +32,12 @@ void Target::draw(const Uniforms& uniforms) {
   renderer.draw(uniforms);
 }
 
-/* delegate transform to renderer */
+/**
+ * Delegate transform to renderer
+ * Translate target to position from tilemap
+ */
 void Target::set_transform(const Transformation& t) {
-  renderer.set_transform(t);
+  renderer.set_transform({ glm::translate(glm::mat4(1.0f), m_position), t.view, t.projection });
 }
 
 /* Free renderer (vao/vbo buffers) & shader program */

src/globals/targets.cpp

@@ -0,0 +1,15 @@
+#include "globals/targets.hpp"
+
+/* Static class members require a declaration in *.cpp (to allocate space for them & avoid linking error) */
+std::vector<Target> Targets::cubes;
+
+void Targets::add(const Target& target) {
+  cubes.push_back(target);
+}
+
+/* Free all targets */
+void Targets::free() {
+  for (Target& target : Targets::cubes) {
+    target.free();
+  }
+}

src/main.cpp

@@ -149,7 +149,6 @@ int main() {
   */
 
   // callback for processing mouse click (after init static members)
-  // MouseHandler::init(&window, &camera, targets, &audio);
   MouseHandler::init(&window, &camera, &audio);
   window.attach_mouse_listeners(MouseHandler::on_mouse_move, MouseHandler::on_mouse_click, MouseHandler::on_mouse_scroll);
   std::cout << "window.width: " << window.width

src/render/level_renderer.cpp

@@ -4,15 +4,15 @@
 
 #include "render/level_renderer.hpp"
 #include "geometries/surface.hpp"
+#include "globals/targets.hpp"
 
 /**
  * Sets positions of walls tiles only once in constructor
  * Needed for collision with camera
  */
 LevelRenderer::LevelRenderer(const Program& program_tile, const Tilemap& tilemap, const glm::vec3& position, Assimp::Importer& importer):
-  // renderer for walls/floors & characters (targets, grass)
+  // renderer for walls/floors, props (trees)
   m_renderer(program_tile, VBO(Surface()), {{0, "position", 2, 4, 0}, {0, "texture_coord", 2, 4, 2}}),
-  m_target(),
   m_tree(importer, "assets/models/tree/tree.obj", Program("assets/shaders/basic.vert", "assets/shaders/basic.frag")),
 
   m_tilemap(tilemap),
@@ -52,6 +52,10 @@ LevelRenderer::LevelRenderer(const Program& program_tile, const Tilemap& tilemap
         case Tilemap::Tiles::WALL_L_INV:
           angle = glm::radians(-90.0f);
           break;
+        case Tilemap::Tiles::ENEMMY: // non-mobile enemies
+          glm::vec3 position_target = position_tile + glm::vec3(0.0f, 0.5f, 0.0f);
+          Targets::add(Target(position_target));
+          continue;
       }
 
       // save world position for walls (for collision with camera)
@@ -79,10 +83,11 @@ LevelRenderer::LevelRenderer(const Program& program_tile, const Tilemap& tilemap
  * @param uniforms Uniforms passed to shader
  */
 void LevelRenderer::draw(const Uniforms& u) {
-  // draw floor & ceiling
+  // draw floor & ceiling & targets
   Uniforms uniforms = u;
   draw_floor(uniforms);
   draw_ceiling(uniforms);
+  draw_targets(uniforms);
 
   for (size_t i_row = 0; i_row < m_tilemap.n_rows; ++i_row) {
     for (size_t i_col = 0; i_col < m_tilemap.n_cols; ++i_col) {
@@ -95,13 +100,7 @@ void LevelRenderer::draw(const Uniforms& u) {
       // choose angle/texture of surface accord. to tile
       switch (tile) {
         case Tilemap::Tiles::ENEMMY:
-          // colored cube enemies
-          m_target.set_transform({
-            glm::translate(glm::mat4(1.0f), position_tile + glm::vec3(0.0f, 0.5f, 0.0f)), // local origin at cube centroid
-            m_transformation.view, m_transformation.projection });
-          m_target.draw(uniforms);
           continue;
-          break;
         case Tilemap::Tiles::TREE:
           // 3d model
           m_tree.set_transform({
@@ -160,6 +159,14 @@ void LevelRenderer::draw(const Uniforms& u) {
   }
 }
 
+/* Draw targets */
+void LevelRenderer::draw_targets(const Uniforms& u) {
+  for (Target& target : Targets::cubes) {
+    target.set_transform(m_transformation);
+    target.draw(u);
+  }
+}
+
 /**
  * Draw horizontal surface at given height
  * @param size Amount by which to scale surface on xy vertical plan
@@ -207,6 +214,6 @@ void LevelRenderer::set_transform(const Transformation& t) {
 /* Renderer lifecycle managed internally */
 void LevelRenderer::free() {
   m_renderer.free();
-  m_target.free();
   m_tree.free();
+  Targets::free();
 }