Revert "Shadow will actually shut itself off and delete itself now"

Shadow will actually shut itself off and delete itself now

include/Engine/Network/Client.h

@@ -10,30 +10,31 @@
 #include <boost/asio.hpp>
 #include <boost/shared_array.hpp>
 
+#include "Core/World.h"
+#include "Core/EntityFile.h"
+#include "Core/EventBroker.h"
+#include "Core/ConfigFile.h"
+#include "Core/EPlayerDeath.h"
+#include "Core/EPlayerDamage.h"
+#include "Core/EPlayerSpawned.h"
+#include "Core/EAmmoPickup.h"
+#include "Game/Events/EDoubleJump.h"
+#include "Game/Events/EDashAbility.h"
+#include "Game/Events/EReset.h"
+#include "Input/EInputCommand.h"
+#include "imgui/imgui.h"
 #include "Network/Network.h"
 #include "Network/MessageType.h"
 #include "Network/PlayerDefinition.h"
 #include "Network/UDPClient.h"
 #include "Network/TCPClient.h"
 #include "Network/SnapshotDefinitions.h"
-#include "Core/World.h"
-#include "Core/EntityFile.h"
-#include "Core/EventBroker.h"
-#include "Core/ConfigFile.h"
-#include "Core/EPlayerDeath.h"
-#include "Input/EInputCommand.h"
-#include "Core/EPlayerDamage.h"
-#include "../Game/Events/EDoubleJump.h"
-#include "Network/EInterpolate.h"
-#include "Network/SnapshotFilter.h"
-#include "Core/EPlayerSpawned.h"
-#include "Core/EAmmoPickup.h"
-#include "Network/ESearchForServers.h"
-#include "../Game/Events/EDashAbility.h"
 #include "Network/EDisplayServerlist.h"
 #include "Network/EConnectRequest.h"
 #include "Network/EPlayerDisconnected.h"
-#include "Game/Events/EReset.h"
+#include "Network/ESearchForServers.h"
+#include "Network/EInterpolate.h"
+#include "Network/SnapshotFilter.h"
 
 class Client : public Network
 {

include/Engine/Rendering/DrawFinalPass.h

@@ -76,7 +76,6 @@ private:
 	const ShadowPass* m_ShadowPass;
 
     ShaderProgram* m_ForwardPlusProgram;
-	ShaderProgram* m_ForwardPlusNoShadowsProgram;
     ShaderProgram* m_ExplosionEffectProgram;
 	ShaderProgram* m_ExplosionEffectSplatMapProgram;
     ShaderProgram* m_SpriteProgram;

include/Engine/Rendering/Renderer.h

@@ -71,7 +71,6 @@ private:
     bool m_ResizeWindow = false;
 	int m_SSAO_Quality = 0;
 	int m_GLOW_Quality = 2;
-	bool m_Shadow_Enabled = true;
 
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;

include/Engine/Rendering/ShadowPass.h

@@ -38,8 +38,6 @@ public:
 	void ClearBuffer();
 	void Draw(RenderScene& scene);
 
-	void CheckStatus(bool status);
-
 	void DebugGUI();
 
 	GLuint DepthMap() const { return m_DepthMap; }
@@ -47,7 +45,6 @@ public:
 	std::array<glm::mat4, MAX_SPLITS> LightV() const { return m_LightView; }
 	std::array<float, MAX_SPLITS> FarDistance() const { std::array<float, MAX_SPLITS> f; for (int i = 0; i < MAX_SPLITS; i++) f[i] = m_shadowFrusta[i].FarClip; return f; }
 	int CurrentNrOfSplits() const { return m_CurrentNrOfSplits; }
-	bool EnableShadows() const { return m_EnableShadows; }
 
 	void SetSplitWeight(float split_weight) { m_SplitWeight = split_weight; };
 private:
@@ -66,8 +63,8 @@ private:
 
 	GLuint m_DepthMap;
 	FrameBuffer m_DepthBuffer;
-	ShaderProgram* m_ShadowProgram;
-	ShaderProgram* m_ShadowProgramSkinned;
+    ShaderProgram* m_ShadowProgram;
+    ShaderProgram* m_ShadowProgramSkinned;
 
 	std::array<glm::mat4, MAX_SPLITS> m_LightProjection;
 	std::array<glm::mat4, MAX_SPLITS> m_LightView;
@@ -78,7 +75,7 @@ private:
 
 	bool m_TransparentObjects = false;
 	bool m_TexturedShadows = false;
-	bool m_EnableShadows = false;
+	bool m_EnableShadows = true;
 
 	int m_CurrentNrOfSplits = 4;
 	float m_SplitWeight = 0.962f;

include/Engine/Sound/SoundManager.h

@@ -30,6 +30,7 @@
 #include "../Engine/Core/EPause.h"
 #include "../Engine/Core/EComponentAttached.h"
 #include "../Core/EPlayerSpawned.h"
+#include "../Rendering/ESetCamera.h"
 
 
 typedef std::pair<ALuint, std::vector<ALuint>> QueuedBuffers;
@@ -91,7 +92,6 @@ private:
     void matchBGMLoop();
     Source* m_CurrentBGM = nullptr;
     Source* m_CurrentBGMCombo = nullptr;
-    bool m_DrumLoopHasBeenStarted = false;
 
     // Logic
     World* m_World = nullptr;
@@ -139,6 +139,8 @@ private:
     bool OnPlayQueueOnEntity(const Events::PlayQueueOnEntity &e);
     EventRelay<SoundManager, Events::ChangeBGM> m_EChangeBGM;
     bool OnChangeBGM(const Events::ChangeBGM &e);
+    EventRelay<SoundManager, Events::SetCamera> m_ESetCamera;
+    bool OnSetCamera(const Events::SetCamera& e);
 
 
 };

resources/Shaders/ForwardPlusNoShadows.frag.glsl

