Merge remote-tracking branch 'origin/master' into NormalSpecularMapping

# Conflicts:
#	include/Engine/Rendering/RenderSystem.h
#	src/Engine/Rendering/DrawFinalPass.cpp
#	src/Engine/Rendering/RenderSystem.cpp

src/Engine/Collision/CollidableOctreeSystem.cpp

@@ -8,7 +8,7 @@ void CollidableOctreeSystem::Update(double dt)
 void CollidableOctreeSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     if (entity.HasComponent("AABB")) {
-        boost::optional<AABB> absoluteAABB = Collision::EntityAbsoluteAABB(entity);
+        boost::optional<EntityAABB> absoluteAABB = Collision::EntityAbsoluteAABB(entity);
         if (absoluteAABB) {
             m_Octree->AddDynamicObject(*absoluteAABB);
         }

src/Engine/Collision/Collision.cpp

@@ -283,7 +283,7 @@ bool attachAABBComponentFromModel(World* world, EntityID id)
     return true;
 }
 
-boost::optional<AABB> EntityAbsoluteAABB(EntityWrapper& entity)
+boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity)
 {
     if (!entity.HasComponent("AABB")) {
         return boost::none;
@@ -294,7 +294,11 @@ boost::optional<AABB> EntityAbsoluteAABB(EntityWrapper& entity)
     glm::vec3 absScale = Transform::AbsoluteScale(entity.World, entity.ID);
     glm::vec3 origin = absPosition + (glm::vec3)cAABB["Origin"];
     glm::vec3 size = (glm::vec3)cAABB["Size"] * absScale;
-    return AABB::FromOriginSize(origin, size);
+
+    EntityAABB aabb = EntityAABB::FromOriginSize(origin, size);
+    aabb.Entity = entity;
+
+    return aabb;
 }
 
 }

src/Engine/Collision/CollisionSystem.cpp

@@ -9,12 +9,12 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     }
     ComponentWrapper& cPhysics = entity["Physics"];
 
-    boost::optional<AABB> boundingBox = Collision::EntityAbsoluteAABB(entity);
+    boost::optional<EntityAABB> boundingBox = Collision::EntityAbsoluteAABB(entity);
     if (!boundingBox) {
         return;
     }
     ComponentWrapper& cTransform = entity["Transform"];
-    AABB& boxA = *boundingBox;
+    EntityAABB& boxA = *boundingBox;
 
     //Press 'Z' to enable/disable collision.
     if (zPress) {
@@ -22,7 +22,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     }
 
     // Collide against octree
