Review examples collection -WIP-

WARNING: Examples list has been reviewed but examples haven't been recompiled yet... that's not trivial...

9 files changed, 0 insertions, 1754 deletions

diff --git a/examples/web/others/audio_standalone.c b/examples/web/others/audio_standalone.c
deleted file mode 100644
index 3edf889..0000000
--- a/examples/web/others/audio_standalone.c
+++ /dev/null
@@ -1,123 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib [audio] example - Using audio module as standalone module
-*
-*   NOTE: This example does not require any graphic device, it can run directly on console.
-*
-*   [audio] module requires some external libs:
-*       OpenAL Soft - Audio device management lib (http://kcat.strangesoft.net/openal.html)
-*       stb_vorbis - Ogg audio files loading (http://www.nothings.org/stb_vorbis/)
-*       jar_xm - XM module file loading
-*       jar_mod - MOD audio file loading
-*
-*   Compile audio module using:
-*   gcc -c audio.c stb_vorbis.c -Wall -std=c99 -DAUDIO_STANDALONE
-*
-*   Compile example using:
-*   gcc -o $(NAME_PART).exe $(FILE_NAME) audio.o stb_vorbis.o -lopenal32 -std=c99
-*
-*   This example has been created using raylib 1.5 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include <stdio.h>
-#if defined(_WIN32)
-#include <conio.h>      // Windows only, no stardard library
-#endif
-#include "audio.h"
-
-#if defined(__linux__)
-
-#include <stdio.h>
-#include <termios.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-static int kbhit(void)
-{
-	struct termios oldt, newt;
-	int ch;
-	int oldf;
-
-	tcgetattr(STDIN_FILENO, &oldt);
-	newt = oldt;
-	newt.c_lflag &= ~(ICANON | ECHO);
-	tcsetattr(STDIN_FILENO, TCSANOW, &newt);
-	oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
-	fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
-
-	ch = getchar();
-
-	tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
-	fcntl(STDIN_FILENO, F_SETFL, oldf);
-
-	if(ch != EOF)
-	{
-		ungetc(ch, stdin);
-		return 1;
-	}
-
-	return 0;
-}
-
-static char getch()
-{
-	return getchar();
-}
-
-#endif
-
-#define KEY_ESCAPE  27
-
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    unsigned char key;
-    
-    InitAudioDevice();
-    
-    Sound fxWav = LoadSound("resources/audio/weird.wav");         // Load WAV audio file
-    Sound fxOgg = LoadSound("resources/audio/tanatana.ogg");      // Load OGG audio file
-    
-    Music music = LoadMusicStream("resources/audio/guitar_noodling.ogg");
-    PlayMusicStream(music);
-
-    printf("\nPress s or d to play sounds...\n");
-    //--------------------------------------------------------------------------------------
-
-    // Main loop
-    while (key != KEY_ESCAPE)
-    {
-        if (kbhit()) key = getch();
-
-        if (key == 's')
-        {
-            PlaySound(fxWav);
-            key = 0;
-        }
-        
-        if (key == 'd')
-        {
-            PlaySound(fxOgg);
-            key = 0;
-        }
-        
-        UpdateMusicStream(music);
-    }
-    
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    UnloadSound(fxWav);         // Unload sound data
-    UnloadSound(fxOgg);         // Unload sound data
-    
-    UnloadMusicStream(music);   // Unload music stream data
-    
-    CloseAudioDevice();
-    //--------------------------------------------------------------------------------------
-
-    return 0;
-}
diff --git a/examples/web/others/font_selector.c b/examples/web/others/font_selector.c
deleted file mode 100644
index 0984bbd..0000000
--- a/examples/web/others/font_selector.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib [core] example - Font selector (adapted for HTML5 platform)
-*
-*   This example has been created using raylib 1.3 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#if defined(PLATFORM_WEB)
-    #include <emscripten/emscripten.h>
-#endif
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-int screenWidth = 800;
-int screenHeight = 450;
-
-SpriteFont fonts[8];        // SpriteFont array
-
-int currentFont = 0;        // Selected font
-
-Color *colors;
-const char (*fontNames)[20];
-
-const char text[50] = "THIS is THE FONT you SELECTED!";
-
-Vector2 textSize;
-Vector2 mousePoint;
-
-Color btnNextOutColor;       // Button color (outside line)
-Color btnNextInColor;        // Button color (inside)
-
-int framesCounter = 0;      // Useful to count frames button is 'active' = clicked
-int positionY = 180;        // Text selector and button Y position
-
-Rectangle btnNextRec;
-
-//----------------------------------------------------------------------------------
-// Module Functions Declaration
-//----------------------------------------------------------------------------------
-void UpdateDrawFrame(void);     // Update and Draw one frame
-
-//----------------------------------------------------------------------------------
-// Main Enry Point
-//----------------------------------------------------------------------------------
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    InitWindow(screenWidth, screenHeight, "raylib [text] example - font selector");
-    
-    btnNextOutColor = DARKBLUE;
-    btnNextInColor = SKYBLUE;
-    
-    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
-    fonts[0] = LoadSpriteFont("resources/fonts/alagard.rbmf");       // SpriteFont loading
-    fonts[1] = LoadSpriteFont("resources/fonts/pixelplay.rbmf");     // SpriteFont loading
-    fonts[2] = LoadSpriteFont("resources/fonts/mecha.rbmf");         // SpriteFont loading
-    fonts[3] = LoadSpriteFont("resources/fonts/setback.rbmf");       // SpriteFont loading
-    fonts[4] = LoadSpriteFont("resources/fonts/romulus.rbmf");       // SpriteFont loading
-    fonts[5] = LoadSpriteFont("resources/fonts/pixantiqua.rbmf");    // SpriteFont loading
-    fonts[6] = LoadSpriteFont("resources/fonts/alpha_beta.rbmf");    // SpriteFont loading
-    fonts[7] = LoadSpriteFont("resources/fonts/jupiter_crash.rbmf"); // SpriteFont loading
-    
-    Color tempColors[8] = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, RED };
-    
-    colors = tempColors;
-    
-    const char tempFontNames[8][20] = { "[0] Alagard", "[1] PixelPlay", "[2] MECHA", "[3] Setback",
-                         "[4] Romulus", "[5] PixAntiqua", "[6] Alpha Beta", "[7] Jupiter Crash" };;
-                         
-    fontNames = tempFontNames;
-    
-    textSize = MeasureTextEx(fonts[currentFont], text, fonts[currentFont].baseSize*3, 1);
-    
-    btnNextRec = (Rectangle){ 673, positionY, 109, 44 };    // Button rectangle (useful for collision)
-    
-#if defined(PLATFORM_WEB)
-    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
-#else
-    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
-    //--------------------------------------------------------------------------------------
-    
-    // Main game loop
-    while (!WindowShouldClose())    // Detect window close button or ESC key
-    {
-        UpdateDrawFrame();
-    }
-#endif
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    for (int i = 0; i < 8; i++) UnloadSpriteFont(fonts[i]);       // SpriteFont(s) unloading
-    
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
-}
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition
-//----------------------------------------------------------------------------------
-void UpdateDrawFrame(void)
-{
-    // Update
-    //----------------------------------------------------------------------------------
-    // Keyboard-based font selection (easy)
-    if (IsKeyPressed(KEY_RIGHT))
-    {
-        if (currentFont < 7) currentFont++;
-    }
-
-    if (IsKeyPressed(KEY_LEFT))
-    {
-        if (currentFont > 0) currentFont--;
-    }
-    
-    if (IsKeyPressed('0')) currentFont = 0;
-    else if (IsKeyPressed('1')) currentFont = 1;
-    else if (IsKeyPressed('2')) currentFont = 2;
-    else if (IsKeyPressed('3')) currentFont = 3;
-    else if (IsKeyPressed('4')) currentFont = 4;
-    else if (IsKeyPressed('5')) currentFont = 5;
-    else if (IsKeyPressed('6')) currentFont = 6;
-    else if (IsKeyPressed('7')) currentFont = 7;
-
-    // Mouse-based font selection (NEXT button logic)
-    mousePoint = GetMousePosition();
-
-    if (CheckCollisionPointRec(mousePoint, btnNextRec))
-    {
-        // Mouse hover button logic
-        if (framesCounter == 0)
-        {
-            btnNextOutColor = DARKPURPLE;
-            btnNextInColor = PURPLE;
-        }
-
-        if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
-        {
-            framesCounter = 20;         // Frames button is 'active'
-            btnNextOutColor = MAROON;
-            btnNextInColor = RED;
-        }
-    }
-    else
-    {
-        // Mouse not hover button
-        btnNextOutColor = DARKBLUE;
-        btnNextInColor = SKYBLUE;
-    }
-    
-    if (framesCounter > 0) framesCounter--;
-
-    if (framesCounter == 1)     // We change font on frame 1
-    {
-        currentFont++;
-        if (currentFont > 7) currentFont = 0;
-    }
-
-    // Text measurement for better positioning on screen
-    textSize = MeasureTextEx(fonts[currentFont], text, fonts[currentFont].baseSize*3, 1);
-    //----------------------------------------------------------------------------------
-
-    // Draw
-    //----------------------------------------------------------------------------------
-    BeginDrawing();
-
-        ClearBackground(RAYWHITE);
-
-        DrawText("font selector - use arroys, button or numbers", 160, 80, 20, DARKGRAY);
-        DrawLine(120, 120, 680, 120, DARKGRAY);
-
-        DrawRectangle(18, positionY, 644, 44, DARKGRAY);
-        DrawRectangle(20, positionY + 2, 640, 40, LIGHTGRAY);
-        DrawText(fontNames[currentFont], 30, positionY + 13, 20, BLACK);
-        DrawText("< >", 610, positionY + 8, 30, BLACK);
-
-        DrawRectangleRec(btnNextRec, btnNextOutColor);
-        DrawRectangle(675, positionY + 2, 105, 40, btnNextInColor);
-        DrawText("NEXT", 700, positionY + 13, 20, btnNextOutColor);
-
-        DrawTextEx(fonts[currentFont], text, (Vector2){ screenWidth/2 - textSize.x/2,
-                   260 + (70 - textSize.y)/2 }, fonts[currentFont].baseSize*3,
-                   1, colors[currentFont]);
-
-    EndDrawing();
-    //----------------------------------------------------------------------------------
-}
\ No newline at end of file
diff --git a/examples/web/others/oculus_rift.c b/examples/web/others/oculus_rift.c
deleted file mode 100644
index f1b0bd3..0000000
--- a/examples/web/others/oculus_rift.c
+++ /dev/null
@@ -1,538 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib [core] example - Oculus Rift CV1
-*
-*   Compile example using:
-*   gcc -o $(NAME_PART).exe $(FILE_NAME) -I..\src\external -I..\src\external\OculusSDK\LibOVR\Include /
-*       -L. -L..\src\external\OculusSDK\LibOVR -lLibOVRRT32_1 -lraylib -lglfw3 -lopengl32 -lgdi32 -std=c99 /
-*       -Wl,-allow-multiple-definition
-*
-*   #define SUPPORT_OCULUS_RIFT_CV1 / RLGL_OCULUS_SUPPORT
-*       Enable Oculus Rift CV1 functionality
-*
-*   This example has been created using raylib 1.5 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#include "glad.h"                   // Required for: OpenGL types and functions declarations
-#include "raymath.h"                // Required for: Vector3, Quaternion and Matrix functionality
-
-#include <string.h>                 // Required for: memset()
-#include <stdlib.h>                 // Required for: exit()
-#include <stdio.h>                  // required for: vfprintf()
-#include <stdarg.h>                 // Required for: va_list, va_start(), vfprintf(), va_end()
-
-#define RLGL_OCULUS_SUPPORT         // Enable Oculus Rift code
-#if defined(RLGL_OCULUS_SUPPORT)
-    #include "OVR_CAPI_GL.h"        // Oculus SDK for OpenGL
-#endif
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-// ...
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-
-// TraceLog message types
-typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
-
-#if defined(RLGL_OCULUS_SUPPORT)
-// Oculus buffer type
-typedef struct OculusBuffer {
-    ovrTextureSwapChain textureChain;
-    GLuint depthId;
-    GLuint fboId;
-    int width;
-    int height;
-} OculusBuffer;
-
-// Oculus mirror texture type
-typedef struct OculusMirror {
-    ovrMirrorTexture texture;
-    GLuint fboId;
-    int width;
-    int height;
-} OculusMirror;
-
-// Oculus layer type
-typedef struct OculusLayer {
-    ovrViewScaleDesc viewScaleDesc;
-    ovrLayerEyeFov eyeLayer;      // layer 0
-    //ovrLayerQuad quadLayer;     // TODO: layer 1: '2D' quad for GUI
-    Matrix eyeProjections[2];
-    int width;
-    int height;
-} OculusLayer;
-#endif
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-#if defined(RLGL_OCULUS_SUPPORT)
-// OVR device variables
-static ovrSession session;              // Oculus session (pointer to ovrHmdStruct)
-static ovrHmdDesc hmdDesc;              // Oculus device descriptor parameters
-static ovrGraphicsLuid luid;            // Oculus locally unique identifier for the program (64 bit)
-static OculusLayer layer;               // Oculus drawing layer (similar to photoshop)
-static OculusBuffer buffer;             // Oculus internal buffers (texture chain and fbo)
-static OculusMirror mirror;             // Oculus mirror texture and fbo
-static unsigned int frameIndex = 0;     // Oculus frames counter, used to discard frames from chain
-#endif
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Declaration
-//----------------------------------------------------------------------------------
-#if defined(RLGL_OCULUS_SUPPORT)
-static bool InitOculusDevice(void);                 // Initialize Oculus device (returns true if success)
-static void CloseOculusDevice(void);                // Close Oculus device
-static void UpdateOculusTracking(Camera *camera);   // Update Oculus head position-orientation tracking
-static void BeginOculusDrawing(void);               // Setup Oculus buffers for drawing
-static void EndOculusDrawing(void);                 // Finish Oculus drawing and blit framebuffer to mirror
-
-static OculusBuffer LoadOculusBuffer(ovrSession session, int width, int height);    // Load Oculus required buffers
-static void UnloadOculusBuffer(ovrSession session, OculusBuffer buffer);            // Unload texture required buffers
-static OculusMirror LoadOculusMirror(ovrSession session, int width, int height);    // Load Oculus mirror buffers
-static void UnloadOculusMirror(ovrSession session, OculusMirror mirror);            // Unload Oculus mirror buffers
-static void BlitOculusMirror(ovrSession session, OculusMirror mirror);              // Copy Oculus screen buffer to mirror texture
-static OculusLayer InitOculusLayer(ovrSession session);                             // Init Oculus layer (similar to photoshop)
-static Matrix FromOvrMatrix(ovrMatrix4f ovrM);  // Convert from Oculus ovrMatrix4f struct to raymath Matrix struct
-#endif
-
-static void TraceLog(int msgType, const char *text, ...);
-
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    int screenWidth = 1080;
-    int screenHeight = 600;
-    
-    // NOTE: screenWidth/screenHeight should match VR device aspect ratio
-    
-    InitWindow(screenWidth, screenHeight, "raylib [core] example - oculus rift");
-    
-    bool vrDeviceReady = InitOculusDevice();            // Init VR device Oculus Rift CV1
-    
-    if (!vrDeviceReady) InitVrSimulator(HMD_OCULUS_RIFT_CV1); // Init VR simulator if device fails
-    
-    // Define the camera to look into our 3d world
-    Camera camera;
-    camera.position = (Vector3){ 5.0f, 2.0f, 5.0f };    // Camera position
-    camera.target = (Vector3){ 0.0f, 2.0f, 0.0f };      // Camera looking at point
-    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
-    camera.fovy = 60.0f;                                // Camera field-of-view Y
-    
-    Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
-    
-    SetCameraMode(camera, CAMERA_FIRST_PERSON);         // Set first person camera mode
-    
-    SetTargetFPS(90);                   // Set our game to run at 90 frames-per-second
-    //--------------------------------------------------------------------------------------
-
-    // Main game loop
-    while (!WindowShouldClose())        // Detect window close button or ESC key
-    {
-        // Update
-        //----------------------------------------------------------------------------------
-        if (!vrDeviceReady) UpdateCamera(&camera);      // Update camera (simulator mode)
-        else UpdateOculusTracking(&camera);             // Update camera with device tracking data
-    
-        if (IsKeyPressed(KEY_SPACE)) ToggleVrMode();    // Toggle VR mode
-        //----------------------------------------------------------------------------------
-
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
-
-            ClearBackground(RAYWHITE);
-            
-            if (vrDeviceReady) BeginOculusDrawing();
-            else BeginVrDrawing();
-
-            Begin3dMode(camera);
-
-                DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
-                DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
-
-                DrawGrid(40, 1.0f);
-
-            End3dMode();
-            
-            if (vrDeviceReady) EndOculusDrawing();
-            else EndVrDrawing();
-
-            DrawFPS(10, 10);
-
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    if (vrDeviceReady) CloseOculusDevice();
-    else CloseVrSimulator();
-    
-    CloseWindow();          // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
-}
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Definition
-//----------------------------------------------------------------------------------
-
-#if defined(RLGL_OCULUS_SUPPORT)
-// Set internal projection and modelview matrix depending on eyes tracking data
-static void SetStereoView(int eye, Matrix matProjection, Matrix matModelView)
-{
-    Matrix eyeProjection = matProjection;
-    Matrix eyeModelView = matModelView;
-
-    glViewport(layer.eyeLayer.Viewport[eye].Pos.x, layer.eyeLayer.Viewport[eye].Pos.y,
-               layer.eyeLayer.Viewport[eye].Size.w, layer.eyeLayer.Viewport[eye].Size.h);
-
-    Quaternion eyeRenderPose = (Quaternion){ layer.eyeLayer.RenderPose[eye].Orientation.x,
-                                             layer.eyeLayer.RenderPose[eye].Orientation.y,
-                                             layer.eyeLayer.RenderPose[eye].Orientation.z,
-                                             layer.eyeLayer.RenderPose[eye].Orientation.w };
-    QuaternionInvert(&eyeRenderPose);
-    Matrix eyeOrientation = QuaternionToMatrix(eyeRenderPose);
-    Matrix eyeTranslation = MatrixTranslate(-layer.eyeLayer.RenderPose[eye].Position.x,
-                                            -layer.eyeLayer.RenderPose[eye].Position.y,
-                                            -layer.eyeLayer.RenderPose[eye].Position.z);
-
-    Matrix eyeView = MatrixMultiply(eyeTranslation, eyeOrientation);    // Matrix containing eye-head movement
-    eyeModelView = MatrixMultiply(matModelView, eyeView);               // Combine internal camera matrix (modelview) wih eye-head movement
-
-    eyeProjection = layer.eyeProjections[eye];
-}
-
-// Initialize Oculus device (returns true if success)
-static bool InitOculusDevice(void)
-{
-    bool oculusReady = false;
-
-    ovrResult result = ovr_Initialize(NULL);
-
-    if (OVR_FAILURE(result)) TraceLog(WARNING, "OVR: Could not initialize Oculus device");
-    else
-    {
-        result = ovr_Create(&session, &luid);
-        if (OVR_FAILURE(result))
-        {
-            TraceLog(WARNING, "OVR: Could not create Oculus session");
-            ovr_Shutdown();
-        }
-        else
-        {
-            hmdDesc = ovr_GetHmdDesc(session);
-
-            TraceLog(INFO, "OVR: Product Name: %s", hmdDesc.ProductName);
-            TraceLog(INFO, "OVR: Manufacturer: %s", hmdDesc.Manufacturer);
-            TraceLog(INFO, "OVR: Product ID: %i", hmdDesc.ProductId);
-            TraceLog(INFO, "OVR: Product Type: %i", hmdDesc.Type);
-            //TraceLog(INFO, "OVR: Serial Number: %s", hmdDesc.SerialNumber);
-            TraceLog(INFO, "OVR: Resolution: %ix%i", hmdDesc.Resolution.w, hmdDesc.Resolution.h);
-
-            // NOTE: Oculus mirror is set to defined screenWidth and screenHeight...
-            // ...ideally, it should be (hmdDesc.Resolution.w/2, hmdDesc.Resolution.h/2)
-
-            // Initialize Oculus Buffers
-            layer = InitOculusLayer(session);
-            buffer = LoadOculusBuffer(session, layer.width, layer.height);
-            mirror = LoadOculusMirror(session, hmdDesc.Resolution.w/2, hmdDesc.Resolution.h/2);     // NOTE: hardcoded...
-            layer.eyeLayer.ColorTexture[0] = buffer.textureChain;     //SetOculusLayerTexture(eyeLayer, buffer.textureChain);
-
-            // Recenter OVR tracking origin
-            ovr_RecenterTrackingOrigin(session);
-
-            oculusReady = true;
-        }
-    }
-
-    return oculusReady;
-}
-
-// Close Oculus device (and unload buffers)
-static void CloseOculusDevice(void)
-{
-    UnloadOculusMirror(session, mirror);    // Unload Oculus mirror buffer
-    UnloadOculusBuffer(session, buffer);    // Unload Oculus texture buffers
-
-    ovr_Destroy(session);   // Free Oculus session data
-    ovr_Shutdown();         // Close Oculus device connection
-}
-
-// Update Oculus head position-orientation tracking
-static void UpdateOculusTracking(Camera *camera)
-{
-    frameIndex++;
-
-    ovrPosef eyePoses[2];
-    ovr_GetEyePoses(session, frameIndex, ovrTrue, layer.viewScaleDesc.HmdToEyeOffset, eyePoses, &layer.eyeLayer.SensorSampleTime);
-
-    layer.eyeLayer.RenderPose[0] = eyePoses[0];
-    layer.eyeLayer.RenderPose[1] = eyePoses[1];
-
-    // TODO: Update external camera with eyePoses data (position, orientation)
-    // NOTE: We can simplify to simple camera if we consider IPD and HMD device configuration again later
-    // it will be useful for the user to draw, lets say, billboards oriented to camera
-
-    // Get session status information
-    ovrSessionStatus sessionStatus;
-    ovr_GetSessionStatus(session, &sessionStatus);
-
-    if (sessionStatus.ShouldQuit) TraceLog(WARNING, "OVR: Session should quit...");
-    if (sessionStatus.ShouldRecenter) ovr_RecenterTrackingOrigin(session);
-    //if (sessionStatus.HmdPresent)  // HMD is present.
-    //if (sessionStatus.DisplayLost) // HMD was unplugged or the display driver was manually disabled or encountered a TDR.
-    //if (sessionStatus.HmdMounted)  // HMD is on the user's head.
-    //if (sessionStatus.IsVisible)   // the game or experience has VR focus and is visible in the HMD.
-}
-
-// Setup Oculus buffers for drawing
-static void BeginOculusDrawing(void)
-{
-    GLuint currentTexId;
-    int currentIndex;
-
-    ovr_GetTextureSwapChainCurrentIndex(session, buffer.textureChain, &currentIndex);
-    ovr_GetTextureSwapChainBufferGL(session, buffer.textureChain, currentIndex, &currentTexId);
-
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, buffer.fboId);
-    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, currentTexId, 0);
-    //glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, buffer.depthId, 0);    // Already binded
-}
-
-// Finish Oculus drawing and blit framebuffer to mirror
-static void EndOculusDrawing(void)
-{
-    // Unbind current framebuffer (Oculus buffer)
-    glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-
-    ovr_CommitTextureSwapChain(session, buffer.textureChain);
-
-    ovrLayerHeader *layers = &layer.eyeLayer.Header;
-    ovr_SubmitFrame(session, frameIndex, &layer.viewScaleDesc, &layers, 1);
-
-    // Blit mirror texture to back buffer
-    BlitOculusMirror(session, mirror);
-}
-
-// Load Oculus required buffers: texture-swap-chain, fbo, texture-depth
-static OculusBuffer LoadOculusBuffer(ovrSession session, int width, int height)
-{
-    OculusBuffer buffer;
-    buffer.width = width;
-    buffer.height = height;
-
-    // Create OVR texture chain
-    ovrTextureSwapChainDesc desc = {};
-    desc.Type = ovrTexture_2D;
-    desc.ArraySize = 1;
-    desc.Width = width;
-    desc.Height = height;
-    desc.MipLevels = 1;
-    desc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;   // Requires glEnable(GL_FRAMEBUFFER_SRGB);
-    desc.SampleCount = 1;
-    desc.StaticImage = ovrFalse;
-
-    ovrResult result = ovr_CreateTextureSwapChainGL(session, &desc, &buffer.textureChain);
-
-    if (!OVR_SUCCESS(result)) TraceLog(WARNING, "OVR: Failed to create swap textures buffer");
-
-    int textureCount = 0;
-    ovr_GetTextureSwapChainLength(session, buffer.textureChain, &textureCount);
-
-    if (!OVR_SUCCESS(result) || !textureCount) TraceLog(WARNING, "OVR: Unable to count swap chain textures");
-
-    for (int i = 0; i < textureCount; ++i)
-    {
-        GLuint chainTexId;
-        ovr_GetTextureSwapChainBufferGL(session, buffer.textureChain, i, &chainTexId);
-        glBindTexture(GL_TEXTURE_2D, chainTexId);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    }
-
-    glBindTexture(GL_TEXTURE_2D, 0);
-
-    /*
-    // Setup framebuffer object (using depth texture)
-    glGenFramebuffers(1, &buffer.fboId);
-    glGenTextures(1, &buffer.depthId);
-    glBindTexture(GL_TEXTURE_2D, buffer.depthId);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16, buffer.width, buffer.height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
-    */
-
-    // Setup framebuffer object (using depth renderbuffer)
-    glGenFramebuffers(1, &buffer.fboId);
-    glGenRenderbuffers(1, &buffer.depthId);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, buffer.fboId);
-    glBindRenderbuffer(GL_RENDERBUFFER, buffer.depthId);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, buffer.width, buffer.height);
-    glBindRenderbuffer(GL_RENDERBUFFER, 0);
-    glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, buffer.depthId);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-
-    return buffer;
-}
-
-// Unload texture required buffers
-static void UnloadOculusBuffer(ovrSession session, OculusBuffer buffer)
-{
-    if (buffer.textureChain)
-    {
-        ovr_DestroyTextureSwapChain(session, buffer.textureChain);
-        buffer.textureChain = NULL;
-    }
-
-    if (buffer.depthId != 0) glDeleteTextures(1, &buffer.depthId);
-    if (buffer.fboId != 0) glDeleteFramebuffers(1, &buffer.fboId);
-}
-
-// Load Oculus mirror buffers
-static OculusMirror LoadOculusMirror(ovrSession session, int width, int height)
-{
-    OculusMirror mirror;
-    mirror.width = width;
-    mirror.height = height;
-
-    ovrMirrorTextureDesc mirrorDesc;
-    memset(&mirrorDesc, 0, sizeof(mirrorDesc));
-    mirrorDesc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;
-    mirrorDesc.Width = mirror.width;
-    mirrorDesc.Height = mirror.height;
-
-    if (!OVR_SUCCESS(ovr_CreateMirrorTextureGL(session, &mirrorDesc, &mirror.texture))) TraceLog(WARNING, "Could not create mirror texture");
-
-    glGenFramebuffers(1, &mirror.fboId);
-
-    return mirror;
-}
-
-// Unload Oculus mirror buffers
-static void UnloadOculusMirror(ovrSession session, OculusMirror mirror)
-{
-    if (mirror.fboId != 0) glDeleteFramebuffers(1, &mirror.fboId);
-    if (mirror.texture) ovr_DestroyMirrorTexture(session, mirror.texture);
-}
-
-// Copy Oculus screen buffer to mirror texture
-static void BlitOculusMirror(ovrSession session, OculusMirror mirror)
-{
-    GLuint mirrorTextureId;
-
-    ovr_GetMirrorTextureBufferGL(session, mirror.texture, &mirrorTextureId);
-
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, mirror.fboId);
-    glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mirrorTextureId, 0);
-#if defined(GRAPHICS_API_OPENGL_33)
-    // NOTE: glBlitFramebuffer() requires extension: GL_EXT_framebuffer_blit (not available in OpenGL ES 2.0)
-    glBlitFramebuffer(0, 0, mirror.width, mirror.height, 0, mirror.height, mirror.width, 0, GL_COLOR_BUFFER_BIT, GL_NEAREST);
-#endif
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
-}
-
-// Init Oculus layer (similar to photoshop)
-static OculusLayer InitOculusLayer(ovrSession session)
-{
-    OculusLayer layer = { 0 };
-
-    layer.viewScaleDesc.HmdSpaceToWorldScaleInMeters = 1.0f;
-
-    memset(&layer.eyeLayer, 0, sizeof(ovrLayerEyeFov));
-    layer.eyeLayer.Header.Type = ovrLayerType_EyeFov;
-    layer.eyeLayer.Header.Flags = ovrLayerFlag_TextureOriginAtBottomLeft;
-
-    ovrEyeRenderDesc eyeRenderDescs[2];
-
-    for (int eye = 0; eye < 2; eye++)
-    {
-        eyeRenderDescs[eye] = ovr_GetRenderDesc(session, eye, hmdDesc.DefaultEyeFov[eye]);
-        ovrMatrix4f ovrPerspectiveProjection = ovrMatrix4f_Projection(eyeRenderDescs[eye].Fov, 0.01f, 10000.0f, ovrProjection_None); //ovrProjection_ClipRangeOpenGL);
-        layer.eyeProjections[eye] = FromOvrMatrix(ovrPerspectiveProjection);      // NOTE: struct ovrMatrix4f { float M[4][4] } --> struct Matrix
-
-        layer.viewScaleDesc.HmdToEyeOffset[eye] = eyeRenderDescs[eye].HmdToEyeOffset;
-        layer.eyeLayer.Fov[eye] = eyeRenderDescs[eye].Fov;
-
-        ovrSizei eyeSize = ovr_GetFovTextureSize(session, eye, layer.eyeLayer.Fov[eye], 1.0f);
-        layer.eyeLayer.Viewport[eye].Size = eyeSize;
-        layer.eyeLayer.Viewport[eye].Pos.x = layer.width;
-        layer.eyeLayer.Viewport[eye].Pos.y = 0;
-
-        layer.height = eyeSize.h;     //std::max(renderTargetSize.y, (uint32_t)eyeSize.h);
-        layer.width += eyeSize.w;
-    }
-
-    return layer;
-}
-
-// Convert from Oculus ovrMatrix4f struct to raymath Matrix struct
-static Matrix FromOvrMatrix(ovrMatrix4f ovrmat)
-{
-    Matrix rmat;
-
-    rmat.m0 = ovrmat.M[0][0];
-    rmat.m1 = ovrmat.M[1][0];
-    rmat.m2 = ovrmat.M[2][0];
-    rmat.m3 = ovrmat.M[3][0];
-    rmat.m4 = ovrmat.M[0][1];
-    rmat.m5 = ovrmat.M[1][1];
-    rmat.m6 = ovrmat.M[2][1];
-    rmat.m7 = ovrmat.M[3][1];
-    rmat.m8 = ovrmat.M[0][2];
-    rmat.m9 = ovrmat.M[1][2];
-    rmat.m10 = ovrmat.M[2][2];
-    rmat.m11 = ovrmat.M[3][2];
-    rmat.m12 = ovrmat.M[0][3];
-    rmat.m13 = ovrmat.M[1][3];
-    rmat.m14 = ovrmat.M[2][3];
-    rmat.m15 = ovrmat.M[3][3];
-
-    MatrixTranspose(&rmat);
-
-    return rmat;
-}
-#endif
-
-// Output a trace log message
-// NOTE: Expected msgType: (0)Info, (1)Error, (2)Warning
-static void TraceLog(int msgType, const char *text, ...)
-{
-    va_list args;
-    va_start(args, text);
-
-    switch (msgType)
-    {
-        case INFO: fprintf(stdout, "INFO: "); break;
-        case ERROR: fprintf(stdout, "ERROR: "); break;
-        case WARNING: fprintf(stdout, "WARNING: "); break;
-        case DEBUG: fprintf(stdout, "DEBUG: "); break;
-        default: break;
-    }
-
-    vfprintf(stdout, text, args);
-    fprintf(stdout, "\n");
-
-    va_end(args);
-
-    if (msgType == ERROR) exit(1);
-}
-
diff --git a/examples/web/others/resources/shaders/glsl100/standard.fs b/examples/web/others/resources/shaders/glsl100/standard.fs
deleted file mode 100644
index fe604e2..0000000
--- a/examples/web/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/web/others/resources/shaders/glsl100/standard.vs b/examples/web/others/resources/shaders/glsl100/standard.vs
deleted file mode 100644
index 49c5a3e..0000000
--- a/examples/web/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 mvpMatrix;
-
-void main()
-{
-    fragPosition = vertexPosition;
-    fragTexCoord = vertexTexCoord;
-    fragColor = vertexColor;
-    fragNormal = vertexNormal;
-
-    gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
-}
\ No newline at end of file
diff --git a/examples/web/others/resources/shaders/glsl330/standard.fs b/examples/web/others/resources/shaders/glsl330/standard.fs
deleted file mode 100644
index 0d46148..0000000
--- a/examples/web/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/web/others/resources/shaders/glsl330/standard.vs b/examples/web/others/resources/shaders/glsl330/standard.vs
deleted file mode 100644
index fc0a5ff..0000000
--- a/examples/web/others/resources/shaders/glsl330/standard.vs
+++ /dev/null
@@ -1,23 +0,0 @@
-#version 330 
-
-in vec3 vertexPosition;
-in vec3 vertexNormal;
-in vec2 vertexTexCoord;
-in vec4 vertexColor;
-
-out vec3 fragPosition;
-out vec2 fragTexCoord;
-out vec4 fragColor;
-out vec3 fragNormal;
-
-uniform mat4 mvpMatrix;
-
-void main()
-{
-    fragPosition = vertexPosition;
-    fragTexCoord = vertexTexCoord;
-    fragColor = vertexColor;
-    fragNormal = vertexNormal;
-
-    gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
-}
\ No newline at end of file
diff --git a/examples/web/others/rlgl_standalone.c b/examples/web/others/rlgl_standalone.c
deleted file mode 100644
index be0cfc5..0000000
--- a/examples/web/others/rlgl_standalone.c
+++ /dev/null
@@ -1,395 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib [rlgl] example - Using rlgl module as standalone module
-*
-*   NOTE: This example requires OpenGL 3.3 or ES2 versions for shaders support,
-*         OpenGL 1.1 does not support shaders but it can also be used.
-*
-*   Compile rlgl module using:
-*   gcc -c rlgl.c -Wall -std=c99 -DRLGL_STANDALONE -DRAYMATH_IMPLEMENTATION -DGRAPHICS_API_OPENGL_33
-*
-*   NOTE: rlgl module requires the following header-only files:
-*       external/glad.h - OpenGL extensions loader (stripped to only required extensions)
-*       shader_standard.h - Standard shader for materials and lighting
-*       shader_distortion.h - Distortion shader for VR
-*       raymath.h - Vector and matrix math functions
-*
-*   Compile example using:
-*   gcc -o rlgl_standalone.exe rlgl_standalone.c rlgl.o -lglfw3 -lopengl32 -lgdi32 -std=c99
-*
-*   This example has been created using raylib 1.5 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include <GLFW/glfw3.h>         // Windows/Context and inputs management
-
-#define RLGL_STANDALONE
-#include "rlgl.h"               // rlgl library: OpenGL 1.1 immediate-mode style coding
-
-#define RED        (Color){ 230, 41, 55, 255 }     // Red
-#define RAYWHITE   (Color){ 245, 245, 245, 255 }   // My own White (raylib logo)
-#define DARKGRAY   (Color){ 80, 80, 80, 255 }      // Dark Gray
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Declaration
-//----------------------------------------------------------------------------------
-static void ErrorCallback(int error, const char* description);
-static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
-
-// Drawing functions (uses rlgl functionality)
-static void DrawGrid(int slices, float spacing);
-static void DrawCube(Vector3 position, float width, float height, float length, Color color);
-static void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);
-static void DrawRectangleV(Vector2 position, Vector2 size, Color color);
-
-//----------------------------------------------------------------------------------
-// Main Entry point
-//----------------------------------------------------------------------------------
-int main(void)
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
-    const int screenHeight = 450;
-    
-    // GLFW3 Initialization + OpenGL 3.3 Context + Extensions
-    //--------------------------------------------------------
-    glfwSetErrorCallback(ErrorCallback);
-    
-    if (!glfwInit())
-    {
-        TraceLog(WARNING, "GLFW3: Can not initialize GLFW");
-        return 1;
-    }
-    else TraceLog(INFO, "GLFW3: GLFW initialized successfully");
-    
-    glfwWindowHint(GLFW_SAMPLES, 4);
-    glfwWindowHint(GLFW_DEPTH_BITS, 16);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-    glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
-   
-    GLFWwindow *window = glfwCreateWindow(screenWidth, screenHeight, "rlgl standalone", NULL, NULL);
-    
-    if (!window)
-    {
-        glfwTerminate();
-        return 2;
-    }
-    else TraceLog(INFO, "GLFW3: Window created successfully");
-    
-    glfwSetWindowPos(window, 200, 200);
-    
-    glfwSetKeyCallback(window, KeyCallback);
-    
-    glfwMakeContextCurrent(window);
-    glfwSwapInterval(1);
-    
-    // Load OpenGL 3.3 supported extensions
-    rlglLoadExtensions(glfwGetProcAddress);
-    //--------------------------------------------------------
-    
-    // Initialize OpenGL context (states and resources)
-    rlglInit(screenWidth, screenHeight);
-
-    // Initialize viewport and internal projection/modelview matrices
-    rlViewport(0, 0, screenWidth, screenHeight);
-    rlMatrixMode(RL_PROJECTION);                        // Switch to PROJECTION matrix
-    rlLoadIdentity();                                   // Reset current matrix (PROJECTION)
-    rlOrtho(0, screenWidth, screenHeight, 0, 0.0f, 1.0f); // Orthographic projection with top-left corner at (0,0)
-    rlMatrixMode(RL_MODELVIEW);                         // Switch back to MODELVIEW matrix
-    rlLoadIdentity();                                   // Reset current matrix (MODELVIEW)
-
-    rlClearColor(245, 245, 245, 255);                   // Define clear color
-    rlEnableDepthTest();                                // Enable DEPTH_TEST for 3D
-    
-    Camera camera;
-    camera.position = (Vector3){ 5.0f, 5.0f, 5.0f };    // Camera position
-    camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
-    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
-    camera.fovy = 45.0f;                                // Camera field-of-view Y
-    
-    Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };        // Cube default position (center)
-    //--------------------------------------------------------------------------------------    
-
-    // Main game loop    
-    while (!glfwWindowShouldClose(window)) 
-    {
-        // Update
-        //----------------------------------------------------------------------------------
-        // ...
-        //----------------------------------------------------------------------------------
-
-        // Draw
-        //----------------------------------------------------------------------------------
-        rlClearScreenBuffers();             // Clear current framebuffer
-        
-            // Calculate projection matrix (from perspective) and view matrix from camera look at
-            Matrix matProj = MatrixPerspective(camera.fovy, (double)screenWidth/(double)screenHeight, 0.01, 1000.0);
-            MatrixTranspose(&matProj);
-            Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up);
-
-            SetMatrixModelview(matView);    // Replace internal modelview matrix by a custom one
-            SetMatrixProjection(matProj);   // Replace internal projection matrix by a custom one
-
-            DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
-            DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, RAYWHITE);
-            DrawGrid(10, 1.0f);
-
-            // NOTE: Internal buffers drawing (3D data)
-            rlglDraw();
-            
-            // Draw '2D' elements in the scene (GUI)
-#define RLGL_CREATE_MATRIX_MANUALLY
-#if defined(RLGL_CREATE_MATRIX_MANUALLY)
-            matProj = MatrixOrtho(0.0, screenWidth, screenHeight, 0.0, 0.0, 1.0);
-            MatrixTranspose(&matProj);
-            matView = MatrixIdentity();
-            
-            SetMatrixModelview(matView);    // Replace internal modelview matrix by a custom one
-            SetMatrixProjection(matProj);   // Replace internal projection matrix by a custom one
-
-#else   // Let rlgl generate and multiply matrix internally
-
-            rlMatrixMode(RL_PROJECTION);                            // Enable internal projection matrix
-            rlLoadIdentity();                                       // Reset internal projection matrix
-            rlOrtho(0.0, screenWidth, screenHeight, 0.0, 0.0, 1.0); // Recalculate internal projection matrix
-            rlMatrixMode(RL_MODELVIEW);                             // Enable internal modelview matrix
-            rlLoadIdentity();                                       // Reset internal modelview matrix
-#endif
-            DrawRectangleV((Vector2){ 10.0f, 10.0f }, (Vector2){ 780.0f, 20.0f }, DARKGRAY);
-
-            // NOTE: Internal buffers drawing (2D data)
-            rlglDraw();
-            
-        glfwSwapBuffers(window);
-        glfwPollEvents();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    rlglClose();                    // Unload rlgl internal buffers and default shader/texture
-    
-    glfwDestroyWindow(window);      // Close window
-    glfwTerminate();                // Free GLFW3 resources
-    //--------------------------------------------------------------------------------------
-    
-    return 0;
-}
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Definitions
-//----------------------------------------------------------------------------------
-
-// GLFW3: Error callback
-static void ErrorCallback(int error, const char* description)
-{
-    TraceLog(ERROR, description);
-}
-
-// GLFW3: Keyboard callback
-static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
-{
-    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
-    {
-        glfwSetWindowShouldClose(window, GL_TRUE);
-    }
-}
-
-// Draw rectangle using rlgl OpenGL 1.1 style coding (translated to OpenGL 3.3 internally)
-static void DrawRectangleV(Vector2 position, Vector2 size, Color color)
-{
-    rlBegin(RL_TRIANGLES);
-        rlColor4ub(color.r, color.g, color.b, color.a);
-
-        rlVertex2i(position.x, position.y);
-        rlVertex2i(position.x, position.y + size.y);
-        rlVertex2i(position.x + size.x, position.y + size.y);
-
-        rlVertex2i(position.x, position.y);
-        rlVertex2i(position.x + size.x, position.y + size.y);
-        rlVertex2i(position.x + size.x, position.y);
-    rlEnd();
-}
-
-// Draw a grid centered at (0, 0, 0)
-static void DrawGrid(int slices, float spacing)
-{
-    int halfSlices = slices / 2;
-
-    rlBegin(RL_LINES);
-        for(int i = -halfSlices; i <= halfSlices; i++)
-        {
-            if (i == 0)
-            {
-                rlColor3f(0.5f, 0.5f, 0.5f);
-                rlColor3f(0.5f, 0.5f, 0.5f);
-                rlColor3f(0.5f, 0.5f, 0.5f);
-                rlColor3f(0.5f, 0.5f, 0.5f);
-            }
-            else
-            {
-                rlColor3f(0.75f, 0.75f, 0.75f);
-                rlColor3f(0.75f, 0.75f, 0.75f);
-                rlColor3f(0.75f, 0.75f, 0.75f);
-                rlColor3f(0.75f, 0.75f, 0.75f);
-            }
-
-            rlVertex3f((float)i*spacing, 0.0f, (float)-halfSlices*spacing);
-            rlVertex3f((float)i*spacing, 0.0f, (float)halfSlices*spacing);
-
-            rlVertex3f((float)-halfSlices*spacing, 0.0f, (float)i*spacing);
-            rlVertex3f((float)halfSlices*spacing, 0.0f, (float)i*spacing);
-        }
-    rlEnd();
-}
-
-// Draw cube
-// NOTE: Cube position is the center position
-void DrawCube(Vector3 position, float width, float height, float length, Color color)
-{
-    float x = 0.0f;
-    float y = 0.0f;
-    float z = 0.0f;
-
-    rlPushMatrix();
-
-        // NOTE: Be careful! Function order matters (rotate -> scale -> translate)
-        rlTranslatef(position.x, position.y, position.z);
-        //rlScalef(2.0f, 2.0f, 2.0f);
-        //rlRotatef(45, 0, 1, 0);
-
-        rlBegin(RL_TRIANGLES);
-            rlColor4ub(color.r, color.g, color.b, color.a);
-
-            // Front Face -----------------------------------------------------
-            rlVertex3f(x-width/2, y-height/2, z+length/2);  // Bottom Left
-            rlVertex3f(x+width/2, y-height/2, z+length/2);  // Bottom Right
-            rlVertex3f(x-width/2, y+height/2, z+length/2);  // Top Left
-
-            rlVertex3f(x+width/2, y+height/2, z+length/2);  // Top Right
-            rlVertex3f(x-width/2, y+height/2, z+length/2);  // Top Left
-            rlVertex3f(x+width/2, y-height/2, z+length/2);  // Bottom Right
-
-            // Back Face ------------------------------------------------------
-            rlVertex3f(x-width/2, y-height/2, z-length/2);  // Bottom Left
-            rlVertex3f(x-width/2, y+height/2, z-length/2);  // Top Left
-            rlVertex3f(x+width/2, y-height/2, z-length/2);  // Bottom Right
-
-            rlVertex3f(x+width/2, y+height/2, z-length/2);  // Top Right
-            rlVertex3f(x+width/2, y-height/2, z-length/2);  // Bottom Right
-            rlVertex3f(x-width/2, y+height/2, z-length/2);  // Top Left
-
-            // Top Face -------------------------------------------------------
-            rlVertex3f(x-width/2, y+height/2, z-length/2);  // Top Left
-            rlVertex3f(x-width/2, y+height/2, z+length/2);  // Bottom Left
-            rlVertex3f(x+width/2, y+height/2, z+length/2);  // Bottom Right
-
-            rlVertex3f(x+width/2, y+height/2, z-length/2);  // Top Right
-            rlVertex3f(x-width/2, y+height/2, z-length/2);  // Top Left
-            rlVertex3f(x+width/2, y+height/2, z+length/2);  // Bottom Right
-
-            // Bottom Face ----------------------------------------------------
-            rlVertex3f(x-width/2, y-height/2, z-length/2);  // Top Left
-            rlVertex3f(x+width/2, y-height/2, z+length/2);  // Bottom Right
-            rlVertex3f(x-width/2, y-height/2, z+length/2);  // Bottom Left
-
-            rlVertex3f(x+width/2, y-height/2, z-length/2);  // Top Right
-            rlVertex3f(x+width/2, y-height/2, z+length/2);  // Bottom Right
-            rlVertex3f(x-width/2, y-height/2, z-length/2);  // Top Left
-
-            // Right face -----------------------------------------------------
-            rlVertex3f(x+width/2, y-height/2, z-length/2);  // Bottom Right
-            rlVertex3f(x+width/2, y+height/2, z-length/2);  // Top Right
-            rlVertex3f(x+width/2, y+height/2, z+length/2);  // Top Left
-
-            rlVertex3f(x+width/2, y-height/2, z+length/2);  // Bottom Left
-            rlVertex3f(x+width/2, y-height/2, z-length/2);  // Bottom Right
-            rlVertex3f(x+width/2, y+height/2, z+length/2);  // Top Left
-
-            // Left Face ------------------------------------------------------
-            rlVertex3f(x-width/2, y-height/2, z-length/2);  // Bottom Right
-            rlVertex3f(x-width/2, y+height/2, z+length/2);  // Top Left
-            rlVertex3f(x-width/2, y+height/2, z-length/2);  // Top Right
-
-            rlVertex3f(x-width/2, y-height/2, z+length/2);  // Bottom Left
-            rlVertex3f(x-width/2, y+height/2, z+length/2);  // Top Left
-            rlVertex3f(x-width/2, y-height/2, z-length/2);  // Bottom Right
-        rlEnd();
-    rlPopMatrix();
-}
-
-// Draw cube wires
-void DrawCubeWires(Vector3 position, float width, float height, float length, Color color)
-{
-    float x = 0.0f;
-    float y = 0.0f;
-    float z = 0.0f;
-
-    rlPushMatrix();
-
-        rlTranslatef(position.x, position.y, position.z);
-        //rlRotatef(45, 0, 1, 0);
-
-        rlBegin(RL_LINES);
-            rlColor4ub(color.r, color.g, color.b, color.a);
-
-            // Front Face -----------------------------------------------------
-            // Bottom Line
-            rlVertex3f(x-width/2, y-height/2, z+length/2);  // Bottom Left
-            rlVertex3f(x+width/2, y-height/2, z+length/2);  // Bottom Right
-
-            // Left Line
-            rlVertex3f(x+width/2, y-height/2, z+length/2);  // Bottom Right
-            rlVertex3f(x+width/2, y+height/2, z+length/2);  // Top Right
-
-            // Top Line
-            rlVertex3f(x+width/2, y+height/2, z+length/2);  // Top Right
-            rlVertex3f(x-width/2, y+height/2, z+length/2);  // Top Left
-
-            // Right Line
-            rlVertex3f(x-width/2, y+height/2, z+length/2);  // Top Left
-            rlVertex3f(x-width/2, y-height/2, z+length/2);  // Bottom Left
-
-            // Back Face ------------------------------------------------------
-            // Bottom Line
-            rlVertex3f(x-width/2, y-height/2, z-length/2);  // Bottom Left
-            rlVertex3f(x+width/2, y-height/2, z-length/2);  // Bottom Right
-
-            // Left Line
-            rlVertex3f(x+width/2, y-height/2, z-length/2);  // Bottom Right
-            rlVertex3f(x+width/2, y+height/2, z-length/2);  // Top Right
-
-            // Top Line
-            rlVertex3f(x+width/2, y+height/2, z-length/2);  // Top Right
-            rlVertex3f(x-width/2, y+height/2, z-length/2);  // Top Left
-
-            // Right Line
-            rlVertex3f(x-width/2, y+height/2, z-length/2);  // Top Left
-            rlVertex3f(x-width/2, y-height/2, z-length/2);  // Bottom Left
-
-            // Top Face -------------------------------------------------------
-            // Left Line
-            rlVertex3f(x-width/2, y+height/2, z+length/2);  // Top Left Front
-            rlVertex3f(x-width/2, y+height/2, z-length/2);  // Top Left Back
-
-            // Right Line
-            rlVertex3f(x+width/2, y+height/2, z+length/2);  // Top Right Front
-            rlVertex3f(x+width/2, y+height/2, z-length/2);  // Top Right Back
-
-            // Bottom Face  ---------------------------------------------------
-            // Left Line
-            rlVertex3f(x-width/2, y-height/2, z+length/2);  // Top Left Front
-            rlVertex3f(x-width/2, y-height/2, z-length/2);  // Top Left Back
-
-            // Right Line
-            rlVertex3f(x+width/2, y-height/2, z+length/2);  // Top Right Front
-            rlVertex3f(x+width/2, y-height/2, z-length/2);  // Top Right Back
-        rlEnd();
-    rlPopMatrix();
-}
diff --git a/examples/web/others/standard_lighting.c b/examples/web/others/standard_lighting.c
deleted file mode 100644
index 728ebb4..0000000
--- a/examples/web/others/standard_lighting.c
+++ /dev/null
@@ -1,154 +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.3 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#if defined(PLATFORM_WEB)
-    #include <emscripten/emscripten.h>
-#endif
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-int screenWidth = 800;
-int screenHeight = 450;
-
-// 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 dwarf;
-Material material;
-
-Light spotLight;
-Light dirLight;
-Light pointLight;
-    
-//----------------------------------------------------------------------------------
-// Module Functions Declaration
-//----------------------------------------------------------------------------------
-void UpdateDrawFrame(void);     // Update and Draw one frame
-
-//----------------------------------------------------------------------------------
-// Main Enry Point
-//----------------------------------------------------------------------------------
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
-    InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader");
-   
-    dwarf = LoadModel("resources/model/dwarf.obj");                     // Load OBJ model
-    material = LoadStandardMaterial();
-    
-    material.texDiffuse = LoadTexture("resources/model/dwarf_diffuse.png");   // Load model diffuse texture
-    material.texNormal = LoadTexture("resources/model/dwarf_normal.png");     // Load model normal texture
-    material.texSpecular = LoadTexture("resources/model/dwarf_specular.png"); // Load model specular texture
-    material.colDiffuse = WHITE;
-    material.colAmbient = (Color){0, 0, 10, 255};
-    material.colSpecular = WHITE;
-    material.glossiness = 50.0f;
-    
-    dwarf.material = material;      // Apply material to model
-
-    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;
-
-    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};
-
-    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;
-
-    // Setup orbital camera
-    SetCameraMode(CAMERA_ORBITAL);          // Set an orbital camera mode
-    SetCameraPosition(camera.position);     // Set internal camera position to match our camera position
-    SetCameraTarget(camera.target);         // Set internal camera target to match our camera target
-
-#if defined(PLATFORM_WEB)
-    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
-#else
-    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
-    //--------------------------------------------------------------------------------------
-    
-    // Main game loop
-    while (!WindowShouldClose())    // Detect window close button or ESC key
-    {
-        UpdateDrawFrame();
-    }
-#endif
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    UnloadMaterial(material);   // Unload material and assigned textures
-    UnloadModel(dwarf);         // Unload model
-    
-    // Destroy all created lights
-    DestroyLight(pointLight);
-    DestroyLight(dirLight);
-    DestroyLight(spotLight);
-
-    CloseWindow();              // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
-}
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition
-//----------------------------------------------------------------------------------
-void UpdateDrawFrame(void)
-{
-    // Update
-    //----------------------------------------------------------------------------------
-    UpdateCamera(&camera);              // Update internal camera and our camera
-    //----------------------------------------------------------------------------------
-
-    // Draw
-    //----------------------------------------------------------------------------------
-    BeginDrawing();
-
-        ClearBackground(RAYWHITE);
-
-        Begin3dMode(camera);
-            
-            DrawModel(dwarf, 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
-
-        End3dMode();
-        
-        DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY);
-        
-        DrawFPS(10, 10);
-
-    EndDrawing();
-    //----------------------------------------------------------------------------------
-}
\ No newline at end of file