@@ -1,204 +0,0 @@
-#version 430
-
-#define MIN_AMBIENT_LIGHT 0.3
-#define MAX_SPLITS 4
-
-uniform mat4 VM;
-uniform mat4 M;
-uniform mat4 V;
-uniform mat4 P;
-uniform vec4 Color;
-uniform vec4 DiffuseColor;
-uniform vec2 ScreenDimensions;
-uniform vec4 FillColor;
-uniform vec4 AmbientColor;
-uniform float FillPercentage;
-uniform float GlowIntensity;
-uniform vec3 CameraPosition;
-uniform int SSAOQuality;
-uniform float FarDistance[MAX_SPLITS];
-
-uniform vec2 DiffuseUVRepeat;
-uniform vec2 NormalUVRepeat;
-uniform vec2 SpecularUVRepeat;
-uniform vec2 GlowUVRepeat;
-layout (binding = 0) uniform sampler2D AOTexture;
-layout (binding = 1) uniform sampler2D DiffuseTexture;
-layout (binding = 2) uniform sampler2D NormalMapTexture;
-layout (binding = 3) uniform sampler2D SpecularMapTexture;
-layout (binding = 4) uniform sampler2D GlowMapTexture;
-layout (binding = 5) uniform samplerCube CubeMap;
-
-#define TILE_SIZE 16
-
-struct LightSource {
-	vec4 Position;
-	vec4 Direction;
-	vec4 Color;
-	float Radius;
-	float Intensity;
-	float Falloff;
-	int Type;
-};
-
-layout (std430, binding = 1) buffer LightBuffer
-{
-	LightSource List[];
-} LightSources;
-
-struct LightGrid {
-	float Start;
-	float Amount;
-	vec2 Padding;
-};
-
-layout (std430, binding = 2) buffer LightGridBuffer
-{
-	LightGrid Data[];
-} LightGrids;
-
-layout (std430, binding = 4) buffer LightIndexBuffer
-{
-	float LightIndex[];
-};
-
-in VertexData{
-	vec3 Position;
-	vec3 Normal;
-	vec3 Tangent;
-	vec3 BiTangent;
-	vec2 TextureCoordinate;
-	vec4 ExplosionColor;
-	float ExplosionPercentageElapsed;
-	vec4 PositionLightSpace[MAX_SPLITS];
-}Input;
-
-out vec4 sceneColor;
-out vec4 bloomColor;
-
-struct LightResult {
-	vec4 Diffuse;
-	vec4 Specular;
-};
-
-float CalcAttenuation(float radius, float dist, float falloff) {
-	return 1.0 - smoothstep(radius * falloff, radius, dist);
-}
-
-vec4 CalcSpecular(vec4 lightColor, vec4 viewVec,  vec4 lightVec, vec4 normal) {
-	vec4 R = normalize( reflect(-lightVec, normal));
-	float RdotV = max( dot(R, viewVec), 0.0);
-	return lightColor * pow(RdotV, 90.0);
-}
-
-vec4 CalcDiffuse(vec4 lightColor, vec4 lightVec, vec4 normal) {
-	float power = max( dot(normal, lightVec), 0.0);
-	return lightColor * power;
-}
-
-LightResult CalcPointLightSource(vec4 lightPos, float lightRadius, vec4 lightColor, float intensity, vec4 viewVec, vec4 position, vec4 normal, float falloff)
-{
-	vec4 L = lightPos - position;
-	float dist = length(L);
-	L = normalize(L);
-
-	float attenuation = CalcAttenuation(lightRadius, dist, falloff);
-
-	LightResult result;
-	result.Diffuse = CalcDiffuse(lightColor, L, normal) * attenuation * intensity;
-	result.Specular = CalcSpecular(lightColor, viewVec, L, normal) * attenuation *  intensity;
-	return result;
-}
-
-LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensity, vec4 viewVec, vec4 vertNormal)
-{
-	vec4 L = normalize( -vec4(direction.xyz, 0) );
-
-	LightResult result;
-	result.Diffuse = CalcDiffuse(color, L, vertNormal) * intensity;
-	result.Specular = CalcSpecular(color, viewVec, L, vertNormal) * intensity;
-	return result;
-}
-
-vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textureCoordinate, sampler2D normalMap)
-{
-	mat3 TBN = mat3(tangent, bitangent, normal);
-	vec3 NormalMap = texture(normalMap, textureCoordinate).xyz * 2.0 - vec3(1.0);
-	return vec4(TBN * normalize(NormalMap), 0.0);
-}
-
-void main()
-{
-	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
-	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
-	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate * DiffuseUVRepeat);
-	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate * GlowUVRepeat);
-	vec4 specularTexel = texture2D(SpecularMapTexture, Input.TextureCoordinate * SpecularUVRepeat);
-	vec4 position = VM * vec4(Input.Position, 1.0); 
-	vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate * NormalUVRepeat, NormalMapTexture);
-	normal = normalize(normal);
-	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
-	vec4 viewVec = normalize(-position);
-	vec3 I = normalize(vec3(M * vec4(Input.Position, 1.0)) - CameraPosition);
-	vec3 R = reflect(-I, Input.Normal);
-	//R = vec3(P * vec4(R, 1.0));
-	vec4 reflectionColor = texture(CubeMap, R);
-
-	vec2 tilePos;
-	tilePos.x = int(gl_FragCoord.x/TILE_SIZE);
-	tilePos.y = int(gl_FragCoord.y/TILE_SIZE);
-
-	LightResult totalLighting;
-	totalLighting.Diffuse = vec4(AmbientColor.rgb * ao, 1.0);
-	int currentTile = int(floor(gl_FragCoord.x/TILE_SIZE) + (floor(gl_FragCoord.y/TILE_SIZE) * int(ScreenDimensions.x/TILE_SIZE)));
-
-	int start = int(LightGrids.Data[currentTile].Start);
-	int amount = int(LightGrids.Data[currentTile].Amount);
-	
-	for(int i = start; i < start + amount; i++) {
-
-		int l = int(LightIndex[i]);
-		LightSource light = LightSources.List[l];
-
-		LightResult light_result;
-		//These if statements should be removed.
-		if(light.Type == 1) { // point
-			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
-		} else if (light.Type == 2) { //Directional
-			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
-		}
-		totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a);
-		totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a);
-	}
-
-	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
-	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
-	float specularResult = (specularTexel.r + specularTexel.g + specularTexel.b)/3.0;
-	vec4 reflectionTotal = reflectionColor * (1-specularTexel.a) * color_result.a * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
-	color_result = color_result * clamp(1/specularTexel.a, 0, 1) + reflectionTotal;
-	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
-	
-
-	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
-
-	if(pos <= FillPercentage) {
-		color_result += FillColor;
-	}
-	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
-	//sceneColor = CommonUniforms.testColour;
-	//sceneColor = vec4(reflectionColor.xyz, 1);
-	color_result.xyz += glowTexel.xyz*GlowIntensity;
-
-	bloomColor = vec4(max(color_result.xyz - 1.0, 0.0), clamp(color_result.a, 0, 1));
-
-	//Tiled Debug Code
-	/*
-	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
-		sceneColor += vec4(0.5, 0, 0, 0);
-	} else {
-		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
-	}
-	*/
-}
-
-

