Spot works

HydraClient/source/HydraGame.cpp

@@ -4,11 +4,20 @@ bool HydraGame::Initialise()
 {
     // m_angle = 0.01f;
 
-    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.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

@@ -8,6 +8,10 @@
 #include "../source/actor/HydraPlaneActor.h"
 #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

@@ -11,43 +11,91 @@ uint METAL_ROUGH_TEXTURE_ID = 2;
 uint NORMAL_TEXTURE_ID = 3;
 uint POSITION_TEXTIURE_ID = 4;
 
-struct light_structure
-{	
-	vec4 light_colour;
-	float light_intensity;
-	uint chunk_id;
-	uint light_type;
-	float padding[1];
+
+uint HYDRA_LIGHT_DIRECTIONAL = 1;
+uint HYDRA_LIGHT_POINT = 2;
+uint HYDRA_LIGHT_SPOT = 3;
+
+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;
@@ -100,62 +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 DirectionalShading(vec3 normal,
+						vec3 diffuse,
+						float roughness,
+						float metallic,
+						float light_intensity,
+						vec3 light_dir,
+						vec3 light_pos,
+						vec3 world_pos,
+						vec3 view_pos)
+{
+
+	float distance = length(light_pos - world_pos);
+	float attenuation = 1.0;
+
+	vec3 radiance = diffuse * attenuation;
+
+	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;
@@ -165,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]];
@@ -172,53 +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);
-	for(int i = 0; i < ubo_per_frame.light_count; i ++)
-	{
-		mat4 model = model_matrix[lights[i].chunk_id];
-		mat3 rot_mat = GetRotationOnlyMatrix(model);
-		vec3 light_direction = rot_mat * vec3(0,0,1);
-		
-		vec3 light_pos = model[3].xyz;
-		
-		vec3 colour = 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 = colour;
-		//uFragColor = vec4(light_direction, 1);
-	}
-	
-	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 Lo = ambient;
+	for(int i = 0; i < ubo_per_frame.light_count; i ++)
+	{
+		mat4 model = model_matrix[lights[i].entity_id];
+		mat3 rot_mat = GetRotationOnlyMatrix(model);
+		vec3 light_direction = normalize(rot_mat * vec3(0,0,1));
 
-    vec3 output_color = ambient + Lo;
+		vec3 light_pos = model[3].xyz;
+		if(lights[i].light_type == HYDRA_LIGHT_DIRECTIONAL)
+		{
+			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].intensity,
+							light_pos,
+							lights[i].constant,
+							lights[i].linear,
+							lights[i].quadratic,
+							world_pos,
+							ubo_per_frame.viewer_pos);
+		}
+		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;
+    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/HydraDirectionalLightActor.h

@@ -1,5 +1,5 @@
-#ifndef HYDRALIGHTACTOR
-#define HYDRALIGHTACTOR
+#ifndef HYDRADIRECTIONALLIGHTACTOR
+#define HYDRADIRECTIONALLIGHTACTOR
 #include "HydraActor.h"
 
 class CLASS_DEFINE HydraDirectionalLightActor : public HydraActor
@@ -15,4 +15,4 @@ class CLASS_DEFINE HydraDirectionalLightActor : public HydraActor
 };
 
 
-#endif /* HYDRALIGHTACTOR */
+#endif /* HYDRADIRECTIONALLIGHTACTOR */

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

@@ -0,0 +1,37 @@
+#include "HydraPointLightActor.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 "../buffer/HydraLightBufferManager.h"
+#include "../buffer/HydraLightBuffer.h"
+
+
+
+
+void HydraPointLightActor::InitialiseComponents()
+{
+    HydraLightComponent light_comp = {};
+	HydraECS *ecs = GetEngine()->ECS();
+    
+    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();
+
+	ecs->AddComponent<HydraLightComponent>(GetID(), light_comp);
+    
+	HydraPositionComponent position_component;
+	ecs->AddComponent<HydraPositionComponent>(GetID(), position_component);
+}
+
+void HydraPointLightActor::Destroy()
+{
+
+}

HydraEngine/source/actor/HydraPointLightActor.h

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

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

@@ -146,6 +146,7 @@ void HydraGLTFLoader::_ProcessGLTFMesh(aiScene const *scene, HydraID parent_acto
             vert.normal[1] = mesh->mNormals[i_verts].y;
             vert.normal[2] = mesh->mNormals[i_verts].z;
         }
+        
         if(mesh->HasTangentsAndBitangents())
         {
             vert.bitanget[0] = mesh->mBitangents[i_verts].x;
@@ -279,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();
         }
 };

Libraries/glew-2.3.1/LICENSE.txt

@@ -0,0 +1,73 @@
+The OpenGL Extension Wrangler Library
+Copyright (C) 2002-2007, Milan Ikits <milan ikits[]ieee org>
+Copyright (C) 2002-2007, Marcelo E. Magallon <mmagallo[]debian org>
+Copyright (C) 2002, Lev Povalahev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, 
+  this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, 
+  this list of conditions and the following disclaimer in the documentation 
+  and/or other materials provided with the distribution.
+* The name of the author may be used to endorse or promote products 
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Mesa 3-D graphics library
+Version:  7.0
+
+Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Copyright (c) 2007 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

Libraries/glew-2.3.1/Makefile

