Spot works

HydraClient/source/HydraGame.cpp

@@ -4,11 +4,20 @@ bool HydraGame::Initialise()
 {
     // m_angle = 0.01f;
 
-    m_sun_light_id = GetEngine()->ActorManager()->CreateActor<HydraPointLightActor>();
-    GetEngine()->ActorManager()->InitialiseActor(m_sun_light_id);
-    GetEngine()->ActorManager()->SetOrientation(m_sun_light_id, -0.5f, 0.0f, 0.0f);
-    GetEngine()->ActorManager()->SetPosition(m_sun_light_id, glm::dvec3(0.0f, 4.0f, 10.0f));
+    // m_sun_light_id = GetEngine()->ActorManager()->CreateActor<HydraPointLightActor>();
+    // GetEngine()->ActorManager()->InitialiseActor(m_sun_light_id);
+    // GetEngine()->ActorManager()->SetOrientation(m_sun_light_id, -0.5f, 0.0f, 0.0f);
+    // GetEngine()->ActorManager()->SetPosition(m_sun_light_id, glm::dvec3(0.0f, 4.0f, 10.0f));
 
+    // m_sun_light_id = GetEngine()->ActorManager()->CreateActor<HydraDirectionalLightActor>();
+    // GetEngine()->ActorManager()->InitialiseActor(m_sun_light_id);
+    // GetEngine()->ActorManager()->SetOrientation(m_sun_light_id, -0.5f, -0.2f, 0.0f);
+    
+
+    m_other_light_id = GetEngine()->ActorManager()->CreateActor<HydraPointLightActor>();
+    GetEngine()->ActorManager()->InitialiseActor(m_other_light_id);
+   // GetEngine()->ActorManager()->SetOrientation(m_other_light_id, -0.7f, 0.0f, 0.0f);
+    GetEngine()->ActorManager()->SetPosition(m_other_light_id, glm::dvec3(0.0f, 4.0f, 5.0f));
 
     // m_other_light_id = GetEngine()->ActorManager()->CreateActor<HydraDirectionalLightActor>();
     // GetEngine()->ActorManager()->InitialiseActor(m_other_light_id);
@@ -17,6 +26,10 @@ bool HydraGame::Initialise()
     // //1.570796327f
     // //3.141592654f
 
+    m_cube_actor_id = GetEngine()->ActorManager()->CreateActor<HydraTestCubeActor>();
+    GetEngine()->ActorManager()->InitialiseActor(m_cube_actor_id);
+    GetEngine()->ActorManager()->SetPosition(m_cube_actor_id, glm::dvec3(0, 1.0, 0));
+
     m_plane_actor_id = GetEngine()->ActorManager()->CreateActor<HydraPlaneActor>();
     GetEngine()->ActorManager()->InitialiseActor(m_plane_actor_id);
     GetEngine()->ActorManager()->SetPosition(m_plane_actor_id, glm::dvec3(0, 0, 0));
@@ -30,9 +43,13 @@ bool HydraGame::Initialise()
     GetEngine()->ActorManager()->InitialiseActor(m_gltf_id);
     GetEngine()->ActorManager()->SetPosition(m_gltf_id, glm::dvec3(0, 0, 0));
 
+    // m_gltf_id1 = GetEngine()->ActorManager()->LoadActor("c:/Code/HydraV3/Media/Tree1.glb");        
+    // GetEngine()->ActorManager()->InitialiseActor(m_gltf_id);
+    // GetEngine()->ActorManager()->SetPosition(m_gltf_id, glm::dvec3(0, 0, 500));
+
     m_player_actor_id = GetEngine()->ActorManager()->CreateActor<HydraPlayerActor>();
     GetEngine()->ActorManager()->InitialiseActor(m_player_actor_id);
-    GetEngine()->ActorManager()->SetPosition(m_player_actor_id, glm::dvec3(0, 4, 4));
+    GetEngine()->ActorManager()->SetPosition(m_player_actor_id, glm::dvec3(0, 2, 2));
 
     GetEngine()->PossessPlayer(m_player_actor_id);
     GetEngine()->Camera()->AttachToActor(m_player_actor_id);
@@ -53,7 +70,7 @@ void HydraGame::Update(float delta_t_seconds)
     // }
 
     m_angle += m_diff;
-    GetEngine()->ActorManager()->SetOrientation(m_sun_light_id, -0.2, m_angle, 0);
+    //GetEngine()->ActorManager()->SetOrientation(m_other_light_id, -0.5f, m_angle, 0);
     // GetEngine()->ActorManager()->SetOrientation(m_gltf_id, 0, m_angle, 0);
     // GetEngine()->ActorManager()->SetOrientation(m_plane_actor_id, 0, m_angle, 0);
 }

HydraClient/source/HydraGame.h

@@ -15,6 +15,7 @@ class HydraGame : public HydraGameProxy
        HydraID m_sun_light_id = INVALID_HYDRA_ID;
        HydraID m_other_light_id = INVALID_HYDRA_ID;
        HydraID m_gltf_id = INVALID_HYDRA_ID;
+       HydraID m_gltf_id1 = INVALID_HYDRA_ID;
        float m_time = 0;
        float m_angle = 0;
        float m_diff = 0.005;

HydraEngine/includes/Hydra.h

@@ -9,6 +9,9 @@
 #include "../source/actor/HydraPlayerActor.h"
 #include "../source/actor/HydraDirectionalLightActor.h"
 #include "../source/actor/HydraPointLightActor.h"
+#include "../source/actor/HydraSpotLightActor.h"
+#include "../source/actor/HydraTestCubeActor.h"
+
 #include "../source/camera/HydraCamera.h"
 
 #include <GLMIncludes.h>

HydraEngine/source/HydraDefines.h

@@ -41,6 +41,9 @@ const uint32_t MAX_MATERIALS = 1000;
 const uint32_t MAX_TEXTURES = 1000;
 const uint32_t MAX_ACTORS = 10000;
 const uint32_t MAX_LIGHTS = 500;
+const uint32_t MAX_DIRECTIONAL_SHADOWS = 10;
+const uint32_t MAX_SPOT_SHADOWS = 10;
+const uint32_t SHADOW_MAP_SIZE = 4096;
 
 
 enum class HYDRA_RENDERABLE_TYPE
@@ -49,7 +52,8 @@ enum class HYDRA_RENDERABLE_TYPE
 	HYDRA_SHADOW,
 	HYDRA_TRANSPARENT,
 	HYDRA_LIGHTING,
-	HYDRA_OUTPUT
+	HYDRA_OUTPUT,
+	HYDRA_TEXTURE_DEBUG
 };
 
 enum class HYDRA_BUFFER_TYPE

HydraEngine/source/ShaderFiles/deferred_output_shader.frag

@@ -16,43 +16,86 @@ uint HYDRA_LIGHT_DIRECTIONAL = 1;
 uint HYDRA_LIGHT_POINT = 2;
 uint HYDRA_LIGHT_SPOT = 3;
 
-struct light_structure
-{	
-	vec4 light_colour;
-	float light_intensity;
-	uint chunk_id;
-	uint light_type;
-	float padding[1];
+struct LightStructure
+{
+	vec4 ambient;
+	vec4 diffuse;
+	vec4 specular;
+	float intensity;
+	float constant;
+	float linear;
+	float quadratic;
+    float cutoff;
+	float cutoff_outer;
+	uint entity_id;
+    uint light_type;
+	uint shadow_map_id;
+	uint shadow_caster;
+	uint padding0;
+	uint padding1;
+};
+
+struct DirectionalShadowMapSet
+{
+    uint entity_id;
+    uint shadow_id;
+    uint shadow_texture_id;
+    uint frame_buffer_id;
+    float near_plane[8];
+    float far_plane[8];
+    mat4 light_space_proj[6];
+    mat4 light_space_view[6];
+};
+
+struct SpotShadowMapSet
+{
+	uint entity_id;    
+	uint shadow_id;
+    uint shadow_texture_id;   
+    uint frame_buffer_id;    	
+    float far_plane;
+	uint padding[3];
+    mat4 light_space_proj;
+    mat4 light_space_view;
 };
 
 layout(binding = 0) uniform uniform_per_frame
-{	
+{
 	mat4 view;
 	mat4 proj;
-	vec3 viewer_pos;	
+	vec3 viewer_pos;
 	uint light_count;
 } ubo_per_frame;
 
 
 layout(binding = 1) uniform uniform_output_textures
-{	
+{
 	uint texture_ids[16];
 };
 
-layout(binding = 1) readonly buffer PositionsBuffer 
+layout(std430, binding = 1) readonly buffer positions_buffer
 {
 	mat4 model_matrix[];
 };
 
-layout( std430, binding = 3) readonly buffer TextureBuffer {
+layout( std430, binding = 3) readonly buffer texture_buffer {
     uvec2 textures[1000];
 };
 
-layout (std430, binding = 4) readonly buffer LightBuffer
+layout (std430, binding = 4) readonly buffer light_buffer
 {
-	light_structure lights[500];
+	LightStructure lights[500];
 };
 
+layout (std430, binding = 5) readonly buffer directional_shadow_map_sets
+{
+	DirectionalShadowMapSet directional_shadows[];
+};
+
+layout (std430, binding = 6) readonly buffer spot_shadow_map_sets
+{
+	SpotShadowMapSet spot_shadows[];
+};
 layout (location=0) in VS_OUT
 {
 	vec2 vsUV;
@@ -105,115 +148,130 @@ vec3 fresnelSchlick(float cosTheta, vec3 F0)
     return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
 }
 
-vec3 DirectionalShading(vec3 normal, vec3 diffuse, float roughness, float metallic, float light_intensity, vec3 lightColour, vec3 lightDir, vec3 lightPos, vec3 worldPos, vec3 viewPos)
+vec3 CalculatePBR(vec3 normal, vec3 view_pos, vec3 world_pos,vec3 light_dir, vec3 diffuse, vec3 radiance, float roughness, float metallic )
 {
-
 	vec3 N = normalize(normal);
-    vec3 V = normalize(viewPos - worldPos);
+    vec3 V = normalize(view_pos - world_pos);
 
-    // calculate reflectance at normal incidence; if dia-electric (like plastic) use F0 
-    // of 0.04 and if it's a metal, use the albedo color as F0 (metallic workflow)    
-    vec3 F0 = vec3(0.04); 
+    // calculate reflectance at normal incidence; if dia-electric (like plastic) use F0
+    // of 0.04 and if it's a metal, use the albedo color as F0 (metallic workflow)
+    vec3 F0 = vec3(0.04);
     F0 = mix(F0, diffuse, metallic);
 
-    // reflectance equation
-    vec3 Lo = vec3(0.0);
-    
+
 	// calculate per-light radiance
-	vec3 L = normalize(lightDir);
+	vec3 L = normalize(light_dir);
 	vec3 H = normalize(V + L);
-	float distance = length(lightPos - worldPos); 
-	float attenuation = 1.0;
-	
-	// if(light_intensity > 0)
-	// {
-	// 	attenuation = light_intensity / (distance * distance);
-	// }
-	
-	vec3 radiance = lightColour * attenuation;
 
 	// Cook-Torrance BRDF
-	float NDF = DistributionGGX(N, H, roughness);   
-	float G   = GeometrySmith(N, V, L, roughness);      
+	float NDF = DistributionGGX(N, H, roughness);
+	float G   = GeometrySmith(N, V, L, roughness);
 	vec3 F    = fresnelSchlick(clamp(dot(H, V), 0.0, 1.0), F0);
-		
-	vec3 numerator    = NDF * G * F; 
+
+	vec3 numerator    = NDF * G * F;
 	float denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, L), 0.0) + 0.0001; // + 0.0001 to prevent divide by zero
 	vec3 specular = numerator / denominator;
-	
+
 	// kS is equal to Fresnel
 	vec3 kS = F;
 	// for energy conservation, the diffuse and specular light can't
 	// be above 1.0 (unless the surface emits light); to preserve this
 	// relationship the diffuse component (kD) should equal 1.0 - kS.
 	vec3 kD = vec3(1.0) - kS;
-	// multiply kD by the inverse metalness such that only non-metals 
+	// multiply kD by the inverse metalness such that only non-metals
 	// have diffuse lighting, or a linear blend if partly metal (pure metals
 	// have no diffuse light).
-	kD *= 1.0 - metallic;	  
+	kD *= 1.0 - metallic;
 
 	// scale light by NdotL
-	float NdotL = max(dot(N, L), 0.0);        
+	float NdotL = max(dot(N, L), 0.0);
 
 	// add to outgoing radiance Lo
-	Lo += (kD * diffuse / PI + specular) * radiance * NdotL;  // note that we already multiplied the BRDF by the Fresnel (kS) so we won't multiply by kS again
+	vec3 Lo = (kD * diffuse / PI + specular) * radiance * NdotL;  // note that we already multiplied the BRDF by the Fresnel (kS) so we won't multiply by kS again
 
 	return Lo;
 }
-   
 
-vec3 PointShading(vec3 normal, vec3 diffuse, float roughness, float metallic, float light_intensity, vec3 lightColour, vec3 lightDir, vec3 lightPos, vec3 worldPos, vec3 viewPos)
+vec3 DirectionalShading(vec3 normal,
+						vec3 diffuse,
+						float roughness,
+						float metallic,
+						float light_intensity,
+						vec3 light_dir,
+						vec3 light_pos,
+						vec3 world_pos,
+						vec3 view_pos)
 {
 
-	vec3 N = normalize(normal);
-    vec3 V = normalize(viewPos - worldPos);
-
-    // calculate reflectance at normal incidence; if dia-electric (like plastic) use F0 
-    // of 0.04 and if it's a metal, use the albedo color as F0 (metallic workflow)    
-    vec3 F0 = vec3(0.04); 
-    F0 = mix(F0, diffuse, metallic);
-
-    // reflectance equation
-    vec3 Lo = vec3(0.0);
-    
-	// calculate per-light radiance
-	vec3 L = normalize(lightPos - worldPos);
-	vec3 H = normalize(V + L);
-	float distance = length(lightPos - worldPos); 
+	float distance = length(light_pos - world_pos);
 	float attenuation = 1.0;
-	
-	attenuation = light_intensity / (distance * distance);
-	
-	vec3 radiance = lightColour * attenuation;
 
-	// Cook-Torrance BRDF
-	float NDF = DistributionGGX(N, H, roughness);   
-	float G   = GeometrySmith(N, V, L, roughness);      
-	vec3 F    = fresnelSchlick(clamp(dot(H, V), 0.0, 1.0), F0);
-		
-	vec3 numerator    = NDF * G * F; 
-	float denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, L), 0.0) + 0.0001; // + 0.0001 to prevent divide by zero
-	vec3 specular = numerator / denominator;
-	
-	// kS is equal to Fresnel
-	vec3 kS = F;
-	// for energy conservation, the diffuse and specular light can't
-	// be above 1.0 (unless the surface emits light); to preserve this
-	// relationship the diffuse component (kD) should equal 1.0 - kS.
-	vec3 kD = vec3(1.0) - kS;
-	// multiply kD by the inverse metalness such that only non-metals 
-	// have diffuse lighting, or a linear blend if partly metal (pure metals
-	// have no diffuse light).
-	kD *= 1.0 - metallic;	  
+	vec3 radiance = diffuse * attenuation;
 
-	// scale light by NdotL
-	float NdotL = max(dot(N, L), 0.0);        
-
-	// add to outgoing radiance Lo
-	Lo += (kD * diffuse / PI + specular) * radiance * NdotL;  // note that we already multiplied the BRDF by the Fresnel (kS) so we won't multiply by kS again
+	vec3 Lo = CalculatePBR(normal, view_pos, world_pos, light_dir, diffuse,  radiance, roughness, metallic);
 
 	return Lo;
 }
+
+
+vec3 PointShading(vec3 normal,
+					vec3 diffuse,
+					float roughness,
+					float metallic,
+					float light_intensity,
+					vec3 light_pos,
+					float light_constant,
+					float light_linear,
+					float light_quadratic,
+					vec3 world_pos,
+					vec3 view_pos)
+{
+	float distance = length(light_pos - world_pos);
+	float attenuation = 1.0;
+
+	attenuation = light_intensity / (light_constant + (light_linear * distance) + (light_quadratic * distance * distance));
+	vec3 radiance = diffuse * attenuation;
+	 vec3 light_dir = normalize(light_pos - world_pos);
+	vec3 Lo = CalculatePBR(normal, view_pos, world_pos, light_dir, diffuse,  radiance, roughness, metallic);
+
+	return Lo;
+}
+vec3 SpotShading(vec3 normal,
+					vec3 diffuse,
+					float roughness,
+					float metallic,
+					float light_intensity,
+					vec3 light_dir,
+					vec3 light_pos,
+					float cutoff,
+					float cutoff_outer,
+					float light_constant,
+					float light_linear,
+					float light_quadratic,
+					vec3 world_pos,
+					vec3 view_pos,
+					float shadow_val)
+{
+
+	vec3 direction_to_light = normalize(light_pos - world_pos);
+	float theta = dot(direction_to_light, light_dir);
+	float falloff = 0.0f;
+	float epsilon   = cutoff - cutoff_outer;
+
+ 	falloff = clamp((theta - cutoff_outer) / epsilon, 0.0, 1.0);
+
+	float distance = length(light_pos - world_pos);
+	float attenuation = 1.0;
+
+	attenuation = light_intensity / (light_constant + (light_linear * distance) + (light_quadratic * distance * distance));
+
+	vec3 radiance = diffuse * attenuation * falloff * (1.0-shadow_val);
+
+	vec3 Lo = CalculatePBR(normal, view_pos, world_pos, direction_to_light, diffuse,  radiance, roughness, metallic);
+
+	return Lo;// * shadow;
+}
+
 mat3 GetRotationOnlyMatrix(mat4 model_mat)
 {
 	mat3 rot_mat;
@@ -223,6 +281,140 @@ mat3 GetRotationOnlyMatrix(mat4 model_mat)
 	return rot_mat;
 }
 
+float SimpleSampleShadow(vec4 frag_clip_space, sampler2DArray sampler_shadow_map, uint shadow_trans_idx)
+{
+	vec3 frag_light_space = frag_clip_space.xyz / frag_clip_space.w;
+	frag_light_space = (frag_light_space * 0.5) + 0.5;
+
+	float shadow_map_depth = texture(sampler_shadow_map, vec3(frag_light_space.xy, shadow_trans_idx)).r;
+	// return frag_light_space.z - shadow_map_depth;
+	  //return shadow_map_depth ;
+	  //return frag_light_space.z;
+	if(frag_light_space.z > shadow_map_depth)
+	{
+		return 0;
+	}
+	return 1;
+}
+
+float SampleCascadeShadow(vec4 frag_clip_space, sampler2DArray sampler_shadow_map, uint shadow_trans_idx, vec3 normal, vec3 light_dir)
+{
+	vec3 frag_light_space = frag_clip_space.xyz / frag_clip_space.w;
+	frag_light_space = (frag_light_space * 0.5) + 0.5;
+
+	float shadow_map_depth = texture(sampler_shadow_map, vec3(frag_light_space.xy, shadow_trans_idx)).r;
+    // calculate bias (based on depth map resolution and slope)
+
+    float bias = max(0.0005 * (1.0 - dot(normal, light_dir)), 0.00005);
+    // check whether current frag pos is in shadow
+    // float shadow = currentDepth - bias > closestDepth  ? 1.0 : 0.0;
+    // PCF
+	//bias = 0;
+    float shadow = 0.0;
+    vec2 texel_size = 1.0 / textureSize(sampler_shadow_map, 0).xy;
+	if((frag_light_space.x >= 0.0)&&(frag_light_space.y >= 0.0)
+	 	&&(frag_light_space.x <= 1.0)&&(frag_light_space.y <= 1.0))
+	 {
+		for(int x = -1; x <= 1; ++x)
+		{
+			for(int y = -1; y <= 1; ++y)
+			{			
+				shadow_map_depth = texture(sampler_shadow_map, vec3(frag_light_space.xy + vec2(x, y) * texel_size, shadow_trans_idx)).r;
+				shadow += frag_light_space.z - bias > shadow_map_depth  ? 1.0 : 0.0;
+			}
+		}
+		shadow /= 9.0;
+	 }
+    // keep the shadow at 0.0 when outside the far_plane region of the light's frustum.
+    if(frag_light_space.z > 1.0)
+        shadow = 0.0;
+	
+    return shadow;
+}
+
+
+float SampleSingleShadow(vec4 frag_clip_space, sampler2D sampler_shadow_map,  vec3 normal, vec3 light_dir)
+{
+	vec3 frag_light_space = frag_clip_space.xyz / frag_clip_space.w;
+	frag_light_space = (frag_light_space * 0.5) + 0.5;
+
+	float shadow_map_depth = texture(sampler_shadow_map, frag_light_space.xy).r;
+    // calculate bias (based on depth map resolution and slope)
+
+    float bias = max(0.00005 * (1.0 - dot(normal, light_dir)), 0.000005);
+    // check whether current frag pos is in shadow
+    // float shadow = currentDepth - bias > closestDepth  ? 1.0 : 0.0;
+    // PCF
+	//bias = 0;
+    float shadow = 0.0;
+    vec2 texel_size = 1.0 / textureSize(sampler_shadow_map, 0).xy;
+	if((frag_light_space.x >= 0.0)&&(frag_light_space.y >= 0.0)
+	 	&&(frag_light_space.x <= 1.0)&&(frag_light_space.y <= 1.0))
+	 {
+		for(int x = -1; x <= 1; ++x)
+		{
+			for(int y = -1; y <= 1; ++y)
+			{			
+				shadow_map_depth = texture(sampler_shadow_map, frag_light_space.xy + vec2(x, y) * texel_size).r;
+				shadow += frag_light_space.z - bias > shadow_map_depth  ? 1.0 : 0.0;
+			}
+		}
+		shadow /= 9.0;
+	 }
+    // keep the shadow at 0.0 when outside the far_plane region of the light's frustum.
+    if(frag_light_space.z > 1.0)
+        shadow = 0.0;
+	
+    return shadow;
+}
+vec3 CalculateDirectionalShadow(vec4 world_pos, uint shadow_idx, vec3 normal, vec3 light_dir, vec3 viewer_pos)
+{
+	float shadow = 1;
+	
+	//measure the distance of the fragment from the light
+	float frag_distance = abs(length(viewer_pos - world_pos.xyz));
+	
+	uint shadow_trans_idx = 5;
+	uint ignore_shadow = 0;
+	//Work out which shadowmap is appropriate for this distance
+	for(uint i = 0; i < 6; i++)
+	{
+		if(frag_distance <= directional_shadows[shadow_idx].far_plane[i])
+		{
+			//record the shadow map level
+			shadow_trans_idx = i;
+			//and indicate that this has a level
+			ignore_shadow = 1;
+			break;
+		}
+	}
+
+	if(ignore_shadow == 1)
+	{
+		vec4 translated_pixel = directional_shadows[shadow_idx].light_space_proj[shadow_trans_idx] *
+							directional_shadows[shadow_idx].light_space_view[shadow_trans_idx] *
+							world_pos;
+		uvec2 shadow_handle = textures[directional_shadows[shadow_idx].shadow_texture_id];
+		shadow = 1.0 - SampleCascadeShadow(translated_pixel, sampler2DArray(shadow_handle), shadow_trans_idx, normal, light_dir);
+	}
+
+	return vec3(shadow);
+}
+float CalculateSpotShadow(vec4 world_pos, uint shadow_idx, vec3 normal, vec3 light_dir, vec3 viewer_pos)
+{
+
+
+		vec4 translated_pixel = spot_shadows[shadow_idx].light_space_proj *
+							spot_shadows[shadow_idx].light_space_view *
+							world_pos;
+		
+		uvec2 shadow_handle = textures[spot_shadows[shadow_idx].shadow_texture_id];
+		
+		float shadow =(SampleSingleShadow(translated_pixel, sampler2D(shadow_handle), normal, light_dir));
+
+	return shadow;
+}
+
 void main()
 {
 	uvec2 diffuse_handle = textures[texture_ids[DIFFUSE_TEXTURE_ID]];
@@ -230,59 +422,98 @@ void main()
 	uvec2 metal_rough_handle = textures[texture_ids[METAL_ROUGH_TEXTURE_ID]];
 	uvec2 world_pos_handle = textures[texture_ids[POSITION_TEXTIURE_ID]];
 	vec4 diffuse = texture(sampler2D(diffuse_handle), vs_out.vsUV.xy);
-	
+
 	if(diffuse[3] <= 0.1)
-	{	
+	{
 		discard;
 	}
 
 	vec3 normal = texture(sampler2D(normal_handle), vs_out.vsUV.xy).xyz;
-	vec3 metal_rough = texture(sampler2D(metal_rough_handle), vs_out.vsUV.xy).xyz; 
-	vec3 world_pos = texture(sampler2D(world_pos_handle), vs_out.vsUV.xy).xyz; 
+	vec3 metal_rough = texture(sampler2D(metal_rough_handle), vs_out.vsUV.xy).xyz;
+	vec3 world_pos = texture(sampler2D(world_pos_handle), vs_out.vsUV.xy).xyz;
 	float rough = metal_rough[1];
 	float metal = metal_rough[2];
-	
-	vec3 Lo = vec3(0,0,0);
+	float ao = 1;
+    vec3 ambient = vec3(0.05) * diffuse.xyz * ao;
+	vec3 Lo = ambient;
 	for(int i = 0; i < ubo_per_frame.light_count; i ++)
 	{
-		mat4 model = model_matrix[lights[i].chunk_id];
+		mat4 model = model_matrix[lights[i].entity_id];
 		mat3 rot_mat = GetRotationOnlyMatrix(model);
-		vec3 light_direction = rot_mat * vec3(0,0,1);
-		
+		vec3 light_direction = normalize(rot_mat * vec3(0,0,1));
+
 		vec3 light_pos = model[3].xyz;
 		if(lights[i].light_type == HYDRA_LIGHT_DIRECTIONAL)
 		{
-			Lo+= DirectionalShading(normal, diffuse.xyz, rough, metal, lights[i].light_intensity, lights[i].light_colour.xyz, light_direction, light_pos, world_pos, ubo_per_frame.viewer_pos);
+			Lo += DirectionalShading(normal, diffuse.xyz, rough, metal, lights[i].intensity, light_direction, light_pos, world_pos, ubo_per_frame.viewer_pos);
+			if(lights[i].shadow_caster == 1)
+			{
+				vec3 shadow = CalculateDirectionalShadow(vec4(world_pos, 1.0), lights[i].shadow_map_id, normal, light_direction, ubo_per_frame.viewer_pos);
+				//Lo = Lo * vec3(shadow);
+				Lo = Lo * shadow;
+			}
 		}
 		else if(lights[i].light_type == HYDRA_LIGHT_POINT)
 		{
-			Lo+= PointShading(normal, diffuse.xyz, rough, metal, lights[i].light_intensity, lights[i].light_colour.xyz, light_direction, light_pos, world_pos, ubo_per_frame.viewer_pos);
+
+			Lo += PointShading(normal,
+							diffuse.xyz,
+							rough,
+							metal,
+							lights[i].intensity,
+							light_pos,
+							lights[i].constant,
+							lights[i].linear,
+							lights[i].quadratic,
+							world_pos,
+							ubo_per_frame.viewer_pos);
 		}
-		
-		//uFragColor = vec4(light_direction, 1);
+		else if(lights[i].light_type == HYDRA_LIGHT_SPOT)
+		{
+			float shadow = 0;
+						if(lights[i].shadow_caster == 1)
+			{
+				float distance = length(light_pos - world_pos);
+				shadow = CalculateSpotShadow(vec4(world_pos, 1.0), 
+				lights[i].shadow_map_id, 
+				normal, 
+				light_direction, 
+				ubo_per_frame.viewer_pos);
+			}
+			Lo += SpotShading(normal,
+							diffuse.xyz,
+							rough,
+							metal,
+							lights[i].intensity,
+							light_direction,
+							light_pos,
+							lights[i].cutoff,
+							lights[i].cutoff_outer,
+							lights[i].constant,
+							lights[i].linear,
+							lights[i].quadratic,
+							world_pos,
+							ubo_per_frame.viewer_pos,
+							shadow);
+
+				
+		}
+
 	}
-	
+
 	float lighting = 0;
-
-	
-	
- // ambient lighting (note that the next IBL tutorial will replace 
-    // this ambient lighting with environment lighting).
-	float ao = 1;
-    vec3 ambient = vec3(0.05) * diffuse.xyz * ao;
-
-    vec3 output_color = ambient + Lo;
+    vec3 output_color = Lo;
 
     // HDR tonemapping
     output_color = output_color / (output_color + vec3(1.0));
     // gamma correct
-    output_color = pow(output_color, vec3(1.0/2.1)); 
+    output_color = pow(output_color, vec3(1.0/2.1));
 
     uFragColor = vec4(output_color, 1.0);
 	// float light = dot(lights[0].light_direction, normal);
 
 	// uFragColor = vec4(diffuse.xyz * light,1);
-	
+
 	// uFragColor = vec4(normal, 1);
 }
 

HydraEngine/source/ShaderFiles/deferred_output_shader.vert

@@ -9,7 +9,7 @@ layout(binding = 0) uniform uniform_per_frame
 	uint light_count;
 } ubo_per_frame;
 