src/Engine/Core/Transform.cpp

@@ -1,162 +0,0 @@
-#include "Core/TransformSystem.h"
-
-std::unordered_map<EntityWrapper, glm::vec3> TransformSystem::PositionCache;
-std::unordered_map<EntityWrapper, glm::quat> TransformSystem::OrientationCache;
-std::unordered_map<EntityWrapper, glm::vec3> TransformSystem::ScaleCache;
-std::unordered_map<EntityWrapper, glm::mat4> TransformSystem::MatrixCache;
-
-int TransformSystem::RecalculatedPositions = 0;
-int TransformSystem::RecalculatedOrientations = 0;
-int TransformSystem::RecalculatedScales = 0;
-
-TransformSystem::TransformSystem(SystemParams params)
-    : System(params)
-{
-    EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &TransformSystem::OnEntityDeleted);
-}
-
-bool TransformSystem::OnEntityDeleted(const Events::EntityDeleted& e)
-{
-    // Clean up deleted entity
-    PositionCache.erase(e.DeletedEntity);
-    OrientationCache.erase(e.DeletedEntity);
-    ScaleCache.erase(e.DeletedEntity);
-    MatrixCache.erase(e.DeletedEntity);
-    return true;
-}
-
-//glm::mat4 Transform::AbsoluteTransformation(EntityWrapper entity)
-//{
-//    glm::mat4 t = glm::mat4(1.f);
-//
-//    while (entity.Valid()) {
-//        t = glm::translate((const glm::vec3&)entity["Transform"]["Position"]) * glm::toMat4(glm::quat((const glm::vec3&)entity["Transform"]["Orientation"])) * glm::scale((const glm::vec3&)entity["Transform"]["Scale"]) * t;
-//        entity = entity.Parent();
-//    }
-//
-//    return t;
-//}
-
-glm::vec3 TransformSystem::AbsolutePosition(World* world, EntityID entity)
-{
-    return TransformSystem::AbsolutePosition(EntityWrapper(world, entity));
-}
-
-glm::vec3 TransformSystem::AbsolutePosition(EntityWrapper entity)
-{
-    if (!entity.Valid()) {
-        return glm::vec3();
-    }
-
-    auto cacheIt = PositionCache.find(entity);
-    ComponentWrapper cTransform = entity["Transform"];
-    ComponentWrapper::SubscriptProxy cTransformPosition = cTransform["Position"];
-    if (cacheIt != PositionCache.end() && !cTransformPosition.Dirty(DirtySetType::Transform)) {
-        return cacheIt->second;
-    } else {
-        EntityWrapper parent = entity.Parent();
-        // Calculate position
-        glm::vec3 position = AbsolutePosition(parent) + TransformSystem::AbsoluteOrientation(parent) * (TransformSystem::AbsoluteScale(parent) * (const glm::vec3&)cTransformPosition);
-        // Cache it
-        PositionCache[entity] = position;
-        RecalculatedPositions++;
-        // Unset dirty flag
-        cTransformPosition.SetDirty(DirtySetType::Transform, false);
-        return position;
-    }
-}
-
-glm::vec3 TransformSystem::AbsoluteOrientationEuler(EntityWrapper entity)
-{
-    glm::vec3 orientation;
-
-    while (entity.Valid()) {
-        ComponentWrapper transform = entity["Transform"];
-        orientation += (Field<glm::vec3>)transform["Orientation"];
-        entity = entity.Parent();
-    }
-
-    return orientation;
-}
-
-glm::quat TransformSystem::AbsoluteOrientation(World* world, EntityID entity)
-{
-    return TransformSystem::AbsoluteOrientation(EntityWrapper(world, entity));
-}
-
-glm::quat TransformSystem::AbsoluteOrientation(EntityWrapper entity)
-{
-    if (!entity.Valid()) {
-        return glm::quat();
-    }
-
-    auto cacheIt = OrientationCache.find(entity);
-    ComponentWrapper cTransform = entity["Transform"];
-    ComponentWrapper::SubscriptProxy cTransformOrientation = cTransform["Orientation"];
-    if (cacheIt != OrientationCache.end() && !cTransformOrientation.Dirty(DirtySetType::Transform)) {
-        return cacheIt->second;
-    } else {
-        EntityWrapper parent = entity.Parent();
-        // Calculate orientation
-        glm::quat orientation = AbsoluteOrientation(parent) * glm::quat((const glm::vec3&)cTransformOrientation);
-        // Cache it
-        OrientationCache[entity] = orientation;
-        RecalculatedOrientations++;
-        // Unset dirty flag
-        cTransformOrientation.SetDirty(DirtySetType::Transform, false);
-        return orientation;
-    }
-}
-
-glm::vec3 TransformSystem::AbsoluteScale(World* world, EntityID entity)
-{
-    return TransformSystem::AbsoluteScale(EntityWrapper(world, entity));
-}
-
-glm::vec3 TransformSystem::AbsoluteScale(EntityWrapper entity)
-{
-    if (!entity.Valid()) {
-        return glm::vec3(1.f);
-    }
-
-    auto cacheIt = ScaleCache.find(entity);
-    ComponentWrapper cTransform = entity["Transform"];
-    ComponentWrapper::SubscriptProxy cTransformScale = cTransform["Scale"];
-    if (cacheIt != ScaleCache.end() && !cTransformScale.Dirty(DirtySetType::Transform)) {
-        return cacheIt->second;
-    } else {
-        EntityWrapper parent = entity.Parent();
-        // Calculate scale
-        glm::vec3 scale = AbsoluteScale(parent) * (const glm::vec3&)cTransformScale;
-        // Cache it
-        ScaleCache[entity] = scale;
-        RecalculatedPositions++;
-        // Unset dirty flag
-        cTransformScale.SetDirty(DirtySetType::Transform, false);
-        return scale;
-    }
-}
-
-glm::mat4 TransformSystem::ModelMatrix(EntityID entityID, World* world)
-{
-    return ModelMatrix(EntityWrapper(world, entityID));
-}
-
-glm::mat4 TransformSystem::ModelMatrix(EntityWrapper entity)
-{
-    auto cacheIt = MatrixCache.find(entity);
-    ComponentWrapper cTransform = entity["Transform"];
-    bool isDirty = cTransform["Position"].Dirty(DirtySetType::Transform) || cTransform["Orientation"].Dirty(DirtySetType::Transform) || cTransform["Scale"].Dirty(DirtySetType::Transform);
-    if (cacheIt != MatrixCache.end() && !isDirty) {
-        return cacheIt->second;
-    } else {
-        glm::mat4 matrix = glm::translate(AbsolutePosition(entity)) * glm::toMat4(AbsoluteOrientation(entity)) * glm::scale(AbsoluteScale(entity));
-        MatrixCache[entity] = matrix;
-        return matrix;
-    }
-}
-
-glm::vec3 TransformSystem::TransformPoint(const glm::vec3& point, const glm::mat4& matrix)
-{
-    return glm::vec3(matrix * glm::vec4(point.x, point.y, point.z, 1));
-}