@@ -0,0 +1,359 @@
+#!gmake
+## The OpenGL Extension Wrangler Library
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002, Lev Povalahev
+## All rights reserved.
+## 
+## Redistribution and use in source and binary forms, with or without 
+## modification, are permitted provided that the following conditions are met:
+## 
+## * Redistributions of source code must retain the above copyright notice, 
+##   this list of conditions and the following disclaimer.
+## * Redistributions in binary form must reproduce the above copyright notice, 
+##   this list of conditions and the following disclaimer in the documentation 
+##   and/or other materials provided with the distribution.
+## * The name of the author may be used to endorse or promote products 
+##   derived from this software without specific prior written permission.
+##
+## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+## AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+## IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+## ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+## LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+## CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+## SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+## INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+## CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+## ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+## THE POSSIBILITY OF SUCH DAMAGE.
+
+include config/version
+
+SHELL = /bin/sh
+SYSTEM ?= $(shell config/config.guess | cut -d - -f 3 | sed -e 's/\.//g' -e 's/[0-9]\{1,\}.*//')
+SYSTEM.SUPPORTED = $(shell test -f config/Makefile.$(SYSTEM) && echo 1)
+
+ifeq ($(SYSTEM.SUPPORTED), 1)
+include config/Makefile.$(SYSTEM)
+else
+$(error "Platform '$(SYSTEM)' not supported")
+endif
+
+GLEW_PREFIX ?= /usr/local
+GLEW_DEST ?= /usr/local
+BINDIR    ?= $(GLEW_DEST)/bin
+LIBDIR    ?= $(GLEW_DEST)/lib
+INCDIR    ?= $(GLEW_DEST)/include/GL
+PKGDIR    ?= $(GLEW_DEST)/lib/pkgconfig
+
+ifneq ($(GLEW_NO_GLU), -DGLEW_NO_GLU)
+LIBGLU = glu
+endif
+
+DIST_NAME    ?= glew-$(GLEW_VERSION)
+DIST_SRC_ZIP ?= $(shell pwd)/$(DIST_NAME).zip
+DIST_SRC_TGZ ?= $(shell pwd)/$(DIST_NAME).tgz
+DIST_WIN32   ?= $(shell pwd)/$(DIST_NAME)-win32.zip
+
+DIST_DIR := $(shell mktemp -d /tmp/glew.XXXXXX)/$(DIST_NAME)
+
+# To disable stripping of linked binaries either:
+#   - use STRIP= on gmake command-line
+#   - edit this makefile to set STRIP to the empty string
+#
+# To disable symlinks:
+#   - use LN= on gmake command-line
+
+AR       ?= ar
+ARFLAGS  ?= cr
+INSTALL  ?= install
+STRIP    ?= strip
+RM       ?= rm -f
+LN       ?= ln -sf
+UNIX2DOS ?= unix2dos -q
+DOS2UNIX ?= dos2unix -q
+
+ifneq (,$(filter debug,$(MAKECMDGOALS)))
+OPT = -g
+STRIP :=
+else
+OPT = $(POPT)
+endif
+INCLUDE = -Iinclude
+CFLAGS = $(OPT) $(WARN) $(INCLUDE) $(CFLAGS.EXTRA)
+
+all debug: glew.lib glew.bin
+
+# GLEW shared and static libraries
+
+LIB.LDFLAGS        := $(LDFLAGS.EXTRA) $(LDFLAGS.GL)
+LIB.LIBS           := $(GL_LDFLAGS)
+LIB.SHARED.DIR     ?= lib
+
+LIB.SRCS           := src/glew.c
+LIB.SRCS.NAMES     := $(notdir $(LIB.SRCS))
+
+LIB.OBJS           := $(addprefix tmp/$(SYSTEM)/default/static/,$(LIB.SRCS.NAMES))
+LIB.OBJS           := $(LIB.OBJS:.c=.o)
+LIB.SOBJS          := $(addprefix tmp/$(SYSTEM)/default/shared/,$(LIB.SRCS.NAMES))
+LIB.SOBJS          := $(LIB.SOBJS:.c=.o)
+
+glew.lib: glew.lib.shared glew.lib.static
+
+glew.lib.shared: lib $(LIB.SHARED.DIR) $(LIB.SHARED.DIR)/$(LIB.SHARED) glew.pc
+glew.lib.static: lib lib/$(LIB.STATIC) glew.pc
+
+.PHONY: glew.lib glew.lib.shared glew.lib.static
+
+lib:
+	mkdir lib
+
+lib/$(LIB.STATIC): $(LIB.OBJS)
+ifneq ($(AR),)
+	$(AR) $(ARFLAGS) $@ $^
+else ifneq ($(LIBTOOL),)
+	$(LIBTOOL) $@ $^
+endif
+ifneq ($(STRIP),)
+	$(STRIP) -x $@
+endif
+
+$(LIB.SHARED.DIR)/$(LIB.SHARED): $(LIB.SOBJS)
+	$(LD) $(LDFLAGS.SO) -o $@ $^ $(LIB.LDFLAGS) $(LIB.LIBS)
+ifneq ($(LN),)
+	$(LN) $(LIB.SHARED) $(LIB.SHARED.DIR)/$(LIB.SONAME)
+	$(LN) $(LIB.SHARED) $(LIB.SHARED.DIR)/$(LIB.DEVLNK)
+endif
+ifneq ($(STRIP),)
+	$(STRIP) -x $@
+endif
+
+tmp/$(SYSTEM)/default/static/glew.o: src/glew.c include/GL/glew.h include/GL/wglew.h include/GL/glxew.h
+	@mkdir -p $(dir $@)
+	$(CC) -DGLEW_NO_GLU -DGLEW_STATIC $(CFLAGS) $(CFLAGS.SO) -o $@ -c $<
+
+tmp/$(SYSTEM)/default/shared/glew.o: src/glew.c include/GL/glew.h include/GL/wglew.h include/GL/glxew.h
+	@mkdir -p $(dir $@)
+	$(CC) -DGLEW_NO_GLU -DGLEW_BUILD $(CFLAGS) $(CFLAGS.SO) -o $@ -c $<
+
+# Force re-write of glew.pc, GLEW_DEST can vary
+
+.PHONY: glew.pc
+
+glew.pc: glew.pc.in
+	sed \
+		-e "s|@prefix@|$(GLEW_PREFIX)|g" \
+		-e "s|@libdir@|$(LIBDIR)|g" \
+		-e "s|@exec_prefix@|$(BINDIR)|g" \
+		-e "s|@includedir@|$(INCDIR)|g" \
+		-e "s|@version@|$(GLEW_VERSION)|g" \
+		-e "s|@cflags@||g" \
+		-e "s|@libname@|$(NAME)|g" \
+		-e "s|@libgl@|$(LDFLAGS.GL)|g" \
+		-e "s|@requireslib@|$(LIBGLU)|g" \
+		< $< > $@
+
+# GLEW utility programs
+
+BIN.LIBS = -Llib $(LDFLAGS.DYNAMIC) -l$(NAME) $(LDFLAGS.EXTRA) $(LDFLAGS.GL)
+
+GLEWINFO.BIN       := glewinfo$(BIN.SUFFIX)
+GLEWINFO.BIN.SRC   := src/glewinfo.c
+GLEWINFO.BIN.OBJ   := $(addprefix tmp/$(SYSTEM)/default/shared/,$(notdir $(GLEWINFO.BIN.SRC)))
+GLEWINFO.BIN.OBJ   := $(GLEWINFO.BIN.OBJ:.c=.o)
+
+VISUALINFO.BIN     := visualinfo$(BIN.SUFFIX)
+VISUALINFO.BIN.SRC := src/visualinfo.c
+VISUALINFO.BIN.OBJ := $(addprefix tmp/$(SYSTEM)/default/shared/,$(notdir $(VISUALINFO.BIN.SRC)))
+VISUALINFO.BIN.OBJ := $(VISUALINFO.BIN.OBJ:.c=.o)
+
+# Don't build glewinfo or visualinfo for NaCL, yet.
+
+ifneq ($(filter nacl%,$(SYSTEM)),)
+glew.bin: glew.lib
+else
+glew.bin: glew.lib bin/$(GLEWINFO.BIN) bin/$(VISUALINFO.BIN)
+endif
+
+bin/$(GLEWINFO.BIN): $(GLEWINFO.BIN.OBJ) $(LIB.SHARED.DIR)/$(LIB.SHARED)
+	@mkdir -p $(dir $@)
+	$(CC) $(CFLAGS) -o $@ $(GLEWINFO.BIN.OBJ) $(BIN.LIBS)
+ifneq ($(STRIP),)
+	$(STRIP) -x $@
+endif
+
+bin/$(VISUALINFO.BIN): $(VISUALINFO.BIN.OBJ) $(LIB.SHARED.DIR)/$(LIB.SHARED)
+	@mkdir -p $(dir $@)
+	$(CC) $(CFLAGS) -o $@ $(VISUALINFO.BIN.OBJ) $(BIN.LIBS)
+ifneq ($(STRIP),)
+	$(STRIP) -x $@
+endif
+
+$(GLEWINFO.BIN.OBJ): $(GLEWINFO.BIN.SRC) include/GL/glew.h include/GL/wglew.h include/GL/glxew.h
+	@mkdir -p $(dir $@)
+	$(CC) -DGLEW_NO_GLU $(CFLAGS) $(CFLAGS.SO) -o $@ -c $<
+
+$(VISUALINFO.BIN.OBJ): $(VISUALINFO.BIN.SRC) include/GL/glew.h include/GL/wglew.h include/GL/glxew.h
+	@mkdir -p $(dir $@)
+	$(CC) -DGLEW_NO_GLU $(CFLAGS) $(CFLAGS.SO) -o $@ -c $<
+
+# Install targets
+
+install.all: install install.bin
+
+install:     install.include install.lib install.pkgconfig
+
+install.lib: glew.lib
+	$(INSTALL) -d -m 0755 "$(DESTDIR)$(LIBDIR)"
+# runtime
+ifeq ($(filter-out mingw% cygwin,$(SYSTEM)),)
+	$(INSTALL) -d -m 0755 "$(DESTDIR)$(BINDIR)"
+	$(INSTALL) -m 0755 $(LIB.SHARED.DIR)/$(LIB.SHARED) "$(DESTDIR)$(BINDIR)/"
+else
+	$(INSTALL) -m 0644 $(LIB.SHARED.DIR)/$(LIB.SHARED) "$(DESTDIR)$(LIBDIR)/"
+endif
+ifneq ($(LN),)
+	$(LN) $(LIB.SHARED) "$(DESTDIR)$(LIBDIR)/$(LIB.SONAME)"
+endif
+
+# development files
+ifeq ($(filter-out mingw% cygwin,$(SYSTEM)),)
+	$(INSTALL) -m 0644 lib/$(LIB.DEVLNK) "$(DESTDIR)$(LIBDIR)/"
+endif
+ifneq ($(LN),)
+	$(LN) $(LIB.SHARED) "$(DESTDIR)$(LIBDIR)/$(LIB.DEVLNK)"
+endif
+	$(INSTALL) -m 0644 lib/$(LIB.STATIC) "$(DESTDIR)$(LIBDIR)/"
+
+install.bin: glew.bin
+	$(INSTALL) -d -m 0755 "$(DESTDIR)$(BINDIR)"
+	$(INSTALL)    -m 0755 bin/$(GLEWINFO.BIN) bin/$(VISUALINFO.BIN) "$(DESTDIR)$(BINDIR)/"
+
+install.include:
+	$(INSTALL) -d -m 0755 "$(DESTDIR)$(INCDIR)"
+	$(INSTALL) -m 0644 include/GL/eglew.h "$(DESTDIR)$(INCDIR)/"
+	$(INSTALL) -m 0644 include/GL/wglew.h "$(DESTDIR)$(INCDIR)/"
+	$(INSTALL) -m 0644 include/GL/glew.h "$(DESTDIR)$(INCDIR)/"
+	$(INSTALL) -m 0644 include/GL/glxew.h "$(DESTDIR)$(INCDIR)/"
+	$(INSTALL) -m 0644 include/GL/eglew.h "$(DESTDIR)$(INCDIR)/"
+
+install.pkgconfig: glew.pc
+	$(INSTALL) -d -m 0755 "$(DESTDIR)$(PKGDIR)"
+	$(INSTALL) -d -m 0755 "$(DESTDIR)$(PKGDIR)"
+	$(INSTALL) -m 0644 glew.pc "$(DESTDIR)$(PKGDIR)/"
+
+uninstall:
+	$(RM) "$(DESTDIR)$(INCDIR)/eglew.h"
+	$(RM) "$(DESTDIR)$(INCDIR)/wglew.h"
+	$(RM) "$(DESTDIR)$(INCDIR)/glew.h"
+	$(RM) "$(DESTDIR)$(INCDIR)/glxew.h"
+	$(RM) "$(DESTDIR)$(LIBDIR)/$(LIB.DEVLNK)"
+ifeq ($(filter-out mingw% cygwin,$(SYSTEM)),)
+	$(RM) "$(DESTDIR)$(BINDIR)/$(LIB.SHARED)"
+else
+	$(RM) "$(DESTDIR)$(LIBDIR)/$(LIB.SONAME)"
+	$(RM) "$(DESTDIR)$(LIBDIR)/$(LIB.SHARED)"
+endif
+	$(RM) "$(DESTDIR)$(LIBDIR)/$(LIB.STATIC)"
+	$(RM) "$(DESTDIR)$(BINDIR)/$(GLEWINFO.BIN)" "$(DESTDIR)$(BINDIR)/$(VISUALINFO.BIN)"
+
+clean:
+	$(RM) -r tmp/
+	$(RM) -r lib/
+	$(RM) -r bin/
+	$(RM) glew.pc
+
+distclean: clean
+	find . -name \*~ | xargs $(RM)
+	find . -name .\*.sw\? | xargs $(RM)
+
+# Distributions
+
+dist-win32:
+	$(RM) -r $(DIST_DIR)
+	mkdir -p $(DIST_DIR)
+	cp -a include $(DIST_DIR)
+	cp -a doc $(DIST_DIR)
+	cp -a *.txt $(DIST_DIR)
+	cp -a bin $(DIST_DIR)
+	cp -a lib $(DIST_DIR)
+	$(RM) -f $(DIST_DIR)/bin/*/*/*.pdb $(DIST_DIR)/bin/*/*/*.exp
+	$(RM) -f $(DIST_DIR)/bin/*/*/glewinfo-*.exe $(DIST_DIR)/bin/*/*/visualinfo-*.exe 
+	$(RM) -f $(DIST_DIR)/lib/*/*/*.pdb $(DIST_DIR)/lib/*/*/*.exp
+	$(UNIX2DOS) $(DIST_DIR)/include/GL/*.h
+	$(UNIX2DOS) $(DIST_DIR)/doc/*.txt
+	$(UNIX2DOS) $(DIST_DIR)/doc/*.html
+	$(UNIX2DOS) $(DIST_DIR)/*.txt
+	rm -f $(DIST_WIN32)
+	cd $(DIST_DIR)/.. && zip -rq9 $(DIST_WIN32) $(DIST_NAME)
+	$(RM) -r $(DIST_DIR)
+
+dist-src:
+	$(RM) -r $(DIST_DIR)
+	mkdir -p $(DIST_DIR)
+	mkdir -p $(DIST_DIR)/bin
+	mkdir -p $(DIST_DIR)/lib
+	cp -a auto $(DIST_DIR)
+	$(RM) -Rf $(DIST_DIR)/auto/registry
+	$(RM) -Rf $(DIST_DIR)/auto/glfixes
+	$(RM) -Rf $(DIST_DIR)/auto/OpenGL-Registry
+	$(RM) -Rf $(DIST_DIR)/auto/EGL-Registry
+	cp -a build $(DIST_DIR)
+	cp -a config $(DIST_DIR)
+	cp -a src $(DIST_DIR)
+	cp -a doc $(DIST_DIR)
+	cp -a include $(DIST_DIR)
+	cp -a *.md $(DIST_DIR)
+	cp -a *.txt $(DIST_DIR)
+	cp -a Makefile $(DIST_DIR)
+	cp -a glew.pc.in $(DIST_DIR)
+	find $(DIST_DIR) -name '*.o' | xargs $(RM) -r
+	find $(DIST_DIR) -name '*~' | xargs $(RM) -r
+	find $(DIST_DIR) -name CVS -o -name .cvsignore | xargs $(RM) -r
+	find $(DIST_DIR) -name .svn | xargs $(RM) -r
+	find $(DIST_DIR) -name "*.patch" | xargs $(RM) -r
+	$(DOS2UNIX) $(DIST_DIR)/Makefile
+	$(DOS2UNIX) $(DIST_DIR)/auto/Makefile
+	$(DOS2UNIX) $(DIST_DIR)/config/*
+	$(UNIX2DOS) $(DIST_DIR)/auto/core/*
+	$(UNIX2DOS) $(DIST_DIR)/auto/extensions/*
+	find $(DIST_DIR) -name '*.h' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.c' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.md' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.txt' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.html' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.css' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.sh' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.pl' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name 'Makefile' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.in' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.pm' | xargs $(UNIX2DOS)
+	find $(DIST_DIR) -name '*.rc' | xargs $(UNIX2DOS)
+	rm -f $(DIST_SRC_ZIP)
+	cd $(DIST_DIR)/.. && zip -rq9 $(DIST_SRC_ZIP) $(DIST_NAME)
+	$(DOS2UNIX) $(DIST_DIR)/Makefile
+	$(DOS2UNIX) $(DIST_DIR)/auto/Makefile
+	$(DOS2UNIX) $(DIST_DIR)/config/*
+	$(DOS2UNIX) $(DIST_DIR)/auto/core/*
+	$(DOS2UNIX) $(DIST_DIR)/auto/extensions/*
+	find $(DIST_DIR) -name '*.h' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.c' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.md' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.txt' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.html' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.css' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.sh' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.pl' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name 'Makefile' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.in' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.pm' | xargs $(DOS2UNIX)
+	find $(DIST_DIR) -name '*.rc' | xargs $(DOS2UNIX)
+	rm -f $(DIST_SRC_TGZ)
+	cd $(DIST_DIR)/.. && env GZIP=-9 tar czf $(DIST_SRC_TGZ) $(DIST_NAME)
+	$(RM) -r $(DIST_DIR)
+
+extensions:
+	$(MAKE) -C auto
+
+.PHONY: clean distclean tardist dist-win32 dist-src

Libraries/glew-2.3.1/README.md

@@ -0,0 +1,253 @@
+# GLEW - The OpenGL Extension Wrangler Library
+
+The OpenGL Extension Wrangler Library (GLEW) is a cross-platform open-source C/C++ extension loading library. GLEW provides efficient run-time mechanisms for determining which OpenGL extensions are supported on the target platform. OpenGL core and extension functionality is exposed in a single header file. GLEW has been tested on a variety of operating systems, including Windows, Linux, Mac OS X, FreeBSD, Irix, and Solaris.
+
+[![](http://glew.sourceforge.net/glew.png)](https://github.com/nigels-com/glew)
+
+https://github.com/nigels-com/glew
+
+[![GitHub Stars](https://img.shields.io/github/stars/nigels-com/glew)](https://github.com/nigels-com/glew)
+![Contributors](https://img.shields.io/github/contributors/nigels-com/glew)
+[![Commits since release](https://img.shields.io/github/commits-since/nigels-com/glew/latest)](https://github.com/nigels-com/glew/commits/master/)
+[![Issues](https://img.shields.io/github/issues/nigels-com/glew)](https://github.com/nigels-com/glew/issues)
+[![Pull Requests](https://img.shields.io/github/issues-pr/nigels-com/glew)](https://github.com/nigels-com/glew/pulls)
+
+[![GitHub Downloads](https://img.shields.io/github/downloads/nigels-com/glew/latest/total)](https://github.com/nigels-com/glew/releases)
+[![SourceForge Downloads](https://img.shields.io/sourceforge/dm/glew.svg)](https://sourceforge.net/projects/glew/files/latest/download)
+[![Health](https://codebuild.ap-southeast-2.amazonaws.com/badges?uuid=eyJlbmNyeXB0ZWREYXRhIjoiZ0cxMFNORFBPTGQ5Z1MyRUsxRnU5V1ZyOUNUWmZZRFJwNWdBNng5MnNtdFFObGNsTEJkQkxZa0lHYmtMNEZRREZaZmdvMUh2bDMxVjhFc3c2L29odFQ4PSIsIml2UGFyYW1ldGVyU3BlYyI6InhLVlFqWXVaMEZRVFh6c1QiLCJtYXRlcmlhbFNldFNlcmlhbCI6MX0%3D&branch=master)](https://ap-southeast-2.codebuild.aws.amazon.com/project/eyJlbmNyeXB0ZWREYXRhIjoiK3RLWndGOVVkMWthbXRQZCtVTTNOQ0w2dEpxakZ1cVBTNDZ1UldGODdqUERSdkx0U21Nd0RFaGhQL1kycVlmNzh2OXpEYnRKV3hXTVJJdjUvVStCbTl0dkliZm5jRTFsc0VBPSIsIml2UGFyYW1ldGVyU3BlYyI6ImZ0ekRoMkNjaU0rRUt5K2UiLCJtYXRlcmlhbFNldFNlcmlhbCI6MX0%3D)
+
+## Table of Contents
+
+* [Downloads](#downloads)
+* [Build](#build)
+	* [Linux and Mac](#linux-and-mac)
+		* [Using GNU Make](#using-gnu-make)
+		* [Install build tools](#install-build-tools)
+		* [Build](#build-1)
+		* [Linux EGL](#linux-egl)
+		* [Linux OSMesa](#linux-osmesa)
+		* [Linux mingw-w64](#linux-mingw-w64)
+	* [Using cmake](#using-cmake)
+		* [Install build tools](#install-build-tools-1)
+		* [Build](#build-2)
+	* [Windows](#windows)
+		* [Visual Studio](#visual-studio)
+		* [MSYS/Mingw](#msysmingw)
+		* [MSYS2/Mingw-w64](#msys2mingw-w64)
+* [glewinfo](#glewinfo)
+* [Code Generation](#code-generation)
+* [Authors](#authors)
+* [Contributions](#contributions)
+* [Copyright and Licensing](#copyright-and-licensing)
+
+## Downloads
+
+Current release is [2.3.0](https://github.com/nigels-com/glew/releases/tag/glew-2.3.0).
+[(Change Log)](http://glew.sourceforge.net/log.html)
+
+Sources available as
+[ZIP](https://github.com/nigels-com/glew/releases/download/glew-2.3.0/glew-2.3.0.zip) or
+[TGZ](https://github.com/nigels-com/glew/releases/download/glew-2.3.0/glew-2.3.0.tgz).
+
+Windows binaries for [32-bit and 64-bit](https://github.com/nigels-com/glew/releases/download/glew-2.3.0/glew-2.3.0-win32.zip).
+
+## Build
+
+It is highly recommended to build from a tgz or zip release snapshot.
+The code generation workflow is a complex brew of gnu make, perl and python, that works best on Linux or Mac.
+The code generation is known to work on Windows using [MSYS2](https://www.msys2.org/).
+For most end-users of GLEW the official releases are the best choice, with first class support.
+
+### Linux and Mac
+
+#### Using GNU Make
+
+GNU make is the primary build system for GLEW, historically.
+It includes targets for building the sources and headers, for maintenance purposes.
+
+##### Install build tools
+
+Debian/Ubuntu/Mint:    `$ sudo apt-get install build-essential libxmu-dev libxi-dev libgl-dev`
+
+RedHat/CentOS/Fedora:  `$ sudo yum install libXmu-devel libXi-devel libGL-devel`
+
+FreeBSD: `# pkg install xorg lang/gcc git cmake gmake bash python perl5`
+
+##### Build
+
+	$ make
+	$ sudo make install
+	$ make clean
+
+Targets:    `all, glew.lib (sub-targets: glew.lib.shared, glew.lib.static), glew.bin, clean, install, uninstall`
+
+Variables:  `SYSTEM=linux-clang, GLEW_DEST=/usr/local, STRIP=`
+
+_Note: you may need to call `make` in the  **auto** folder first_
+
+##### Linux EGL
+
+	$ sudo apt install libegl1-mesa-dev
+	$ make SYSTEM=linux-egl
+
+##### Linux OSMesa
+
+	$ sudo apt install libosmesa-dev
+	$ make SYSTEM=linux-osmesa
+
+##### Linux mingw-w64
+
+	$ sudo apt install mingw-w64
+	$ make SYSTEM=linux-mingw32
+	$ make SYSTEM=linux-mingw64
+
+#### Using cmake
+
+The cmake build is mostly contributor maintained.
+Due to the multitude of use cases this is maintained on a _best effort_ basis.
+Pull requests are welcome.
+
+*CMake 3.16 or higher is required.*
+
+##### Install build tools
+
+Debian/Ubuntu/Mint:   `$ sudo apt-get install build-essential libxmu-dev libxi-dev libgl-dev cmake git`
+
+RedHat/CentOS/Fedora: `$ sudo yum install libXmu-devel libXi-devel libGL-devel cmake git`
+
+##### Build
+
+	$ cd build
+	$ cmake ./cmake
+	$ make -j4
+
+| Target     | Description |
+| ---------- | ----------- |
+| glew       | Build the glew shared library. |
+| glew_s     | Build the glew static library. |
+| glewinfo   | Build the `glewinfo` executable (requires `BUILD_UTILS` to be `ON`). |
+| visualinfo | Build the `visualinfo` executable (requires `BUILD_UTILS` to be `ON`). |
+| install    | Install all enabled targets into `CMAKE_INSTALL_PREFIX`. |
+| clean      | Clean up build artifacts. |
+| all        | Build all enabled targets (default target). |
+
+| Variables       | Description |
+| --------------- | ----------- |
+| BUILD_UTILS     | Build the `glewinfo` and `visualinfo` executables. |
+| GLEW_REGAL      | Build in Regal mode. |
+| GLEW_OSMESA     | Build in off-screen Mesa mode. |
+| BUILD_FRAMEWORK | Build as MacOSX Framework.  Setting `CMAKE_INSTALL_PREFIX` to `/Library/Frameworks` is recommended. |
+
+### Windows
+
+#### Visual Studio
+
+Use the provided Visual Studio project file in build/vc15/
+
+Projects for vc6, vc10, vc12 and vc14 are also provided
+
+#### MSYS/Mingw
+
+Available from [Mingw](http://www.mingw.org/)
+
+Requirements: bash, make, gcc
+
+	$ mingw32-make
+	$ mingw32-make install
+	$ mingw32-make install.all
+
+Alternative toolchain:  `SYSTEM=mingw-win32`
+
+#### MSYS2/Mingw-w64
+
+Available from [Msys2](http://msys2.github.io/) and/or [Mingw-w64](http://mingw-w64.org/)
+
+Requirements: bash, make, gcc
+
+	$ pacman -S gcc make mingw-w64-i686-gcc mingw-w64-x86_64-gcc
+	$ make
+	$ make install
+	$ make install.all
+
+Alternative toolchain:  `SYSTEM=msys, SYSTEM=msys-win32, SYSTEM=msys-win64`
+
+## glewinfo
+
+`glewinfo` is a command-line tool useful for inspecting the capabilities of an
+OpenGL implementation and GLEW support for that.  Please include `glewinfo.txt`
+with bug reports, as appropriate.
+
+	---------------------------
+	    GLEW Extension Info
+	---------------------------
+
+	GLEW version 2.0.0
+	Reporting capabilities of pixelformat 3
+	Running on a Intel(R) HD Graphics 3000 from Intel
+	OpenGL version 3.1.0 - Build 9.17.10.4229 is supported
+
+	GL_VERSION_1_1:                                                OK
+	---------------
+
+	GL_VERSION_1_2:                                                OK
+	---------------
+	  glCopyTexSubImage3D:                                         OK
+	  glDrawRangeElements:                                         OK
+	  glTexImage3D:                                                OK
+	  glTexSubImage3D:                                             OK
+
+	...
+
+## Code Generation
+
+A Unix or Mac environment is needed for building GLEW from scratch to
+include new extensions, or customize the code generation. The extension
+data is regenerated from the top level source directory with:
+
+	make extensions
+
+An alternative to generating the GLEW sources from scratch is to
+download a pre-generated (unsupported) snapshot:
+
+https://sourceforge.net/projects/glew/files/glew/snapshots/
+
+## Authors
+
+GLEW is currently maintained by [Nigel Stewart](https://github.com/nigels-com)
+with bug fixes, new OpenGL extension support and new releases.
+
+GLEW was developed by [Milan Ikits](http://www.cs.utah.edu/~ikits/)
+and [Marcelo Magallon](http://wwwvis.informatik.uni-stuttgart.de/~magallon/).
+Aaron Lefohn, Joe Kniss, and Chris Wyman were the first users and also
+assisted with the design and debugging process.
+
+The acronym GLEW originates from Aaron Lefohn.
+Pasi Kärkkäinen identified and fixed several problems with
+GLX and SDL.  Nate Robins created the `wglinfo` utility, to
+which modifications were made by Michael Wimmer.
+
+## Contributions
+
+GLEW welcomes community contributions.  Typically these are co-ordinated
+via [Issues](https://github.com/nigels-com/glew/issues) or
+[Pull Requests](https://github.com/nigels-com/glew/pulls) in the
+GitHub web interface.
+
+Be sure to mention platform and compiler toolchain details when filing
+a bug report.  The output of `glewinfo` can be quite useful for discussion
+also.
+
+Generally GLEW is usually released once a year, around the time of the Siggraph
+computer graphics conference.  If you're not using the current release
+version of GLEW, be sure to check if the issue or bug is fixed there.
+
+## Copyright and Licensing
+
+GLEW is originally derived from the EXTGL project by Lev Povalahev.
+The source code is licensed under the
+[Modified BSD License](http://glew.sourceforge.net/glew.txt), the
+[Mesa 3-D License](http://glew.sourceforge.net/mesa.txt) (MIT) and the
+[Khronos License](http://glew.sourceforge.net/khronos.txt) (MIT).
+
+The automatic code generation scripts are released under the
+[GNU GPL](http://glew.sourceforge.net/gpl.txt).

Libraries/glew-2.3.1/auto/Makefile

@@ -0,0 +1,376 @@
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+include ../config/version
+
+#GLEW_SPLIT_SOURCE = yes
+
+SHELL = bash
+PYTHON ?= python
+
+EXT          = extensions/gl
+CORE         = core/gl
+
+REPO_OPENGL  ?= https://github.com/KhronosGroup/OpenGL-Registry.git
+REPO_EGL     ?= https://github.com/KhronosGroup/EGL-Registry.git
+REPO_GLFIXES ?= https://github.com/nigels-com/glfixes
+
+BIN = bin
+SRC = src
+BLACKLIST = blacklist
+
+GL_CORE_SPEC := $(CORE)/GL_VERSION*
+GLX_CORE_SPEC := $(CORE)/GLX_VERSION*
+EGL_CORE_SPEC := $(CORE)/EGL_VERSION*
+ifeq (custom,$(MAKECMDGOALS))
+#GL_CORE_SPEC  := $(shell grep GL_VERSION custom.txt    |                       perl -pi -e "s=^=$(CORE)/=g;")
+GL_EXT_SPEC    := $(shell grep "^[ \t]*GL_" custom.txt  | grep -v GL_VERSION  | perl -pi -e "s=^=$(EXT)/=g;")
+WGL_EXT_SPEC   := $(shell grep "^[ \t]*WGL_" custom.txt |                       perl -pi -e "s=^=$(EXT)/=g;")
+#GLX_CORE_SPEC := $(shell grep GLX_VERSION custom.txt   |                       perl -pi -e "s=^=$(CORE)/=g;")
+GLX_EXT_SPEC   := $(shell grep "^[ \t]*GLX_" custom.txt | grep -v GLX_VERSION | perl -pi -e "s=^=$(EXT)/=g;")
+EGL_EXT_SPEC   := $(shell grep "^[ \t]*EGL_" custom.txt | grep -v EGL_VERSION | perl -pi -e "s=^=$(EXT)/=g;")
+else
+GL_EXT_SPEC := $(EXT)/GL_*
+WGL_EXT_SPEC := $(EXT)/WGL_*
+GLX_EXT_SPEC := $(EXT)/GLX_*
+EGL_EXT_SPEC := $(EXT)/EGL_*
+endif
+
+PARSE_SPEC = parse_spec.pl
+SYSTEM = $(strip $(shell uname -s))
+
+TOP = ..
+I.DEST = $(TOP)/include/GL
+S.DEST = $(TOP)/src
+D.DEST = $(TOP)/doc
+B.DEST = $(TOP)/build
+
+I.TARGETS = \
+	$(I.DEST)/glew.h \
+	$(I.DEST)/wglew.h \
+	$(I.DEST)/glxew.h \
+	$(I.DEST)/eglew.h
+
+ifeq (yes,$(GLEW_SPLIT_SOURCE))
+S.TARGETS = \
+	$(S.DEST)/glew_def.c \
+	$(S.DEST)/glew_init.c \
+	$(S.DEST)/glew_str.c \
+	$(S.DEST)/glewinfo.c
+else
+S.TARGETS = \
+	$(S.DEST)/glew.c \
+	$(S.DEST)/glewinfo.c
+endif
+
+D.TARGETS = \
+	$(D.DEST)/index.html \
+	$(D.DEST)/install.html \
+	$(D.DEST)/basic.html \
+	$(D.DEST)/advanced.html \
+	$(D.DEST)/build.html \
+	$(D.DEST)/credits.html \
+	$(D.DEST)/log.html \
+	$(D.DEST)/glew.html \
+	$(D.DEST)/wglew.html \
+	$(D.DEST)/glxew.html \
+	$(D.DEST)/eglew.html
+
+B.TARGETS = \
+	$(B.DEST)/glew.rc \
+	$(B.DEST)/glewinfo.rc \
+	$(B.DEST)/visualinfo.rc
+
+all custom: $(I.TARGETS) $(S.TARGETS) $(D.TARGETS) $(B.TARGETS)
+
+ext: $(EXT)/.dummy
+
+OpenGL-Registry/.dummy:
+	@echo "--------------------------------------------------------------------"
+	@echo "Downloading OpenGL-Registry"
+	@echo "--------------------------------------------------------------------"
+	git clone --depth=1 $(REPO_OPENGL) OpenGL-Registry
+	git clone --depth=1 --branch glew $(REPO_GLFIXES) glfixes
+	touch $@
+
+EGL-Registry/.dummy:
+	@echo "--------------------------------------------------------------------"
+	@echo "Downloading EGL-Registry"
+	@echo "--------------------------------------------------------------------"
+	git clone --depth=1 $(REPO_EGL) EGL-Registry
+	touch $@
+
+$(EXT)/.dummy: OpenGL-Registry/.dummy EGL-Registry/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "OpenGL descriptors"
+	@echo "--------------------------------------------------------------------"
+	rm -rf $(EXT)
+	cp -r glfixes/gl/specs/ANGLE OpenGL-Registry/extensions
+	cp -r glfixes/gl/specs/REGAL OpenGL-Registry/extensions
+	$(BIN)/update_ext.sh $(EXT) OpenGL-Registry/extensions $(BLACKLIST)
+	@echo "--------------------------------------------------------------------"
+	@echo "WGL descriptors"
+	@echo "--------------------------------------------------------------------"
+	rm -f $(EXT)/WGL_*
+	$(PYTHON) $(BIN)/parse_xml.py OpenGL-Registry/xml/wgl.xml --api wgl --extensions extensions/gl
+	@echo "--------------------------------------------------------------------"
+	@echo "GLX descriptors"
+	@echo "--------------------------------------------------------------------"
+	rm -f $(EXT)/GLX_*
+	$(PYTHON) $(BIN)/parse_xml.py OpenGL-Registry/xml/glx.xml --api glx --extensions extensions/gl
+	@echo "--------------------------------------------------------------------"
+	@echo "EGL descriptors"
+	@echo "--------------------------------------------------------------------"
+	$(PYTHON) $(BIN)/parse_xml.py EGL-Registry/api/egl.xml --api egl --extensions extensions/gl
+	@echo "--------------------------------------------------------------------"
+	@echo "filter descriptors"
+	@echo "--------------------------------------------------------------------"
+	$(BIN)/filter_gl_ext.sh $(EXT)
+ifeq ($(patsubst Darwin%,Darwin,$(SYSTEM)), Darwin)
+	find $(CORE) -maxdepth 1 -type f | grep -v VERSION | grep -v "~" | \
+	xargs -J % cp % $(EXT)
+else
+	find $(CORE) -maxdepth 1 -type f | grep -v VERSION | grep -v "~" | \
+	xargs -I % -n 1 cp % $(EXT)
+endif
+	touch $@
+
+$(I.DEST)/glew.h: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating glew.h"
+	@echo "--------------------------------------------------------------------"
+	test -d $(I.DEST) || mkdir -p $(I.DEST)
+	cp -f $(SRC)/glew_license.h $@
+	cat $(SRC)/mesa_license.h >> $@
+	cat $(SRC)/khronos_license.h >> $@
+	cat $(SRC)/glew_head.h >> $@
+	$(BIN)/make_header.pl GLAPIENTRY GL $(GL_CORE_SPEC) >> $@
+	$(BIN)/make_header.pl GLAPIENTRY GL $(GL_EXT_SPEC) >> $@
+	echo -e "/* ------------------------------------------------------------------------- */\n\n" >> $@
+	$(BIN)/make_struct_fun.pl GLEW_FUN_EXPORT $(GL_CORE_SPEC) $(GL_EXT_SPEC) >> $@
+	$(BIN)/make_struct_var.pl GLEW_VAR_EXPORT $(GL_CORE_SPEC) $(GL_EXT_SPEC) >> $@
+	perl -e "s/GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_2;/GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_1;\nGLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_2;/" -pi $@
+	cat $(SRC)/glew_tail.h >> $@
+	perl -e "s/GLEW_VERSION_STRING/$(GLEW_VERSION)/g" -pi $@
+	perl -e "s/GLEW_VERSION_MAJOR_STRING/$(GLEW_MAJOR)/g" -pi $@
+	perl -e "s/GLEW_VERSION_MINOR_STRING/$(GLEW_MINOR)/g" -pi $@
+	perl -e "s/GLEW_VERSION_MICRO_STRING/$(GLEW_MICRO)/g" -pi $@
+	rm -f $@.bak
+
+$(I.DEST)/wglew.h: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating wglew.h"
+	@echo "--------------------------------------------------------------------"
+	cp -f $(SRC)/glew_license.h $@
+	cat $(SRC)/khronos_license.h >> $@
+	cat $(SRC)/wglew_head.h >> $@
+	$(BIN)/make_header.pl WINAPI WGL $(WGL_EXT_SPEC) >> $@
+	cat $(SRC)/wglew_mid.h >> $@
+	$(BIN)/make_struct_fun.pl WGLEW_FUN_EXPORT $(WGL_EXT_SPEC) >> $@
+	$(BIN)/make_struct_var.pl WGLEW_VAR_EXPORT $(WGL_EXT_SPEC) >> $@
+	cat $(SRC)/wglew_tail.h >> $@
+
+$(I.DEST)/glxew.h: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating glxew.h"
+	@echo "--------------------------------------------------------------------"
+	cp -f $(SRC)/glew_license.h $@
+	cat $(SRC)/mesa_license.h >> $@
+	cat $(SRC)/khronos_license.h >> $@
+	cat $(SRC)/glxew_head.h >> $@
+	$(BIN)/make_header.pl "" GLX $(GLX_CORE_SPEC) >> $@
+	$(BIN)/make_header.pl "" GLX $(GLX_EXT_SPEC) >> $@
+	cat $(SRC)/glxew_mid.h >> $@
+	$(BIN)/make_struct_fun.pl GLXEW_FUN_EXPORT $(GLX_CORE_SPEC) $(GLX_EXT_SPEC) >> $@
+	$(BIN)/make_struct_var.pl GLXEW_VAR_EXPORT $(GLX_CORE_SPEC) $(GLX_EXT_SPEC) >> $@
+	perl -e "s/GLXEW_VAR_EXPORT GLboolean __GLXEW_VERSION_1_2;/GLXEW_VAR_EXPORT GLboolean __GLXEW_VERSION_1_0;\nGLXEW_VAR_EXPORT GLboolean __GLXEW_VERSION_1_1;\nGLXEW_VAR_EXPORT GLboolean __GLXEW_VERSION_1_2;/" -pi $@
+	cat $(SRC)/glxew_tail.h >> $@
+
+$(I.DEST)/eglew.h: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating eglew.h"
+	@echo "--------------------------------------------------------------------"
+	cp -f $(SRC)/glew_license.h $@
+	cat $(SRC)/mesa_license.h >> $@
+	cat $(SRC)/khronos_license.h >> $@
+	cat $(SRC)/eglew_head.h >> $@
+	$(BIN)/make_header.pl "" EGL $(EGL_CORE_SPEC) >> $@
+	$(BIN)/make_header.pl "" EGL $(EGL_EXT_SPEC) >> $@
+	cat $(SRC)/eglew_mid.h >> $@
+	$(BIN)/make_struct_fun.pl EGLEW_FUN_EXPORT $(EGL_CORE_SPEC) $(EGL_EXT_SPEC) >> $@
+	$(BIN)/make_struct_var.pl EGLEW_VAR_EXPORT $(EGL_CORE_SPEC) $(EGL_EXT_SPEC) >> $@
+	cat $(SRC)/eglew_tail.h >> $@
+
+$(S.DEST)/glew.c: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating glew.c"
+	@echo "--------------------------------------------------------------------"
+	cp -f $(SRC)/glew_license.h $@
+	cat $(SRC)/glew_head.c >> $@
+	$(BIN)/make_def_fun.pl GL $(GL_CORE_SPEC) >> $@
+	$(BIN)/make_def_fun.pl GL $(GL_EXT_SPEC) >> $@
+	echo -e "\nGLboolean __GLEW_VERSION_1_1 = GL_FALSE;" >> $@
+	$(BIN)/make_def_var.pl GL $(GL_CORE_SPEC) >> $@
+	$(BIN)/make_def_var.pl GL $(GL_EXT_SPEC) >> $@
+	echo -e "\nstatic const char * _glewExtensionLookup[] = {" >> $@;
+	$(BIN)/make_index.pl $(GL_CORE_SPEC) $(GL_EXT_SPEC) >> $@
+	echo -e "  NULL\n};\n\n" >> $@;
+	$(BIN)/make_enable_index.pl $(GL_CORE_SPEC) $(GL_EXT_SPEC) >> $@
+	$(BIN)/make_initd.pl GL $(GL_CORE_SPEC) >> $@
+	$(BIN)/make_initd.pl GL $(GL_EXT_SPEC) >> $@
+	echo -e "" >> $@;
+	$(BIN)/make_init.pl GL $(GL_CORE_SPEC) >> $@
+	$(BIN)/make_init.pl GL $(GL_EXT_SPEC) >> $@
+	cat $(SRC)/glew_init_gl.c >> $@
+	$(BIN)/make_list.pl $(GL_CORE_SPEC) | grep -v '\"GL_VERSION' >> $@
+	$(BIN)/make_list.pl $(GL_EXT_SPEC) >> $@
+	$(BIN)/make_list2.pl $(GL_EXT_SPEC) >> $@
+	echo -e "\n  return GLEW_OK;\n}\n" >> $@
+	echo -e "\n#if defined(GLEW_OSMESA)" >> $@
+	echo -e "\n#elif defined(GLEW_EGL)" >> $@
+	$(BIN)/make_def_fun.pl EGL $(EGL_CORE_SPEC) >> $@
+	$(BIN)/make_def_fun.pl EGL $(EGL_EXT_SPEC) >> $@
+	$(BIN)/make_def_var.pl EGL $(EGL_CORE_SPEC) >> $@
+	$(BIN)/make_def_var.pl EGL $(EGL_EXT_SPEC) >> $@
+	$(BIN)/make_init.pl EGL $(EGL_CORE_SPEC) >> $@
+	$(BIN)/make_init.pl EGL $(EGL_EXT_SPEC) >> $@
+	cat $(SRC)/glew_init_egl.c >> $@
+	$(BIN)/make_list.pl $(EGL_CORE_SPEC) >> $@
+	$(BIN)/make_list.pl $(EGL_EXT_SPEC) >> $@
+	echo -e "\n  return GLEW_OK;\n}" >> $@
+	echo -e "\n#elif defined(_WIN32)" >> $@
+	$(BIN)/make_def_fun.pl WGL $(WGL_EXT_SPEC) >> $@
+	$(BIN)/make_def_var.pl WGL $(WGL_EXT_SPEC) >> $@
+	$(BIN)/make_init.pl WGL $(WGL_EXT_SPEC) >> $@
+	cat $(SRC)/glew_init_wgl.c >> $@
+	$(BIN)/make_list.pl $(WGL_EXT_SPEC) >> $@
+	echo -e "\n  return GLEW_OK;\n}" >> $@;
+	echo -e "\n#elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX))" >> $@
+	$(BIN)/make_def_fun.pl GLX $(GLX_CORE_SPEC) >> $@
+	$(BIN)/make_def_fun.pl GLX $(GLX_EXT_SPEC) >> $@
+	echo -e "\nGLboolean __GLXEW_VERSION_1_0 = GL_FALSE;" >> $@
+	echo -e "GLboolean __GLXEW_VERSION_1_1 = GL_FALSE;" >> $@
+	$(BIN)/make_def_var.pl GLX $(GLX_CORE_SPEC) >> $@
+	$(BIN)/make_def_var.pl GLX $(GLX_EXT_SPEC) >> $@
+	$(BIN)/make_init.pl GLX $(GLX_CORE_SPEC) >> $@
+	$(BIN)/make_init.pl GLX $(GLX_EXT_SPEC) >> $@
+	cat $(SRC)/glew_init_glx.c >> $@
+	$(BIN)/make_list.pl $(CORE)/GLX_VERSION_1_3 | grep -v '\"GLX_VERSION' >> $@
+	$(BIN)/make_list.pl $(GLX_EXT_SPEC) >> $@
+	echo -e "\n  return GLEW_OK;\n}" >> $@
+	echo -e "\n#endif /* !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) */\n" >> $@;
+	cat $(SRC)/glew_init_tail.c >> $@
+	cat $(SRC)/glew_str_head.c >> $@
+	$(BIN)/make_str.pl $(GL_CORE_SPEC) $(GL_EXT_SPEC) >> $@
+	cat $(SRC)/glew_str_wgl.c >> $@
+	$(BIN)/make_str.pl $(WGL_EXT_SPEC) >> $@
+	cat $(SRC)/glew_str_glx.c >> $@
+	$(BIN)/make_str.pl $(GLX_CORE_SPEC) $(GLX_EXT_SPEC) >> $@
+	cat $(SRC)/glew_str_egl.c >> $@
+	$(BIN)/make_str.pl $(EGL_CORE_SPEC) $(EGL_EXT_SPEC) >> $@
+	cat $(SRC)/glew_str_tail.c >> $@
+	perl -e "s/GLEW_VERSION_STRING/$(GLEW_VERSION)/g" -pi $@
+	perl -e "s/GLEW_VERSION_MAJOR_STRING/$(GLEW_MAJOR)/g" -pi $@
+	perl -e "s/GLEW_VERSION_MINOR_STRING/$(GLEW_MINOR)/g" -pi $@
+	perl -e "s/GLEW_VERSION_MICRO_STRING/$(GLEW_MICRO)/g" -pi $@
+	perl -e "s/GLEW_ARB_vertex_shader = !_glewInit_GL_ARB_vertex_shader\(\);/{ GLEW_ARB_vertex_shader = !_glewInit_GL_ARB_vertex_shader(); _glewInit_GL_ARB_vertex_program(); }/g" -pi $@
+	perl -e "s/\(\(glColorSubTable = /((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)\"glBlendEquation\")) == NULL) || r;\n  r = ((glColorSubTable = /g" -pi $@
+	rm -f $@.bak
+
+$(S.DEST)/glewinfo.c: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating glewinfo.c"
+	@echo "--------------------------------------------------------------------"
+	cp -f $(SRC)/glew_license.h $@
+	cat $(SRC)/glewinfo_head.c >> $@
+	$(BIN)/make_info.pl $(GL_CORE_SPEC) >> $@
+	$(BIN)/make_info.pl $(GL_EXT_SPEC) >> $@
+	echo -e "#if defined(GLEW_EGL)\n" >> $@
+	$(BIN)/make_info.pl $(EGL_CORE_SPEC) >> $@
+	$(BIN)/make_info.pl $(EGL_EXT_SPEC) >> $@
+	echo -e "#elif _WIN32\n" >> $@
+	$(BIN)/make_info.pl $(WGL_EXT_SPEC) >> $@
+	echo -e "#else /* _UNIX */\n" >> $@
+	$(BIN)/make_info.pl $(GLX_CORE_SPEC) >> $@
+	$(BIN)/make_info.pl $(GLX_EXT_SPEC) >> $@
+	echo -e "#endif /* _WIN32 */\n" >> $@
+
+	cat $(SRC)/glewinfo_gl.c >> $@
+	$(BIN)/make_info_list.pl $(GL_CORE_SPEC) >> $@
+	$(BIN)/make_info_list.pl $(GL_EXT_SPEC) >> $@
+	cat $(SRC)/glewinfo_wgl.c >> $@
+	$(BIN)/make_info_list.pl $(WGL_EXT_SPEC) >> $@
+	cat $(SRC)/glewinfo_glx.c >> $@
+	$(BIN)/make_info_list.pl $(GLX_CORE_SPEC) >> $@
+	$(BIN)/make_info_list.pl $(GLX_EXT_SPEC) >> $@
+	cat $(SRC)/glewinfo_egl.c >> $@
+	$(BIN)/make_info_list.pl $(EGL_CORE_SPEC) >> $@
+	$(BIN)/make_info_list.pl $(EGL_EXT_SPEC) >> $@
+	cat $(SRC)/glewinfo_tail.c >> $@
+	perl -e 's/"glColorSubTable"/"glBlendEquation", glBlendEquation == NULL);\n  glewInfoFunc(fi, "glColorSubTable"/g' -pi $@
+	rm -f $@.bak
+
+# Update documentation
+
+$(D.DEST)/%.html: doc/%.html
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating $(@F)"
+	@echo "--------------------------------------------------------------------"
+	cat $(SRC)/header.html $< $(SRC)/footer.html | \
+	perl -pe 's#<a href="$(@F)">(.*)</a>#\1#' > $@
+
+$(D.DEST)/glew.html: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating glew.html"
+	@echo "--------------------------------------------------------------------"
+	cp -f $(SRC)/header.html $@
+	echo -e "<h2>Supported OpenGL Extensions</h2>\n" >> $@
+	$(BIN)/make_html.pl $(GL_EXT_SPEC) >> $@
+	cat $(SRC)/footer.html >> $@
+	perl -i -pe 's#<a href="$(@F)">(.*)</a>#\1#' $@
+
+$(D.DEST)/wglew.html: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating wglew.html"
+	@echo "--------------------------------------------------------------------"
+	cp -f $(SRC)/header.html $@
+	echo -e "<h2>Supported WGL Extensions</h2>\n" >> $@
+	$(BIN)/make_html.pl $(WGL_EXT_SPEC) >> $@
+	cat $(SRC)/footer.html >> $@
+	perl -i -pe 's#<a href="$(@F)">(.*)</a>#\1#' $@
+
+$(D.DEST)/glxew.html: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating glxew.html"
+	@echo "--------------------------------------------------------------------"
+	cp -f $(SRC)/header.html $@
+	echo -e "<h2>Supported GLX Extensions</h2>\n" >> $@
+	$(BIN)/make_html.pl $(GLX_EXT_SPEC) >> $@
+	cat $(SRC)/footer.html >> $@
+	perl -i -pe 's#<a href="$(@F)">(.*)</a>#\1#' $@
+
+$(D.DEST)/eglew.html: $(EXT)/.dummy
+	@echo "--------------------------------------------------------------------"
+	@echo "Creating eglew.html"
+	@echo "--------------------------------------------------------------------"
+	cp -f $(SRC)/header.html $@
+	echo -e "<h2>Supported EGL Extensions</h2>\n" >> $@
+	$(BIN)/make_html.pl $(EGL_EXT_SPEC) >> $@
+	cat $(SRC)/footer.html >> $@
+	perl -i -pe 's#<a href="$(@F)">(.*)</a>#\1#' $@
+
+$(B.DEST)/%.rc: src/%.rc $(EXT)/.dummy
+	perl -e "s/GLEW_MAJOR/$(GLEW_MAJOR)/g;s/GLEW_MINOR/$(GLEW_MINOR)/g;s/GLEW_MICRO/$(GLEW_MICRO)/g;" -p $< > $@
+
+clean:
+	rm -rf $(I.TARGETS) $(S.TARGETS) $(D.TARGETS) $(B.TARGETS)
+
+clobber: clean
+	rm -rf $(EXT)
+
+destroy: clobber
+	rm -rf registry

