Merge branch 'OctTree' of github.com:teamfisk/TacticalZ into OctTree

# Conflicts:
#	src/Engine/Core/OctTree.cpp

src/Engine/CMakeLists.txt

@@ -7,6 +7,7 @@ find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono)
 find_package(assimp REQUIRED)
 find_package(ZLIB REQUIRED)
 find_package(PNG REQUIRED)
+find_package(Xerces REQUIRED)
 # Because FindOpenAL is retarded
 #set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "${CMAKE_SOURCE_DIR}/deps/include/AL")
 #find_package(OpenAL REQUIRED)
@@ -23,6 +24,7 @@ include_directories(
     ${Boost_INCLUDE_DIRS}
     ${assimp_INCLUDE_DIRS}
     ${PNG_INCLUDE_DIRS}
+    ${Xerces_INCLUDE_DIRS}
     ${OPENAL_INCLUDE_DIR}
     ${X11_INCLUDE_DIRS}
 )
@@ -44,6 +46,12 @@ file(GLOB SOURCE_FILES_Input
 )
 source_group(Input FILES ${SOURCE_FILES_Input})
 
+file(GLOB SOURCE_FILES_Network
+    "${INCLUDE_PATH}/Network/*.h"
+    "Network/*.cpp"
+)
+source_group(Network FILES ${SOURCE_FILES_Network})
+
 file(GLOB SOURCE_FILES_Rendering
     "${INCLUDE_PATH}/Rendering/*.h"
     "Rendering/*.cpp"
@@ -52,6 +60,7 @@ file(GLOB SOURCE_FILES_Rendering_Util
     "${INCLUDE_PATH}/Rendering/Util/*.h"
     "Rendering/Util/*.cpp"
 )
+
 source_group(Rendering FILES ${SOURCE_FILES_Rendering})
 source_group(Rendering\\Util FILES ${SOURCE_FILES_Rendering_Util})
 
@@ -65,8 +74,10 @@ set(SOURCE_FILES
     ${SOURCE_FILES_Core}
     ${SOURCE_FILES_Core_Util}
     #${SOURCE_FILES_Input}
+	${SOURCE_FILES_Network}
     ${SOURCE_FILES_GUI}
     ${SOURCE_FILES_Rendering}
+    ${SOURCE_FILES_Rendering_Util}
 )
 
 set(LIBRARIES
@@ -76,6 +87,7 @@ set(LIBRARIES
     ${Boost_LIBRARIES}
     ${assimp_LIBRARIES}
     ${PNG_LIBRARIES}
+    ${Xerces_LIBRARIES}
     ${OPENAL_LIBRARY}
     ${X11_LIBRARIES}
 )

src/Engine/Core/ComponentPool.cpp

@@ -0,0 +1,79 @@
+#include "Core/ComponentPool.h"
+
+
+
+ComponentWrapper ComponentPoolForwardIterator::operator*() const
+{
+    char* data = &(*m_MemoryPoolIterator);
+    ComponentWrapper wrapper(m_ComponentInfo, data);
+    return wrapper;
+}
+
+bool ComponentPoolForwardIterator::operator==(const ComponentPoolForwardIterator& other) const
+{
+    return m_MemoryPoolIterator == other.m_MemoryPoolIterator;
+}
+
+bool ComponentPoolForwardIterator::operator!=(const ComponentPoolForwardIterator& other) const
+{
+    return m_MemoryPoolIterator != other.m_MemoryPoolIterator;
+}
+
+ComponentPoolForwardIterator& ComponentPoolForwardIterator::operator++(int)
+{
+    ComponentPoolForwardIterator copyIter(*this);
+    operator++();
+    return copyIter;
+}
+
+ComponentPoolForwardIterator& ComponentPoolForwardIterator::operator++()
+{
+    ++m_MemoryPoolIterator;
+    return *this;
+}
+
+//const ::ComponentInfo& ComponentPool::ComponentInfo() const
+//{
+//    return m_ComponentInfo;
+//}
+
+ComponentWrapper ComponentPool::Allocate(EntityID entity)
+{
+    char* data = m_Pool.Allocate();
+    memcpy(data, &entity, sizeof(EntityID));
+    m_EntityToComponent[entity] = data;
+    return ComponentWrapper(m_ComponentInfo, data);
+}
+
+ComponentWrapper ComponentPool::GetByEntity(EntityID ent)
+{
+    return ComponentWrapper(m_ComponentInfo, m_EntityToComponent.at(ent));
+}
+
+void ComponentPool::Delete(ComponentWrapper& wrapper)
+{
+    m_EntityToComponent.erase(wrapper.EntityID);
+    m_Pool.Free(wrapper.Data);
+}
+
+ComponentPool::iterator ComponentPool::begin() const
+{
+    return iterator(m_ComponentInfo, m_Pool.begin(), m_Pool.end());
+}
+
+ComponentPool::iterator ComponentPool::end() const
+{
+    return iterator(m_ComponentInfo, m_Pool.end(), m_Pool.end());
+}
+
+template <typename InterpretType /*= char*/>
+void ComponentPool::Dump() const
+{
+    m_Pool.Dump<InterpretType>();
+}
+
+template <typename InterpretType /*= char*/, typename OutStream>
+void ComponentPool::Dump(OutStream& out) const
+{
+    m_Pool.Dump<InterpretType>(out);
+}

src/Engine/Core/OctTree.cpp

@@ -168,6 +168,7 @@ void OctTree::AddBox(const AABB& box)
 }
 
 //remove the content (boxes) in the tree, but dont rememove the tree-structure
+//TODO: Only clear dynamic boxes, AddDynamic, AddStatic
 void OctTree::ClearBoxes()
 {
     if (hasChildren()) {

src/Engine/Core/World.cpp

@@ -0,0 +1,54 @@
+#include "Core/World.h"
+
+World::~World()
+{
+    for (auto& pool : m_ComponentPools) {
+        delete pool.second;
+    }
+}
+
+EntityID World::CreateEntity(EntityID parent /*= 0*/)
+{
+    EntityID newEntity = generateEntityID();
+    m_EntityParents[newEntity] = parent;
+    if (parent != 0) {
+        m_EntityChildren.insert(std::make_pair(parent, newEntity));
+    }
+    return newEntity;
+}
+
+void World::RegisterComponent(ComponentInfo& ci)
+{
+    m_ComponentPools[ci.Name] = new ComponentPool(ci);
+}
+
+ComponentWrapper World::AttachComponent(EntityID entity, std::string componentType)
+{
+    ComponentPool* pool = m_ComponentPools.at(componentType);
+    const ComponentInfo& ci = pool->ComponentInfo();
+
+    // Allocate space for the component
+    ComponentWrapper c = pool->Allocate(entity);
+    // Write default values
+    memcpy(c.Data, ci.Defaults.get(), ci.Meta.Stride);
+
+    return c;
+}
+
+ComponentWrapper World::GetComponent(EntityID entity, std::string componentType)
+{
+    ComponentPool* pool = m_ComponentPools.at(componentType);
+    return pool->GetByEntity(entity);
+}
+
+const ComponentPool& World::GetComponents(std::string componentType)
+{
+    return *m_ComponentPools.at(componentType);
+}
+
+EntityID World::generateEntityID()
+{
+    // TODO: Make EntityID generation smarter
+    return m_CurrentEntityID++;
+}
+

src/Engine/Network/Client.cpp

@@ -0,0 +1,11 @@
+#include "Network\Client.h"
+
+Client::Client()
+{
+
+}
+
+Client::~Client()
+{
+
+}

src/Engine/Network/Server.cpp

@@ -0,0 +1,11 @@
+#include "Network\Server.h"
+
+Server::Server()
+{
+
+}
+
+Server::~Server()
+{
+
+}

src/Engine/Rendering/Camera.cpp

@@ -17,6 +17,12 @@ glm::vec3 Camera::Forward()
 {
 	return m_Orientation * glm::vec3(0, 0, -1);
 }
+
+glm::vec3 Camera::Right()
+{
+	return m_Orientation * glm::vec3(1, 0, 0);
+}
+
 //
 //glm::vec3 Camera::Right()
 //{

src/Engine/Rendering/FrameBuffer.cpp

@@ -0,0 +1,88 @@
+
+#include "Rendering/FrameBuffer.h"
+
+
+BufferResource::BufferResource(GLuint* resourceHandle, GLenum resourceType, GLenum attachment)
+{
+    m_ResourceHandle = resourceHandle;
+    m_ResourceType = resourceType;
+    m_Attachment = attachment;
+}
+
+Texture2D::~Texture2D()
+{
+    if (m_ResourceHandle != 0) {
+        glDeleteTextures(1, m_ResourceHandle);
+    }
+}
+
+
+RenderBuffer::~RenderBuffer()
+{
+    if (m_ResourceHandle != 0) {
+        glDeleteRenderbuffers(1, m_ResourceHandle);
+    }
+}
+
+
+FrameBuffer::~FrameBuffer()
+{
+    if (m_BufferHandle != 0) {
+        glDeleteFramebuffers(1, &m_BufferHandle);
+    }
+}
+
+void FrameBuffer::AddResource(std::shared_ptr<BufferResource> resource)
+{
+    m_Resources.push_back(resource);
+}
+
+void FrameBuffer::Generate()
+{
+    std::vector<GLenum> attachments;
+
+    glGenFramebuffers(1, &m_BufferHandle);
+    glBindFramebuffer(GL_FRAMEBUFFER, m_BufferHandle);
+
+    for (auto it = m_Resources.begin(); it != m_Resources.end(); it++) {
+        switch ((*it)->m_ResourceType) {
+        case GL_TEXTURE_2D:
+            glFramebufferTexture2D(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle, 0);
+            break;
+        case GL_RENDERBUFFER:
+            glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
+            break;
+        }
+        
+        GLERROR("FrameBuffer generate");
+
+        if ((*it)->m_Attachment != GL_DEPTH_ATTACHMENT) {
+            attachments.push_back((*it)->m_Attachment);
+        }
+    }
+        
+   
+    
+    GLenum* bufferTextures = &attachments[0];
+    glDrawBuffers(1, bufferTextures);
+
+    if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
+        LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus);
+        exit(EXIT_FAILURE);
+    }
+}
+
+void FrameBuffer::Bind()
+{
+    glBindFramebuffer(GL_FRAMEBUFFER, m_BufferHandle);
+}
+
+void FrameBuffer::Unbind()
+{
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+}
+
+GLuint FrameBuffer::GetHandle()
+{
+    return m_BufferHandle;
+}

src/Engine/Rendering/RenderQueueFactory.cpp

@@ -0,0 +1,67 @@
+#include "Rendering/RenderQueueFactory.h"
+
+
+RenderQueueFactory::RenderQueueFactory()
+{
+    m_RenderQueues = RenderQueueCollection();
+}
+
+void RenderQueueFactory::Update(World* world)
+{
+    m_RenderQueues.Clear();
+    FillModels(world, &m_RenderQueues.Forward);
+    FillLights(world, &m_RenderQueues.Lights);
+}
+
+glm::mat4 RenderQueueFactory::ModelMatrix(World* world, EntityID entity)
+{
+    //should really return absolute model matrix based on parents position, scale and orientation
+    //GetAbsolutePosition(World* world, ComponentWrapper transformComponent)
+
+    ComponentWrapper transformComponent = world->GetComponent(entity, "Transform");
+    glm::vec3 position = transformComponent["Position"];
+    glm::vec3 scale = transformComponent["Scale"];
+    glm::quat oritentation = transformComponent["Orientation"];
+
+    glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(oritentation) * glm::scale(scale);
+    return modelMatrix;
+}
+
+glm::vec3 GetAbsolutePosition(World* world, ComponentWrapper transformComponent)
+{
+  //  positionComponent.EntityID
+    return glm::vec3();
+}
+
+void RenderQueueFactory::FillModels(World* world, RenderQueue* renderQueue)
+{
+   for(auto& modelC : world->GetComponents("Model")) {
+       ModelJob job;
+       std::string resource = modelC["Resource"];
+       glm::vec4 color = modelC["Color"];
+       Model* model = ResourceManager::Load<Model>(resource);
+
+       for (auto texGroup : model->TextureGroups) {
+           job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
+           job.DiffuseTexture = texGroup.Texture.get();
+           job.NormalTexture = texGroup.NormalMap.get();
+           job.SpecularTexture = texGroup.SpecularMap.get();
+           job.Model = model;
+           job.StartIndex = texGroup.StartIndex;
+           job.EndIndex = texGroup.EndIndex;
+           job.ModelMatrix = model->m_Matrix * ModelMatrix(world, modelC.EntityID);
+           job.Color = color;
+
+           //TODO: RENDERER: Not sure if the best solution for pickingColor to entity link is this
+           job.Entity = modelC.EntityID;
+
+           renderQueue->Add(job);
+       }
+   }
+}
+
+void RenderQueueFactory::FillLights(World* world, RenderQueue* renderQueue)
+{
+
+}
+

src/Engine/Rendering/Renderer.cpp

@@ -0,0 +1,329 @@
+#include "Rendering/Renderer.h"
+
+void Renderer::Initialize()
+{
+	InitializeWindow();
+
+	// Create default camera
+	m_DefaultCamera = new ::Camera((float)m_Resolution.Width / m_Resolution.Height, glm::radians(45.f), 0.01f, 5000.f);
+	m_DefaultCamera->SetPosition(glm::vec3(0, 0, 10));
+	if (m_Camera == nullptr) {
+		m_Camera = m_DefaultCamera;
+	}
+
+	glfwSwapInterval(m_VSYNC);
+	InitializeShaders();
+    InitializeTextures();
+    InitializeFrameBuffers();
+
+
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+    m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
+    m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");
+}
+
+void Renderer::InitializeWindow()
+{
+	// Initialize GLFW
+	if (!glfwInit()) {
+		LOG_ERROR("GLFW: Initialization failed");
+		exit(EXIT_FAILURE);
+	}
+
+	// Create a window
+	GLFWmonitor* monitor = nullptr;
+	if (m_Fullscreen) {
+		monitor = glfwGetPrimaryMonitor();
+	}
+	//glfwWindowHint(GLFW_SAMPLES, 8);
+	m_Window = glfwCreateWindow(m_Resolution.Width, m_Resolution.Height, "daydream", monitor, nullptr);
+	if (!m_Window) {
+		LOG_ERROR("GLFW: Failed to create window");
+		exit(EXIT_FAILURE);
+	}
+	glfwMakeContextCurrent(m_Window);
+
+	// GL version info
+	glGetIntegerv(GL_MAJOR_VERSION, &m_GLVersion[0]);
+	glGetIntegerv(GL_MINOR_VERSION, &m_GLVersion[1]);
+	m_GLVendor = (GLchar*)glGetString(GL_VENDOR);
+	std::stringstream ss;
+	ss << m_GLVendor << " OpenGL " << m_GLVersion[0] << "." << m_GLVersion[1];
+#ifdef DEBUG
+	ss << " DEBUG";
+#endif
+	LOG_INFO(ss.str().c_str());
+	glfwSetWindowTitle(m_Window, ss.str().c_str());
+
+	// Initialize GLEW
+	if (glewInit() != GLEW_OK) {
+		LOG_ERROR("GLEW: Initialization failed");
+		exit(EXIT_FAILURE);
+	}
+}
+
+void Renderer::InitializeShaders()
+{
+	m_BasicForwardProgram.AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/BasicForward.vert.glsl")));
+	m_BasicForwardProgram.AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/BasicForward.frag.glsl")));
+	m_BasicForwardProgram.Compile();
+	m_BasicForwardProgram.Link();
+
+    m_PickingProgram.AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Picking.vert.glsl")));
+    m_PickingProgram.AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Picking.frag.glsl")));
+    m_PickingProgram.Compile();
+    m_PickingProgram.BindFragDataLocation(0, "TextureFragment");
+    m_PickingProgram.Link();
+
+    m_DrawScreenQuadProgram.AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawScreenQuad.vert.glsl")));
+    m_DrawScreenQuadProgram.AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl")));
+    m_DrawScreenQuadProgram.Compile();
+    m_DrawScreenQuadProgram.Link();
+
+}
+
+void Renderer::InputUpdate(double dt)
+{
+	glm::vec3 m_Position = m_Camera->Position();
+	if (glfwGetKey(m_Window, GLFW_KEY_O) == GLFW_PRESS)
+	{
+		m_Position = glm::vec3(0.f, 0.f, 5.f);
+	}
+	if (glfwGetKey(m_Window, GLFW_KEY_W) == GLFW_PRESS)
+	{
+		m_Position += m_Camera->Forward() * m_CameraMoveSpeed * (float)dt;
+	}
+	if (glfwGetKey(m_Window, GLFW_KEY_S) == GLFW_PRESS)
+	{
+		m_Position -= m_Camera->Forward() * m_CameraMoveSpeed * (float)dt;
+	}
+	if (glfwGetKey(m_Window, GLFW_KEY_D) == GLFW_PRESS)
+	{
+		m_Position += m_Camera->Right() * m_CameraMoveSpeed * (float)dt;
+	}
+	if (glfwGetKey(m_Window, GLFW_KEY_A) == GLFW_PRESS)
+	{
+		m_Position -= m_Camera->Right() * m_CameraMoveSpeed * (float)dt;
+	}
+	if (glfwGetKey(m_Window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
+	{
+		m_CameraMoveSpeed = 5.f;
+	}
+	else {
+		m_CameraMoveSpeed = 0.5f;
+	}
+
+
+    static double mousePosX, mousePosY;
+    glfwGetCursorPos(m_Window, &mousePosX, &mousePosY);
+    if (glfwGetMouseButton(m_Window, GLFW_MOUSE_BUTTON_1) == GLFW_PRESS) {
+        glm::vec3 data = ScreenCoords::ToPixelData(mousePosX, m_Resolution.Height - mousePosY, &m_PickingBuffer, m_DepthBuffer);
+        glm::vec2 color = glm::vec2(data);
+        float depth = data.z;
+        
+        glm::vec3 viewPos = ScreenCoords::ToWorldPos(mousePosX, m_Resolution.Height - mousePosY, depth, m_Resolution, m_Camera->ProjectionMatrix(), m_Camera->ViewMatrix());
+      //  glm::vec3 worldPos = glm::vec3(glm::inverse(m_Camera->ViewMatrix()) * glm::vec4(viewPos, 1.f));
+
+        //printf("R: %f, G: %f, Depth: %f\n", color.r, color.g, depth);
+        //printf("view: x: %f, y: %f z: %f, Length: %f\n\n", viewPos.x, viewPos.y, viewPos.z, glm::length(viewPos));
+
+        if (color != glm::vec2(0, 0)) {
+            EntityID pickedEntity = m_PickingColorsToEntity[color];
+            printf("Picked Entity: %i", pickedEntity);
+
+        }
+    }
+
+	if (glfwGetKey(m_Window, GLFW_KEY_SPACE) == GLFW_PRESS) {
+
+		
+		double deltaX, deltaY;
+		deltaX = mousePosX - (float)Resolution().Width / 2;
+		deltaY = mousePosY - (float)Resolution().Height / 2;
+
+		float rotationY = -deltaY / 300.f;
+		float rotationX = -deltaX / 300.f;
+		glm::quat orientation = m_Camera->Orientation();
+		
+		
+		orientation = orientation * glm::angleAxis<float>(rotationY, glm::vec3(1, 0, 0));
+		orientation = glm::angleAxis<float>(rotationX, glm::vec3(0, 1, 0)) * orientation;
+		
+		m_Camera->SetOrientation(orientation);
+
+		glfwSetCursorPos(m_Window, Resolution().Width / 2, Resolution().Height / 2);
+	}
+	m_Camera->SetPosition(m_Position);
+}
+
+void Renderer::Update(double dt)
+{
+	InputUpdate(dt);
+    
+}
+
+void Renderer::Draw(RenderQueueCollection& rq)
+{
+    //TODO: Renderer: Kanske borde vara längst upp i update.
+    PickingPass(rq);
+    DrawScreenQuad(m_PickingTexture);
+    
+    DrawScene(rq);
+	glfwSwapBuffers(m_Window);
+}
+
+void Renderer::DrawScene(RenderQueueCollection& rq)
+{
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    //TODO: Render: Clean up draw code
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_BACK);
+
+    glClearColor(255.f / 255, 163.f / 255, 176.f / 255, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    //TODO: Render: Add code for more jobs than modeljobs.
+    for (auto &job : rq.Forward) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+        if (modelJob) {
+            GLuint ShaderHandle = m_BasicForwardProgram.GetHandle();
+
+            m_BasicForwardProgram.Bind();
+            //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->ModelMatrix));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Camera->ViewMatrix()));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Camera->ProjectionMatrix()));
+            glUniform4fv(glGetUniformLocation(ShaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
+
+            //TODO: Renderer: bättre textur felhantering samt fler texturer stöd
+            if (modelJob->DiffuseTexture != nullptr) {
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture->m_Texture);
+            } else {
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+            }
+
+            glBindVertexArray(modelJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+            glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, 0, modelJob->StartIndex);
+
+            continue;
+        }
+    }
+}
+
+void Renderer::PickingPass(RenderQueueCollection& rq)
+{
+    m_PickingBuffer.Bind();
+
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_BACK);
+
+    glClearColor(0.f, 0.f, 0.f, 1.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    int r = 30;
+    int g = 0;
+    //TODO: Render: Add code for more jobs than modeljobs.
+
+
+    GLuint ShaderHandle = m_PickingProgram.GetHandle();
+    m_PickingProgram.Bind();
+
+    for (auto &job : rq.Forward) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+
+        if (modelJob) {
+            glm::vec2 pickColor = glm::vec2(r/255.f, g/255.f);
+            m_PickingColorsToEntity[pickColor] = modelJob->Entity;
+            
+
+            //Render picking stuff
+            //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->ModelMatrix));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Camera->ViewMatrix()));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Camera->ProjectionMatrix()));
+            glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(pickColor));
+
+            glBindVertexArray(modelJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+            glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, 0, modelJob->StartIndex);
+            r+=50;
+            if(r > 255) {
+                r = 0;
+                g+=50;
+            }
+        }
+    }
+    m_PickingBuffer.Unbind();
+}
+
+
+void Renderer::DrawScreenQuad(GLuint textureToDraw)
+{
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_CULL_FACE);
+
+    glClearColor(0.f, 0.f, 0.f, 1.f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+
+    m_DrawScreenQuadProgram.Bind();
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, textureToDraw);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->TextureGroups[0].EndIndex - m_ScreenQuad->TextureGroups[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->TextureGroups[0].StartIndex);
+}
+
+
+void Renderer::InitializeTextures()
+{
+    m_ErrorTexture=ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
+    m_WhiteTexture=ResourceManager::Load<Texture>("Textures/Core/Blank.png");
+    /*
+    glGenTextures(1, &m_PickingTexture);
+    glBindTexture(GL_TEXTURE_2D, m_PickingTexture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RG8, m_Resolution.Width, m_Resolution.Height, 0, GL_RG, GL_FLOAT, NULL);//TODO: Renderer: Fix the precision and Resolution
+    GLERROR("m_PickingTexture initialization failed");
+    */
+
+    GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
+        glm::vec2(m_Resolution.Width, m_Resolution.Height), GL_RG8, GL_RG, GL_FLOAT);
+}
+
+void Renderer::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type)
+{
+    glGenTextures(1, texture);
+    glBindTexture(GL_TEXTURE_2D, *texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, NULL);//TODO: Renderer: Fix the precision and Resolution
+    GLERROR("Texture initialization failed");
+}
+
+
+
+void Renderer::InitializeFrameBuffers()//TODO: Renderer: Get this to a better location, as its really big
+{
+    glGenRenderbuffers(1, &m_DepthBuffer);
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Resolution.Width, m_Resolution.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)));
+    m_PickingBuffer.Generate();
+}