src/Engine/Network/Client.cpp

@@ -108,7 +108,15 @@ void Client::Update(double dt)
 
         hasServerTimedOut();
     }
-    //Network::Update();
+
+    if (ImGui::BeginPopupModal("Disconnected", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
+        ImGui::Text("You have been disconnected from server.\n\n");
+        ImGui::SetCursorPosX(ImGui::GetContentRegionAvailWidth() - 120);
+        if (ImGui::Button("OK", ImVec2(120, 0))) {
+            ImGui::CloseCurrentPopup();
+        }
+        ImGui::EndPopup();
+    }
 }
 
 void Client::parseMessageType(Packet& packet)
@@ -196,7 +204,7 @@ void Client::parseTCPConnect(Packet& packet)
     packet.WritePrimitive(m_PlayerID);
     m_Unreliable.Send(packet);
 
-     //  LOG_INFO("Sent UDP Connect Server");
+    //  LOG_INFO("Sent UDP Connect Server");
 }
 
 void Client::parsePlayerConnected(Packet & packet)
@@ -676,6 +684,7 @@ void Client::hasServerTimedOut()
     if (timeSincePing > m_TimeoutMs) {
         // Clear everything and go to menu.
         LOG_INFO("Server has timed out, returning to menu, Beep Boop.");
+        ImGui::OpenPopup("Disconnected");
         disconnect();
     }
 }

src/Engine/Rendering/DrawFinalPass.cpp

@@ -65,15 +65,6 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ForwardPlusProgram->Link();
     GLERROR("Creating forward+ program");
 
-	m_ForwardPlusNoShadowsProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusNoShadowProgram");
-	m_ForwardPlusNoShadowsProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
-	m_ForwardPlusNoShadowsProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusNoShadows.frag.glsl")));
-	m_ForwardPlusNoShadowsProgram->Compile();
-	m_ForwardPlusNoShadowsProgram->BindFragDataLocation(0, "sceneColor");
-	m_ForwardPlusNoShadowsProgram->BindFragDataLocation(1, "bloomColor");
-	m_ForwardPlusNoShadowsProgram->Link();
-	GLERROR("Creating forward+ program without shadows");
-
     m_ExplosionEffectProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectProgram");
     m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
     m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new GeometryShader("Shaders/ExplosionEffect.geom.glsl")));
@@ -363,12 +354,7 @@ void DrawFinalPass::OnWindowResize()
 
 void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
-	GLuint forwardHandle;
-	if (m_ShadowPass->EnableShadows()) {
-		forwardHandle = m_ForwardPlusProgram->GetHandle();
-	} else {
-		forwardHandle = m_ForwardPlusNoShadowsProgram->GetHandle();
-	}
+    GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
 	GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
 	GLuint explosionSplatMapHandle = m_ExplosionEffectSplatMapProgram->GetHandle();
 	GLuint forwardSplatMapHandle = m_ForwardPlusSplatMapProgram->GetHandle();