Libraries/glew-2.3.1/auto/bin/filter_gl_ext.sh

@@ -0,0 +1,636 @@
+#!/usr/bin/env bash
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+##
+## Parameters:
+##
+##       $1: Extensions directory
+
+set -e
+
+# fix GL_NV_texture_compression_vtc
+    grep -v EXT $1/GL_NV_texture_compression_vtc > tmp
+    mv tmp $1/GL_NV_texture_compression_vtc
+
+# remove duplicates from GL_ARB_vertex_program and GL_ARB_fragment_program
+    tail -n +5 $1/GL_ARB_vertex_program > patterns
+    grep -v -F -f patterns $1/GL_ARB_fragment_program > tmp
+    mv tmp $1/GL_ARB_fragment_program
+
+# remove duplicates from GLX_EXT_visual_rating and GLX_EXT_visual_info
+    tail -n +5 $1/GLX_EXT_visual_info > patterns
+    grep -v -F -f patterns $1/GLX_EXT_visual_rating > tmp
+    mv tmp $1/GLX_EXT_visual_rating
+
+# GL_EXT_draw_buffers2 and GL_EXT_transform_feedback both define glGetBooleanIndexedvEXT but with different parameter names
+    grep -v glGetBooleanIndexedvEXT $1/GL_EXT_transform_feedback > tmp
+    mv tmp $1/GL_EXT_transform_feedback    
+
+# GL_EXT_draw_buffers2 and GL_EXT_transform_feedback both define glGetIntegerIndexedvEXT but with different parameter names
+    grep -v glGetIntegerIndexedvEXT $1/GL_EXT_transform_feedback > tmp
+    mv tmp $1/GL_EXT_transform_feedback    
+
+# remove duplicates from GL_NV_video_capture and GLX_NV_video_capture
+    grep -v glX $1/GL_NV_video_capture > tmp
+    mv tmp $1/GL_NV_video_capture
+
+# add missing functions to GL_NV_video_capture
+	cat >> $1/GL_NV_video_capture <<EOT
+    void glGetVideoCaptureStreamivNV (GLuint video_capture_slot, GLuint stream, GLenum pname, GLint* params)
+    void glGetVideoCaptureStreamfvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat* params)
+    void glGetVideoCaptureStreamdvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble* params)
+    void glVideoCaptureStreamParameterivNV (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint* params)
+    void glVideoCaptureStreamParameterfvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat* params)
+    void glVideoCaptureStreamParameterdvNV (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble* params)
+EOT
+
+# fix WGL_NV_video_capture
+    cat >> $1/WGL_NV_video_capture <<EOT
+    DECLARE_HANDLE(HVIDEOINPUTDEVICENV);
+EOT
+
+# fix GLX_NV_video_capture
+    cat >> $1/GLX_NV_video_capture <<EOT
+    typedef XID GLXVideoCaptureDeviceNV
+EOT
+
+# remove duplicates from GL_NV_present_video and GLX_NV_present_video
+    tail -n +5 $1/GLX_NV_present_video > patterns
+    grep -v -F -f patterns $1/GL_NV_present_video > tmp
+    mv tmp $1/GL_NV_present_video
+
+# fix WGL_NV_present_video
+    cat >> $1/WGL_NV_present_video <<EOT
+    DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV);
+EOT
+
+# fix WGL_NV_video_output
+    cat >> $1/WGL_NV_video_output <<EOT
+    DECLARE_HANDLE(HPVIDEODEV);
+EOT
+
+# fix GL_NV_occlusion_query and GL_HP_occlusion_test
+    grep -v '_HP' $1/GL_NV_occlusion_query > tmp
+    mv tmp $1/GL_NV_occlusion_query
+
+# add deprecated constants to GL_ATI_fragment_shader
+    cat >> $1/GL_ATI_fragment_shader <<EOT
+	GL_NUM_FRAGMENT_REGISTERS_ATI 0x896E
+	GL_NUM_FRAGMENT_CONSTANTS_ATI 0x896F
+	GL_NUM_PASSES_ATI 0x8970
+	GL_NUM_INSTRUCTIONS_PER_PASS_ATI 0x8971
+	GL_NUM_INSTRUCTIONS_TOTAL_ATI 0x8972
+	GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI 0x8973
+	GL_NUM_LOOPBACK_COMPONENTS_ATI 0x8974
+	GL_COLOR_ALPHA_PAIRING_ATI 0x8975
+	GL_SWIZZLE_STRQ_ATI 0x897A
+	GL_SWIZZLE_STRQ_DQ_ATI 0x897B
+EOT
+
+# add deprecated constants to GL_NV_texture_shader
+    cat >> $1/GL_NV_texture_shader <<EOT
+	GL_OFFSET_TEXTURE_2D_MATRIX_NV 0x86E1
+	GL_OFFSET_TEXTURE_2D_BIAS_NV 0x86E3
+	GL_OFFSET_TEXTURE_2D_SCALE_NV 0x86E2
+EOT
+	
+# fix WGL_ATI_pixel_format_float
+    cat >> $1/WGL_ATI_pixel_format_float <<EOT
+	GL_RGBA_FLOAT_MODE_ATI 0x8820
+	GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835
+EOT
+
+# fix WGL_ARB_make_current_read
+    cat >> $1/WGL_ARB_make_current_read <<EOT
+	ERROR_INVALID_PIXEL_TYPE_ARB 0x2043
+	ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054
+EOT
+
+# fix WGL_EXT_make_current_read
+    cat >> $1/WGL_EXT_make_current_read <<EOT
+	ERROR_INVALID_PIXEL_TYPE_EXT 0x2043
+EOT
+
+# add typedefs to GL_ARB_vertex_buffer_object; (from personal communication
+# with Marco Fabbricatore).
+#
+# Rationale.  The spec says:
+#
+#   "Both types are defined as signed integers large enough to contain
+#   any pointer value [...] The idea of making these types unsigned was
+#   considered, but was ultimately rejected ..."
+    cat >> $1/GL_ARB_vertex_buffer_object <<EOT
+	typedef ptrdiff_t GLsizeiptrARB
+	typedef ptrdiff_t GLintptrARB
+EOT
+
+# add typedefs to GLX_EXT_import_context
+    cat >> $1/GLX_EXT_import_context <<EOT
+	typedef XID GLXContextID
+EOT
+
+# add tokens to GLX_OML_swap_method
+    cat >> $1/GLX_OML_swap_method <<EOT
+	GLX_SWAP_EXCHANGE_OML 0x8061
+	GLX_SWAP_COPY_OML 0x8062
+	GLX_SWAP_UNDEFINED_OML 0x8063
+EOT
+
+# add typedefs to GLX_SGIX_fbconfig
+    cat >> $1/GLX_SGIX_fbconfig <<EOT
+	typedef XID GLXFBConfigIDSGIX
+	typedef struct __GLXFBConfigRec *GLXFBConfigSGIX
+EOT
+
+# Skip GLX_SGIX_dmbuffer and GLX_SGIX_video_source
+# unknown DMparams, DMbuffer, etc
+    rm -f $1/GLX_SGIX_dmbuffer
+    rm -f $1/GLX_SGIX_video_source
+
+# add typedefs to GLX_SGIX_pbuffer
+    cat >> $1/GLX_SGIX_pbuffer <<EOT
+    typedef XID GLXPbufferSGIX
+	typedef struct { int type; unsigned long serial; Bool send_event; Display *display; GLXDrawable drawable; int event_type; int draw_type; unsigned int mask; int x, y; int width, height; int count; } GLXBufferClobberEventSGIX
+EOT
+
+# add typedef to GL_NV_half_float
+    cat >> $1/GL_NV_half_float <<EOT
+	typedef unsigned short GLhalf
+EOT
+
+# add handle to WGL_ARB_pbuffer
+    cat >> $1/WGL_ARB_pbuffer <<EOT
+	DECLARE_HANDLE(HPBUFFERARB);
+EOT
+
+# add handle to WGL_EXT_pbuffer
+    cat >> $1/WGL_EXT_pbuffer <<EOT
+	DECLARE_HANDLE(HPBUFFEREXT);
+EOT
+
+# get rid of GL_SUN_multi_draw_arrays
+    rm -f $1/GL_SUN_multi_draw_arrays
+
+# change variable names in GL_ARB_vertex_shader
+    perl -e 's/v0/x/g' -pi $1/GL_ARB_vertex_shader
+    perl -e 's/v1/y/g' -pi $1/GL_ARB_vertex_shader
+    perl -e 's/v2/z/g' -pi $1/GL_ARB_vertex_shader
+    perl -e 's/v3/w/g' -pi $1/GL_ARB_vertex_shader
+
+# remove triplicates in GL_ARB_shader_objects, GL_ARB_fragment_shader, 
+# and GL_ARB_vertex_shader
+    tail -n +5 $1/GL_ARB_shader_objects > patterns
+    grep -v -F -f patterns $1/GL_ARB_fragment_shader > tmp
+    mv tmp $1/GL_ARB_fragment_shader
+    grep -v -F -f patterns $1/GL_ARB_vertex_shader > tmp
+    mv tmp $1/GL_ARB_vertex_shader
+
+# remove duplicates in GL_ARB_vertex_program and GL_ARB_vertex_shader
+    tail -n +5 $1/GL_ARB_vertex_program > patterns
+    grep -v -F -f patterns $1/GL_ARB_vertex_shader > tmp
+    mv tmp $1/GL_ARB_vertex_shader
+
+# remove triplicates in GL_ARB_fragment_program, GL_ARB_fragment_shader,
+# and GL_ARB_vertex_shader
+    tail -n +5 $1/GL_ARB_fragment_program > patterns
+    grep -v -F -f patterns $1/GL_ARB_fragment_shader > tmp
+    mv tmp $1/GL_ARB_fragment_shader
+    grep -v -F -f patterns $1/GL_ARB_vertex_shader > tmp
+    mv tmp $1/GL_ARB_vertex_shader
+
+# remove duplicates in GL_EXT_direct_state_access
+    grep -v "glGetBooleanIndexedvEXT" $1/GL_EXT_direct_state_access > tmp
+    mv tmp $1/GL_EXT_direct_state_access
+    grep -v "glGetIntegerIndexedvEXT" $1/GL_EXT_direct_state_access > tmp
+    mv tmp $1/GL_EXT_direct_state_access
+    grep -v "glDisableIndexedEXT" $1/GL_EXT_direct_state_access > tmp
+    mv tmp $1/GL_EXT_direct_state_access
+    grep -v "glEnableIndexedEXT" $1/GL_EXT_direct_state_access > tmp
+    mv tmp $1/GL_EXT_direct_state_access
+    grep -v "glIsEnabledIndexedEXT" $1/GL_EXT_direct_state_access > tmp
+    mv tmp $1/GL_EXT_direct_state_access
+
+# remove duplicates in GL_NV_explicit_multisample
+    grep -v "glGetBooleanIndexedvEXT" $1/GL_NV_explicit_multisample > tmp
+    mv tmp $1/GL_NV_explicit_multisample
+    grep -v "glGetIntegerIndexedvEXT" $1/GL_NV_explicit_multisample > tmp
+    mv tmp $1/GL_NV_explicit_multisample
+
+# fix bugs in GL_ARB_vertex_shader
+    grep -v "GL_FLOAT" $1/GL_ARB_vertex_shader > tmp
+    mv tmp $1/GL_ARB_vertex_shader
+    perl -e 's/handle /GLhandleARB /g' -pi $1/GL_ARB_vertex_shader
+
+# fix bugs in GL_ARB_shader_objects
+    grep -v "GL_FLOAT " $1/GL_ARB_shader_objects > tmp
+    mv tmp $1/GL_ARB_shader_objects
+    grep -v "GL_INT " $1/GL_ARB_shader_objects > tmp
+    mv tmp $1/GL_ARB_shader_objects
+
+# add typedefs to GL_ARB_shader_objects
+    cat >> $1/GL_ARB_shader_objects <<EOT
+	typedef char GLcharARB
+	typedef unsigned int GLhandleARB
+EOT
+
+# add missing functions to GL_ARB_transpose_matrix
+	cat >> $1/GL_ARB_transpose_matrix <<EOT
+	void glLoadTransposeMatrixfARB (GLfloat m[16])
+	void glLoadTransposeMatrixdARB (GLdouble m[16])
+	void glMultTransposeMatrixfARB (GLfloat m[16])
+	void glMultTransposeMatrixdARB (GLdouble m[16])
+EOT
+
+# add missing tokens to GL_EXT_framebuffer_multisample
+	cat >> $1/GL_EXT_framebuffer_multisample <<EOT
+	GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT 0x8D56
+	GL_MAX_SAMPLES_EXT 0x8D57
+EOT
+
+# Filter out GL_NV_gpu_program_fp64 enums and functions
+    head -n4 $1/GL_NV_gpu_program_fp64 > tmp
+    mv tmp $1/GL_NV_gpu_program_fp64
+
+# Filter glGetUniformui64vNV from GL_NV_shader_buffer_load
+    grep -v "glGetUniformui64vNV" $1/GL_NV_shader_buffer_load > tmp
+    mv tmp $1/GL_NV_shader_buffer_load
+
+# Filter out profile enumerations from GLX_ARB_create_context
+    grep -v "_PROFILE_" $1/GLX_ARB_create_context > tmp
+    mv tmp $1/GLX_ARB_create_context
+
+# Filter only profile related enumerations for GLX_ARB_create_context_profile
+    head -n4 $1/GLX_ARB_create_context_profile > tmp
+    grep "_PROFILE_" $1/GLX_ARB_create_context_profile >> tmp
+    mv tmp $1/GLX_ARB_create_context_profile
+
+# Filter out profile enumerations from WGL_ARB_create_context
+    grep -v "_PROFILE_" $1/WGL_ARB_create_context > tmp
+    mv tmp $1/WGL_ARB_create_context
+
+# Filter only profile related enumerations for WGL_ARB_create_context_profile
+    head -n4 $1/WGL_ARB_create_context_profile > tmp
+    grep "_PROFILE_" $1/WGL_ARB_create_context_profile >> tmp
+    mv tmp $1/WGL_ARB_create_context_profile
+
+# add missing function to GLX_NV_copy_image
+	cat >> $1/GLX_NV_copy_image <<EOT
+  void glXCopyImageSubDataNV (Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth)
+EOT
+
+# add missing function to WGL_NV_copy_image
+	cat >> $1/WGL_NV_copy_image <<EOT
+  BOOL wglCopyImageSubDataNV (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth)
+EOT
+
+# Filter glProgramUniform from GL_EXT_separate_shader_objects
+    cat $1/GL_EXT_separate_shader_objects | grep -v "glProgramUniform" | grep -v "glProgramParameteri" > tmp
+    mv tmp $1/GL_EXT_separate_shader_objects
+
+# Filter out EXT functions from GL_ARB_viewport_array
+    grep -v "EXT" $1/GL_ARB_viewport_array > tmp
+    mv tmp $1/GL_ARB_viewport_array
+
+# Additional enumerations for GL_NV_vertex_buffer_unified_memory
+# These are mentioned in GL_ARB_draw_indirect.txt
+
+    cat >> $1/GL_NV_vertex_buffer_unified_memory <<EOT
+	GL_DRAW_INDIRECT_UNIFIED_NV 0x8F40
+	GL_DRAW_INDIRECT_ADDRESS_NV 0x8F41
+	GL_DRAW_INDIRECT_LENGTH_NV  0x8F42
+EOT
+
+# Filter glGetPointerv from GL_ARB_debug_output
+# It's part of OpenGL 1.1, after all
+
+    grep -v "glGetPointerv" $1/GL_ARB_debug_output > tmp
+    mv tmp $1/GL_ARB_debug_output
+
+# Filter glGetPointerv from GL_EXT_vertex_array
+# It's part of OpenGL 1.1, after all
+
+    grep -v "glGetPointerv" $1/GL_EXT_vertex_array > tmp
+    mv tmp $1/GL_EXT_vertex_array
+
+# add typedef to GL_AMD_debug_output
+# parse_spec.pl can't parse typedefs from New Types section, but ought to
+    cat >> $1/GL_AMD_debug_output <<EOT
+	typedef void (GLAPIENTRY *GLDEBUGPROCAMD)(GLuint id, GLenum category, GLenum severity, GLsizei length, const GLchar* message, void* userParam)
+EOT
+
+# add typedef to GL_ARB_debug_output
+# parse_spec.pl can't parse typedefs from New Types section, but ought to
+    cat >> $1/GL_ARB_debug_output <<EOT
+	typedef void (GLAPIENTRY *GLDEBUGPROCARB)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam)
+EOT
+
+# add typedef to GL_KHR_debug
+# parse_spec.pl can't parse typedefs from New Types section, but ought to
+    cat >> $1/GL_KHR_debug <<EOT
+	typedef void (GLAPIENTRY *GLDEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam)
+EOT
+
+# Remove glGetPointerv from GL_KHR_debug
+    grep -v "glGetPointerv" $1/GL_KHR_debug > tmp
+    mv tmp $1/GL_KHR_debug
+
+# add typedefs to GL_ARB_cl_event
+# parse_spec.pl can't parse typedefs from New Types section, but ought to
+    cat >> $1/GL_ARB_cl_event <<EOT
+	typedef struct _cl_context *cl_context
+	typedef struct _cl_event *cl_event
+EOT
+
+# Filter out EXT functions from GL_ARB_gpu_shader_fp64
+    grep -v 'EXT ' $1/GL_ARB_gpu_shader_fp64 > tmp
+    mv tmp $1/GL_ARB_gpu_shader_fp64
+
+# add missing functions to GL_EXT_direct_state_access (GL_ARB_gpu_shader_fp64 related)
+	cat >> $1/GL_EXT_direct_state_access <<EOT
+    void glProgramUniform1dEXT (GLuint program, GLint location, GLdouble x)
+    void glProgramUniform2dEXT (GLuint program, GLint location, GLdouble x, GLdouble y)
+    void glProgramUniform3dEXT (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z)
+    void glProgramUniform4dEXT (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+    void glProgramUniform1dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value)
+    void glProgramUniform2dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value)
+    void glProgramUniform3dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value)
+    void glProgramUniform4dvEXT (GLuint program, GLint location, GLsizei count, const GLdouble *value)
+    void glProgramUniformMatrix2dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
+    void glProgramUniformMatrix3dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
+    void glProgramUniformMatrix4dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
+    void glProgramUniformMatrix2x3dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
+    void glProgramUniformMatrix2x4dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
+    void glProgramUniformMatrix3x2dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
+    void glProgramUniformMatrix3x4dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
+    void glProgramUniformMatrix4x2dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
+    void glProgramUniformMatrix4x3dvEXT (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
+EOT
+
+# add missing functions to GL_EXT_direct_state_access (GL_ARB_instanced_arrays related)
+# https://sourceforge.net/p/glew/bugs/242/
+    cat >> $1/GL_EXT_direct_state_access <<EOT
+    void glVertexArrayVertexAttribDivisorEXT (GLuint vaobj, GLuint index, GLuint divisor)
+EOT
+
+# add missing functions to GL_EXT_direct_state_access (GL_ARB_sparse_texture related)
+# https://github.com/nigels-com/glew/issues/445
+    cat >> $1/GL_EXT_direct_state_access <<EOT
+    void glTexturePageCommitmentEXT (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit)
+EOT
+
+# add missing functions to GL_EXT_direct_state_access (GL_EXT_buffer_storage related)
+# https://github.com/nigels-com/glew/issues/454
+    cat >> $1/GL_EXT_direct_state_access <<EOT
+    void glNamedBufferStorageEXT (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags)
+EOT
+
+# Filter out GL_UNSIGNED_INT and GL_FLOAT from GL_AMD_performance_monitor
+    grep -v 'GL_UNSIGNED_INT ' $1/GL_AMD_performance_monitor > tmp
+    mv tmp $1/GL_AMD_performance_monitor
+    grep -v 'GL_FLOAT ' $1/GL_AMD_performance_monitor > tmp
+    mv tmp $1/GL_AMD_performance_monitor
+
+# Filter out GL_STORAGE_CACHED_APPLE and GL_STORAGE_SHARED_APPLE from GL_APPLE_texture_range
+    grep -v 'GL_STORAGE_CACHED_APPLE ' $1/GL_APPLE_texture_range > tmp
+    mv tmp $1/GL_APPLE_texture_range
+    grep -v 'GL_STORAGE_SHARED_APPLE ' $1/GL_APPLE_texture_range > tmp
+    mv tmp $1/GL_APPLE_texture_range
+
+# Filter out GL_RED from GL_ARB_texture_rg
+    grep -v 'GL_RED ' $1/GL_ARB_texture_rg > tmp
+    mv tmp $1/GL_ARB_texture_rg
+
+# Filter out _EXT enums from GL_ARB_texture_storage
+    grep -v '_EXT ' $1/GL_ARB_texture_storage > tmp
+    mv tmp $1/GL_ARB_texture_storage
+
+# Filter out TEXTURE_3D enums from GL_EXT_paletted_texture
+    grep -v 'TEXTURE_3D' $1/GL_EXT_paletted_texture > tmp
+    mv tmp $1/GL_EXT_paletted_texture
+
+# Filter out GL_VERSION_1_1 enums from GL_AMD_stencil_operation_extended
+    grep -v '0x150' $1/GL_AMD_stencil_operation_extended > tmp
+    mv tmp $1/GL_AMD_stencil_operation_extended
+
+# Filter out from GL_APPLE_ycbcr_422
+    grep -v 'GL_UNSIGNED_SHORT_8_8_APPLE' $1/GL_APPLE_ycbcr_422 > tmp
+    mv tmp $1/GL_APPLE_ycbcr_422
+    grep -v 'GL_UNSIGNED_SHORT_8_8_REV_APPLE' $1/GL_APPLE_ycbcr_422 > tmp
+    mv tmp $1/GL_APPLE_ycbcr_422
+
+# Filter out GL_FRAGMENT_DEPTH_EXT from GL_EXT_light_texture
+    grep -v 'GL_FRAGMENT_DEPTH_EXT' $1/GL_EXT_light_texture > tmp
+    mv tmp $1/GL_EXT_light_texture
+
+# Filter out GL_MULTISAMPLE_BIT_EXT from GL_SGIS_multisample
+    grep -v 'GL_MULTISAMPLE_BIT_EXT' $1/GL_SGIS_multisample > tmp
+    mv tmp $1/GL_SGIS_multisample
+
+# Filter out GL_COMPRESSED_RGB_S3TC_DXT1_EXT from GL_EXT_texture_compression_dxt1
+    grep -v 'GL_COMPRESSED_RGB_S3TC_DXT1_EXT' $1/GL_EXT_texture_compression_dxt1 > tmp
+    mv tmp $1/GL_EXT_texture_compression_dxt1
+
+# Filter out GL_COMPRESSED_RGBA_S3TC_DXT1_EXT from GL_EXT_texture_compression_dxt1
+    grep -v 'GL_COMPRESSED_RGBA_S3TC_DXT1_EXT' $1/GL_EXT_texture_compression_dxt1 > tmp
+    mv tmp $1/GL_EXT_texture_compression_dxt1
+
+# Append GLfixed to GL_ARB_ES2_compatibility
+# Probably ought to be explicitly mentioned in the spec language
+
+    cat >> $1/GL_ARB_ES2_compatibility <<EOT
+	typedef int GLfixed
+EOT
+
+# Append GLclampx to GL_REGAL_ES1_0_compatibility
+# Probably ought to be explicitly mentioned in the spec language
+
+    cat >> $1/GL_REGAL_ES1_0_compatibility <<EOT
+	typedef int GLclampx
+EOT
+
+# Append GLLOGPROCREGAL to GL_REGAL_log
+# Probably ought to be explicitly mentioned in the spec language
+
+    cat >> $1/GL_REGAL_log <<EOT
+	typedef void (APIENTRY *LOGPROCREGAL)(GLenum stream, GLsizei length, const GLchar *message, void *context)
+EOT
+
+# Fixup LOGPROCREGAL -> GLLOGPROCREGAL
+    perl -e 's/LOGPROCREGAL/GLLOGPROCREGAL/g' -pi $1/GL_REGAL_log
+
+# Filter out GL_BYTE from GL_OES_byte_coordinates
+    grep -v 'GL_BYTE' $1/GL_OES_byte_coordinates > tmp
+    mv tmp $1/GL_OES_byte_coordinates
+
+# Filter out fp64 (not widely supported) from GL_EXT_direct_state_access
+    egrep -v 'glProgramUniform.*[1234]d[v]?EXT' $1/GL_EXT_direct_state_access > tmp
+    mv tmp $1/GL_EXT_direct_state_access
+
+# Filter out all enums from GL_ANGLE_depth_texture
+    grep -v '0x' $1/GL_ANGLE_depth_texture > tmp
+    mv tmp $1/GL_ANGLE_depth_texture
+
+# Filter out GL_NONE enum from GL_ANGLE_depth_texture
+    grep -v 'GL_NONE' $1/GL_ANGLE_texture_usage > tmp
+    mv tmp $1/GL_ANGLE_texture_usage
+
+# Fixup REGAL and ANGLE urls
+
+    for i in $1/GL_REGAL_*; do perl -e 's#http://www.opengl.org/registry/specs/REGAL/.*#https://github.com/p3/regal/tree/master/doc/extensions#g' -pi $i; done
+    for i in $1/GL_ANGLE_*; do perl -e 's#http://www.opengl.org/registry/specs/ANGLE/.*#https://code.google.com/p/angleproject/source/browse/\#git%2Fextensions#g' -pi $i; done
+
+# Filter out GL_NV_blend_equation_advanced_coherent enums and functions
+    head -n4 $1/GL_NV_blend_equation_advanced_coherent > tmp
+    mv tmp $1/GL_NV_blend_equation_advanced_coherent
+
+# Filter out GL_AMD_gpu_shader_int64 enums and functions
+    head -n4 $1/GL_AMD_gpu_shader_int64 > tmp
+    mv tmp $1/GL_AMD_gpu_shader_int64
+
+# Filter out GL_NO_ERROR enum and glGetGraphicsResetStatus from GL_KHR_robustness
+    grep -v 'GL_NO_ERROR'              $1/GL_KHR_robustness |
+    grep -v 'glGetGraphicsResetStatus' > tmp
+    mv tmp $1/GL_KHR_robustness
+
+# Filter out all enums from GL_KHR_blend_equation_advanced_coherent
+    grep -v '0x' $1/GL_KHR_blend_equation_advanced_coherent > tmp
+    mv tmp $1/GL_KHR_blend_equation_advanced_coherent
+
+# Filter out glBlendBarrierKHR enum from GL_KHR_blend_equation_advanced_coherent
+    grep -v 'glBlendBarrierKHR' $1/GL_KHR_blend_equation_advanced_coherent > tmp
+    mv tmp $1/GL_KHR_blend_equation_advanced_coherent
+
+# Filter out GL_NONE enum from GL_KHR_context_flush_control
+    grep -v 'GL_NONE' $1/GL_KHR_context_flush_control > tmp
+    mv tmp $1/GL_KHR_context_flush_control
+
+# Filter out CoverageModulation from NV_framebuffer_mixed_samples
+# Superset of EXT_raster_multisample
+
+    grep -v "CoverageModulation" $1/GL_NV_framebuffer_mixed_samples > tmp
+    mv tmp $1/GL_NV_framebuffer_mixed_samples
+
+# Filter out glRasterSamplesEXT from NV_framebuffer_mixed_samples
+# Superset of EXT_raster_multisample
+
+    grep -v "RasterSamplesEXT" $1/GL_NV_framebuffer_mixed_samples > tmp
+    mv tmp $1/GL_NV_framebuffer_mixed_samples
+
+# Filter out glNamedBufferStorageEXT from GL_ARB_buffer_storage
+
+    grep -v "glNamedBufferStorageEXT" $1/GL_ARB_buffer_storage > tmp
+    mv tmp $1/GL_ARB_buffer_storage
+
+# Filter out glFramebufferTextureEXT from GL_EXT_geometry_point_size
+# and GL_EXT_geometry_shader
+
+    grep -v "glFramebufferTextureEXT" $1/GL_EXT_geometry_point_size > tmp
+    mv tmp $1/GL_EXT_geometry_point_size
+
+    grep -v "glFramebufferTextureEXT" $1/GL_EXT_geometry_shader > tmp
+    mv tmp $1/GL_EXT_geometry_shader
+
+# Filter out glBindFragDataLocationEXT from GL_EXT_blend_func_extended
+
+    grep -v "glBindFragDataLocationEXT" $1/GL_EXT_blend_func_extended > tmp
+    mv tmp $1/GL_EXT_blend_func_extended
+
+# Filter out glDrawArraysInstancedEXT and glDrawElementsInstancedEXT from GL_EXT_blend_func_extended
+
+    grep -v "glDrawArraysInstancedEXT" $1/GL_EXT_instanced_arrays > tmp
+    mv tmp $1/GL_EXT_instanced_arrays
+
+    grep -v "glDrawElementsInstancedEXT" $1/GL_EXT_instanced_arrays > tmp
+    mv tmp $1/GL_EXT_instanced_arrays
+
+# Filter out glRenderbufferStorageMultisampleEXT from GL_EXT_multisampled_render_to_texture
+
+    grep -v "glRenderbufferStorageMultisampleEXT" $1/GL_EXT_multisampled_render_to_texture > tmp
+    mv tmp $1/GL_EXT_multisampled_render_to_texture
+
+# Filter out glTexturePageCommitmentEXT from GL_ARB_sparse_texture
+
+    grep -v "glTexturePageCommitmentEXT" $1/GL_ARB_sparse_texture > tmp
+    mv tmp $1/GL_ARB_sparse_texture
+
+# Filter out TextureStorage* from GL_ARB_texture_storage
+
+    grep -v "TextureStorage" $1/GL_ARB_texture_storage > tmp
+    mv tmp $1/GL_ARB_texture_storage
+
+# Filter out functions from GL_EXT_occlusion_query_boolean
+
+    grep -v "(" $1/GL_EXT_occlusion_query_boolean > tmp
+    mv tmp $1/GL_EXT_occlusion_query_boolean
+
+# Filter out duplicate enums from GL_EXT_protected_textures
+
+    cat $1/GL_EXT_protected_textures | grep -v GL_TRUE | grep -v GL_FALSE > tmp
+    mv tmp $1/GL_EXT_protected_textures
+
+# Filter out duplicate enums from GL_EXT_robustness
+
+    cat $1/GL_EXT_robustness | grep -v GL_NO_ERROR > tmp
+    mv tmp $1/GL_EXT_robustness
+
+# Filter  GL_EXT_shader_framebuffer_fetch_non_coherent
+
+    grep -v "FramebufferFetchBarrierEXT" $1/GL_EXT_shader_framebuffer_fetch_non_coherent > tmp
+    mv tmp $1/GL_EXT_shader_framebuffer_fetch_non_coherent
+
+# Filter GL_EXT_tessellation_shader
+
+    grep -v "PatchParameteriEXT" $1/GL_EXT_tessellation_shader > tmp
+    mv tmp $1/GL_EXT_tessellation_shader
+
+# Filter GL_EXT_texture_buffer
+
+    grep -v "TexBuffer" $1/GL_EXT_texture_buffer > tmp
+    mv tmp $1/GL_EXT_texture_buffer
+
+# Filter GL_EXT_texture_border_clamp
+
+    grep -v "TexParameter" $1/GL_EXT_texture_border_clamp > tmp
+    mv tmp $1/GL_EXT_texture_border_clamp
+
+# Filter GL_EXT_disjoint_timer_query
+
+    cat $1/GL_EXT_disjoint_timer_query | grep -v GetQueryObjecti64v | grep -v GetQueryObjectui64v > tmp
+    mv tmp $1/GL_EXT_disjoint_timer_query
+
+# Filter GL_NV_read_buffer_front
+
+    grep -v "ReadBufferNV" $1/GL_NV_read_buffer_front > tmp
+    mv tmp $1/GL_NV_read_buffer_front
+
+# Append GLVULKANPROCNV to GL_NV_draw_vulkan_image
+# Probably ought to be explicitly mentioned in the spec language
+
+    cat >> $1/GL_NV_draw_vulkan_image <<EOT
+    typedef void (APIENTRY *GLVULKANPROCNV)(void)
+EOT
+
+# remove duplicates in GL_EXT_fragment_shading_rate and GL_EXT_fragment_shading_rate_primitive
+    tail -n +5 $1/GL_EXT_fragment_shading_rate_primitive > patterns
+    grep -v -F -f patterns $1/GL_EXT_fragment_shading_rate_primitive > tmp
+    mv tmp $1/GL_EXT_fragment_shading_rate_primitive
+
+# remove duplicates in GL_EXT_fragment_shading_rate and GL_EXT_fragment_shading_rate_attachment
+    tail -n +5 $1/GL_EXT_fragment_shading_rate_attachment > patterns
+    grep -v -F -f patterns $1/GL_EXT_fragment_shading_rate_attachment > tmp
+    mv tmp $1/GL_EXT_fragment_shading_rate_attachment
+
+# GLU extensions are not relevant here
+    rm -f $1/GL_GLU_*
+
+# Not complete
+    rm -f $1/GL_SGIX_color_type
+
+# clean up
+    rm -f patterns $1/*.bak

Libraries/glew-2.3.1/auto/bin/filter_gles_ext.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+##
+## Parameters:
+##
+##       $1: Extensions directory
+##       $2: Registry directory
+##       $3: The black list
+
+set -e
+
+# clean up
+    rm -f $1/*.bak

Libraries/glew-2.3.1/auto/bin/filter_spec.py

@@ -0,0 +1,38 @@
+#!/usr/bin/python
+
+import re
+
+section = re.compile('^(Name|Name Strings?|Contact|Notice|Number|Dependencies|Overview|Issues|IP Status|Status|Version|New Procedures and Functions|New Tokens|Additions to .*|Changes to .*|Modifications to .*|Add new Section .*)\s*$')
+token   = re.compile('^\s+(([A-Z0-9][A-Z0-9_x]*):?\s+((?:0x)?[0-9A-F]+)([^\?]*))?\s*$')
+match   = [ 'Name', 'Name String', 'Contact', 'Notice', 'Name Strings', 'Version', 'Number', 'Dependencies', 'New Procedures and Functions', 'New Tokens']
+
+if __name__ == '__main__':
+
+  from optparse import OptionParser
+  import os
+
+  parser = OptionParser('usage: %prog [options] [SOURCES...]')
+  (options, args) = parser.parse_args()
+
+  for i in args:
+      lines = open(i).readlines()
+      f = open(i,'w')
+
+      # Keep track of the current section as we iterate over the input
+      current = ''
+      for j in lines:
+
+          # Detect the start of a new section
+          m = section.match(j)
+          if m:
+              current = m.group(1).strip()
+              if current in match:
+                  print >>f, j,
+              continue
+
+          if current=='New Tokens':
+              if token.match(j):
+                  print >>f, j,
+          elif current in match:
+                  print >>f, j,
+

Libraries/glew-2.3.1/auto/bin/make.pl

@@ -0,0 +1,224 @@
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+my %regex = (
+    extname  => qr/^[A-Z][A-Za-z0-9_]+$/,
+    exturl   => qr/^http.+$/,
+    function => qr/^(.+) ([a-z][a-z0-9_]*) \((.*)\)$/i,
+    token    => qr/^([A-Z][A-Za-z0-9_x]*)\s+((?:0x|-)?[0-9A-Fa-f]+(u(ll)?)?|[A-Z][A-Za-z0-9(),_-]*)$/,
+    type     => qr/^typedef\s+(.+)$/,
+    exact    => qr/.*;$/,
+);
+
+# prefix function name with glew
+sub prefixname($)
+{
+    my $name = $_[0];
+    $name =~ s/^(.*?)gl/__$1glew/;
+    return $name;
+}
+
+# prefix function name with glew
+sub prefix_varname($)
+{
+    my $name = $_[0];
+    $name =~ s/^(.*?)GL(X*?)EW/__$1GL$2EW/;
+    return $name;
+}
+
+#---------------------------------------------------------------------------------------
+
+sub make_exact($)
+{
+	my $exact = $_[0];
+	$exact =~ s/(; |{)/$1\n/g;
+    return $exact;
+}
+
+sub make_separator($)
+{
+    my $extname = $_[0];
+    my $l = length $extname;
+    my $s = (71 - $l)/2;
+    print "/* ";
+    my $j = 3;
+    for (my $i = 0; $i < $s; $i++)
+    {
+	print "-";
+	$j++;
+    }
+    print " $_[0] ";
+    $j += $l + 2;
+    while ($j < 76)
+    {
+	print "-";
+	$j++;
+    }
+    print " */\n\n";
+}
+
+#---------------------------------------------------------------------------------------
+
+sub parse_ext($)
+{
+    my $filename = shift;
+    my %functions = ();
+    my %tokens = ();
+    my @reuse = ();      # Extensions to reuse
+    my @types = ();
+    my @exacts = ();
+    my $extname = "";    # Full extension name GL_FOO_extension
+    my $exturl = "";     # Info URL
+    my $extstring = "";  # Relevant extension string 
+
+    open EXT, "<$filename" or return;
+
+    # As of GLEW 1.14.0 the first four lines _must_ be
+    # the extension name, the URL and the GL extension
+    # string (which might be different to the name),
+    # and the reused extensions
+    #
+    # For example GL_NV_geometry_program4 is available
+    # iff GL_NV_gpu_program4 appears in the extension
+    # string.
+    #
+    # For core OpenGL versions, the third line should
+    # be blank.
+    #
+    # If the URL is unknown, the second line should be
+    # blank.
+   
+    $extname   = readline(*EXT);
+    $exturl    = readline(*EXT);
+    $extstring = readline(*EXT);
+    @reuse     = split(" ", readline(*EXT));
+
+    chomp($extname);
+    chomp($exturl);
+    chomp($extstring);
+
+    while(<EXT>)
+    {
+        chomp;
+        if (s/^\s+//)
+        {
+            if (/$regex{exact}/)
+            {
+                push @exacts, $_;
+            }
+            elsif (/$regex{type}/)
+            {
+                push @types, $_;
+            }
+            elsif (/$regex{token}/)
+            {
+                my ($name, $value) = ($1, $2);
+                $tokens{$name} = $value;
+            }
+            elsif (/$regex{function}/)
+            {
+                my ($return, $name, $parms) = ($1, $2, $3);
+                $functions{$name} = {
+		    rtype => $return,
+		    parms => $parms,
+		};
+            } else {
+                print STDERR "'$_' matched no regex.\n";
+            }
+        }
+    }
+
+    close EXT;
+
+    return ($extname, $exturl, $extstring, \@reuse, \@types, \%tokens, \%functions, \@exacts);
+}
+
+sub output_tokens($$)
+{
+    my ($tbl, $fnc) = @_;
+    if (keys %{$tbl})
+    {
+        local $, = "\n";
+        print "\n";
+        print map { &{$fnc}($_, $tbl->{$_}) } sort { 
+            if (${$tbl}{$a} eq ${$tbl}{$b}) {
+                    $a cmp $b
+            } else {
+                if (${$tbl}{$a} =~ /_/) {
+                    if (${$tbl}{$b} =~ /_/) {
+                        $a cmp $b
+                    } else {
+                        -1
+                    }
+                } else {
+                    if (${$tbl}{$b} =~ /_/) {
+                        1
+                    } else {
+                        if (hex ${$tbl}{$a} eq hex ${$tbl}{$b}) {
+                            $a cmp $b
+                        } else {
+                            hex ${$tbl}{$a} <=> hex ${$tbl}{$b}
+                        }
+                    }                    
+                }
+            }
+        } keys %{$tbl};
+        print "\n";
+    } else {
+        print STDERR "no keys in table!\n";
+    }
+}
+
+sub output_types($$)
+{
+    my ($tbl, $fnc) = @_;
+    if (scalar @{$tbl})
+    {
+        local $, = "\n";
+        print "\n";
+        print map { &{$fnc}($_) } sort @{$tbl};
+        print "\n";
+    }
+}
+
+sub output_decls($$)
+{
+    my ($tbl, $fnc) = @_;
+    if (keys %{$tbl})
+    {
+        local $, = "\n";
+        print "\n";
+        print map { &{$fnc}($_, $tbl->{$_}) } sort keys %{$tbl};
+        print "\n";
+    }
+}
+
+sub output_exacts($$)
+{
+    my ($tbl, $fnc) = @_;
+    if (scalar @{$tbl})
+    {
+        local $, = "\n";
+        print "\n";
+        print map { &{$fnc}($_) } sort @{$tbl};
+        print "\n";
+    }
+}
+
+sub output_reuse($$)
+{
+    my ($tbl, $fnc) = @_;
+    if (scalar @{$tbl})
+    {
+        local $, = "\n";
+        print "\n";
+        print map { &{$fnc}($_) } sort @{$tbl};
+        print "\n";
+    }
+}

Libraries/glew-2.3.1/auto/bin/make_def_fun.pl

@@ -0,0 +1,37 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+# function pointer declaration
+sub make_pfn_decl($%)
+{
+    return "PFN" . (uc $_[0]) . "PROC " . prefixname($_[0]) . " = NULL;";
+}
+
+my @extlist = ();
+my %extensions = ();
+
+our $type = shift;
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+		output_decls($functions, \&make_pfn_decl);
+	}
+}