-    std::vector<AABB> octreeResult;
+    std::vector<EntityAABB> octreeResult;
     m_Octree->ObjectsInSameRegion(*boundingBox, octreeResult);
     for (auto& boxB : octreeResult) {
         glm::vec3 resolutionVector;

src/Engine/Collision/TriggerSystem.cpp

@@ -3,79 +3,72 @@
 #include "Core/AABB.h"
 #include "Rendering/Model.h"
 
-void TriggerSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
+void TriggerSystem::UpdateComponent(EntityWrapper& triggerEntity, ComponentWrapper& cTrigger, double dt)
 {
-    //Currently only players can trigger things.
-    auto players = m_World->GetComponents("Player");
-    if (players == nullptr) {
-        return;
-    }
-    EntityID tId = component.EntityID;
-    boost::optional<AABB> triggerBox = Collision::EntityAbsoluteAABB(entity);
-    //The trigger *should* have a bounding box, or something, to test against so it can be triggered.
+    // The trigger *should* have a bounding box, or something, to test against so it can be triggered.
+    boost::optional<EntityAABB> triggerBox = Collision::EntityAbsoluteAABB(triggerEntity);
     if (!triggerBox) {
         return;
     }
-    for (auto& pc : *players) {
-        EntityID pId = pc.EntityID;
-        boost::optional<AABB> playerBox = Collision::EntityAbsoluteAABB(EntityWrapper(m_World, pId));
-        //The player can't trigger anything without an AABB.
-        if (!playerBox) {
-            continue;
-        }
-        if (!Collision::AABBVsAABB(*triggerBox, *playerBox)) {
-            //Entity is not touching the trigger,
-            //Throw event if it was previously.
-            if (throwLeaveIfWasInTrigger(m_EntitiesTouchingTrigger[tId], pId, tId)) {
-                continue;
-            }
-            //This only occurs if the entity was completely inside the trigger one frame, 
-            //then completely outside the trigger, e.g. when dying and respawning.
-            throwLeaveIfWasInTrigger(m_EntitiesCompletelyInTrigger[tId], pId, tId);
-        } else {
-            //Entity is at least touching the trigger.
+
+    m_OctreeOut.clear();
+    m_Octree->ObjectsInSameRegion(*triggerBox, m_OctreeOut);
+
+    for (EntityAABB& colliderBox : m_OctreeOut) {
+        EntityWrapper colliderEntity = colliderBox.Entity;
+
+        if (Collision::AABBVsAABB(*triggerBox, colliderBox)) {
             AABB completelyInsideBox;
-            bool playerFitsInTrigger = glm::all(glm::greaterThan((*triggerBox).Size(), (*playerBox).Size()));
-            if (playerFitsInTrigger) {
-                completelyInsideBox = AABB::FromOriginSize((*triggerBox).Origin(), (*triggerBox).Size() - 2.0f * (*playerBox).Size());
+            bool colliderFitsInTrigger = glm::all(glm::greaterThan((*triggerBox).Size(), colliderBox.Size()));
+            if (colliderFitsInTrigger) {
+                completelyInsideBox = AABB::FromOriginSize((*triggerBox).Origin(), (*triggerBox).Size() - 2.0f * colliderBox.Size());
             }
-            if (playerFitsInTrigger && Collision::AABBVsAABB(completelyInsideBox, *playerBox)) {
-                //Entity is completely inside the trigger.
-                //If it was only touching before, it is erased.
-                m_EntitiesTouchingTrigger[tId].erase(pId);
-                std::unordered_set<EntityID>& completeSet = m_EntitiesCompletelyInTrigger[tId];
-                if (completeSet.count(pId) == 0) {
-                    //If it wasn't completely in the trigger, throw Enter and add to the set.
-                    completeSet.insert(pId);
-                    publish<Events::TriggerEnter>(pId, tId);
+            if (colliderFitsInTrigger && Collision::AABBVsAABB(completelyInsideBox, colliderBox)) {
+                // Entity is completely inside the trigger.
+                // If it was only touching before, it is erased.
+                m_EntitiesTouchingTrigger[triggerEntity].erase(colliderEntity);
+                auto& completeSet = m_EntitiesCompletelyInTrigger[triggerEntity];
+                if (completeSet.count(colliderEntity) == 0) {
+                    // If it wasn't completely in the trigger, throw Enter and add to the set.
+                    completeSet.insert(colliderEntity);
+                    publish<Events::TriggerEnter>(colliderEntity, triggerEntity);
                 }
             } else {
-                //Entity is only touching the trigger.
-                std::unordered_set<EntityID>& touchSet = m_EntitiesTouchingTrigger[tId];
-                std::unordered_set<EntityID>& completeSet = m_EntitiesCompletelyInTrigger[tId];
-                const auto& it = completeSet.find(pId);
+                // Entity is only touching the trigger.
+                auto& touchSet = m_EntitiesTouchingTrigger[triggerEntity];
+                auto& completeSet = m_EntitiesCompletelyInTrigger[triggerEntity];
+                const auto& it = completeSet.find(colliderEntity);
                 //If it was completely inside before.
                 if (it != completeSet.end()) {
                     completeSet.erase(it);
-                    touchSet.insert(pId);
+                    touchSet.insert(colliderEntity);
                     //If it was completely outside before.
-                } else if (touchSet.count(pId) == 0) {
-                    publish<Events::TriggerTouch>(pId, tId);
-                    touchSet.insert(pId);
+                } else if (touchSet.count(colliderEntity) == 0) {
+                    publish<Events::TriggerTouch>(colliderEntity, triggerEntity);
+                    touchSet.insert(colliderEntity);
                 }
-                //Else, it was touching the trigger last frame too and nothing is done.
+                // Else, it was touching the trigger last frame too and nothing is done.
             }
+        } else {
+            // Entity is not touching the trigger,
+            // Throw event if it was previously.
+            if (throwLeaveIfWasInTrigger(m_EntitiesTouchingTrigger[triggerEntity], colliderEntity, triggerEntity)) {
+                continue;
+            }
+            // This only occurs if the entity was completely inside the trigger one frame, 
+            // then completely outside the trigger, e.g. when dying and respawning.
+            throwLeaveIfWasInTrigger(m_EntitiesCompletelyInTrigger[triggerEntity], colliderEntity, triggerEntity);
         }
     }
 }
 
-bool TriggerSystem::throwLeaveIfWasInTrigger(std::unordered_set<EntityID>& triggerSet, EntityID pId, EntityID tId)
+bool TriggerSystem::throwLeaveIfWasInTrigger(std::unordered_set<EntityWrapper>& triggerSet, EntityWrapper colliderEntity, EntityWrapper triggerEntity)
 {
-    const auto& it = triggerSet.find(pId);
+    const auto& it = triggerSet.find(colliderEntity);
     if (it != triggerSet.end()) {
         //If it was in the trigger, but not anymore, throw leaveEvent and erase from the set.
         triggerSet.erase(it);
-        publish<Events::TriggerLeave>(pId, tId);
+        publish<Events::TriggerLeave>(colliderEntity, triggerEntity);
         return true;
     }
     return false;

src/Engine/Core/AABB.cpp

@@ -20,10 +20,6 @@ AABB::AABB(const glm::vec3& minPos, const glm::vec3& maxPos)
     }
 }
 
-AABB::AABB(const glm::vec4& minPos, const glm::vec4& maxPos)
-    : AABB(glm::vec3(minPos), glm::vec3(maxPos))
-{ }
-
 AABB AABB::FromOriginSize(const glm::vec3& origin, const glm::vec3& size)
 {
     return AABB(origin - (size/2.f), origin + (size/2.f));

src/Engine/Core/EntityFile.cpp

@@ -20,7 +20,7 @@ void EntityFile::Parse(const EntityFileHandler* handler) const
 {
     using namespace xercesc;
 
-    EntityFileSAXHandler saxHandler(handler, nullptr);
+    EntityFileSAXHandler saxHandler(handler, m_SAX2XMLReader);
     setReaderFeatures(m_SAX2XMLReader);
     m_SAX2XMLReader->setContentHandler(&saxHandler);
     m_SAX2XMLReader->setErrorHandler(&saxHandler);
@@ -37,6 +37,7 @@ void EntityFile::setReaderFeatures(xercesc::SAX2XMLReader* reader)
     reader->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
     reader->setFeature(XMLUni::fgXercesSchema, true);
     reader->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
+    reader->setFeature(XMLUni::fgXercesCalculateSrcOfs, true);
 }
 
 std::size_t EntityFile::GetTypeStride(std::string typeName)
@@ -111,8 +112,9 @@ void EntityFile::WriteValueData(char* outData, const ComponentInfo::Field_t& fie
     } catch (const boost::bad_lexical_cast&) { }
 }
 
-EntityFileSAXHandler::EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader) : m_Handler(handler)
-, m_Reader(reader)
+EntityFileSAXHandler::EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader) 
+    : m_Handler(handler)
+    , m_Reader(reader)
 {
     // 0 is imaginary base parent
     m_EntityStack.push(0);
@@ -188,21 +190,29 @@ void EntityFileSAXHandler::characters(const XMLCh* const chars, const XMLSize_t
 
 void EntityFileSAXHandler::fatalError(const xercesc::SAXParseException& e)
 {
-    XS::ToString s(e.getMessage());
-    LOG_ERROR("SAXParseException: %s", ((std::string)s).c_str());
-    //throw e;
+    std::string message = XS::ToString(e.getMessage());
+    std::string systemId = XS::ToString(e.getSystemId());
+    XMLFileLoc line = e.getLineNumber();
+    XMLFileLoc column = e.getColumnNumber();
+    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tFatal Error: %s", systemId.c_str(), line, column, message.c_str());
 }
 
 void EntityFileSAXHandler::error(const xercesc::SAXParseException& e)
 {
-    XS::ToString s(e.getMessage());
-    LOG_ERROR("SAXParseException: %s", ((std::string)s).c_str());
+    std::string message = XS::ToString(e.getMessage());
+    std::string systemId = XS::ToString(e.getSystemId());
+    XMLFileLoc line = e.getLineNumber();
+    XMLFileLoc column = e.getColumnNumber();
+    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tError: %s", systemId.c_str(), line, column, message.c_str());
 }
 
 void EntityFileSAXHandler::warning(const xercesc::SAXParseException& e)
 {
-    XS::ToString s(e.getMessage());
-    LOG_ERROR("SAXParseException: %s", ((std::string)s).c_str());
+    std::string message = XS::ToString(e.getMessage());
+    std::string systemId = XS::ToString(e.getSystemId());
+    XMLFileLoc line = e.getLineNumber();
+    XMLFileLoc column = e.getColumnNumber();
+    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tWarning: %s", systemId.c_str(), line, column, message.c_str());
 }
 
 void EntityFileSAXHandler::onStartEntity(const xercesc::Attributes& attrs)

src/Engine/Core/EntityFilePreprocessor.cpp

@@ -65,6 +65,7 @@ void EntityFilePreprocessor::parseComponentInfo()
 
         // Name
         compInfo.Name = XS::ToString(element->getName());
+        bool brk = compInfo.Name == "HiddenForLocalPlayer";
         // Known allocation
         compInfo.Meta->Allocation = m_ComponentCounts[compInfo.Name];
         // Annotation
@@ -90,7 +91,7 @@ void EntityFilePreprocessor::parseComponentInfo()
         // <xs:all>
         auto modelGroupParticle = complexTypeDefinition->getParticle();
         if (modelGroupParticle == nullptr || modelGroupParticle->getTermType() != XSParticle::TERM_MODELGROUP) {
-            //LOG_ERROR("Failed to parse component definition for \"%s\": Model group particle was null or wasn't TERM_MODELGROUP!", compInfo.Name.c_str());
+            LOG_ERROR("Failed to parse component definition for \"%s\": Model group particle was null or wasn't TERM_MODELGROUP!", compInfo.Name.c_str());
             continue;
         }
         auto modelGroup = modelGroupParticle->getModelGroupTerm();

src/Engine/Core/EntityWrapper.cpp

@@ -97,11 +97,6 @@ EntityWrapper::operator EntityID() const
     return this->ID;
 }
 
-EntityWrapper::operator bool()
-{
-    return this->Valid();
-}
-
 EntityWrapper EntityWrapper::firstChildByNameRecursive(const std::string& name, EntityID parent)
 {
     if (!this->World->ValidEntity(parent)) {

src/Engine/Core/Util/Logging.cpp

@@ -4,4 +4,40 @@
 _LOG_LEVEL LOG_LEVEL = LOG_LEVEL_DEBUG;
 #else
 _LOG_LEVEL LOG_LEVEL = LOG_LEVEL_INFO;
-#endif
+#endif
+
+const char* _LOG_LEVEL_PREFIX[] =
+{
+    "EE: ",
+	"",
+	"WW: ",
+	"DD: "
+};
+
+void _LOG(_LOG_LEVEL logLevel, const char* file, const char* func, unsigned int line, const char* format, ...)
+{
+	if (logLevel > LOG_LEVEL) {
+		return;
+	}
+
+	char* message = nullptr;
+	va_list args;
+
+	va_start(args, format);
+	size_t size = vsnprintf(message, 0, format, args) + 1;
+	va_end(args);
+
+	va_start(args, format);
+	message = new char[size];
+	vsnprintf(message, size, format, args);
+	va_end(args);
+
+	if (logLevel == LOG_LEVEL_ERROR) {
+		std::cerr << file << ":" << line << " " << func << std::endl;
+		std::cerr << _LOG_LEVEL_PREFIX[logLevel] << message << std::endl;
+	} else {
+		std::cout << _LOG_LEVEL_PREFIX[logLevel] << message << std::endl;
+	}
+
+	delete[] message;
+}

src/Engine/Core/World.cpp

@@ -54,8 +54,12 @@ ComponentWrapper World::AttachComponent(EntityID entity, const std::string& comp
 
 bool World::HasComponent(EntityID entity, const std::string& componentType) const
 {
-    ComponentPool* pool = m_ComponentPools.at(componentType);
-    return pool->KnowsEntity(entity);
+    auto it = m_ComponentPools.find(componentType);
+    if (it == m_ComponentPools.end()) {
+        return false;
+    } else {
+        return it->second->KnowsEntity(entity);
+    }
 }
 
 ComponentWrapper World::GetComponent(EntityID entity, const std::string& componentType)

src/Engine/Editor/EditorRenderSystem.cpp

@@ -12,7 +12,7 @@ EditorRenderSystem::EditorRenderSystem(World* m_World, EventBroker* eventBroker,
 
 void EditorRenderSystem::Update(double dt)
 {
-    if (m_CurrentCamera) {
+    if (m_CurrentCamera.Valid()) {
         ComponentWrapper cameraTransform = m_CurrentCamera["Transform"];
         m_EditorCamera->SetPosition(cameraTransform["Position"]);
         m_EditorCamera->SetOrientation(glm::quat((const glm::vec3&)cameraTransform["Orientation"]));

src/Engine/Editor/EditorWidgetSystem.cpp

@@ -30,7 +30,7 @@ void EditorWidgetSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper
 
     auto camera = m_PickData.Camera;
     glm::vec3 axis = cEditorWidget["Axis"];
-    glm::vec2 axisScreen = camera->WorldToScreen(axis, m_Renderer->Resolution()) - camera->WorldToScreen(glm::vec3(0, 0, 0), m_Renderer->Resolution());
+    glm::vec2 axisScreen = camera->WorldToScreen(axis, m_Renderer->GetViewPortSize()) - camera->WorldToScreen(glm::vec3(0, 0, 0), m_Renderer->GetViewPortSize());
     float dot = glm::dot(m_MouseDelta, glm::normalize(axisScreen)) / glm::length(axisScreen);
     glm::vec3 worldMovement = dot * axis;
 

src/Engine/Rendering/DrawBloomPass.cpp

@@ -34,12 +34,12 @@ void DrawBloomPass::InitializeShaderPrograms()
 
 void DrawBloomPass::InitializeBuffers()
 {
-    GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
 
     m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
     m_GaussianFrameBuffer_horiz.Generate();
 
-    GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
 
     m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
     m_GaussianFrameBuffer_vert.Generate();

src/Engine/Rendering/DrawFinalPass.cpp

@@ -21,12 +21,12 @@ void DrawFinalPass::InitializeFrameBuffers()
 {
     glGenRenderbuffers(1, &m_DepthBuffer);
     glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height);
 
-    GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-    //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-    GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-    //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_FLOAT, 4);
+    GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_FLOAT, 4);
 
     m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
     m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));

src/Engine/Rendering/LightCullingPass.cpp

@@ -25,8 +25,8 @@ void LightCullingPass::GenerateNewFrustum(RenderScene& scene)
 
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
     glUniformMatrix4fv(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "P"), 1, false, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-    glUniform2f(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
-    glDispatchCompute((int)(m_Renderer->Resolution().Width/(TILE_SIZE*TILE_SIZE) + 1), (int)(m_Renderer->Resolution().Height/(TILE_SIZE*TILE_SIZE) + 1), 1);
+    glUniform2f(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "ScreenDimensions"), m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height);
+    glDispatchCompute((int)(m_Renderer->GetViewPortSize().Width/(TILE_SIZE*TILE_SIZE) + 1), (int)(m_Renderer->GetViewPortSize().Height/(TILE_SIZE*TILE_SIZE) + 1), 1);
 
     GLERROR("CalculateFrustum Error: End");
 }
@@ -40,7 +40,7 @@ void LightCullingPass::OnResolutionChange()
 
 void LightCullingPass::SetSSBOSizes()
 {
-    m_NumberOfTiles = (int)(m_Renderer->Resolution().Width/TILE_SIZE) * (int)(m_Renderer->Resolution().Height/TILE_SIZE);
+    m_NumberOfTiles = (int)(m_Renderer->GetViewPortSize().Width/TILE_SIZE) * (int)(m_Renderer->GetViewPortSize().Height/TILE_SIZE);
 
     m_Frustums = new Frustum[m_NumberOfTiles];
     m_LightGrid = new LightGrid[m_NumberOfTiles];
@@ -67,14 +67,14 @@ void LightCullingPass::CullLights(RenderScene& scene)
     glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 
     m_LightCullProgram->Bind();
-    glUniform2f(glGetUniformLocation(m_LightCullProgram->GetHandle(), "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+    glUniform2f(glGetUniformLocation(m_LightCullProgram->GetHandle(), "ScreenDimensions"), m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height);
     glUniformMatrix4fv(glGetUniformLocation(m_LightCullProgram->GetHandle(), "V"), 1, false, glm::value_ptr(scene.Camera->ViewMatrix()));
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightGridSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, m_LightOffsetSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightIndexSSBO);
-    glDispatchCompute(glm::ceil(m_Renderer->Resolution().Width / TILE_SIZE), glm::ceil(m_Renderer->Resolution().Height / TILE_SIZE), 1);
+    glDispatchCompute(glm::ceil(m_Renderer->GetViewPortSize().Width/ TILE_SIZE), glm::ceil(m_Renderer->GetViewPortSize().Height / TILE_SIZE), 1);
 
     GLERROR("CullLights Error: End");
 }

src/Engine/Rendering/PickingPass.cpp

@@ -18,14 +18,14 @@ PickingPass::~PickingPass()
 void PickingPass::InitializeTextures()
 {
     GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
-        glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
+        glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
 }
 
 void PickingPass::InitializeFrameBuffers()
 {
     glGenRenderbuffers(1, &m_DepthBuffer);
     glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height);
 
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_PickingTexture, GL_COLOR_ATTACHMENT0)));

src/Engine/Rendering/RenderSystem.cpp

@@ -31,33 +31,44 @@ bool RenderSystem::OnSetCamera(Events::SetCamera& e)
     return true;
 }
 
+bool RenderSystem::isChildOfACamera(EntityWrapper entity)
+{
+    return entity.FirstParentWithComponent("Camera").Valid();
+}
 void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs, std::list<std::shared_ptr<RenderJob>>& transparentJobs)
+
+place me somewhere
+
+bool RenderSystem::isChildOfCurrentCamera(EntityWrapper entity)
+{
+    return entity == m_CurrentCamera || entity.IsChildOf(m_CurrentCamera);
+}
+
 {
     auto models = m_World->GetComponents("Model");
     if (models == nullptr) {
         return;
     }
 
-    for (auto& modelComponent : *models) {
-        bool visible = modelComponent["Visible"];
+    for (auto& cModel : *models) {
+        bool visible = cModel["Visible"];
         if (!visible) {
             continue;
         }
-        std::string resource = modelComponent["Resource"];
+        std::string resource = cModel["Resource"];
         if (resource.empty()) {
             continue;
         }
 
-        EntityWrapper entity(m_World, modelComponent.EntityID);
+        EntityWrapper entity(m_World, cModel.EntityID);
 
-        // Don't render the local player
-        if (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) {
-            if (!entity.HasComponent("HealthHUD") && entity.Name() != "Crosshair" && entity.Name() != "Weapon") { //Should work but needs to be fixed. Should only render the things "childed" to the local player camera
-                continue;
-            }
+        // Only render children of a camera if that camera is currently active
+        if (isChildOfACamera(entity) && !isChildOfCurrentCamera(entity)) {
+            continue;
         }
 
-        if ((entity.Name() == "Weapon" || entity.HasComponent("HealthHUD")) && !entity.IsChildOf(m_LocalPlayer)) {
+        // Hide things parented to local player if they have the HiddenFromLocalPlayer component
+        if (entity.HasComponent("HiddenForLocalPlayer") && (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer))) {
             continue;
         }
 
@@ -77,23 +88,23 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs,
 
         float fillPercentage = 0.f;
         glm::vec4 fillColor = glm::vec4(0);
-        if(m_World->HasComponent(modelComponent.EntityID, "Fill")) {
-            auto fillComponent = m_World->GetComponent(modelComponent.EntityID, "Fill");
+        if(m_World->HasComponent(cModel.EntityID, "Fill")) {
+            auto fillComponent = m_World->GetComponent(cModel.EntityID, "Fill");
             fillPercentage = (float)(double)fillComponent["Percentage"];
             fillColor = (glm::vec4)fillComponent["Color"];
         }
 
-        glm::mat4 modelMatrix = Transform::ModelMatrix(modelComponent.EntityID, m_World);
+        glm::mat4 modelMatrix = Transform::ModelMatrix(cModel.EntityID, m_World);
         for (auto matGroup : model->MaterialGroups()) {
-            if (m_World->HasComponent(modelComponent.EntityID, "ExplosionEffect")) {
-                auto explosionEffectComponent = m_World->GetComponent(modelComponent.EntityID, "ExplosionEffect");
+            if (m_World->HasComponent(cModel.EntityID, "ExplosionEffect")) {
+                auto explosionEffectComponent = m_World->GetComponent(cModel.EntityID, "ExplosionEffect");
                 std::shared_ptr<ExplosionEffectJob> explosionEffectJob = std::shared_ptr<ExplosionEffectJob>(new ExplosionEffectJob(
                     explosionEffectComponent, 
                     model, 
                     m_Camera, 
                     modelMatrix, 
                     matGroup, 
-                    modelComponent, 
+                    cModel, 
                     m_World, 
                     fillColor, 
                     fillPercentage
@@ -113,7 +124,7 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs,
                     m_Camera, 
                     modelMatrix, 
                     matGroup, 
-                    modelComponent, 
+                    cModel, 
                     m_World, 
                     fillColor, 
                     fillPercentage

src/Engine/Rendering/Renderer.cpp

@@ -58,6 +58,11 @@ void Renderer::InitializeWindow()
 		LOG_ERROR("GLEW: Initialization failed");
 		exit(EXIT_FAILURE);
 	}
+
+    int res[2];
+    glfwGetWindowSize(m_Window, &res[0], &res[1]);
+    SetViewPortSize(Rectangle::Rectangle(res[0], res[1]));
+
 }
 
 void Renderer::InitializeShaders()