@@ -550,13 +536,9 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                         glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                     }
 					else {
-						if (lastShader != forwardHandle) {
-							if (forwardHandle == m_ForwardPlusProgram->GetHandle()) {
-								m_ForwardPlusProgram->Bind();
-							} else {
-								m_ForwardPlusNoShadowsProgram->Bind();
-							}
-							lastShader = forwardHandle;
+						if (lastShader != m_ForwardPlusProgram->GetHandle()) {
+							m_ForwardPlusProgram->Bind();
+							lastShader = m_ForwardPlusProgram->GetHandle();
 							GLERROR("Bind ForwardPlusProgram program");
 							glUniform1i(glGetUniformLocation(forwardHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
 							glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
@@ -641,12 +623,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 
 void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
-	GLuint forwardHandle;
-	if (m_ShadowPass->EnableShadows()) {
-		forwardHandle = m_ForwardPlusProgram->GetHandle();
-	} else {
-		forwardHandle = m_ForwardPlusNoShadowsProgram->GetHandle();
-	}
+	GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
 	GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
 	GLuint explosionSplatMapHandle = m_ExplosionEffectSplatMapProgram->GetHandle();
 	GLuint forwardSplatMapHandle = m_ForwardPlusSplatMapProgram->GetHandle();
@@ -1047,14 +1024,9 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 
 							}
 							else {
-								if (lastShader != forwardHandle) {
-									if (forwardHandle == m_ForwardPlusProgram->GetHandle()) {
-										m_ForwardPlusProgram->Bind();
-									}
-									else {
-										m_ForwardPlusNoShadowsProgram->Bind();
-									}
-									lastShader = forwardHandle;
+								if (lastShader != m_ForwardPlusProgram->GetHandle()) {
+									m_ForwardPlusProgram->Bind();
+									lastShader = m_ForwardPlusProgram->GetHandle();
 									GLERROR("Bind ForwardPlusProgram program");
 									glUniform1i(glGetUniformLocation(forwardHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
 									glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
@@ -1140,12 +1112,7 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 
 void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
-	GLuint forwardHandle;
-	if (m_ShadowPass->EnableShadows()) {
-		forwardHandle = m_ForwardPlusProgram->GetHandle();
-	} else {
-		forwardHandle = m_ForwardPlusNoShadowsProgram->GetHandle();
-	}
+    GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
     GLERROR("forwardHandle");
     GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
     GLERROR("explosionHandle");
@@ -1204,11 +1171,7 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
             auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
             if (modelJob) {
                 //bind forward program
-				if (m_ShadowPass->EnableShadows()) {
-					m_ForwardPlusProgram->Bind();
-				} else {
-					m_ForwardPlusNoShadowsProgram->Bind();
-				}
+                m_ForwardPlusProgram->Bind();
                 glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
 
                 //bind uniforms

src/Engine/Rendering/RenderSystem.cpp

@@ -362,6 +362,11 @@ void RenderSystem::fillPointLights(std::list<std::shared_ptr<RenderJob>>& jobs,
                 continue;
             }
 
+            EntityWrapper entity(world, pointlightC.EntityID);
+            if (!isEntityVisible(entity)) {
+                continue;
+            }
+
             std::shared_ptr<PointLightJob> pointLightJob = std::shared_ptr<PointLightJob>(new PointLightJob(transformC, pointlightC, m_World));
             jobs.push_back(pointLightJob);
         }

src/Engine/Rendering/Renderer.cpp

@@ -67,10 +67,19 @@ void Renderer::InitializeWindow()
 	// Create a window
 	GLFWmonitor* monitor = nullptr;
 	if (m_Fullscreen) {
-		monitor = glfwGetPrimaryMonitor();
+        //monitor = glfwGetPrimaryMonitor();
+        //const GLFWvidmode* mode = glfwGetVideoMode(monitor);
+
+        //glfwWindowHint(GLFW_RED_BITS, mode->redBits);
+        //glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits);
+        //glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
+        //glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate);
+        glfwWindowHint(GLFW_DECORATED, false);
+        glfwWindowHint(GLFW_AUTO_ICONIFY, false);
 	}
-	//glfwWindowHint(GLFW_SAMPLES, 8);
-	m_Window = glfwCreateWindow(m_Resolution.Width, m_Resolution.Height, "daydream", monitor, nullptr);
+
+    //glfwWindowHint(GLFW_SAMPLES, 8);
+	m_Window = glfwCreateWindow(m_Resolution.Width, m_Resolution.Height + 1, "daydream", monitor, nullptr);
 	if (!m_Window) {
 		LOG_ERROR("GLFW: Failed to create window");
 		exit(EXIT_FAILURE);
@@ -168,10 +177,8 @@ void Renderer::Draw(RenderFrame& frame)
 
 	ImGui::SliderInt("SSAO Quality", &m_SSAO_Quality, 0, 3);
 	ImGui::SliderInt("Glow Quality", &m_GLOW_Quality, 0, 3);
-	ImGui::Checkbox("EnableShadows", &m_Shadow_Enabled);
 	m_SSAOPass->ChangeQuality(m_SSAO_Quality);
 	m_DrawBloomPass->ChangeQuality(m_GLOW_Quality);
-	m_ShadowPass->CheckStatus(m_Shadow_Enabled);
     GLERROR("SSAO Settings");
     //clear buffer 0
     glClearColor(0.f, 0.f, 0.f, 0.f);

src/Engine/Rendering/ShadowPass.cpp

@@ -6,7 +6,7 @@ ShadowPass::ShadowPass(IRenderer * renderer, int shadow_res_x, int shadow_res_y)
 	m_ResolutionSizeWidth = shadow_res_x;
 	m_ResolutionSizeHeight = shadow_res_y;
 
-	CheckStatus(true);
+	InitializeFrameBuffers();
 	InitializeShaderPrograms();
 }
 
@@ -14,17 +14,18 @@ ShadowPass::ShadowPass(IRenderer * renderer)
 {
 	m_Renderer = renderer;
 
-	CheckStatus(true);
+	InitializeFrameBuffers();
 	InitializeShaderPrograms();
 }
 
 ShadowPass::~ShadowPass()
 {
-	CommonFunctions::DeleteTexture(&m_DepthMap);
+
 }
 
 void ShadowPass::DebugGUI()
 {
+	ImGui::Checkbox("EnableShadows", &m_EnableShadows);
 	ImGui::DragFloat2("ShadowMapNearFar", m_NearFarPlane, 1.f, -1000.f, 1000.f);
 	ImGui::DragFloat("ShadowClippingWeight", &m_SplitWeight, 0.001f, 0.f, 1.f);
 	ImGui::Checkbox("ShadowTransparentObjects", &m_TransparentObjects);
@@ -125,7 +126,6 @@ float ShadowPass::FindRadius(ShadowFrustum& frustum)
 void ShadowPass::InitializeFrameBuffers()
 {
 	// Depth texture
-	glDeleteTextures(1, &m_DepthMap);
 	glGenTextures(1, &m_DepthMap);
 
 	glBindTexture(GL_TEXTURE_2D_ARRAY, m_DepthMap);
@@ -156,12 +156,12 @@ void ShadowPass::InitializeShaderPrograms()
 	m_ShadowProgram->BindFragDataLocation(0, "ShadowMap");
 	m_ShadowProgram->Link();
 
-	m_ShadowProgramSkinned = ResourceManager::Load<ShaderProgram>("#ShadowProgramSkinned");
-	m_ShadowProgramSkinned->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShadowSkinned.vert.glsl")));
-	m_ShadowProgramSkinned->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Shadow.frag.glsl")));
-	m_ShadowProgramSkinned->Compile();
-	m_ShadowProgramSkinned->BindFragDataLocation(0, "ShadowMap");
-	m_ShadowProgramSkinned->Link();
+    m_ShadowProgramSkinned = ResourceManager::Load<ShaderProgram>("#ShadowProgramSkinned");
+    m_ShadowProgramSkinned->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShadowSkinned.vert.glsl")));
+    m_ShadowProgramSkinned->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Shadow.frag.glsl")));
+    m_ShadowProgramSkinned->Compile();
+    m_ShadowProgramSkinned->BindFragDataLocation(0, "ShadowMap");
+    m_ShadowProgramSkinned->Link();
 }
 
 void ShadowPass::ClearBuffer()
@@ -209,109 +209,53 @@ void ShadowPass::RadiusToLightspace(ShadowFrustum& frustum)
 	frustum.LRBT = { left, right, bottom, top };
 }
 
-void ShadowPass::CheckStatus(bool shadowStatus)
-{
-	if (m_EnableShadows == shadowStatus) {
-		return;
-	}
-
-	m_EnableShadows = shadowStatus;
-
-	if (m_EnableShadows == false) {
-		CommonFunctions::DeleteTexture(&m_DepthMap);
-		return;
-	}
-
-	InitializeFrameBuffers();
-}
-
 void ShadowPass::Draw(RenderScene & scene)
 {
-	if (!m_EnableShadows) {
-		return;
-	}
+	if (m_EnableShadows) {
+		InitializeCameras(scene);
+		UpdateSplitDist(m_shadowFrusta, scene.Camera->NearClip(), scene.Camera->FarClip());
 
-	InitializeCameras(scene);
-	UpdateSplitDist(m_shadowFrusta, scene.Camera->NearClip(), scene.Camera->FarClip());
+		ShadowPassState* state = new ShadowPassState(m_DepthBuffer.GetHandle());
 
-	ShadowPassState* state = new ShadowPassState(m_DepthBuffer.GetHandle());
+		
+		glViewport(0, 0, m_ResolutionSizeWidth, m_ResolutionSizeHeight);
 
-	glViewport(0, 0, m_ResolutionSizeWidth, m_ResolutionSizeHeight);
+		for (int i = 0; i < m_CurrentNrOfSplits; i++) {
+			UpdateFrustumPoints(m_shadowFrusta[i], scene.Camera->Position(), scene.Camera->Forward());
 
-	for (int i = 0; i < m_CurrentNrOfSplits; i++) {
-		UpdateFrustumPoints(m_shadowFrusta[i], scene.Camera->Position(), scene.Camera->Forward());
-
-		glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthMap, 0, i);
-
-		GLuint shaderHandle;
-
-		for (auto &job : scene.Jobs.DirectionalLight) {
-
-			auto directionalLightJob = std::dynamic_pointer_cast<DirectionalLightJob>(job);
-
-			if (directionalLightJob) {
-				m_LightView[i] = glm::lookAt(glm::vec3(-directionalLightJob->Direction) + m_shadowFrusta[i].MiddlePoint, m_shadowFrusta[i].MiddlePoint, glm::vec3(0.f, 1.f, 0.f));
-
-				PointsToLightspace(m_shadowFrusta[i], m_LightView[i]);
-				//FindRadius(m_shadowFrusta[i]);
-				//RadiusToLightspace(m_shadowFrusta[i]);
-				m_LightProjection[i] = glm::ortho(m_shadowFrusta[i].LRBT[LEFT], m_shadowFrusta[i].LRBT[RIGHT], m_shadowFrusta[i].LRBT[BOTTOM], m_shadowFrusta[i].LRBT[TOP], m_NearFarPlane[NEAR], m_NearFarPlane[FAR]);
+			glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthMap, 0, i);
 
 
-				m_ShadowProgram->Bind();
-				shaderHandle = m_ShadowProgram->GetHandle();
-				glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i]));
-				glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i]));
+            GLuint shaderHandle;
 
-				m_ShadowProgramSkinned->Bind();
-				shaderHandle = m_ShadowProgramSkinned->GetHandle();
-				glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i]));
-				glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i]));
+			for (auto &job : scene.Jobs.DirectionalLight) {
+
+				auto directionalLightJob = std::dynamic_pointer_cast<DirectionalLightJob>(job);
+
+				if (directionalLightJob) {
+					m_LightView[i] = glm::lookAt(glm::vec3(-directionalLightJob->Direction) + m_shadowFrusta[i].MiddlePoint, m_shadowFrusta[i].MiddlePoint, glm::vec3(0.f, 1.f, 0.f));
+
+					PointsToLightspace(m_shadowFrusta[i], m_LightView[i]);
+					//FindRadius(m_shadowFrusta[i]);
+					//RadiusToLightspace(m_shadowFrusta[i]);
+					m_LightProjection[i] = glm::ortho(m_shadowFrusta[i].LRBT[LEFT], m_shadowFrusta[i].LRBT[RIGHT], m_shadowFrusta[i].LRBT[BOTTOM], m_shadowFrusta[i].LRBT[TOP], m_NearFarPlane[NEAR], m_NearFarPlane[FAR]);
+
+
+                    m_ShadowProgram->Bind();
+                    shaderHandle = m_ShadowProgram->GetHandle();
+					glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i]));
+					glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i]));
+
+                    m_ShadowProgramSkinned->Bind();
+                    shaderHandle = m_ShadowProgramSkinned->GetHandle();
+                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i]));
+                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i]));
 
 
 