Libraries/glew-2.3.1/auto/bin/make_def_var.pl

@@ -0,0 +1,33 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+my @extlist = ();
+my %extensions = ();
+
+our $type = shift;
+
+if (@ARGV)
+{
+	@extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+		my $extvar = $extname;
+		$extvar =~ s/GL(X*)_/GL$1EW_/;
+		print "GLboolean " . prefix_varname($extvar) . " = GL_FALSE;\n";
+	}
+}

Libraries/glew-2.3.1/auto/bin/make_enable_index.pl

@@ -0,0 +1,48 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+use File::Basename;
+
+use lib '.';
+do 'bin/make.pl';
+
+##
+## Make Extension-enabled Index
+##
+
+my @extlist = ();
+
+if (@ARGV)
+{
+	@extlist = @ARGV;
+
+	print "/* Detected in the extension string or strings */\n";
+	print "static GLboolean  _glewExtensionString[" . scalar @extlist . "];\n";
+
+	print "/* Detected via extension string or experimental mode */\n";
+	print "static GLboolean* _glewExtensionEnabled[] = {\n";;
+
+	foreach my $ext (sort { basename($a) cmp basename($b) } @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = 
+			parse_ext($ext);
+
+		my $extvar = $extname;
+		$extvar =~ s/GL(X*)_/GL$1EW_/;
+
+		print "#ifdef $extname\n";
+		print "  &__$extvar,\n";
+		print "#endif\n";
+	}
+
+	print "  NULL\n};\n\n";
+}

