text: #include "OGL4BookOfShadersScenes.h"
  #include "ECS/Components/IncludeComponents.h"
  #include "Shape/Neutral/ShapeType.h"
  
  namespace ExtraLifeSandbox{
  
  	void OGL4BookOfShadersScenes::load_all_ogl4(const ExtraLife::ISceneLoader* scene_loader){
  		// Single Cube
  		single_cube_diffuse_lighting(scene_loader);
  		single_cube_phong_lighting(scene_loader);
  		single_cube_discard_effect(scene_loader);
  		single_cube_multiple_positional_lights(scene_loader);
  		single_cube_directional_light(scene_loader);
  		single_cube_directional_light_frag_calc(scene_loader);
  		single_cube_blinn_phong_directional(scene_loader);
  		single_cube_toon(scene_loader);
  
  		// Textured Cube
  		single_cube_textured_blinn_phong_one_material(scene_loader);
  		single_cube_textured_blinn_phong_two_materials(scene_loader);
  		single_cube_textured_blinn_phong_mixed(scene_loader);
  		single_cube_textured_blinn_phong_alpha_discard(scene_loader);
  	}
  	
  	void OGL4BookOfShadersScenes::single_cube_diffuse_lighting(const ExtraLife::ISceneLoader* scene_loader) {
  		// Load Shader
  		const std::string cube_id = "single_cube_test1";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/1_diffuse_vertex_shading.glsl", "Assets/shaders/models/colored_cube/1_diffuse_fragment_shading.glsl", true);
  
  		// Set Shader Uniforms
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  		shader_program->set_uniform("light_position_in_world", glm::vec3(100.0f, 20.0f, 0.0f));
  		shader_program->set_uniform("light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Prepare Components
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormals);		
  		ExtraLife::StandardShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Materials
  		ExtraLife::MaterialHandler* material_handler = cube_component.get_material_handler();
  		material_handler->attach_material_color(glm::vec4(0.2f, 0.4f, 0.2f, 1.0f), ExtraLife::MaterialColorType::DIFFUSE, "diffuse");
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(cube_entity, shader_program);
  		registry.emplace<ExtraLife::StandardShapeComponent>(cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(cube_entity, glm::vec3{ 0, 0, 0 });
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_phong_lighting(const ExtraLife::ISceneLoader* scene_loader){
  		// Load Shader
  		const std::string cube_id = "single_cube_test2";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/4_phong_2sided_vertex_shading.glsl", "Assets/shaders/models/colored_cube/4_phong_2sided_fragment_shading.glsl", true);
  
  		// Set Shader Uniforms
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  		shader_program->set_uniform("light_info.light_position_in_world", glm::vec3(0.0f, 20.0f, 0.0f));
  		shader_program->set_uniform("light_info.ambient_light_intensity", glm::vec4(0.4f, 0.4f, 0.4f, 1.0f));
  		shader_program->set_uniform("light_info.diffuse_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  		shader_program->set_uniform("light_info.specular_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Prepare Components
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormals);
  		ExtraLife::StandardShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Materials
  		ExtraLife::MaterialHandler* material_handler = cube_component.get_material_handler();
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::AMBIENT, "ambient");
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::DIFFUSE, "diffuse");
  		material_handler->attach_material_color(glm::vec4(0.8f, 0.8f, 0.8f, 1.0f), ExtraLife::MaterialColorType::SPECULAR, "specular");
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(cube_entity, shader_program);
  		registry.emplace<ExtraLife::StandardShapeComponent>(cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(cube_entity, glm::vec3{ 3, 0, 0 });
  
  		// Additional Shaders
  		// scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/2_phong_vertex_shading.glsl", "Assets/shaders/models/colored_cube/2_phong_fragment_shading.glsl", true);
  		// scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/3_phong_equation_vertex_shading.glsl", "Assets/shaders/models/colored_cube/3_phong_equation_fragment_shading.glsl", true);
  	}
  
  
  	void OGL4BookOfShadersScenes::single_cube_discard_effect(const ExtraLife::ISceneLoader* scene_loader) {
  		// Load Shader
  		const std::string cube_id = "single_cube_test3";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/5_phong_discard_vertex_shading.glsl", "Assets/shaders/models/colored_cube/5_phong_discard_fragment_shading.glsl", true);
  
  		// Set Shader Uniforms
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  		shader_program->set_uniform("light_info.light_position_in_world", glm::vec3(0.0f, 20.0f, 0.0f));
  		shader_program->set_uniform("light_info.ambient_light_intensity", glm::vec4(0.4f, 0.4f, 0.4f, 1.0f));
  		shader_program->set_uniform("light_info.diffuse_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  		shader_program->set_uniform("light_info.specular_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Prepare Components
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormalTextured);
  		ExtraLife::StandardShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Materials
  		ExtraLife::MaterialHandler* material_handler = cube_component.get_material_handler();
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::AMBIENT, "ambient");
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::DIFFUSE, "diffuse");
  		material_handler->attach_material_color(glm::vec4(0.8f, 0.8f, 0.8f, 1.0f), ExtraLife::MaterialColorType::SPECULAR, "specular");
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(cube_entity, shader_program);
  		registry.emplace<ExtraLife::StandardShapeComponent>(cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(cube_entity, glm::vec3{ 6, 0, 0 });
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_multiple_positional_lights(const ExtraLife::ISceneLoader* scene_loader) {
  		// Note: No attenuation or anything is taken into account with this example.
  
  		// Load Shader
  		const std::string cube_id = "single_cube_test4";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/6_phong_positional_lights_vertex_shading.glsl", "Assets/shaders/models/colored_cube/6_phong_positional_lights_fragment_shading.glsl", true);
  
  		// Set Shader Uniforms
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  
  		// Positional Light #1
  		shader_program->set_uniform("light_info[0].light_position_in_world", glm::vec3(0.0f, 20.0f, 0.0f));
  		shader_program->set_uniform("light_info[0].ambient_light_intensity", glm::vec4(0.4f, 0.4f, 0.4f, 1.0f));
  		shader_program->set_uniform("light_info[0].diffuse_specular_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Positional Light #2
  		shader_program->set_uniform("light_info[1].light_position_in_world", glm::vec3(0.0f, -20.0f, 0.0f));
  		shader_program->set_uniform("light_info[1].ambient_light_intensity", glm::vec4(0.4f, 0.4f, 0.4f, 1.0f));
  		shader_program->set_uniform("light_info[1].diffuse_specular_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Prepare Components
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormals);
  		ExtraLife::StandardShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Materials
  		ExtraLife::MaterialHandler* material_handler = cube_component.get_material_handler();
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::AMBIENT, "ambient");
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::DIFFUSE, "diffuse");
  		material_handler->attach_material_color(glm::vec4(0.8f, 0.8f, 0.8f, 1.0f), ExtraLife::MaterialColorType::SPECULAR, "specular");
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(cube_entity, shader_program);
  		registry.emplace<ExtraLife::StandardShapeComponent>(cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(cube_entity, glm::vec3{ 9, 0, 0 });
  
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_directional_light(const ExtraLife::ISceneLoader* scene_loader) {
  		// Directional Light
  		// 4th component as 0.0f indicates a light direction from object towards light source
  		// This is normalized in the shader.
  
  		// Load Shader
  		const std::string cube_id = "single_cube_test5";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/7_phong_directional_light_vertex_shading.glsl", "Assets/shaders/models/colored_cube/7_phong_directional_light_fragment_shading.glsl", true);
  
  		// Set Shader Uniforms
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  
  		// Light is directional or positional (0.0f in 4th position indicates directional light)
  		shader_program->set_uniform("light_info.light_in_world", glm::vec4(1.0f, -1.0f, 0.0f, 0.0f));
  		shader_program->set_uniform("light_info.ambient_light_intensity", glm::vec4(0.4f, 0.4f, 0.4f, 1.0f));
  		shader_program->set_uniform("light_info.diffuse_specular_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Prepare Components
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormals);
  		ExtraLife::StandardShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Materials
  		ExtraLife::MaterialHandler* material_handler = cube_component.get_material_handler();
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::AMBIENT, "ambient");
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::DIFFUSE, "diffuse");
  		material_handler->attach_material_color(glm::vec4(0.8f, 0.8f, 0.8f, 1.0f), ExtraLife::MaterialColorType::SPECULAR, "specular");
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(cube_entity, shader_program);
  		registry.emplace<ExtraLife::StandardShapeComponent>(cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(cube_entity, glm::vec3{ 12, 0, 0 });
  
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_directional_light_frag_calc(const ExtraLife::ISceneLoader* scene_loader) {
  		// Directional Light
  		// 4th component as 0.0f indicates a light direction from object towards light source
  		// This is normalized in the shader.
  
  		// Load Shader
  		const std::string cube_id = "single_cube_test6";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/8_phongF_directional_light_vertex_shading.glsl", "Assets/shaders/models/colored_cube/8_phongF_directional_light_fragment_shading.glsl", true);
  
  		// Set Shader Uniforms
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  
  		// Light is directional or positional (0.0f in 4th position indicates directional light)
  		shader_program->set_uniform("light_info.light_in_world", glm::vec4(0.0f, 1.0f, 1.0f, 0.0f));
  		shader_program->set_uniform("light_info.ambient_light_intensity", glm::vec4(0.4f, 0.4f, 0.4f, 1.0f));
  		shader_program->set_uniform("light_info.diffuse_specular_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Prepare Components
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormals);
  		ExtraLife::StandardShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Materials
  		ExtraLife::MaterialHandler* material_handler = cube_component.get_material_handler();
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::AMBIENT, "ambient");
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::DIFFUSE, "diffuse");
  		material_handler->attach_material_color(glm::vec4(0.8f, 0.8f, 0.8f, 1.0f), ExtraLife::MaterialColorType::SPECULAR, "specular");
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(cube_entity, shader_program);
  		registry.emplace<ExtraLife::StandardShapeComponent>(cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(cube_entity, glm::vec3{ 15, 0, 0 });
  
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_blinn_phong_directional(const ExtraLife::ISceneLoader* scene_loader) {
  		// Directional Light
  		// 4th component as 0.0f indicates a light direction from object towards light source
  		// This is normalized in the shader.
  
  		// Load Shader
  		const std::string cube_id = "single_cube_test7";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/9_BlinnPhong_directional_light_vertex_shading.glsl", "Assets/shaders/models/colored_cube/9_BlinnPhong_directional_light_fragment_shading.glsl", true);
  
  		// Set Shader Uniforms
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  
  		// Light is directional or positional (0.0f in 4th position indicates directional light)
  		shader_program->set_uniform("light_info.light_in_world", glm::vec4(1.0f, 1.0f, 1.0f, 0.0f));
  		shader_program->set_uniform("light_info.ambient_light_intensity", glm::vec4(0.4f, 0.4f, 0.4f, 1.0f));
  		shader_program->set_uniform("light_info.diffuse_specular_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Prepare Components
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormals);
  		ExtraLife::StandardShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Materials
  		ExtraLife::MaterialHandler* material_handler = cube_component.get_material_handler();
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::AMBIENT, "ambient");
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::DIFFUSE, "diffuse");
  		material_handler->attach_material_color(glm::vec4(0.8f, 0.8f, 0.8f, 1.0f), ExtraLife::MaterialColorType::SPECULAR, "specular");
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(cube_entity, shader_program);
  		registry.emplace<ExtraLife::StandardShapeComponent>(cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(cube_entity, glm::vec3{ 18, 0, 0 });
  
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_toon(const ExtraLife::ISceneLoader* scene_loader) {
  		// Directional Light
  		// 4th component as 0.0f indicates a light direction from object towards light source
  		// This is normalized in the shader.
  		
  		// Load Shader
  		const std::string cube_id = "single_cube_test8";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/colored_cube/10_toon_vertex_shading.glsl", "Assets/shaders/models/colored_cube/10_toon_fragment_shading.glsl", true);
  
  		// Set Shader Uniforms
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  
  		// Light is directional or positional (0.0f in 4th position indicates directional light)
  		shader_program->set_uniform("light_info.light_in_world", glm::vec4(1.0f, -1.0f, 0.0f, 0.0f));
  		shader_program->set_uniform("light_info.ambient_light_intensity", glm::vec4(0.4f, 0.4f, 0.4f, 1.0f));
  		shader_program->set_uniform("light_info.diffuse_specular_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Prepare Components
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormals);
  		ExtraLife::StandardShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Materials
  		ExtraLife::MaterialHandler* material_handler = cube_component.get_material_handler();
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::AMBIENT, "ambient");
  		material_handler->attach_material_color(glm::vec4(0.9f, 0.5f, 0.3f, 1.0f), ExtraLife::MaterialColorType::DIFFUSE, "diffuse");
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(cube_entity, shader_program);
  		registry.emplace<ExtraLife::StandardShapeComponent>(cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(cube_entity, glm::vec3{ 21, 0, 0 });
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_textured_blinn_phong_one_material(const ExtraLife::ISceneLoader* scene_loader) {
  		// Specular impact is similar to the colored cube (no specular material being used)
  		
  		// Load Shader
  		const std::string cube_id = "single_cube_textured1";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/textured_cube/1_BlinnPhong_light_vertex_shading.glsl", "Assets/shaders/models/textured_cube/1_BlinnPhong_light_fragment_shading.glsl", true);
  
  		// Load Textures
  		scene_loader->load_texture("brown_container", "Assets/textures/brown_container.png", ExtraLife::TextureType::DIFFUSE);
  		
  		// Prepare Components
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormalTextured);
  		ExtraLife::TexturedShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Textures
  		ExtraLife::ITextureHandler* texture_handler = cube_component.get_texture_handler();
  		texture_handler->attach_texture(*scene_loader->get_texture("brown_container"), ExtraLife::TextureType::DIFFUSE, "diffuse");
  
  		// Set Uniforms				
  		// Lights (0.0f in 4th position indicates directional light)
  		shader_program->set_uniform("light_info.light_in_world", glm::vec4(-1.0f, 1.0f, 0.0f, 0.0f));
  
  		// Scene Lights
  		shader_program->set_uniform("scenelight.scale_light_intensity", glm::vec4(8.0f, 8.0f, 8.0f, 1.0f));
  		shader_program->set_uniform("scenelight.ambient_intensity", glm::vec4(0.2f, 0.2f, 0.2f, 1.0f));
  		shader_program->set_uniform("scenelight.diffuse_intensity", glm::vec4(0.5f, 0.5f, 0.5f, 1.0f));
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity textured_cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(textured_cube_entity, shader_program);
  		registry.emplace<ExtraLife::TexturedShapeComponent>(textured_cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(textured_cube_entity, glm::vec3{ -3.0f, 0.0f, 0.0f });
  
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_textured_blinn_phong_two_materials(const ExtraLife::ISceneLoader* scene_loader) {
  
  		// Load Shader
  		const std::string cube_id = "single_cube_textured2";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/textured_cube/1_1_BlinnPhong_light_vertex_shading_2_textures.glsl", "Assets/shaders/models/textured_cube/1_1_BlinnPhong_light_fragment_shading_2_textures.glsl", true);
  
  		// Load Textures
  		// Specular impact is similar to the colored cube (no specular material being used)
  		scene_loader->load_texture("brown_container", "Assets/textures/brown_container.png", ExtraLife::TextureType::DIFFUSE);
  		scene_loader->load_texture("brown_container_specular", "Assets/textures/container_specular_map.png", ExtraLife::TextureType::SPECULAR);
  
  		// Prepare Components
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormalTextured);
  		ExtraLife::TexturedShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  				
  		// Attach Textures
  		ExtraLife::ITextureHandler* texture_handler = cube_component.get_texture_handler();
  		texture_handler->attach_texture(*scene_loader->get_texture("brown_container"), ExtraLife::TextureType::DIFFUSE, "diffuse");
  		texture_handler->attach_texture(*scene_loader->get_texture("brown_container_specular"), ExtraLife::TextureType::SPECULAR, "specular");
  
  		// Set Uniforms	
  		// Lights (0.0f in 4th position indicates directional light)
  		shader_program->set_uniform("light_info.light_in_world", glm::vec4(-1.0f, 1.0f, 0.0f, 0.0f));
  
  		// Scene Lights
  		shader_program->set_uniform("scenelight.scale_light_intensity", glm::vec4(8.0f, 8.0f, 8.0f, 1.0f));
  		shader_program->set_uniform("scenelight.ambient_intensity", glm::vec4(0.2f, 0.2f, 0.2f, 1.0f));
  		shader_program->set_uniform("scenelight.diffuse_intensity", glm::vec4(0.5f, 0.5f, 0.5f, 1.0f));
  		shader_program->set_uniform("scenelight.specular_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity textured_cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(textured_cube_entity, shader_program);
  		registry.emplace<ExtraLife::TexturedShapeComponent>(textured_cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(textured_cube_entity, glm::vec3{ -6.0f, 0.0f, 0.0f });
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_textured_blinn_phong_mixed(const ExtraLife::ISceneLoader* scene_loader) {
  		// Load Shader
  		const std::string cube_id = "single_cube_textured3";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/textured_cube/2_BlinnPhong_light_vertex_shading_2_textures.glsl", "Assets/shaders/models/textured_cube/2_BlinnPhong_light_fragment_shading_2_textures.glsl", true);
  
  		// Load Textures
  		scene_loader->load_texture("brick", "Assets/textures/brick.jpg", ExtraLife::TextureType::DIFFUSE);
  		scene_loader->load_texture("moss", "Assets/textures/moss.png", ExtraLife::TextureType::DIFFUSE);
  
  		// Prepare Components
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormalTextured);
  		ExtraLife::TexturedShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Textures
  		ExtraLife::ITextureHandler* texture_handler = cube_component.get_texture_handler();
  		texture_handler->attach_texture(*scene_loader->get_texture("brick"), ExtraLife::TextureType::DIFFUSE, "diffuse1");
  		texture_handler->attach_texture(*scene_loader->get_texture("moss"), ExtraLife::TextureType::DIFFUSE, "diffuse2");
  
  		// Set Uniforms
  		// Lights (0.0f in 4th position indicates directional light)
  		shader_program->set_uniform("light_info.light_in_world", glm::vec4(-1.0f, 1.0f, 0.0f, 0.0f));
  
  		// Scene Lights
  		shader_program->set_uniform("scenelight.scale_light_intensity", glm::vec4(8.0f, 8.0f, 8.0f, 1.0f));
  		shader_program->set_uniform("scenelight.ambient_intensity", glm::vec4(0.2f, 0.2f, 0.2f, 1.0f));
  		shader_program->set_uniform("scenelight.diffuse_intensity", glm::vec4(0.5f, 0.5f, 0.5f, 1.0f));
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity textured_cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(textured_cube_entity, shader_program);
  		registry.emplace<ExtraLife::TexturedShapeComponent>(textured_cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(textured_cube_entity, glm::vec3{ -9.0f, 0.0f, 0.0f });
  	}
  
  	void OGL4BookOfShadersScenes::single_cube_textured_blinn_phong_alpha_discard(const ExtraLife::ISceneLoader* scene_loader) {
  		// Load Shader
  		const std::string cube_id = "single_cube_textured4";
  		scene_loader->load_shader(cube_id, "Assets/shaders/models/textured_cube/3_BlinnPhong_light_vertex_shading_discard_fragments.glsl", "Assets/shaders/models/textured_cube/3_BlinnPhong_light_fragment_shading_discard_fragments.glsl", true);
  
  		// Load Textures
  		scene_loader->load_texture("brick", "Assets/textures/brick.jpg", ExtraLife::TextureType::DIFFUSE);
  		scene_loader->load_texture("moss", "Assets/textures/moss.png", ExtraLife::TextureType::DIFFUSE);
  
  		// Prepare Components
  		ExtraLife::IShaderProgram* shader_program = scene_loader->get_shader(cube_id);
  		const ExtraLife::ShapeMetadata shape_metadata = scene_loader->get_shape_metadata(ExtraLife::ShapeType::CubeNormalTextured);
  		ExtraLife::TexturedShapeComponent cube_component{ shape_metadata.m_vao_id, shape_metadata.m_index_count, *shader_program };
  
  		// Attach Textures
  		ExtraLife::ITextureHandler* texture_handler = cube_component.get_texture_handler();
  		texture_handler->attach_texture(*scene_loader->get_texture("brick"), ExtraLife::TextureType::DIFFUSE, "diffuse1");
  		texture_handler->attach_texture(*scene_loader->get_texture("moss"), ExtraLife::TextureType::DIFFUSE, "diffuse2");
  
  		// Set Uniforms
  		// Lights (0.0f in 4th position indicates directional light)
  		shader_program->set_uniform("light_info.light_in_world", glm::vec4(-1.0f, 1.0f, 0.0f, 0.0f));
  
  		// Scene Lights
  		shader_program->set_uniform("scenelight.scale_light_intensity", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
  		shader_program->set_uniform("scenelight.ambient_intensity", glm::vec4(0.2f, 0.2f, 0.2f, 1.0f));
  		shader_program->set_uniform("scenelight.diffuse_intensity", glm::vec4(0.5f, 0.5f, 0.5f, 1.0f));
  
  		// Load Entity
  		entt::registry& registry = scene_loader->get_registry();
  		const entt::entity textured_cube_entity = registry.create();
  		registry.emplace<ExtraLife::ShaderComponent>(textured_cube_entity, shader_program);
  		registry.emplace<ExtraLife::TexturedShapeComponent>(textured_cube_entity, cube_component);
  		registry.emplace<ExtraLife::TransformComponent>(textured_cube_entity, glm::vec3{ -12.0f, 0.0f, 0.0f });
  	}
  	
  } // namespace ExtraLifeSandbox