Crudely caching model matrix calculations, work in progress.

Tobbe sa att jag fick pusha direkt

include/Engine/Core/Transform.h

@@ -4,11 +4,11 @@
 #include "../GLM.h"
 #include "World.h"
 #include "EntityWrapper.h"
+#include "System.h"
 
 namespace Transform
 {
 
-glm::mat4 AbsoluteTransformation(EntityWrapper entity);
 glm::vec3 AbsolutePosition(EntityWrapper entity);
 glm::vec3 AbsolutePosition(World* world, EntityID entity);
 glm::vec3 AbsoluteOrientationEuler(EntityWrapper entity);
@@ -20,6 +20,16 @@ glm::mat4 ModelMatrix(EntityWrapper entity);
 glm::mat4 ModelMatrix(EntityID entity, World* world);
 glm::vec3 TransformPoint(const glm::vec3& point, const glm::mat4& matrix);
 
+class ClearCache : public ImpureSystem
+{
+public:
+    ClearCache(SystemParams params)
+        : System(params)
+    { }
+
+    virtual void Update(double dt) override;
+};
+
 }
 
 #endif

include/Game/Systems/CapturePointSystem.h

@@ -30,6 +30,7 @@ private:
     bool CapturePointSystem::OnTriggerLeave(const Events::TriggerLeave& e);
     EventRelay<CapturePointSystem, Events::Captured> m_ECaptured;
     bool CapturePointSystem::OnCaptured(const Events::Captured& e);
+    void ChangeCapturePointModelsVisibility(EntityWrapper &capturePointModels, bool isOwner);
 
     bool m_WinnerWasFound = false;
     //need to track these variables for the captureSystem to work as per design!

resources/Schema/Entities/aim_rays_with_capturep.xml

@@ -99,7 +99,7 @@
         </c:Team>
         <c:PlayerSpawn/>
         <c:Spawner>
-          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+          <EntityFile>Schema/Entities/PlayerRed.xml</EntityFile>
         </c:Spawner>
         <c:Transform/>
       </Components>
@@ -225,6 +225,11 @@
               </Team>
             </c:Team>
             <c:Trigger/>
+            <c:Model>
+              <Resource></Resource>
+              <Color A="0.300000012" B="0" G="0" R="1"/>
+              <Visible>false</Visible>
+            </c:Model>
             <c:Transform>
               <Position X="0" Y="0" Z="-4.10000038"/>
             </c:Transform>
@@ -239,7 +244,17 @@
                   <Scale X="2.70000005" Y="3.4000001" Z="4.60000038"/>
                 </c:Transform>
               </Components>
-              <Children/>
+              <Children>
+                <Entity>
+                  <Components>
+                    <c:Model>
+                      <Resource></Resource>
+                    </c:Model>
+                    <c:Transform/>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
             </Entity>
             <Entity name="Blue">
               <Components>

src/Engine/Collision/Collision.cpp

@@ -621,7 +621,7 @@ boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeM
         ComponentWrapper& cAABB = entity["AABB"];
         modelSpaceBox = EntityAABB::FromOriginSize((glm::vec3)cAABB["Origin"], (glm::vec3)cAABB["Size"]);
     } else if (entity.HasComponent("Model")) {
-        std::string res = entity["Model"]["Resource"];
+        const std::string& res = entity["Model"]["Resource"];
         if (res.empty()) {
             return boost::none;
         }
@@ -638,7 +638,7 @@ boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeM
         return boost::none;
     }
 
-    glm::mat4 modelMat = Transform::AbsoluteTransformation(entity);
+    glm::mat4 modelMat = Transform::ModelMatrix(entity);
     glm::vec3 mini(INFINITY);
     glm::vec3 maxi(-INFINITY);
     glm::vec3 maxCorner = modelSpaceBox.MaxCorner();

src/Engine/Core/Transform.cpp

@@ -1,16 +1,6 @@
 #include "Core/Transform.h"
 
-glm::mat4 Transform::AbsoluteTransformation(EntityWrapper entity)
-{
-    glm::mat4 t = glm::mat4(1.f);
-
-    while (entity.Valid()) {
-        t = glm::translate((glm::vec3&)entity["Transform"]["Position"]) * glm::toMat4(glm::quat((glm::vec3&)entity["Transform"]["Orientation"])) * glm::scale((glm::vec3&)entity["Transform"]["Scale"]) * t;
-        entity = entity.Parent();
-    }
-
-    return t;
-}
+static std::unordered_map<EntityWrapper, glm::mat4> MatrixCache;
 
 glm::vec3 Transform::AbsolutePosition(EntityWrapper entity)
 {
@@ -80,24 +70,36 @@ glm::vec3 Transform::AbsoluteScale(World* world, EntityID entity)
     return scale;
 }
 