src/Engine/Rendering/ShaderProgram.cpp

@@ -0,0 +1,163 @@
+#include "Rendering/ShaderProgram.h"
+
+GLuint Shader::CompileShader(GLenum shaderType, std::string fileName)
+{
+	LOG_INFO("Compiling shader \"%s\"", fileName.c_str());
+
+	std::string shaderFile;
+	std::ifstream in(fileName, std::ios::in);
+	if (!in) {
+		LOG_ERROR("Error: Failed to open shader file \"%s\"", fileName.c_str());
+		return 0;
+	}
+	in.seekg(0, std::ios::end);
+	shaderFile.resize((int)in.tellg());
+	in.seekg(0, std::ios::beg);
+	in.read(&shaderFile[0], shaderFile.size());
+	in.close();
+
+	GLuint shader = glCreateShader(shaderType);
+	if (GLERROR("glCreateShader"))
+		return 0;
+
+	const GLchar* shaderFiles = shaderFile.c_str();
+	const GLint length = shaderFile.length();
+	glShaderSource(shader, 1, &shaderFiles, &length);
+	if (GLERROR("glShaderSource"))
+		return 0;
+
+	glCompileShader(shader);
+
+	GLint compileStatus;
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
+	if (compileStatus != GL_TRUE) {
+		LOG_ERROR("Shader compilation failed");
+		GLsizei infoLogLength;
+		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
+		GLchar* infolog = new GLchar[infoLogLength];
+		glGetShaderInfoLog(shader, infoLogLength, &infoLogLength, infolog);
+		LOG_ERROR(infolog);
+		delete[] infolog;
+	}
+
+	if (GLERROR("glCompileShader"))
+		return 0;
+
+	return shader;
+}
+
+Shader::Shader(GLenum shaderType, std::string fileName) : m_ShaderType(shaderType), m_FileName(fileName)
+{
+	m_ShaderHandle = 0;
+}
+
+Shader::~Shader()
+{
+	if (m_ShaderHandle != 0) {
+		glDeleteShader(m_ShaderHandle);
+	}
+}
+
+GLuint Shader::Compile()
+{
+	m_ShaderHandle = CompileShader(m_ShaderType, m_FileName);
+	return m_ShaderHandle;
+}
+
+GLenum Shader::GetType() const
+{
+	return m_ShaderType;
+}
+
+std::string Shader::GetFileName() const
+{
+	return m_FileName;
+}
+
+GLuint Shader::GetHandle() const
+{
+	return m_ShaderHandle;
+}
+
+bool Shader::IsCompiled() const
+{
+	return m_ShaderHandle != 0;
+}
+
+ShaderProgram::~ShaderProgram()
+{
+	if (m_ShaderProgramHandle != 0) {
+		glDeleteProgram(m_ShaderProgramHandle);
+	}
+}
+
+void ShaderProgram::AddShader(std::shared_ptr<Shader> shader)
+{
+	m_Shaders.push_back(shader);
+}
+
+void ShaderProgram::Compile()
+{
+	if (m_ShaderProgramHandle == 0)
+	{
+		m_ShaderProgramHandle = glCreateProgram();
+	}
+
+	for (auto &shader : m_Shaders)
+	{
+		if (!shader->IsCompiled())
+		{
+			shader->Compile();
+		}
+	}
+}
+
+GLuint ShaderProgram::Link()
+{
+	if (m_Shaders.size() == 0)
+	{
+		LOG_ERROR("Failed to link shader program: No shaders bound");
+		return 0;
+	}
+
+	LOG_INFO("Linking shader program");
+
+	for (auto &shader : m_Shaders)
+	{
+		glAttachShader(m_ShaderProgramHandle, shader->GetHandle());
+	}
+	glLinkProgram(m_ShaderProgramHandle);
+	if (GLERROR("glLinkProgram"))
+		return 0;
+	m_Shaders.clear();
+
+	return m_ShaderProgramHandle;
+}
+
+GLuint ShaderProgram::GetHandle()
+{
+	return m_ShaderProgramHandle;
+}
+
+void ShaderProgram::Bind()
+{
+	if (m_ShaderProgramHandle == 0)
+		return;
+
+	glUseProgram(m_ShaderProgramHandle);
+}
+
+void ShaderProgram::Unbind()
+{
+	glActiveShaderProgram(0, 0);
+}
+
+void ShaderProgram::BindFragDataLocation(int index, std::string name)
+{
+
+    if (m_ShaderProgramHandle == 0)
+        return;
+
+    glBindFragDataLocation(m_ShaderProgramHandle, index, name.c_str());
+}
+