Libraries/glew-2.3.1/auto/bin/make_header.pl

@@ -0,0 +1,73 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+# token
+sub make_define($$)
+{
+    return "#define $_[0] $_[1]"
+}
+
+# type declaration
+sub make_type($$)
+{
+    return "@_;"
+}
+
+# function pointer type declaration
+sub make_pfn_type($%)
+{
+    our $api;
+    return join(' ', "typedef", $_[1]->{rtype},
+        "($api * PFN" . (uc $_[0]) . "PROC)",
+        "(" . $_[1]->{parms} . ")") . ";";
+}
+
+# function name alias
+sub make_pfn_alias($%)
+{
+    our $type;
+    return join(" ", "#define", $_[0], $type . "EW_GET_FUN(" . prefixname($_[0]) . ")")
+}
+
+my @extlist = ();
+my %extensions = ();
+
+our $api = shift;
+our $type = shift;
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+
+		make_separator($extname);
+		print "#ifndef $extname\n#define $extname 1\n";
+		output_tokens($tokens, \&make_define);
+		output_types($types, \&make_type);
+		output_exacts($exacts, \&make_exact);
+		output_decls($functions, \&make_pfn_type);
+		output_decls($functions, \&make_pfn_alias);
+
+		my $extvar = $extname;
+		$extvar =~ s/GL(X*)_/GL$1EW_/;
+		
+		print "\n#define $extvar " . $type . "EW_GET_VAR(" . prefix_varname($extvar) . ")\n";
+		print "\n#endif /* $extname */\n\n";
+	}
+}

