Text still disappears if its behind transparent sprites

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,16 +20,6 @@ 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/Engine/Rendering/DrawFinalPass.h

@@ -13,6 +13,7 @@
 #include "Texture.h"
 #include "ShadowPass.h"
 #include "BlurHUD.h"
+#include "TextPass.h"
 
 class DrawFinalPass
 {
@@ -22,7 +23,7 @@ public:
     void InitializeTextures();
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
-    void Draw(RenderScene& scene, BlurHUD* blurHUDPass);
+    void Draw(RenderScene& scene, BlurHUD* blurHUDPass, TextPass* textPass);
     void ClearBuffer();
     void OnWindowResize();
 

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")) {
-        const std::string& res = entity["Model"]["Resource"];
+        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::ModelMatrix(entity);
+    glm::mat4 modelMat = Transform::AbsoluteTransformation(entity);
     glm::vec3 mini(INFINITY);
     glm::vec3 maxi(-INFINITY);
     glm::vec3 maxCorner = modelSpaceBox.MaxCorner();

src/Engine/Core/Transform.cpp

@@ -1,6 +1,16 @@
 #include "Core/Transform.h"
 
-static std::unordered_map<EntityWrapper, glm::mat4> MatrixCache;
+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;
+}
 
 glm::vec3 Transform::AbsolutePosition(EntityWrapper entity)
 {
@@ -70,36 +80,24 @@ 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 ModelMatrix(EntityWrapper(world, entity));
+    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;
 }
 
 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/DrawFinalPass.cpp

@@ -242,7 +242,7 @@ void DrawFinalPass::InitializeShaderPrograms()
 	
 }
 
-void DrawFinalPass::Draw(RenderScene& scene, BlurHUD* blurHUDPass)
+void DrawFinalPass::Draw(RenderScene& scene, BlurHUD* blurHUDPass, TextPass* textPass)
 {
     GLERROR("Pre");
 	DrawFinalPassState* stateDethp = new DrawFinalPassState(m_ShieldDepthFrameBuffer.GetHandle());
@@ -282,10 +282,36 @@ void DrawFinalPass::Draw(RenderScene& scene, BlurHUD* blurHUDPass)
 	//state->StencilMask(0x00);
 	DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
 	GLERROR("OpaqueObjects");
+    delete state;
+   
+    DrawFinalPassState* stateSprite = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
+    if (scene.ShouldBlur) {
+        //Combine nonblur and blur texture
+        stateSprite->Disable(GL_DEPTH_TEST);
+        stateSprite->Disable(GL_STENCIL_TEST);
+        m_CombinedTexture = blurHUDPass->CombineTextures(m_SceneTexture, m_FullBlurredTexture);
+
+    }
+    //Draw Transparen objects
+    //state->BlendFunc(GL_ONE, GL_ONE);
+    //state->StencilFunc(GL_EQUAL, 1, 0xFF);
+    //DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
+    GLERROR("TransparentObjects");
+    //state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    stateSprite->Enable(GL_DEPTH_TEST);
+    //stateSprite->AlphaFunc(GL_GEQUAL, 0.05f);
+    //stateSprite->Enable(GL_ALPHA_TEST);
+    DrawSprites(scene.Jobs.SpriteJob, scene);
+    GLERROR("SpriteJobs");
+
+    delete stateSprite;
+
+    state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
 
 	//state->Disable(GL_STENCIL_TEST);
     //Draw Transparen Shielded objects
 	state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    textPass->Draw(scene, m_FinalPassFrameBuffer);
 	DrawModelRenderQueuesWithShieldCheck(scene.Jobs.TransparentObjects, scene); //might need changing
     GLERROR("Shielded Transparent objects");
 
@@ -296,27 +322,7 @@ void DrawFinalPass::Draw(RenderScene& scene, BlurHUD* blurHUDPass)
         m_FullBlurredTexture = blurHUDPass->Draw(m_SceneTexture, scene);
     }
 
