update

src/world/scene.cpp

@@ -0,0 +1,91 @@
+#include "scene.h"
+
+Entity *getEntity(Scene *s, uint32 id) {
+    return &s->entities[id - 1];
+}
+
+SceneGraphNode *getSceneGraphNodeForEntity(Scene *s, uint32 entityHandle) {
+    return &s->graphNodes[s->entities[entityHandle - 1].graphNodeHandle - 1];
+}
+
+SceneGraphNode *getSceneGraphNode(Scene *s, uint32 sceneGraphNodeHandle) {
+    return &s->graphNodes[sceneGraphNodeHandle - 1];
+}
+
+uint32 createEntity(Scene *s) {
+    s->entities.emplace_back();
+    s->graphNodes.emplace_back();
+    s->entities.back().graphNodeHandle = (uint32)s->graphNodes.size();
+    s->graphNodes.back().entityHandle = (uint32)s->entities.size();
+    uint32 handle = (uint32)s->entities.size();
+    uint32 graphNodeHandle = (uint32)s->graphNodes.size();
+    initGraphNode(getSceneGraphNode(s, graphNodeHandle));
+    return handle;
+}
+
+uint32 createSceneGraphNode(Scene *s) {
+    s->graphNodes.emplace_back();
+    return (uint32)s->graphNodes.size();
+}
+
+void initGraphNode(SceneGraphNode *n) {
+    n->scale = glm::vec3(1.0f, 1.0f, 1.0f);
+    n->translation = glm::vec3(0.0f, 0.0f, 0.0f);
+    n->rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
+    n->local = glm::mat4(1.0f);
+    n->world = n->local;
+}
+
+void recalcGraphNode(SceneGraphNode *n) {
+    n->local = glm::scale(
+        glm::translate(
+            glm::mat4(1.0f), 
+            n->translation
+        ) * glm::toMat4(n->rotation), 
+        n->scale
+    );
+}
+
+Scene createScene() {
+    Scene result = {};
+    result.sceneRoot = createSceneGraphNode(&result);
+    return result;
+}
+
+void recalcSceneGraphNode(Scene *s, uint32 parentHandle) {
+    SceneGraphNode *node = getSceneGraphNode(s, parentHandle);
+    if (node->entityHandle) {
+        getEntity(s, node->entityHandle)->flags |= EntityFlags_Render;
+    }
+    for (uint32 &nodeId : node->children) {
+        SceneGraphNode *graphNode = getSceneGraphNode(s, nodeId);
+        graphNode->parentHandle = parentHandle;
+        recalcGraphNode(graphNode);
+        graphNode->world = node->world * graphNode->local;
+        recalcSceneGraphNode(s, nodeId);
+    }
+}
+
+void recalcScene(Scene *s) {
+    recalcSceneGraphNode(s, s->sceneRoot);
+}
+
+void removeEntity(Scene *s, uint32 entityHandle) {
+    Entity *entity = getEntity(s, entityHandle);
+    entity->flags |= EntityFlags_Dead;
+    SceneGraphNode *graphNode = getSceneGraphNode(s, entity->graphNodeHandle);
+    if (graphNode->parentHandle) {
+        SceneGraphNode *parentNode = getSceneGraphNode(s, graphNode->parentHandle);
+        for (int i = 0; i < parentNode->children.size(); i++) {
+            if (parentNode->children.at(i) == entityHandle) {
+                parentNode->children.erase(parentNode->children.begin() + i);
+                graphNode->parentHandle = 0;
+                break;
+            }
+        }
+    }
+}
+
+void sceneNodeAddEntity(Scene *s, uint32 graphNodeHandle, uint32 entityHandle) {
+    getSceneGraphNode(s, graphNodeHandle)->children.push_back(getEntity(s, entityHandle)->graphNodeHandle);
+}

src/world/scene.h

@@ -0,0 +1,47 @@
+#include <vector>
+#include "glm/glm.hpp"
+#include <glm/gtx/quaternion.hpp>
+#include "../gfx/gfx.h"
+
+enum EntityFlags {
+    EntityFlags_Visible=1<<0,
+    EntityFlags_Dead=1<<1,
+    EntityFlags_Render=1<<2,
+}; 
+
+struct Entity {
+    Mesh *mesh;
+    Texture *tex;
+    uint32 graphNodeHandle;
+    uint64 flags;
+};
+
+struct SceneGraphNode {
+    glm::mat4 local;
+    glm::mat4 world;
+    glm::vec3 translation;
+    glm::quat rotation;
+    glm::vec3 scale;
+    std::vector<uint32> children;
+    uint32 entityHandle;
+    uint32 parentHandle;
+};
+
+struct Scene {
+    uint32 sceneRoot;
+    std::vector<Entity> entities;
+    std::vector<SceneGraphNode> graphNodes;
+};
+
+uint32 createEntity(Scene *s);
+Entity *getEntity(Scene *s);
+SceneGraphNode *getSceneGraphNode(Scene *s, int id); 
+uint32 createSceneGraphNode(Scene *s);
+Scene createScene(Scene *s);
+void initGraphNode(SceneGraphNode *n); 
+void recalcGraphNode(SceneGraphNode *n);
+void recalcSceneGraphNode(Scene *s, uint32 parentHandle);
+void recalcScene(Scene *s);
+void removeEntity(Scene *s, uint32 entityHandle);
+void sceneNodeAddEntity(Scene *s, uint32 graphNodeHandle, uint32 entityHandle);
+SceneGraphNode *getSceneGraphNodeForEntity(Scene *s, uint32 entityHandle);

src/world/world.cpp

@@ -0,0 +1 @@
+#include "scene.cpp"