src/Engine/Rendering/Util/ScreenCoords.cpp

@@ -0,0 +1,50 @@
+#include "Rendering/Util/ScreenCoords.h"
+
+glm::vec3 ScreenCoords::ToWorldPos(float x, float y, float depth, float screenWidth, float screenHeight, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat)
+{
+    glm::vec3 ndc;
+    ndc.x = (x / screenWidth)*2.f - 1.f;
+    ndc.y = (y / screenHeight)*2.f - 1.f;
+    ndc.z = depth*2.f - 1.f;
+    glm::vec4 clipSpace = glm::vec4(ndc, 1.0f);
+    glm::vec4 EyeSpace = glm::inverse(cameraProjectionMat) * clipSpace;
+    glm::vec4 WorldSpace = glm::inverse(cameraViewMat) * EyeSpace;
+    WorldSpace = glm::vec4(glm::vec3(WorldSpace) / WorldSpace.w, 1.f);
+
+    return glm::vec3(WorldSpace);
+}
+
+glm::vec3 ScreenCoords::ToWorldPos(glm::vec2 screenCoord, float depth, Rectangle resolution, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat)
+{
+    return ToWorldPos(screenCoord.x, screenCoord.y, depth, resolution.Width, resolution.Height, cameraProjectionMat, cameraViewMat);
+}
+
+glm::vec3 ScreenCoords::ToWorldPos(float x, float y, float depth, Rectangle resolution, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat)
+{
+    return ToWorldPos(x, y, depth, resolution.Width, resolution.Height, cameraProjectionMat, cameraViewMat);
+}
+
+glm::vec3 ScreenCoords::ToWorldPos(glm::vec2 screenCoord, float depth, float screenWidth, float screenHeight, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat)
+{
+    return ToWorldPos(screenCoord.x, screenCoord.y, depth, screenWidth, screenHeight, cameraProjectionMat, cameraViewMat);
+}
+
+glm::vec3 ScreenCoords::ToPixelData(float x, float y, FrameBuffer* PickDataBuffer, GLuint DepthBuffer)
+{
+    PickDataBuffer->Bind();
+    glm::vec2 pixelData;
+    glReadPixels(x, y, 1, 1, GL_RG, GL_FLOAT, &pixelData);
+    PickDataBuffer->Unbind();
+
+    glBindFramebuffer(GL_FRAMEBUFFER, DepthBuffer);
+    float depthData;
+    glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depthData);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    return glm::vec3(pixelData, depthData);
+}
+
+glm::vec3 ScreenCoords::ToPixelData(glm::vec2 screenCoord, FrameBuffer* PickDataBuffer, GLuint DepthBuffer)
+{
+    return ToPixelData(screenCoord.x, screenCoord.y, PickDataBuffer, DepthBuffer);
+}