Libraries/glew-2.3.1/auto/bin/make_html.pl

@@ -0,0 +1,57 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+#---------------------------------------------------------------------------------------
+
+my @extlist = ();
+my %extensions = ();
+my $group = "";
+my $cur_group = "";
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+	my $n = 1;
+	print "<table border=\"0\" width=\"100%\" cellpadding=\"1\" cellspacing=\"0\" align=\"center\">\n";
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+		$cur_group = $extname;
+		$cur_group =~ s/^(?:W?)GL(?:X?)_([A-Z0-9]+?)_.*$/$1/;
+		$extname =~ s/^(?:W?)GL(?:X?)_(.*)$/$1/;
+		if ($cur_group ne $group)
+		{
+			if ($group ne "")
+			{
+				print "<tr><td><br></td><td></td><td></td></tr>\n";
+			}
+			$group = $cur_group;
+		}
+
+		{
+			if ($exturl)
+			{
+				print "<tr><td class=\"num\">$n</td><td>&nbsp;</td><td><a href=\"$exturl\">$extname</a></td></tr>\n";
+			}
+			else
+			{
+				print "<tr><td class=\"num\">$n</td><td>&nbsp;</td><td>$extname</td></tr>\n";
+			}
+			$n++;
+		}
+	}
+	print "</table>\n"
+}

Libraries/glew-2.3.1/auto/bin/make_index.pl

@@ -0,0 +1,41 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+use File::Basename;
+
+use lib '.';
+do 'bin/make.pl';
+
+##
+## Make Index
+##
+## Output sorted array of extension strings for indexing into extension
+## enable/disable flags.  This provides a way to convert an extension string
+## into an integer index.
+##
+
+my @extlist = ();
+
+if (@ARGV)
+{
+	@extlist = @ARGV;
+
+	foreach my $ext (sort { basename($a) cmp basename($b) } @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = 
+			parse_ext($ext);
+
+		print "#ifdef $extname\n";
+		print "  \"$extname\",\n";
+		print "#endif\n";
+	}
+}

Libraries/glew-2.3.1/auto/bin/make_info.pl

@@ -0,0 +1,71 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+#---------------------------------------------------------------------------------------
+
+# function pointer definition
+sub make_pfn_info($%)
+{
+    my $name = $_[0];
+    return "  glewInfoFunc(fi, \"$_[0]\", $name == NULL);";
+}
+
+#---------------------------------------------------------------------------------------
+
+my @extlist = ();
+my %extensions = ();
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+		my $extvar = $extname;
+		$extvar =~ s/GL(X*)_/GL$1EW_/;
+		my $extpre = $extname;
+		$extpre =~ s/(GLX|GLW|GL).*/$1/;
+		$extpre = lc $extpre;
+
+		#make_separator($extname);
+		print "#ifdef $extname\n\n";
+		print "static void _glewInfo_$extname (void)\n{\n";
+
+		if (! %$functions)
+		{
+			print "  ";		
+		}
+		else
+		{
+			print "  GLboolean fi = ";		
+		}
+
+		if ($extvar =~ /VERSION/)
+		{
+			print "glewPrintExt(\"$extname\", $extvar, $extvar, $extvar);\n";
+		}
+		else
+		{
+			print "glewPrintExt(\"$extname\", $extvar, $extpre" .
+				"ewIsSupported(\"$extname\"), $extpre" .
+				"ewGetExtension(\"$extstring\"));\n";
+		}
+		output_decls($functions, \&make_pfn_info);
+		print "}\n\n";
+		print "#endif /* $extname */\n\n";
+	}
+}

Libraries/glew-2.3.1/auto/bin/make_info_list.pl

@@ -0,0 +1,49 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+#---------------------------------------------------------------------------------------
+
+# function pointer definition
+sub make_pfn_def($%)
+{
+    return "PFN" . (uc $_[0]) . "PROC " . prefixname($_[0]) . " = NULL;";
+}
+
+# function pointer definition
+sub make_init_call($%)
+{
+    my $name = prefixname($_[0]);
+    return "  r = r || (" . $name . " = (PFN" . (uc $_[0]) . "PROC)glewGetProcAddress((const GLubyte*)\"" . $name . "\")) == NULL;";
+}
+
+#---------------------------------------------------------------------------------------
+
+my @extlist = ();
+my %extensions = ();
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+
+		print "#ifdef $extname\n";
+		print "  _glewInfo_$extname();\n";
+		print "#endif /* $extname */\n";
+	}
+}

Libraries/glew-2.3.1/auto/bin/make_init.pl

@@ -0,0 +1,61 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+#-------------------------------------------------------------------------------
+
+# function pointer definition
+sub make_pfn_def_init($%)
+{
+    #my $name = prefixname($_[0]);
+    return "  r = ((" . $_[0] . " = (PFN" . (uc $_[0]) . "PROC)glewGetProcAddress((const GLubyte*)\"" . $_[0] . "\")) == NULL) || r;";
+}
+
+sub make_reuse_call($%)
+{
+	return "  r = _glewInit_" . $_[0] . "() || r;";
+}
+
+#-------------------------------------------------------------------------------
+
+my @extlist = ();
+my %extensions = ();
+
+our $type = shift;
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = 
+			parse_ext($ext);
+
+		#make_separator($extname);
+		my $extvar = $extname;
+		my $extvardef = $extname;
+		$extvar =~ s/GL(X*)_/GL$1EW_/;
+		if (keys %$functions or keys @$reuse)
+		{
+			print "#ifdef $extname\n\n";
+			print "static GLboolean _glewInit_$extname (void)\n{\n  GLboolean r = GL_FALSE;\n";
+			output_reuse($reuse, \&make_reuse_call);
+			output_decls($functions, \&make_pfn_def_init);
+			print "\n  return r;\n}\n\n";
+			print "#endif /* $extname */\n\n";
+		}
+	}
+}

Libraries/glew-2.3.1/auto/bin/make_initd.pl

@@ -0,0 +1,45 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+## Output declarations for the _glewInit_[extension] functions defined
+## by make_init.pl script.  These are necessary for for initializers to
+## call each other, such as a core GL 3 context that depends on certain
+## extensions.
+
+#-------------------------------------------------------------------------------
+
+my @extlist = ();
+my %extensions = ();
+
+our $type = shift;
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = 
+			parse_ext($ext);
+
+		#print "#ifdef $extname\n\n";
+		if (keys %$functions)
+		{
+			print "static GLboolean _glewInit_$extname (void);\n";
+		}
+		#print "#endif /* $extname */\n\n";
+	}
+}

Libraries/glew-2.3.1/auto/bin/make_list.pl

@@ -0,0 +1,75 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+#---------------------------------------------------------------------------------------
+
+# function pointer definition
+sub make_init_call($%)
+{
+    my $name = prefixname($_[0]);
+    return "  r = r || (" . $_[0] . " = (PFN" . (uc $_[0]) . "PROC)glewGetProcAddress(\"" . $name . "\")) == NULL;";
+}
+
+#---------------------------------------------------------------------------------------
+
+my @extlist = ();
+my %extensions = ();
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+
+		my $extvar = $extname;
+		$extvar =~ s/GL(X*)_/GL$1EW_/;
+
+		my $extpre = $extname;
+		$extpre =~ s/^(W?E?)GL(X?).*$/\l$1gl\l$2ew/;
+
+		#my $pextvar = prefix_varname($extvar);
+
+		if (length($extstring) && $extstring !~ /^GL_/ || keys %$functions)
+		{
+			print "#ifdef $extname\n";
+		}
+
+		if (length($extstring) && $extstring !~ /^GL_/)
+		{
+			print "  " . $extvar . " = _glewSearchExtension(\"$extstring\", extStart, extEnd);\n";
+		}
+
+		if (keys %$functions)
+		{
+			if ($extname =~ /WGL_.*/)
+			{
+				print "  if (glewExperimental || " . $extvar . "|| crippled) " . $extvar . "= !_glewInit_$extname();\n";
+			}
+			else
+			{
+				print "  if (glewExperimental || " . $extvar . ") " . $extvar . " = !_glewInit_$extname();\n";
+			}
+		}
+
+		if (length($extstring) && $extstring !~ /^GL_/ || keys %$functions)
+		{
+			print "#endif /* $extname */\n";
+		}
+	}
+
+}

