Can also click on Room Sprites

ChangeLog.md

 
 ## OpenRaider (0.1.4) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20150811 ]
+    * Can click on RoomModels and RoomSprites
+    * This will show their BoundingSpheres
+    * Fixed Mouse Selector Depth Sorting Issue
+    * Improved Room List UI
+
     [ 20150803 ]
     * Started working on ray casting for mouse object selection
 

include/Room.h

     int getNumZSectors() { return numZSectors; }
     int getIndex() { return roomIndex; }
 
-    void addSprite(RoomSprite* s) { sprites.emplace_back(s); }
     void addSector(Sector* s) { sectors.emplace_back(s); }
 
+    void addSprite(RoomSprite* s) { sprites.emplace_back(s); }
+    unsigned long sizeSprites() { return sprites.size(); }
+    RoomSprite& getSprite(unsigned long index) { return *sprites.at(index); }
+
     void addModel(StaticModel* s) { models.emplace_back(s); }
     unsigned long sizeModels() { return models.size(); }
     StaticModel& getModel(unsigned long index) { return *models.at(index); }

include/RoomData.h

   public:
     RoomSprite(glm::vec3 p, int s) : pos(p), sprite(s) { }
     void display(glm::mat4 VP);
+    void displayUI();
+
+    glm::vec3 getCenter();
+    float getRadius();
+    void displayBoundingSphere(glm::mat4 VP, glm::vec3 color);
 
   private:
     glm::vec3 pos;

include/Sprite.h

 
 #include <vector>
 
+#include "BoundingSphere.h"
+
 class Sprite {
   public:
     Sprite(int tile, int x, int y, int width, int height);
 
     int getTexture() { return texture; }
     glm::vec4 getUVs() { return uv2D; }
+    BoundingSphere& getBoundingSphere() { return boundingSphere; }
 
   private:
     int texture;
     std::vector<glm::vec3> vertexBuff;
     std::vector<glm::vec2> uvBuff;
     glm::vec4 uv2D;
+    BoundingSphere boundingSphere;
 };
 
 class SpriteSequence {

include/global.h

     spriteObject,
     meshObject,
     modelObject,
+    entityObject,
 
     WorldObjectCount // Should always be at the end
 } WorldObjects;

src/Room.cpp

  */
 
 #include "global.h"
+#include "Camera.h"
 #include "Log.h"
 #include "Room.h"
 
         ImGui::Text("None");
     }
     ImGui::NextColumn();
+    if (sprites.size() > 0) {
+        if (ImGui::TreeNode("...##sprite")) {
+            for (auto& s : sprites) {
+                s->displayUI();
+            }
+            ImGui::TreePop();
+        }
+    } else {
+        ImGui::Text("None");
+    }
+    ImGui::NextColumn();
+    if (ImGui::Button("Warp")) {
+        Camera::setPosition(pos);
+    }
+    ImGui::NextColumn();
     ImGui::PopID();
 }
 

src/RoomData.cpp

 
 // ----------------------------------------------------------------------------
 
+glm::vec3 RoomSprite::getCenter() {
+    glm::vec3 center = World::getSprite(sprite).getBoundingSphere().getPosition();
+    glm::vec4 tmp = glm::translate(glm::mat4(1.0f), pos) * glm::vec4(center, 1.0f);
+    return glm::vec3(tmp) / tmp.w;
+}
+
+float RoomSprite::getRadius() {
+    return World::getSprite(sprite).getBoundingSphere().getRadius();
+}
+
+void RoomSprite::displayBoundingSphere(glm::mat4 VP, glm::vec3 color) {
+    World::getSprite(sprite).getBoundingSphere().display(VP * glm::translate(glm::mat4(1.0f), pos), color);
+}
+
 void RoomSprite::display(glm::mat4 VP) {
     glm::mat4 translate = glm::translate(glm::mat4(1.0f), pos);
 
     World::getSprite(sprite).display(VP * (translate * rotate));
 }
 
+void RoomSprite::displayUI() {
+    ImGui::Text("Sprite %d", sprite);
+}
+
 // ----------------------------------------------------------------------------
 
 bool Portal::showBoundingBox = false;

src/Selector.cpp

 
 bool Selector::visible = false;
 WorldObjects Selector::lastClickedObject = WorldObjectCount;
-std::array<bool, WorldObjectCount> Selector::clickOnObject = {{ false, true, true, true, false, false }};
+
+// geometryObject, roomSpriteObject, roomModelObject, spriteObject, meshObject, modelObject, entityObject
+std::array<bool, WorldObjectCount> Selector::clickOnObject = {{ false, true, true, false, false, false, false }};
+
 glm::i32vec2 Selector::rayScreen(-1, -1);
 glm::vec3 Selector::rayWorld, Selector::lastIntersectPos, Selector::lastIntersectNorm;
 unsigned long Selector::lastIndexA, Selector::lastIndexB;
         bool foundSomething = false;
         float depth = -1.0f;
 