-				GLERROR("ShadowLight ERROR");
+					GLERROR("ShadowLight ERROR");
 
-				for (auto &objectJob : scene.Jobs.OpaqueObjects) {
-					if (!std::dynamic_pointer_cast<ExplosionEffectJob>(objectJob)) {
-						auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
-
-						if (!modelJob->Shadow) {
-							continue;
-						}
-
-						if (modelJob->Model->IsSkinned()) {
-							m_ShadowProgramSkinned->Bind();
-							shaderHandle = m_ShadowProgramSkinned->GetHandle();
-
-							std::vector<glm::mat4> frameBones;
-							if (modelJob->BlendTree != nullptr) {
-								frameBones = modelJob->BlendTree->GetFinalPose();
-							}
-							else {
-								frameBones = modelJob->Skeleton->GetTPose();
-							}
-							glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-
-						}
-						else {
-							m_ShadowProgram->Bind();
-							shaderHandle = m_ShadowProgram->GetHandle();
-						}
-
-						glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
-						glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), 1.f);
-
-						glBindVertexArray(modelJob->Model->VAO);
-						glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
-						glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
-
-						GLERROR("Shadow Draw ERROR");
-					}
-				}
-				if (m_TransparentObjects) {
-					state->CullFace(GL_BACK);
-					for (auto &objectJob : scene.Jobs.TransparentObjects) {
+					for (auto &objectJob : scene.Jobs.OpaqueObjects) {
 						if (!std::dynamic_pointer_cast<ExplosionEffectJob>(objectJob)) {
 							auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
 
@@ -319,53 +263,25 @@ void ShadowPass::Draw(RenderScene & scene)
 								continue;
 							}
 
-							if (modelJob->Model->IsSkinned()) {
-								m_ShadowProgramSkinned->Bind();
-								shaderHandle = m_ShadowProgramSkinned->GetHandle();
+                            if(modelJob->Model->IsSkinned()) {
+                                m_ShadowProgramSkinned->Bind();
+                                shaderHandle = m_ShadowProgramSkinned->GetHandle();
 
-								std::vector<glm::mat4> frameBones;
-								if (modelJob->BlendTree != nullptr) {
-									frameBones = modelJob->BlendTree->GetFinalPose();
-								}
-								else {
-									frameBones = modelJob->Skeleton->GetTPose();
-								}
-								glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                                std::vector<glm::mat4> frameBones;
+                                if (modelJob->BlendTree != nullptr) {
+                                    frameBones = modelJob->BlendTree->GetFinalPose();
+                                } else {
+                                    frameBones = modelJob->Skeleton->GetTPose();
+                                }
+                                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-							}
-							else {
-								m_ShadowProgram->Bind();
-								shaderHandle = m_ShadowProgram->GetHandle();
-							}
+                            } else {
+                                m_ShadowProgram->Bind();
+                                shaderHandle = m_ShadowProgram->GetHandle();
+                            }
 
 							glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
-							glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), modelJob->Color.a);
-
-							if (m_TexturedShadows) {
-								switch (modelJob->Type) {
-								case RawModel::MaterialType::SingleTextures:
-								case RawModel::MaterialType::Basic:
-								{
-									glActiveTexture(GL_TEXTURE24);
-									if (modelJob->DiffuseTexture.size() > 0 && modelJob->DiffuseTexture[0]->Texture != nullptr) {
-										glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture[0]->Texture->m_Texture);
-										glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(modelJob->DiffuseTexture[0]->UVRepeat));
-									}
-									else {
-										glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
-										glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
-									}
-									break;
-								}
-								case RawModel::MaterialType::SplatMapping:
-								{
-									glActiveTexture(GL_TEXTURE24);
-									glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
-									glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
-									break;
-								}
-								}
-							}
+							glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), 1.f);
 
 							glBindVertexArray(modelJob->Model->VAO);
 							glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