src/Game/Game.cpp

@@ -1,8 +1,11 @@
 #include "Game.h"
+#include "HardcodedTestWorld.h"
 
 Game::Game(int argc, char* argv[])
 {
 	ResourceManager::RegisterType<ConfigFile>("ConfigFile");
+	ResourceManager::RegisterType<Model>("Model");
+	ResourceManager::RegisterType<Texture>("Texture");
 
 	m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
 	LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
@@ -10,8 +13,10 @@ Game::Game(int argc, char* argv[])
 	// Create the core event broker
 	m_EventBroker = new EventBroker();
 
+    m_RenderQueueFactory = new RenderQueueFactory();
+
 	// Create the renderer
-	m_Renderer = new DummyRenderer();
+	m_Renderer = new Renderer();
 	m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
 	m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false));
 	m_Renderer->SetResolution(Rectangle(
@@ -30,6 +35,9 @@ Game::Game(int argc, char* argv[])
 	m_FrameStack->Width = m_Renderer->Resolution().Width;
 	m_FrameStack->Height = m_Renderer->Resolution().Height;
 
+    // Create a TEST WORLD
+    m_World = new HardcodedTestWorld();
+
 	m_LastTime = glfwGetTime();
 }
 
@@ -47,10 +55,12 @@ void Game::Tick()
 
 	m_EventBroker->Swap();
 	m_InputManager->Update(dt);
+	m_Renderer->Update(dt);
 	m_EventBroker->Swap();
 
-	RenderQueueCollection rq;
-	m_Renderer->Draw(rq);
+    m_RenderQueueFactory->Update(m_World);
+
+	m_Renderer->Draw(m_RenderQueueFactory->RenderQueues());
 
 	m_EventBroker->Swap();
 	m_EventBroker->Clear();

src/Tests/CollisionTest.cpp

@@ -92,11 +92,12 @@ BOOST_AUTO_TEST_CASE(octTest)
     glm::vec3 mini = glm::vec3(-1, -1, -1);
     glm::vec3 maxi = glm::vec3(1, 1, 1);
     OctTree tree(AABB(mini, maxi), 2);
-    tree.AddBox(AABB(mini, 0.1f*maxi));
+    tree.AddBox(AABB(mini, -0.9f*maxi));
     OctTree::Output data;
-    BOOST_CHECK(tree.RayCollides({ glm::vec3(0, 0, 0), glm::normalize(mini) }, data));
+    glm::vec3 origin = 3.0f * mini;
+    BOOST_CHECK(tree.RayCollides({origin , glm::normalize(mini - origin) }, data));
     tree.ClearBoxes();
-    BOOST_CHECK(!tree.RayCollides({ glm::vec3(0, 0, 0), glm::normalize(mini) }, data));
+    BOOST_CHECK(!tree.RayCollides({ origin , glm::normalize(mini - origin) }, data));
 }
 
 BOOST_AUTO_TEST_SUITE_END()

