Clicking on Room Models will now highlight their bounding sphere

include/BoundingSphere.h

+/*!
+ * \file include/BoundingSphere.h
+ * \brief 3D Bounding Sphere
+ *
+ * \author xythobuz
+ */
+
+#ifndef _BOUNDING_SPHERE_H_
+#define _BOUNDING_SPHERE_H_
+
+#include <vector>
+
+class BoundingSphere {
+  public:
+    BoundingSphere(glm::vec3 p = glm::vec3(0.0f, 0.0f, 0.0f), float r = 100.0f, int res = 10) : pos(p), radius(r), resolution(res) { }
+
+    void setPosition(glm::vec3 p) { pos = p; }
+    glm::vec3 getPosition() { return pos; }
+
+    void setRadius(float r) { radius = r; }
+    float getRadius() { return radius; }
+
+    void display(glm::mat4 VP, glm::vec3 color);
+
+    static void display();
+
+  private:
+    glm::vec3 pos;
+    float radius;
+    int resolution;
+
+    static std::vector<glm::vec4> vertices;
+    static std::vector<glm::vec3> colors;
+};
+
+#endif
+

include/Mesh.h

 
 #include <vector>
 
+#include "BoundingSphere.h"
 #include "system/Shader.h"
 
 struct IndexedRectangle {
     void prepare();
     void display(glm::mat4 MVP, ShaderTexture* shaderTexture = nullptr);
 
-    glm::vec3 getCenter() { return center; }
-    float getRadius() { return radius; }
+    BoundingSphere& getBoundingSphere() { return sphere; }
 
   private:
     std::vector<unsigned short> indicesBuff;
     std::vector<glm::vec3> colorsBuff;
     std::vector<unsigned int> colorsIndexBuff;
 
-    glm::vec3 center;
-    float radius;
+    BoundingSphere sphere;
 };
 
 #endif

include/RoomData.h

 
     glm::vec3 getCenter();
     float getRadius();
+    void displayBoundingSphere(glm::mat4 VP, glm::vec3 color);
 
   private:
     void find();

include/StaticMesh.h

 
 #include <memory>
 