@@ -374,13 +290,76 @@ void ShadowPass::Draw(RenderScene & scene)
 							GLERROR("Shadow Draw ERROR");
 						}
 					}
-					state->CullFace(GL_FRONT);
+					if (m_TransparentObjects) {
+						state->CullFace(GL_BACK);
+						for (auto &objectJob : scene.Jobs.TransparentObjects) {
+							if (!std::dynamic_pointer_cast<ExplosionEffectJob>(objectJob)) {
+								auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
+
+								if (!modelJob->Shadow) {
+									continue;
+								}
+
+                                if (modelJob->Model->IsSkinned()) {
+                                    m_ShadowProgramSkinned->Bind();
+                                    shaderHandle = m_ShadowProgramSkinned->GetHandle();
+
+                                    std::vector<glm::mat4> frameBones;
+                                    if (modelJob->BlendTree != nullptr) {
+                                        frameBones = modelJob->BlendTree->GetFinalPose();
+                                    } else {
+                                        frameBones = modelJob->Skeleton->GetTPose();
+                                    }
+                                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+                                } else {
+                                    m_ShadowProgram->Bind();
+                                    shaderHandle = m_ShadowProgram->GetHandle();
+                                }
+
+								glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+								glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), modelJob->Color.a);
+
+								if (m_TexturedShadows) {
+									switch (modelJob->Type) {
+									case RawModel::MaterialType::SingleTextures:
+									case RawModel::MaterialType::Basic:
+									{
+										glActiveTexture(GL_TEXTURE24);
+										if (modelJob->DiffuseTexture.size() > 0 && modelJob->DiffuseTexture[0]->Texture != nullptr) {
+											glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture[0]->Texture->m_Texture);
+											glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(modelJob->DiffuseTexture[0]->UVRepeat));
+										}
+										else {
+											glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+											glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+										}
+										break;
+									}
+									case RawModel::MaterialType::SplatMapping:
+									{
+										glActiveTexture(GL_TEXTURE24);
+										glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+										glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+										break;
+									}
+									}
+								}
+
+								glBindVertexArray(modelJob->Model->VAO);
+								glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+								glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
+
+								GLERROR("Shadow Draw ERROR");
+							}
+						}
+						state->CullFace(GL_FRONT);
+					}
 				}
 			}
 		}
+		glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+		m_DepthBuffer.Unbind();
+		delete state;
 	}
-
-	glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-	m_DepthBuffer.Unbind();
-	delete state;
 }