-glm::mat4 Transform::ModelMatrix(EntityWrapper entity)
-{
-    return ModelMatrix(entity.ID, entity.World);
-}
-
 glm::mat4 Transform::ModelMatrix(EntityID entity, World* world)
 {
-    return AbsoluteTransformation(EntityWrapper(world, entity));
-
-    //glm::vec3 position = Transform::AbsolutePosition(world, entity);
-    //glm::quat orientation = Transform::AbsoluteOrientation(world, entity);
-    //glm::vec3 scale = Transform::AbsoluteScale(world, entity);
-
-    //glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
-    //return modelMatrix;
+    return ModelMatrix(EntityWrapper(world, entity));
 }
 
 glm::vec3 Transform::TransformPoint(const glm::vec3& point, const glm::mat4& matrix)
 {
     return glm::vec3(matrix * glm::vec4(point.x, point.y, point.z, 1));
-}
+}
+
+glm::mat4 Transform::ModelMatrix(EntityWrapper entity)
+{
+    auto cacheIt = MatrixCache.find(entity);
+    if (cacheIt != MatrixCache.end()) {
+        return cacheIt->second;
+    }
+
+    ComponentWrapper cTransform = entity["Transform"];
+    glm::mat4 t = glm::translate((const glm::vec3&)cTransform["Position"]) * glm::toMat4(glm::quat((const glm::vec3&)cTransform["Orientation"])) * glm::scale((const glm::vec3&)cTransform["Scale"]);
+
+    EntityWrapper parent = entity.Parent();
+    if (parent.Valid()) {
+        t = ModelMatrix(parent) * t;
+    }
+
+    MatrixCache[entity] = t;
+    return t;
+}
+
+void Transform::ClearCache::Update(double dt)
+{
+    MatrixCache.clear();
+}

src/Engine/Rendering/DrawFinalPassState.cpp

@@ -10,6 +10,8 @@ DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
     Enable(GL_DEPTH_TEST);
 	DepthMask(GL_TRUE);
     Enable(GL_CULL_FACE);
+	Enable(GL_ALPHA_TEST);
+	AlphaFunc(GL_GEQUAL, 0.05f);
    // Enable(GL_STENCIL_TEST);
    // StencilFunc(GL_NOTEQUAL, 1, 0xFF);
    // StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

src/Engine/Rendering/RenderSystem.cpp

@@ -184,7 +184,7 @@ bool RenderSystem::isEntityVisible(EntityWrapper& entity)
     }
 
     // Hide things parented to local player if they have the HiddenFromLocalPlayer component
-    bool outOfBodyExperience = ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false);
+    bool outOfBodyExperience = false; // ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false); // APPARENTLY THIS IS REALLY SLOW
     if (
         (entity.HasComponent("HiddenForLocalPlayer") || entity.FirstParentWithComponent("HiddenForLocalPlayer").Valid()) 
         && (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) 

src/Game/Game.cpp

@@ -42,7 +42,6 @@
 #include "Game/Systems/StartSystem.h"
 #include "Rendering/TextureSprite.h"
 
-
 Game::Game(int argc, char* argv[])
 {
     parseArgs(argc, argv);
@@ -159,6 +158,8 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<StartSystem>(updateOrderLevel);
     // Populate Octree with collidables
     ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<Transform::ClearCache>(updateOrderLevel);
+    ++updateOrderLevel;
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
@@ -174,6 +175,8 @@ Game::Game(int argc, char* argv[])
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
     ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<Transform::ClearCache>(updateOrderLevel);
+    ++updateOrderLevel;
     m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame, m_OctreeFrustrumCulling);
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<EditorSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);

src/Game/Systems/CapturePointSystem.cpp

@@ -108,10 +108,10 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
         //change what model is displaying (change all in case 2 capturepoints has been captured on the same frame)
         for (int i = 0; i < m_NumberOfCapturePoints; i++) {
             auto owner = (int)m_CapturePointNumberToEntityMap[i]["Team"]["Team"];
-            if (m_CapturePointNumberToEntityMap[i].FirstChildByName("Red").ID != EntityID_Invalid) {
-                (bool&)m_CapturePointNumberToEntityMap[i].FirstChildByName("Red")["Model"]["Visible"] = owner == redTeam ? true : false;
-                (bool&)m_CapturePointNumberToEntityMap[i].FirstChildByName("Blue")["Model"]["Visible"] = owner == blueTeam ? true : false;
-                (bool&)m_CapturePointNumberToEntityMap[i].FirstChildByName("Spectator")["Model"]["Visible"] = owner == spectatorTeam ? true : false;
+            if (m_CapturePointNumberToEntityMap[i].FirstChildByName("Red").Valid()) {
+                ChangeCapturePointModelsVisibility(m_CapturePointNumberToEntityMap[i].FirstChildByName("Red"), owner == redTeam);
+                ChangeCapturePointModelsVisibility(m_CapturePointNumberToEntityMap[i].FirstChildByName("Blue"), owner == blueTeam);
+                ChangeCapturePointModelsVisibility(m_CapturePointNumberToEntityMap[i].FirstChildByName("Spectator"), owner == spectatorTeam);
             }
         }
         //save the next cap points and publish the captured event
@@ -232,6 +232,14 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
 
 }
 
+void CapturePointSystem::ChangeCapturePointModelsVisibility(EntityWrapper &capturePointModels, bool isOwner) {
+    (bool&)capturePointModels["Model"]["Visible"] = isOwner;
+    for (auto& capModel : capturePointModels.ChildrenWithComponent("Model"))
+    {
+        (bool&)capModel["Model"]["Visible"] = isOwner;
+    }
+}
+
 bool CapturePointSystem::OnTriggerTouch(const Events::TriggerTouch& e)
 {
     //personEntered = e.Entity, thingEntered = e.Trigger