Libraries/glew-2.3.1/auto/bin/make_list2.pl

@@ -0,0 +1,46 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+#---------------------------------------------------------------------------------------
+# Extensions that depend on others can be enabled once we know
+# if the one it depends on, is enabled.
+
+my @extlist = ();
+my %extensions = ();
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+
+		if ($extname ne $extstring && length($extstring))
+		{
+			my $extvar = $extname;
+			$extvar =~ s/GL(X*)_/GL$1EW_/;
+
+			my $parent = $extstring;
+			$parent =~ s/GL(X*)_/GL$1EW_/;
+
+			print "#ifdef $extname\n";
+			print "  $extvar = $parent;\n";
+			print "#endif /* $extname */\n";
+		}
+	}
+
+}

Libraries/glew-2.3.1/auto/bin/make_str.pl

@@ -0,0 +1,55 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+my @extlist = ();
+my %extensions = ();
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	my $curexttype = "";
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+		my $exttype = $extname;
+		$exttype =~ s/(W?E?)GL(X?)_(.*?_)(.*)/$3/;
+		my $extrem = $extname;
+		$extrem =~ s/(W?E?)GL(X?)_(.*?_)(.*)/$4/;
+		my $extvar = $extname;
+		$extvar =~ s/(W?E?)GL(X?)_/$1GL$2EW_/;
+		if(!($exttype =~ $curexttype))
+		{
+			if(length($curexttype) > 0)
+			{
+				print "      }\n";
+			}
+			print "      if (_glewStrSame2(&pos, &len, (const GLubyte*)\"$exttype\", " . length($exttype) . "))\n";
+			print "      {\n";
+			$curexttype = $exttype;
+		}
+		print "#ifdef $extname\n";
+		print "        if (_glewStrSame3(&pos, &len, (const GLubyte*)\"$extrem\", ". length($extrem) . "))\n";
+		#print "        return $extvar;\n";
+		print "        {\n";
+		print "          ret = $extvar;\n";
+		print "          continue;\n";
+		print "        }\n";
+		print "#endif\n";
+	}
+
+	print "      }\n";
+}

Libraries/glew-2.3.1/auto/bin/make_struct_fun.pl

@@ -0,0 +1,38 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+# function pointer declaration
+sub make_pfn_decl($%)
+{
+    our $export;
+    return $export . " PFN" . (uc $_[0]) . "PROC " . prefixname($_[0]) . ";";
+}
+
+my @extlist = ();
+my %extensions = ();
+
+our $export = shift;
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+		output_decls($functions, \&make_pfn_decl);
+	}
+}

Libraries/glew-2.3.1/auto/bin/make_struct_var.pl

@@ -0,0 +1,33 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+use lib '.';
+do 'bin/make.pl';
+
+my @extlist = ();
+my %extensions = ();
+
+our $export = shift;
+
+if (@ARGV)
+{
+    @extlist = @ARGV;
+
+	foreach my $ext (sort @extlist)
+	{
+		my ($extname, $exturl, $extstring, $reuse, $types, $tokens, $functions, $exacts) = parse_ext($ext);
+		my $extvar = $extname;
+		$extvar =~ s/GL(X*)_/GL$1EW_/;
+		print $export . " GLboolean " . prefix_varname($extvar) . ";\n";
+	}
+}

Libraries/glew-2.3.1/auto/bin/parse_spec.pl

@@ -0,0 +1,410 @@
+#!/usr/bin/env perl
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+
+use strict;
+use warnings;
+
+sub compile_regex
+{
+    my $regex = join('', @_);
+    return qr/$regex/
+}
+
+my @sections = (
+    "Name",
+    "Name Strings?",
+    "New Procedures and Functions",
+    "New Tokens.*",                    # Optional (GL/WGL/GLX/...) suffix
+    "Additions to Chapter.*",
+);
+
+my %typemap = (
+    bitfield => "GLbitfield",
+    boolean  => "GLboolean",
+    # fsck up in EXT_vertex_array
+    Boolean  => "GLboolean",
+    byte     => "GLbyte",
+    clampd   => "GLclampd",
+    clampf   => "GLclampf",
+    double   => "GLdouble",
+    enum     => "GLenum",
+    # Intel fsck up
+    Glenum   => "GLenum",
+    float    => "GLfloat",
+    half     => "GLhalf",
+    int      => "GLint",
+    short    => "GLshort",
+    sizei    => "GLsizei",
+    ubyte    => "GLubyte",
+    uint     => "GLuint",
+    ushort   => "GLushort",
+    DMbuffer => "void *",
+    # Nvidia video output fsck up
+    int64EXT => "GLint64EXT",
+    uint64EXT=> "GLuint64EXT",
+
+    # ARB VBO introduces these.
+
+    sizeiptr => "GLsizeiptr",
+    intptr   => "GLintptr",
+    sizeiptrARB => "GLsizeiptrARB",
+    intptrARB   => "GLintptrARB",
+
+    # ARB shader objects introduces these, charARB is at least 8 bits,
+    # handleARB is at least 32 bits
+    charARB => "GLcharARB",
+    handleARB => "GLhandleARB",
+
+    char => "GLchar",
+
+    # OpenGL 3.2 and GL_ARB_sync
+
+    int64  => "GLint64",
+    uint64 => "GLuint64",
+    sync   => "GLsync",
+
+    # GL_EXT_EGL_image_storage
+
+    eglImageOES => "GLeglImageOES",
+
+    # AMD_debug_output
+
+    DEBUGPROCAMD => "GLDEBUGPROCAMD",
+
+    # ARB_debug_output
+
+    DEBUGPROCARB => "GLDEBUGPROCARB",
+
+    # KHR_debug
+
+    DEBUGPROC => "GLDEBUGPROC",
+
+    VULKANPROCNV => "GLVULKANPROCNV",
+
+    vdpauSurfaceNV => "GLvdpauSurfaceNV",
+    
+    # GLX 1.3 defines new types which might not be available at compile time
+
+    #GLXFBConfig   => "void*",
+    #GLXFBConfigID => "XID",
+    #GLXContextID  => "XID",
+    #GLXWindow     => "XID",
+    #GLXPbuffer    => "XID",
+
+    # Weird stuff to some SGIX extension
+
+    #GLXFBConfigSGIX   => "void*",
+    #GLXFBConfigIDSGIX => "XID",
+
+);
+
+my %voidtypemap = (
+    void    => "GLvoid",
+);
+
+my %taboo_tokens = (
+    GL_ZERO => 1,
+);
+
+# list of function definitions to be ignored, unless they are being defined in
+# the given spec.  This is an ugly hack around the fact that people writing
+# spec files seem to shut down all brain activity while they are at this task.
+#
+# This will be moved to its own file eventually.
+#
+# (mem, 2003-03-19)
+
+my %fnc_ignore_list = (
+    "BindProgramARB"                => "ARB_vertex_program",
+    "ColorSubTableEXT"              => "EXT_color_subtable",
+    "DeleteProgramsARB"             => "ARB_vertex_program",
+    "GenProgramsARB"                => "ARB_vertex_program",
+    "GetProgramEnvParameterdvARB"   => "ARB_vertex_program",
+    "GetProgramEnvParameterfvARB"   => "ARB_vertex_program",
+    "GetProgramLocalParameterdvARB" => "ARB_vertex_program",
+    "GetProgramLocalParameterfvARB" => "ARB_vertex_program",
+    "GetProgramStringARB"           => "ARB_vertex_program",
+    "GetProgramivARB"               => "ARB_vertex_program",
+    "IsProgramARB"                  => "ARB_vertex_program",
+    "ProgramEnvParameter4dARB"      => "ARB_vertex_program",
+    "ProgramEnvParameter4dvARB"     => "ARB_vertex_program",
+    "ProgramEnvParameter4fARB"      => "ARB_vertex_program",
+    "ProgramEnvParameter4fvARB"     => "ARB_vertex_program",
+    "ProgramLocalParameter4dARB"    => "ARB_vertex_program",
+    "ProgramLocalParameter4dvARB"   => "ARB_vertex_program",
+    "ProgramLocalParameter4fARB"    => "ARB_vertex_program",
+    "ProgramLocalParameter4fvARB"   => "ARB_vertex_program",
+    "ProgramStringARB"              => "ARB_vertex_program",
+    "EGLImageTargetTexture2DOES"    => "OES_EGL_image",
+    "FramebufferTextureOES"         => "GL_OES_geometry_shader",
+    "PatchParameteriOES"            => "GL_OES_tessellation_shader",
+    "PointSizePointerOES"           => "GL_OES_point_size_array",
+    "LockArraysEXT"                 => "EXT_compiled_vertex_array",
+    "UnlockArraysEXT"               => "EXT_compiled_vertex_array",
+    "CoverageMaskNV"                => "NV_coverage_sample",
+    "CoverageOperationNV"           => "NV_coverage_sample",
+    "glXCreateContextAttribsARB"    => "ARB_create_context_profile",
+    "wglCreateContextAttribsARB"    => "WGL_ARB_create_context_profile",
+);
+
+my %regex = (
+    eofnc    => qr/(?:\);?$|^$)/, # )$ | );$ | ^$
+    extname  => qr/^[A-Z][A-Za-z0-9_]+$/,
+    none     => qr/^\(none\)$/,
+    function => qr/^(.+) ([a-z][a-z0-9_]*) \((.*)\)$/i,
+    prefix   => qr/^(?:[aw]?gl|glX|egl)/, # gl | agl | wgl | glX
+    tprefix  => qr/^(?:[AW]?GL|GLX|EGL)_/, # GL_ | AGL_ | WGL_ | GLX_
+    section  => compile_regex('^(', join('|', @sections), ')$'), # sections in spec
+    token    => qr/^([A-Z0-9][A-Z0-9_x]*):?\s+((?:0x)?[0-9A-Fa-f]+(u(ll)?)?)(|\s[^\?]*)$/, # define tokens
+    types    => compile_regex('\b(', join('|', keys %typemap), ')\b'), # var types
+    voidtype => compile_regex('\b(', keys %voidtypemap, ')\b '), # void type
+);
+
+# reshapes the the function declaration from multiline to single line form
+sub normalize_prototype
+{
+    local $_ = join(" ", @_);
+    s/\s+/ /g;                # multiple whitespace -> single space
+    s/\<.*\>//g;              # remove <comments> from direct state access extension
+    s/\<.*$//g;               # remove incomplete <comments> from direct state access extension
+    s#/\*.*\*/##g;            # remove /* ... */ comments
+    s/\s*\(\s*/ \(/;          # exactly one space before ( and none after
+    s/\s*\)\s*/\)/;           # no space before or after )
+    s/\s*\*([a-zA-Z])/\* $1/; # "* identifier"
+    s/\*wgl/\* wgl/;          # "* wgl"
+    s/\*glX/\* glX/;          # "* glX"
+    s/\.\.\./void/;           # ... -> void
+    s/;$//;                   # remove ; at the end of the line
+    return $_;
+}
+
+# Ugly hack to work around the fact that functions are declared in more
+# than one spec file.
+sub ignore_function($$)
+{
+    return exists($fnc_ignore_list{$_[0]}) && $fnc_ignore_list{$_[0]} ne $_[1]
+}
+
+sub parse_spec($)
+{
+    my $filename = shift;
+    my $extname = "";
+    my $vendortag = "";
+    my @extnames = ();
+    my %functions = ();
+    my %tokens = ();
+
+    my $section = "";
+    my @fnc = ();
+
+    my %proc = (
+        "Name" => sub {
+            if (/^([a-z0-9]+)_([a-z0-9_]+)/i)
+            {
+                $extname = "$1_$2";
+                $vendortag = $1;
+            }
+        },
+
+        "Name Strings" => sub {
+            # Add extension name to extension list
+        
+           # Initially use $extname if (none) specified
+            if (/$regex{none}/)
+            {
+                $_ = $extname;
+            }
+
+            if (/$regex{extname}/)
+            {
+                # prefix with "GL_" if prefix not present
+                s/^/GL_/ unless /$regex{tprefix}/o;
+                # Add extension name to extension list
+                push @extnames, $_;
+            }
+        },
+
+        "New Procedures and Functions" => sub {
+            # if line matches end of function
+            if (/$regex{eofnc}/)
+            {
+                # add line to function declaration
+                push @fnc, $_;
+
+                # if normalized version of function looks like a function
+                if (normalize_prototype(@fnc) =~ /$regex{function}/)
+                {
+                    # get return type, name, and arguments from regex
+                    my ($return, $name, $parms) = ($1, $2, $3);
+                    if (!ignore_function($name, $extname))
+                    {
+                        # prefix with "gl" if prefix not present
+                        $name =~ s/^/gl/ unless $name =~ /$regex{prefix}/;
+                        # is this a pure GL function?
+                        if ($name =~ /^gl/ && $name !~ /^glX/)
+                        {
+                            # apply typemaps
+                            $return =~ s/$regex{types}/$typemap{$1}/og;
+                            $return =~ s/GLvoid/void/og;
+                            $return =~ s/void\*/void */og;
+                            $parms =~ s/$regex{types}/$typemap{$1}/og;
+                            $parms =~ s/$regex{voidtype}/$voidtypemap{$1}/og;
+                            $parms =~ s/GLvoid/void/og;
+                            $parms =~ s/ void\* / void */og;
+                            if ($parms eq "")
+                            {
+                                $parms = "void";  # NVX_progress_fence and others
+                            }
+                        }
+                        # add to functions hash
+                        $functions{$name} = {
+                            rtype => $return,
+                            parms => $parms,
+                        };
+                    }
+                }
+                # reset function declaration
+                @fnc = ();
+            } elsif ($_ ne "" and $_ ne "None") {
+                # if not eof, add line to function declaration
+                push @fnc, $_
+            }
+        },
+
+        "New Tokens" => sub {
+            if (/$regex{token}/)
+            {
+                my ($name, $value) = ($1, $2);
+                # prefix with "GL_" if prefix not present
+                $name =~ s/^/GL_/ unless $name =~ /$regex{tprefix}/;
+                # Add (name, value) pair to tokens hash, unless it's taboo
+                $tokens{$name} = $value unless exists $taboo_tokens{$name};
+            }
+        },
+    );
+
+    # Some people can't read, the template clearly says "Name String_s_"
+    $proc{"Name String"} = $proc{"Name Strings"};
+
+    # Open spec file
+    open SPEC, "<$filename" or return;
+
+    # For each line of SPEC
+    while(<SPEC>)
+    {
+        # Delete trailing newline character
+        chomp;
+        # Remove trailing white spaces
+        s/\s+$//;
+        # If starts with a capital letter, it must be a new section
+        if (/^[A-Z]/)
+        {
+            # Match section name with one of the predefined names 
+            $section = /$regex{section}/o ? $1 : "default";
+        } else {
+            # Line is internal to a section
+            # Remove leading whitespace
+            s/^\s+//;
+            # Call appropriate section processing function if it exists
+            &{$proc{$section}} if exists $proc{$section};
+        }
+    }
+
+    close SPEC;
+
+    return ($extname, \@extnames, \%tokens, \%functions);
+}
+
+#----------------------------------------------------------------------------------------
+
+my @speclist = ();
+my %extensions = ();
+
+my $ext_dir = shift;
+my $reg_http = "https://www.khronos.org/registry/OpenGL/extensions/";
+
+# Take command line arguments or read list from file
+if (@ARGV)
+{
+    @speclist = @ARGV;
+} else {
+    local $/; #???
+    @speclist = split "\n", (<>);
+}
+
+foreach my $spec (sort @speclist)
+{
+    my ($extname, $extnames, $tokens, $functions) = parse_spec($spec);
+
+    foreach my $ext (@{$extnames})
+    {
+        my $info = "$ext_dir/" . $ext;
+        open EXT, ">$info";
+        print EXT $ext . "\n";                       # Extension name
+        my $specname = $spec;
+        $specname =~ s/OpenGL-Registry\/extensions\///;
+        print EXT $reg_http . $specname . "\n";      # Extension info URL
+        print EXT $ext . "\n";                       # Extension string
+        print EXT "\n";                              # Resuses nothing by default
+
+        my $prefix = $ext;
+        $prefix =~ s/^(.+?)(_.+)$/$1/;
+        foreach my $token (sort { 
+                if (${$tokens}{$a} eq ${$tokens}{$b}) {
+                        $a cmp $b
+                } else {
+                    if (${$tokens}{$a} =~ /_/) {
+                        if (${$tokens}{$b} =~ /_/) {
+                            $a cmp $b
+                        } else {
+                            -1
+                        }
+                    } else {
+                        if (${$tokens}{$b} =~ /_/) {
+                            1
+                        } else {
+                            if (${$tokens}{$a} =~ /u(ll)?$/) {
+                                if (${$tokens}{$b} =~ /u(ll)?$/) {
+                                    $a cmp $b
+                                } else {
+                                    -1
+                                }
+			    } else {
+                                if (${$tokens}{$b} =~ /u(ll)?$/) {
+                                    1
+                                } else {
+                                    if (hex ${$tokens}{$a} eq hex ${$tokens}{$b})
+                                    {
+                                        $a cmp $b
+                                    } else {
+                                        hex ${$tokens}{$a} <=> hex ${$tokens}{$b}
+                                    }
+                                }
+                            }
+                        }                    
+                    }
+                }
+            } keys %{$tokens})
+            {
+            if ($token =~ /^$prefix\_.*/i)
+            {
+                print EXT "\t" . $token . " " . ${\%{$tokens}}{$token} . "\n";
+            }
+        }
+        foreach my $function (sort keys %{$functions})
+        {
+            if ($function =~ /^$prefix.*/i)
+            {
+                print EXT "\t" . ${$functions}{$function}{rtype} . " " . $function . " (" . ${$functions}{$function}{parms} . ")" . "\n";
+            }
+        }
+        close EXT;
+    }
+}

