Can click on Room Models

include/Camera.h

     static bool boxInFrustum(BoundingBox b);
     static void displayFrustum(glm::mat4 MVP);
 
-    static const float fov;
-    static const float nearDist;
-    static const float farDist;
-
   private:
     static void calculateFrustumPlanes();
 
     static bool updateViewFrustum, dirty, movingFaster;
     static bool keepInRoom;
     static int room;
+
+    static const float fov;
+    static const float nearDist;
+    static const float farDist;
 };
 
 #endif

include/Mesh.h

     void prepare();
     void display(glm::mat4 MVP, ShaderTexture* shaderTexture = nullptr);
 
+    glm::vec3 getCenter() { return center; }
+    float getRadius() { return radius; }
+
   private:
     std::vector<unsigned short> indicesBuff;
     std::vector<glm::vec3> verticesBuff;
     std::vector<glm::vec3> verticesColorBuff;
     std::vector<glm::vec3> colorsBuff;
     std::vector<unsigned int> colorsIndexBuff;
+
+    glm::vec3 center;
+    float radius;
 };
 
 #endif

include/Room.h

     int getIndex() { return roomIndex; }
 
     void addSprite(RoomSprite* s) { sprites.emplace_back(s); }
-    void addModel(StaticModel* s) { models.emplace_back(s); }
     void addSector(Sector* s) { sectors.emplace_back(s); }
 
+    void addModel(StaticModel* s) { models.emplace_back(s); }
+    unsigned long sizeModels() { return models.size(); }
+    StaticModel& getModel(unsigned long index) { return *models.at(index); }
+
     void addPortal(Portal* p) { portals.emplace_back(p); }
     unsigned long sizePortals() { return portals.size(); }
     Portal& getPortal(unsigned long index) { return *portals.at(index); }

include/RoomData.h

     void display(glm::mat4 VP);
     void displayUI();
 
+    glm::vec3 getCenter();
+    float getRadius();
+
   private:
+    void find();
+
     int id;
     int cache;
     glm::mat4 model;

include/StaticMesh.h

     void display(glm::mat4 MVP);
     void displayUI();
 
+    glm::vec3 getCenter();
+    float getRadius();
+
     int getID() { return id; }
 
     static void setShowBoundingBox(bool s) { showBoundingBox = s; }

src/CMakeLists.txt

 set (SRCS ${SRCS} "Entity.cpp" "../include/Entity.h")
 set (SRCS ${SRCS} "Game.cpp" "../include/Game.h")
 set (SRCS ${SRCS} "Log.cpp" "../include/Log.h")
-set (SRCS ${SRCS} "main.cpp")
+set (SRCS ${SRCS} "main.cpp" "../include/global.h")
 set (SRCS ${SRCS} "Menu.cpp" "../include/Menu.h")
 set (SRCS ${SRCS} "Mesh.cpp" "../include/Mesh.h")
 set (SRCS ${SRCS} "Render.cpp" "../include/Render.h")

src/Mesh.cpp

 #include "Mesh.h"
 
 #include <glbinding/gl/gl.h>