src/Tests/ComponentPoolTest.cpp

@@ -0,0 +1,34 @@
+#include <boost/test/unit_test.hpp>
+
+#include "Core/ComponentPool.h"
+
+BOOST_AUTO_TEST_CASE(ComponentPoolTest)
+{
+    // TODO: Write an updated test for component pool
+    BOOST_CHECK(false);
+    //ComponentInfo ci;
+    //ci.Name = "Test";
+    //ci.FieldTypes["Field"] = "int";
+    //ci.FieldOffsets["Field"] = 0;
+    //ci.Meta.Allocation = 3;
+    //ci.Meta.Stride = sizeof(EntityID) + sizeof(int);
+
+    //std::vector<ComponentWrapper> wrappers;
+    //ComponentPool pool(ci);
+    //for (int i = 0; i < 4; i++) {
+    //    ComponentWrapper c = pool.New();
+    //    c.EntityID = i;
+    //    unsigned int offset = c.Info.FieldOffsets.at("Field");
+    //    memcpy(&c.Data[offset], &i, sizeof(int));
+    //    wrappers.push_back(c);
+    //}
+
+    //int i = 0;
+    //for (auto& c : pool) {
+    //    BOOST_CHECK(c.EntityID == i);
+    //    BOOST_CHECK((int)c["Field"] == i);
+    //    i++;
+    //}
+
+    //pool.Delete(wrappers[1]);
+}