-layout(binding = 1) readonly buffer PositionsBuffer 
+layout(std430, binding = 1) readonly buffer positions_buffer 
 {
 	mat4 model_matrix[];
 };

HydraEngine/source/ShaderFiles/deferred_shader.frag

@@ -16,12 +16,12 @@ struct MaterialStore
 	uint padding[1];
 };
 
-layout(binding = 2, std430) readonly buffer MaterialBuffer
+layout(binding = 2, std430) readonly buffer material_buffer
 {
 	MaterialStore materials[1000];
 };
 
-layout( std430, binding = 3) readonly buffer TextureBuffer {
+layout( std430, binding = 3) readonly buffer texture_buffer {
     uvec2 textures[1000];
 };
 

HydraEngine/source/ShaderFiles/deferred_shader.vert

@@ -9,7 +9,7 @@ layout(binding = 0) uniform uniform_per_frame
 	uint light_count;
 } ubo_per_frame;
 
-layout(binding = 1) readonly buffer PositionsBuffer 
+layout(std430, binding = 1) readonly buffer positions_buffer 
 {
 	mat4 model_matrix[];
 };

HydraEngine/source/ShaderFiles/forward_shader.frag

@@ -26,7 +26,6 @@ layout (location=0) in VS_OUT
 {
 	vec2 vsUV;
 	vec4 vsWorldPos;
-	vec4 normal;
 	flat uint vsChunkID;
 	flat uint vsMaterialID;
 }vs_out;

HydraEngine/source/ShaderFiles/shadow_cascade_shader.frag

@@ -0,0 +1,63 @@
+//*PIXEL*
+#version 460
+
+#extension GL_ARB_bindless_texture : require
+
+const uint DIRECTIONAL_LIGHT = 1;
+const uint POINT_LIGHT = 2;
+const uint SPOT_LIGHT = 3;
+uint INVALID_HYDRA_ID = 4294967295;
+
+struct MaterialStore
+{
+	vec4 diffuse_colour;	
+	vec4 matalic_rough;	 
+    uint diffuse_texture_id;
+    uint metallic_rough_texture_id;
+    uint normal_texture_id;
+	uint padding[1];
+};
+
+layout(std430, binding = 2) readonly buffer material_buffer
+{
+	MaterialStore materials[1000];
+};
+
+layout(std430, binding = 3) readonly buffer texture_buffer 
+{
+    uvec2 textures[1000];
+};
+
+layout (location=0) in GEOM_OUT
+{
+	vec2 vsUV;
+    flat uint vsMaterialID;
+}geom_out;
+
+layout (location=0) out vec4 output_colour;
+
+void main() 
+{
+    MaterialStore mat = materials[geom_out.vsMaterialID];
+	vec4 diffuse_val = mat.diffuse_colour;
+
+    output_colour = vec4(1,0,0,1);
+    
+    if(mat.diffuse_texture_id != INVALID_HYDRA_ID)
+	{
+        output_colour =  vec4(0,1,0,1);
+		uvec2 diffuse_handle = textures[mat.diffuse_texture_id];
+		diffuse_val = diffuse_val * texture(sampler2D(diffuse_handle), geom_out.vsUV.xy);	
+        if(mat.diffuse_texture_id== 10)
+        {
+            output_colour = vec4(0,0,1,1);
+        }
+	}
+
+    if(diffuse_val[3] < 1.0)
+	{
+        discard;
+		output_colour = vec4(0,1,1,1);
+	}
+
+}

HydraEngine/source/ShaderFiles/shadow_cascade_shader.geom

@@ -0,0 +1,63 @@
+#version 450
+
+layout(triangles, invocations = 6) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+struct DirectionalShadowMapSet
+{
+    uint entity_id;
+    uint shadow_id;
+    uint shadow_texture_id;   
+    uint frame_buffer_id;
+    float near_plane[8];
+    float far_plane[8];
+    mat4 light_space_proj[6];
+    mat4 light_space_view[6];
+};
+
+
+//Push constants updated for each light
+layout(binding = 0) uniform shadow_per_frame
+{
+	vec3 camera_pos;
+	uint shadow_idxs;
+};
+
+layout (std430, binding = 5) readonly buffer directional_shadow_map_sets
+{
+	DirectionalShadowMapSet directional_shadows[];
+};
+
+
+
+layout (location=0) in VS_OUT
+{
+	vec2 vsUV;
+    flat uint vsMaterialID;
+}vs_in[];
+
+layout (location=0) out GEOM_OUT
+{
+	vec2 vsUV;
+    flat uint vsMaterialID; 
+}geom_out;
+
+void main()
+{      
+	mat4 view = directional_shadows[shadow_idxs].light_space_view[gl_InvocationID];
+	mat4 proj = directional_shadows[shadow_idxs].light_space_proj[gl_InvocationID];
+
+	for (int i = 0; i < 3; ++i)
+	{
+		gl_Layer = gl_InvocationID;
+        vec4 clip_space_pos = proj * view * gl_in[i].gl_Position;
+        
+        gl_Position = clip_space_pos;
+
+        geom_out.vsMaterialID = vs_in[gl_InvocationID].vsMaterialID;
+        geom_out.vsUV = vs_in[gl_InvocationID].vsUV;
+
+        EmitVertex();
+	}
+	EndPrimitive();
+}  

HydraEngine/source/ShaderFiles/shadow_cascade_shader.vert

@@ -0,0 +1,57 @@
+//*VERTEX*
+#version 460
+
+struct ShadowMapSet
+{
+    uint entity_id;
+    uint shadow_id;
+    uint shadow_texture_id;   
+    uint frame_buffer_id;
+    float near_plane[8];
+    float far_plane[8];
+    mat4 light_space_proj[6];
+    mat4 light_space_view[6];
+};
+
+struct SpotShadowMapSet
+{
+	uint entity_id;    
+	uint shadow_id;
+    uint shadow_texture_id;   
+    uint frame_buffer_id;    	
+    float far_plane;
+	uint padding[3];
+    mat4 light_space_proj;
+    mat4 light_space_view;
+};
+
+layout(binding = 1) readonly buffer positions_buffer 
+{
+	mat4 model_matrix[];
+};
+
+
+
+layout (location = 0) in vec3 inPos; 		//12 bytes : 0
+layout (location = 1) in vec2 inUV;  		//8 Bytes  : 12
+layout (location = 2) in uvec3 inChunkID; 	//12 Bytes : 20
+layout (location = 3) in vec3 inNormal;  	//8 Bytes  : 12 
+layout (location = 4) in vec3 inBiTangent;
+layout (location = 5) in vec3 inTangent;
+
+layout (location=0) out VS_OUT
+{
+	vec2 vsUV;
+    flat uint vsMaterialID;
+}vs_out;
+
+
+
+void main() 
+{  	
+	 uint chunkid = inChunkID[0];
+	 mat4 model = model_matrix[chunkid];
+	 gl_Position = model * vec4(inPos, 1.0);
+	 vs_out.vsUV = inUV;
+	 vs_out.vsMaterialID = inChunkID[1];
+}

HydraEngine/source/ShaderFiles/shadow_spot_shader.frag

@@ -0,0 +1,63 @@
+//*PIXEL*
+#version 460
+
+#extension GL_ARB_bindless_texture : require
+
+const uint DIRECTIONAL_LIGHT = 1;
+const uint POINT_LIGHT = 2;
+const uint SPOT_LIGHT = 3;
+uint INVALID_HYDRA_ID = 4294967295;
+
+struct MaterialStore
+{
+	vec4 diffuse_colour;	
+	vec4 matalic_rough;	 
+    uint diffuse_texture_id;
+    uint metallic_rough_texture_id;
+    uint normal_texture_id;
+	uint padding[1];
+};
+
+layout(std430, binding = 2) readonly buffer material_buffer
+{
+	MaterialStore materials[1000];
+};
+
+layout(std430, binding = 3) readonly buffer texture_buffer 
+{
+    uvec2 textures[1000];
+};
+
+layout (location=0) in VS_OUT
+{
+	vec2 vsUV;
+    flat uint vsMaterialID;
+}vs_out;
+
+layout (location=0) out vec4 output_colour;
+
+void main() 
+{
+    MaterialStore mat = materials[vs_out.vsMaterialID];
+	vec4 diffuse_val = mat.diffuse_colour;
+
+    output_colour = vec4(1,0,0,1);
+    
+    if(mat.diffuse_texture_id != INVALID_HYDRA_ID)
+	{
+        output_colour =  vec4(0,1,0,1);
+		uvec2 diffuse_handle = textures[mat.diffuse_texture_id];
+		diffuse_val = diffuse_val * texture(sampler2D(diffuse_handle), vs_out.vsUV.xy);	
+        if(mat.diffuse_texture_id== 10)
+        {
+            output_colour = vec4(0,0,1,1);
+        }
+	}
+
+    if(diffuse_val[3] < 1.0)
+	{
+        discard;
+		output_colour = vec4(0,1,1,1);
+	}
+
+}

HydraEngine/source/ShaderFiles/shadow_spot_shader.vert

@@ -0,0 +1,57 @@
+//*VERTEX*
+#version 460
+
+
+struct SpotShadowMapSet
+{
+	uint entity_id;    
+	uint shadow_id;
+    uint shadow_texture_id;   
+    uint frame_buffer_id;    	
+    float far_plane;
+	uint padding[3];
+    mat4 light_space_proj;
+    mat4 light_space_view;
+};
+
+layout(binding = 1) readonly buffer positions_buffer 
+{
+	mat4 model_matrix[];
+};
+
+layout (std430, binding = 6) readonly buffer spot_shadow_map_sets
+{	
+	SpotShadowMapSet spot_shadows[];
+};
+
+layout(binding = 0) uniform shadow_per_frame
+{
+	vec3 camera_pos;
+	uint shadow_idxs;
+};
+
+layout (location = 0) in vec3 inPos; 		//12 bytes : 0
+layout (location = 1) in vec2 inUV;  		//8 Bytes  : 12
+layout (location = 2) in uvec3 inChunkID; 	//12 Bytes : 20
+layout (location = 3) in vec3 inNormal;  	//8 Bytes  : 12 
+layout (location = 4) in vec3 inBiTangent;
+layout (location = 5) in vec3 inTangent;
+
+layout (location=0) out VS_OUT
+{
+	vec2 vsUV;
+    flat uint vsMaterialID;
+}vs_out;
+
+void main() 
+{  	
+	 uint chunkid = inChunkID[0];
+	 mat4 model = model_matrix[chunkid];
+	 mat4 proj = spot_shadows[shadow_idxs].light_space_proj;
+	 mat4 view = spot_shadows[shadow_idxs].light_space_view;
+	//view = mat4(1);
+	//proj = mat4(1);
+	 gl_Position =  proj * view * model * vec4(inPos, 1.0);
+	 vs_out.vsUV = inUV;
+	 vs_out.vsMaterialID = inChunkID[1];
+}

HydraEngine/source/ShaderFiles/texture_debug_shader.frag

@@ -0,0 +1,39 @@
+//*PIXEL*
+#version 450
+
+#extension GL_EXT_scalar_block_layout : enable
+#extension GL_EXT_nonuniform_qualifier : enable
+#extension GL_ARB_bindless_texture : enable
+
+const uint DIRECTIONAL_LIGHT = 1;
+const uint POINT_LIGHT = 2;
+const uint SPOT_LIGHT = 3;
+
+layout( std430, binding = 3) readonly buffer texture_buffer {
+    uvec2 textures[1000];
+};
+
+layout(binding = 0) uniform uniform_per_frame
+{	
+	mat4 view;
+	mat4 proj;	
+    uint shadow_texture_id;
+    vec3 padding0;
+};
+
+layout (location=0) in VS_OUT
+{
+	vec2 vsUV;	
+};
+
+
+layout (location=0) out vec4 output_colour;
+
+void main() 
+{
+    	uvec2 shadow_handle = textures[shadow_texture_id];
+        float colour = texture(sampler2DArray(shadow_handle), vec3(vsUV, 0)).r;
+        //colour = (1.0 - (1.0 - colour) * 1.4);
+        output_colour = vec4(colour, colour, colour, 1.0);			
+        //output_colour = vec4(1,0,0,1);
+}

HydraEngine/source/ShaderFiles/texture_debug_shader.vert

@@ -0,0 +1,37 @@
+//*VERTEX*
+#version 450
+#extension GL_EXT_buffer_reference : enable
+
+layout(binding = 1) readonly buffer positions_buffer 
+{
+	mat4 model_matrix[];
+};
+
+layout(binding = 0) uniform uniform_per_frame
+{	
+	mat4 view;
+	mat4 proj;	
+    uint shadow_texture_id;
+    vec3 padding0;
+};
+
+
+layout (location = 0) in vec3 inPos; 		//12 bytes : 0
+layout (location = 1) in vec2 inUV;  		//8 Bytes  : 12
+layout (location = 2) in uvec3 inChunkID; 	//12 Bytes : 20
+layout (location = 3) in vec3 inNormal;  	//8 Bytes  : 12 
+layout (location = 4) in vec3 inBiTangent;
+layout (location = 5) in vec3 inTangent;
+
+layout (location=0) out VS_OUT
+{
+	vec2 vsUV;	
+};
+
+void main() 
+{  
+	 uint chunkid = inChunkID[0];
+	 mat4 model = model_matrix[chunkid];
+	 gl_Position = proj * view * vec4(inPos, 1.0);
+     vsUV = inUV;
+}

HydraEngine/source/actor/HydraDirectionalLightActor.cpp

@@ -8,6 +8,7 @@
 #include "../ecs/components/HydraRenderableComponent.h"
 #include "../ecs/components/HydraMaterialComponent.h"
 #include "../ecs/components/HydraLightComponent.h"
+#include "../ecs/components/HydraDirectionalShadowSourceComponent.h"
 
 #include "../buffer/HydraLightBufferManager.h"
 #include "../buffer/HydraLightBuffer.h"
@@ -19,24 +20,20 @@ void HydraDirectionalLightActor::InitialiseComponents()
 {
     HydraLightComponent light_comp = {};
 	HydraECS *ecs = GetEngine()->ECS();
-
-	// HydraLightBuffer light = {};
-    // light.light_colour = glm::vec3(1,1,1);
-    // light.light_direction = glm::vec3(0,0,0);
-    // light.light_intensity = 1;
-    // light.light_type = static_cast<uint32_t>(HYDRA_LIGHT_TYPE::HYDRA_LIGHT_DIRECTIONAL);
-
-    //light_comp.light_id = GetEngine()->LightBufferManager()->CreateLight(light);
-    
-    light_comp.light_colour = glm::vec4(1,1,1,1);
-    light_comp.light_intensity = 100.0f;
+   
+    light_comp.diffuse = glm::vec4(1,1,1,1);
+    light_comp.intensity = 10000.0f;
     light_comp.light_type = static_cast<uint32_t>(HYDRA_LIGHT_TYPE::HYDRA_LIGHT_DIRECTIONAL);
     light_comp.entity_id = GetID();
+    light_comp.shadow_caster  =1;
 
 	ecs->AddComponent<HydraLightComponent>(GetID(), light_comp);
     
-	HydraPositionComponent position_component;
+	HydraPositionComponent position_component = {};
 	ecs->AddComponent<HydraPositionComponent>(GetID(), position_component);
+
+    HydraDirectionalShadowSourceComponent shadow_component = {};
+    ecs->AddComponent<HydraDirectionalShadowSourceComponent>(GetID(), shadow_component);
 }
 
 void HydraDirectionalLightActor::Destroy()

HydraEngine/source/actor/HydraOutputActor.cpp

@@ -23,34 +23,36 @@ void HydraOutputActor::_CreateMaterial()
 		render_settings.DisplayHeight, 
 		GL_RGBA8,
 		GL_NEAREST,
-		GL_NEAREST);
+		GL_NEAREST, 1);
+
     HydraID depth = engine->TextureBufferManager()->CreateTexture("deferred_depth", 
 		render_settings.DisplayWidth, 
 		render_settings.DisplayHeight, 
 		GL_DEPTH_COMPONENT24,
 		GL_NEAREST,
-		GL_NEAREST);
+		GL_NEAREST, 1);
 
  	HydraID metal_rough = engine->TextureBufferManager()->CreateTexture("deferred_metal_rough_buffer", 
 		render_settings.DisplayWidth, 
 		render_settings.DisplayHeight, 
 		GL_RGBA8,
 		GL_NEAREST,
-		GL_NEAREST);
+		GL_NEAREST, 1);
 
 	HydraID normal = engine->TextureBufferManager()->CreateTexture("deferred_normal_buffer", 
 		render_settings.DisplayWidth, 
 		render_settings.DisplayHeight, 
 		GL_RGBA32F,
 		GL_NEAREST,
-		GL_NEAREST);
+		GL_NEAREST, 1);
 	
 	HydraID position = engine->TextureBufferManager()->CreateTexture("deferred_position_buffer", 
 		render_settings.DisplayWidth, 
 		render_settings.DisplayHeight, 
 		GL_RGBA32F,
 		GL_NEAREST,
-		GL_NEAREST);
+		GL_NEAREST, 1);
+
 
 	// engine->TextureBufferManager()->BindTexture(depth);
 	// engine->TextureBufferManager()->BindTexture(buffer_0);

HydraEngine/source/actor/HydraPointLightActor.cpp

@@ -20,8 +20,8 @@ void HydraPointLightActor::InitialiseComponents()
     HydraLightComponent light_comp = {};
 	HydraECS *ecs = GetEngine()->ECS();
     
-    light_comp.light_colour = glm::vec4(1,1,1,1);
-    light_comp.light_intensity = 10.0f;
+    light_comp.diffuse = glm::vec4(1,1,1,1);
+    light_comp.intensity = 1000.0f;
     light_comp.light_type = static_cast<uint32_t>(HYDRA_LIGHT_TYPE::HYDRA_LIGHT_POINT);
     light_comp.entity_id = GetID();
 

HydraEngine/source/actor/HydraSpotLightActor.cpp

@@ -0,0 +1,43 @@
+#include "HydraSpotLightActor.h"
+#include "../engine/HydraEngine.h"
+#include "../actor/HydraActorManager.h"
+#include "../task/HydraTask.h"
+#include "../ecs/HydraECS.h"
+#include "../ecs/components/HydraPositionComponent.h"
+#include "../ecs/components/HydraMeshComponent.h"
+#include "../ecs/components/HydraRenderableComponent.h"
+#include "../ecs/components/HydraMaterialComponent.h"
+#include "../ecs/components/HydraLightComponent.h"
+#include "../ecs/components/HydraSpotShadowSourceComponent.h"
+
+#include "../buffer/HydraLightBufferManager.h"
+#include "../buffer/HydraLightBuffer.h"
+
+
+
+
+void HydraSpotLightActor::InitialiseComponents()
+{
+    HydraLightComponent light_comp = {};
+	HydraECS *ecs = GetEngine()->ECS();
+    
+    light_comp.diffuse = glm::vec4(1,1,1,1);
+    light_comp.intensity = 10000.0f;
+    light_comp.light_type = static_cast<uint32_t>(HYDRA_LIGHT_TYPE::HYDRA_LIGHT_SPOT);
+    light_comp.cutoff = glm::cos(glm::radians(10.0f));
+    light_comp.cutoff_outer = glm::cos(glm::radians(25.0f));
+    light_comp.entity_id = GetID();
+
+	ecs->AddComponent<HydraLightComponent>(GetID(), light_comp);
+    
+	HydraPositionComponent position_component;
+	ecs->AddComponent<HydraPositionComponent>(GetID(), position_component);
+
+    HydraSpotShadowSourceComponent shadow_component = {};
+    ecs->AddComponent<HydraSpotShadowSourceComponent>(GetID(), shadow_component);
+}
+
+void HydraSpotLightActor::Destroy()
+{
+
+}

HydraEngine/source/actor/HydraSpotLightActor.h

@@ -0,0 +1,18 @@
+#ifndef HYDRASPOTLIGHTACTOR
+#define HYDRASPOTLIGHTACTOR
+
+#include "HydraActor.h"
+
+class CLASS_DEFINE HydraSpotLightActor : public HydraActor
+{
+    private:
+        
+    protected:
+        
+    public:
+        virtual void InitialiseComponents() override;
+        virtual void Destroy() override;
+        
+};
+
+#endif /* HYDRASPOTLIGHTACTOR */

HydraEngine/source/actor/HydraTestCubeActor.cpp

