Improved Selector, fixed depth sorting issue

include/BoundingSphere.h

 
 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) { }
+    BoundingSphere(glm::vec3 p = glm::vec3(0.0f, 0.0f, 0.0f), float r = 100.0f, int res = 42) : pos(p), radius(r), resolution(res) { }
 
     void setPosition(glm::vec3 p) { pos = p; }
     glm::vec3 getPosition() { return pos; }

include/Selector.h

 #ifndef _SELECTOR_H_
 #define _SELECTOR_H_
 
+#include <array>
+
 class Selector {
   public:
+    static void displaySelection();
     static void display();
 
     static bool isVisible() { return visible; }
 
   private:
     static bool visible;
+    static WorldObjects lastClickedObject;
+    static std::array<bool, WorldObjectCount> clickOnObject;
+    static glm::i32vec2 rayScreen;
+    static glm::vec3 rayWorld, lastIntersectPos, lastIntersectNorm;
+    static unsigned long lastIndexA, lastIndexB;
 };
 
 #endif

include/global.h

 
 void renderFrame();
 
+typedef enum {
+    geometryObject = 0,
+    roomSpriteObject,
+    roomModelObject,
+    spriteObject,
+    meshObject,
+    modelObject,
+
+    WorldObjectCount // Should always be at the end
+} WorldObjects;
+
 // Actions that can be bound to a key and sent to the game engine
 typedef enum {
     menuAction = 0,

src/Render.cpp

 #include "Camera.h"
 #include "Log.h"
 #include "Menu.h"
+#include "Selector.h"
 #include "StaticMesh.h"
 #include "World.h"
 #include "system/Shader.h"
     if (displayViewFrustum)
         Camera::displayFrustum(VP);
 
+    Selector::displaySelection();
+
     BoundingBox::display();
     BoundingSphere::display();
 

src/Selector.cpp

 #include <glm/gtx/intersect.hpp>
 
 bool Selector::visible = false;
-
-static int lastX = -1, lastY = -1;
-static bool workToDo = false;
-static bool clickOnGeometry = false, clickOnRoomModels = true, clickOnRoomSprites = true;
-static bool clickOnSprites = true, clickOnMeshes = false, clickOnModels = false;
+WorldObjects Selector::lastClickedObject = WorldObjectCount;
+std::array<bool, WorldObjectCount> Selector::clickOnObject = {{ false, true, true, true, false, false }};
+glm::i32vec2 Selector::rayScreen(-1, -1);
+glm::vec3 Selector::rayWorld, Selector::lastIntersectPos, Selector::lastIntersectNorm;
+unsigned long Selector::lastIndexA, Selector::lastIndexB;
 
 void Selector::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
     if ((button == leftmouseKey) && (!released)) {
-        lastX = x;
-        lastY = y;
-
-        if (workToDo) {
-            Log::get(LOG_DEBUG) << "Selector missed mouse click event!" << Log::endl;
-        }
-
-        workToDo = true;
-    }
-}
-
-void Selector::display() {
-    if (!visible)
-        return;
-
-    if (!ImGui::Begin("Object Selector", &visible, ImVec2(500, 200))) {
-        ImGui::End();
-        return;
-    }
-
-    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);
+        rayScreen = glm::vec2(x, y);
+        glm::vec2 normalized = glm::vec2((2.0f * rayScreen.x) / Window::getSize().x - 1.0f,
+                                         1.0f - (2.0f * rayScreen.y) / Window::getSize().y);
         glm::vec4 rayClip(normalized.x, normalized.y, -1.0f, 1.0f);
         glm::vec4 rayEye(glm::inverse(Camera::getProjectionMatrix()) * rayClip);
         rayEye = glm::vec4(rayEye.x, rayEye.y, -1.0f, 0.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) {
+        bool foundSomething = false;
+        float depth = -1.0f;
+
+        if (clickOnObject[modelObject]) {
 
         }
 
-        if (clickOnMeshes) {
+        if (clickOnObject[meshObject]) {
 
         }
 
-        if (clickOnSprites) {
+        if (clickOnObject[spriteObject]) {
 
         }
 
-        if (clickOnRoomModels) {
+        if (clickOnObject[roomModelObject]) {
             for (unsigned long i = 0; i < World::sizeRoom(); i++) {
-                Room& r = World::getRoom(i);
+                Room &r = World::getRoom(i);
                 for (unsigned long j = 0; j < r.sizeModels(); j++) {
-                    StaticModel& sm = r.getModel(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;
+                        float newDepth = glm::abs(glm::distance(sm.getCenter(), Camera::getPosition()));
+                        if ((newDepth < depth) || (depth < 0.0f)) {
+                            depth = newDepth;
+                            lastIndexA = i;
+                            lastIndexB = j;
+                            lastIntersectPos = pos;
+                            lastIntersectNorm = norm;
+                            lastClickedObject = roomModelObject;
+                            foundSomething = true;
+                        }
                     }
                 }
             }
         }
 
-        if (clickOnRoomSprites) {
+        if (clickOnObject[roomSpriteObject]) {
 
         }
 
-        if (clickOnGeometry) {
+        if (clickOnObject[geometryObject]) {
 
+
+        }
+
+        if (!foundSomething) {
+            lastClickedObject = WorldObjectCount;
         }
     }
+}
 
-    ImGui::Checkbox("Geometry", &clickOnGeometry);
+void Selector::displaySelection() {
+    if (lastClickedObject == roomModelObject) {
+        World::getRoom(lastIndexA).getModel(lastIndexB).displayBoundingSphere(Camera::getProjectionMatrix() * Camera::getViewMatrix(), glm::vec3(1.0f, 0.0f, 0.0f));
+    }
+}
+
+void Selector::display() {
+    if (!visible)
+        return;
+
+    if (!ImGui::Begin("Object Selector", &visible, ImVec2(500, 200))) {
+        ImGui::End();
+        return;
+    }
+
+    ImGui::Checkbox("Geometry", &clickOnObject[geometryObject]);
     ImGui::SameLine();
-    ImGui::Checkbox("RoomModels", &clickOnRoomModels);
+    ImGui::Checkbox("RoomModels", &clickOnObject[roomModelObject]);
     ImGui::SameLine();
-    ImGui::Checkbox("RoomSprites", &clickOnRoomSprites);
-    ImGui::Checkbox("Sprites", &clickOnSprites);
+    ImGui::Checkbox("RoomSprites", &clickOnObject[roomSpriteObject]);
+    ImGui::Checkbox("Sprites", &clickOnObject[spriteObject]);
     ImGui::SameLine();
-    ImGui::Checkbox("Meshes", &clickOnMeshes);
+    ImGui::Checkbox("Meshes", &clickOnObject[meshObject]);
     ImGui::SameLine();
-    ImGui::Checkbox("Models", &clickOnModels);
+    ImGui::Checkbox("Models", &clickOnObject[modelObject]);
     ImGui::SameLine();
     if (ImGui::Button("Hide Selector")) {
         visible = false;
     ImGui::Separator();
 
     // Not yet implemented!
-    clickOnModels = false;
-    clickOnMeshes = false;
-    clickOnSprites = false;
-    clickOnRoomSprites = false;
-    clickOnGeometry = false;
+    clickOnObject[modelObject] = false;
+    clickOnObject[meshObject] = false;
+    clickOnObject[spriteObject] = false;
+    clickOnObject[roomSpriteObject] = false;
+    clickOnObject[geometryObject] = false;
 
     ImGui::Text("Camera: (%.2f %.2f %.2f)", Camera::getPosition().x, Camera::getPosition().y, Camera::getPosition().z);
-    ImGui::Text("Last click: (%d %d)", lastX, lastY);
-    if ((lastX >= 0) && (lastY >= 0)) {
+    ImGui::Text("Last click: (%d %d)", rayScreen.x, rayScreen.y);
+    if ((rayScreen.x >= 0) && (rayScreen.y >= 0)) {
         ImGui::Text("Normalized Ray: (%.3f %.3f %.3f)", rayWorld.x, rayWorld.y, rayWorld.z);
     }
 
-    if (foundSomething) {
+    if (lastClickedObject != WorldObjectCount) {
         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);
+    }
 
-        World::getRoom(lastRoom).getModel(lastModel).displayBoundingSphere(Camera::getProjectionMatrix() * Camera::getViewMatrix(), glm::vec3(1.0f, 0.0f, 0.0f));
+    if (lastClickedObject == roomModelObject) {
+        ImGui::Text("Last Room: %lu", lastIndexA);
+        ImGui::Text("Last RoomModel: %lu", lastIndexB);
     }
 
     ImGui::End();