-#include "RoomData.h"
+#include "BoundingBox.h"
+#include "BoundingSphere.h"
 
 class StaticMesh {
   public:
     void display(glm::mat4 MVP);
     void displayUI();
 
-    glm::vec3 getCenter();
-    float getRadius();
+    BoundingSphere& getBoundingSphere();
 
     int getID() { return id; }
 

src/BoundingBox.cpp

 #include "Camera.h"
 #include "World.h"
 #include "system/Shader.h"
-#include "RoomData.h"
+#include "BoundingBox.h"
 
 #include <glbinding/gl/gl.h>
 

src/BoundingSphere.cpp

+/*!
+ * \file src/BoundingSphere.cpp
+ * \brief 3D Axis Aligned Bounding Sphere
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "Camera.h"
+#include "World.h"
+#include "system/Shader.h"
+#include "BoundingSphere.h"
+
+#include <glbinding/gl/gl.h>
+
+std::vector<glm::vec4> BoundingSphere::vertices;
+std::vector<glm::vec3> BoundingSphere::colors;
+
+void BoundingSphere::display(glm::mat4 VP, glm::vec3 color) {
+    for (int w = 0; w < resolution; w++) {
+        for (int h = (-resolution / 2); h < (resolution / 2); h++){
+            float inc1 = (w / float(resolution)) * 2.0f * glm::pi<float>();
+            float inc2 = ((w + 1) / float(resolution)) * 2.0f * glm::pi<float>();
+            float inc3 = (h / float(resolution)) * glm::pi<float>();
+            float inc4 = ((h + 1) / float(resolution)) * glm::pi<float>();
+
+            float x1 = glm::sin(inc1);
+            float y1 = glm::cos(inc1);
+            float x2 = glm::sin(inc2);
+            float y2 = glm::cos(inc2);
+
+            float radius1 = radius * glm::cos(inc3);
+            float radius2 = radius * glm::cos(inc4);
+
+            float z1 = radius * glm::sin(inc3);
+            float z2 = radius * glm::sin(inc4);
+
+            vertices.emplace_back(VP * (glm::vec4(radius1 * x1, z1, radius1 * y1, 1.0f) + glm::vec4(pos, 0.0f)));
+            vertices.emplace_back(VP * (glm::vec4(radius1 * x2, z1, radius1 * y2, 1.0f) + glm::vec4(pos, 0.0f)));
+            vertices.emplace_back(VP * (glm::vec4(radius2 * x2, z2, radius2 * y2, 1.0f) + glm::vec4(pos, 0.0f)));
+
+            vertices.emplace_back(VP * (glm::vec4(radius1 * x1, z1, radius1 * y1, 1.0f) + glm::vec4(pos, 0.0f)));
+            vertices.emplace_back(VP * (glm::vec4(radius2 * x2, z2, radius2 * y2, 1.0f) + glm::vec4(pos, 0.0f)));
+            vertices.emplace_back(VP * (glm::vec4(radius2 * x1, z2, radius2 * y1, 1.0f) + glm::vec4(pos, 0.0f)));
+
+            for (int i = 0; i < 6; i++) {
+                colors.emplace_back(color);
+            }
+        }
+
+    }
+}
+
+void BoundingSphere::display() {
+    if (vertices.size() > 0) {
+        Shader::drawGL(vertices, colors, gl::GL_POINTS);
+    }
+
+    vertices.clear();
+    colors.clear();
+}

src/CMakeLists.txt

 
 # Set Source files
 set (SRCS ${SRCS} "BoundingBox.cpp" "../include/BoundingBox.h")
+set (SRCS ${SRCS} "BoundingSphere.cpp" "../include/BoundingSphere.h")
 set (SRCS ${SRCS} "Camera.cpp" "../include/Camera.h")
 set (SRCS ${SRCS} "Console.cpp" "../include/Console.h")
 set (SRCS ${SRCS} "Entity.cpp" "../include/Entity.h")

src/Mesh.cpp

     verticesColorBuff = std::move(vertCol);
     colorsBuff = std::move(cols);
 
-    center = average / float(averageCount);
-    radius = 0.0f;
+    glm::vec3 center = average / float(averageCount);
+    float radius = 0.0f;
     for (auto& vert : verticesBuff) {
         float dist = glm::distance(center, vert);
         if (dist > radius) radius = dist;
         float dist = glm::distance(center, vert);
         if (dist > radius) radius = dist;
     }
+
+    sphere.setPosition(center);
+    sphere.setRadius(radius);
 }
 
 void Mesh::display(glm::mat4 MVP, ShaderTexture* shaderTexture) {

src/Render.cpp

 
 #include "global.h"
 #include "BoundingBox.h"
+#include "BoundingSphere.h"
 #include "Camera.h"
 #include "Log.h"
 #include "Menu.h"
         Camera::displayFrustum(VP);
 
     BoundingBox::display();
+    BoundingSphere::display();
 
     if (mode == RenderMode::Wireframe) {
         gl::glPolygonMode(gl::GL_FRONT_AND_BACK, gl::GL_FILL);

src/RoomData.cpp

 
 glm::vec3 StaticModel::getCenter() {
     find();
-    glm::vec3 center = World::getStaticMesh(cache).getCenter();
+    glm::vec3 center = World::getStaticMesh(cache).getBoundingSphere().getPosition();
     glm::vec4 tmp = model * glm::vec4(center, 1.0f);
     return glm::vec3(tmp) / tmp.w;
 }
 
 float StaticModel::getRadius() {
     find();
-    return World::getStaticMesh(cache).getRadius();
+    return World::getStaticMesh(cache).getBoundingSphere().getRadius();
+}
+
+void StaticModel::displayBoundingSphere(glm::mat4 VP, glm::vec3 color) {
+    find();
+    World::getStaticMesh(cache).getBoundingSphere().display(VP * model, color);
 }
 
 void StaticModel::display(glm::mat4 VP) {

src/Selector.cpp

 
 static int lastX = -1, lastY = -1;
 static bool workToDo = false;
-static float grabSphere = 102.4f;
 static bool clickOnGeometry = false, clickOnRoomModels = true, clickOnRoomSprites = true;
 static bool clickOnSprites = true, clickOnMeshes = false, clickOnModels = false;
 
         }
     }
 
-    ImGui::SliderFloat("Grab Sphere", &grabSphere, 0.1f, 10240.0f);
     ImGui::Checkbox("Geometry", &clickOnGeometry);
     ImGui::SameLine();
     ImGui::Checkbox("RoomModels", &clickOnRoomModels);
         ImGui::Text("Intersect Norm: (%.2f %.2f %.2f)", lastIntersectNorm.x, lastIntersectNorm.y, lastIntersectNorm.z);
         ImGui::Text("Last Room: %lu", lastRoom);
         ImGui::Text("Last RoomModel: %lu", lastModel);
+
+        World::getRoom(lastRoom).getModel(lastModel).displayBoundingSphere(Camera::getProjectionMatrix() * Camera::getViewMatrix(), glm::vec3(1.0f, 0.0f, 0.0f));
     }
 
     ImGui::End();

src/StaticMesh.cpp

 
 bool StaticMesh::showBoundingBox = false;
 
-glm::vec3 StaticMesh::getCenter() {
-    return World::getMesh(mesh).getCenter();
-}
-
-float StaticMesh::getRadius() {
-    return World::getMesh(mesh).getRadius();
+BoundingSphere& StaticMesh::getBoundingSphere() {
+    return World::getMesh(mesh).getBoundingSphere();
 }
 
 void StaticMesh::display(glm::mat4 MVP) {