Started work on Entity system

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140124 ]
+    * Started working on Entity system.
+
     [ 20140118 ]
     * Added ability to visualize font _outline_.
     * Updated imgui to newest version, now with its own TTF support.

include/Entity.h

 #ifndef _ENTITY_H_
 #define _ENTITY_H_
 
-#include "SkeletalModel.h"
-
 class Entity {
   public:
-    typedef enum {
-        MoveTypeWalkNoSwim = -1,
-        MoveTypeWalk       = 0,
-        MoveTypeNoClipping = 1,
-        MoveTypeFly        = 2,
-        MoveTypeSwim       = 3
-    } MoveType;
-
-    Entity(float p[3], float a[3], int id, long r, unsigned int model);
-
-    void display();
-    void move(char movement);
-    void print();
-
-    SkeletalModel& getModel();
-    void setSkeletalModel(unsigned int model);
-    MoveType getMoveType();
-    void setMoveType(MoveType m);
-    int getObjectId();
-    void setAngles(float a[3]);
-    float getPos(unsigned int i);
-    float getAngle(unsigned int i);
-    long getRoom();
-
-    // Animation State
-    unsigned long getAnimation();
-    void setAnimation(unsigned long index);
-    unsigned long getBoneFrame();
-    void setBoneFrame(unsigned long index);
-    unsigned long getIdleAnimation();
-    void setIdleAnimation(unsigned long index);
+    Entity(int i, int r, glm::vec3 po, glm::vec3 ro)
+        : id(i), room(r), pos(po), rot(ro), cache(-1), cacheType(-1),
+        sprite(0), animation(0), frame(0) { }
+    void display(glm::mat4 VP);
+
+    int getID() { return id; }
+    int getRoom() { return room; }
+    glm::vec3 getPosition() { return pos; }
+    glm::vec3 getRotation() { return rot; }
+
+    int getSprite() { return sprite; }
+    void setSprite(int i) { sprite = i; }
+    int getAnimation() { return animation; }
+    void setAnimation(int i) { animation = i; frame = 0; }
+    int getFrame() { return frame; }
+    void setFrame(int i) { frame = i; }
+
+    static void setShowEntitySprites(bool s) { showEntitySprites = s; }
+    static bool getShowEntitySprites() { return showEntitySprites; }
+    static void setShowEntityMeshes(bool s) { showEntityMeshes = s; }
+    static bool getShowEntityMeshes() { return showEntityMeshes; }
+    static void setShowEntityModels(bool s) { showEntityModels = s; }
+    static bool getShowEntityModels() { return showEntityModels; }
 
   private:
-    float pos[3];
-    float angles[3];
-    long room;
-
-    unsigned int skeletalModel;
-    MoveType moveType;
-
-    int state;
-    int objectId;
-
-    // Animation State
-    unsigned long boneFrame;
-    unsigned long animationFrame;
-    unsigned long idleAnimation;
+    int id;
+    int room;
+    glm::vec3 pos;
+    glm::vec3 rot;
+    int cache, cacheType;
+
+    int sprite;
+    int animation;
+    int frame;
+
+    static bool showEntitySprites;
+    static bool showEntityMeshes;
+    static bool showEntityModels;
 };
 
 #endif

include/Room.h

 class Room {
   public:
     Room(glm::vec3 _pos, BoundingBox* _bbox, RoomMesh* _mesh, unsigned int f,
-         int a, int x, int z);
+         int a, int x, int z, int i);
 
     void prepare() { mesh->prepare(); }
     void display(glm::mat4 VP);
     BoundingBox& getBoundingBox() { return *bbox; }
     RoomMesh& getMesh() { return *mesh; }
 
-    unsigned int getNumXSectors() { return numXSectors; }
-    unsigned int getNumZSectors() { return numZSectors; }
-
     unsigned int getFlags() { return flags; }
+    int getAlternateRoom() { return alternateRoom; }
+    int getNumXSectors() { return numXSectors; }
+    int getNumZSectors() { return numZSectors; }
+    int getIndex() { return roomIndex; }
 
     void addSprite(RoomSprite* s) { sprites.emplace_back(s); }
     void addModel(StaticModel* s) { models.emplace_back(s); }
     int alternateRoom;
     int numXSectors;
     int numZSectors;
+    int roomIndex;
 
     std::vector<std::unique_ptr<RoomSprite>> sprites;
     std::vector<std::unique_ptr<StaticModel>> models;

