Merge remote-tracking branch 'refs/remotes/raysan5/develop' into develop

examples/oculus_glfw_sample/base.vs

@@ -0,0 +1,26 @@
+#version 330
+
+// Input vertex attributes
+in vec3 vertexPosition;
+in vec2 vertexTexCoord;
+in vec3 vertexNormal;
+in vec4 vertexColor;
+
+// Input uniform values
+uniform mat4 mvpMatrix;
+
+// Output vertex attributes (to fragment shader)
+out vec2 fragTexCoord;
+out vec4 fragColor;
+
+// NOTE: Add here your custom variables 
+
+void main()
+{
+    // Send vertex attributes to fragment shader
+    fragTexCoord = vertexTexCoord;
+    fragColor = vertexColor;
+    
+    // Calculate final vertex position
+    gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
+}

examples/oculus_glfw_sample/distortion.fs

@@ -0,0 +1,59 @@
+#version 330
+
+// Input vertex attributes (from vertex shader)
+in vec2 fragTexCoord;
+
+// Input uniform values
+uniform sampler2D texture0;
+
+// Output fragment color
+out vec4 finalColor;
+
+// NOTE: Add here your custom variables
+const vec2 LeftLensCenter = vec2(0.2863248, 0.5);
+const vec2 RightLensCenter = vec2(0.7136753, 0.5);
+const vec2 LeftScreenCenter = vec2(0.25, 0.5);
+const vec2 RightScreenCenter = vec2(0.75, 0.5);
+const vec2 Scale = vec2(0.25, 0.45);    //vec2(0.1469278, 0.2350845);
+const vec2 ScaleIn = vec2(4, 2.2222);
+const vec4 HmdWarpParam = vec4(1, 0.22, 0.24, 0);
+
+/*
+// Another set of default values
+ChromaAbCorrection = {1.0, 0.0, 1.0, 0}
+DistortionK = {1.0, 0.22, 0.24, 0}
+Scale = {0.25, 0.5*AspectRatio, 0, 0}
+ScaleIn = {4.0, 2/AspectRatio, 0, 0}
+Left Screen Center = {0.25, 0.5, 0, 0}
+Left Lens Center = {0.287994117, 0.5, 0, 0}
+Right Screen Center = {0.75, 0.5, 0, 0}
+Right Lens Center = {0.712005913, 0.5, 0, 0}
+*/
+
+// Scales input texture coordinates for distortion.
+vec2 HmdWarp(vec2 in01, vec2 LensCenter)
+{
+    vec2 theta = (in01 - LensCenter)*ScaleIn; // Scales to [-1, 1]
+    float rSq = theta.x*theta.x + theta.y*theta.y;
+    vec2 rvector = theta*(HmdWarpParam.x + HmdWarpParam.y*rSq + HmdWarpParam.z*rSq*rSq + HmdWarpParam.w*rSq*rSq*rSq);
+
+    return LensCenter + Scale*rvector;
+}
+
+void main()
+{
+    // SOURCE: http://www.mtbs3d.com/phpbb/viewtopic.php?f=140&t=17081
+    
+    // The following two variables need to be set per eye
+    vec2 LensCenter = gl_FragCoord.x < 540 ? LeftLensCenter : RightLensCenter;
+    vec2 ScreenCenter = gl_FragCoord.x < 540 ? LeftScreenCenter : RightScreenCenter;
+
+    vec2 tc = HmdWarp(fragTexCoord, LensCenter);
+
+    if (any(bvec2(clamp(tc,ScreenCenter-vec2(0.25,0.5), ScreenCenter+vec2(0.25,0.5)) - tc))) finalColor = vec4(0.0, 0.0, 0.0, 1.0);
+    else
+    {
+        //tc.x = gl_FragCoord.x < 640 ? (2.0 * tc.x) : (2.0 * (tc.x - 0.5));
+        finalColor = texture2D(texture0, tc);
+    }
+}