+#include <glm/glm.hpp>
 
 Mesh::Mesh(const std::vector<glm::vec3>& vert,
            const std::vector<IndexedRectangle>& rect,
     std::vector<glm::vec2> uvBuff;
     std::vector<unsigned int> tex;
 
+    glm::vec3 average(0.0f, 0.0f, 0.0f);
+    unsigned long averageCount = 0;
+
     int vertIndex = 0;
     for (int i = 0; i < indicesBuff.size(); i++) {
         unsigned int texture = TextureManager::getTile(texturesBuff.at(i)).getTexture();
             vert.push_back(verticesBuff.at(vertIndex + v));
             uvBuff.push_back(TextureManager::getTile(texturesBuff.at(i)).getUV(v));
             tex.push_back(texture);
+
+            // Calculate quick-n-dirty center point of mesh
+            average += verticesBuff.at(vertIndex + v);
+            averageCount++;
         }
 
         if (indicesBuff.at(i) == 0) {
             vertCol.push_back(verticesColorBuff.at(vertIndex + v));
             glm::vec4 c = TextureManager::getPalette(colorsIndexBuff.at(i));
             cols.push_back(glm::vec3(c.x, c.y, c.z));
+
+            average += verticesColorBuff.at(vertIndex + v);
+            averageCount++;
         }
 
         if (indicesColorBuff.at(i) == 0) {
     indicesColorBuff = std::move(indCol);
     verticesColorBuff = std::move(vertCol);
     colorsBuff = std::move(cols);
+
+    center = average / float(averageCount);
+    radius = 0.0f;
+    for (auto& vert : verticesBuff) {
+        float dist = glm::distance(center, vert);
+        if (dist > radius) radius = dist;
+    }
+    for (auto& vert : verticesColorBuff) {
+        float dist = glm::distance(center, vert);
+        if (dist > radius) radius = dist;
+    }
 }
 
 void Mesh::display(glm::mat4 MVP, ShaderTexture* shaderTexture) {

src/Room.cpp

 #include <glm/gtx/intersect.hpp>
 
 bool Room::showBoundingBox = false;
-bool Room::showRoomModels = false;
+bool Room::showRoomModels = true;
 bool Room::showRoomSprites = true;
 bool Room::showRoomGeometry = true;
 

src/RoomData.cpp

     model = translate * rotate;
 }
 
-void StaticModel::display(glm::mat4 VP) {
+void StaticModel::find() {
     if (cache < 0) {
         for (int i = 0; i < World::sizeStaticMesh(); i++) {
             if (World::getStaticMesh(i).getID() == id) {
         }
         orAssertGreaterThanEqual(cache, 0);
     }
+}
+
+glm::vec3 StaticModel::getCenter() {
+    find();
+    glm::vec3 center = World::getStaticMesh(cache).getCenter();
+    glm::vec4 tmp = model * glm::vec4(center, 1.0f);
+    return glm::vec3(tmp) / tmp.w;
+}
 
+float StaticModel::getRadius() {
+    find();
+    return World::getStaticMesh(cache).getRadius();
+}
+
+void StaticModel::display(glm::mat4 VP) {
+    find();
     World::getStaticMesh(cache).display(VP * model);
 }
 

src/Selector.cpp

 #include "global.h"
 #include "Camera.h"
 #include "Log.h"
+#include "World.h"
 #include "system/Window.h"
 #include "Selector.h"
 
+#include <glm/gtx/intersect.hpp>
+
 bool Selector::visible = false;
 
 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;
 
 void Selector::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
     if ((button == leftmouseKey) && (!released)) {
     }
 
     static glm::vec3 rayWorld;
+    static glm::vec3 lastIntersectPos, lastIntersectNorm;
+    static unsigned long lastRoom, lastModel;
+    static bool foundSomething = false;
 
     if (workToDo) {
+        // Calculate click ray
         glm::vec2 normalized = glm::vec2((2.0f * lastX) / Window::getSize().x - 1.0f,
                                          1.0f - (2.0f * lastY) / Window::getSize().y);
         glm::vec4 rayClip(normalized.x, normalized.y, -1.0f, 1.0f);
         rayWorld = glm::vec3(glm::inverse(Camera::getViewMatrix()) * rayEye);
         rayWorld = glm::normalize(rayWorld);
         workToDo = false;
+
+        // Check for any intersections with object bounding spheres
+        if (clickOnModels) {
+
+        }
+
+        if (clickOnMeshes) {
+
+        }
+
+        if (clickOnSprites) {
+
+        }
+
+        if (clickOnRoomModels) {
+            for (unsigned long i = 0; i < World::sizeRoom(); i++) {
+                Room& r = World::getRoom(i);
+                for (unsigned long j = 0; j < r.sizeModels(); j++) {
+                    StaticModel& sm = r.getModel(j);
+                    glm::vec3 pos, norm;
+                    if (glm::intersectRaySphere(Camera::getPosition(), rayWorld, sm.getCenter(), sm.getRadius(),
+                                                pos, norm)) {
+                        //! \fixme This is not enough. Should be depth sorted?!
+                        lastRoom = i;
+                        lastModel = j;
+                        lastIntersectPos = pos;
+                        lastIntersectNorm = norm;
+                        foundSomething = true;
+                    }
+                }
+            }
+        }
+
+        if (clickOnRoomSprites) {
+
+        }
+
+        if (clickOnGeometry) {
+
+        }
+    }
+
+    ImGui::SliderFloat("Grab Sphere", &grabSphere, 0.1f, 10240.0f);
+    ImGui::Checkbox("Geometry", &clickOnGeometry);
+    ImGui::SameLine();
+    ImGui::Checkbox("RoomModels", &clickOnRoomModels);
+    ImGui::SameLine();
+    ImGui::Checkbox("RoomSprites", &clickOnRoomSprites);
+    ImGui::Checkbox("Sprites", &clickOnSprites);
+    ImGui::SameLine();
+    ImGui::Checkbox("Meshes", &clickOnMeshes);
+    ImGui::SameLine();
+    ImGui::Checkbox("Models", &clickOnModels);
+    ImGui::SameLine();
+    if (ImGui::Button("Hide Selector")) {
+        visible = false;
     }
+    ImGui::Separator();
+
+    // Not yet implemented!
+    clickOnModels = false;
+    clickOnMeshes = false;
+    clickOnSprites = false;
+    clickOnRoomSprites = false;
+    clickOnGeometry = false;
 
-    ImGui::Text("Screenspace: (%d %d)", lastX, lastY);
     ImGui::Text("Camera: (%.2f %.2f %.2f)", Camera::getPosition().x, Camera::getPosition().y, Camera::getPosition().z);
-    if ((lastX < 0) || (lastY < 0)) {
-        ImGui::Text("Normalized Ray: (? ? ?)");
-    } else {
+    ImGui::Text("Last click: (%d %d)", lastX, lastY);
+    if ((lastX >= 0) && (lastY >= 0)) {
         ImGui::Text("Normalized Ray: (%.3f %.3f %.3f)", rayWorld.x, rayWorld.y, rayWorld.z);
     }
 
-    if (ImGui::Button("Hide Selector")) {
-        visible = false;
+    if (foundSomething) {
+        ImGui::Text("Intersect Pos: (%.2f %.2f %.2f)", lastIntersectPos.x, lastIntersectPos.y, lastIntersectPos.z);
+        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);
     }
 
     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();
+}
+
 void StaticMesh::display(glm::mat4 MVP) {
     World::getMesh(mesh).display(MVP);
 

src/UI.cpp

                          ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize
                          | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings
                          | ImGuiWindowFlags_AlwaysAutoResize)) {
-#ifdef DEBUG
-            ImGui::Text("%d FPS  %lu CPF", RunTime::getFPS(), RunTime::getCallCount());
-#else
             ImGui::Text("%d FPS", RunTime::getFPS());
+
+#ifdef DEBUG
+            ImGui::SameLine();
+            ImGui::Text("%lu CPF", RunTime::getCallCount());
 #endif
 
             ImGui::Text("X: %.1f (%.2f)", Camera::getPosition().x, Camera::getRotation().x);
 
             auto window = ImGui::GetWindowSize();
             auto screen = Window::getSize();
-            //ImGui::SetWindowPos(ImVec2(10, screen.y - window.y - 10));
+            ImGui::SetWindowPos(ImVec2(10, screen.y - window.y - 10));
         }
         ImGui::End();
     }