Working on web examples

Reorganizing folders
Review examples
Work on makefile and loader.html

docs/examples/web/others/audio_standalone.c

@@ -0,0 +1,123 @@
+/*******************************************************************************************
+*
+*   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;
+}

docs/examples/web/others/font_selector.c

@@ -0,0 +1,196 @@
+/*******************************************************************************************
+*
+*   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();
+    //----------------------------------------------------------------------------------
+}

docs/examples/web/others/image_formats_loading.c

@@ -0,0 +1,271 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - texture formats loading (adapted for HTML5 platform)
+*
+*   NOTE: This example requires raylib OpenGL 3.3+ or ES2 versions for compressed textures,
+*         OpenGL 1.1 does not support compressed textures, only uncompressed ones.
+*
+*   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
+
+#define NUM_TEXTURES    24
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+int screenWidth = 800;
+int screenHeight = 450;
+
+int selectedFormat;
+Rectangle selectRecs[NUM_TEXTURES];
+Texture2D sonic[NUM_TEXTURES];
+
+typedef enum { 
+    PNG_R8G8B8A8 = 0, 
+    PVR_GRAYSCALE, 
+    PVR_GRAY_ALPHA, 
+    PVR_R5G6B5, 
+    PVR_R5G5B5A1, 
+    PVR_R4G4B4A4,
+    DDS_R5G6B5,
+    DDS_R5G5B5A1,
+    DDS_R4G4B4A4,
+    DDS_R8G8B8A8,
+    DDS_DXT1_RGB,
+    DDS_DXT1_RGBA,
+    DDS_DXT3_RGBA,
+    DDS_DXT5_RGBA,
+    PKM_ETC1_RGB,
+    PKM_ETC2_RGB,
+    PKM_ETC2_EAC_RGBA,
+    KTX_ETC1_RGB,
+    KTX_ETC2_RGB,
+    KTX_ETC2_EAC_RGBA,
+    ASTC_4x4_LDR,
+    ASTC_8x8_LDR,
+    PVR_PVRT_RGB,
+    PVR_PVRT_RGBA
+    
+} TextureFormats;
+
+static const char *formatText[] = {
+    "PNG_R8G8B8A8",
+    "PVR_GRAYSCALE",
+    "PVR_GRAY_ALPHA",
+    "PVR_R5G6B5",
+    "PVR_R5G5B5A1",
+    "PVR_R4G4B4A4",
+    "DDS_R5G6B5",
+    "DDS_R5G5B5A1",
+    "DDS_R4G4B4A4",
+    "DDS_R8G8B8A8",
+    "DDS_DXT1_RGB",
+    "DDS_DXT1_RGBA",
+    "DDS_DXT3_RGBA",
+    "DDS_DXT5_RGBA",
+    "PKM_ETC1_RGB",
+    "PKM_ETC2_RGB",
+    "PKM_ETC2_EAC_RGBA",
+    "KTX_ETC1_RGB",
+    "KTX_ETC2_RGB",
+    "KTX_ETC2_EAC_RGBA",
+    "ASTC_4x4_LDR",
+    "ASTC_8x8_LDR",
+    "PVR_PVRT_RGB",
+    "PVR_PVRT_RGBA"
+};
+
+// Texture sizes in KB
+float textureSizes[NUM_TEXTURES] = { 
+    512*512*32/8/1024,      //PNG_R8G8B8A8 (32 bpp)
+    512*512*8/8/1024,       //PVR_GRAYSCALE (8 bpp)
+    512*512*16/8/1024,      //PVR_GRAY_ALPHA (16 bpp) 
+    512*512*16/8/1024,      //PVR_R5G6B5 (16 bpp)
+    512*512*16/8/1024,      //PVR_R5G5B5A1 (16 bpp) 
+    512*512*16/8/1024,      //PVR_R4G4B4A4 (16 bpp)
+    512*512*16/8/1024,      //DDS_R5G6B5 (16 bpp)
+    512*512*16/8/1024,      //DDS_R5G5B5A1 (16 bpp)
+    512*512*16/8/1024,      //DDS_R4G4B4A4 (16 bpp)
+    512*512*32/8/1024,      //DDS_R8G8B8A8 (32 bpp)
+    512*512*4/8/1024,       //DDS_DXT1_RGB (4 bpp) -Compressed-
+    512*512*4/8/1024,       //DDS_DXT1_RGBA (4 bpp) -Compressed-
+    512*512*8/8/1024,       //DDS_DXT3_RGBA (8 bpp) -Compressed-
+    512*512*8/8/1024,       //DDS_DXT5_RGBA (8 bpp) -Compressed-
+    512*512*4/8/1024,       //PKM_ETC1_RGB (4 bpp) -Compressed-
+    512*512*4/8/1024,       //PKM_ETC2_RGB (4 bpp) -Compressed-
+    512*512*8/8/1024,       //PKM_ETC2_EAC_RGBA (8 bpp) -Compressed-
+    512*512*4/8/1024,       //KTX_ETC1_RGB (4 bpp) -Compressed-
+    512*512*4/8/1024,       //KTX_ETC2_RGB (4 bpp) -Compressed-
+    512*512*8/8/1024,       //KTX_ETC2_EAC_RGBA (8 bpp) -Compressed-
+    512*512*8/8/1024,       //ASTC_4x4_LDR (8 bpp) -Compressed-
+    512*512*2/8/1024,       //ASTC_8x8_LDR (2 bpp) -Compressed-
+    512*512*4/8/1024,       //PVR_PVRT_RGB (4 bpp) -Compressed-
+    512*512*4/8/1024,       //PVR_PVRT_RGBA (4 bpp) -Compressed-
+};
+
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void);     // Update and Draw one frame
+
+//----------------------------------------------------------------------------------
+// Main Enry Point
+//----------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture formats loading");
+
+    selectedFormat = PNG_R8G8B8A8;    
+    
+    sonic[PNG_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic.png");
+    
+    // Load UNCOMPRESSED PVR texture data
+    sonic[PVR_GRAYSCALE] = LoadTexture("resources/texture_formats/sonic_GRAYSCALE.pvr");
+    sonic[PVR_GRAY_ALPHA] = LoadTexture("resources/texture_formats/sonic_L8A8.pvr");
+    sonic[PVR_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.pvr");
+    sonic[PVR_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_R5G5B5A1.pvr");
+    sonic[PVR_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_R4G4B4A4.pvr");
+    
+    // Load UNCOMPRESSED DDS texture data
+    sonic[DDS_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.dds");
+    sonic[DDS_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_A1R5G5B5.dds");
+    sonic[DDS_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_A4R4G4B4.dds");
+    sonic[DDS_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic_A8R8G8B8.dds");
+   
+    // Load COMPRESSED DXT DDS texture data (if supported)
+    sonic[DDS_DXT1_RGB] = LoadTexture("resources/texture_formats/sonic_DXT1_RGB.dds");
+    sonic[DDS_DXT1_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT1_RGBA.dds");
+    sonic[DDS_DXT3_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT3_RGBA.dds");
+    sonic[DDS_DXT5_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT5_RGBA.dds");
+    
+    // Load COMPRESSED ETC texture data (if supported)
+    sonic[PKM_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.pkm");
+    sonic[PKM_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.pkm");
+    sonic[PKM_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.pkm");
+    
+    sonic[KTX_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.ktx");
+    sonic[KTX_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.ktx");
+    sonic[KTX_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.ktx");
+    
+    // Load COMPRESSED ASTC texture data (if supported)
+    sonic[ASTC_4x4_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_4x4_ldr.astc");
+    sonic[ASTC_8x8_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_8x8_ldr.astc");
+
+    // Load COMPRESSED PVR texture data (if supported)
+    sonic[PVR_PVRT_RGB] = LoadTexture("resources/texture_formats/sonic_PVRT_RGB.pvr");
+    sonic[PVR_PVRT_RGBA] = LoadTexture("resources/texture_formats/sonic_PVRT_RGBA.pvr");
+    
+    
+    
+    for (int i = 0; i < NUM_TEXTURES; i++)
+    {
+        if (i < NUM_TEXTURES/2) selectRecs[i] = (Rectangle){ 40, 30 + 32*i, 150, 30 };
+        else selectRecs[i] = (Rectangle){ 40 + 152, 30 + 32*(i - NUM_TEXTURES/2), 150, 30 };
+    }
+    
+#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 < NUM_TEXTURES; i++) UnloadTexture(sonic[i]);
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void)
+{
+    // Update
+    //----------------------------------------------------------------------------------
+    if (IsKeyPressed(KEY_DOWN))
+    {
+        selectedFormat++;
+        if (selectedFormat >= NUM_TEXTURES) selectedFormat = 0;
+    }
+    else if (IsKeyPressed(KEY_UP))
+    {
+        selectedFormat--;
+        if (selectedFormat < 0) selectedFormat = NUM_TEXTURES - 1;
+    }
+    else if (IsKeyPressed(KEY_RIGHT))
+    {
+        if (selectedFormat < NUM_TEXTURES/2) selectedFormat += NUM_TEXTURES/2;
+    }
+    else if (IsKeyPressed(KEY_LEFT))
+    {
+        if (selectedFormat >= NUM_TEXTURES/2) selectedFormat -= NUM_TEXTURES/2;
+    }
+    //----------------------------------------------------------------------------------
+
+    // Draw
+    //----------------------------------------------------------------------------------
+    BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+
+        // Draw rectangles
+        for (int i = 0; i < NUM_TEXTURES; i++)
+        {
+            if (i == selectedFormat)
+            {
+                DrawRectangleRec(selectRecs[i], SKYBLUE);
+                DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, BLUE);
+                DrawText(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[i], 10)/2, selectRecs[i].y + 11, 10, DARKBLUE);
+            }
+            else
+            {
+                DrawRectangleRec(selectRecs[i], LIGHTGRAY);
+                DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, GRAY);
+                DrawText(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[i], 10)/2, selectRecs[i].y + 11, 10, DARKGRAY);
+            }
+        }
+
+        // Draw selected texture
+        if (sonic[selectedFormat].id != 0)
+        {
+            DrawTexture(sonic[selectedFormat], 350, -10, WHITE);
+        }
+        else 
+        {
+            DrawRectangleLines(488, 165, 200, 110, DARKGRAY);
+            DrawText("FORMAT", 550, 180, 20, MAROON);
+            DrawText("NOT SUPPORTED", 500, 210, 20, MAROON);
+            DrawText("ON YOUR GPU", 520, 240, 20, MAROON);
+        }
+
+        DrawText("Select texture format (use cursor keys):", 40, 10, 10, DARKGRAY);
+        DrawText("Required GPU memory size (VRAM):", 40, 427, 10, DARKGRAY);
+        DrawText(FormatText("%4.0f KB", textureSizes[selectedFormat]), 240, 420, 20, DARKBLUE);
+
+    EndDrawing();
+    //----------------------------------------------------------------------------------
+}

docs/examples/web/others/oculus_rift.c

@@ -0,0 +1,538 @@
+/*******************************************************************************************
+*
+*   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);
+}
+

docs/examples/web/others/particles_trail_blending.c

@@ -0,0 +1,163 @@
+/*******************************************************************************************
+*
+*   raylib [core] example - Basic window (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
+
+#define MAX_PARTICLES 200
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+int screenWidth = 800;
+int screenHeight = 450;
+
+// Particle structure with basic data
+typedef struct {
+    Vector2 position;
+    Color color;
+    float alpha;
+    float size;
+    float rotation;
+    bool active;        // NOTE: Use it to activate/deactive particle
+} Particle;
+
+Particle mouseTail[MAX_PARTICLES]; 
+
+float gravity = 3.0f;
+
+Texture2D smoke;
+
+int blending = BLEND_ALPHA;
+
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void);     // Update and Draw one frame
+
+//----------------------------------------------------------------------------------
+// Main Enry Point
+//----------------------------------------------------------------------------------
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
+    
+     // Initialize particles
+    for (int i = 0; i < MAX_PARTICLES; i++)
+    {
+        mouseTail[i].position = (Vector2){ 0, 0 };
+        mouseTail[i].color = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 };
+        mouseTail[i].alpha = 1.0f;
+        mouseTail[i].size = (float)GetRandomValue(1, 30)/20.0f;
+        mouseTail[i].rotation = GetRandomValue(0, 360);
+        mouseTail[i].active = false;
+    }
+    
+    smoke = LoadTexture("resources/smoke.png");
+    
+#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
+    //--------------------------------------------------------------------------------------
+	UnloadTexture(smoke);	// Texture unloading
+
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void)
+{
+    // Update
+    //----------------------------------------------------------------------------------
+    // Activate one particle every frame and Update active particles
+    // NOTE: Particles initial position should be mouse position when activated
+    // NOTE: Particles fall down with gravity and rotation... and disappear after 2 seconds (alpha = 0)
+    // NOTE: When a particle disappears, active = false and it can be reused.
+    for (int i = 0; i < MAX_PARTICLES; i++)
+    {
+        if (!mouseTail[i].active)
+        {
+            mouseTail[i].active = true;
+            mouseTail[i].alpha = 1.0f;
+            mouseTail[i].position = GetMousePosition();
+            i = MAX_PARTICLES;
+        }
+    }
+
+    for (int i = 0; i < MAX_PARTICLES; i++)
+    {
+        if (mouseTail[i].active)
+        {
+            mouseTail[i].position.y += gravity;
+            mouseTail[i].alpha -= 0.01f;
+            
+            if (mouseTail[i].alpha <= 0.0f) mouseTail[i].active = false;
+            
+            mouseTail[i].rotation += 5.0f;
+        }
+    }
+    
+    if (IsKeyPressed(KEY_SPACE))
+    {
+        if (blending == BLEND_ALPHA) blending = BLEND_ADDITIVE;
+        else blending = BLEND_ALPHA;
+    }
+    //----------------------------------------------------------------------------------
+
+    // Draw
+    //----------------------------------------------------------------------------------
+    BeginDrawing();
+
+        ClearBackground(DARKGRAY);
+            
+        BeginBlendMode(blending);
+
+	        // Draw active particles
+	        for (int i = 0; i < MAX_PARTICLES; i++)
+	        {
+	            if (mouseTail[i].active) DrawTexturePro(smoke, (Rectangle){ 0, 0, smoke.width, smoke.height }, 
+	                                                   (Rectangle){ mouseTail[i].position.x, mouseTail[i].position.y, smoke.width*mouseTail[i].size, smoke.height*mouseTail[i].size },
+	                                                   (Vector2){ smoke.width*mouseTail[i].size/2, smoke.height*mouseTail[i].size/2 }, mouseTail[i].rotation,
+	                                                   Fade(mouseTail[i].color, mouseTail[i].alpha));
+	        }
+        
+        EndBlendMode();
+		
+        DrawText("PRESS SPACE to CHANGE BLENDING MODE", 180, 20, 20, BLACK);
+        
+        if (blending == BLEND_ALPHA) DrawText("ALPHA BLENDING", 290, screenHeight - 40, 20, BLACK);
+        else DrawText("ADDITIVE BLENDING", 280, screenHeight - 40, 20, RAYWHITE);
+
+    EndDrawing();
+    //----------------------------------------------------------------------------------
+}