include/SkeletalModel.h

   public:
     SkeletalModel(int i) : id(i) { }
     ~SkeletalModel();
-    void display(unsigned long aframe, unsigned long bframe);
+    void display(glm::mat4 MVP, int aframe, int bframe);
 
-    int getId() { return id; }
+    int getID() { return id; }
 
     unsigned long size();
     AnimationFrame& get(unsigned long i);

include/Sprite.h

   public:
     SpriteSequence(int objectID, int offset, int size)
         : id(objectID), start(offset), length(size) { }
+    void display(glm::mat4 MVP, int index);
+
+    int getID() { return id; }
 
   private:
     int id;

include/commands/CommandGame.h

-/*!
- * \file include/commands/CommandGame.h
- * \brief Game Command interface
- *
- * \author xythobuz
- */
-
-#ifndef _COMMAND_GAME_H_
-#define _COMMAND_GAME_H_
-
-#include "commands/Command.h"
-
-class CommandPos : public Command {
-  public:
-    virtual std::string name();
-    virtual std::string brief();
-    virtual int execute(std::istream& args);
-};
-
-class CommandViewmodel : public Command {
-  public:
-    virtual std::string name();
-    virtual std::string brief();
-    virtual int execute(std::istream& args);
-};
-
-#endif
-

include/commands/CommandMove.h

-/*!
- * \file include/commands/CommandMove.h
- * \brief Move Command interface
- *
- * \author xythobuz
- */
-
-#ifndef _COMMAND_MOVE_H_
-#define _COMMAND_MOVE_H_
-
-#include "commands/Command.h"
-
-class CommandMove : public Command {
-  public:
-    virtual std::string name();
-    virtual std::string brief();
-    virtual void printHelp();
-    virtual int execute(std::istream& args);
-};
-
-#endif
-

include/commands/CommandRender.h

-/*!
- * \file include/commands/CommandRender.h
- * \brief Render Command interface
- *
- * \author xythobuz
- */
-
-#ifndef _COMMAND_RENDER_H_
-#define _COMMAND_RENDER_H_
-
-#include "commands/Command.h"
-
-class CommandMode : public Command {
-  public:
-    virtual std::string name();
-    virtual std::string brief();
-    virtual void printHelp();
-    virtual int execute(std::istream& args);
-};
-
-#endif
-

src/Camera.cpp

 const static float fov = 45.0f;
 const static float nearDist = 0.1f;
 const static float farDist = 75000.0f;
-const static float maxSpeed = 2048.0f;
+const static float maxSpeed = 3072.0f;
 const static float controllerViewFactor = glm::pi<float>();
 const static float controllerDeadZone = 0.1f;
 

src/Entity.cpp

  */
 
 #include "global.h"
+#include "Camera.h"
 #include "Log.h"
 #include "World.h"
 #include "Entity.h"
 