src/Tests/WorldTest.cpp

@@ -0,0 +1,71 @@
+#include <boost/test/unit_test.hpp>
+namespace utf = boost::unit_test;
+
+#include "Common.h"
+#include "GLM.h"
+#include "Core/World.h"
+
+BOOST_AUTO_TEST_CASE(WorldTestSingleAllocation, * boost::unit_test::tolerance(0.001))
+{
+    World w;
+
+    auto f = ComponentWrapperFactory("Test");
+    f.AddProperty("TestInteger", 1337);
+    f.AddProperty("TestDouble", 13.37);
+    f.AddProperty("TestString", std::string("Carlito"));
+    f.AddProperty("TestVec3", glm::vec3(1.f, 2.f, 3.f));
+    w.RegisterComponent(f);
+
+    EntityID e = w.CreateEntity();
+    ComponentWrapper c = w.AttachComponent(e, "Test");
+
+    // Check default values
+    BOOST_TEST((int)c["TestInteger"] == c.Property<int>("TestInteger"));
+    BOOST_TEST((int)c["TestInteger"] == 1337);
+    BOOST_TEST((double)c["TestDouble"] == 13.37);
+    BOOST_TEST((std::string)c["TestString"] == "Carlito");
+    glm::vec3 vec3 = c["TestVec3"];
+    BOOST_TEST(vec3.x == 1.f);
+    BOOST_TEST(vec3.y == 2.f);
+    BOOST_TEST(vec3.z == 3.f);
+
+    // Change values
+    ((int&)c["TestInteger"]) += 1;
+    BOOST_TEST((int)c["TestInteger"] == 1338);
+    ((double&)c["TestDouble"]) += 1.11;
+    std::cout << (double)c["TestDouble"] << std::endl;
+    BOOST_TEST((double)c["TestDouble"] == 14.48);
+    c["TestString"] = "Siesta";
+    BOOST_TEST((std::string)c["TestString"] == "Siesta");
+    ((glm::vec3&)c["TestVec3"]).y += 1.f;
+    BOOST_TEST(((glm::vec3)c["TestVec3"]).y == 3.f);
+}
+
+BOOST_AUTO_TEST_CASE(WorldTestMultipleAllocations, * utf::tolerance(0.00001))
+{
+    World w;
+
+    // Create allocation for 3 entities
+    auto f = ComponentWrapperFactory("Test", 3);
+    f.AddProperty("TestInteger", 1337);
+    f.AddProperty("TestDouble", 13.37);
+    f.AddProperty("TestString", std::string("Carlito"));
+    f.AddProperty("TestVec3", glm::vec3(1.f, 2.f, 3.f));
+    w.RegisterComponent(f);
+
+    // Create 6 entities with Test components
+    // 3 will reside in contiguous memory
+    // 3 will be allocated dynamically
+    for (int i = 0; i < 6; i++) {
+        EntityID e = w.CreateEntity();
+        ComponentWrapper c = w.AttachComponent(e, "Test");
+        c["TestInteger"] = i;
+    }
+
+    // Loop through them and check data
+    int i = 0;
+    for (auto& c : w.GetComponents("Test")) {
+        BOOST_TEST((int)c["TestInteger"] == i);
+        i++;
+    }
+}