examples/oculus_glfw_sample/rlgl_standalone_stereo.c

@@ -24,11 +24,26 @@
 #define RLGL_STANDALONE
 #include "rlgl.h"               // rlgl library: OpenGL 1.1 immediate-mode style coding
 
+#include <stdlib.h>             // Required for: abs()
+
 
 #define RED        (Color){ 230, 41, 55, 255 }     // Red
 #define MAROON     (Color){ 190, 33, 55, 255 }     // Maroon
 #define RAYWHITE   (Color){ 245, 245, 245, 255 }   // My own White (raylib logo)
 #define DARKGRAY   (Color){ 80, 80, 80, 255 }      // Dark Gray
+#define WHITE      (Color){ 255, 255, 255, 255 }   // White
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+
+// Rectangle type
+typedef struct Rectangle {
+    int x;
+    int y;
+    int width;
+    int height;
+} Rectangle;
 
 //----------------------------------------------------------------------------------
 // Module specific Functions Declaration
@@ -41,6 +56,8 @@ 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);
+static void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint);
+static void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint);
 
 //----------------------------------------------------------------------------------
 // Main Entry point
@@ -52,7 +69,6 @@ int main(void)
     const int screenWidth = 1080;
     const int screenHeight = 600;
     
-    
     // GLFW3 Initialization + OpenGL 3.3 Context + Extensions
     //--------------------------------------------------------
     glfwSetErrorCallback(ErrorCallback);
@@ -100,6 +116,14 @@ int main(void)
     rlClearColor(245, 245, 245, 255);   // Define clear color
     rlEnableDepthTest();                // Enable DEPTH_TEST for 3D
     
+    Shader distortion = LoadShader("base.vs", "distortion.fs");
+    
+    // TODO: Upload to distortion shader configuration parameters (screen size, etc.)
+    //SetShaderValue(Shader shader, int uniformLoc, float *value, int size);
+    
+    // Create a RenderTexture2D to be used for render to texture
+    RenderTexture2D target = rlglLoadRenderTexture(screenWidth, screenHeight);
+    
     Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
     
     Camera camera;
@@ -119,6 +143,8 @@ int main(void)
 
         // Draw
         //----------------------------------------------------------------------------------
+        rlEnableRenderTexture(target.id);   // Enable render target
+    
         rlClearScreenBuffers();             // Clear current framebuffer
     
         for (int i = 0; i < 2; i++)
@@ -126,8 +152,11 @@ int main(void)
             rlViewport(i*screenWidth/2, 0, screenWidth/2, screenHeight); 
     
             // Calculate projection matrix (from perspective) and view matrix from camera look at
+            // TODO: Consider every eye fovy
             Matrix matProj = MatrixPerspective(camera.fovy, (double)(screenWidth/2)/(double)screenHeight, 0.01, 1000.0);
             MatrixTranspose(&matProj);
+            
+            // TODO: Recalculate view matrix considering IPD (inter-pupillary-distance)
             Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up);
 
             SetMatrixModelview(matView);    // Replace internal modelview matrix by a custom one
@@ -141,8 +170,8 @@ int main(void)
             rlglDraw();
             
             // Draw '2D' elements in the scene (GUI)
-    #define RLGL_CREATE_MATRIX_MANUALLY
+#define RLGL_CREATE_MATRIX_MANUALLY
-    #if defined(RLGL_CREATE_MATRIX_MANUALLY)
+#if defined(RLGL_CREATE_MATRIX_MANUALLY)
 
             matProj = MatrixOrtho(0.0, screenWidth/2, screenHeight, 0.0, 0.0, 1.0);
             MatrixTranspose(&matProj);
@@ -151,20 +180,39 @@ int main(void)
             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