-        DrawFinalPassState* stateSprite = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
-    if(scene.ShouldBlur) {
-        //Combine nonblur and blur texture
-        stateSprite->Disable(GL_DEPTH_TEST);
-        stateSprite->Disable(GL_STENCIL_TEST);
-        m_CombinedTexture = blurHUDPass->CombineTextures(m_SceneTexture, m_FullBlurredTexture);
-
-    }
-	//Draw Transparen objects
-	//state->BlendFunc(GL_ONE, GL_ONE);
-	//state->StencilFunc(GL_EQUAL, 1, 0xFF);
-	//DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
-	GLERROR("TransparentObjects");
-	//state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    stateSprite->Enable(GL_DEPTH_TEST);
-    //stateSprite->AlphaFunc(GL_GEQUAL, 0.05f);
-    //stateSprite->Enable(GL_ALPHA_TEST);
-	DrawSprites(scene.Jobs.SpriteJob, scene);
-	GLERROR("SpriteJobs");
-
-	delete stateSprite;
+    
     GLERROR("END");
     
 }

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 = false; // ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false); // APPARENTLY THIS IS REALLY SLOW
+    bool outOfBodyExperience = ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false);
     if (
         (entity.HasComponent("HiddenForLocalPlayer") || entity.FirstParentWithComponent("HiddenForLocalPlayer").Valid()) 
         && (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) 

src/Engine/Rendering/Renderer.cpp

@@ -210,14 +210,15 @@ void Renderer::Draw(RenderFrame& frame)
         PerformanceTimer::StartTimerAndStopPrevious("Renderer-Light Culling");
         m_LightCullingPass->CullLights(*scene);
         GLERROR("LightCulling");
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Text");
+        //m_TextPass->Draw(*scene, *m_DrawFinalPass->FinalPassFrameBuffer());
+        GLERROR("Draw Text");
 		PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Geometry+Light");
-		m_DrawFinalPass->Draw(*scene, m_BlurHUDPass);
+		m_DrawFinalPass->Draw(*scene, m_BlurHUDPass, m_TextPass);
         GLERROR("Draw Geometry+Light");
         //m_DrawScenePass->Draw(*scene);
 
-        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Text");
-        m_TextPass->Draw(*scene, *m_DrawFinalPass->FinalPassFrameBuffer());
-        GLERROR("Draw Text");
+        
         PerformanceTimer::StopTimer("Renderer-Draw Text");
     }
 

src/Engine/Rendering/TextPass.cpp

@@ -34,7 +34,7 @@ void TextPass::Update()
 void TextPass::Draw(RenderScene& scene, FrameBuffer& frameBuffer)
 {
     GLERROR("Derp1");
-    TextPassState* state = new TextPassState(frameBuffer.GetHandle());
+    //TextPassState* state = new TextPassState(frameBuffer.GetHandle());
     for (auto &job : scene.Jobs.Text) {
         auto textJob = std::dynamic_pointer_cast<TextJob>(job);
         if (textJob) {
@@ -43,7 +43,7 @@ void TextPass::Draw(RenderScene& scene, FrameBuffer& frameBuffer)
         }
     }
     GLERROR("Derp2");
-    delete state;
+  //  delete state;
 }
 
 void TextPass::renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix)

src/Engine/Rendering/TextPassState.cpp

@@ -4,10 +4,13 @@
 TextPassState::TextPassState(GLuint frameBuffer)
 {
     BindFramebuffer(frameBuffer);
-    glEnable(GL_BLEND);
-    glDisable(GL_CULL_FACE);
-    glEnable(GL_DEPTH_TEST);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    Enable(GL_BLEND);
+    Disable(GL_CULL_FACE);
+    Enable(GL_DEPTH_TEST);
+    BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    Enable(GL_ALPHA_TEST);
+    AlphaFunc(GL_GEQUAL, 0.05f);
+    
 }
 
 TextPassState::~TextPassState()

src/Game/Game.cpp

@@ -42,6 +42,7 @@
 #include "Game/Systems/StartSystem.h"
 #include "Rendering/TextureSprite.h"
 
+
 Game::Game(int argc, char* argv[])
 {
     parseArgs(argc, argv);
@@ -158,8 +159,6 @@ 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);
@@ -175,8 +174,6 @@ 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);