-Entity::Entity(float p[3], float a[3], int id, long r, unsigned int model) {
-    for (int i = 0; i < 3; i++) {
-        pos[i] = p[i];
-        angles[i] = a[i];
+#include <glm/gtc/matrix_transform.hpp>
+
+#define CACHE_SPRITE 0
+#define CACHE_MESH 1
+#define CACHE_MODEL 2
+
+bool Entity::showEntitySprites = true;
+bool Entity::showEntityMeshes = true;
+bool Entity::showEntityModels = true;
+
+void Entity::display(glm::mat4 VP) {
+    if ((cache == -1) || (cacheType == -1)) {
+        for (int i = 0; i < getWorld().sizeSpriteSequence(); i++) {
+            auto& s = getWorld().getSpriteSequence(i);
+            if (s.getID() == id) {
+                cacheType = CACHE_SPRITE;
+                cache = i;
+                break;
+            }
+        }
+
+        for (int i = 0; (i < getWorld().sizeStaticMesh()) && (cache == -1); i++) {
+            auto& s = getWorld().getStaticMesh(i);
+            if (s.getID() == id) {
+                cacheType = CACHE_MESH;
+                cache = i;
+                break;
+            }
+        }
+
+        for (int i = 0; (i < getWorld().sizeSkeletalModel()) && (cache == -1); i++) {
+            auto& s = getWorld().getSkeletalModel(i);
+            if (s.getID() == id) {
+                cacheType = CACHE_MODEL;
+                cache = i;
+                break;
+            }
+        }
+
+        assert(cache > -1);
+        assert(cacheType > -1);
     }
-    objectId = id;
-    moveType = MoveTypeWalk;
-    room = r;
-    skeletalModel = model;
-    boneFrame = 0;
-    animationFrame = 0;
-    idleAnimation = 0;
-    state = 0;
-}
-
-void Entity::display() {
-    /*
-    glPushMatrix();
-    glTranslatef(pos[0], pos[1], pos[2]);
-    glRotatef(glm::degrees(angles[1]), 0, 1, 0);
-    glRotatef(glm::degrees(angles[0]), 1, 0, 0);
-    //glRotatef(glm::degrees(angles[2]), 0, 0, 1);
-    getWorld().getSkeletalModel(skeletalModel).display(animationFrame, boneFrame);
-    glPopMatrix();
-    */
-}
-
-void Entity::move(char movement) {
-
-}
-
-void Entity::print() {
-    Log::get(LOG_INFO) << "Entity " << objectId << ":" << Log::endl
-                       << "  Room " << room << " (" << getWorld().getRoom(room).getFlags()
-                       << ")" << Log::endl
-                       << "  " << pos[0] << "x " << pos[1] << "y " << pos[2] << "z"
-                       << Log::endl
-                       << "  " << glm::degrees(angles[1]) << " Yaw" << Log::endl;
-}
-
-SkeletalModel& Entity::getModel() {
-    return getWorld().getSkeletalModel(skeletalModel);
-}
-
-void Entity::setSkeletalModel(unsigned int model) {
-    skeletalModel = model;
-    animationFrame = 0;
-    boneFrame = 0;
-    idleAnimation = 0;
-}
-
-Entity::MoveType Entity::getMoveType() {
-    return moveType;
-}
-
-void Entity::setMoveType(MoveType m) {
-    moveType = m;
-}
-
-int Entity::getObjectId() {
-    return objectId;
-}
-
-void Entity::setAngles(float a[3]) {
-    for (unsigned int i = 0; i < 3; i++)
-        angles[i] = a[i];
-}
-
-float Entity::getPos(unsigned int i) {
-    return pos[i];
-}
-
-float Entity::getAngle(unsigned int i) {
-    return angles[i];
-}
 
-long Entity::getRoom() {
-    return room;
-}
-
-unsigned long Entity::getAnimation() {
-    return animationFrame;
-}
-
-void Entity::setAnimation(unsigned long index) {
-    animationFrame = index;
-    boneFrame = 0;
-}
-
-unsigned long Entity::getBoneFrame() {
-    return boneFrame;
-}
-
-void Entity::setBoneFrame(unsigned long index) {
-    boneFrame = index;
-}
-
-unsigned long Entity::getIdleAnimation() {
-    return idleAnimation;
-}
-
-void Entity::setIdleAnimation(unsigned long index) {
-    idleAnimation = index;
+    glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(pos.x, -pos.y, pos.z));
+    glm::mat4 rotate;
+    if (cacheType == 0) {
+        rotate = glm::rotate(glm::mat4(1.0f), Camera::getRotation().x, glm::vec3(0.0f, 1.0f, 0.0f));
+    } else {
+        rotate = glm::rotate(glm::mat4(1.0f), rot.y, glm::vec3(0.0f, 1.0f, 0.0f));
+    }
+    glm::mat4 model = translate * rotate;
+    glm::mat4 MVP = VP * model;
+
+    if (cacheType == CACHE_SPRITE) {
+        if (showEntitySprites)
+            getWorld().getSpriteSequence(cache).display(MVP, sprite);
+    } else if (cacheType == CACHE_MESH) {
+        if (showEntityMeshes)
+            getWorld().getStaticMesh(cache).display(MVP);
+    } else if (cacheType == CACHE_MODEL) {
+        if (showEntityModels)
+            getWorld().getSkeletalModel(cache).display(MVP, animation, frame);
+    } else {
+        assert(false && "This should not happen...");
+    }
 }
 

src/Game.cpp

             Console::setVisible(true);
             UI::setVisible(true);
         } else {
-            Camera::setPosition(glm::vec3(getLara().getPos(0),
-                                          getLara().getPos(1) - 1024.0f,
-                                          getLara().getPos(2)));
+            Camera::setPosition(glm::vec3(getLara().getPosition().x,
+                                          getLara().getPosition().y - 1024.0f,
+                                          getLara().getPosition().z));
         }
     } else {
         Log::get(LOG_ERROR) << "No suitable loader for this level!" << Log::endl;

src/Render.cpp

 
     for (int r = roomList.size() - 1; r >= 0; r--) {
         roomList.at(r)->display(VP);
+
+        for (int i = 0; i < getWorld().sizeEntity(); i++) {
+            auto& e = getWorld().getEntity(i);
+            if (roomList.at(r)->getIndex() == e.getRoom()) {
+                e.display(VP);
+            }
+        }
     }
 
     if (displayViewFrustum)
             Room::setShowRoomSprites(showRoomSprites);
         }
 