+#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
+#endif
-                DrawRectangleV((Vector2){ 10.0f, 10.0f }, (Vector2){ 600.0f, 20.0f }, DARKGRAY);
+            // TODO: 2D not drawing properly on stereo rendering
+            //DrawRectangleV((Vector2){ 10.0f, 10.0f }, (Vector2){ 500.0f, 20.0f }, DARKGRAY);
 
             // NOTE: Internal buffers drawing (2D data)
             rlglDraw();
         }
         
+        rlDisableRenderTexture();           // Disable render target
+
+        // Set viewport to default framebuffer size (screen size)
+        rlViewport(0, 0, screenWidth, screenHeight);
+        
+        // Let rlgl reconfigure internal matrices using OpenGL 1.1 style coding
+        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
+    
+        // Draw RenderTexture (fbo) using distortion shader 
+        BeginShaderMode(distortion);
+            // NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
+            DrawTextureRec(target.texture, (Rectangle){ 0, 0, target.texture.width, -target.texture.height }, (Vector2){ 0, 0 }, WHITE);
+        EndShaderMode();
+            
         glfwSwapBuffers(window);
         glfwPollEvents();
         //----------------------------------------------------------------------------------
@@ -172,6 +220,8 @@ int main(void)
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
+    UnloadShader(distortion);
+    
     rlglClose();                // Unload rlgl internal buffers and default shader/texture
     
     glfwDestroyWindow(window);
@@ -392,3 +442,55 @@ void DrawCubeWires(Vector3 position, float width, float height, float length, Co
         rlEnd();
     rlPopMatrix();
 }
+
+// Draw a part of a texture (defined by a rectangle)
+static void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint)
+{
+    Rectangle destRec = { (int)position.x, (int)position.y, abs(sourceRec.width), abs(sourceRec.height) };
+    Vector2 origin = { 0, 0 };
+
+    DrawTexturePro(texture, sourceRec, destRec, origin, 0.0f, tint);
+}
+
+// Draw a part of a texture (defined by a rectangle) with 'pro' parameters
+// NOTE: origin is relative to destination rectangle size
+static void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint)
+{
+    // Check if texture is valid
+    if (texture.id != 0)
+    {
+        if (sourceRec.width < 0) sourceRec.x -= sourceRec.width;
+        if (sourceRec.height < 0) sourceRec.y -= sourceRec.height;
+        
+        rlEnableTexture(texture.id);
+
+        rlPushMatrix();
+            rlTranslatef(destRec.x, destRec.y, 0);
+            rlRotatef(rotation, 0, 0, 1);
+            rlTranslatef(-origin.x, -origin.y, 0);
+
+            rlBegin(RL_QUADS);
+                rlColor4ub(tint.r, tint.g, tint.b, tint.a);
+                rlNormal3f(0.0f, 0.0f, 1.0f);                          // Normal vector pointing towards viewer
+
+                // Bottom-left corner for texture and quad
+                rlTexCoord2f((float)sourceRec.x / texture.width, (float)sourceRec.y / texture.height);
+                rlVertex2f(0.0f, 0.0f);
+
+                // Bottom-right corner for texture and quad
+                rlTexCoord2f((float)sourceRec.x / texture.width, (float)(sourceRec.y + sourceRec.height) / texture.height);
+                rlVertex2f(0.0f, destRec.height);
+
+                // Top-right corner for texture and quad
+                rlTexCoord2f((float)(sourceRec.x + sourceRec.width) / texture.width, (float)(sourceRec.y + sourceRec.height) / texture.height);
+                rlVertex2f(destRec.width, destRec.height);
+
+                // Top-left corner for texture and quad
+                rlTexCoord2f((float)(sourceRec.x + sourceRec.width) / texture.width, (float)sourceRec.y / texture.height);
+                rlVertex2f(destRec.width, 0.0f);
+            rlEnd();
+        rlPopMatrix();
+
+        rlDisableTexture();
+    }
+}

src/core.c

@@ -513,11 +513,6 @@ void CloseWindow(void)
     }
 #endif
 