@@ -0,0 +1,208 @@
+#include "HydraTestCubeActor.h"
+#include "../engine/HydraEngine.h"
+#include "../actor/HydraActorManager.h"
+#include "../task/HydraTask.h"
+#include "../ecs/HydraECS.h"
+#include "../ecs/components/HydraPositionComponent.h"
+#include "../ecs/components/HydraMeshComponent.h"
+#include "../ecs/components/HydraRenderableComponent.h"
+#include "../ecs/components/HydraMaterialComponent.h"
+#include "../buffer/HydraMaterialBufferManager.h"
+#include "../buffer/HydraTextureBufferManager.h"
+#include "../buffer/HydraMaterialBuffer.h"
+#include "../mesh/HydraMeshManager.h"
+#include "../mesh/HydraMesh.h"
+
+void HydraTestCubeActor::InitialiseComponents()
+{
+	// HydraECS* ecs = GetEngine()->ECS();
+	// HydraID entity_id = ecs->CreateEntity();
+	_CreatePosition();
+	// _CreatePhysics();
+
+	_CreateMaterial();
+	_CreateMesh();
+	_CreateRenderableComponent();
+}
+
+void HydraTestCubeActor::DeferredInitialiseComponents()
+{
+}
+
+void HydraTestCubeActor::_CreatePosition()
+{
+	HydraECS *ecs = GetEngine()->ECS();
+	HydraPositionComponent position_component;
+	ecs->AddComponent<HydraPositionComponent>(GetID(), position_component);
+}
+
+void HydraTestCubeActor::_CreateMesh()
+{
+	HydraMeshManager *mesh_manager = GetEngine()->MeshManager();
+	HydraID mesh_id = mesh_manager->CreateMesh();
+	HydraMesh *mesh = mesh_manager->GetMesh(mesh_id);
+
+	HydraMaterialComponent mat_comp = GetEngine()->ECS()->GetComponent<HydraMaterialComponent>(GetID());
+
+	mesh->vertexes.resize(24);
+	mesh->indexes.resize(36);
+
+	float scale_x = 1.0f;
+	float scale_y = 1.0f;
+	float scale_z = 1.0f;
+
+	float min_x = -0.5f * scale_x;
+	float min_y = -0.5f * scale_y;
+	float min_z = -0.5f * scale_z;
+
+	float max_x = 0.5f * scale_x;
+	float max_y = 0.5f * scale_y;
+	float max_z = 0.5f * scale_z;
+
+	float min_u = 1;
+	float min_v = 1;
+
+	float max_u = 0;
+	float max_v = 0;
+
+	// 1---2		5---6
+	//|	/ |		| / |
+	// 0---3		4---7
+
+	HydraID actor_id = GetID();
+	mesh->vertexes[0] = {min_x, min_y, min_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[1] = {min_x, max_y, min_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[2] = {max_x, max_y, min_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[3] = {max_x, min_y, min_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	// Face 0
+	mesh->indexes[0] = 0;
+	mesh->indexes[1] = 1;
+	mesh->indexes[2] = 2;
+
+	mesh->indexes[3] = 0;
+	mesh->indexes[4] = 2;
+	mesh->indexes[5] = 3;
+
+	mesh->vertexes[4] = {max_x, min_y, min_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[5] = {max_x, max_y, min_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[6] = {max_x, max_y, max_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[7] = {max_x, min_y, max_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[6] = 4;
+	mesh->indexes[7] = 5;
+	mesh->indexes[8] = 6;
+
+	mesh->indexes[9] = 4;
+	mesh->indexes[10] = 6;
+	mesh->indexes[11] = 7;
+
+	// Back Face
+	mesh->vertexes[8] = {max_x, min_y, max_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[9] = {max_x, max_y, max_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[10] = {min_x, max_y, max_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[11] = {min_x, min_y, max_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[12] = 8;
+	mesh->indexes[13] = 9;
+	mesh->indexes[14] = 10;
+
+	mesh->indexes[15] = 8;
+	mesh->indexes[16] = 10;
+	mesh->indexes[17] = 11;
+
+	mesh->vertexes[12] = {min_x, min_y, max_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[13] = {min_x, max_y, max_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[14] = {min_x, max_y, min_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[15] = {min_x, min_y, min_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[18] = 12;
+	mesh->indexes[19] = 13;
+	mesh->indexes[20] = 14;
+
+	mesh->indexes[21] = 12;
+	mesh->indexes[22] = 14;
+	mesh->indexes[23] = 15;
+
+	mesh->vertexes[16] = {min_x, max_y, min_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[17] = {min_x, max_y, max_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[18] = {max_x, max_y, max_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[19] = {max_x, max_y, min_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[24] = 16;
+	mesh->indexes[25] = 17;
+	mesh->indexes[26] = 18;
+
+	mesh->indexes[27] = 16;
+	mesh->indexes[28] = 18;
+	mesh->indexes[29] = 19;
+
+	mesh->vertexes[20] = {min_x, min_y, min_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[21] = {max_x, min_y, min_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[22] = {max_x, min_y, max_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[23] = {min_x, min_y, max_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[30] = 20;
+	mesh->indexes[31] = 21;
+	mesh->indexes[32] = 22;
+
+	mesh->indexes[33] = 20;
+	mesh->indexes[34] = 22;
+	mesh->indexes[35] = 23;
+
+	mesh_manager->CalculateNormals(mesh->mesh_id);
+
+	HydraECS *ecs = GetEngine()->ECS();
+	HydraMeshComponent mesh_comp;
+
+	mesh_comp.mesh_id = mesh_id;
+	mesh_comp.mesh_state = HYDRA_STATE::Waiting;
+
+	ecs->AddComponent<HydraMeshComponent>(GetID(), mesh_comp);
+}
+
+void HydraTestCubeActor::_CreateMaterial()
+{
+
+	HydraEngine *engine = GetEngine();
+	std::string filename = std::string(texture_base) + std::string("/DesignArea/DesignArea_Albedo.png");
+
+	HydraID tex_id = engine->TextureBufferManager()->LoadTexture(filename);
+
+	HydraMaterialBuffer material = {};
+
+	material.diffuse_texture_id = tex_id;
+	material.diffuse_colour = glm::vec4(1, 1, 1, 1);
+	material.metalic_rough = glm::vec4(0, 0.5, 0.3, 1);
+	HydraID mat_id = engine->MaterialBufferManager()->CreateMaterial(material);
+
+	HydraMaterialComponent mat_comp = {};
+	mat_comp.material_id = mat_id;
+	engine->ECS()->AddComponent<HydraMaterialComponent>(GetID(), mat_comp);
+}
+
+void HydraTestCubeActor::_CreatePhysics()
+{
+	// HydraECSPhysicsComponent physics_component;
+	// physics_component.physics_state = Hydra_State::Waiting;
+	// physics_component.physics_definition.actor_id = GetID();
+	// physics_component.physics_definition.physics_type = HydraPhyicsType::Static;
+	// physics_component.physics_definition.physics_shape = HydraPhysicsShape::HydraBoxShape;
+	// physics_component.physics_definition.mass = 100000.0f;
+	// physics_component.physics_definition.extent_x = 1000.0f;
+	// physics_component.physics_definition.extent_y = 0.5f;
+	// physics_component.physics_definition.extent_z = 1000.0f;
+	// physics_component.physics_definition.dynamic_friction = 0.5f;
+	// physics_component.physics_definition.restitution = 0.5f;
+
+	// HydraECS* ecs = GetEngine()->ECS();
+
+	// ecs->AddComponent<HydraECSPhysicsComponent>(GetID(), physics_component);
+}
+void HydraTestCubeActor::_CreateRenderableComponent()
+{
+	HydraRenderableComponent render_comp;
+	HydraECS *ecs = GetEngine()->ECS();
+	render_comp.renderable_types.set((uint32_t)HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR, true);
+	ecs->AddComponent<HydraRenderableComponent>(GetID(), render_comp);
+}

HydraEngine/source/actor/HydraTestCubeActor.h

@@ -0,0 +1,31 @@
+#ifndef HYDRATESTCUBEACTOR
+#define HYDRATESTCUBEACTOR
+
+
+#include "HydraActor.h"
+
+class CLASS_DEFINE HydraTestCubeActor : public HydraActor
+{
+    private:
+        double m_scale = 1.0;
+        double m_widthscale = 1.0f;
+        HydraID m_material_component = INVALID_HYDRA_ID;
+        HydraID m_position_component = INVALID_HYDRA_ID;
+        HydraID m_mesh_component = INVALID_HYDRA_ID;
+    protected:
+        void _CreatePosition();
+        void _CreateMesh();
+        void _CreateMaterial();
+        void _CreatePhysics();
+        void _CreateRenderableComponent();
+    public:
+        virtual void InitialiseComponents();
+        virtual void DeferredInitialiseComponents();
+        virtual void Destroy(){}
+        
+};
+
+
+
+
+#endif /* HYDRATESTCUBEACTOR */

HydraEngine/source/actor/HydraTextureDebugActor.cpp

@@ -0,0 +1,87 @@
+#include "HydraTextureDebugActor.h"
+#include "../engine/HydraEngine.h"
+#include "../actor/HydraActorManager.h"
+#include "../task/HydraTask.h"
+#include "../ecs/HydraECS.h"
+#include "../ecs/components/HydraPositionComponent.h"
+#include "../ecs/components/HydraMeshComponent.h"
+#include "../ecs/components/HydraRenderableComponent.h"
+#include "../ecs/components/HydraMaterialComponent.h"
+#include "../buffer/HydraMaterialBufferManager.h"
+#include "../buffer/HydraTextureBufferManager.h"
+#include "../buffer/HydraMaterialBuffer.h"
+#include "../mesh/HydraMeshManager.h"
+#include "../mesh/HydraMesh.h"
+
+
+
+void HydraTextureDebugActor::_CreateMesh()
+{
+    HydraMeshManager *mesh_manager = GetEngine()->MeshManager();
+	HydraID mesh_id = mesh_manager->CreateMesh();
+	HydraMesh *mesh = mesh_manager->GetMesh(mesh_id);
+
+	mesh->vertexes.resize(4);
+	mesh->indexes.resize(6);
+
+	float scale_x = 1.0f;
+	float scale_y = 1.0f;
+	float scale_z = 1.0f;
+
+	float min_x = -0.5f * scale_x;
+	float min_y = -0.5f * scale_y;
+	float min_z = 0.5f * scale_z;
+
+	float max_x = 0.5f * scale_x;
+	float max_y = 0.5f * scale_y;
+	float max_z = 0.5f * scale_z;
+
+	float min_u = 0;
+	float min_v = 0;
+
+	float max_u = 1;
+	float max_v = 1;
+
+	// 1---2		5---6
+	// | / |	    | / |
+	// 0---3		4---7
+
+	HydraID actor_id = GetID();
+	mesh->vertexes[0] = {min_x, min_y, min_z, min_u, min_v, actor_id, 0, 0, 0,0,0,0,0,0,0,0,0};
+	mesh->vertexes[1] = {min_x, max_y, min_z, min_u, max_v, actor_id, 0, 0, 0,0,0,0,0,0,0,0,0};
+	mesh->vertexes[2] = {max_x, max_y, min_z, max_u, max_v, actor_id, 0, 0, 0,0,0,0,0,0,0,0,0};
+	mesh->vertexes[3] = {max_x, min_y, min_z, max_u, min_v, actor_id, 0, 0, 0,0,0,0,0,0,0,0,0};
+
+	// Face 0
+	mesh->indexes[0] = 0;
+	mesh->indexes[1] = 1;
+	mesh->indexes[2] = 2;
+
+	mesh->indexes[3] = 0;
+	mesh->indexes[4] = 2;
+	mesh->indexes[5] = 3;
+	
+
+	HydraECS *ecs = GetEngine()->ECS();
+	HydraMeshComponent mesh_comp;
+
+	mesh_comp.mesh_id = mesh_id;
+	mesh_comp.mesh_state = HYDRA_STATE::Waiting;
+
+	ecs->AddComponent<HydraMeshComponent>(GetID(), mesh_comp);
+}
+
+void HydraTextureDebugActor::_CreateRenderableComponent()
+{
+    HydraRenderableComponent render_comp;
+	HydraECS *ecs = GetEngine()->ECS();
+	render_comp.renderable_types.set((uint32_t)HYDRA_RENDERABLE_TYPE::HYDRA_TEXTURE_DEBUG, true);
+	ecs->AddComponent<HydraRenderableComponent>(GetID(), render_comp);
+}
+
+
+void HydraTextureDebugActor::InitialiseComponents()
+{
+    _CreateMesh();
+    _CreateRenderableComponent();
+}

HydraEngine/source/actor/HydraTextureDebugActor.h

@@ -0,0 +1,25 @@
+#ifndef HYDRATEXTUREDEBUGACTOR
+#define HYDRATEXTUREDEBUGACTOR
+
+
+#include "HydraActor.h"
+
+class CLASS_DEFINE HydraTextureDebugActor : public HydraActor
+{
+    private:
+        HydraID m_mesh_component = INVALID_HYDRA_ID;
+
+    protected:
+        
+        void _CreateMesh();
+        void _CreateRenderableComponent();
+    public:
+        virtual void InitialiseComponents();
+        virtual void Destroy(){}
+        HydraID Texture_ID = INVALID_HYDRA_ID;
+};
+
+
+
+
+#endif /* HYDRATEXTUREDEBUGACTOR */

HydraEngine/source/buffer/HydraBufferManager.cpp

@@ -22,30 +22,6 @@ void HydraBufferManager::Shutdown()
     }
 }
 
-// HydraID HydraBufferManager::CreateGPUBuffer(std::string buffer_name, 
-//     uint32_t buffer_size_bytes, 
-//     uint32_t binding,
-//     HYDRA_BUFFER_TYPE buffer_type)
-// {
-//     HydraID buffer_id = _GetBufferID();
-//     HydraBuffer buffer = {};
-//     buffer.buffer_id = buffer_id;
-//     buffer.size_bytes = buffer_size_bytes;
-//     buffer.buffer_name = buffer_name;
-//     buffer.buffer_type = buffer_type;
-//     uint32_t gl_buffer_type = _DecodeBufferType(buffer_type);
-//     //Create the buffer
-//     glGenBuffers(1, &buffer.gpu_buffer_id);
-//     glBindBuffer(gl_buffer_type, buffer.gpu_buffer_id);
-//     //Allocate storage
-//     glBufferData(gl_buffer_type, buffer.size_bytes, NULL, GL_DYNAMIC_DRAW);     
-//     glBindBufferBase(gl_buffer_type, binding, buffer.gpu_buffer_id);
-//     glBindBuffer(gl_buffer_type, 0);
-//     m_buffers[buffer_id] = buffer;
-//     return buffer_id;
-    
-// }
-
 HydraID HydraBufferManager::CreateGPUBuffer(std::string buffer_name, 
     uint32_t buffer_size_bytes, 
     uint32_t binding,

HydraEngine/source/buffer/HydraShadowBuffer.h

@@ -0,0 +1,14 @@
+#ifndef HYDRASHADOWBUFFER
+#define HYDRASHADOWBUFFER
+    
+
+#include "../engine/HydraEngine.h"
+#include "../ecs/components/HydraDirectionalShadowSourceComponent.h"
+#include "../ecs/components/HydraSpotShadowSourceComponent.h"
+
+struct HydraShadowBuffer
+{
+    HydraDirectionalShadowSourceComponent directional_shadows[MAX_DIRECTIONAL_SHADOWS];
+    HydraSpotShadowSourceComponent spot_shadows[MAX_SPOT_SHADOWS];
+};
+#endif /* HYDRASHADOWBUFFER */

HydraEngine/source/buffer/HydraShadowBufferManager.cpp

@@ -0,0 +1,115 @@
+#include "HydraShadowBufferManager.h"
+#include "../scheduler/HydraTaskScheduler.h"
+#include "../task/buffer/HydraCreateGPUBufferTask.hpp"
+#include "../task/buffer/HydraUpdateWholeGPUBufferTask.hpp"
+#include "../task/buffer/HydraUpdatePartialGPUBufferTask.hpp"
+#include "../task/buffer/HydraCreateUnBoundTextureTask.hpp"
+#include "../task/renderer/HydraCreateCascadeShadowFrameBuffer.hpp"
+#include "../task/renderer/HydraCreateShadowFrameBuffer.hpp"
+
+void HydraShadowBufferManager::Initialise()
+{
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+    for(uint32_t i = 0; i < MAX_DIRECTIONAL_SHADOWS; i++)
+    {
+        m_available_dir.push(i);
+    }
+    for(uint32_t i = 0; i < MAX_SPOT_SHADOWS; i++)
+    {
+        m_available_spot.push(i);
+    }
+    m_directional_shadow_buffer.resize(MAX_DIRECTIONAL_SHADOWS);
+    m_spot_shadow_buffer.resize(MAX_SPOT_SHADOWS);
+
+
+    uint32_t buffer_size = (MAX_DIRECTIONAL_SHADOWS * sizeof(HydraDirectionalShadowSourceComponent));
+                          
+    HydraID create_gpu_buffer_task_id = task_scheduler->CreateTask<HydraCreateGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraCreateGPUBufferTask *task = static_cast<HydraCreateGPUBufferTask *>(task_scheduler->GetTask(create_gpu_buffer_task_id));
+    task->Intialise("DirectionalShadowBuffer", 1, buffer_size, &m_directional_shadow_buffer_id, HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+    task_scheduler->WaitForTask(create_gpu_buffer_task_id);
+
+    buffer_size = (MAX_SPOT_SHADOWS * sizeof(HydraSpotShadowSourceComponent));
+
+    create_gpu_buffer_task_id = task_scheduler->CreateTask<HydraCreateGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraCreateGPUBufferTask *spot_task = static_cast<HydraCreateGPUBufferTask *>(task_scheduler->GetTask(create_gpu_buffer_task_id));
+    spot_task->Intialise("SpotShadowBuffer", 1, buffer_size, &m_spot_shadow_buffer_id, HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+    task_scheduler->WaitForTask(create_gpu_buffer_task_id);
+}
+void HydraShadowBufferManager::Shutdown()
+{
+
+}
+HydraID HydraShadowBufferManager::AddDirectionalShadow(HydraDirectionalShadowSourceComponent shadow)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if(m_available_dir.size() == 0)
+    {
+        return INVALID_HYDRA_ID;
+    }
+
+    HydraID shadow_id = m_available_dir.front();
+    shadow.shadow_id = shadow_id;
+    m_directional_shadow_buffer[shadow_id] = shadow;
+    return shadow_id;
+}
+HydraID HydraShadowBufferManager::AddSpotShadow(HydraSpotShadowSourceComponent shadow)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if(m_available_spot.size() == 0)
+    {
+        return INVALID_HYDRA_ID;
+    }
+
+    HydraID shadow_id = m_available_spot.front();
+    m_spot_shadow_buffer[shadow_id] = shadow;
+    return shadow_id;
+}
+
+void HydraShadowBufferManager::UpdateDirectionalShadow(HydraID shadow_id, HydraDirectionalShadowSourceComponent shadow)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if(shadow_id < MAX_DIRECTIONAL_SHADOWS)
+    {
+        m_directional_shadow_buffer[shadow_id] = shadow;
+    }
+}
+
+void HydraShadowBufferManager::UpdateSpotShadow(HydraID shadow_id, HydraSpotShadowSourceComponent shadow)
+{
+        std::lock_guard<std::mutex> lock(m_mutex);
+    if(shadow_id < MAX_SPOT_SHADOWS)
+    {
+        m_spot_shadow_buffer[shadow_id] = shadow;
+    }
+}
+
+void HydraShadowBufferManager::RemoveDirectionalShadow(HydraID shadow_id)
+{
+
+}
+void HydraShadowBufferManager::RemoveSpotShadow(HydraID shadow_id)
+{
+
+}
+
+void HydraShadowBufferManager::UpdateShadowBuffer()
+{
+    HydraEngine *engine = GetEngine();
+    HydraECS *ecs = engine->ECS();
+
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+    void *buffer = static_cast<void *>(m_directional_shadow_buffer.data());
+
+    HydraID update_buffer_task_id = task_scheduler->CreateTask<HydraUpdateWholeGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraUpdateWholeGPUBufferTask *task = static_cast<HydraUpdateWholeGPUBufferTask *>(task_scheduler->GetTask(update_buffer_task_id));
+    task->Intialise(m_directional_shadow_buffer_id,  buffer);
+    task_scheduler->WaitForTask(update_buffer_task_id);
+
+    void *spot_buffer = static_cast<void *>(m_spot_shadow_buffer.data());
+
+    update_buffer_task_id = task_scheduler->CreateTask<HydraUpdateWholeGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraUpdateWholeGPUBufferTask *spot_task = static_cast<HydraUpdateWholeGPUBufferTask *>(task_scheduler->GetTask(update_buffer_task_id));
+    spot_task->Intialise(m_spot_shadow_buffer_id,  spot_buffer);
+    task_scheduler->WaitForTask(update_buffer_task_id);
+}

HydraEngine/source/buffer/HydraShadowBufferManager.h

@@ -0,0 +1,34 @@
+#ifndef HYDRASHADOWBUFFERMANAGER
+#define HYDRASHADOWBUFFERMANAGER
+
+#include "../engine/HydraObject.h"
+#include "HydraShadowBuffer.h"
+#include "../ecs/components/HydraDirectionalShadowSourceComponent.h"
+#include "../ecs/components/HydraSpotShadowSourceComponent.h"
+
+#include <queue>
+#include <mutex>
+
+class HydraShadowBufferManager : public HydraObject
+{
+    public:
+        void Initialise();
+        void Shutdown();
+        HydraID AddDirectionalShadow(HydraDirectionalShadowSourceComponent shadow);
+        HydraID AddSpotShadow(HydraSpotShadowSourceComponent shadow);
+        void UpdateDirectionalShadow(HydraID shadow_id, HydraDirectionalShadowSourceComponent shadow);
+        void UpdateSpotShadow(HydraID shadow_id, HydraSpotShadowSourceComponent shadow);
+        void RemoveDirectionalShadow(HydraID shadow_id);
+        void RemoveSpotShadow(HydraID shadow_id);
+        void UpdateShadowBuffer();
+    private:
+        std::vector<HydraDirectionalShadowSourceComponent> m_directional_shadow_buffer;
+        std::vector<HydraSpotShadowSourceComponent> m_spot_shadow_buffer;
+        std::queue<HydraID> m_available_dir;
+        std::queue<HydraID> m_available_spot;
+        uint32_t m_directional_shadow_buffer_id;
+        uint32_t m_spot_shadow_buffer_id;
+        std::mutex m_mutex;
+        
+};
+#endif /* HYDRASHADOWBUFFERMANAGER */

HydraEngine/source/buffer/HydraTextureBufferManager.cpp

@@ -57,13 +57,13 @@ HydraID HydraTextureBufferManager::LoadTexture(std::string texture_filename)
     HydraID create_tex_id = scheduler->CreateTask<HydraCreateTextureTask>(HydraThreadAffinity::Render);
     HydraCreateTextureTask *create_tex_task = static_cast<HydraCreateTextureTask *>(scheduler->GetTask(create_tex_id));
     HydraID tex_id = INVALID_HYDRA_ID;
-    create_tex_task->Initialise(texture_filename,
+    create_tex_task->Initialise(texture_filename,                                
                                 width,
                                 height,
                                 GL_RGBA8,
                                 format,
                                 GL_NEAREST_MIPMAP_NEAREST,
-                                GL_LINEAR,
+                                GL_LINEAR,                                
                                 GL_UNSIGNED_BYTE,
                                 5,
                                 data,
@@ -106,12 +106,50 @@ HydraID HydraTextureBufferManager::_GetTextureID()
     return id;
 }
 
-HydraID HydraTextureBufferManager::CreateTexture(std::string texture_name,
+HydraID HydraTextureBufferManager::CreateTextureArray(std::string texture_name,                                                 
                                                  uint32_t width,
                                                  uint32_t height,
                                                  uint32_t internal_format,
                                                  uint32_t min_filter,
                                                  uint32_t mag_filter,
+                                                 uint32_t levels                                                 
+                                                 )
+{
+    uint32_t gl_tex_id = 0;
+    glCreateTextures(GL_TEXTURE_2D_ARRAY, 1, &gl_tex_id);
+    glBindTexture(GL_TEXTURE_2D_ARRAY, gl_tex_id);
+
+    
+    glTextureStorage3D(gl_tex_id, 1, internal_format, width, height, levels);
+
+    
+    glTextureParameteri(gl_tex_id, GL_TEXTURE_MIN_FILTER, min_filter);
+    glTextureParameteri(gl_tex_id, GL_TEXTURE_MAG_FILTER, mag_filter);
+
+    glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
+    HydraTextureBuffer texture_buffer = {};
+    HydraID texture_id = _GetTextureID();
+    texture_buffer.texture_id = texture_id;
+    texture_buffer.format = 0;
+    texture_buffer.internal_format = internal_format;
+    texture_buffer.width = width;
+    texture_buffer.height = height;
+    texture_buffer.gl_tex_id = gl_tex_id;
+    texture_buffer.mag_filter = mag_filter;
+    texture_buffer.min_filter = min_filter;
+
+    m_textures[texture_id] = texture_buffer;
+    m_texture_lookup.insert(std::pair<std::string, HydraID>(texture_name, texture_id));
+
+    return texture_id;
+}
+
+HydraID HydraTextureBufferManager::CreateTexture(std::string texture_name,                                                 
+                                                 uint32_t width,
+                                                 uint32_t height,
+                                                 uint32_t internal_format,
+                                                 uint32_t min_filter,
+                                                 uint32_t mag_filter,                                                 
                                                  uint32_t format,
                                                  uint32_t data_type,
                                                  uint32_t mip_levels,
@@ -120,9 +158,8 @@ HydraID HydraTextureBufferManager::CreateTexture(std::string texture_name,
     uint32_t gl_tex_id = 0;
     glCreateTextures(GL_TEXTURE_2D, 1, &gl_tex_id);
     glBindTexture(GL_TEXTURE_2D, gl_tex_id);
-
-    // important to create mip_levels + 1 images
-    glTextureStorage2D(gl_tex_id, mip_levels + 1, internal_format, width, height);
+    
+    glTextureStorage2D(gl_tex_id,1+ mip_levels, internal_format, width, height);
 
     if (data != nullptr)
     {
@@ -160,7 +197,7 @@ HydraID HydraTextureBufferManager::CreateTexture(std::string texture_name,
     return texture_id;
 }
 
-void HydraTextureBufferManager::BindTexture(HydraID texture_id)
+void HydraTextureBufferManager::BindTexture(HydraID texture_id, uint32_t target)
 {
 
     if (texture_id >= MAX_TEXTURES)
@@ -168,7 +205,7 @@ void HydraTextureBufferManager::BindTexture(HydraID texture_id)
         return;
     }
     HydraTextureBuffer texture = m_textures[texture_id];
-    glBindTexture(GL_TEXTURE_2D, texture.gl_tex_id);
+    glBindTexture(target, texture.gl_tex_id);
     glTextureParameteri(texture.gl_tex_id, GL_TEXTURE_WRAP_S, GL_REPEAT);
     glTextureParameteri(texture.gl_tex_id, GL_TEXTURE_WRAP_T, GL_REPEAT);
     glTextureParameteri(texture.gl_tex_id, GL_TEXTURE_MIN_FILTER, texture.min_filter);

HydraEngine/source/buffer/HydraTextureBufferManager.h

@@ -18,10 +18,19 @@ class HydraTextureBufferManager : public HydraObject
     public:
         void Intialise();                
         void Shutdown();
-        HydraID CreateTexture(std::string texture_name, uint32_t width, uint32_t height, uint32_t internal_format, 
+        HydraID CreateTexture(std::string texture_name,
+            uint32_t width, uint32_t height, uint32_t internal_format, 
             uint32_t min_filter, uint32_t mag_filter,
-            uint32_t format = GL_RGBA, uint32_t data_type = GL_UNSIGNED_BYTE, uint32_t mip_levels = 0, void* data = nullptr);        
-        void BindTexture(HydraID texture_id);
+            uint32_t format = GL_RGBA, uint32_t data_type = GL_UNSIGNED_BYTE, uint32_t mip_levels = 0, void* data = nullptr);  
+            
+        HydraID CreateTextureArray(std::string texture_name,                                                 
+                                                 uint32_t width,
+                                                 uint32_t height,
+                                                 uint32_t internal_format,
+                                                 uint32_t min_filter,
+                                                 uint32_t mag_filter,
+                                                 uint32_t levels);
+        void BindTexture(HydraID texture_id, uint32_t target);
         void UnbindTexture(HydraID texture_id);
         void DeleteTexture(HydraID texture_id);
         HydraID LoadTexture(std::string texture_filename);

HydraEngine/source/ecs/HydraComponentArray.h

@@ -69,6 +69,10 @@ class HydraComponentArray : public IHydraComponentArray
         T& GetComponent(HydraID entity_id)
         {
             std::lock_guard<std::mutex> lock(m_mutex);
+            if(m_entity_to_component.find(entity_id) == m_entity_to_component.end())
+            {
+                std::cout << "HERE";
+            }
             assert(m_entity_to_component.find(entity_id) != m_entity_to_component.end() && "Trying to get a component that doesnt exist");
             HydraID component_index = m_entity_to_component[entity_id];
             return m_components[component_index];

HydraEngine/source/ecs/HydraSystemManager.h

@@ -26,11 +26,9 @@ public:
 	template <typename T> std::shared_ptr<T> GetSystem()
 	{
 		std::string type_name = std::string(typeid(T).name());
-
 		auto it = m_systems.find(type_name);
 		assert(it!= m_systems.end() && "System not found.");
 		return std::static_pointer_cast<T>( it->second);
-        
 	}
 
     template <typename T>
@@ -50,12 +48,9 @@ public:
     template<typename T> void SetSignature(HydraSignature signature)
     {
         std::string type_name = std::string(typeid(T).name());
-
 		assert(m_systems.find(type_name) != m_systems.end() && "System used before registered.");
-
 		// Set the signature for this system
 		m_signatures.insert({type_name, signature});
-
     }
     void EntitySignatureChanged(HydraID entity_id, HydraSignature signature)
 	{

HydraEngine/source/ecs/components/HydraDirectionalShadowSourceComponent.h

@@ -0,0 +1,18 @@
+#ifndef HYDRADIRECTIONALSHADOWSOURCECOMPONENT
+#define HYDRADIRECTIONALSHADOWSOURCECOMPONENT
+
+#include "../../engine/HydraEngine.h"
+
+struct HydraDirectionalShadowSourceComponent
+{
+    uint32_t entity_id;
+    uint32_t shadow_id;
+    uint32_t shadow_texture_id;   
+    uint32_t frame_buffer_id;
+    float near_plane[8];
+    float far_plane[8];
+    alignas(16) glm::mat4 light_space_proj[6];
+    alignas(16) glm::mat4 light_space_view[6];
+};
+            
+#endif /* HYDRACASTERCOMPONENT */

HydraEngine/source/ecs/components/HydraLightComponent.h

@@ -4,11 +4,21 @@
 
 struct HydraLightComponent
 {        
-	glm::vec4 light_colour;
-	float light_intensity;    
+	glm::vec4 ambient = {0.0f, 0.0f, 0.0f, 0.0f};
+	glm::vec4 diffuse = {1.0f, 1.0f, 1.0f, 1.0f};
+	glm::vec4 specular = {1.0f, 1.0f, 1.0f, 1.0f};
+	float intensity = 1.0f;
+	float constant = 1.0f;
+	float linear = 0.7;
+	float quadratic = 1.8;
+	float cutoff = 0.5f;
+	float cutoff_outer = 0.75f;
     HydraID entity_id;
     uint32_t light_type;
-	float padding[1];
+	uint32_t shadow_map_id = 0;
+	uint32_t shadow_caster = 0;
+	uint32_t padding0;
+	uint32_t padding1;
 };
 
 #endif /* HYDRAECSLIGHTCOMPONENT */

HydraEngine/source/ecs/components/HydraShadowComponent.h

@@ -1,18 +0,0 @@
-#ifndef HYDRAECSSHADOWCOMPONENT
-#define HYDRAECSSHADOWCOMPONENT
-//#include "../helper/VulkanHelper.h"
-//#include "../buffer/HydraShadowMapTransform.h"
-
-struct HydrahadowComponent
-{
-    // HydraID shadow_map_id;                          //4
-    // HydraID shadow_map_index;                       //8
-    // float padding0;                                 //12
-    // float padding1;                                 //16
-    // HydraShadowMapTransform shadow_transforms[6];   //880 (144*6) 
-    // float padding[20];                              //960
-    
-
-};
-
-#endif /* HYDRAECSSHADOWCOMPONENT */

HydraEngine/source/ecs/components/HydraSpotShadowSourceComponent.h

@@ -0,0 +1,18 @@
+#ifndef HYDRASPOTSHADOWCOMPONENT
+#define HYDRASPOTSHADOWCOMPONENT
+
+#include "../../engine/HydraEngine.h"
+
+struct HydraSpotShadowSourceComponent
+{
+    uint32_t entity_id;    
+    uint32_t shadow_id;
+    uint32_t shadow_texture_id;   
+    uint32_t frame_buffer_id;    
+    float far_plane;
+    uint32_t padding[3];
+    alignas(16) glm::mat4 light_space_proj;
+    alignas(16) glm::mat4 light_space_view;
+};
+            
+#endif /* HYDRASPOTSHADOWCOMPONENT */

HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.cpp

@@ -0,0 +1,118 @@
+#include "HydraDirectionalShadowSourceSystem.h"
+#include "../../engine/HydraEngine.h"
+#include "../../camera/HydraCamera.h"
+#include "../HydraECS.h"
+#include "../components/HydraDirectionalShadowSourceComponent.h"
+#include "../components/HydraPositionComponent.h"
+#include "../components/HydraLightComponent.h"
+
+#include "../../buffer/HydraShadowBuffer.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+#include "../../buffer/HydraShadowBufferManager.h"
+
+#include "../../scheduler/HydraTaskScheduler.h"
+#include "../../task/buffer/HydraCreateGPUBufferTask.hpp"
+#include "../../task/buffer/HydraUpdateWholeGPUBufferTask.hpp"
+#include "../../task/buffer/HydraUpdatePartialGPUBufferTask.hpp"
+#include "../../task/buffer/HydraCreateUnBoundTextureTask.hpp"
+#include "../../task/renderer/HydraCreateCascadeShadowFrameBuffer.hpp"
+#include "../../task/renderer/HydraCreateShadowFrameBuffer.hpp"
+#include "../../actor/HydraActorManager.h"
+
+void HydraDirectionalShadowSourceSystem::Initialise()
+{
+
+}
+
+void HydraDirectionalShadowSourceSystem::InitialiseComponent(HydraID entity_id)
+{
+    HydraEngine *engine = GetEngine();
+    HydraECS *ecs = engine->ECS();
+    HydraLightComponent &light_comp = ecs->GetComponent<HydraLightComponent>(entity_id);
+
+    
+    HydraDirectionalShadowSourceComponent& shadow_comp = ecs->GetComponent<HydraDirectionalShadowSourceComponent>(entity_id);
+
+    HydraID shadow_id = GetEngine()->ShadowBufferManager()->AddDirectionalShadow(shadow_comp);
+    assert(shadow_id != INVALID_HYDRA_ID && "Add directional Shadow - out of shadows!");
+
+    light_comp.shadow_map_id = shadow_id;
+    light_comp.shadow_caster = 1;
+    shadow_comp.shadow_id = shadow_id;
+    _InitialiseShadowMap(entity_id);
+
+}
+
+void HydraDirectionalShadowSourceSystem::UpdateSystem(float delta_t_seconds)
+{
+    for (HydraID entity_id : Entities)
+    {
+        _UpdateShadowMap(entity_id);
+    }
+}
+
+void HydraDirectionalShadowSourceSystem::_UpdateShadowMap(HydraID entity_id)
+{
+    HydraEngine *engine = GetEngine();
+    HydraECS *ecs = engine->ECS();
+    HydraPositionComponent pos_comp = ecs->GetComponent<HydraPositionComponent>(entity_id);
+    HydraDirectionalShadowSourceComponent &shad_comp = ecs->GetComponent<HydraDirectionalShadowSourceComponent>(entity_id);
+
+    float view_size = 4.0f;
+    float view_near = 0.1f;
+    float view_far = 4.0f;
+    
+    glm::mat4 light_rot = glm::eulerAngleXYZ(pos_comp.orientation.x, pos_comp.orientation.y, pos_comp.orientation.z);
+    glm::vec3 light_dir = glm::normalize(glm::vec3(light_rot * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f)));
+
+    glm::vec3 camera_pos = GetEngine()->Camera()->GetPosition();
+
+    for (uint32_t i = 0; i < 6; i++)
+    {
+        glm::vec3 light_pos = camera_pos;//- (light_dir * 2.0f);          
+        glm::vec3 target_pos = light_pos + light_dir;
+        glm::vec3 up_vector = glm::vec3(0.0f, 1.0f, 0.0f);
+
+        if (glm::abs(glm::dot(light_dir, up_vector)) > 0.99f) 
+        {
+            up_vector = glm::vec3(1.0f, 0.0f, 0.0f); // Prevent gimbal lock
+        }
+
+        glm::mat4 view = glm::lookAt(light_pos, target_pos, up_vector);         
+        glm::mat4 proj = glm::ortho(-view_size, view_size, -view_size, view_size, view_near, view_far);          
+
+        // Save data to component
+        shad_comp.far_plane[i] = view_far;         
+        shad_comp.near_plane[i] = view_near;         
+        shad_comp.light_space_proj[i] = proj;         
+        shad_comp.light_space_view[i] = view;          
+
+        // Scale bounds exponentially for the next cascade tier
+        view_size *= 3.0f;     
+        view_far  *= 3.0f;        
+    }
+    GetEngine()->ShadowBufferManager()->UpdateDirectionalShadow(shad_comp.shadow_id, shad_comp);
+}
+
+
+void HydraDirectionalShadowSourceSystem::_InitialiseShadowMap(HydraID entity_id)
+{
+    HydraEngine *engine = GetEngine();
+    HydraECS *ecs = engine->ECS();
+    HydraTextureBufferManager *tex_man = engine->TextureBufferManager();
+    HydraDirectionalShadowSourceComponent &shad_comp = ecs->GetComponent<HydraDirectionalShadowSourceComponent>(entity_id);
+    HydraLightComponent &light_comp = ecs->GetComponent<HydraLightComponent>(entity_id);
+
+    shad_comp.entity_id = entity_id;   
+    
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+
+    uint32_t depth_texture_id = 0;
+    HydraID create_framebuffer_task_id = task_scheduler->CreateTask<HydraCreateCascadeShadowFrameBuffer>(HydraThreadAffinity::Render);
+    HydraCreateCascadeShadowFrameBuffer *fb_task = static_cast<HydraCreateCascadeShadowFrameBuffer *>(task_scheduler->GetTask(create_framebuffer_task_id));
+    fb_task->Initialise(&shad_comp.shadow_texture_id, &depth_texture_id, &shad_comp.frame_buffer_id);
+    
+    task_scheduler->WaitForTask(create_framebuffer_task_id);
+    shad_comp.shadow_texture_id = depth_texture_id;
+}
+

HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.h

@@ -0,0 +1,25 @@
+#ifndef HYDRADIRECTIONALSHADOWSOURCESYSTEM
+#define HYDRADIRECTIONALSHADOWSOURCESYSTEM
+#include "../../engine/HydraObject.h"
+#include "../HydraSystem.h"
+#include "../components/HydraDirectionalShadowSourceComponent.h"
+#include <GLMIncludes.h>
+#include <queue>
+#include <vector>
+#include <mutex>
+
+class HydraDirectionalShadowSourceSystem : public HydraSystem
+{
+    public:        
+        virtual void Initialise() override;
+    protected: 
+        void InitialiseComponent(HydraID entity_id) override;
+        void UpdateSystem(float delta_t_seconds) override;
+    private:
+        void _UpdateShadowMap(HydraID entity_id);
+        void _InitialiseShadowMap(HydraID entity_id);
+        std::mutex m_mutex;
+
+};
+
+#endif /* HYDRASHADOWCASTERSYSTEM */

HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.cpp

@@ -0,0 +1,116 @@
+#include "HydraSpotShadowSourceSystem.h"
+#include "../../engine/HydraEngine.h"
+#include "../../camera/HydraCamera.h"
+#include "../HydraECS.h"
+#include "../components/HydraDirectionalShadowSourceComponent.h"
+#include "../components/HydraPositionComponent.h"
+#include "../components/HydraLightComponent.h"
+
+#include "../../buffer/HydraShadowBuffer.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+#include "../../buffer/HydraShadowBufferManager.h"
+
+#include "../../scheduler/HydraTaskScheduler.h"
+#include "../../task/buffer/HydraCreateGPUBufferTask.hpp"
+#include "../../task/buffer/HydraUpdateWholeGPUBufferTask.hpp"
+#include "../../task/buffer/HydraUpdatePartialGPUBufferTask.hpp"
+#include "../../task/buffer/HydraCreateUnBoundTextureTask.hpp"
+
+#include "../../task/renderer/HydraCreateCascadeShadowFrameBuffer.hpp"
+#include "../../task/renderer/HydraCreateShadowFrameBuffer.hpp"
+#include "../../actor/HydraActorManager.h"
+
+void HydraSpotShadowSourceSystem::Initialise()
+{
+
+}
+
+void HydraSpotShadowSourceSystem::InitialiseComponent(HydraID entity_id)
+{
+    HydraEngine *engine = GetEngine();
+    HydraECS *ecs = engine->ECS();
+    HydraLightComponent &light_comp = ecs->GetComponent<HydraLightComponent>(entity_id);
+
+    
+    HydraSpotShadowSourceComponent& shadow_comp = ecs->GetComponent<HydraSpotShadowSourceComponent>(entity_id);
+
+    HydraID shadow_id = GetEngine()->ShadowBufferManager()->AddSpotShadow(shadow_comp);
+    assert(shadow_id != INVALID_HYDRA_ID && "Add Spot Shadow - out of shadows!");
+
+    light_comp.shadow_map_id = shadow_id;
+    light_comp.shadow_caster = 1;
+    shadow_comp.shadow_id = shadow_id;
+    _InitialiseShadowMap(entity_id);
+
+}
+
+void HydraSpotShadowSourceSystem::UpdateSystem(float delta_t_seconds)
+{
+    HydraEngine *engine = GetEngine();
+    HydraECS *ecs = engine->ECS();
+    
+    for (HydraID entity_id : Entities)
+    {
+        _UpdateShadowMap(entity_id);
+    }
+
+}
+
+void HydraSpotShadowSourceSystem::_UpdateShadowMap(HydraID entity_id)
+{
+    HydraEngine *engine = GetEngine();
+    HydraECS *ecs = engine->ECS();
+    HydraPositionComponent pos_comp = ecs->GetComponent<HydraPositionComponent>(entity_id);
+    HydraSpotShadowSourceComponent &shad_comp = ecs->GetComponent<HydraSpotShadowSourceComponent>(entity_id);
+    HydraLightComponent light_comp = ecs->GetComponent<HydraLightComponent>(entity_id);
+
+    float view_size = 50.0f;
+    float view_near = 0.3f;
+    float view_far = 50.0f;
+
+    glm::mat4 light_rot = glm::eulerAngleXYZ(pos_comp.orientation.x, pos_comp.orientation.y, pos_comp.orientation.z);
+    glm::vec3 light_dir = glm::normalize(glm::vec3(light_rot * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f)));
+
+    glm::vec3 light_pos =  pos_comp.position;          
+    glm::vec3 target_pos = light_pos + light_dir;
+    glm::vec3 up_vector = glm::vec3(0.0f, 1.0f, 0.0f);
+
+    if (glm::abs(glm::dot(light_dir, up_vector)) > 0.99f) 
+    {
+        up_vector = glm::vec3(1.0f, 0.0f, 0.0f); // Prevent gimbal lock
+    }
+
+    glm::mat4 view = glm::lookAt(light_pos, target_pos, up_vector);         
+
+	float fovRad = glm::radians(55.0f);
+    glm::mat4 proj = glm::perspectiveFovRH<float>(fovRad, view_size, view_size, view_near, view_far);
+
+    // Save data to component
+    shad_comp.far_plane = view_far;                 
+    shad_comp.light_space_proj = proj;         
+    shad_comp.light_space_view = view;  
+    GetEngine()->ShadowBufferManager()->UpdateSpotShadow(shad_comp.shadow_id, shad_comp);
+}
+
+
+void HydraSpotShadowSourceSystem::_InitialiseShadowMap(HydraID entity_id)
+{
+    HydraEngine *engine = GetEngine();
+    HydraECS *ecs = engine->ECS();
+    HydraTextureBufferManager *tex_man = engine->TextureBufferManager();
+    HydraSpotShadowSourceComponent &shad_comp = ecs->GetComponent<HydraSpotShadowSourceComponent>(entity_id);
+    HydraLightComponent &light_comp = ecs->GetComponent<HydraLightComponent>(entity_id);
+
+    shad_comp.entity_id = entity_id;
+    
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+
+    uint32_t depth_texture_id = 0;
+    HydraID create_framebuffer_task_id = task_scheduler->CreateTask<HydraCreateShadowFrameBuffer>(HydraThreadAffinity::Render);
+    HydraCreateShadowFrameBuffer *fb_task = static_cast<HydraCreateShadowFrameBuffer *>(task_scheduler->GetTask(create_framebuffer_task_id));
+    fb_task->Initialise(&shad_comp.shadow_texture_id, &depth_texture_id, &shad_comp.frame_buffer_id);
+    
+    task_scheduler->WaitForTask(create_framebuffer_task_id);
+    shad_comp.shadow_texture_id = depth_texture_id;
+}
+

HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.h

@@ -0,0 +1,31 @@
+#ifndef HYDRASPOTSHADOWSOURCESYSTEM
+#define HYDRASPOTSHADOWSOURCESYSTEM
+
+
+#include "../../engine/HydraObject.h"
+#include "../HydraSystem.h"
+#include "../components/HydraSpotShadowSourceComponent.h"
+#include <GLMIncludes.h>
+#include <queue>
+#include <vector>
+#include <mutex>
+
+class HydraSpotShadowSourceSystem : public HydraSystem
+{
+    public:        
+        virtual void Initialise() override;
+    protected: 
+        void InitialiseComponent(HydraID entity_id) override;
+        void UpdateSystem(float delta_t_seconds) override;
+    private:
+        void _UpdateShadowMap(HydraID entity_id);
+        void _InitialiseShadowMap(HydraID entity_id);
+        
+        
+        
+        
+        std::mutex m_mutex;
+
+};
+
+#endif /* HYDRASPOTSHADOWSOURCESYSTEM */

HydraEngine/source/engine/HydraEngine.cpp

@@ -13,6 +13,7 @@
 #include "../buffer/HydraTextureBufferManager.h"
 #include "../buffer/HydraMaterialBufferManager.h"
 #include "../buffer/HydraLightBufferManager.h"
+#include "../buffer/HydraShadowBufferManager.h"
 
 #include "../ecs/HydraECS.h"
 #include "../ecs/systems/HydraTransformSystem.h"
@@ -20,6 +21,8 @@
 #include "../ecs/systems/HydraRenderSystem.h"
 #include "../ecs/systems/HydraMaterialSystem.h"
 #include "../ecs/systems/HydraLightSystem.h"
+#include "../ecs/systems/HydraDirectionalShadowSourceSystem.h"
+#include "../ecs/systems/HydraSpotShadowSourceSystem.h"
 
 #include "../ecs/components/HydraPositionComponent.h"
 #include "../ecs/components/HydraMeshComponent.h"
@@ -27,6 +30,8 @@
 #include "../ecs/components/HydraTextureComponent.h"
 #include "../ecs/components/HydraMaterialComponent.h"
 #include "../ecs/components/HydraLightComponent.h"
+#include "../ecs/components/HydraDirectionalShadowSourceComponent.h"
+#include "../ecs/components/HydraSpotShadowSourceComponent.h"
 
 
 #include "../camera/HydraCamera.h"
@@ -35,6 +40,7 @@
 #include "../pipeline/HydraPipeline.h"
 #include "../pipeline/HydraForwardPipeline.h"
 #include "../pipeline/HydraDeferredPipeline.h"
+#include "../pipeline/HydraShadowPipeline.h"
 
 #include "../task/windowmanager/HydraInitialiseWindowManagerTask.hpp"
 #include "../task/windowmanager/HydraShutdownWindowManagerTask.hpp"
@@ -49,8 +55,11 @@
 #include "../task/ecs/HydraInitialiseComponentsTask.hpp"
 #include "../task/buffer/HydraShutdownBufferManagerTask.hpp"
 #include "../task/buffer/HydraInitialiseTextureManagerTask.hpp"
+#include "../task/buffer/HydraInitialiseShadowBufferTask.hpp"
 #include "../task/actor/HydraUpdatePlayerTask.h"
 
+#include "../task/renderer/HydraEndRenderTask.hpp"
+
 #include "../mesh/HydraMeshManager.h"
 HydraTaskScheduler *const HydraEngine::TaskScheduler()
 {
@@ -142,6 +151,11 @@ HydraLightBufferManager *const HydraEngine::LightBufferManager()
     return m_light_buffer_manager;
 }
 
+HydraShadowBufferManager *const HydraEngine::ShadowBufferManager()
+{
+    return m_shadow_buffer_manager;
+}
+
 void HydraEngine::PossessPlayer(HydraID actor_id)
 {
     m_possessed_actor_id = actor_id;
@@ -176,9 +190,11 @@ void HydraEngine::_CreateManagers()
     m_mesh_manager = new HydraMeshManager();
     m_pipeline = new HydraForwardPipeline();
     m_deferred_pipeline = new HydraDeferredPipeline();
+    m_shadow_pipeline = new HydraShadowPipeline();
     m_texture_buffer_manager = new HydraTextureBufferManager();
     m_material_buffer_manager = new HydraMaterialBufferManager();
     m_light_buffer_manager = new HydraLightBufferManager();
+    m_shadow_buffer_manager = new HydraShadowBufferManager();
 }
 
 void HydraEngine::_InitialiseManagers()
@@ -200,6 +216,9 @@ void HydraEngine::_InitialiseManagers()
     m_material_buffer_manager->Intialise();
     m_light_buffer_manager->Initialise();
 
+    HydraID create_shadow_buffer_task_id = m_task_scheduler->CreateTask<HydraInitialiseShadowBufferTask>(HydraThreadAffinity::Render);
+    m_task_scheduler->WaitForTask(create_shadow_buffer_task_id);
+
 }
 
 void HydraEngine::_InitialiseSystems()
@@ -210,30 +229,49 @@ void HydraEngine::_InitialiseSystems()
     m_ecs->RegisterComponentType<HydraTextureComponent>();
     m_ecs->RegisterComponentType<HydraMaterialComponent>();
     m_ecs->RegisterComponentType<HydraLightComponent>();
+    m_ecs->RegisterComponentType<HydraDirectionalShadowSourceComponent>();
+    m_ecs->RegisterComponentType<HydraSpotShadowSourceComponent>();
 
     m_mesh_system = m_ecs->RegisterSystem<HydraMeshSystem>();
     m_transform_system = m_ecs->RegisterSystem<HydraTransformSystem>();
     m_render_system = m_ecs->RegisterSystem<HydraRenderSystem>();
     m_material_system = m_ecs->RegisterSystem<HydraMaterialSystem>();
     m_light_system = m_ecs->RegisterSystem<HydraLightSystem>();
+    m_directional_shadow_system = m_ecs->RegisterSystem<HydraDirectionalShadowSourceSystem>();
+    m_spot_shadow_system = m_ecs->RegisterSystem<HydraSpotShadowSourceSystem>();
 
     HydraSignature mesh_sig;
     HydraSignature trans_sig;
     HydraSignature render_sig;
     HydraSignature material_sig;
     HydraSignature light_sig;
+    HydraSignature directional_shadow_sig;
+    HydraSignature spot_shadow_sig;
 
     mesh_sig.set(m_ecs->GetComponentType<HydraMeshComponent>(),true);
     trans_sig.set(m_ecs->GetComponentType<HydraPositionComponent>(),true);
     render_sig.set(m_ecs->GetComponentType<HydraRenderableComponent>(),true);
     material_sig.set(m_ecs->GetComponentType<HydraMaterialComponent>(),true);
+    
     light_sig.set(m_ecs->GetComponentType<HydraLightComponent>(), true);
+    light_sig.set(m_ecs->GetComponentType<HydraPositionComponent>(), true);
+        
+    directional_shadow_sig.set(m_ecs->GetComponentType<HydraLightComponent>(), true);
+    directional_shadow_sig.set(m_ecs->GetComponentType<HydraPositionComponent>(), true);
+    directional_shadow_sig.set(m_ecs->GetComponentType<HydraDirectionalShadowSourceComponent>(), true);
+
+    spot_shadow_sig.set(m_ecs->GetComponentType<HydraLightComponent>(), true);
+    spot_shadow_sig.set(m_ecs->GetComponentType<HydraPositionComponent>(), true);
+    spot_shadow_sig.set(m_ecs->GetComponentType<HydraSpotShadowSourceComponent>(), true);
 
     m_ecs->SetSystemSignature<HydraMeshSystem>(mesh_sig);
     m_ecs->SetSystemSignature<HydraTransformSystem>(trans_sig);
     m_ecs->SetSystemSignature<HydraRenderSystem>(render_sig);
     m_ecs->SetSystemSignature<HydraMaterialSystem>(material_sig);
     m_ecs->SetSystemSignature<HydraLightSystem>(light_sig);
+    m_ecs->SetSystemSignature<HydraDirectionalShadowSourceSystem>(directional_shadow_sig);
+    m_ecs->SetSystemSignature<HydraSpotShadowSourceSystem>(spot_shadow_sig);
+
 }
 
  void HydraEngine::_UpdateSystems()
@@ -250,13 +288,29 @@ void HydraEngine::_InitialiseSystems()
 
     m_task_scheduler->StartTask(update_trans_id);   
     m_task_scheduler->StartTask(update_mat_id);   
-
     m_task_scheduler->WaitForBarrier(posUpdateBarrierID);
 
     HydraID update_light_id = m_task_scheduler->CreateTask<HydraUpdateSystemTask>(HydraThreadAffinity::General);
     HydraUpdateSystemTask* update_light_task = static_cast<HydraUpdateSystemTask*>(m_task_scheduler->GetTask(update_light_id));    
     update_light_task->Initialise(m_delta_t, m_light_system);
     m_task_scheduler->WaitForTask(update_light_id);
+
+    HydraID shadow_barrier = m_task_scheduler->CreateBarrier();
+
+    HydraID update_shadow_id = m_task_scheduler->CreateTask<HydraUpdateSystemTask>(HydraThreadAffinity::General, shadow_barrier);
+    HydraUpdateSystemTask* update_shadow_task = static_cast<HydraUpdateSystemTask*>(m_task_scheduler->GetTask(update_shadow_id));    
+    update_shadow_task->Initialise(m_delta_t, m_directional_shadow_system);
+    
+
+    HydraID update_spot_shadow_id = m_task_scheduler->CreateTask<HydraUpdateSystemTask>(HydraThreadAffinity::General, shadow_barrier);
+    HydraUpdateSystemTask* update_spot_shadow_task = static_cast<HydraUpdateSystemTask*>(m_task_scheduler->GetTask(update_spot_shadow_id));    
+    update_spot_shadow_task->Initialise(m_delta_t, m_spot_shadow_system);
+    
+    m_task_scheduler->StartTask(update_shadow_id);
+    m_task_scheduler->StartTask(update_spot_shadow_id);
+    m_task_scheduler->WaitForBarrier(shadow_barrier);
+
+    m_shadow_buffer_manager->UpdateShadowBuffer();
 }
 
 void HydraEngine::_GameLoop()
@@ -285,6 +339,11 @@ void HydraEngine::_GameLoop()
     pipeline_task->Initialise(m_pipeline);
     m_task_scheduler->WaitForTask(initialise_pipeline_task_id);
 
+    HydraID initialise_shadow_pipeline_task_id = m_task_scheduler->CreateTask<HydraInitialisePipelineTask>(HydraThreadAffinity::Render);
+    HydraInitialisePipelineTask *pipeline_shadow_task = static_cast<HydraInitialisePipelineTask*>(m_task_scheduler->GetTask(initialise_shadow_pipeline_task_id));
+    pipeline_shadow_task->Initialise(m_shadow_pipeline);
+    m_task_scheduler->WaitForTask(initialise_shadow_pipeline_task_id);
+
     HydraID initialise_def_pipeline_task_id = m_task_scheduler->CreateTask<HydraInitialisePipelineTask>(HydraThreadAffinity::Render);
     HydraInitialisePipelineTask *pipeline_def_task = static_cast<HydraInitialisePipelineTask*>(m_task_scheduler->GetTask(initialise_def_pipeline_task_id));
     pipeline_def_task->Initialise(m_deferred_pipeline);
@@ -333,15 +392,20 @@ void HydraEngine::_GameLoop()
         
         _UpdateSystems();
 
-        // HydraID render_task_id = m_task_scheduler->CreateTask<HydraRenderPipelineTask>(HydraThreadAffinity::Render);
-        // HydraRenderPipelineTask* render_task = static_cast<HydraRenderPipelineTask*>(m_task_scheduler->GetTask(render_task_id));
-        // render_task->Initialise(m_pipeline);
-        // m_task_scheduler->WaitForTask(render_task_id);
+        
+
+        HydraID render_shadow_task_id = m_task_scheduler->CreateTask<HydraRenderPipelineTask>(HydraThreadAffinity::Render);
+        HydraRenderPipelineTask* render_shadow_task = static_cast<HydraRenderPipelineTask*>(m_task_scheduler->GetTask(render_shadow_task_id));
+        render_shadow_task->Initialise(m_shadow_pipeline);
+        m_task_scheduler->WaitForTask(render_shadow_task_id);
 
         HydraID render_def_task_id = m_task_scheduler->CreateTask<HydraRenderPipelineTask>(HydraThreadAffinity::Render);
         HydraRenderPipelineTask* render_def_task = static_cast<HydraRenderPipelineTask*>(m_task_scheduler->GetTask(render_def_task_id));
         render_def_task->Initialise(m_deferred_pipeline);
         m_task_scheduler->WaitForTask(render_def_task_id);
+
+        HydraID end_task_id = m_task_scheduler->CreateTask<HydraEndRenderTask>(HydraThreadAffinity::Render);
+        m_task_scheduler->WaitForTask(end_task_id);
     }
 }
 

HydraEngine/source/engine/HydraEngine.h

@@ -25,6 +25,9 @@ class HydraTextureBufferManager;
 class HydraMaterialBufferManager;
 class HydraLightBufferManager;
 class HydraLightSystem;
+class HydraDirectionalShadowSourceSystem;
+class HydraSpotShadowSourceSystem;
+class HydraShadowBufferManager;
 
 class CLASS_DEFINE HydraEngine : public HydraObject
 {
@@ -56,6 +59,7 @@ public:
     HydraTextureBufferManager* const TextureBufferManager();
     HydraMaterialBufferManager* const MaterialBufferManager();
     HydraLightBufferManager* const LightBufferManager();
+    HydraShadowBufferManager* const ShadowBufferManager();
     void PossessPlayer(HydraID actor_id);
     HydraID GetPossessedPlayer();
     float GetDeltaT();
@@ -82,15 +86,19 @@ private:
     HydraRenderSettings m_render_settings;
     HydraPipeline* m_pipeline = nullptr;
     HydraPipeline* m_deferred_pipeline = nullptr;
+    HydraPipeline* m_shadow_pipeline = nullptr;
     HydraTextureBufferManager* m_texture_buffer_manager = nullptr;
     HydraMaterialBufferManager* m_material_buffer_manager = nullptr;
     HydraLightBufferManager* m_light_buffer_manager = nullptr;
-
+    HydraShadowBufferManager* m_shadow_buffer_manager = nullptr;
     std::shared_ptr<HydraMeshSystem> m_mesh_system;
     std::shared_ptr<HydraTransformSystem> m_transform_system;
     std::shared_ptr<HydraRenderSystem> m_render_system;
     std::shared_ptr<HydraMaterialSystem> m_material_system;
     std::shared_ptr<HydraLightSystem> m_light_system;
+    std::shared_ptr<HydraDirectionalShadowSourceSystem> m_directional_shadow_system;
+    std::shared_ptr<HydraSpotShadowSourceSystem> m_spot_shadow_system;
+    
 
     bool m_running = true;
     float m_delta_t = 0.0f;

HydraEngine/source/fileaccess/HydraGLTFLoader.cpp

@@ -280,17 +280,17 @@ void HydraGLTFLoader::_ProcessGLTFTextures(aiScene const *scene, std::vector<uin
         //stbi_set_flip_vertically_on_load(1);
         stbi_uc* data = stbi_load_from_memory(reinterpret_cast<stbi_uc*>(tex->pcData), tex->mWidth, &width, &height, &channels, 4);
         
-        HydraID texture_id = texture_manager->CreateTexture(texture_name, 
+        HydraID texture_id = texture_manager->CreateTexture(texture_name,
             width, 
             height, 
             GL_RGBA8, 
             GL_LINEAR_MIPMAP_LINEAR,
-            GL_LINEAR,
+            GL_LINEAR,            
             GL_RGBA,
             GL_UNSIGNED_BYTE,
             5, 
             data);
-        texture_manager->BindTexture(texture_id);
+        texture_manager->BindTexture(texture_id, GL_TEXTURE_2D);
         // store the texture id against the scene index for the texture. Materials will have *n where n is the index
         texture_lookup[i_tex] = texture_id;
     }

HydraEngine/source/pipeline/HydraDeferredPipeline.cpp

@@ -5,14 +5,20 @@
 #include "../buffer/HydraTextureBufferManager.h"
 #include "../buffer/HydraLightBufferManager.h"
 #include "PerFrameUBO.hpp"
+#include "TextureDebugUBO.hpp"
 
 #include "../camera/HydraCamera.h"
 #include "../renderer/HydraRenderer.h"
 #include "../ecs/HydraECS.h"
 #include "../ecs/systems/HydraRenderSystem.h"
+#include "../ecs/systems/HydraDirectionalShadowSourceSystem.h"
+#include "../ecs/components/HydraDirectionalShadowSourceComponent.h"
+#include "../ecs/systems/HydraSpotShadowSourceSystem.h"
+#include "../ecs/components/HydraSpotShadowSourceComponent.h"
 #include "../mesh/StandardVertex.h"
 #include "../actor/HydraActorManager.h"
 #include "../actor/HydraOutputActor.h"
+#include "../actor/HydraTextureDebugActor.h"
 
 void HydraDeferredPipeline::Initialise()
 {
@@ -22,7 +28,8 @@ void HydraDeferredPipeline::Initialise()
     _CreateOutputActor();
     _CreateFrameBuffer();
     _CreateColourRenderStage();
-    _CreateOutputRenderStage();    
+    _CreateOutputRenderStage(); 
+    _CreateTextureDebugOutputStage();   
 }
 
 void HydraDeferredPipeline::Shutdown()
@@ -38,23 +45,33 @@ void HydraDeferredPipeline::Shutdown()
 void HydraDeferredPipeline::Render()
 {
     _UpdateUBO();
-    
-    glBindFramebuffer(GL_FRAMEBUFFER, m_frame_buffer_id);
-    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // we're not using the stencil buffer now
-    glEnable(GL_DEPTH_TEST);
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
     HydraECS* ecs = GetEngine()->ECS();
     std::shared_ptr<HydraRenderSystem> render_system = ecs->GetSystem<HydraRenderSystem>();
     
-    GetEngine()->Renderer()->BeginFrame();
+    HydraRenderSettings render_settings = GetEngine()->RenderSettings();
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  
+
+    glViewport(0, 0, render_settings.ViewportWidth, render_settings.ViewportHeight);
     
+    float clear_colour[4] = {0, 0, 0, 0};
+    float depth_value = 1;
+    
+    glClearNamedFramebufferfv(m_frame_buffer_id, GL_COLOR, 0, clear_colour);
+    glClearNamedFramebufferfv(m_frame_buffer_id, GL_COLOR, 1, clear_colour);
+    glClearNamedFramebufferfv(m_frame_buffer_id, GL_COLOR, 2, clear_colour);
+    glClearNamedFramebufferfv(m_frame_buffer_id, GL_COLOR, 3, clear_colour);
+    glClearNamedFramebufferfv(m_frame_buffer_id, GL_DEPTH, 0, &depth_value);
+
+    float screen_colour[4] = {0.0f, 0.5f, 0.7f, 1.0f};
+    glClearNamedFramebufferfv(0, GL_COLOR, 0, screen_colour);
+    glClearNamedFramebufferfv(0, GL_DEPTH, 0, &depth_value);
+
     for(uint32_t rs_idx = 0; rs_idx <m_render_stages.size(); rs_idx++)
     {
         m_render_stages[rs_idx]->Render(render_system->Entities);
-    }
-    GetEngine()->Renderer()->EndFrame();
+    }    
 }
 
 void HydraDeferredPipeline::_UpdateUBO()
@@ -79,6 +96,21 @@ void HydraDeferredPipeline::_UpdateUBO()
     output_ubo.light_count = light_count;
     buffer_manager->UpdateWholeBuffer(m_per_frame_output_ubo, &output_ubo);
     glBindBuffer(GL_UNIFORM_BUFFER, m_per_frame_output_ubo);
+
+    std::shared_ptr<HydraSpotShadowSourceSystem> sys = GetEngine()->ECS()->GetSystem<HydraSpotShadowSourceSystem>();
+    HydraID texture_id = 0;
+    if(sys->Entities.size() > 0)
+    {
+        auto it = sys->Entities.begin();
+        HydraSpotShadowSourceComponent shad_comp = GetEngine()->ECS()->GetComponent<HydraSpotShadowSourceComponent>(*it);
+        texture_id = shad_comp.shadow_texture_id;
+    }
+    TextureDebugUBO texture_ubo = {};
+    texture_ubo.view = glm::translate(glm::vec3(1,1,0));
+    texture_ubo.proj = glm::ortho(-2.0f, 2.0f, -2.0f, 2.0f);   
+    texture_ubo.shadow_idx = texture_id;
+    buffer_manager->UpdateWholeBuffer(m_texture_debug_ubo, &texture_ubo);
+    glBindBuffer(GL_UNIFORM_BUFFER, m_texture_debug_ubo);
 }
 
 void HydraDeferredPipeline::_CreateFrameBuffer()
@@ -127,12 +159,11 @@ void HydraDeferredPipeline::_CreateFrameBuffer()
     glDrawBuffers(4, draw_buffers);
     glBindTexture(GL_TEXTURE_2D, 0);
 
-    tex_buffer_manager->BindTexture(depth_texture.texture_id);
-    tex_buffer_manager->BindTexture(buffer_0_texture.texture_id);
-    tex_buffer_manager->BindTexture(metal_rough_texture.texture_id);
-    tex_buffer_manager->BindTexture(normal_texture.texture_id);
-    tex_buffer_manager->BindTexture(position_texture.texture_id);
-
+    tex_buffer_manager->BindTexture(depth_texture.texture_id, GL_TEXTURE_2D);
+    tex_buffer_manager->BindTexture(buffer_0_texture.texture_id, GL_TEXTURE_2D);
+    tex_buffer_manager->BindTexture(metal_rough_texture.texture_id, GL_TEXTURE_2D);
+    tex_buffer_manager->BindTexture(normal_texture.texture_id, GL_TEXTURE_2D);
+    tex_buffer_manager->BindTexture(position_texture.texture_id, GL_TEXTURE_2D);
 
     HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
     buffer_manager->UpdateWholeBuffer(m_output_texture_ubo, &actor->texture_buffers[0]);
@@ -152,17 +183,17 @@ void HydraDeferredPipeline::_CreateColourRenderStage()
 
     HydraShaderBinding shader_binding = {};
     
-    shader_binding.block_name.push_back("PositionsBuffer");
+    shader_binding.block_name.push_back("positions_buffer");
     shader_binding.binding_point.push_back(1);
     shader_binding.buffer_id.push_back(pos_buffer_id);
     shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
 
-    shader_binding.block_name.push_back("MaterialBuffer");
+    shader_binding.block_name.push_back("material_buffer");
     shader_binding.binding_point.push_back(2);
     shader_binding.buffer_id.push_back(mat_buffer_id);
     shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
 
-    shader_binding.block_name.push_back("TextureBuffer");
+    shader_binding.block_name.push_back("texture_buffer");
     shader_binding.binding_point.push_back(3);
     shader_binding.buffer_id.push_back(tex_buffer_id);
     shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
@@ -173,14 +204,14 @@ void HydraDeferredPipeline::_CreateColourRenderStage()
     shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
     std::vector<uint32_t> textures;
 
-
-
     render_stage->Initialise(shader_path + "deferred_shader.vert", 
-        shader_path + "deferred_shader.frag", 
+        shader_path + "deferred_shader.frag", "",
         shader_binding, 
         m_frame_buffer_id,
         textures,
         true,
+        GL_BACK,
+        true,
         HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR);
     m_render_stages.push_back(render_stage);
 }
@@ -204,15 +235,16 @@ void HydraDeferredPipeline::_CreateOutputRenderStage()
     HydraID tex_buffer_id = buffer_manager->FindBuffer("TextureBuffer");
     HydraID output_texture_buffer_id = buffer_manager->FindBuffer("DeferredOutputTextureUBO");
     HydraID light_buffer_id = buffer_manager->FindBuffer("LightBuffer");
+    HydraID directional_shadow_buffer_id = buffer_manager->FindBuffer("DirectionalShadowBuffer");
+    HydraID spot_shadow_buffer_id = buffer_manager->FindBuffer("SpotShadowBuffer");
 
     HydraShaderBinding shader_binding = {};
-    shader_binding.block_name.push_back("PositionsBuffer");
+    shader_binding.block_name.push_back("position_buffer");
     shader_binding.binding_point.push_back(1);
     shader_binding.buffer_id.push_back(pos_buffer_id);
     shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
 
-
-    shader_binding.block_name.push_back("TextureBuffer");
+    shader_binding.block_name.push_back("texture_buffer");
     shader_binding.binding_point.push_back(3);
     shader_binding.buffer_id.push_back(tex_buffer_id);
     shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
@@ -227,29 +259,87 @@ void HydraDeferredPipeline::_CreateOutputRenderStage()
     shader_binding.buffer_id.push_back(output_texture_buffer_id);
     shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
 
-    shader_binding.block_name.push_back("LightBuffer");
+    shader_binding.block_name.push_back("light_buffer");
     shader_binding.binding_point.push_back(4);
     shader_binding.buffer_id.push_back(light_buffer_id);
     shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
 
+    shader_binding.block_name.push_back("directional_shadow_buffer");
+    shader_binding.binding_point.push_back(5);
+    shader_binding.buffer_id.push_back(directional_shadow_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
     
+    shader_binding.block_name.push_back("spot_shadow_buffer");
+    shader_binding.binding_point.push_back(6);
+    shader_binding.buffer_id.push_back(spot_shadow_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
     render_stage->Initialise(shader_path + "deferred_output_shader.vert", 
-        shader_path + "deferred_output_shader.frag", 
+        shader_path + "deferred_output_shader.frag", "",
         shader_binding, 
         0,
         textures,
         false,     
+        GL_BACK,
+        true,
         HYDRA_RENDERABLE_TYPE::HYDRA_OUTPUT);
     m_render_stages.push_back(render_stage);
 }
 
+void HydraDeferredPipeline::_CreateTextureDebugOutputStage()
+{
+     HydraRenderStage* render_stage = new HydraRenderStage();
+    std::string shader_path = std::string(shader_base);
+    HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
+
+    std::vector<uint32_t> textures;
+
+    GetEngine()->ActorManager()->InitialiseActor(m_output_actor_id);
+    HydraOutputActor* actor = static_cast<HydraOutputActor*>(GetEngine()->ActorManager()->GetActor(m_output_actor_id));
+
+    HydraTextureBufferManager* tex_buf_manager = GetEngine()->TextureBufferManager();
+
+    HydraID pos_buffer_id = buffer_manager->FindBuffer("PositionsBuffer");
+    HydraID tex_buffer_id = buffer_manager->FindBuffer("TextureBuffer");
+    HydraID texture_debug_ubo = buffer_manager->FindBuffer("TextureDebugUBO");
+    
+    HydraShaderBinding shader_binding = {};
+    shader_binding.block_name.push_back("position_buffer");
+    shader_binding.binding_point.push_back(1);
+    shader_binding.buffer_id.push_back(pos_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("texture_buffer");
+    shader_binding.binding_point.push_back(3);
+    shader_binding.buffer_id.push_back(tex_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("uniform_per_frame");
+    shader_binding.binding_point.push_back(0);
+    shader_binding.buffer_id.push_back(texture_debug_ubo);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+
+    render_stage->Initialise(shader_path + "texture_debug_shader.vert", 
+        shader_path + "texture_debug_shader.frag", "",
+        shader_binding,
+        0,
+        textures,
+        false,     
+        GL_BACK,
+        false,
+        HYDRA_RENDERABLE_TYPE::HYDRA_TEXTURE_DEBUG);
+    m_render_stages.push_back(render_stage);
+}
+
 void HydraDeferredPipeline::_CreateOutputActor()
 {
     m_output_actor_id = GetEngine()->ActorManager()->CreateActor<HydraOutputActor>();
     GetEngine()->ActorManager()->InitialiseActor(m_output_actor_id);
     HydraOutputActor* actor = static_cast<HydraOutputActor*>(GetEngine()->ActorManager()->GetActor(m_output_actor_id));
 
-
+    m_texture_debug_actor_id = GetEngine()->ActorManager()->CreateActor<HydraTextureDebugActor>();
+    GetEngine()->ActorManager()->InitialiseActor(m_texture_debug_actor_id);
+    HydraTextureDebugActor* tex_actor = static_cast<HydraTextureDebugActor*>(GetEngine()->ActorManager()->GetActor(m_texture_debug_actor_id));
 }
 
 void HydraDeferredPipeline::_CreateUBOs()
@@ -265,6 +355,7 @@ void HydraDeferredPipeline::_CreateUBOs()
     m_output_texture_ubo = buffer_manager->CreateGPUBuffer("DeferredOutputTextureUBO", 
     sizeof(uint32_t)*16, 0, HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
 
-
+    m_texture_debug_ubo = buffer_manager->CreateGPUBuffer("TextureDebugUBO", 
+    sizeof(TextureDebugUBO), 0, HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
 }
 

HydraEngine/source/pipeline/HydraDeferredPipeline.h

@@ -24,9 +24,10 @@ class HydraDeferredPipeline : public HydraPipeline
         HydraID m_buffer_0 = INVALID_HYDRA_ID; //Frame buffer 0;
         HydraID m_depth = INVALID_HYDRA_ID;
         HydraID m_output_actor_id = INVALID_HYDRA_ID;
+        HydraID m_texture_debug_actor_id = INVALID_HYDRA_ID;
         HydraID m_output_texture_ubo = INVALID_HYDRA_ID;
         HydraID m_output_light_ubo = INVALID_HYDRA_ID;
-
+        HydraID m_texture_debug_ubo = INVALID_HYDRA_ID;
         uint32_t m_frame_buffer_id;
 
         void _UpdateUBO();
@@ -35,6 +36,7 @@ class HydraDeferredPipeline : public HydraPipeline
         void _CreateColourRenderStage();
         void _CreateOutputRenderStage();
         void _CreateOutputActor();
+        void _CreateTextureDebugOutputStage();
         void _CreateUBOs();
 };
 

HydraEngine/source/pipeline/HydraForwardPipeline.cpp

@@ -36,14 +36,11 @@ void HydraForwardPipeline::Initialise()
     std::vector<uint32_t> textures;
     std::vector<uint32_t> rb_attachments;
     
-    
-    
-    render_stage->Initialise(shader_path + "forward_shader.vert", shader_path + "forward_shader.frag", shader_binding, 0, textures, true, HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR);
+    render_stage->Initialise(shader_path + "forward_shader.vert", shader_path + "forward_shader.frag", "", shader_binding, 0, textures, true, GL_BACK, true, HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR);
     m_render_stages.push_back(render_stage);
 
-
     m_per_frame_ubo = buffer_manager->CreateGPUBuffer("PerFrameUBO", 
-        sizeof(PerFrameUBO), 0, HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+    sizeof(PerFrameUBO), 0, HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
     
 }
 
@@ -63,13 +60,16 @@ void HydraForwardPipeline::Render()
     HydraECS* ecs = GetEngine()->ECS();
     std::shared_ptr<HydraRenderSystem> render_system = ecs->GetSystem<HydraRenderSystem>();
     
-    GetEngine()->Renderer()->BeginFrame();
+    float depth_value = 1;
+    float screen_colour[4] = {0, 0.2, 0.7, 1};
+    
+    glClearNamedFramebufferfv(0, GL_COLOR, 0, screen_colour);
+    glClearNamedFramebufferfv(0, GL_DEPTH, 0, &depth_value);
     
     for(uint32_t rs_idx = 0; rs_idx <m_render_stages.size(); rs_idx++)
     {
         m_render_stages[rs_idx]->Render(render_system->Entities);
     }
-    GetEngine()->Renderer()->EndFrame();
 }
 
 void HydraForwardPipeline::_UpdateUBO()

HydraEngine/source/pipeline/HydraRenderStage.cpp

@@ -14,32 +14,58 @@
 
 void HydraRenderStage::Initialise(std::string vertex_shader_file, 
     std::string fragment_shader_file, 
+    std::string geometry_shader_file, 
     HydraShaderBinding shader_binding,
     uint32_t framebuffer_id,
     std::vector<uint32_t> textures, 
-    bool enable_culling,   
+    bool enable_culling,
+    uint32_t cull_face,
+    bool depth_enable,   
     HYDRA_RENDERABLE_TYPE renderable_type)
 {
     m_framebuffer_id = framebuffer_id;
     m_renderable_type = static_cast<uint32_t>(renderable_type);
     m_shader_binding = shader_binding;
     m_textures = textures;
+    m_depth_enable = depth_enable;
     m_cull = enable_culling;
-
+    m_program = glCreateProgram();
+    m_cull_face = cull_face;
     if(vertex_shader_file.length() > 0)
     {
         m_vertex_shader = _LoadShader(vertex_shader_file, GL_VERTEX_SHADER);        
+        glAttachShader(m_program, m_vertex_shader);
     }
     if(fragment_shader_file.length() > 0)
     {
         m_fragment_shader = _LoadShader(fragment_shader_file, GL_FRAGMENT_SHADER);
+        glAttachShader(m_program, m_fragment_shader);
+    }
+    if(geometry_shader_file.length() > 0)
+    {
+        m_geometry_shader = _LoadShader(geometry_shader_file, GL_GEOMETRY_SHADER);
+        glAttachShader(m_program, m_geometry_shader);
     }
-    m_program = glCreateProgram();
-    glAttachShader(m_program, m_vertex_shader);
-    glAttachShader(m_program, m_fragment_shader);
     glLinkProgram(m_program);
 
+    int success;
+glGetProgramiv(m_program, GL_LINK_STATUS, &success);
+
+if (!success) {
+    // 2. Get the log length (optional but recommended)
+    int logLength;
+    glGetProgramiv(m_program, GL_INFO_LOG_LENGTH, &logLength);
     
+    // 3. Retrieve and print the error log
+    char* infoLog = new char[logLength];
+    glGetProgramInfoLog(m_program, logLength, NULL, infoLog);
+    
+    std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
+    
+    // 4. Clean up allocated memory
+    delete[] infoLog;
+}
+
 }
 
 void HydraRenderStage::ShutDown()
@@ -49,11 +75,13 @@ void HydraRenderStage::ShutDown()
     glDeleteProgram(m_program);
 }
 
-void HydraRenderStage::Render(std::set<HydraID>& entities)
+void HydraRenderStage::Render(std::set<HydraID>& entities, uint32_t framebuffer_id)
 {
     HydraECS* ecs = GetEngine()->ECS();
-
-    glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_id);
+    if(framebuffer_id != INVALID_HYDRA_ID)
+    {
+        glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id);
+    }
     //glDrawBuffers(m_rb_attachments.size(), &m_rb_attachments[0]);
     HydraVertexBufferManager* vert_buffer_mananger = GetEngine()->VertexBufferManager();
     glUseProgram(m_program);
@@ -65,12 +93,22 @@ void HydraRenderStage::Render(std::set<HydraID>& entities)
     if(m_cull)
     {
         glEnable(GL_CULL_FACE);
+        glCullFace(m_cull_face);
     }
     else
     {
         glDisable(GL_CULL_FACE);
     }
 
+    if(m_depth_enable)
+    {
+        glEnable(GL_DEPTH_TEST);
+    }
+    else
+    {   
+        glDisable(GL_DEPTH_TEST);
+    }
+
     for(const auto& entity_id : entities )
     {
         HydraRenderableComponent render_comp = ecs->GetComponent<HydraRenderableComponent>(entity_id);
@@ -88,6 +126,11 @@ void HydraRenderStage::Render(std::set<HydraID>& entities)
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
+void HydraRenderStage::Render(std::set<HydraID> &entities)
+{
+    Render(entities, m_framebuffer_id);
+}
+
 uint32_t HydraRenderStage::_LoadShader(std::string filename, uint32_t shader_type)
 { 
 

HydraEngine/source/pipeline/HydraRenderStage.h

@@ -12,12 +12,16 @@ class HydraRenderStage : public HydraObject
     public:        
         void Initialise(std::string vertex_shader_file, 
             std::string fragment_shader_file, 
+            std::string geometry_shader_file, 
             HydraShaderBinding shader_binding, 
             uint32_t framebuffer_id,
             std::vector<uint32_t> textures,
             bool enable_culling,
+            uint32_t cull_face,
+            bool depth_enable,
             HYDRA_RENDERABLE_TYPE renderable_type);
         void ShutDown();
+        void Render(std::set<HydraID>& entities, uint32_t framebuffer_id);
         void Render(std::set<HydraID>& entities);
     private:
         uint32_t _LoadShader(std::string filename, uint32_t shader_type);
@@ -27,10 +31,13 @@ class HydraRenderStage : public HydraObject
         HydraShaderBinding m_shader_binding;
         uint32_t m_vertex_shader = GL_INVALID_VALUE;
         uint32_t m_fragment_shader = GL_INVALID_VALUE;
+        uint32_t m_geometry_shader = GL_INVALID_VALUE;
         uint32_t m_program = GL_INVALID_VALUE;
         uint32_t m_renderable_type;
         uint32_t m_framebuffer_id = 0;
+        uint32_t m_cull_face = GL_NONE;
         bool m_cull = false;
+        bool m_depth_enable = true;
         std::vector<uint32_t> m_textures;
         
 };

HydraEngine/source/pipeline/HydraShadowPipeline.cpp

@@ -0,0 +1,222 @@
+#include "HydraShadowPipeline.h"
+
+#include "HydraRenderStage.h"
+#include "../engine/HydraEngine.h"
+#include "../buffer/HydraBufferManager.h"
+#include "../buffer/HydraTextureBufferManager.h"
+#include "../buffer/HydraLightBufferManager.h"
+#include "PerFrameUBO.hpp"
+
+#include "../camera/HydraCamera.h"
+#include "../renderer/HydraRenderer.h"
+#include "../ecs/HydraECS.h"
+#include "../ecs/systems/HydraRenderSystem.h"
+#include "../ecs/systems/HydraDirectionalShadowSourceSystem.h"
+#include "../ecs/systems/HydraSpotShadowSourceSystem.h"
+#include "../ecs/components/HydraLightComponent.h"
+#include "../mesh/StandardVertex.h"
+#include "../actor/HydraActorManager.h"
+#include "../actor/HydraOutputActor.h"
+
+void HydraShadowPipeline::Initialise()
+{
+    m_render_stages.resize(2);
+    _CreateUBOs();
+    _CreateDirectionalRenderStage();
+    _CreateSpotRenderStage();
+}
+
+void HydraShadowPipeline::Shutdown()
+{
+}
+
+void HydraShadowPipeline::Render()
+{
+    glViewport(0, 0, SHADOW_MAP_SIZE, SHADOW_MAP_SIZE);
+    
+    glEnable(GL_DEPTH_TEST); // Depth testing must be active
+    glDepthMask(GL_TRUE);    // Depth buffer must be writable
+    glDepthFunc(GL_LESS);
+     
+    _RenderDirectionalShadowMaps();
+    _RenderSpotShadowMaps();
+
+}
+
+void HydraShadowPipeline::_RenderDirectionalShadowMaps()
+{
+     HydraECS *ecs = GetEngine()->ECS();
+    std::shared_ptr<HydraRenderSystem> render_system = ecs->GetSystem<HydraRenderSystem>();
+    std::shared_ptr<HydraDirectionalShadowSourceSystem> shadow_system = ecs->GetSystem<HydraDirectionalShadowSourceSystem>();
+
+    for (HydraID entity_id : shadow_system->Entities)
+    {
+        HydraDirectionalShadowSourceComponent shad_comp = GetEngine()->ECS()->GetComponent<HydraDirectionalShadowSourceComponent>(entity_id);
+        HydraLightComponent light_comp = GetEngine()->ECS()->GetComponent<HydraLightComponent>(entity_id);
+        _UpdateUBO(light_comp.shadow_map_id);
+        
+        glBindFramebuffer(GL_FRAMEBUFFER, shad_comp.frame_buffer_id);
+
+        float depth_value = 1.0f;
+        float clear_colour[] = {0,0,0};
+        glClearNamedFramebufferfv(shad_comp.frame_buffer_id, GL_DEPTH, 0, &depth_value);
+        glClearNamedFramebufferfv(shad_comp.frame_buffer_id, GL_COLOR, 0, clear_colour);
+        m_render_stages[DIRECTIONAL_RENDER_STAGE]->Render(render_system->Entities, INVALID_HYDRA_ID);
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);        
+    }
+}
+
+void HydraShadowPipeline::_RenderSpotShadowMaps()
+{
+     HydraECS *ecs = GetEngine()->ECS();
+    std::shared_ptr<HydraRenderSystem> render_system = ecs->GetSystem<HydraRenderSystem>();
+    std::shared_ptr<HydraSpotShadowSourceSystem> shadow_system = ecs->GetSystem<HydraSpotShadowSourceSystem>();
+
+    for (HydraID entity_id : shadow_system->Entities)
+    {
+        HydraSpotShadowSourceComponent shad_comp = GetEngine()->ECS()->GetComponent<HydraSpotShadowSourceComponent>(entity_id);
+        HydraLightComponent light_comp = GetEngine()->ECS()->GetComponent<HydraLightComponent>(entity_id);
+        _UpdateUBO(light_comp.shadow_map_id);
+        
+        glBindFramebuffer(GL_FRAMEBUFFER, shad_comp.frame_buffer_id);
+
+        float depth_value = 1.0f;
+        float clear_colour[] = {0,0,0};
+        glClearNamedFramebufferfv(shad_comp.frame_buffer_id, GL_DEPTH, 0, &depth_value);
+        glClearNamedFramebufferfv(shad_comp.frame_buffer_id, GL_COLOR, 0, clear_colour);
+        m_render_stages[SPOT_RENDER_STAGE]->Render(render_system->Entities, INVALID_HYDRA_ID);
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    }
+}
+
+void HydraShadowPipeline::_CreateDirectionalRenderStage()
+{
+    HydraRenderStage *render_stage = new HydraRenderStage();
+    std::string shader_path = std::string(shader_base);
+    HydraBufferManager *buffer_manager = GetEngine()->BufferManager();
+
+    HydraID pos_buffer_id = buffer_manager->FindBuffer("PositionsBuffer");
+    HydraID mat_buffer_id = buffer_manager->FindBuffer("MaterialBuffer");
+    HydraID tex_buffer_id = buffer_manager->FindBuffer("TextureBuffer");
+    HydraID shadow_buffer_id = buffer_manager->FindBuffer("DirectionalShadowBuffer");
+    HydraID per_frame_buffer_id = buffer_manager->FindBuffer("ShadowPerFrameUBO");
+
+    HydraShaderBinding shader_binding = {};
+
+    shader_binding.block_name.push_back("positions_buffer");
+    shader_binding.binding_point.push_back(1);
+    shader_binding.buffer_id.push_back(pos_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("material_buffer");
+    shader_binding.binding_point.push_back(2);
+    shader_binding.buffer_id.push_back(mat_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("texture_buffer");
+    shader_binding.binding_point.push_back(3);
+    shader_binding.buffer_id.push_back(tex_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("directional_shadow_map_sets");
+    shader_binding.binding_point.push_back(5);
+    shader_binding.buffer_id.push_back(shadow_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("shadow_per_frame");
+    shader_binding.binding_point.push_back(1);
+    shader_binding.buffer_id.push_back(per_frame_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+
+    std::vector<uint32_t> textures;
+
+    render_stage->Initialise(shader_path + "shadow_cascade_shader.vert",
+                             shader_path + "shadow_cascade_shader.frag",
+                             shader_path + "shadow_cascade_shader.geom",
+                             shader_binding,
+                             0,
+                             textures,
+                             true,
+                             GL_FRONT,
+                             true,
+                             HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR);
+    m_render_stages[DIRECTIONAL_RENDER_STAGE] = render_stage;
+}
+
+void HydraShadowPipeline::_CreateSpotRenderStage()
+{
+    HydraRenderStage *render_stage = new HydraRenderStage();
+    std::string shader_path = std::string(shader_base);
+    HydraBufferManager *buffer_manager = GetEngine()->BufferManager();
+
+    HydraID pos_buffer_id = buffer_manager->FindBuffer("PositionsBuffer");
+    HydraID mat_buffer_id = buffer_manager->FindBuffer("MaterialBuffer");
+    HydraID tex_buffer_id = buffer_manager->FindBuffer("TextureBuffer");
+    HydraID shadow_buffer_id = buffer_manager->FindBuffer("SpotShadowBuffer");
+    HydraID per_frame_buffer_id = buffer_manager->FindBuffer("ShadowPerFrameUBO");
+
+    HydraShaderBinding shader_binding = {};
+
+    shader_binding.block_name.push_back("positions_buffer");
+    shader_binding.binding_point.push_back(1);
+    shader_binding.buffer_id.push_back(pos_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("material_buffer");
+    shader_binding.binding_point.push_back(2);
+    shader_binding.buffer_id.push_back(mat_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("texture_buffer");
+    shader_binding.binding_point.push_back(3);
+    shader_binding.buffer_id.push_back(tex_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("spot_shadow_map_sets");
+    shader_binding.binding_point.push_back(6);
+    shader_binding.buffer_id.push_back(shadow_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("shadow_per_frame");
+    shader_binding.binding_point.push_back(1);
+    shader_binding.buffer_id.push_back(per_frame_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+
+    std::vector<uint32_t> textures;
+
+    render_stage->Initialise(shader_path + "shadow_spot_shader.vert",
+                             shader_path + "shadow_spot_shader.frag",
+                             "",
+                             shader_binding,
+                             0,
+                             textures,
+                             true,
+                             GL_FRONT,
+                             true,
+                             HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR);
+    m_render_stages[SPOT_RENDER_STAGE] = render_stage;
+}
+
+
+void HydraShadowPipeline::_UpdateUBO(uint32_t shadow_idx)
+{
+    HydraBufferManager *buffer_manager = GetEngine()->BufferManager();
+    buffer_manager->UpdatePartialBuffer(m_per_frame_ubo, 3 * sizeof(float), sizeof(uint32_t), &shadow_idx);
+    glBindBuffer(GL_UNIFORM_BUFFER, m_per_frame_ubo);
+}
+
+void HydraShadowPipeline::_BindFrameBufferAttachments(HydraID entity_id)
+{
+    HydraDirectionalShadowSourceComponent shad_comp = GetEngine()->ECS()->GetComponent<HydraDirectionalShadowSourceComponent>(entity_id);
+    glBindFramebuffer(GL_FRAMEBUFFER, shad_comp.frame_buffer_id);
+    glBindTextureUnit(0, 0);
+}
+
+
+void HydraShadowPipeline::_CreateUBOs()
+{
+    HydraBufferManager *buffer_manager = GetEngine()->BufferManager();
+
+    m_per_frame_ubo = buffer_manager->CreateGPUBuffer("ShadowPerFrameUBO",
+                                                      sizeof(float) * 4, 0, HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+}

HydraEngine/source/pipeline/HydraShadowPipeline.h

@@ -0,0 +1,38 @@
+#ifndef HYDRASHADOWPIPELINE
+#define HYDRASHADOWPIPELINE
+
+#include "../engine/HydraObject.h"
+#include "../windowmanager/HydraRenderSettings.h"
+#include "HydraPipeline.h"
+#include "HydraRenderStage.h"
+
+#include <vector>
+
+class HydraRenderStage;
+
+class HydraShadowPipeline : public HydraPipeline
+{
+    public:        
+        void Initialise() override;
+        void Shutdown() override;
+        void Render() override;
+    private:
+        void _CreateUBOs();
+        void _CreateSpotRenderStage();
+        void _CreateDirectionalRenderStage();
+        void _UpdateUBO(uint32_t shadow_idx);
+        void _BindFrameBufferAttachments(HydraID entity_id);
+        void _RenderDirectionalShadowMaps();
+        void _RenderSpotShadowMaps();
+
+        HydraID m_per_frame_ubo = INVALID_HYDRA_ID;
+        const uint32_t DIRECTIONAL_RENDER_STAGE = 0;
+        const uint32_t SPOT_RENDER_STAGE = 1;
+        
+       
+};
+
+#endif /* HYDRADEFERREDPIPELINE */
+
+
+

HydraEngine/source/pipeline/TextureDebugUBO.hpp

@@ -0,0 +1,15 @@
+#ifndef TEXTUREDEBUGUBO
+#define TEXTUREDEBUGUBO
+
+
+#include <GLMIncludes.h>
+
+struct TextureDebugUBO
+{
+    glm::mat4 view;
+    glm::mat4 proj;
+    uint32_t shadow_idx;
+    glm::vec3 padding0;
+};
+
+#endif /* TEXTUREDEBUGUBO */

HydraEngine/source/renderer/HydraRenderer.cpp

@@ -31,18 +31,18 @@ void HydraRenderer::Initialise(HydraRenderSettings render_settings)
     }
 }
 
-void HydraRenderer::BeginFrame()
-{
+// void HydraRenderer::BeginFrame()
+// {
      
-    glViewport(0, 0, m_render_settings.ViewportWidth, m_render_settings.ViewportHeight);
+//     glViewport(0, 0, m_render_settings.ViewportWidth, m_render_settings.ViewportHeight);
     
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  
-    glClearColor(0.0f, 0.5f, 0.7f, 1.0f);
+//     glEnable(GL_BLEND);
+//     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  
+//     glClearColor(0.0f, 0.5f, 0.7f, 1.0f);
     
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+//     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     
-}
+// }
 
 void HydraRenderer::EndFrame()
 {

HydraEngine/source/renderer/HydraRenderer.h

@@ -7,7 +7,7 @@ class HydraRenderer : public HydraObject
 {
     public:        
         void Initialise(HydraRenderSettings render_settings);
-        void BeginFrame();
+        //void BeginFrame();
         void EndFrame();
         
         

HydraEngine/source/task/buffer/HydraCreateTextureTask.hpp

@@ -16,7 +16,8 @@ private:
     uint32_t m_data_type;
     uint32_t m_mip_levels;
     uint32_t m_min_filter;
-    uint32_t m_mag_filter;
+    uint32_t m_mag_filter;    
+    uint32_t m_target;
     void *m_data;
     HydraID *m_texture_id;
 
@@ -28,21 +29,21 @@ public:
              m_width, m_height, 
              m_internal_format, 
               m_min_filter,
-             m_mag_filter,
+             m_mag_filter,             
              m_format, 
              m_data_type, 
              m_mip_levels, 
              m_data);
-        GetEngine()->TextureBufferManager()->BindTexture(*m_texture_id);
+        GetEngine()->TextureBufferManager()->BindTexture(*m_texture_id, GL_TEXTURE_2D);
 
     }
-    void Initialise(std::string texture_name,
+    void Initialise(std::string texture_name,                    
                    uint32_t width,
                    uint32_t height,
                    uint32_t internal_format,
                    uint32_t format,
                    uint32_t min_filter,
-                   uint32_t mag_filter,
+                   uint32_t mag_filter,                   
                    uint32_t data_type,
                    uint32_t mip_levels,
                    void *data,
@@ -58,7 +59,7 @@ public:
         m_data = data;
         m_texture_id = texture_id;
         m_min_filter = min_filter;
-        m_mag_filter = mag_filter;
+        m_mag_filter = mag_filter;        
 
     }
 };

HydraEngine/source/task/buffer/HydraCreateUnBoundTextureTask.hpp

@@ -0,0 +1,67 @@
+#ifndef HYDRACREATEUNBOUNDTEXTURETASK
+#define HYDRACREATEUNBOUNDTEXTURETASK
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+
+class HydraCreateUnBoundTextureTask : public HydraTask
+{
+private:
+    std::string m_texture_name;
+    uint32_t m_width;
+    uint32_t m_height;
+    uint32_t m_internal_format;
+    uint32_t m_format;
+    uint32_t m_data_type;
+    uint32_t m_mip_levels;
+    uint32_t m_min_filter;
+    uint32_t m_mag_filter;    
+    void *m_data;
+    HydraID *m_texture_id;
+
+protected:
+public:
+    virtual void Process() override
+    {
+        *m_texture_id = GetEngine()->TextureBufferManager()->CreateTexture(m_texture_name,
+             m_width, m_height, 
+             m_internal_format, 
+              m_min_filter,
+             m_mag_filter,             
+             m_format, 
+             m_data_type, 
+             m_mip_levels, 
+             m_data);        
+
+    }
+    void Initialise(std::string texture_name,        
+                   uint32_t width,
+                   uint32_t height,
+                   uint32_t internal_format,
+                   uint32_t format,
+                   uint32_t min_filter,
+                   uint32_t mag_filter,                   
+                   uint32_t data_type,
+                   uint32_t mip_levels,
+                   void *data,
+                   HydraID *texture_id)
+    {
+        m_texture_name = texture_name;
+        
+        m_width = width;
+        m_height = height;
+        m_internal_format = internal_format;
+        m_format = format;
+        m_data_type = data_type;
+        m_mip_levels = mip_levels;
+        m_data = data;
+        m_texture_id = texture_id;
+        m_min_filter = min_filter;
+        m_mag_filter = mag_filter;
+        
+
+    }
+};
+
+#endif /* HYDRACREATEUNBOUNDTEXTURETASK */

HydraEngine/source/task/buffer/HydraInitialiseShadowBufferTask.hpp

@@ -0,0 +1,18 @@
+#ifndef HYDRAINITIALISESHADOWBUFFERTASK
+#define HYDRAINITIALISESHADOWBUFFERTASK
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraShadowBufferManager.h"
+
+class HydraInitialiseShadowBufferTask : public HydraTask
+{
+    private:     
+    protected:
+    public:
+        virtual void Process() override
+        {
+           GetEngine()->ShadowBufferManager()->Initialise();
+        }
+};
+
+#endif /* HYDRAINITIALISESHADOWBUFFERTASK */

HydraEngine/source/task/buffer/HydraUpdatePartialGPUBufferTask.hpp

@@ -15,8 +15,8 @@ class HydraUpdatePartialGPUBufferTask : public HydraTask
     protected:
     public:
         virtual void Process() override
-        {
-           GetEngine()->BufferManager()->UpdateWholeBuffer(m_buffer_id, m_data);
+        {           
+           GetEngine()->BufferManager()->UpdatePartialBuffer(m_buffer_id, m_start, m_size, m_data);
         }
         void Intialise(HydraID buffer_id, uint32_t start, uint32_t size, void* data)
         {
@@ -25,7 +25,6 @@ class HydraUpdatePartialGPUBufferTask : public HydraTask
             m_start = start;
             m_size = size;
         }
-        
 };
 
 #endif /* HYDRAUPDATEPARTIALGPUBUFFERTASK */

HydraEngine/source/task/renderer/HydraCreateCascadeShadowFrameBuffer.hpp

@@ -0,0 +1,86 @@
+#ifndef HYDRACREATECASCADESHADOWFRAMEBUFFER
+#define HYDRACREATECASCADESHADOWFRAMEBUFFER
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../renderer/HydraRenderer.h"
+#include <GLMIncludes.h>
+#include "../../GlewIncludes.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+
+class HydraCreateCascadeShadowFrameBuffer : public HydraTask
+{
+private:
+    uint32_t *m_texture_id = 0;
+    uint32_t *m_depth_texture_id = 0;
+    uint32_t *m_frame_buffer_id = nullptr;
+    
+protected:
+public:
+    void Process() override
+    {
+        HydraEngine *engine = GetEngine();
+
+        HydraTextureBufferManager *tex_buffer_manager = engine->TextureBufferManager();
+        HydraRenderSettings render_settings = engine->RenderSettings();
+
+        *m_texture_id = tex_buffer_manager->CreateTextureArray("shadow_FB",
+                                                               SHADOW_MAP_SIZE, SHADOW_MAP_SIZE,
+                                                               GL_RGBA8,
+                                                               GL_NEAREST,
+                                                               GL_NEAREST,
+                                                               6);
+
+        HydraTextureBuffer texture = tex_buffer_manager->GetTexture(*m_texture_id);
+
+        *m_depth_texture_id = tex_buffer_manager->CreateTextureArray("shadow_depth_buffer",
+                                                                     SHADOW_MAP_SIZE, SHADOW_MAP_SIZE,
+                                                                     GL_DEPTH_COMPONENT32F,
+                                                                     GL_NEAREST,
+                                                                     GL_NEAREST,
+                                                                     6);
+
+        HydraTextureBuffer depth_texture = tex_buffer_manager->GetTexture(*m_depth_texture_id);
+        glGenFramebuffers(1, m_frame_buffer_id);
+        glBindFramebuffer(GL_FRAMEBUFFER, *m_frame_buffer_id);
+
+        glTextureParameteri(texture.gl_tex_id, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTextureParameteri(texture.gl_tex_id, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+        // FIX 1: Set explicit filters for the depth texture to prevent incomplete attachment
+        glTextureParameteri(depth_texture.gl_tex_id, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTextureParameteri(depth_texture.gl_tex_id, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        glm::vec4 border = glm::vec4(1,1,1,1);
+
+        glTextureParameteri(depth_texture.gl_tex_id, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+        glTextureParameteri(depth_texture.gl_tex_id, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+        glTextureParameterfv(depth_texture.gl_tex_id, GL_TEXTURE_BORDER_COLOR, &border[0]);
+        
+        glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture.gl_tex_id, 0);
+        glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_texture.gl_tex_id, 0);
+
+        glNamedFramebufferDrawBuffer(*m_frame_buffer_id, GL_COLOR_ATTACHMENT0);
+        glNamedFramebufferReadBuffer(*m_frame_buffer_id, GL_COLOR_ATTACHMENT0);
+
+        GLenum draw_buffers[] = {GL_COLOR_ATTACHMENT0};
+        glNamedFramebufferDrawBuffers(*m_frame_buffer_id, 1, draw_buffers);
+
+        GLenum status = glCheckNamedFramebufferStatus(*m_frame_buffer_id, GL_FRAMEBUFFER);
+        if (status != GL_FRAMEBUFFER_COMPLETE)
+        {
+            std::cout << "Framebuffer error: " << status << std::endl;
+        }
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+        tex_buffer_manager->BindTexture(*m_depth_texture_id, GL_TEXTURE_2D_ARRAY);
+        
+    }
+    void Initialise(uint32_t *texture_id, uint32_t *depth_texture_id, uint32_t *frame_buffer_id)
+    {
+        m_texture_id = texture_id;
+        m_frame_buffer_id = frame_buffer_id;
+        m_depth_texture_id = depth_texture_id;
+    }
+};
+#endif /* HYDRACREATESHADOWFRAMEBUFFER */

HydraEngine/source/task/renderer/HydraCreateShadowFrameBuffer.hpp

@@ -0,0 +1,89 @@
+#ifndef HYDRACREATESHADOWFRAMEBUFFER
+#define HYDRACREATESHADOWFRAMEBUFFER
+
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../renderer/HydraRenderer.h"
+#include <GLMIncludes.h>
+#include "../../GlewIncludes.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+
+class HydraCreateShadowFrameBuffer : public HydraTask
+{
+private:
+    uint32_t *m_texture_id = 0;
+    uint32_t *m_depth_texture_id = 0;
+    uint32_t *m_frame_buffer_id = nullptr;
+    
+protected:
+public:
+    void Process() override
+    {
+        HydraEngine *engine = GetEngine();
+
+        HydraTextureBufferManager *tex_buffer_manager = engine->TextureBufferManager();
+        HydraRenderSettings render_settings = engine->RenderSettings();
+
+        *m_texture_id = tex_buffer_manager->CreateTexture("shadow_FB",
+                                                               SHADOW_MAP_SIZE, SHADOW_MAP_SIZE,
+                                                               GL_RGBA8,
+                                                               GL_NEAREST,
+                                                               GL_NEAREST,
+                                                               1);
+
+        HydraTextureBuffer texture = tex_buffer_manager->GetTexture(*m_texture_id);
+
+        *m_depth_texture_id = tex_buffer_manager->CreateTexture("shadow_depth_buffer",
+                                                                     SHADOW_MAP_SIZE, SHADOW_MAP_SIZE,
+                                                                     GL_DEPTH_COMPONENT32F,
+                                                                     GL_NEAREST,
+                                                                     GL_NEAREST,
+                                                                     1);
+
+        HydraTextureBuffer depth_texture = tex_buffer_manager->GetTexture(*m_depth_texture_id);
+        glGenFramebuffers(1, m_frame_buffer_id);
+        glBindFramebuffer(GL_FRAMEBUFFER, *m_frame_buffer_id);
+
+        glTextureParameteri(texture.gl_tex_id, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTextureParameteri(texture.gl_tex_id, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+        // FIX 1: Set explicit filters for the depth texture to prevent incomplete attachment
+        glTextureParameteri(depth_texture.gl_tex_id, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTextureParameteri(depth_texture.gl_tex_id, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        glm::vec4 border = glm::vec4(1,1,1,1);
+
+        glTextureParameteri(depth_texture.gl_tex_id, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+        glTextureParameteri(depth_texture.gl_tex_id, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+        glTextureParameterfv(depth_texture.gl_tex_id, GL_TEXTURE_BORDER_COLOR, &border[0]);
+        
+        glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture.gl_tex_id, 0);
+        glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_texture.gl_tex_id, 0);
+
+        glNamedFramebufferDrawBuffer(*m_frame_buffer_id, GL_COLOR_ATTACHMENT0);
+        glNamedFramebufferReadBuffer(*m_frame_buffer_id, GL_COLOR_ATTACHMENT0);
+
+        GLenum draw_buffers[] = {GL_COLOR_ATTACHMENT0};
+        glNamedFramebufferDrawBuffers(*m_frame_buffer_id, 1, draw_buffers);
+
+        GLenum status = glCheckNamedFramebufferStatus(*m_frame_buffer_id, GL_FRAMEBUFFER);
+        if (status != GL_FRAMEBUFFER_COMPLETE)
+        {
+            std::cout << "Framebuffer error: " << status << std::endl;
+        }
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+        tex_buffer_manager->BindTexture(*m_depth_texture_id, GL_TEXTURE_2D);
+        
+    }
+    void Initialise(uint32_t *texture_id, uint32_t *depth_texture_id, uint32_t *frame_buffer_id)
+    {
+        m_texture_id = texture_id;
+        m_frame_buffer_id = frame_buffer_id;
+        m_depth_texture_id = depth_texture_id;
+    }
+};
+
+
+#endif /* HYDRACREATESHADOWFRAMEBUFFER */

HydraEngine/source/task/renderer/HydraEndRenderTask.hpp

@@ -0,0 +1,18 @@
+#ifndef HYDRAENDRENDERTASK
+#define HYDRAENDRENDERTASK
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../renderer/HydraRenderer.h"
+
+class HydraEndRenderTask : public HydraTask
+{
+    private:
+    protected:
+    public:
+        virtual void Process() override
+        {
+            GetEngine()->Renderer()->EndFrame();
+        }
+};
+#endif /* HYDRAENDRENDERTASK */

HydraEngine/source/task/renderer/HydraRenderTask.hpp

@@ -10,8 +10,7 @@ class HydraRenderTask : public HydraTask
     protected:
     public:
         virtual void Process() override
-        {
-            GetEngine()->Renderer()->BeginFrame();
+        {            
             GetEngine()->Renderer()->EndFrame();
         }
 };

build/.cmake/api/v1/reply/codemodel-v2-096b8a8b347f4803f005.json

@@ -161,28 +161,28 @@
 				{
 					"directoryIndex" : 0,
 					"id" : "ALL_BUILD::@6890427a1f51a3e7e1df",
-					"jsonFile" : "target-ALL_BUILD-Debug-9ddbbbeb4caedf0a48f0.json",
+					"jsonFile" : "target-ALL_BUILD-Debug-79cb89fa590649c6cd6a.json",
 					"name" : "ALL_BUILD",
 					"projectIndex" : 0
 				},
 				{
 					"directoryIndex" : 1,
 					"id" : "ALL_BUILD::@fafd37b19aacd4c483ed",
-					"jsonFile" : "target-ALL_BUILD-Debug-30097c8e6651db3aff43.json",
+					"jsonFile" : "target-ALL_BUILD-Debug-21126e6f26f8151b82a1.json",
 					"name" : "ALL_BUILD",
 					"projectIndex" : 1
 				},
 				{
 					"directoryIndex" : 0,
 					"id" : "HydraClient::@6890427a1f51a3e7e1df",
-					"jsonFile" : "target-HydraClient-Debug-78ce361b98c7c89e9629.json",
+					"jsonFile" : "target-HydraClient-Debug-ccca9689ebe6b19fe65a.json",
 					"name" : "HydraClient",
 					"projectIndex" : 0
 				},
 				{
 					"directoryIndex" : 1,
 					"id" : "HydraEngine::@fafd37b19aacd4c483ed",
-					"jsonFile" : "target-HydraEngine-Debug-552fba7b8e0c042c3903.json",
+					"jsonFile" : "target-HydraEngine-Debug-c5670bbc5edcb254f4f2.json",
 					"name" : "HydraEngine",
 					"projectIndex" : 1
 				},
@@ -355,28 +355,28 @@
 				{
 					"directoryIndex" : 0,
 					"id" : "ALL_BUILD::@6890427a1f51a3e7e1df",
-					"jsonFile" : "target-ALL_BUILD-Release-9ddbbbeb4caedf0a48f0.json",
+					"jsonFile" : "target-ALL_BUILD-Release-79cb89fa590649c6cd6a.json",
 					"name" : "ALL_BUILD",
 					"projectIndex" : 0
 				},
 				{
 					"directoryIndex" : 1,
 					"id" : "ALL_BUILD::@fafd37b19aacd4c483ed",
-					"jsonFile" : "target-ALL_BUILD-Release-30097c8e6651db3aff43.json",
+					"jsonFile" : "target-ALL_BUILD-Release-21126e6f26f8151b82a1.json",
 					"name" : "ALL_BUILD",
 					"projectIndex" : 1
 				},
 				{
 					"directoryIndex" : 0,
 					"id" : "HydraClient::@6890427a1f51a3e7e1df",
-					"jsonFile" : "target-HydraClient-Release-5f750d1feb1d099be72b.json",
+					"jsonFile" : "target-HydraClient-Release-f300bf694420197200c5.json",
 					"name" : "HydraClient",
 					"projectIndex" : 0
 				},
 				{
 					"directoryIndex" : 1,
 					"id" : "HydraEngine::@fafd37b19aacd4c483ed",
-					"jsonFile" : "target-HydraEngine-Release-d5355df26e8e8ebc1862.json",
+					"jsonFile" : "target-HydraEngine-Release-88bc84ff8a06c001fb0b.json",
 					"name" : "HydraEngine",
 					"projectIndex" : 1
 				},
@@ -549,28 +549,28 @@
 				{
 					"directoryIndex" : 0,
 					"id" : "ALL_BUILD::@6890427a1f51a3e7e1df",
-					"jsonFile" : "target-ALL_BUILD-MinSizeRel-9ddbbbeb4caedf0a48f0.json",
+					"jsonFile" : "target-ALL_BUILD-MinSizeRel-79cb89fa590649c6cd6a.json",
 					"name" : "ALL_BUILD",
 					"projectIndex" : 0
 				},
 				{
 					"directoryIndex" : 1,
 					"id" : "ALL_BUILD::@fafd37b19aacd4c483ed",
-					"jsonFile" : "target-ALL_BUILD-MinSizeRel-30097c8e6651db3aff43.json",
+					"jsonFile" : "target-ALL_BUILD-MinSizeRel-21126e6f26f8151b82a1.json",
 					"name" : "ALL_BUILD",
 					"projectIndex" : 1
 				},
 				{
 					"directoryIndex" : 0,
 					"id" : "HydraClient::@6890427a1f51a3e7e1df",
-					"jsonFile" : "target-HydraClient-MinSizeRel-0b1754e9511a8dea2861.json",
+					"jsonFile" : "target-HydraClient-MinSizeRel-707588ed524688a0f034.json",
 					"name" : "HydraClient",
 					"projectIndex" : 0
 				},
 				{
 					"directoryIndex" : 1,
 					"id" : "HydraEngine::@fafd37b19aacd4c483ed",
-					"jsonFile" : "target-HydraEngine-MinSizeRel-300e0b7a01e3150809fd.json",
+					"jsonFile" : "target-HydraEngine-MinSizeRel-3f820b7fb6c0cca80b22.json",
 					"name" : "HydraEngine",
 					"projectIndex" : 1
 				},
@@ -743,28 +743,28 @@
 				{
 					"directoryIndex" : 0,
 					"id" : "ALL_BUILD::@6890427a1f51a3e7e1df",
-					"jsonFile" : "target-ALL_BUILD-RelWithDebInfo-9ddbbbeb4caedf0a48f0.json",
+					"jsonFile" : "target-ALL_BUILD-RelWithDebInfo-79cb89fa590649c6cd6a.json",
 					"name" : "ALL_BUILD",
 					"projectIndex" : 0
 				},
 				{
 					"directoryIndex" : 1,
 					"id" : "ALL_BUILD::@fafd37b19aacd4c483ed",
-					"jsonFile" : "target-ALL_BUILD-RelWithDebInfo-30097c8e6651db3aff43.json",
+					"jsonFile" : "target-ALL_BUILD-RelWithDebInfo-21126e6f26f8151b82a1.json",
 					"name" : "ALL_BUILD",
 					"projectIndex" : 1
 				},
 				{
 					"directoryIndex" : 0,
 					"id" : "HydraClient::@6890427a1f51a3e7e1df",
-					"jsonFile" : "target-HydraClient-RelWithDebInfo-19110864938462bdea5b.json",
+					"jsonFile" : "target-HydraClient-RelWithDebInfo-a4b1a5ac731bdcc03733.json",
 					"name" : "HydraClient",
 					"projectIndex" : 0
 				},
 				{
 					"directoryIndex" : 1,
 					"id" : "HydraEngine::@fafd37b19aacd4c483ed",
-					"jsonFile" : "target-HydraEngine-RelWithDebInfo-365df9edb3aa4717e569.json",
+					"jsonFile" : "target-HydraEngine-RelWithDebInfo-6380502de83523fc2633.json",
 					"name" : "HydraEngine",
 					"projectIndex" : 1
 				},

build/.cmake/api/v1/reply/index-2026-08-06T11-46-48-0603.json

@@ -27,7 +27,7 @@
 	"objects" : 
 	[
 		{
-			"jsonFile" : "codemodel-v2-aa0145a10a295b367570.json",
+			"jsonFile" : "codemodel-v2-096b8a8b347f4803f005.json",
 			"kind" : "codemodel",
 			"version" : 
 			{
@@ -100,7 +100,7 @@
 						}
 					},
 					{
-						"jsonFile" : "codemodel-v2-aa0145a10a295b367570.json",
+						"jsonFile" : "codemodel-v2-096b8a8b347f4803f005.json",
 						"kind" : "codemodel",
 						"version" : 
 						{

build/.cmake/api/v1/reply/target-ALL_BUILD-Debug-21126e6f26f8151b82a1.json

@@ -22,10 +22,10 @@
 	"dependencies" : 
 	[
 		{
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"folder" : 

build/.cmake/api/v1/reply/target-ALL_BUILD-Debug-79cb89fa590649c6cd6a.json

@@ -25,10 +25,10 @@
 			"id" : "HydraClient::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"folder" : 

build/.cmake/api/v1/reply/target-ALL_BUILD-MinSizeRel-21126e6f26f8151b82a1.json

@@ -22,10 +22,10 @@
 	"dependencies" : 
 	[
 		{
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"folder" : 

build/.cmake/api/v1/reply/target-ALL_BUILD-MinSizeRel-79cb89fa590649c6cd6a.json

@@ -25,10 +25,10 @@
 			"id" : "HydraClient::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"folder" : 

build/.cmake/api/v1/reply/target-ALL_BUILD-RelWithDebInfo-21126e6f26f8151b82a1.json

@@ -22,10 +22,10 @@
 	"dependencies" : 
 	[
 		{
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"folder" : 

build/.cmake/api/v1/reply/target-ALL_BUILD-RelWithDebInfo-79cb89fa590649c6cd6a.json

@@ -25,10 +25,10 @@
 			"id" : "HydraClient::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"folder" : 

build/.cmake/api/v1/reply/target-ALL_BUILD-Release-21126e6f26f8151b82a1.json

@@ -22,10 +22,10 @@
 	"dependencies" : 
 	[
 		{
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"folder" : 

build/.cmake/api/v1/reply/target-ALL_BUILD-Release-79cb89fa590649c6cd6a.json

@@ -25,10 +25,10 @@
 			"id" : "HydraClient::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"folder" : 

build/.cmake/api/v1/reply/target-HydraClient-Debug-ccca9689ebe6b19fe65a.json

@@ -107,11 +107,11 @@
 	"dependencies" : 
 	[
 		{
-			"backtrace" : 2,
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"backtrace" : 2,
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"id" : "HydraClient::@6890427a1f51a3e7e1df",

build/.cmake/api/v1/reply/target-HydraClient-MinSizeRel-707588ed524688a0f034.json

@@ -107,11 +107,11 @@
 	"dependencies" : 
 	[
 		{
-			"backtrace" : 2,
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"backtrace" : 2,
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"id" : "HydraClient::@6890427a1f51a3e7e1df",

build/.cmake/api/v1/reply/target-HydraClient-RelWithDebInfo-a4b1a5ac731bdcc03733.json

@@ -107,11 +107,11 @@
 	"dependencies" : 
 	[
 		{
-			"backtrace" : 2,
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"backtrace" : 2,
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"id" : "HydraClient::@6890427a1f51a3e7e1df",

build/.cmake/api/v1/reply/target-HydraClient-Release-f300bf694420197200c5.json

@@ -107,11 +107,11 @@
 	"dependencies" : 
 	[
 		{
-			"backtrace" : 2,
-			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
+			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
 		},
 		{
-			"id" : "ZERO_CHECK::@6890427a1f51a3e7e1df"
+			"backtrace" : 2,
+			"id" : "HydraEngine::@fafd37b19aacd4c483ed"
 		}
 	],
 	"id" : "HydraClient::@6890427a1f51a3e7e1df",

build/.cmake/api/v1/reply/target-HydraEngine-Debug-c5670bbc5edcb254f4f2.json

@@ -199,36 +199,43 @@
 				15,
 				17,
 				19,
-				22,
+				21,
+				23,
 				25,
 				28,
-				30,
+				31,
 				34,
-				36,
-				40,
-				44,
-				46,
-				56,
-				58,
-				60,
-				62,
-				64,
+				37,
+				39,
+				43,
+				45,
+				49,
+				53,
+				55,
 				66,
 				68,
 				70,
 				72,
 				74,
-				77,
+				76,
+				78,
 				80,
 				82,
 				84,
 				86,
 				88,
-				90,
-				92,
+				91,
 				94,
 				96,
-				100
+				98,
+				100,
+				102,
+				104,
+				106,
+				108,
+				110,
+				112,
+				116
 			]
 		}
 	],
@@ -315,36 +322,43 @@
 				15,
 				17,
 				19,
-				22,
+				21,
+				23,
 				25,
 				28,
-				30,
+				31,
 				34,
-				36,
-				40,
-				44,
-				46,
-				56,
-				58,
-				60,
-				62,
-				64,
+				37,
+				39,
+				43,
+				45,
+				49,
+				53,
+				55,
 				66,
 				68,
 				70,
 				72,
 				74,
-				77,
+				76,
+				78,
 				80,
 				82,
 				84,
 				86,
 				88,
-				90,
-				92,
+				91,
 				94,
 				96,
-				100
+				98,
+				100,
+				102,
+				104,
+				106,
+				108,
+				110,
+				112,
+				116
 			]
 		},
 		{
@@ -363,57 +377,66 @@
 				16,
 				18,
 				20,
-				21,
-				23,
+				22,
 				24,
 				26,
 				27,
 				29,
-				31,
+				30,
 				32,
 				33,
 				35,
-				37,
+				36,
 				38,
-				39,
+				40,
 				41,
 				42,
-				43,
-				45,
+				44,
+				46,
 				47,
 				48,
-				49,
 				50,
 				51,
 				52,
-				53,
 				54,
-				55,
+				56,
 				57,
+				58,
 				59,
+				60,
 				61,
+				62,
 				63,
+				64,
 				65,
 				67,
 				69,
 				71,
 				73,
 				75,
-				76,
-				78,
+				77,
 				79,
 				81,
 				83,
 				85,
 				87,
 				89,
-				91,
+				90,
+				92,
 				93,
 				95,
 				97,
-				98,
 				99,
-				101
+				101,
+				103,
+				105,
+				107,
+				109,
+				111,
+				113,
+				114,
+				115,
+				117
 			]
 		}
 	],
@@ -533,6 +556,39 @@
 			"path" : "HydraEngine/source/actor/HydraPointLightActor.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraSpotLightActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraSpotLightActor.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraTestCubeActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraTestCubeActor.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraTextureDebugActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraTextureDebugActor.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"path" : "HydraEngine/source/buffer/HydraBuffer.h",
@@ -581,6 +637,22 @@
 			"path" : "HydraEngine/source/buffer/HydraMaterialBufferManager.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/buffer/HydraShadowBuffer.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/buffer/HydraShadowBufferManager.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/buffer/HydraShadowBufferManager.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -677,6 +749,11 @@
 			"path" : "HydraEngine/source/ecs/HydraSystemManager.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/components/HydraDirectionalShadowSourceComponent.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"path" : "HydraEngine/source/ecs/components/HydraLightComponent.h",
@@ -709,7 +786,7 @@
 		},
 		{
 			"backtrace" : 1,
-			"path" : "HydraEngine/source/ecs/components/HydraShadowComponent.h",
+			"path" : "HydraEngine/source/ecs/components/HydraSpotShadowSourceComponent.h",
 			"sourceGroupIndex" : 1
 		},
 		{
@@ -717,6 +794,17 @@
 			"path" : "HydraEngine/source/ecs/components/HydraTextureComponent.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -761,6 +849,17 @@
 			"path" : "HydraEngine/source/ecs/systems/HydraRenderSystem.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -892,6 +991,17 @@
 			"path" : "HydraEngine/source/pipeline/HydraRenderStage.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/pipeline/HydraShadowPipeline.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/pipeline/HydraShadowPipeline.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,

build/.cmake/api/v1/reply/target-HydraEngine-MinSizeRel-3f820b7fb6c0cca80b22.json

@@ -199,36 +199,43 @@
 				15,
 				17,
 				19,
-				22,
+				21,
+				23,
 				25,
 				28,
-				30,
+				31,
 				34,
-				36,
-				40,
-				44,
-				46,
-				56,
-				58,
-				60,
-				62,
-				64,
+				37,
+				39,
+				43,
+				45,
+				49,
+				53,
+				55,
 				66,
 				68,
 				70,
 				72,
 				74,
-				77,
+				76,
+				78,
 				80,
 				82,
 				84,
 				86,
 				88,
-				90,
-				92,
+				91,
 				94,
 				96,
-				100
+				98,
+				100,
+				102,
+				104,
+				106,
+				108,
+				110,
+				112,
+				116
 			]
 		}
 	],
@@ -315,36 +322,43 @@
 				15,
 				17,
 				19,
-				22,
+				21,
+				23,
 				25,
 				28,
-				30,
+				31,
 				34,
-				36,
-				40,
-				44,
-				46,
-				56,
-				58,
-				60,
-				62,
-				64,
+				37,
+				39,
+				43,
+				45,
+				49,
+				53,
+				55,
 				66,
 				68,
 				70,
 				72,
 				74,
-				77,
+				76,
+				78,
 				80,
 				82,
 				84,
 				86,
 				88,
-				90,
-				92,
+				91,
 				94,
 				96,
-				100
+				98,
+				100,
+				102,
+				104,
+				106,
+				108,
+				110,
+				112,
+				116
 			]
 		},
 		{
@@ -363,57 +377,66 @@
 				16,
 				18,
 				20,
-				21,
-				23,
+				22,
 				24,
 				26,
 				27,
 				29,
-				31,
+				30,
 				32,
 				33,
 				35,
-				37,
+				36,
 				38,
-				39,
+				40,
 				41,
 				42,
-				43,
-				45,
+				44,
+				46,
 				47,
 				48,
-				49,
 				50,
 				51,
 				52,
-				53,
 				54,
-				55,
+				56,
 				57,
+				58,
 				59,
+				60,
 				61,
+				62,
 				63,
+				64,
 				65,
 				67,
 				69,
 				71,
 				73,
 				75,
-				76,
-				78,
+				77,
 				79,
 				81,
 				83,
 				85,
 				87,
 				89,
-				91,
+				90,
+				92,
 				93,
 				95,
 				97,
-				98,
 				99,
-				101
+				101,
+				103,
+				105,
+				107,
+				109,
+				111,
+				113,
+				114,
+				115,
+				117
 			]
 		}
 	],
@@ -533,6 +556,39 @@
 			"path" : "HydraEngine/source/actor/HydraPointLightActor.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraSpotLightActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraSpotLightActor.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraTestCubeActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraTestCubeActor.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraTextureDebugActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraTextureDebugActor.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"path" : "HydraEngine/source/buffer/HydraBuffer.h",
@@ -581,6 +637,22 @@
 			"path" : "HydraEngine/source/buffer/HydraMaterialBufferManager.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/buffer/HydraShadowBuffer.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/buffer/HydraShadowBufferManager.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/buffer/HydraShadowBufferManager.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -677,6 +749,11 @@
 			"path" : "HydraEngine/source/ecs/HydraSystemManager.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/components/HydraDirectionalShadowSourceComponent.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"path" : "HydraEngine/source/ecs/components/HydraLightComponent.h",
@@ -709,7 +786,7 @@
 		},
 		{
 			"backtrace" : 1,
-			"path" : "HydraEngine/source/ecs/components/HydraShadowComponent.h",
+			"path" : "HydraEngine/source/ecs/components/HydraSpotShadowSourceComponent.h",
 			"sourceGroupIndex" : 1
 		},
 		{
@@ -717,6 +794,17 @@
 			"path" : "HydraEngine/source/ecs/components/HydraTextureComponent.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -761,6 +849,17 @@
 			"path" : "HydraEngine/source/ecs/systems/HydraRenderSystem.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -892,6 +991,17 @@
 			"path" : "HydraEngine/source/pipeline/HydraRenderStage.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/pipeline/HydraShadowPipeline.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/pipeline/HydraShadowPipeline.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,

build/.cmake/api/v1/reply/target-HydraEngine-RelWithDebInfo-6380502de83523fc2633.json

@@ -199,36 +199,43 @@
 				15,
 				17,
 				19,
-				22,
+				21,
+				23,
 				25,
 				28,
-				30,
+				31,
 				34,
-				36,
-				40,
-				44,
-				46,
-				56,
-				58,
-				60,
-				62,
-				64,
+				37,
+				39,
+				43,
+				45,
+				49,
+				53,
+				55,
 				66,
 				68,
 				70,
 				72,
 				74,
-				77,
+				76,
+				78,
 				80,
 				82,
 				84,
 				86,
 				88,
-				90,
-				92,
+				91,
 				94,
 				96,
-				100
+				98,
+				100,
+				102,
+				104,
+				106,
+				108,
+				110,
+				112,
+				116
 			]
 		}
 	],
@@ -315,36 +322,43 @@
 				15,
 				17,
 				19,
-				22,
+				21,
+				23,
 				25,
 				28,
-				30,
+				31,
 				34,
-				36,
-				40,
-				44,
-				46,
-				56,
-				58,
-				60,
-				62,
-				64,
+				37,
+				39,
+				43,
+				45,
+				49,
+				53,
+				55,
 				66,
 				68,
 				70,
 				72,
 				74,
-				77,
+				76,
+				78,
 				80,
 				82,
 				84,
 				86,
 				88,
-				90,
-				92,
+				91,
 				94,
 				96,
-				100
+				98,
+				100,
+				102,
+				104,
+				106,
+				108,
+				110,
+				112,
+				116
 			]
 		},
 		{
@@ -363,57 +377,66 @@
 				16,
 				18,
 				20,
-				21,
-				23,
+				22,
 				24,
 				26,
 				27,
 				29,
-				31,
+				30,
 				32,
 				33,
 				35,
-				37,
+				36,
 				38,
-				39,
+				40,
 				41,
 				42,
-				43,
-				45,
+				44,
+				46,
 				47,
 				48,
-				49,
 				50,
 				51,
 				52,
-				53,
 				54,
-				55,
+				56,
 				57,
+				58,
 				59,
+				60,
 				61,
+				62,
 				63,
+				64,
 				65,
 				67,
 				69,
 				71,
 				73,
 				75,
-				76,
-				78,
+				77,
 				79,
 				81,
 				83,
 				85,
 				87,
 				89,
-				91,
+				90,
+				92,
 				93,
 				95,
 				97,
-				98,
 				99,
-				101
+				101,
+				103,
+				105,
+				107,
+				109,
+				111,
+				113,
+				114,
+				115,
+				117
 			]
 		}
 	],
@@ -533,6 +556,39 @@
 			"path" : "HydraEngine/source/actor/HydraPointLightActor.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraSpotLightActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraSpotLightActor.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraTestCubeActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraTestCubeActor.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraTextureDebugActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraTextureDebugActor.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"path" : "HydraEngine/source/buffer/HydraBuffer.h",
@@ -581,6 +637,22 @@
 			"path" : "HydraEngine/source/buffer/HydraMaterialBufferManager.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/buffer/HydraShadowBuffer.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/buffer/HydraShadowBufferManager.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/buffer/HydraShadowBufferManager.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -677,6 +749,11 @@
 			"path" : "HydraEngine/source/ecs/HydraSystemManager.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/components/HydraDirectionalShadowSourceComponent.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"path" : "HydraEngine/source/ecs/components/HydraLightComponent.h",
@@ -709,7 +786,7 @@
 		},
 		{
 			"backtrace" : 1,
-			"path" : "HydraEngine/source/ecs/components/HydraShadowComponent.h",
+			"path" : "HydraEngine/source/ecs/components/HydraSpotShadowSourceComponent.h",
 			"sourceGroupIndex" : 1
 		},
 		{
@@ -717,6 +794,17 @@
 			"path" : "HydraEngine/source/ecs/components/HydraTextureComponent.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -761,6 +849,17 @@
 			"path" : "HydraEngine/source/ecs/systems/HydraRenderSystem.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -892,6 +991,17 @@
 			"path" : "HydraEngine/source/pipeline/HydraRenderStage.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/pipeline/HydraShadowPipeline.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/pipeline/HydraShadowPipeline.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,

build/.cmake/api/v1/reply/target-HydraEngine-Release-88bc84ff8a06c001fb0b.json

@@ -199,36 +199,43 @@
 				15,
 				17,
 				19,
-				22,
+				21,
+				23,
 				25,
 				28,
-				30,
+				31,
 				34,
-				36,
-				40,
-				44,
-				46,
-				56,
-				58,
-				60,
-				62,
-				64,
+				37,
+				39,
+				43,
+				45,
+				49,
+				53,
+				55,
 				66,
 				68,
 				70,
 				72,
 				74,
-				77,
+				76,
+				78,
 				80,
 				82,
 				84,
 				86,
 				88,
-				90,
-				92,
+				91,
 				94,
 				96,
-				100
+				98,
+				100,
+				102,
+				104,
+				106,
+				108,
+				110,
+				112,
+				116
 			]
 		}
 	],
@@ -315,36 +322,43 @@
 				15,
 				17,
 				19,
-				22,
+				21,
+				23,
 				25,
 				28,
-				30,
+				31,
 				34,
-				36,
-				40,
-				44,
-				46,
-				56,
-				58,
-				60,
-				62,
-				64,
+				37,
+				39,
+				43,
+				45,
+				49,
+				53,
+				55,
 				66,
 				68,
 				70,
 				72,
 				74,
-				77,
+				76,
+				78,
 				80,
 				82,
 				84,
 				86,
 				88,
-				90,
-				92,
+				91,
 				94,
 				96,
-				100
+				98,
+				100,
+				102,
+				104,
+				106,
+				108,
+				110,
+				112,
+				116
 			]
 		},
 		{
@@ -363,57 +377,66 @@
 				16,
 				18,
 				20,
-				21,
-				23,
+				22,
 				24,
 				26,
 				27,
 				29,
-				31,
+				30,
 				32,
 				33,
 				35,
-				37,
+				36,
 				38,
-				39,
+				40,
 				41,
 				42,
-				43,
-				45,
+				44,
+				46,
 				47,
 				48,
-				49,
 				50,
 				51,
 				52,
-				53,
 				54,
-				55,
+				56,
 				57,
+				58,
 				59,
+				60,
 				61,
+				62,
 				63,
+				64,
 				65,
 				67,
 				69,
 				71,
 				73,
 				75,
-				76,
-				78,
+				77,
 				79,
 				81,
 				83,
 				85,
 				87,
 				89,
-				91,
+				90,
+				92,
 				93,
 				95,
 				97,
-				98,
 				99,
-				101
+				101,
+				103,
+				105,
+				107,
+				109,
+				111,
+				113,
+				114,
+				115,
+				117
 			]
 		}
 	],
@@ -533,6 +556,39 @@
 			"path" : "HydraEngine/source/actor/HydraPointLightActor.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraSpotLightActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraSpotLightActor.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraTestCubeActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraTestCubeActor.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/actor/HydraTextureDebugActor.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/actor/HydraTextureDebugActor.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"path" : "HydraEngine/source/buffer/HydraBuffer.h",
@@ -581,6 +637,22 @@
 			"path" : "HydraEngine/source/buffer/HydraMaterialBufferManager.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/buffer/HydraShadowBuffer.h",
+			"sourceGroupIndex" : 1
+		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/buffer/HydraShadowBufferManager.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/buffer/HydraShadowBufferManager.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -677,6 +749,11 @@
 			"path" : "HydraEngine/source/ecs/HydraSystemManager.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/components/HydraDirectionalShadowSourceComponent.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"path" : "HydraEngine/source/ecs/components/HydraLightComponent.h",
@@ -709,7 +786,7 @@
 		},
 		{
 			"backtrace" : 1,
-			"path" : "HydraEngine/source/ecs/components/HydraShadowComponent.h",
+			"path" : "HydraEngine/source/ecs/components/HydraSpotShadowSourceComponent.h",
 			"sourceGroupIndex" : 1
 		},
 		{
@@ -717,6 +794,17 @@
 			"path" : "HydraEngine/source/ecs/components/HydraTextureComponent.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -761,6 +849,17 @@
 			"path" : "HydraEngine/source/ecs/systems/HydraRenderSystem.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,
@@ -892,6 +991,17 @@
 			"path" : "HydraEngine/source/pipeline/HydraRenderStage.h",
 			"sourceGroupIndex" : 1
 		},
+		{
+			"backtrace" : 1,
+			"compileGroupIndex" : 0,
+			"path" : "HydraEngine/source/pipeline/HydraShadowPipeline.cpp",
+			"sourceGroupIndex" : 0
+		},
+		{
+			"backtrace" : 1,
+			"path" : "HydraEngine/source/pipeline/HydraShadowPipeline.h",
+			"sourceGroupIndex" : 1
+		},
 		{
 			"backtrace" : 1,
 			"compileGroupIndex" : 0,

build/CMakeFiles/CMakeConfigureLog.yaml

@@ -105,7 +105,7 @@ events:
       The output was:
       0
       MSBuild version 17.14.40+3e7442088 for .NET Framework
-      Build started 08/07/2026 22:45:52.
+      Build started 05/08/2026 14:49:31.
       
       Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\4.3.3\\CompilerIdCXX\\CompilerIdCXX.vcxproj" on node 1 (default targets).
       PrepareForBuild:
@@ -134,7 +134,7 @@ events:
           0 Warning(s)
           0 Error(s)
       
-      Time Elapsed 00:00:00.50
+      Time Elapsed 00:00:00.75
       
       
       Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "CompilerIdCXX.exe"
@@ -1020,8 +1020,8 @@ events:
     checks:
       - "Detecting CXX compiler ABI info"
     directories:
-      source: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-i02813"
-      binary: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-i02813"
+      source: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-94obry"
+      binary: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-94obry"
     cmakeVariables:
       CMAKE_CXX_FLAGS: "/DWIN32 /D_WINDOWS /EHsc"
       CMAKE_CXX_FLAGS_DEBUG: "/Ob0 /Od /RTC1"
@@ -1032,39 +1032,39 @@ events:
       variable: "CMAKE_CXX_ABI_COMPILED"
       cached: true
       stdout: |
-        Change Dir: 'C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-i02813'
+        Change Dir: 'C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-94obry'
         
-        Run Build Command(s): "C:/Program Files/Microsoft Visual Studio/2022/Professional/MSBuild/Current/Bin/amd64/MSBuild.exe" cmTC_a9d42.vcxproj /p:Configuration=Debug /p:Platform=x64 /p:VisualStudioVersion=17.0 /v:n
+        Run Build Command(s): "C:/Program Files/Microsoft Visual Studio/2022/Professional/MSBuild/Current/Bin/amd64/MSBuild.exe" cmTC_c2249.vcxproj /p:Configuration=Debug /p:Platform=x64 /p:VisualStudioVersion=17.0 /v:n
         MSBuild version 17.14.40+3e7442088 for .NET Framework
-        Build started 08/07/2026 22:45:53.
+        Build started 05/08/2026 14:49:33.
         
-        Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-i02813\\cmTC_a9d42.vcxproj" on node 1 (default targets).
+        Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-94obry\\cmTC_c2249.vcxproj" on node 1 (default targets).
         PrepareForBuild:
           Structured output is enabled. The formatting of compiler diagnostics will reflect the error hierarchy. See https://aka.ms/cpp/structured-output for more details.
-          Creating directory "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-i02813\\Debug\\".
-          Creating directory "cmTC_a9d42.dir\\Debug\\cmTC_a9d42.tlog\\".
+          Creating directory "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-94obry\\Debug\\".
+          Creating directory "cmTC_c2249.dir\\Debug\\cmTC_c2249.tlog\\".
         InitializeBuildStatus:
-          Creating "cmTC_a9d42.dir\\Debug\\cmTC_a9d42.tlog\\unsuccessfulbuild" because "AlwaysCreate" was specified.
-          Touching "cmTC_a9d42.dir\\Debug\\cmTC_a9d42.tlog\\unsuccessfulbuild".
+          Creating "cmTC_c2249.dir\\Debug\\cmTC_c2249.tlog\\unsuccessfulbuild" because "AlwaysCreate" was specified.
+          Touching "cmTC_c2249.dir\\Debug\\cmTC_c2249.tlog\\unsuccessfulbuild".
         ClCompile:
-          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\CL.exe /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_a9d42.dir\\Debug\\\\" /Fd"cmTC_a9d42.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Program Files\\CMake\\share\\cmake-4.3\\Modules\\CMakeCXXCompilerABI.cpp"
+          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\CL.exe /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_c2249.dir\\Debug\\\\" /Fd"cmTC_c2249.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Program Files\\CMake\\share\\cmake-4.3\\Modules\\CMakeCXXCompilerABI.cpp"
           Microsoft (R) C/C++ Optimizing Compiler Version 19.44.35225 for x64
           Copyright (C) Microsoft Corporation.  All rights reserved.
-          cl /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_a9d42.dir\\Debug\\\\" /Fd"cmTC_a9d42.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Program Files\\CMake\\share\\cmake-4.3\\Modules\\CMakeCXXCompilerABI.cpp"
+          cl /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_c2249.dir\\Debug\\\\" /Fd"cmTC_c2249.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Program Files\\CMake\\share\\cmake-4.3\\Modules\\CMakeCXXCompilerABI.cpp"
           CMakeCXXCompilerABI.cpp
         Link:
-          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\link.exe /OUT:"C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-i02813\\Debug\\cmTC_a9d42.exe" /INCREMENTAL /ILK:"cmTC_a9d42.dir\\Debug\\cmTC_a9d42.ilk" /NOLOGO kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-i02813/Debug/cmTC_a9d42.pdb" /SUBSYSTEM:CONSOLE /TLBID:1 /IMPLIB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-i02813/Debug/cmTC_a9d42.lib" /MACHINE:X64  /machine:x64 cmTC_a9d42.dir\\Debug\\CMakeCXXCompilerABI.obj
-          cmTC_a9d42.vcxproj -> C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-i02813\\Debug\\cmTC_a9d42.exe
+          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\link.exe /OUT:"C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-94obry\\Debug\\cmTC_c2249.exe" /INCREMENTAL /ILK:"cmTC_c2249.dir\\Debug\\cmTC_c2249.ilk" /NOLOGO kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-94obry/Debug/cmTC_c2249.pdb" /SUBSYSTEM:CONSOLE /TLBID:1 /IMPLIB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-94obry/Debug/cmTC_c2249.lib" /MACHINE:X64  /machine:x64 cmTC_c2249.dir\\Debug\\CMakeCXXCompilerABI.obj
+          cmTC_c2249.vcxproj -> C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-94obry\\Debug\\cmTC_c2249.exe
         FinalizeBuildStatus:
-          Deleting file "cmTC_a9d42.dir\\Debug\\cmTC_a9d42.tlog\\unsuccessfulbuild".
-          Touching "cmTC_a9d42.dir\\Debug\\cmTC_a9d42.tlog\\cmTC_a9d42.lastbuildstate".
-        Done Building Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-i02813\\cmTC_a9d42.vcxproj" (default targets).
+          Deleting file "cmTC_c2249.dir\\Debug\\cmTC_c2249.tlog\\unsuccessfulbuild".
+          Touching "cmTC_c2249.dir\\Debug\\cmTC_c2249.tlog\\cmTC_c2249.lastbuildstate".
+        Done Building Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-94obry\\cmTC_c2249.vcxproj" (default targets).
         
         Build succeeded.
             0 Warning(s)
             0 Error(s)
         
-        Time Elapsed 00:00:00.52
+        Time Elapsed 00:00:00.49
         
       exitCode: 0
   -
@@ -1109,8 +1109,8 @@ events:
     checks:
       - "Performing Test CMAKE_HAVE_LIBC_PTHREAD"
     directories:
-      source: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-8qp2xf"
-      binary: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-8qp2xf"
+      source: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-ladxj9"
+      binary: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-ladxj9"
     cmakeVariables:
       CMAKE_CXX_FLAGS: "/DWIN32 /D_WINDOWS /EHsc"
       CMAKE_CXX_FLAGS_DEBUG: "/Ob0 /Od /RTC1"
@@ -1120,39 +1120,39 @@ events:
       variable: "CMAKE_HAVE_LIBC_PTHREAD"
       cached: true
       stdout: |
-        Change Dir: 'C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-8qp2xf'
+        Change Dir: 'C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-ladxj9'
         
-        Run Build Command(s): "C:/Program Files/Microsoft Visual Studio/2022/Professional/MSBuild/Current/Bin/amd64/MSBuild.exe" cmTC_301d1.vcxproj /p:Configuration=Debug /p:Platform=x64 /p:VisualStudioVersion=17.0 /v:n
+        Run Build Command(s): "C:/Program Files/Microsoft Visual Studio/2022/Professional/MSBuild/Current/Bin/amd64/MSBuild.exe" cmTC_d0be4.vcxproj /p:Configuration=Debug /p:Platform=x64 /p:VisualStudioVersion=17.0 /v:n
         MSBuild version 17.14.40+3e7442088 for .NET Framework
-        Build started 08/07/2026 22:45:54.
+        Build started 05/08/2026 14:49:33.
         
-        Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\cmTC_301d1.vcxproj" on node 1 (default targets).
+        Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\cmTC_d0be4.vcxproj" on node 1 (default targets).
         PrepareForBuild:
           Structured output is enabled. The formatting of compiler diagnostics will reflect the error hierarchy. See https://aka.ms/cpp/structured-output for more details.
-          Creating directory "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\Debug\\".
-          Creating directory "cmTC_301d1.dir\\Debug\\cmTC_301d1.tlog\\".
+          Creating directory "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\Debug\\".
+          Creating directory "cmTC_d0be4.dir\\Debug\\cmTC_d0be4.tlog\\".
         InitializeBuildStatus:
-          Creating "cmTC_301d1.dir\\Debug\\cmTC_301d1.tlog\\unsuccessfulbuild" because "AlwaysCreate" was specified.
-          Touching "cmTC_301d1.dir\\Debug\\cmTC_301d1.tlog\\unsuccessfulbuild".
+          Creating "cmTC_d0be4.dir\\Debug\\cmTC_d0be4.tlog\\unsuccessfulbuild" because "AlwaysCreate" was specified.
+          Touching "cmTC_d0be4.dir\\Debug\\cmTC_d0be4.tlog\\unsuccessfulbuild".
         ClCompile:
-          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\CL.exe /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CMAKE_HAVE_LIBC_PTHREAD /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_301d1.dir\\Debug\\\\" /Fd"cmTC_301d1.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\src.cxx"
+          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\CL.exe /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CMAKE_HAVE_LIBC_PTHREAD /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_d0be4.dir\\Debug\\\\" /Fd"cmTC_d0be4.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\src.cxx"
           Microsoft (R) C/C++ Optimizing Compiler Version 19.44.35225 for x64
           Copyright (C) Microsoft Corporation.  All rights reserved.
-          cl /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CMAKE_HAVE_LIBC_PTHREAD /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_301d1.dir\\Debug\\\\" /Fd"cmTC_301d1.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\src.cxx"
+          cl /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CMAKE_HAVE_LIBC_PTHREAD /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_d0be4.dir\\Debug\\\\" /Fd"cmTC_d0be4.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\src.cxx"
           src.cxx
-        C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\src.cxx(1,10): error C1083: Cannot open include file: 'pthread.h': No such file or directory [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\cmTC_301d1.vcxproj]
-        Done Building Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\cmTC_301d1.vcxproj" (default targets) -- FAILED.
+        C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\src.cxx(1,10): error C1083: Cannot open include file: 'pthread.h': No such file or directory [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\cmTC_d0be4.vcxproj]
+        Done Building Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\cmTC_d0be4.vcxproj" (default targets) -- FAILED.
         
         Build FAILED.
         
-        "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\cmTC_301d1.vcxproj" (default target) (1) ->
+        "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\cmTC_d0be4.vcxproj" (default target) (1) ->
         (ClCompile target) -> 
-          C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\src.cxx(1,10): error C1083: Cannot open include file: 'pthread.h': No such file or directory [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-8qp2xf\\cmTC_301d1.vcxproj]
+          C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\src.cxx(1,10): error C1083: Cannot open include file: 'pthread.h': No such file or directory [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-ladxj9\\cmTC_d0be4.vcxproj]
         
             0 Warning(s)
             1 Error(s)
         
-        Time Elapsed 00:00:00.29
+        Time Elapsed 00:00:00.30
         
       exitCode: 1
   -
@@ -1168,8 +1168,8 @@ events:
     checks:
       - "Looking for pthread_create in pthreads"
     directories:
-      source: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-hnvot7"
-      binary: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-hnvot7"
+      source: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-xp6u87"
+      binary: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-xp6u87"
     cmakeVariables:
       CMAKE_CXX_FLAGS: "/DWIN32 /D_WINDOWS /EHsc"
       CMAKE_CXX_FLAGS_DEBUG: "/Ob0 /Od /RTC1"
@@ -1179,41 +1179,41 @@ events:
       variable: "CMAKE_HAVE_PTHREADS_CREATE"
       cached: true
       stdout: |
-        Change Dir: 'C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-hnvot7'
+        Change Dir: 'C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-xp6u87'
         
-        Run Build Command(s): "C:/Program Files/Microsoft Visual Studio/2022/Professional/MSBuild/Current/Bin/amd64/MSBuild.exe" cmTC_bca66.vcxproj /p:Configuration=Debug /p:Platform=x64 /p:VisualStudioVersion=17.0 /v:n
+        Run Build Command(s): "C:/Program Files/Microsoft Visual Studio/2022/Professional/MSBuild/Current/Bin/amd64/MSBuild.exe" cmTC_71e3f.vcxproj /p:Configuration=Debug /p:Platform=x64 /p:VisualStudioVersion=17.0 /v:n
         MSBuild version 17.14.40+3e7442088 for .NET Framework
-        Build started 08/07/2026 22:45:54.
+        Build started 05/08/2026 14:49:34.
         
-        Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-hnvot7\\cmTC_bca66.vcxproj" on node 1 (default targets).
+        Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-xp6u87\\cmTC_71e3f.vcxproj" on node 1 (default targets).
         PrepareForBuild:
           Structured output is enabled. The formatting of compiler diagnostics will reflect the error hierarchy. See https://aka.ms/cpp/structured-output for more details.
-          Creating directory "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-hnvot7\\Debug\\".
-          Creating directory "cmTC_bca66.dir\\Debug\\cmTC_bca66.tlog\\".
+          Creating directory "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-xp6u87\\Debug\\".
+          Creating directory "cmTC_71e3f.dir\\Debug\\cmTC_71e3f.tlog\\".
         InitializeBuildStatus:
-          Creating "cmTC_bca66.dir\\Debug\\cmTC_bca66.tlog\\unsuccessfulbuild" because "AlwaysCreate" was specified.
-          Touching "cmTC_bca66.dir\\Debug\\cmTC_bca66.tlog\\unsuccessfulbuild".
+          Creating "cmTC_71e3f.dir\\Debug\\cmTC_71e3f.tlog\\unsuccessfulbuild" because "AlwaysCreate" was specified.
+          Touching "cmTC_71e3f.dir\\Debug\\cmTC_71e3f.tlog\\unsuccessfulbuild".
         ClCompile:
-          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\CL.exe /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CHECK_FUNCTION_EXISTS=pthread_create /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_bca66.dir\\Debug\\\\" /Fd"cmTC_bca66.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-hnvot7\\CheckFunctionExists.cxx"
+          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\CL.exe /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CHECK_FUNCTION_EXISTS=pthread_create /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_71e3f.dir\\Debug\\\\" /Fd"cmTC_71e3f.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-xp6u87\\CheckFunctionExists.cxx"
           Microsoft (R) C/C++ Optimizing Compiler Version 19.44.35225 for x64
           Copyright (C) Microsoft Corporation.  All rights reserved.
-          cl /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CHECK_FUNCTION_EXISTS=pthread_create /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_bca66.dir\\Debug\\\\" /Fd"cmTC_bca66.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-hnvot7\\CheckFunctionExists.cxx"
+          cl /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CHECK_FUNCTION_EXISTS=pthread_create /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_71e3f.dir\\Debug\\\\" /Fd"cmTC_71e3f.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-xp6u87\\CheckFunctionExists.cxx"
           CheckFunctionExists.cxx
         Link:
-          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\link.exe /OUT:"C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-hnvot7\\Debug\\cmTC_bca66.exe" /INCREMENTAL /ILK:"cmTC_bca66.dir\\Debug\\cmTC_bca66.ilk" /NOLOGO pthreads.lib kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-hnvot7/Debug/cmTC_bca66.pdb" /SUBSYSTEM:CONSOLE /TLBID:1 /IMPLIB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-hnvot7/Debug/cmTC_bca66.lib" /MACHINE:X64  /machine:x64 cmTC_bca66.dir\\Debug\\CheckFunctionExists.obj
-        LINK : fatal error LNK1104: cannot open file 'pthreads.lib' [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-hnvot7\\cmTC_bca66.vcxproj]
-        Done Building Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-hnvot7\\cmTC_bca66.vcxproj" (default targets) -- FAILED.
+          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\link.exe /OUT:"C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-xp6u87\\Debug\\cmTC_71e3f.exe" /INCREMENTAL /ILK:"cmTC_71e3f.dir\\Debug\\cmTC_71e3f.ilk" /NOLOGO pthreads.lib kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-xp6u87/Debug/cmTC_71e3f.pdb" /SUBSYSTEM:CONSOLE /TLBID:1 /IMPLIB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-xp6u87/Debug/cmTC_71e3f.lib" /MACHINE:X64  /machine:x64 cmTC_71e3f.dir\\Debug\\CheckFunctionExists.obj
+        LINK : fatal error LNK1104: cannot open file 'pthreads.lib' [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-xp6u87\\cmTC_71e3f.vcxproj]
+        Done Building Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-xp6u87\\cmTC_71e3f.vcxproj" (default targets) -- FAILED.
         
         Build FAILED.
         
-        "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-hnvot7\\cmTC_bca66.vcxproj" (default target) (1) ->
+        "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-xp6u87\\cmTC_71e3f.vcxproj" (default target) (1) ->
         (Link target) -> 
-          LINK : fatal error LNK1104: cannot open file 'pthreads.lib' [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-hnvot7\\cmTC_bca66.vcxproj]
+          LINK : fatal error LNK1104: cannot open file 'pthreads.lib' [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-xp6u87\\cmTC_71e3f.vcxproj]
         
             0 Warning(s)
             1 Error(s)
         
-        Time Elapsed 00:00:00.39
+        Time Elapsed 00:00:00.38
         
       exitCode: 1
   -
@@ -1229,8 +1229,8 @@ events:
     checks:
       - "Looking for pthread_create in pthread"
     directories:
-      source: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-2acd7w"
-      binary: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-2acd7w"
+      source: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-0eom9k"
+      binary: "C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-0eom9k"
     cmakeVariables:
       CMAKE_CXX_FLAGS: "/DWIN32 /D_WINDOWS /EHsc"
       CMAKE_CXX_FLAGS_DEBUG: "/Ob0 /Od /RTC1"
@@ -1240,41 +1240,41 @@ events:
       variable: "CMAKE_HAVE_PTHREAD_CREATE"
       cached: true
       stdout: |
-        Change Dir: 'C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-2acd7w'
+        Change Dir: 'C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-0eom9k'
         
-        Run Build Command(s): "C:/Program Files/Microsoft Visual Studio/2022/Professional/MSBuild/Current/Bin/amd64/MSBuild.exe" cmTC_78744.vcxproj /p:Configuration=Debug /p:Platform=x64 /p:VisualStudioVersion=17.0 /v:n
+        Run Build Command(s): "C:/Program Files/Microsoft Visual Studio/2022/Professional/MSBuild/Current/Bin/amd64/MSBuild.exe" cmTC_62230.vcxproj /p:Configuration=Debug /p:Platform=x64 /p:VisualStudioVersion=17.0 /v:n
         MSBuild version 17.14.40+3e7442088 for .NET Framework
-        Build started 08/07/2026 22:45:55.
+        Build started 05/08/2026 14:49:35.
         
-        Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-2acd7w\\cmTC_78744.vcxproj" on node 1 (default targets).
+        Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-0eom9k\\cmTC_62230.vcxproj" on node 1 (default targets).
         PrepareForBuild:
           Structured output is enabled. The formatting of compiler diagnostics will reflect the error hierarchy. See https://aka.ms/cpp/structured-output for more details.
-          Creating directory "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-2acd7w\\Debug\\".
-          Creating directory "cmTC_78744.dir\\Debug\\cmTC_78744.tlog\\".
+          Creating directory "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-0eom9k\\Debug\\".
+          Creating directory "cmTC_62230.dir\\Debug\\cmTC_62230.tlog\\".
         InitializeBuildStatus:
-          Creating "cmTC_78744.dir\\Debug\\cmTC_78744.tlog\\unsuccessfulbuild" because "AlwaysCreate" was specified.
-          Touching "cmTC_78744.dir\\Debug\\cmTC_78744.tlog\\unsuccessfulbuild".
+          Creating "cmTC_62230.dir\\Debug\\cmTC_62230.tlog\\unsuccessfulbuild" because "AlwaysCreate" was specified.
+          Touching "cmTC_62230.dir\\Debug\\cmTC_62230.tlog\\unsuccessfulbuild".
         ClCompile:
-          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\CL.exe /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CHECK_FUNCTION_EXISTS=pthread_create /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_78744.dir\\Debug\\\\" /Fd"cmTC_78744.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-2acd7w\\CheckFunctionExists.cxx"
+          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\CL.exe /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CHECK_FUNCTION_EXISTS=pthread_create /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_62230.dir\\Debug\\\\" /Fd"cmTC_62230.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-0eom9k\\CheckFunctionExists.cxx"
           Microsoft (R) C/C++ Optimizing Compiler Version 19.44.35225 for x64
           Copyright (C) Microsoft Corporation.  All rights reserved.
-          cl /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CHECK_FUNCTION_EXISTS=pthread_create /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_78744.dir\\Debug\\\\" /Fd"cmTC_78744.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-2acd7w\\CheckFunctionExists.cxx"
+          cl /c /Zi /W1 /WX- /diagnostics:column /Od /Ob0 /D _MBCS /D WIN32 /D _WINDOWS /D CHECK_FUNCTION_EXISTS=pthread_create /D _MBCS /D "CMAKE_INTDIR=\\"Debug\\"" /EHsc /RTC1 /MDd /std:c++17 /Fo"cmTC_62230.dir\\Debug\\\\" /Fd"cmTC_62230.dir\\Debug\\vc143.pdb" /external:W1 /TP /errorReport:queue "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-0eom9k\\CheckFunctionExists.cxx"
           CheckFunctionExists.cxx
         Link:
-          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\link.exe /OUT:"C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-2acd7w\\Debug\\cmTC_78744.exe" /INCREMENTAL /ILK:"cmTC_78744.dir\\Debug\\cmTC_78744.ilk" /NOLOGO pthread.lib kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-2acd7w/Debug/cmTC_78744.pdb" /SUBSYSTEM:CONSOLE /TLBID:1 /IMPLIB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-2acd7w/Debug/cmTC_78744.lib" /MACHINE:X64  /machine:x64 cmTC_78744.dir\\Debug\\CheckFunctionExists.obj
-        LINK : fatal error LNK1104: cannot open file 'pthread.lib' [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-2acd7w\\cmTC_78744.vcxproj]
-        Done Building Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-2acd7w\\cmTC_78744.vcxproj" (default targets) -- FAILED.
+          C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Tools\\MSVC\\14.44.35207\\bin\\HostX64\\x64\\link.exe /OUT:"C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-0eom9k\\Debug\\cmTC_62230.exe" /INCREMENTAL /ILK:"cmTC_62230.dir\\Debug\\cmTC_62230.ilk" /NOLOGO pthread.lib kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-0eom9k/Debug/cmTC_62230.pdb" /SUBSYSTEM:CONSOLE /TLBID:1 /IMPLIB:"C:/Code/HydraV3/build/CMakeFiles/CMakeScratch/TryCompile-0eom9k/Debug/cmTC_62230.lib" /MACHINE:X64  /machine:x64 cmTC_62230.dir\\Debug\\CheckFunctionExists.obj
+        LINK : fatal error LNK1104: cannot open file 'pthread.lib' [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-0eom9k\\cmTC_62230.vcxproj]
+        Done Building Project "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-0eom9k\\cmTC_62230.vcxproj" (default targets) -- FAILED.
         
         Build FAILED.
         
-        "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-2acd7w\\cmTC_78744.vcxproj" (default target) (1) ->
+        "C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-0eom9k\\cmTC_62230.vcxproj" (default target) (1) ->
         (Link target) -> 
-          LINK : fatal error LNK1104: cannot open file 'pthread.lib' [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-2acd7w\\cmTC_78744.vcxproj]
+          LINK : fatal error LNK1104: cannot open file 'pthread.lib' [C:\\Code\\HydraV3\\build\\CMakeFiles\\CMakeScratch\\TryCompile-0eom9k\\cmTC_62230.vcxproj]
         
             0 Warning(s)
             1 Error(s)
         
-        Time Elapsed 00:00:00.37
+        Time Elapsed 00:00:00.36
         
       exitCode: 1
   -

build/HydraClient.dir/Debug/HydraClient.Build.CppClean.log

@@ -2,10 +2,11 @@ c:\code\hydrav3\build\hydraclient.dir\debug\vc143.pdb
 c:\code\hydrav3\build\hydraclient.dir\debug\hydragame.obj
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.obj
 c:\code\hydrav3\build\cmakefiles\generate.stamp
+c:\code\hydrav3\build\debug\hydraclient.exe
+c:\code\hydrav3\build\debug\hydraclient.pdb
 c:\code\hydrav3\build\debug\hydraclient.lib
 c:\code\hydrav3\build\debug\hydraclient.exp
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.ilk
-c:\code\hydrav3\build\debug\hydraclient.pdb
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\cl.command.1.tlog
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\cl.items.tlog
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\cl.read.1.tlog
@@ -13,16 +14,6 @@ c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\cl.write.1.tlog
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\custombuild.command.1.tlog
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\custombuild.read.1.tlog
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\custombuild.write.1.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000-cvtres.read.1.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000-cvtres.write.1.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000-rc.read.1.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000-rc.write.1.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000.read.1.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000.read.2.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000.read.3.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000.read.4.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000.read.5.tlog
-c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.135000.write.1.tlog
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.command.1.tlog
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.read.1.tlog
 c:\code\hydrav3\build\hydraclient.dir\debug\hydraclient.tlog\link.secondary.1.tlog

build/HydraEngine/HydraEngine.dir/Debug/HydraEngine.Build.CppClean.log

@@ -1,30 +1,27 @@
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\vc143.pdb
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraengine.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydratransformsystem.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrarendersystem.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrameshsystem.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydramaterialsystem.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrasystemmanager.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrasystem.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraecs.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydracamera.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydravertexbuffermanager.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydratexturebuffermanager.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydramaterialbuffermanager.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydralightbuffermanager.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrabuffermanager.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydratexturedebugactor.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydratestcubeactor.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraspotlightactor.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrapointlightactor.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraplayeractor.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraplaneactor.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraoutputactor.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydragltfactor.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydradirectionallightactor.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraactormanager.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraactor.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\cmakecxxcompilerid.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrawindowmanager.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydratask.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrathread.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrataskscheduler.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrataskbarrier.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrarenderer.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrashadowpipeline.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrarenderstage.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrapipeline.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraforwardpipeline.obj
@@ -34,9 +31,18 @@ c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydragameproxy.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydragltfloader.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraobject.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrainputmanager.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydralightbuffermanager.obj
-c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydradirectionallightactor.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydraengine.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydratransformsystem.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrashadowsourcesystem.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrarendersystem.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrameshsystem.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydramaterialsystem.obj
 c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydralightsystem.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrasystemmanager.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrawindowmanager.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydratask.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrathread.obj
+c:\code\hydrav3\build\hydraengine\hydraengine.dir\debug\hydrataskscheduler.obj
 c:\code\hydrav3\build\hydraengine\cmakefiles\generate.stamp
 c:\code\hydrav3\build\hydraengine\debug\hydraengine.dll
 c:\code\hydrav3\build\hydraengine\debug\hydraengine.pdb

build/HydraEngine/HydraEngine.dir/Debug/HydraEngine.tlog/Cl.items.tlog

@@ -7,19 +7,25 @@ C:\Code\HydraV3\HydraEngine\source\actor\HydraOutputActor.cpp;C:\Code\HydraV3\bu
 C:\Code\HydraV3\HydraEngine\source\actor\HydraPlaneActor.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraPlaneActor.obj
 C:\Code\HydraV3\HydraEngine\source\actor\HydraPlayerActor.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraPlayerActor.obj
 C:\Code\HydraV3\HydraEngine\source\actor\HydraPointLightActor.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraPointLightActor.obj
+C:\Code\HydraV3\HydraEngine\source\actor\HydraSpotLightActor.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraSpotLightActor.obj
+C:\Code\HydraV3\HydraEngine\source\actor\HydraTestCubeActor.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraTestCubeActor.obj
+C:\Code\HydraV3\HydraEngine\source\actor\HydraTextureDebugActor.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraTextureDebugActor.obj
 C:\Code\HydraV3\HydraEngine\source\buffer\HydraBufferManager.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraBufferManager.obj
 C:\Code\HydraV3\HydraEngine\source\buffer\HydraLightBufferManager.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraLightBufferManager.obj
 C:\Code\HydraV3\HydraEngine\source\buffer\HydraMaterialBufferManager.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraMaterialBufferManager.obj
+C:\Code\HydraV3\HydraEngine\source\buffer\HydraShadowBufferManager.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraShadowBufferManager.obj
 C:\Code\HydraV3\HydraEngine\source\buffer\HydraTextureBufferManager.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraTextureBufferManager.obj
 C:\Code\HydraV3\HydraEngine\source\buffer\HydraVertexBufferManager.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraVertexBufferManager.obj
 C:\Code\HydraV3\HydraEngine\source\camera\HydraCamera.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraCamera.obj
 C:\Code\HydraV3\HydraEngine\source\ecs\HydraECS.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraECS.obj
 C:\Code\HydraV3\HydraEngine\source\ecs\HydraSystem.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraSystem.obj
 C:\Code\HydraV3\HydraEngine\source\ecs\HydraSystemManager.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraSystemManager.obj
+C:\Code\HydraV3\HydraEngine\source\ecs\systems\HydraDirectionalShadowSourceSystem.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraDirectionalShadowSourceSystem.obj
 C:\Code\HydraV3\HydraEngine\source\ecs\systems\HydraLightSystem.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraLightSystem.obj
 C:\Code\HydraV3\HydraEngine\source\ecs\systems\HydraMaterialSystem.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraMaterialSystem.obj
 C:\Code\HydraV3\HydraEngine\source\ecs\systems\HydraMeshSystem.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraMeshSystem.obj
 C:\Code\HydraV3\HydraEngine\source\ecs\systems\HydraRenderSystem.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraRenderSystem.obj
+C:\Code\HydraV3\HydraEngine\source\ecs\systems\HydraSpotShadowSourceSystem.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraSpotShadowSourceSystem.obj
 C:\Code\HydraV3\HydraEngine\source\ecs\systems\HydraTransformSystem.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraTransformSystem.obj
 C:\Code\HydraV3\HydraEngine\source\engine\HydraEngine.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraEngine.obj
 C:\Code\HydraV3\HydraEngine\source\engine\HydraInputManager.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraInputManager.obj
@@ -31,6 +37,7 @@ C:\Code\HydraV3\HydraEngine\source\pipeline\HydraDeferredPipeline.cpp;C:\Code\Hy
 C:\Code\HydraV3\HydraEngine\source\pipeline\HydraForwardPipeline.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraForwardPipeline.obj
 C:\Code\HydraV3\HydraEngine\source\pipeline\HydraPipeline.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraPipeline.obj
 C:\Code\HydraV3\HydraEngine\source\pipeline\HydraRenderStage.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraRenderStage.obj
+C:\Code\HydraV3\HydraEngine\source\pipeline\HydraShadowPipeline.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraShadowPipeline.obj
 C:\Code\HydraV3\HydraEngine\source\renderer\HydraRenderer.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraRenderer.obj
 C:\Code\HydraV3\HydraEngine\source\scheduler\HydraTaskBarrier.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraTaskBarrier.obj
 C:\Code\HydraV3\HydraEngine\source\scheduler\HydraTaskScheduler.cpp;C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraTaskScheduler.obj

build/HydraEngine/HydraEngine.dir/Debug/HydraEngine.tlog/link.secondary.1.tlog

@@ -1,4 +1,4 @@
-^C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\CMAKECXXCOMPILERID.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAACTORMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRABUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRACAMERA.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRADEFERREDPIPELINE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRADIRECTIONALLIGHTACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAECS.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAENGINE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAFORWARDPIPELINE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAGAMEPROXY.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAGLTFACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAGLTFLOADER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAINPUTMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRALIGHTBUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRALIGHTSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAMATERIALBUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAMATERIALSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAMESHMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAMESHSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAOBJECT.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAOUTPUTACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAPIPELINE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAPLANEACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAPLAYERACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAPOINTLIGHTACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRARENDERER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRARENDERSTAGE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRARENDERSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRASYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRASYSTEMMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATASK.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATASKBARRIER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATASKSCHEDULER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATEXTUREBUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATHREAD.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATRANSFORMSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAVERTEXBUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAWINDOWMANAGER.OBJ
+^C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\CMAKECXXCOMPILERID.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAACTORMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRABUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRACAMERA.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRADEFERREDPIPELINE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRADIRECTIONALLIGHTACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRADIRECTIONALSHADOWSOURCESYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAECS.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAENGINE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAFORWARDPIPELINE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAGAMEPROXY.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAGLTFACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAGLTFLOADER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAINPUTMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRALIGHTBUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRALIGHTSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAMATERIALBUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAMATERIALSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAMESHMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAMESHSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAOBJECT.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAOUTPUTACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAPIPELINE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAPLANEACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAPLAYERACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAPOINTLIGHTACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRARENDERER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRARENDERSTAGE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRARENDERSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRASHADOWBUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRASHADOWPIPELINE.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRASPOTLIGHTACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRASPOTSHADOWSOURCESYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRASYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRASYSTEMMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATASK.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATASKBARRIER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATASKSCHEDULER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATESTCUBEACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATEXTUREBUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATEXTUREDEBUGACTOR.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATHREAD.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRATRANSFORMSYSTEM.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAVERTEXBUFFERMANAGER.OBJ|C:\CODE\HYDRAV3\BUILD\HYDRAENGINE\HYDRAENGINE.DIR\DEBUG\HYDRAWINDOWMANAGER.OBJ
 C:\Code\HydraV3\build\HydraEngine\Debug\HydraEngine.lib
 C:\Code\HydraV3\build\HydraEngine\Debug\HydraEngine.EXP
 C:\Code\HydraV3\build\HydraEngine\HydraEngine.dir\Debug\HydraEngine.ilk