-        if (clickOnObject[modelObject]) {
-
-        }
-
-        if (clickOnObject[meshObject]) {
-
-        }
-
-        if (clickOnObject[spriteObject]) {
-
-        }
-
-        if (clickOnObject[roomModelObject]) {
+        if (clickOnObject[roomModelObject] || clickOnObject[roomSpriteObject]) {
             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)) {
-                        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;
+                Room& r = World::getRoom(i);
+                glm::vec3 pos, norm;
+
+                if (clickOnObject[roomModelObject]) {
+                    for (unsigned long j = 0; j < r.sizeModels(); j++) {
+                        StaticModel& sm = r.getModel(j);
+                        if (glm::intersectRaySphere(Camera::getPosition(), rayWorld, sm.getCenter(), sm.getRadius(),
+                                                    pos, norm)) {
+                            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 (clickOnObject[roomSpriteObject]) {
-
-        }
-
-        if (clickOnObject[geometryObject]) {
-
 
+                if (clickOnObject[roomSpriteObject]) {
+                    for (unsigned long j = 0; j < r.sizeSprites(); j++) {
+                        RoomSprite& rs = r.getSprite(j);
+                        if (glm::intersectRaySphere(Camera::getPosition(), rayWorld, rs.getCenter(), rs.getRadius(), pos, norm)) {
+                            float newDepth = glm::abs(glm::distance(rs.getCenter(), Camera::getPosition()));
+                            if ((newDepth < depth) || (depth < 0.0f)) {
+                                depth = newDepth;
+                                lastIndexA = i;
+                                lastIndexB = j;
+                                lastIntersectPos = pos;
+                                lastIntersectNorm = norm;
+                                lastClickedObject = roomSpriteObject;
+                                foundSomething = true;
+                            }
+                        }
+                    }
+                }
+            }
         }
 
         if (!foundSomething) {
 void Selector::displaySelection() {
     if (lastClickedObject == roomModelObject) {
         World::getRoom(lastIndexA).getModel(lastIndexB).displayBoundingSphere(Camera::getProjectionMatrix() * Camera::getViewMatrix(), glm::vec3(1.0f, 0.0f, 0.0f));
+    } else if (lastClickedObject == roomSpriteObject) {
+        World::getRoom(lastIndexA).getSprite(lastIndexB).displayBoundingSphere(Camera::getProjectionMatrix() * Camera::getViewMatrix(), glm::vec3(1.0f, 0.0f, 0.0f));
+    } else {
+        lastClickedObject = WorldObjectCount;
     }
 }
 
         return;
     }
 
-    ImGui::Checkbox("Geometry", &clickOnObject[geometryObject]);
-    ImGui::SameLine();
     ImGui::Checkbox("RoomModels", &clickOnObject[roomModelObject]);
     ImGui::SameLine();
     ImGui::Checkbox("RoomSprites", &clickOnObject[roomSpriteObject]);
-    ImGui::Checkbox("Sprites", &clickOnObject[spriteObject]);
-    ImGui::SameLine();
-    ImGui::Checkbox("Meshes", &clickOnObject[meshObject]);
-    ImGui::SameLine();
-    ImGui::Checkbox("Models", &clickOnObject[modelObject]);
     ImGui::SameLine();
     if (ImGui::Button("Hide Selector")) {
         visible = false;
     }
     ImGui::Separator();
 
-    // Not yet implemented!
-    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)", rayScreen.x, rayScreen.y);
     if ((rayScreen.x >= 0) && (rayScreen.y >= 0)) {
     if (lastClickedObject == roomModelObject) {
         ImGui::Text("Last Room: %lu", lastIndexA);
         ImGui::Text("Last RoomModel: %lu", lastIndexB);
+    } else if (lastClickedObject == roomSpriteObject) {
+        ImGui::Text("Last Room: %lu", lastIndexA);
+        ImGui::Text("Last RoomSprite: %lu", lastIndexB);
+    } else {
+        lastClickedObject = WorldObjectCount;
     }
 
     ImGui::End();

src/Sprite.cpp

     vertexBuff.emplace_back(vertexBuff.at(2));
 
     uv2D = glm::vec4(uvBuff.at(0), uvBuff.at(2));
+
+    glm::vec3 average(0.0f, 0.0f, 0.0f);
+    int averageCount = 0;
+    for (auto& vert : vertexBuff) {
+        average += vert;
+        averageCount++;
+    }
+    glm::vec3 center = average / float(averageCount);
+    float radius = 0.0f;
+    for (auto& vert : vertexBuff) {
+        float dist = glm::distance(center, vert);
+        if (dist > radius) radius = dist;
+    }
+    boundingSphere.setPosition(center);
+    boundingSphere.setRadius(radius);
 }
 
 void Sprite::display(glm::mat4 MVP) {

src/World.cpp

     // Rooms
     static bool offsets = false;
     if (ImGui::CollapsingHeader("Rooms")) {
-        ImGui::Columns(6, "rooms");
+        ImGui::Columns(8, "rooms");
         ImGui::Text("No");
         ImGui::NextColumn();
         ImGui::Text("Ind.");
         ImGui::NextColumn();
         ImGui::Text("Portals");
         ImGui::NextColumn();
+        ImGui::Text("Sprites");
+        ImGui::NextColumn();
+        ImGui::Text("Tools");
+        ImGui::NextColumn();
         ImGui::Separator();
         if (!offsets) {
             ImGui::SetColumnOffset(1, 40.0f);
             ImGui::SetColumnOffset(2, 80.0f);
             ImGui::SetColumnOffset(3, 120.0f);
             ImGui::SetColumnOffset(4, 180.0f);
-            ImGui::SetColumnOffset(5, 300.0f);
+            ImGui::SetColumnOffset(5, 250.0f);
+            ImGui::SetColumnOffset(6, 350.0f);
+            ImGui::SetColumnOffset(7, 400.0f);
             offsets = true;
         }
         for (int i = 0; i < rooms.size(); i++) {