-#if defined(PLATFORM_OCULUS)
-    ovr_Destroy(session);   // Must be called after glfwTerminate()
-    ovr_Shutdown();
-#endif
-
     TraceLog(INFO, "Window closed successfully");
 }
 
@@ -526,6 +521,7 @@ void CloseWindow(void)
 // NOTE: Device initialization should be done before window creation?
 void InitOculusDevice(void)
 {
+    // Initialize Oculus device
     ovrResult result = ovr_Initialize(NULL);
     if (OVR_FAILURE(result)) TraceLog(ERROR, "OVR: Could not initialize Oculus device");
 
@@ -545,13 +541,13 @@ void InitOculusDevice(void)
     TraceLog(INFO, "OVR: Serian Number: %s", hmdDesc.SerialNumber);
     TraceLog(INFO, "OVR: Resolution: %ix%i", hmdDesc.Resolution.w, hmdDesc.Resolution.h);
     
-    screenWidth = hmdDesc.Resolution.w/2;
+    // NOTE: Oculus mirror is set to defined screenWidth and screenHeight...
-    screenHeight = hmdDesc.Resolution.h/2;
+    // ...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);
+    mirror = LoadOculusMirror(session, screenWidth, screenHeight);
     layer.eyeLayer.ColorTexture[0] = buffer.textureChain;     //SetOculusLayerTexture(eyeLayer, buffer.textureChain);
 }
 
@@ -561,8 +557,8 @@ void CloseOculusDevice(void)
     UnloadOculusMirror(session, mirror);    // Unload Oculus mirror buffer
     UnloadOculusBuffer(session, buffer);    // Unload Oculus texture buffers
 
-    ovr_Destroy(session);   // Must be called after glfwTerminate() -->  REALLY???
+    ovr_Destroy(session);   // Free Oculus session data
-    ovr_Shutdown();
+    ovr_Shutdown();         // Close Oculus device connection
 }
 
 // Update Oculus Rift tracking (position and orientation)
@@ -1626,30 +1622,6 @@ static void InitDisplay(int width, int height)
     // Downscale matrix is required in case desired screen area is bigger than display area
     downscaleView = MatrixIdentity();
 
-#if defined(PLATFORM_OCULUS)
-    ovrResult result = ovr_Initialize(NULL);
-    if (OVR_FAILURE(result)) TraceLog(ERROR, "OVR: Could not initialize Oculus device");
-
-    result = ovr_Create(&session, &luid);
-    if (OVR_FAILURE(result))
-    {
-        TraceLog(WARNING, "OVR: Could not create Oculus session");
-        ovr_Shutdown();
-    }
-
-    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: Serian Number: %s", hmdDesc.SerialNumber);
-    TraceLog(INFO, "OVR: Resolution: %ix%i", hmdDesc.Resolution.w, hmdDesc.Resolution.h);
-    
-    screenWidth = hmdDesc.Resolution.w/2;
-    screenHeight = hmdDesc.Resolution.h/2;
-#endif
-    
 #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
     glfwSetErrorCallback(ErrorCallback);
 
@@ -1964,14 +1936,6 @@ static void InitGraphics(void)
     rlglInit();                     // Init rlgl
     rlglInitGraphics(renderOffsetX, renderOffsetY, renderWidth, renderHeight);  // Init graphics (OpenGL stuff)
 
-#if defined(PLATFORM_OCULUS)
-    // Initialize Oculus Buffers
-    layer = InitOculusLayer(session);   
-    buffer = LoadOculusBuffer(session, layer.width, layer.height);
-    mirror = LoadOculusMirror(session, hmdDesc.Resolution.w/2, hmdDesc.Resolution.h/2);
-    layer.eyeLayer.ColorTexture[0] = buffer.textureChain;     //SetOculusLayerTexture(eyeLayer, buffer.textureChain);
-#endif
-
     ClearBackground(RAYWHITE);      // Default background color for raylib games :P
 
 #if defined(PLATFORM_ANDROID)