Libraries/glew-2.3.1/auto/bin/parse_xml.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+
+import re
+import sys
+from xml.dom.minidom import parse, Node
+
+#
+# DOM traversal utility functions
+#
+
+def findChildren(node, path):
+    result = []
+    if len(path)==1:
+        for i in node.childNodes:
+            if i.nodeType==Node.ELEMENT_NODE:
+                if i.tagName==path[0]:
+                    result.append(i)
+    else:
+        for i in node.childNodes:
+            if i.nodeType==Node.ELEMENT_NODE:
+                if i.tagName==path[0]:
+                    result.extend(findChildren(i, path[1:]))
+    return result
+
+def findData(node, path):
+    return [ i.firstChild.data for i in findChildren(node, path) ]
+
+isPointer = re.compile('(.*)([ ]+)([*]+)')
+
+def findParams(node):
+    n = findData(node, ['name'])[0]
+    t = ''
+    for i in node.childNodes:
+        if i.nodeType==Node.TEXT_NODE:
+            t += i.data
+        if i.nodeType==Node.ELEMENT_NODE and i.tagName=='ptype':
+            t += i.firstChild.data
+
+    t.strip()
+    m = isPointer.match(t)
+    if m:
+        t = ('%s%s'%(m.group(1), m.group(3))).strip()
+    return ( t, n.strip())
+
+def findEnums(dom):
+    return {i.getAttribute('name'): i.getAttribute('value') for i in findChildren(dom, [ 'registry', 'enums', 'enum' ])}
+
+def findCommands(dom):
+    ret = {}
+    for i in findChildren(dom, [ 'registry', 'commands', 'command' ]):
+      r,n = findParams(findChildren(i, ['proto'])[0])
+      p = [ findParams(j) for j in findChildren(i, ['param'])]
+      ret[n] = (r, p)
+    return ret
+
+def findFeatures(dom):
+    ret = {}
+    for i in findChildren(dom, [ 'registry', 'feature' ]):
+        n = i.getAttribute('name')
+        e = [j.getAttribute("name") for j in findChildren(i, [ 'require', 'enum' ])]
+        c = [j.getAttribute("name") for j in findChildren(i, [ 'require', 'command' ])]
+        ret[n] = (e,c)
+    return ret
+
+def findExtensions(dom):
+    ret = {}
+    for i in findChildren(dom, [ 'registry', 'extensions', 'extension' ]):
+        n = i.getAttribute('name')
+        e = [j.getAttribute("name") for j in findChildren(i, [ 'require', 'enum' ])]
+        c = [j.getAttribute("name") for j in findChildren(i, [ 'require', 'command' ])]
+        ret[n] = (e,c)
+    return ret
+
+def findApi(dom, name):
+    enums      = findEnums(dom)
+    commands   = findCommands(dom)
+    features   = findFeatures(dom)
+    extensions = findExtensions(dom)
+    return (enums, commands, features, extensions)
+
+#
+#
+#
+
+isWGL = re.compile('WGL_([A-Z0-9]+)_.*')
+
+def writeExtension(f, name, extension, enums, commands):
+    f.write(('%s\n'%name).encode())
+
+    url = 'https://www.khronos.org/registry/egl/specs/eglspec.1.5.pdf'
+
+    m = isWGL.match(name)
+    if m:
+        url = 'https://www.khronos.org/registry/OpenGL/extensions/%s/%s.txt'%(m.group(1), name)
+
+    f.write(('%s\n'%(url)).encode())
+
+    if name.find('_VERSION_')==-1:
+        f.write(('%s\n'%name).encode())
+    else:
+        f.write('\n'.encode())
+    f.write('\n'.encode())
+
+    enums = [ (j, enums[j]) for j in extension[0] ]
+    for e in sorted(enums, key=lambda i: i[1]):
+        f.write(('\t%s %s\n'%(e[0], e[1])).encode())
+
+    commands = [ (j, commands[j]) for j in extension[1] ]
+    for c in sorted(commands):
+        params = ', '.join( [ '%s %s'%(j[0].strip(), j[1].strip()) for j in c[1][1] ] )
+        if len(params)==0:
+            params = 'void'
+        f.write(('\t%s %s (%s)\n'%(c[1][0].strip(), c[0].strip(), params)).encode())
+
+if __name__ == '__main__':
+
+  from argparse import ArgumentParser
+  import os
+
+  parser = ArgumentParser(description='usage: %prog [options] [XML specs...]')
+  parser.add_argument("--core", dest="core", help="location for core outputs", default='')
+  parser.add_argument("--api", dest="name", help="API name: egl, wgl, glx, etc", default='')
+  parser.add_argument("--extensions", dest="extensions", help="location for extensions outputs", default='')
+
+  (options, args) = parser.parse_known_args()
+  options = vars(options)
+
+  for i in args:
+
+    dom = parse(i)
+    api = findApi(dom, options['name'])
+
+    print('Found {} enums, {} commands, {} features and {} extensions.'.format(
+        len(api[0]), len(api[1]), len(api[2]), len(api[3])))
+
+    if len(options['core']):
+        for i in api[2].keys():
+            with open(os.path.join(options['core'], i), 'wb') as f:
+                writeExtension(f, i, api[2][i], api[0], api[1])
+
+    if len(options['extensions']):
+        for i in api[3].keys():
+            with open(os.path.join(options['extensions'], i), 'wb') as f:
+                writeExtension(f, i, api[3][i], api[0], api[1])
+

Libraries/glew-2.3.1/auto/bin/update_ext.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+##
+## Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
+## Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
+## Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
+##
+## This program is distributed under the terms and conditions of the GNU
+## General Public License Version 2 as published by the Free Software
+## Foundation or, at your option, any later version.
+##
+## Parameters:
+##
+##       $1: Extensions directory
+##       $2: Registry directory
+##       $3: The black list
+
+set -e
+
+if [ ! -d $1 ] ; then
+    mkdir -p $1
+
+# Parse each of the extensions in the registry
+    find $2 -name doc -type d -prune -o -name "*.txt" -print | \
+	grep -v -f $3 | sort | bin/parse_spec.pl $1
+
+fi

Libraries/glew-2.3.1/auto/blacklist

@@ -0,0 +1,28 @@
+EXT/draw_range_elements.txt
+EXT/static_vertex_array.txt
+EXT/vertex_array_set.alt.txt
+EXT/vertex_array_set.txt
+EXT/nurbs_tessellator.txt
+EXT/object_space_tess.txt
+MESA/MESA_sampler_objects.txt
+SGI/filter4_parameters.txt
+SGIS/SGIS_texture_color_mask.txt
+SGIX/SGIX_dmbuffer.txt
+SGIX/SGIX_instruments.txt
+SGIX/SGIX_video_source.txt
+SGIX/SGIX_hyperpipe_group.txt
+OES/OES_fixed_point.txt
+OES/OES_query_matrix.txt
+IMG/IMG_user_clip_plane.txt
+NV/NV_query_resource.txt
+NV/EGL_NV_coverage_sample.txt
+OES/OES_draw_elements_base_vertex.txt
+OES/OES_viewport_array.txt
+OES/EGL_KHR_fence_sync.txt
+EXT/EXT_texenv_op.txt
+EXT/EXT_transform_feedback2.txt
+EXT/EXT_vertex_array_set.txt
+EXT/EXT_separate_shader_objects.gles.txt
+IGLOO/IGLOO_swap_triangle_strip_vertex_pointerXXX.txt
+IGLOO/IGLOO_viewport_offsetXXX.txt
+IGLOO/IGLOO_toggle_color_and_lightXXX.txt

Libraries/glew-2.3.1/auto/core/gl/EGL_EXT_device_base

@@ -0,0 +1,7 @@
+EGL_EXT_device_base
+https://www.khronos.org/registry/egl/specs/eglspec.1.5.pdf
+EGL_EXT_device_base
+
+	EGL_BAD_DEVICE_EXT 0x322B
+	EGL_DEVICE_EXT 0x322C
+	EGL_NO_DEVICE_EXT EGL_CAST(EGLDeviceEXT,0)

Libraries/glew-2.3.1/auto/core/gl/EGL_KHR_fence_sync

@@ -0,0 +1,7 @@
+EGL_KHR_fence_sync
+https://www.khronos.org/registry/egl/specs/eglspec.1.5.pdf
+EGL_KHR_fence_sync
+
+	EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR 0x30F0
+	EGL_SYNC_CONDITION_KHR 0x30F8
+	EGL_SYNC_FENCE_KHR 0x30F9

Libraries/glew-2.3.1/auto/core/gl/EGL_KHR_image_base

@@ -0,0 +1,6 @@
+EGL_KHR_image_base
+https://www.khronos.org/registry/egl/specs/eglspec.1.5.pdf
+EGL_KHR_image_base
+
+	EGL_IMAGE_PRESERVED_KHR 0x30D2
+	EGL_NO_IMAGE_KHR EGL_CAST(EGLImageKHR,0)

Libraries/glew-2.3.1/auto/core/gl/EGL_KHR_lock_surface3

@@ -0,0 +1,27 @@
+EGL_KHR_lock_surface3
+https://www.khronos.org/registry/egl/specs/eglspec.1.5.pdf
+EGL_KHR_lock_surface3
+
+	EGL_READ_SURFACE_BIT_KHR 0x0001
+	EGL_WRITE_SURFACE_BIT_KHR 0x0002
+	EGL_LOCK_SURFACE_BIT_KHR 0x0080
+	EGL_OPTIMAL_FORMAT_BIT_KHR 0x0100
+	EGL_MATCH_FORMAT_KHR 0x3043
+	EGL_FORMAT_RGB_565_EXACT_KHR 0x30C0
+	EGL_FORMAT_RGB_565_KHR 0x30C1
+	EGL_FORMAT_RGBA_8888_EXACT_KHR 0x30C2
+	EGL_FORMAT_RGBA_8888_KHR 0x30C3
+	EGL_MAP_PRESERVE_PIXELS_KHR 0x30C4
+	EGL_LOCK_USAGE_HINT_KHR 0x30C5
+	EGL_BITMAP_POINTER_KHR 0x30C6
+	EGL_BITMAP_PITCH_KHR 0x30C7
+	EGL_BITMAP_ORIGIN_KHR 0x30C8
+	EGL_BITMAP_PIXEL_RED_OFFSET_KHR 0x30C9
+	EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR 0x30CA
+	EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR 0x30CB
+	EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR 0x30CC
+	EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR 0x30CD
+	EGL_LOWER_LEFT_KHR 0x30CE
+	EGL_UPPER_LEFT_KHR 0x30CF
+	EGL_BITMAP_PIXEL_SIZE_KHR 0x3110
+	EGLBoolean  eglQuerySurface64KHR (EGLDisplay  dpy, EGLSurface  surface, EGLint  attribute, EGLAttribKHR * value)

Libraries/glew-2.3.1/auto/core/gl/EGL_VERSION_1_0

@@ -0,0 +1,86 @@
+EGL_VERSION_1_0
+https://www.khronos.org/registry/egl/specs/eglspec.1.5.pdf
+
+
+	EGL_FALSE 0
+	EGL_PBUFFER_BIT 0x0001
+	EGL_PIXMAP_BIT 0x0002
+	EGL_WINDOW_BIT 0x0004
+	EGL_SUCCESS 0x3000
+	EGL_NOT_INITIALIZED 0x3001
+	EGL_BAD_ACCESS 0x3002
+	EGL_BAD_ALLOC 0x3003
+	EGL_BAD_ATTRIBUTE 0x3004
+	EGL_BAD_CONFIG 0x3005
+	EGL_BAD_CONTEXT 0x3006
+	EGL_BAD_CURRENT_SURFACE 0x3007
+	EGL_BAD_DISPLAY 0x3008
+	EGL_BAD_MATCH 0x3009
+	EGL_BAD_NATIVE_PIXMAP 0x300A
+	EGL_BAD_NATIVE_WINDOW 0x300B
+	EGL_BAD_PARAMETER 0x300C
+	EGL_BAD_SURFACE 0x300D
+	EGL_BUFFER_SIZE 0x3020
+	EGL_ALPHA_SIZE 0x3021
+	EGL_BLUE_SIZE 0x3022
+	EGL_GREEN_SIZE 0x3023
+	EGL_RED_SIZE 0x3024
+	EGL_DEPTH_SIZE 0x3025
+	EGL_STENCIL_SIZE 0x3026
+	EGL_CONFIG_CAVEAT 0x3027
+	EGL_CONFIG_ID 0x3028
+	EGL_LEVEL 0x3029
+	EGL_MAX_PBUFFER_HEIGHT 0x302A
+	EGL_MAX_PBUFFER_PIXELS 0x302B
+	EGL_MAX_PBUFFER_WIDTH 0x302C
+	EGL_NATIVE_RENDERABLE 0x302D
+	EGL_NATIVE_VISUAL_ID 0x302E
+	EGL_NATIVE_VISUAL_TYPE 0x302F
+	EGL_SAMPLES 0x3031
+	EGL_SAMPLE_BUFFERS 0x3032
+	EGL_SURFACE_TYPE 0x3033
+	EGL_TRANSPARENT_TYPE 0x3034
+	EGL_TRANSPARENT_BLUE_VALUE 0x3035
+	EGL_TRANSPARENT_GREEN_VALUE 0x3036
+	EGL_TRANSPARENT_RED_VALUE 0x3037
+	EGL_NONE 0x3038
+	EGL_SLOW_CONFIG 0x3050
+	EGL_NON_CONFORMANT_CONFIG 0x3051
+	EGL_TRANSPARENT_RGB 0x3052
+	EGL_VENDOR 0x3053
+	EGL_VERSION 0x3054
+	EGL_EXTENSIONS 0x3055
+	EGL_HEIGHT 0x3056
+	EGL_WIDTH 0x3057
+	EGL_LARGEST_PBUFFER 0x3058
+	EGL_DRAW 0x3059
+	EGL_READ 0x305A
+	EGL_CORE_NATIVE_ENGINE 0x305B
+	EGL_TRUE 1
+	EGL_NO_CONTEXT EGL_CAST(EGLContext,0)
+	EGL_NO_DISPLAY EGL_CAST(EGLDisplay,0)
+	EGL_NO_SURFACE EGL_CAST(EGLSurface,0)
+	EGL_DONT_CARE EGL_CAST(EGLint,-1)
+	EGLBoolean  eglChooseConfig (EGLDisplay  dpy, const EGLint * attrib_list, EGLConfig * configs, EGLint  config_size, EGLint * num_config)
+	EGLBoolean  eglCopyBuffers (EGLDisplay  dpy, EGLSurface  surface, EGLNativePixmapType  target)
+	EGLContext  eglCreateContext (EGLDisplay  dpy, EGLConfig  config, EGLContext  share_context, const EGLint * attrib_list)
+	EGLSurface  eglCreatePbufferSurface (EGLDisplay  dpy, EGLConfig  config, const EGLint * attrib_list)
+	EGLSurface  eglCreatePixmapSurface (EGLDisplay  dpy, EGLConfig  config, EGLNativePixmapType  pixmap, const EGLint * attrib_list)
+	EGLSurface  eglCreateWindowSurface (EGLDisplay  dpy, EGLConfig  config, EGLNativeWindowType  win, const EGLint * attrib_list)
+	EGLBoolean  eglDestroyContext (EGLDisplay  dpy, EGLContext  ctx)
+	EGLBoolean  eglDestroySurface (EGLDisplay  dpy, EGLSurface  surface)
+	EGLBoolean  eglGetConfigAttrib (EGLDisplay  dpy, EGLConfig  config, EGLint  attribute, EGLint * value)
+	EGLBoolean  eglGetConfigs (EGLDisplay  dpy, EGLConfig * configs, EGLint  config_size, EGLint * num_config)
+	EGLDisplay  eglGetCurrentDisplay ( void )
+	EGLSurface  eglGetCurrentSurface (EGLint  readdraw)
+	EGLDisplay  eglGetDisplay (EGLNativeDisplayType  display_id)
+	EGLint  eglGetError ( void )
+	EGLBoolean  eglInitialize (EGLDisplay  dpy, EGLint * major, EGLint * minor)
+	EGLBoolean  eglMakeCurrent (EGLDisplay  dpy, EGLSurface  draw, EGLSurface  read, EGLContext  ctx)
+	EGLBoolean  eglQueryContext (EGLDisplay  dpy, EGLContext  ctx, EGLint  attribute, EGLint * value)
+	const char * eglQueryString (EGLDisplay  dpy, EGLint  name)
+	EGLBoolean  eglQuerySurface (EGLDisplay  dpy, EGLSurface  surface, EGLint  attribute, EGLint * value)
+	EGLBoolean  eglSwapBuffers (EGLDisplay  dpy, EGLSurface  surface)
+	EGLBoolean  eglTerminate (EGLDisplay  dpy)
+	EGLBoolean  eglWaitGL ( void )
+	EGLBoolean  eglWaitNative (EGLint  engine)

Libraries/glew-2.3.1/auto/core/gl/EGL_VERSION_1_1

@@ -0,0 +1,22 @@
+EGL_VERSION_1_1
+https://www.khronos.org/registry/egl/specs/eglspec.1.5.pdf
+
+
+	EGL_CONTEXT_LOST 0x300E
+	EGL_BIND_TO_TEXTURE_RGB 0x3039
+	EGL_BIND_TO_TEXTURE_RGBA 0x303A
+	EGL_MIN_SWAP_INTERVAL 0x303B
+	EGL_MAX_SWAP_INTERVAL 0x303C
+	EGL_NO_TEXTURE 0x305C
+	EGL_TEXTURE_RGB 0x305D
+	EGL_TEXTURE_RGBA 0x305E
+	EGL_TEXTURE_2D 0x305F
+	EGL_TEXTURE_FORMAT 0x3080
+	EGL_TEXTURE_TARGET 0x3081
+	EGL_MIPMAP_TEXTURE 0x3082
+	EGL_MIPMAP_LEVEL 0x3083
+	EGL_BACK_BUFFER 0x3084
+	EGLBoolean  eglBindTexImage (EGLDisplay  dpy, EGLSurface  surface, EGLint  buffer)
+	EGLBoolean  eglReleaseTexImage (EGLDisplay  dpy, EGLSurface  surface, EGLint  buffer)
+	EGLBoolean  eglSurfaceAttrib (EGLDisplay  dpy, EGLSurface  surface, EGLint  attribute, EGLint  value)
+	EGLBoolean  eglSwapInterval (EGLDisplay  dpy, EGLint  interval)