+        bool showEntitySprites = Entity::getShowEntitySprites();
+        if (ImGui::Checkbox("Entity Sprites##render", &showEntitySprites)) {
+            Entity::setShowEntitySprites(showEntitySprites);
+        }
+        ImGui::SameLine();
+        bool showEntityMeshes = Entity::getShowEntityMeshes();
+        if (ImGui::Checkbox("Entity Meshes##render", &showEntityMeshes)) {
+            Entity::setShowEntityMeshes(showEntityMeshes);
+        }
+        ImGui::SameLine();
+        bool showEntityModels = Entity::getShowEntityModels();
+        if (ImGui::Checkbox("Entity Models##render", &showEntityModels)) {
+            Entity::setShowEntityModels(showEntityModels);
+        }
+
         ImGui::Separator();
         if (ImGui::Button("New Splash##render")) {
             TextureManager::initializeSplash();

src/Room.cpp

 bool Room::showRoomGeometry = true;
 
 Room::Room(glm::vec3 _pos, BoundingBox* _bbox, RoomMesh* _mesh, unsigned int f,
-           int a, int x, int z) : pos(_pos), bbox(_bbox), mesh(_mesh), flags(f),
-    alternateRoom(a), numXSectors(x), numZSectors(z) {
+           int a, int x, int z, int i) : pos(_pos), bbox(_bbox), mesh(_mesh), flags(f),
+    alternateRoom(a), numXSectors(x), numZSectors(z), roomIndex(i) {
     model = glm::translate(glm::mat4(1.0f), pos);
 }
 

src/SkeletalModel.cpp

         delete animation[i];
 }
 
