Remove broken example: standard_lighting

5 files changed, 0 insertions, 822 deletions

diff --git a/examples/others/resources/shaders/glsl100/standard.fs b/examples/others/resources/shaders/glsl100/standard.fs
deleted file mode 100644
index fe604e2a..00000000
--- a/examples/others/resources/shaders/glsl100/standard.fs
+++ /dev/null
@@ -1,152 +0,0 @@
-#version 100
-
-precision mediump float;
-
-varying vec3 fragPosition;
-varying vec2 fragTexCoord;
-varying vec4 fragColor;
-varying vec3 fragNormal;
-
-uniform sampler2D texture0;
-uniform sampler2D texture1;
-uniform sampler2D texture2;
-
-uniform vec4 colAmbient;
-uniform vec4 colDiffuse;
-uniform vec4 colSpecular;
-uniform float glossiness;
-
-uniform int useNormal;
-uniform int useSpecular;
-
-uniform mat4 modelMatrix;
-uniform vec3 viewDir;
-
-struct Light {
-    int enabled;
-    int type;
-    vec3 position;
-    vec3 direction;
-    vec4 diffuse;
-    float intensity;
-    float radius;
-    float coneAngle;
-};
-
-const int maxLights = 8;
-uniform Light lights[maxLights];
-
-vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
-{
-    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1.0));
-    vec3 surfaceToLight = l.position - surfacePos;
-    
-    // Diffuse shading
-    float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
-    float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
-    
-    // Specular shading
-    float spec = 0.0;
-    if (diff > 0.0)
-    {
-        vec3 h = normalize(-l.direction + v);
-        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
-    }
-    
-    return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
-}
-
-vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
-{
-    vec3 lightDir = normalize(-l.direction);
-    
-    // Diffuse shading
-    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
-    
-    // Specular shading
-    float spec = 0.0;
-    if (diff > 0.0)
-    {
-        vec3 h = normalize(lightDir + v);
-        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
-    }
-    
-    // Combine results
-    return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
-}
-
-vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
-{
-    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
-    vec3 lightToSurface = normalize(surfacePos - l.position);
-    vec3 lightDir = normalize(-l.direction);
-    
-    // Diffuse shading
-    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
-    
-    // Spot attenuation
-    float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
-    attenuation = dot(lightToSurface, -lightDir);
-    
-    float lightToSurfaceAngle = degrees(acos(attenuation));
-    if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
-    
-    float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
-    
-    // Combine diffuse and attenuation
-    float diffAttenuation = diff*attenuation;
-    
-    // Specular shading
-    float spec = 0.0;
-    if (diffAttenuation > 0.0)
-    {
-        vec3 h = normalize(lightDir + v);
-        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
-    }
-    
-    return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
-}
-
-void main()
-{
-    // Calculate fragment normal in screen space
-    // NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
-    mat3 normalMatrix = mat3(modelMatrix);
-    vec3 normal = normalize(normalMatrix*fragNormal);
-
-    // Normalize normal and view direction vectors
-    vec3 n = normalize(normal);
-    vec3 v = normalize(viewDir);
-
-    // Calculate diffuse texture color fetching
-    vec4 texelColor = texture2D(texture0, fragTexCoord);
-    vec3 lighting = colAmbient.rgb;
-    
-    // Calculate normal texture color fetching or set to maximum normal value by default
-    if (useNormal == 1)
-    {
-        n *= texture2D(texture1, fragTexCoord).rgb;
-        n = normalize(n);
-    }
-    
-    // Calculate specular texture color fetching or set to maximum specular value by default
-    float spec = 1.0;
-    if (useSpecular == 1) spec = texture2D(texture2, fragTexCoord).r;
-    
-    for (int i = 0; i < maxLights; i++)
-    {
-        // Check if light is enabled
-        if (lights[i].enabled == 1)
-        {
-            // Calculate lighting based on light type
-            if(lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
-            else if(lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
-            else if(lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
-            
-            // NOTE: It seems that too many ComputeLight*() operations inside for loop breaks the shader on RPI
-        }
-    }
-    
-    // Calculate final fragment color
-    gl_FragColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
-}
diff --git a/examples/others/resources/shaders/glsl100/standard.vs b/examples/others/resources/shaders/glsl100/standard.vs
deleted file mode 100644
index 2b958938..00000000
--- a/examples/others/resources/shaders/glsl100/standard.vs
+++ /dev/null
@@ -1,23 +0,0 @@
-#version 100
-
-attribute vec3 vertexPosition;
-attribute vec3 vertexNormal;
-attribute vec2 vertexTexCoord;
-attribute vec4 vertexColor;
-
-varying vec3 fragPosition;
-varying vec2 fragTexCoord;
-varying vec4 fragColor;
-varying vec3 fragNormal;
-
-uniform mat4 mvp;
-
-void main()
-{
-    fragPosition = vertexPosition;
-    fragTexCoord = vertexTexCoord;
-    fragColor = vertexColor;
-    fragNormal = vertexNormal;
-
-    gl_Position = mvp*vec4(vertexPosition, 1.0);
-}
\ No newline at end of file
diff --git a/examples/others/resources/shaders/glsl330/standard.fs b/examples/others/resources/shaders/glsl330/standard.fs
deleted file mode 100644
index 0d461484..00000000
--- a/examples/others/resources/shaders/glsl330/standard.fs
+++ /dev/null
@@ -1,150 +0,0 @@
-#version 330
-
-in vec3 fragPosition;
-in vec2 fragTexCoord;
-in vec4 fragColor;
-in vec3 fragNormal;
-
-out vec4 finalColor;
-
-uniform sampler2D texture0;
-uniform sampler2D texture1;
-uniform sampler2D texture2;
-
-uniform vec4 colAmbient;
-uniform vec4 colDiffuse;
-uniform vec4 colSpecular;
-uniform float glossiness;
-
-uniform int useNormal;
-uniform int useSpecular;
-
-uniform mat4 modelMatrix;
-uniform vec3 viewDir;
-
-struct Light {
-    int enabled;
-    int type;
-    vec3 position;
-    vec3 direction;
-    vec4 diffuse;
-    float intensity;
-    float radius;
-    float coneAngle;
-};
-
-const int maxLights = 8;
-uniform Light lights[maxLights];
-
-vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
-{
-    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
-    vec3 surfaceToLight = l.position - surfacePos;
-    
-    // Diffuse shading
-    float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
-    float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
-    
-    // Specular shading
-    float spec = 0.0;
-    if (diff > 0.0)
-    {
-        vec3 h = normalize(-l.direction + v);
-        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
-    }
-    
-    return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
-}
-
-vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
-{
-    vec3 lightDir = normalize(-l.direction);
-    
-    // Diffuse shading
-    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
-    
-    // Specular shading
-    float spec = 0.0;
-    if (diff > 0.0)
-    {
-        vec3 h = normalize(lightDir + v);
-        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
-    }
-    
-    // Combine results
-    return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
-}
-
-vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
-{
-    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
-    vec3 lightToSurface = normalize(surfacePos - l.position);
-    vec3 lightDir = normalize(-l.direction);
-    
-    // Diffuse shading
-    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
-    
-    // Spot attenuation
-    float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
-    attenuation = dot(lightToSurface, -lightDir);
-    
-    float lightToSurfaceAngle = degrees(acos(attenuation));
-    if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
-    
-    float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
-    
-    // Combine diffuse and attenuation
-    float diffAttenuation = diff*attenuation;
-    
-    // Specular shading
-    float spec = 0.0;
-    if (diffAttenuation > 0.0)
-    {
-        vec3 h = normalize(lightDir + v);
-        spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
-    }
-    
-    return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
-}
-
-void main()
-{
-    // Calculate fragment normal in screen space
-    // NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
-    mat3 normalMatrix = mat3(modelMatrix);
-    vec3 normal = normalize(normalMatrix*fragNormal);
-
-    // Normalize normal and view direction vectors
-    vec3 n = normalize(normal);
-    vec3 v = normalize(viewDir);
-
-    // Calculate diffuse texture color fetching
-    vec4 texelColor = texture(texture0, fragTexCoord);
-    vec3 lighting = colAmbient.rgb;
-    
-    // Calculate normal texture color fetching or set to maximum normal value by default
-    if (useNormal == 1)
-    {
-        n *= texture(texture1, fragTexCoord).rgb;
-        n = normalize(n);
-    }
-    
-    // Calculate specular texture color fetching or set to maximum specular value by default
-    float spec = 1.0;
-    if (useSpecular == 1) spec = texture(texture2, fragTexCoord).r;
-    
-    for (int i = 0; i < maxLights; i++)
-    {
-        // Check if light is enabled
-        if (lights[i].enabled == 1)
-        {
-            // Calculate lighting based on light type
-            if (lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
-            else if (lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
-            else if (lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
-        }
-    }
-    
-    // Calculate final fragment color
-    finalColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
-}
diff --git a/examples/others/resources/shaders/glsl330/standard.vs b/examples/others/resources/shaders/glsl330/standard.vs
deleted file mode 100644
index e2022201..00000000
--- a/examples/others/resources/shaders/glsl330/standard.vs
+++ /dev/null
@@ -1,23 +0,0 @@
-#version 330 
-
-in vec3 vertexPosition;
-in vec2 vertexTexCoord;
-in vec3 vertexNormal;
-in vec4 vertexColor;
-
-out vec3 fragPosition;
-out vec2 fragTexCoord;
-out vec3 fragNormal;
-out vec4 fragColor;
-
-uniform mat4 mvp;
-
-void main()
-{
-    fragPosition = vertexPosition;
-    fragTexCoord = vertexTexCoord;
-    fragNormal = vertexNormal;
-    fragColor = vertexColor;
-    
-    gl_Position = mvp*vec4(vertexPosition, 1.0);
-}
\ No newline at end of file
diff --git a/examples/others/standard_lighting.c b/examples/others/standard_lighting.c
deleted file mode 100644
index c37ae151..00000000
--- a/examples/others/standard_lighting.c
+++ /dev/null
@@ -1,474 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib [shaders] example - Standard lighting (materials and lights)
-*
-*   NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
-*         OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
-*
-*   NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
-*         on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
-*         raylib comes with shaders ready for both versions, check raylib/shaders install folder
-*
-*   This example has been created using raylib 1.7 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   Copyright (c) 2016-2017 Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#include <stdlib.h>         // Required for: NULL
-#include <string.h>         // Required for: strcpy()
-#include <math.h>           // Required for: vector math
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-#define MAX_LIGHTS      8   // Max lights supported by standard shader
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-
-// Light type
-typedef struct LightData {
-    unsigned int id;        // Light unique id
-    bool enabled;           // Light enabled
-    int type;               // Light type: LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT
-
-    Vector3 position;       // Light position
-    Vector3 target;         // Light direction: LIGHT_DIRECTIONAL and LIGHT_SPOT (cone direction target)
-    float radius;           // Light attenuation radius light intensity reduced with distance (world distance)
-
-    Color diffuse;          // Light diffuse color
-    float intensity;        // Light intensity level
-
-    float coneAngle;        // Light cone max angle: LIGHT_SPOT
-} LightData, *Light;
-
-// Light types
-typedef enum { LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT } LightType;
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-static Light lights[MAX_LIGHTS];            // Lights pool
-static int lightsCount = 0;                 // Enabled lights counter
-static int lightsLocs[MAX_LIGHTS][8];       // Lights location points in shader: 8 possible points per light: 
-                                            // enabled, type, position, target, radius, diffuse, intensity, coneAngle
-
-//----------------------------------------------------------------------------------
-// Module Functions Declaration
-//----------------------------------------------------------------------------------
-static Light CreateLight(int type, Vector3 position, Color diffuse); // Create a new light, initialize it and add to pool
-static void DestroyLight(Light light);     // Destroy a light and take it out of the list
-static void DrawLight(Light light);        // Draw light in 3D world
-
-static void GetShaderLightsLocations(Shader shader);    // Get shader locations for lights (up to MAX_LIGHTS)
-static void SetShaderLightsValues(Shader shader);       // Set shader uniform values for lights
-
-// Vector3 math functions
-static float VectorLength(const Vector3 v);             // Calculate vector length
-static void VectorNormalize(Vector3 *v);                // Normalize provided vector
-static Vector3 VectorSubtract(Vector3 v1, Vector3 v2);  // Substract two vectors
-
-
-//https://www.gamedev.net/topic/655969-speed-gluniform-vs-uniform-buffer-objects/
-//https://www.reddit.com/r/opengl/comments/4ri20g/is_gluniform_more_expensive_than_glprogramuniform/
-//http://cg.alexandra.dk/?p=3778 - AZDO
-//https://developer.apple.com/library/content/documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/BestPracticesforShaders/BestPracticesforShaders.html
-
-//------------------------------------------------------------------------------------
-// Program main entry point
-//------------------------------------------------------------------------------------
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
-    
-    SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
-
-    InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader");
-
-    // Define the camera to look into our 3d world
-    Camera camera = {{ 4.0f, 4.0f, 4.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
-    Vector3 position = { 0.0f, 0.0f, 0.0f };   // Set model position
-    
-    Model model = LoadModel("../models/resources/pbr/trooper.obj");                     // Load OBJ model
-
-    Material material = { 0 };
-    
-    material.shader = LoadShader("resources/shaders/glsl330/standard.vs", 
-                                 "resources/shaders/glsl330/standard.fs");
-    
-    // Try to get lights location points (if available)
-    GetShaderLightsLocations(material.shader);
-    
-    material.maps[MAP_DIFFUSE].texture = LoadTexture("../models/resources/pbr/trooper_albedo.png");   // Load model diffuse texture
-    material.maps[MAP_NORMAL].texture = LoadTexture("../models/resources/pbr/trooper_normals.png");     // Load model normal texture
-    material.maps[MAP_SPECULAR].texture = LoadTexture("../models/resources/pbr/trooper_roughness.png"); // Load model specular texture
-    material.maps[MAP_DIFFUSE].color = WHITE;
-    material.maps[MAP_SPECULAR].color = WHITE;
-    
-    model.materials[0] = material;      // Apply material to model
-
-    Light spotLight = CreateLight(LIGHT_SPOT, (Vector3){3.0f, 5.0f, 2.0f}, (Color){255, 255, 255, 255});
-    spotLight->target = (Vector3){0.0f, 0.0f, 0.0f};
-    spotLight->intensity = 2.0f;
-    spotLight->diffuse = (Color){255, 100, 100, 255};
-    spotLight->coneAngle = 60.0f;
-
-    Light dirLight = CreateLight(LIGHT_DIRECTIONAL, (Vector3){0.0f, -3.0f, -3.0f}, (Color){255, 255, 255, 255});
-    dirLight->target = (Vector3){1.0f, -2.0f, -2.0f};
-    dirLight->intensity = 2.0f;
-    dirLight->diffuse = (Color){100, 255, 100, 255};
-
-    Light pointLight = CreateLight(LIGHT_POINT, (Vector3){0.0f, 4.0f, 5.0f}, (Color){255, 255, 255, 255});
-    pointLight->intensity = 2.0f;
-    pointLight->diffuse = (Color){100, 100, 255, 255};
-    pointLight->radius = 3.0f;
-    
-    // Set shader lights values for enabled lights
-    // NOTE: If values are not changed in real time, they can be set at initialization!!!
-    SetShaderLightsValues(material.shader);
-    
-    // Setup orbital camera
-    SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
-
-    SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
-    //--------------------------------------------------------------------------------------
-
-    // Main game loop
-    while (!WindowShouldClose())            // Detect window close button or ESC key
-    {
-        // Update
-        //----------------------------------------------------------------------------------
-        UpdateCamera(&camera);              // Update camera
-        //----------------------------------------------------------------------------------
-
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
-
-            ClearBackground(RAYWHITE);
-
-            BeginMode3D(camera);
-                
-                DrawModel(model, position, 2.0f, WHITE);   // Draw 3d model with texture
-                
-                DrawLight(spotLight);   // Draw spot light
-                DrawLight(dirLight);    // Draw directional light
-                DrawLight(pointLight);  // Draw point light
-
-                DrawGrid(10, 1.0f);     // Draw a grid
-
-            EndMode3D();
-            
-            DrawFPS(10, 10);
-
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    UnloadMaterial(material);   // Unload material and assigned textures
-    UnloadModel(model);         // Unload model
-    
-    // Destroy all created lights
-    DestroyLight(pointLight);
-    DestroyLight(dirLight);
-    DestroyLight(spotLight);
-
-    // Unload lights
-    if (lightsCount > 0)
-    {
-        for (int i = 0; i < lightsCount; i++) free(lights[i]);
-        lightsCount = 0;
-    }
-
-    CloseWindow();              // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
-}
-
-//--------------------------------------------------------------------------------------------
-// Module Functions Definitions
-//--------------------------------------------------------------------------------------------
-
-// Create a new light, initialize it and add to pool
-Light CreateLight(int type, Vector3 position, Color diffuse)
-{
-    Light light = NULL;
-    
-    if (lightsCount < MAX_LIGHTS)
-    {
-        // Allocate dynamic memory
-        light = (Light)malloc(sizeof(LightData));
-        
-        // Initialize light values with generic values
-        light->id = lightsCount;
-        light->type = type;
-        light->enabled = true;
-        
-        light->position = position;
-        light->target = (Vector3){ 0.0f, 0.0f, 0.0f };
-        light->intensity = 1.0f;
-        light->diffuse = diffuse;
-        
-        // Add new light to the array
-        lights[lightsCount] = light;
-        
-        // Increase enabled lights count
-        lightsCount++;
-    }
-    else
-    {
-        // NOTE: Returning latest created light to avoid crashes
-        light = lights[lightsCount];
-    }
-
-    return light;
-}
-
-// Destroy a light and take it out of the list
-void DestroyLight(Light light)
-{
-    if (light != NULL)
-    {
-        int lightId = light->id;
-
-        // Free dynamic memory allocation
-        free(lights[lightId]);
-
-        // Remove *obj from the pointers array
-        for (int i = lightId; i < lightsCount; i++)
-        {
-            // Resort all the following pointers of the array
-            if ((i + 1) < lightsCount)
-            {
-                lights[i] = lights[i + 1];
-                lights[i]->id = lights[i + 1]->id;
-            }
-        }
-        
-        // Decrease enabled physic objects count
-        lightsCount--;
-    }
-}
-
-// Draw light in 3D world
-void DrawLight(Light light)
-{
-    switch (light->type)
-    {
-        case LIGHT_POINT:
-        {
-            DrawSphereWires(light->position, 0.3f*light->intensity, 8, 8, (light->enabled ? light->diffuse : GRAY));
-            
-            DrawCircle3D(light->position, light->radius, (Vector3){ 0, 0, 0 }, 0.0f, (light->enabled ? light->diffuse : GRAY));
-            DrawCircle3D(light->position, light->radius, (Vector3){ 1, 0, 0 }, 90.0f, (light->enabled ? light->diffuse : GRAY));
-            DrawCircle3D(light->position, light->radius, (Vector3){ 0, 1, 0 },90.0f, (light->enabled ? light->diffuse : GRAY));
-        } break;
-        case LIGHT_DIRECTIONAL:
-        {
-            DrawLine3D(light->position, light->target, (light->enabled ? light->diffuse : GRAY));
-            
-            DrawSphereWires(light->position, 0.3f*light->intensity, 8, 8, (light->enabled ? light->diffuse : GRAY));
-            DrawCubeWires(light->target, 0.3f, 0.3f, 0.3f, (light->enabled ? light->diffuse : GRAY));
-        } break;
-        case LIGHT_SPOT:
-        {
-            DrawLine3D(light->position, light->target, (light->enabled ? light->diffuse : GRAY));
-            
-            Vector3 dir = VectorSubtract(light->target, light->position);
-            VectorNormalize(&dir);
-            
-            DrawCircle3D(light->position, 0.5f, dir, 0.0f, (light->enabled ? light->diffuse : GRAY));
-            
-            //DrawCylinderWires(light->position, 0.0f, 0.3f*light->coneAngle/50, 0.6f, 5, (light->enabled ? light->diffuse : GRAY));
-            DrawCubeWires(light->target, 0.3f, 0.3f, 0.3f, (light->enabled ? light->diffuse : GRAY));
-        } break;
-        default: break;
-    }
-}
-
-// Get shader locations for lights (up to MAX_LIGHTS)
-static void GetShaderLightsLocations(Shader shader)
-{
-    char locName[32] = "lights[x].\0";
-    char locNameUpdated[64];
-    
-    for (int i = 0; i < MAX_LIGHTS; i++)
-    {
-        locName[7] = '0' + i;
-        
-        strcpy(locNameUpdated, locName);
-        strcat(locNameUpdated, "enabled\0");
-        lightsLocs[i][0] = GetShaderLocation(shader, locNameUpdated);
-        
-        locNameUpdated[0] = '\0';
-        strcpy(locNameUpdated, locName);
-        strcat(locNameUpdated, "type\0");
-        lightsLocs[i][1] = GetShaderLocation(shader, locNameUpdated);
-
-        locNameUpdated[0] = '\0';
-        strcpy(locNameUpdated, locName);
-        strcat(locNameUpdated, "position\0");
-        lightsLocs[i][2] = GetShaderLocation(shader, locNameUpdated);
-        
-        locNameUpdated[0] = '\0';
-        strcpy(locNameUpdated, locName);
-        strcat(locNameUpdated, "direction\0");
-        lightsLocs[i][3] = GetShaderLocation(shader, locNameUpdated);
-        
-        locNameUpdated[0] = '\0';
-        strcpy(locNameUpdated, locName);
-        strcat(locNameUpdated, "radius\0");
-        lightsLocs[i][4] = GetShaderLocation(shader, locNameUpdated);
-        
-        locNameUpdated[0] = '\0';
-        strcpy(locNameUpdated, locName);
-        strcat(locNameUpdated, "diffuse\0");
-        lightsLocs[i][5] = GetShaderLocation(shader, locNameUpdated);
-        
-        locNameUpdated[0] = '\0';
-        strcpy(locNameUpdated, locName);
-        strcat(locNameUpdated, "intensity\0");
-        lightsLocs[i][6] = GetShaderLocation(shader, locNameUpdated);
-        
-        locNameUpdated[0] = '\0';
-        strcpy(locNameUpdated, locName);
-        strcat(locNameUpdated, "coneAngle\0");
-        lightsLocs[i][7] = GetShaderLocation(shader, locNameUpdated);
-    }
-}
-
-// Set shader uniform values for lights
-// NOTE: It would be far easier with shader UBOs but are not supported on OpenGL ES 2.0
-static void SetShaderLightsValues(Shader shader)
-{
-    int tempInt[8] = { 0 };
-    float tempFloat[8] = { 0.0f };
-    
-    for (int i = 0; i < MAX_LIGHTS; i++)
-    {
-        if (i < lightsCount)
-        {
-            tempInt[0] = lights[i]->enabled;
-            SetShaderValue(shader, lightsLocs[i][0], tempInt, UNIFORM_INT); //glUniform1i(lightsLocs[i][0], lights[i]->enabled);
-            
-            tempInt[0] = lights[i]->type;
-            SetShaderValue(shader, lightsLocs[i][1], tempInt, UNIFORM_INT); //glUniform1i(lightsLocs[i][1], lights[i]->type);
-            
-            tempFloat[0] = (float)lights[i]->diffuse.r/255.0f;
-            tempFloat[1] = (float)lights[i]->diffuse.g/255.0f;
-            tempFloat[2] = (float)lights[i]->diffuse.b/255.0f;
-            tempFloat[3] = (float)lights[i]->diffuse.a/255.0f;
-            SetShaderValue(shader, lightsLocs[i][5], tempFloat, UNIFORM_VEC4);
-            //glUniform4f(lightsLocs[i][5], (float)lights[i]->diffuse.r/255, (float)lights[i]->diffuse.g/255, (float)lights[i]->diffuse.b/255, (float)lights[i]->diffuse.a/255);
-            
-            tempFloat[0] = lights[i]->intensity;
-            SetShaderValue(shader, lightsLocs[i][6], tempFloat, UNIFORM_FLOAT);
-            
-            switch (lights[i]->type)
-            {
-                case LIGHT_POINT:
-                {
-                    tempFloat[0] = lights[i]->position.x;
-                    tempFloat[1] = lights[i]->position.y;
-                    tempFloat[2] = lights[i]->position.z;
-                    SetShaderValue(shader, lightsLocs[i][2], tempFloat, UNIFORM_VEC3);
-
-                    tempFloat[0] = lights[i]->radius;
-                    SetShaderValue(shader, lightsLocs[i][4], tempFloat, UNIFORM_FLOAT);
-            
-                    //glUniform3f(lightsLocs[i][2], lights[i]->position.x, lights[i]->position.y, lights[i]->position.z);
-                    //glUniform1f(lightsLocs[i][4], lights[i]->radius);
-                } break;
-                case LIGHT_DIRECTIONAL:
-                {
-                    Vector3 direction = VectorSubtract(lights[i]->target, lights[i]->position);
-                    VectorNormalize(&direction);
-                    
-                    tempFloat[0] = direction.x;
-                    tempFloat[1] = direction.y;
-                    tempFloat[2] = direction.z;
-                    SetShaderValue(shader, lightsLocs[i][3], tempFloat, UNIFORM_VEC3);
-                    
-                    //glUniform3f(lightsLocs[i][3], direction.x, direction.y, direction.z);
-                } break;
-                case LIGHT_SPOT:
-                {
-                    tempFloat[0] = lights[i]->position.x;
-                    tempFloat[1] = lights[i]->position.y;
-                    tempFloat[2] = lights[i]->position.z;
-                    SetShaderValue(shader, lightsLocs[i][2], tempFloat, UNIFORM_VEC3);
-                    
-                    //glUniform3f(lightsLocs[i][2], lights[i]->position.x, lights[i]->position.y, lights[i]->position.z);
-                    
-                    Vector3 direction = VectorSubtract(lights[i]->target, lights[i]->position);
-                    VectorNormalize(&direction);
-                    
-                    tempFloat[0] = direction.x;
-                    tempFloat[1] = direction.y;
-                    tempFloat[2] = direction.z;
-                    SetShaderValue(shader, lightsLocs[i][3], tempFloat, UNIFORM_VEC3);
-                    //glUniform3f(lightsLocs[i][3], direction.x, direction.y, direction.z);
-                    
-                    tempFloat[0] = lights[i]->coneAngle;
-                    SetShaderValue(shader, lightsLocs[i][7], tempFloat, UNIFORM_FLOAT);
-                    //glUniform1f(lightsLocs[i][7], lights[i]->coneAngle);
-                } break;
-                default: break;
-            }
-        }
-        else
-        {
-            tempInt[0] = 0;
-            SetShaderValue(shader, lightsLocs[i][0], tempInt, UNIFORM_INT); //glUniform1i(lightsLocs[i][0], 0);   // Light disabled
-        }
-    }
-}
-
-// Calculate vector length
-float VectorLength(const Vector3 v)
-{
-    float length;
-
-    length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
-
-    return length;
-}
-
-// Normalize provided vector
-void VectorNormalize(Vector3 *v)
-{
-    float length, ilength;
-
-    length = VectorLength(*v);
-
-    if (length == 0.0f) length = 1.0f;
-
-    ilength = 1.0f/length;
-
-    v->x *= ilength;
-    v->y *= ilength;
-    v->z *= ilength;
-}
-
-// Substract two vectors
-Vector3 VectorSubtract(Vector3 v1, Vector3 v2)
-{
-    Vector3 result;
-
-    result.x = v1.x - v2.x;
-    result.y = v1.y - v2.y;
-    result.z = v1.z - v2.z;
-
-    return result;
-}