src/Engine/Sound/SoundManager.cpp

@@ -30,10 +30,7 @@ SoundManager::SoundManager(World* world, EventBroker* eventBroker)
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &SoundManager::OnPlayerSpawned);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayQueueOnEntity, &SoundManager::OnPlayQueueOnEntity);
     EVENT_SUBSCRIBE_MEMBER(m_EChangeBGM, &SoundManager::OnChangeBGM);
-
-    Events::ChangeBGM e;
-    e.FilePath = "Audio/bgm/MenuMusic.wav";
-    m_EventBroker->Publish(e);
+    EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &SoundManager::OnSetCamera);
 }
 
 SoundManager::~SoundManager()
@@ -67,8 +64,7 @@ void SoundManager::Update(double dt)
     deleteInactiveEmitters();
     updateEmitters(dt);
     updateListener(dt);
-    if (m_DrumLoopHasBeenStarted)
-        matchBGMLoop();
+    matchBGMLoop();
 }
 
 void SoundManager::deleteInactiveEmitters()
@@ -363,15 +359,6 @@ bool SoundManager::OnPlayerSpawned(const Events::PlayerSpawned &e)
 {
     if (e.PlayerID == -1) { // Local player
         m_LocalPlayer = e.Player;
-        if (m_DrumLoopHasBeenStarted) {
-            return true;
-        }
-        m_CurrentBGMCombo = createSource("Audio/BGM/Layer2.wav");
-        m_CurrentBGMCombo->Type = SoundType::BGM;
-        alSourcei(m_CurrentBGMCombo->ALsource, AL_LOOPING, 1);
-        setGain(m_CurrentBGMCombo, 0);
-        playSound(m_CurrentBGMCombo);
-        m_DrumLoopHasBeenStarted = true;
         return true;
     }
     return false;
@@ -394,7 +381,9 @@ bool SoundManager::OnPlayQueueOnEntity(const Events::PlayQueueOnEntity &e)
 bool SoundManager::OnChangeBGM(const Events::ChangeBGM &e)
 {
     if (m_CurrentBGM != nullptr) {
-        stopSound(m_CurrentBGM);
+        if (getSourceState(m_CurrentBGM->ALsource) == AL_PLAYING) {
+            stopSound(m_CurrentBGM);
+        }
     }
     m_CurrentBGM = createSource(e.FilePath);
     m_CurrentBGM->Type = SoundType::BGM;
@@ -403,6 +392,34 @@ bool SoundManager::OnChangeBGM(const Events::ChangeBGM &e)
     return true;
 }
 
+bool SoundManager::OnSetCamera(const Events::SetCamera& e)
+{
+    if (e.CameraEntity.Name() == "Overview_Camera_Start_Menu") {
+        if (m_CurrentBGMCombo != nullptr) {
+            if (getSourceState(m_CurrentBGMCombo->ALsource) == AL_PLAYING) {
+                stopSound(m_CurrentBGMCombo);
+            }
+        }
+        Events::ChangeBGM changeBGM;
+        changeBGM.FilePath = "Audio/BGM/MenuMusic.wav";
+        m_EventBroker->Publish(changeBGM);
+    } else if (e.CameraEntity.Name() == "PickTeamCamera") {
+        Events::ChangeBGM changeBGM;
+        changeBGM.FilePath = "Audio/BGM/Layer1.wav";
+        m_EventBroker->Publish(changeBGM);
+        if (m_CurrentBGMCombo != nullptr) {
+            if (getSourceState(m_CurrentBGMCombo->ALsource) == AL_PLAYING) {
+                stopSound(m_CurrentBGMCombo);
+            }
+        }
+        m_CurrentBGMCombo = createSource("Audio/BGM/Layer2.wav");
+        m_CurrentBGMCombo->Type = SoundType::BGM;
+        alSourcei(m_CurrentBGMCombo->ALsource, AL_LOOPING, 1);
+        setGain(m_CurrentBGMCombo, 0);
+        playSound(m_CurrentBGMCombo);
+    }
+}
+
 ALenum SoundManager::getSourceState(ALuint source)
 {
     ALenum state;
@@ -419,14 +436,14 @@ void SoundManager::setSoundProperties(Source* source, ComponentWrapper* soundCom
 {
     float gain;
     switch (source->Type) {
-    case SoundType::SFX: 
-        gain = m_SFXVolumeChannel; 
+    case SoundType::SFX:
+        gain = m_SFXVolumeChannel;
         break;
-    case SoundType::BGM: 
+    case SoundType::BGM:
         gain = m_BGMVolumeChannel;
         break;
-    case SoundType::Announcer: 
-        gain = m_AnnouncerVolumeChannel; 
+    case SoundType::Announcer:
+        gain = m_AnnouncerVolumeChannel;
         break;
     default:
         gain = 1.f;

src/Game/Systems/SoundSystem.cpp

@@ -30,11 +30,6 @@ bool SoundSystem::OnPlayerSpawned(const Events::PlayerSpawned &e)
         Events::PlayAnonuncerVoice go;
         go.FilePath = "Audio/Announcer/" + m_Announcer + "/Go.wav";
         m_EventBroker->Publish(go);
-        {
-            Events::ChangeBGM ev;
-            ev.FilePath = "Audio/BGM/Layer1.wav";
-            m_EventBroker->Publish(ev);
-        }
     }
     return true;
 }

src/Game/Systems/SpectatorCameraSystem.cpp

@@ -61,7 +61,11 @@ bool SpectatorCameraSystem::OnInputCommand(const Events::InputCommand& e)
     // TODO: 1 Signifies spectator, should probably have real enum here later.
     // Spectators should never end up at the class select, instead put them at the SpectatorCamera.
     if (swapToClass && m_PickedTeam != 1) {
-        camName = "PickClassCamera";
+        if (m_PickedTeam == 2) {
+            camName = "PickClassCameraRed";
+        } else if (m_PickedTeam == 3) {
+            camName = "PickClassCameraBlue";
+        }
     } else if (e.Command == "SwapToTeamPick") {
         camName = "PickTeamCamera";
     } else {