-void SkeletalModel::display(unsigned long aframe, unsigned long bframe) {
+void SkeletalModel::display(glm::mat4 MVP, int aframe, int bframe) {
     /*
     assert(aframe < size());
     assert(bframe < get(aframe).size());

src/Sprite.cpp

 #include "Camera.h"
 #include "Render.h"
 #include "TextureManager.h"
+#include "World.h"
 #include "Sprite.h"
 
 const static float scale = 4.0f;
     Shader::drawGL(vertices, uvs, texture, MVP);
 }
 
+// ----------------------------------------------------------------------------
+
+void SpriteSequence::display(glm::mat4 MVP, int index) {
+    assert(index >= 0);
+    assert(index < length);
+    getWorld().getSprite(start + index).display(MVP);
+}
+

src/World.cpp

 void World::destroy() {
     mRooms.clear();
     mSprites.clear();
+    mSpriteSequences.clear();
     mEntities.clear();
     mModels.clear();
     mStaticMeshes.clear();

src/commands/CMakeLists.txt

 set (CMD_SRCS ${CMD_SRCS} "Command.cpp" "../../include/commands/Command.h")
 set (CMD_SRCS ${CMD_SRCS} "CommandBind.cpp" "../../include/commands/CommandBind.h")
 set (CMD_SRCS ${CMD_SRCS} "CommandEngine.cpp" "../../include/commands/CommandEngine.h")
-set (CMD_SRCS ${CMD_SRCS} "CommandGame.cpp" "../../include/commands/CommandGame.h")
-set (CMD_SRCS ${CMD_SRCS} "CommandMove.cpp" "../../include/commands/CommandMove.h")
-set (CMD_SRCS ${CMD_SRCS} "CommandRender.cpp" "../../include/commands/CommandRender.h")
 set (CMD_SRCS ${CMD_SRCS} "CommandSet.cpp" "../../include/commands/CommandSet.h")
 
 # Add library

src/commands/Command.cpp

 #include "commands/Command.h"
 #include "commands/CommandBind.h"
 #include "commands/CommandEngine.h"
-#include "commands/CommandGame.h"
-#include "commands/CommandMove.h"
-#include "commands/CommandRender.h"
 #include "commands/CommandSet.h"
 
 std::vector<std::shared_ptr<Command>> Command::commands;
 
 void Command::fillCommandList() {
     commands.clear();
-    commands.push_back(std::shared_ptr<Command>(new CommandLoad()));
     commands.push_back(std::shared_ptr<Command>(new CommandBind()));
+    commands.push_back(std::shared_ptr<Command>(new CommandLoad()));
     commands.push_back(std::shared_ptr<Command>(new CommandSet()));
     commands.push_back(std::shared_ptr<Command>(new CommandGet()));
     commands.push_back(std::shared_ptr<Command>(new CommandScreenshot()));
-    commands.push_back(std::shared_ptr<Command>(new CommandMove()));
-    commands.push_back(std::shared_ptr<Command>(new CommandMode()));
-    commands.push_back(std::shared_ptr<Command>(new CommandPos()));
-    commands.push_back(std::shared_ptr<Command>(new CommandViewmodel()));
     commands.push_back(std::shared_ptr<Command>(new CommandQuit()));
 }
 

src/commands/CommandGame.cpp

-/*!
- * \file src/commands/CommandGame.cpp
- * \brief Game meta-commands
- *
- * \author xythobuz
- */
-
-#include "global.h"
-#include "Game.h"
-#include "Log.h"
-#include "RunTime.h"
-#include "World.h"
-#include "commands/CommandGame.h"
-
-std::string CommandPos::name() {
-    return "pos";
-}
-
-std::string CommandPos::brief() {
-    return "Print position info";
-}
-
-int CommandPos::execute(std::istream& args) {
-    if ((!RunTime::isRunning()) || (!Game::isLoaded())) {
-        Log::get(LOG_USER) << "Use pos command interactively!" << Log::endl;
-        return -1;
-    }
-
-    Game::getLara().print();
-    return 0;
-}
-
-// --------------------------------------
-
-std::string CommandViewmodel::name() {
-    return "viewmodel";
-}
-
-std::string CommandViewmodel::brief() {
-    return "INT - Change Laras model";
-}
-
-int CommandViewmodel::execute(std::istream& args) {
-    if ((!RunTime::isRunning()) || (!Game::isLoaded())) {
-        Log::get(LOG_USER) << "Use viewmodel command interactively!" << Log::endl;
-        return -1;
-    }
-
-    //! \fixme Validate input
-
-    std::string s;
-    args >> s;
-    unsigned int n = atoi(s.c_str());
-
-    if (n < getWorld().sizeSkeletalModel()) {
-        Game::getLara().setSkeletalModel(n);
-        return 0;
-    } else {
-        Log::get(LOG_USER) << "Invalid SkeletalModel index!" << Log::endl;
-        return -2;
-    }
-}
-

src/commands/CommandMove.cpp

-/*!
- * \file src/commands/CommandMove.cpp
- * \brief Move command
- *
- * \author xythobuz
- */
-
-#include "global.h"
-#include "Game.h"
-#include "Log.h"
-#include "RunTime.h"
-#include "commands/CommandMove.h"
-
-std::string CommandMove::name() {
-    return "move";
-}
-
-std::string CommandMove::brief() {
-    return "[walk|fly|noclip]";
-}
-
-void CommandMove::printHelp() {
-    Log::get(LOG_USER) << "move-Command Usage:" << Log::endl;
-    Log::get(LOG_USER) << "  move COMMAND" << Log::endl;
-    Log::get(LOG_USER) << "Where COMMAND is one of the following:" << Log::endl;
-    Log::get(LOG_USER) << "  walk" << Log::endl;
-    Log::get(LOG_USER) << "  fly" << Log::endl;
-    Log::get(LOG_USER) << "  noclip" << Log::endl;
-}
-
-int CommandMove::execute(std::istream& args) {
-    if ((!RunTime::isRunning()) || (!Game::isLoaded())) {
-        Log::get(LOG_USER) << "Use move command interactively!" << Log::endl;
-        return -1;
-    }
-
-    std::string s;
-    args >> s;
-    if (s.compare("walk") == 0) {
-        Game::getLara().setMoveType(Entity::MoveTypeWalk);
-    } else if (s.compare("fly") == 0) {
-        Game::getLara().setMoveType(Entity::MoveTypeFly);
-    } else if (s.compare("noclip") == 0) {
-        Game::getLara().setMoveType(Entity::MoveTypeNoClipping);
-    } else {
-        Log::get(LOG_USER) << "Invalid use of move command (" << s << ")!" << Log::endl;
-        return -2;
-    }
-
-    Log::get(LOG_USER) << s  << "ing" << Log::endl;
-    return 0;
-}
-

src/commands/CommandRender.cpp

-/*!
- * \file src/commands/CommandRender.cpp
- * \brief Renderer commands
- *
- * \author xythobuz
- */
-
-#include "global.h"
-#include "Log.h"
-#include "Render.h"
-#include "commands/CommandRender.h"
-
-std::string CommandMode::name() {
-    return "mode";
-}
-
-std::string CommandMode::brief() {
-    return "MODE - Render mode";
-}
-
-void CommandMode::printHelp() {
-    Log::get(LOG_USER) << "mode-Command Usage:" << Log::endl;
-    Log::get(LOG_USER) << "  mode MODE" << Log::endl;
-    Log::get(LOG_USER) << "Where MODE is one of the following:" << Log::endl;
-    Log::get(LOG_USER) << "  wireframe" << Log::endl;
-    Log::get(LOG_USER) << "  solid" << Log::endl;
-    Log::get(LOG_USER) << "  texture" << Log::endl;
-    Log::get(LOG_USER) << "  titlescreen" << Log::endl;
-
-}
-
-int CommandMode::execute(std::istream& args) {
-    std::string s;
-    args >> s;
-
-    if (s == "wireframe") {
-        Render::setMode(RenderMode::Wireframe);
-        Log::get(LOG_USER) << "Wireframe mode" << Log::endl;
-    } else if (s == "solid") {
-        Render::setMode(RenderMode::Solid);
-        Log::get(LOG_USER) << "Solid mode" << Log::endl;
-    } else if (s == "texture") {
-        Render::setMode(RenderMode::Texture);
-        Log::get(LOG_USER) << "Texture Mode" << Log::endl;
-    } else if (s == "titlescreen") {
-        Render::setMode(RenderMode::LoadScreen);
-        Log::get(LOG_USER) << "Titlescreen mode" << Log::endl;
-    } else {
-        Log::get(LOG_USER) << "Invalid use of mode command (" << s << ")!" << Log::endl;
-        return -2;
-    }
-
-    return 0;
-}
-

src/loader/LoaderTR2.cpp

         BoundingBox* boundingbox = new BoundingBox(bbox[0], bbox[1]);
         RoomMesh* mesh = new RoomMesh(vertices, rectangles, triangles);
         Room* room = new Room(pos, boundingbox, mesh, roomFlags, alternateRoom,
-                              numXSectors, numZSectors);
+                              numXSectors, numZSectors, i);
 
         for (auto p : portals)
             room->addPortal(p);
         // 0x3E00 - Activation mask, open, can be XORed with related FloorData list fields.
         uint16_t flags = file.readU16();
 
-        // TODO for now we're only creating Entities for each Moveable Item
-        for (int m = 0; m < getWorld().sizeSkeletalModel(); m++) {
-            if (getWorld().getSkeletalModel(m).getId() == objectID) {
-                float pos[3] = {
-                    static_cast<float>(x),
-                    static_cast<float>(y),
-                    static_cast<float>(z)
-                };
-
-                float rot[3] = {
-                    0.0f,
-                    glm::radians(((angle >> 14) & 0x03) * 90.0f),
-                    0.0f
-                };
-
-                Entity* e = new Entity(pos, rot, objectID, room, m);
-                getWorld().addEntity(e);
-
-                if (objectID == 0) {
-                    Game::setLara(getWorld().sizeEntity() - 1);
-                }
-            }
+        glm::vec3 pos(
+            static_cast<float>(x),
+            static_cast<float>(y),
+            static_cast<float>(z)
+        );
+
+        glm::vec3 rot(
+            0.0f,
+            glm::radians(((angle >> 14) & 0x03) * 90.0f),
+            0.0f
+        );
+
+        Entity* e = new Entity(objectID, room, pos, rot);
+        getWorld().addEntity(e);
+
+        if (objectID == 0) {
+            Game::setLara(getWorld().sizeEntity() - 1);
         }
     }