From 4476a9e241b952f631afb6c8c3f3c69a481219e3 Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Wed, 2 Mar 2016 17:13:31 +0100
Subject: Review rlglUnproject() system

---
 src/raymath.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/raymath.h')

diff --git a/src/raymath.h b/src/raymath.h
index 35cee39f..52e92b50 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -803,7 +803,7 @@ RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top,
 // Returns perspective projection matrix
 RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double far)
 {
-    double top = near*tanf(fovy*PI/360.0f);
+    double top = near*tan(fovy*PI/360.0);
     double right = top*aspect;
 
     return MatrixFrustum(-right, right, -top, top, near, far);
-- 
cgit v1.2.3


From e060944b34f11978392f5c24282c95781caae63e Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Thu, 12 May 2016 13:02:04 +0200
Subject: Added QuaternionInvert()

---
 src/raymath.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'src/raymath.h')

diff --git a/src/raymath.h b/src/raymath.h
index 52e92b50..59d66e56 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -158,6 +158,7 @@ RMDEF void PrintMatrix(Matrix m);                             // Print matrix ut
 //------------------------------------------------------------------------------------
 RMDEF float QuaternionLength(Quaternion quat);                // Compute the length of a quaternion
 RMDEF void QuaternionNormalize(Quaternion *q);                // Normalize provided quaternion
+RMDEF void QuaternionInvert(Quaternion *quat);                // Invert provided quaternion
 RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2);    // Calculate two quaternion multiplication
 RMDEF Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float slerp); // Calculates spherical linear interpolation between two quaternions
 RMDEF Quaternion QuaternionFromMatrix(Matrix matrix);                 // Returns a quaternion for a given rotation matrix
@@ -908,6 +909,23 @@ RMDEF void QuaternionNormalize(Quaternion *q)
     q->w *= ilength;
 }
 
+// Invert provided quaternion
+RMDEF void QuaternionInvert(Quaternion *quat)
+{
+    float length = QuaternionLength(*quat);
+    float lengthSq = length*length;
+    
+    if (lengthSq != 0.0)
+    {
+        float i = 1.0f/lengthSq;
+        
+        quat->x *= -i;
+        quat->y *= -i;
+        quat->z *= -i;
+        quat->w *= i;
+    }
+}
+
 // Calculate two quaternion multiplication
 RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)
 {
-- 
cgit v1.2.3


From d17a0cee1aa53978387e68be58d901bffd1ac0a9 Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Tue, 31 May 2016 19:12:37 +0200
Subject: Review text formatting (spacing, tabs...)

---
 examples/resources/shaders/standard.fs |   8 ++-
 src/core.c                             |  18 +++---
 src/raylib.h                           |  96 +++++++++++++++---------------
 src/raymath.h                          |   2 +-
 src/rlgl.c                             |   2 +-
 src/rlgl.h                             | 103 +++++++++++++++++----------------
 src/shapes.c                           |   2 +-
 7 files changed, 117 insertions(+), 114 deletions(-)

(limited to 'src/raymath.h')

diff --git a/examples/resources/shaders/standard.fs b/examples/resources/shaders/standard.fs
index e5916031..e5a6d1bc 100644
--- a/examples/resources/shaders/standard.fs
+++ b/examples/resources/shaders/standard.fs
@@ -88,8 +88,10 @@ vec3 CalcSpotLight(Light l, vec3 n, vec3 v, float s)
     // Spot attenuation
     float attenuation = clamp(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
@@ -103,7 +105,7 @@ vec3 CalcSpotLight(Light l, vec3 n, vec3 v, float s)
         spec = pow(dot(n, h), 3 + glossiness)*s;
     }
     
-    return falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb);
+    return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
 }
 
 void main()
@@ -122,7 +124,7 @@ void main()
     vec3 lighting = colAmbient.rgb;
     
     // Calculate normal texture color fetching or set to maximum normal value by default
-    if(useNormal == 1)
+    if (useNormal == 1)
     {
         n *= texture(texture1, fragTexCoord).rgb;
         n = normalize(n);
@@ -130,7 +132,7 @@ void main()
     
     // Calculate specular texture color fetching or set to maximum specular value by default
     float spec = 1.0;
-    if(useSpecular == 1) spec *= normalize(texture(texture2, fragTexCoord).r);
+    if (useSpecular == 1) spec *= normalize(texture(texture2, fragTexCoord).r);
     
     for (int i = 0; i < lightsCount; i++)
     {
diff --git a/src/core.c b/src/core.c
index 70dfa7a5..7bd44c81 100644
--- a/src/core.c
+++ b/src/core.c
@@ -2078,10 +2078,10 @@ static void MouseButtonCallback(GLFWwindow *window, int button, int action, int
     gestureEvent.position[0] = GetMousePosition();
     
     // Normalize gestureEvent.position[0] for screenWidth and screenHeight
-    gestureEvent.position[0].x /= (float)GetScreenWidth(); 
+    gestureEvent.position[0].x /= (float)GetScreenWidth();
     gestureEvent.position[0].y /= (float)GetScreenHeight();
-	
-	// Gesture data is sent to gestures system for processing
+
+    // Gesture data is sent to gestures system for processing
     ProcessGestureEvent(gestureEvent);
 #endif
 }
@@ -2223,10 +2223,10 @@ static void AndroidCommandCallback(struct android_app *app, int32_t cmd)
                     // Load default font for convenience
                     // NOTE: External function (defined in module: text)
                     LoadDefaultFont();
-                    
+
                     // TODO: GPU assets reload in case of lost focus (lost context)
                     // NOTE: This problem has been solved just unbinding and rebinding context from display
-					/*
+                    /*
                     if (assetsReloadRequired)
                     {
                         for (int i = 0; i < assetsCount; i++)
@@ -2759,9 +2759,9 @@ static void *GamepadThread(void *arg)
     };
 
     // Read gamepad event
-	struct js_event gamepadEvent;
+    struct js_event gamepadEvent;
     
-	while (1) 
+    while (1) 
     {
         for (int i = 0; i < MAX_GAMEPADS; i++)
         {
@@ -2792,8 +2792,8 @@ static void *GamepadThread(void *arg)
                 }
             }
         }
-	}
-    
+    }
+
     return NULL;
 }
 #endif
diff --git a/src/raylib.h b/src/raylib.h
index 271c0e42..1ef0a98e 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -349,7 +349,7 @@ typedef struct Camera {
     Vector3 position;       // Camera position
     Vector3 target;         // Camera target it looks-at
     Vector3 up;             // Camera up vector (rotation over its axis)
-    float fovy;             // Field-Of-View apperture in Y (degrees)
+    float fovy;             // Camera field-of-view apperture in Y (degrees)
 } Camera;
 
 // Camera2D type, defines a 2d camera
@@ -362,86 +362,84 @@ typedef struct Camera2D {
 
 // Bounding box type
 typedef struct BoundingBox {
-    Vector3 min;
-    Vector3 max;
+    Vector3 min;            // minimum vertex box-corner
+    Vector3 max;            // maximum vertex box-corner
 } BoundingBox;
 
 // Vertex data definning a mesh
 typedef struct Mesh {
-    int vertexCount;            // number of vertices stored in arrays
-    int triangleCount;          // number of triangles stored (indexed or not)
-    float *vertices;            // vertex position (XYZ - 3 components per vertex) (shader-location = 0)
-    float *texcoords;           // vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
-    float *texcoords2;          // vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
-    float *normals;             // vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
-    float *tangents;            // vertex tangents (XYZ - 3 components per vertex) (shader-location = 4)
-    unsigned char *colors;      // vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
-    unsigned short *indices;    // vertex indices (in case vertex data comes indexed)
-
-    BoundingBox bounds;         // mesh limits defined by min and max points
-    
-    unsigned int vaoId;         // OpenGL Vertex Array Object id
-    unsigned int vboId[7];      // OpenGL Vertex Buffer Objects id (7 types of vertex data)
+    int vertexCount;        // number of vertices stored in arrays
+    int triangleCount;      // number of triangles stored (indexed or not)
+    float *vertices;        // vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+    float *texcoords;       // vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+    float *texcoords2;      // vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
+    float *normals;         // vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
+    float *tangents;        // vertex tangents (XYZ - 3 components per vertex) (shader-location = 4)
+    unsigned char *colors;  // vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+    unsigned short *indices;// vertex indices (in case vertex data comes indexed)
+
+    unsigned int vaoId;     // OpenGL Vertex Array Object id
+    unsigned int vboId[7];  // OpenGL Vertex Buffer Objects id (7 types of vertex data)
 } Mesh;
 
 // Shader type (generic shader)
 typedef struct Shader {
-    unsigned int id;      // Shader program id
+    unsigned int id;        // Shader program id
     
     // Vertex attributes locations (default locations)
-    int vertexLoc;        // Vertex attribute location point    (default-location = 0)
-    int texcoordLoc;      // Texcoord attribute location point  (default-location = 1)
-    int texcoord2Loc;     // Texcoord2 attribute location point (default-location = 5)
-    int normalLoc;        // Normal attribute location point    (default-location = 2)
-    int tangentLoc;       // Tangent attribute location point   (default-location = 4)
-    int colorLoc;         // Color attibute location point      (default-location = 3)
+    int vertexLoc;          // Vertex attribute location point    (default-location = 0)
+    int texcoordLoc;        // Texcoord attribute location point  (default-location = 1)
+    int texcoord2Loc;       // Texcoord2 attribute location point (default-location = 5)
+    int normalLoc;          // Normal attribute location point    (default-location = 2)
+    int tangentLoc;         // Tangent attribute location point   (default-location = 4)
+    int colorLoc;           // Color attibute location point      (default-location = 3)
 
     // Uniform locations
-    int mvpLoc;           // ModelView-Projection matrix uniform location point (vertex shader)
-    int tintColorLoc;     // Diffuse color uniform location point (fragment shader)
+    int mvpLoc;             // ModelView-Projection matrix uniform location point (vertex shader)
+    int tintColorLoc;       // Diffuse color uniform location point (fragment shader)
     
     // Texture map locations (generic for any kind of map)
-    int mapTexture0Loc;  // Map texture uniform location point (default-texture-unit = 0)
-    int mapTexture1Loc;  // Map texture uniform location point (default-texture-unit = 1)
-    int mapTexture2Loc;  // Map texture uniform location point (default-texture-unit = 2)
+    int mapTexture0Loc;     // Map texture uniform location point (default-texture-unit = 0)
+    int mapTexture1Loc;     // Map texture uniform location point (default-texture-unit = 1)
+    int mapTexture2Loc;     // Map texture uniform location point (default-texture-unit = 2)
 } Shader;
 
 // Material type
 typedef struct Material {
-    Shader shader;              // Standard shader (supports 3 map textures)
+    Shader shader;          // Standard shader (supports 3 map textures)
 
-    Texture2D texDiffuse;       // Diffuse texture  (binded to shader mapTexture0Loc)
-    Texture2D texNormal;        // Normal texture   (binded to shader mapTexture1Loc)
-    Texture2D texSpecular;      // Specular texture (binded to shader mapTexture2Loc)
+    Texture2D texDiffuse;   // Diffuse texture  (binded to shader mapTexture0Loc)
+    Texture2D texNormal;    // Normal texture   (binded to shader mapTexture1Loc)
+    Texture2D texSpecular;  // Specular texture (binded to shader mapTexture2Loc)
     
-    Color colDiffuse;           // Diffuse color
-    Color colAmbient;           // Ambient color
-    Color colSpecular;          // Specular color
+    Color colDiffuse;       // Diffuse color
+    Color colAmbient;       // Ambient color
+    Color colSpecular;      // Specular color
     
-    float glossiness;           // Glossiness level (Ranges from 0 to 1000)
+    float glossiness;       // Glossiness level (Ranges from 0 to 1000)
 } Material;
 
 // Model type
 typedef struct Model {
-    Mesh mesh;                  // Vertex data buffers (RAM and VRAM)
-    Matrix transform;           // Local transform matrix
-    Material material;          // Shader and textures data
+    Mesh mesh;              // Vertex data buffers (RAM and VRAM)
+    Matrix transform;       // Local transform matrix
+    Material material;      // Shader and textures data
 } Model;
 
 // Light type
 typedef struct LightData {
-    unsigned int id;    // Light id
-    int type;           // Light type: LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT
-    bool enabled;       // Light enabled
+    unsigned int id;        // Light unique id
+    int type;               // Light type: LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT
+    bool enabled;           // Light enabled
     
-    Vector3 position;   // Light position
-    Vector3 target;     // Light target: LIGHT_DIRECTIONAL and LIGHT_SPOT (cone direction target)
-    float radius;       // Light attenuation radius light intensity reduced with distance (world distance)
+    Vector3 position;       // Light position
+    Vector3 target;         // Light target: LIGHT_DIRECTIONAL and LIGHT_SPOT (cone direction target)
+    float radius;           // Light attenuation radius light intensity reduced with distance (world distance)
     
-    Color diffuse;      // Light diffuse color
-    float intensity;    // Light intensity level
+    Color diffuse;          // Light diffuse color
+    float intensity;        // Light intensity level
     
-    float coneAngle;    // Light cone max angle: LIGHT_SPOT
+    float coneAngle;        // Light cone max angle: LIGHT_SPOT
 } LightData, *Light;
 
 // Light types
diff --git a/src/raymath.h b/src/raymath.h
index 59d66e56..2e055e9f 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -73,7 +73,7 @@
 //----------------------------------------------------------------------------------
 
 #if defined(RAYMATH_STANDALONE)
-	// Vector2 type
+    // Vector2 type
     typedef struct Vector2 {
         float x;
         float y;
diff --git a/src/rlgl.c b/src/rlgl.c
index 6a2adeb2..89361f46 100644
--- a/src/rlgl.c
+++ b/src/rlgl.c
@@ -2369,7 +2369,7 @@ static void LoadCompressedTexture(unsigned char *data, int width, int height, in
 static unsigned int LoadShaderProgram(char *vShaderStr, char *fShaderStr)
 {
     unsigned int program = 0;
-	
+
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
     GLuint vertexShader;
     GLuint fragmentShader;
diff --git a/src/rlgl.h b/src/rlgl.h
index 336f6019..e8e754b4 100644
--- a/src/rlgl.h
+++ b/src/rlgl.h
@@ -130,51 +130,43 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
         COMPRESSED_ASTC_4x4_RGBA,       // 8 bpp
         COMPRESSED_ASTC_8x8_RGBA        // 2 bpp
     } TextureFormat;
-    
-    // Bounding box type
-    typedef struct BoundingBox {
-        Vector3 min;
-        Vector3 max;
-    } BoundingBox;
 
     // Vertex data definning a mesh
     typedef struct Mesh {
-        int vertexCount;            // number of vertices stored in arrays
-        float *vertices;            // vertex position (XYZ - 3 components per vertex) (shader-location = 0)
-        float *texcoords;           // vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
-        float *texcoords2;          // vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
-        float *normals;             // vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
-        float *tangents;            // vertex tangents (XYZ - 3 components per vertex) (shader-location = 4)
-        unsigned char *colors;      // vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
-        unsigned short *indices;    // vertex indices (in case vertex data comes indexed)
-        int triangleCount;          // number of triangles stored (indexed or not)
-        
-        BoundingBox bounds;         // mesh limits defined by min and max points
-        
-        unsigned int vaoId;         // OpenGL Vertex Array Object id
-        unsigned int vboId[7];      // OpenGL Vertex Buffer Objects id (7 types of vertex data)
+        int vertexCount;        // number of vertices stored in arrays
+        int triangleCount;      // number of triangles stored (indexed or not)
+        float *vertices;        // vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+        float *texcoords;       // vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+        float *texcoords2;      // vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
+        float *normals;         // vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
+        float *tangents;        // vertex tangents (XYZ - 3 components per vertex) (shader-location = 4)
+        unsigned char *colors;  // vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+        unsigned short *indices;// vertex indices (in case vertex data comes indexed)
+
+        unsigned int vaoId;     // OpenGL Vertex Array Object id
+        unsigned int vboId[7];  // OpenGL Vertex Buffer Objects id (7 types of vertex data)
     } Mesh;
 
     // Shader type (generic shader)
     typedef struct Shader {
-        unsigned int id;      // Shader program id
+        unsigned int id;        // Shader program id
         
         // Vertex attributes locations (default locations)
-        int vertexLoc;        // Vertex attribute location point (default-location = 0)
-        int texcoordLoc;      // Texcoord attribute location point (default-location = 1)
-        int normalLoc;        // Normal attribute location point (default-location = 2)
-        int colorLoc;         // Color attibute location point (default-location = 3)
-        int tangentLoc;       // Tangent attribute location point (default-location = 4)
-        int texcoord2Loc;     // Texcoord2 attribute location point (default-location = 5)
+        int vertexLoc;          // Vertex attribute location point (default-location = 0)
+        int texcoordLoc;        // Texcoord attribute location point (default-location = 1)
+        int normalLoc;          // Normal attribute location point (default-location = 2)
+        int colorLoc;           // Color attibute location point (default-location = 3)
+        int tangentLoc;         // Tangent attribute location point (default-location = 4)
+        int texcoord2Loc;       // Texcoord2 attribute location point (default-location = 5)
 
         // Uniform locations
-        int mvpLoc;           // ModelView-Projection matrix uniform location point (vertex shader)
-        int tintColorLoc;     // Color uniform location point (fragment shader)
+        int mvpLoc;             // ModelView-Projection matrix uniform location point (vertex shader)
+        int tintColorLoc;       // Color uniform location point (fragment shader)
         
         // Texture map locations (generic for any kind of map)
-        int mapTexture0Loc;  // Map texture uniform location point (default-texture-unit = 0)
-        int mapTexture1Loc;  // Map texture uniform location point (default-texture-unit = 1)
-        int mapTexture2Loc;  // Map texture uniform location point (default-texture-unit = 2)
+        int mapTexture0Loc;     // Map texture uniform location point (default-texture-unit = 0)
+        int mapTexture1Loc;     // Map texture uniform location point (default-texture-unit = 1)
+        int mapTexture2Loc;     // Map texture uniform location point (default-texture-unit = 2)
     } Shader;
 
     // Texture2D type
@@ -196,35 +188,46 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
     
     // Material type
     typedef struct Material {
-        Shader shader;              // Standard shader (supports 3 map types: diffuse, normal, specular)
+        Shader shader;          // Standard shader (supports 3 map types: diffuse, normal, specular)
 
-        Texture2D texDiffuse;       // Diffuse texture
-        Texture2D texNormal;        // Normal texture
-        Texture2D texSpecular;      // Specular texture
+        Texture2D texDiffuse;   // Diffuse texture
+        Texture2D texNormal;    // Normal texture
+        Texture2D texSpecular;  // Specular texture
 
-        Color colDiffuse;           // Diffuse color
-        Color colAmbient;           // Ambient color
-        Color colSpecular;          // Specular color
+        Color colDiffuse;       // Diffuse color
+        Color colAmbient;       // Ambient color
+        Color colSpecular;      // Specular color
         
-        float glossiness;           // Glossiness level (Ranges from 0 to 1000)
+        float glossiness;       // Glossiness level (Ranges from 0 to 1000)
     } Material;
     
+    // Camera type, defines a camera position/orientation in 3d space
+    typedef struct Camera {
+        Vector3 position;       // Camera position
+        Vector3 target;         // Camera target it looks-at
+        Vector3 up;             // Camera up vector (rotation over its axis)
+        float fovy;             // Camera field-of-view apperture in Y (degrees)
+    } Camera;
+
     // Light type
     typedef struct LightData {
-        unsigned int id;    // Light id
-        int type;           // Light type: LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT
-        bool enabled;       // Light enabled
+        unsigned int id;        // Light unique id
+        int type;               // Light type: LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT
+        bool enabled;           // Light enabled
         
-        Vector3 position;   // Light position
-        Vector3 target;     // Light target: LIGHT_DIRECTIONAL and LIGHT_SPOT (cone direction target)
-        float radius;       // Light attenuation radius light intensity reduced with distance (world distance)
+        Vector3 position;       // Light position
+        Vector3 target;         // Light target: LIGHT_DIRECTIONAL and LIGHT_SPOT (cone direction target)
+        float radius;           // Light attenuation radius light intensity reduced with distance (world distance)
         
-        Color diffuse;      // Light diffuse color
-        float intensity;    // Light intensity level
+        Color diffuse;          // Light diffuse color
+        float intensity;        // Light intensity level
         
-        float coneAngle;    // Light cone max angle: LIGHT_SPOT
+        float coneAngle;        // Light cone max angle: LIGHT_SPOT
     } LightData, *Light;
-	
+    
+    // Light types
+    typedef enum { LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT } LightType;
+
     // Color blending modes (pre-defined)
     typedef enum { BLEND_ALPHA = 0, BLEND_ADDITIVE, BLEND_MULTIPLIED } BlendMode;
 #endif
diff --git a/src/shapes.c b/src/shapes.c
index 5b66e5ef..7129ac17 100644
--- a/src/shapes.c
+++ b/src/shapes.c
@@ -489,7 +489,7 @@ Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2)
                 retRec.height = rec2.height - dyy;
             }
         }
-		
+
         if (rec1.width > rec2.width)
         {
             if (retRec.width >= rec2.width) retRec.width = rec2.width;
-- 
cgit v1.2.3


From 5bcddca5e1841f7d320f769bdd56f0f89327cd14 Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Thu, 2 Jun 2016 18:29:49 +0200
Subject: Remove useless stuff

---
 src/raymath.h | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

(limited to 'src/raymath.h')

diff --git a/src/raymath.h b/src/raymath.h
index 2e055e9f..188bd610 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -151,7 +151,6 @@ RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top,
 RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double far);                        // Returns perspective projection matrix
 RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far);    // Returns orthographic projection matrix
 RMDEF Matrix MatrixLookAt(Vector3 position, Vector3 target, Vector3 up);  // Returns camera look-at matrix (view matrix)
-RMDEF void PrintMatrix(Matrix m);                             // Print matrix utility
 
 //------------------------------------------------------------------------------------
 // Functions Declaration to work with Quaternions
@@ -178,9 +177,7 @@ RMDEF void QuaternionTransform(Quaternion *q, Matrix mat);            // Transfo
 
 #if defined(RAYMATH_IMPLEMENTATION) || defined(RAYMATH_EXTERN_INLINE)
 
-#include <stdio.h>      // Used only on PrintMatrix()
-#include <math.h>       // Standard math libary: sin(), cos(), tan()...
-#include <stdlib.h>     // Used for abs()
+#include <math.h>       // Required for: sinf(), cosf(), tan(), fabs()
 
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Vector3 math
@@ -871,17 +868,6 @@ RMDEF Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)
     return result;
 }
 
-// Print matrix utility (for debug)
-RMDEF void PrintMatrix(Matrix m)
-{
-    printf("----------------------\n");
-    printf("%2.2f %2.2f %2.2f %2.2f\n", m.m0, m.m4, m.m8, m.m12);
-    printf("%2.2f %2.2f %2.2f %2.2f\n", m.m1, m.m5, m.m9, m.m13);
-    printf("%2.2f %2.2f %2.2f %2.2f\n", m.m2, m.m6, m.m10, m.m14);
-    printf("%2.2f %2.2f %2.2f %2.2f\n", m.m3, m.m7, m.m11, m.m15);
-    printf("----------------------\n");
-}
-
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Quaternion math
 //----------------------------------------------------------------------------------
-- 
cgit v1.2.3


From 0bc71d84f8ca2b8cbe48eae8769fb16958b98531 Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Thu, 2 Jun 2016 20:23:09 +0200
Subject: Added functions to customize internal matrix

Internal modelview and projection matrices can be replaced before
drawing.
---
 src/raylib.h  |  3 +++
 src/raymath.h |  5 ++---
 src/rlgl.c    | 25 ++++++++++++++++++-------
 src/rlgl.h    |  3 +++
 4 files changed, 26 insertions(+), 10 deletions(-)

(limited to 'src/raymath.h')

diff --git a/src/raylib.h b/src/raylib.h
index a00c0ff9..efd96a67 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -868,6 +868,9 @@ void SetShaderValue(Shader shader, int uniformLoc, float *value, int size); // S
 void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size);  // Set shader uniform value (int)
 void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat);       // Set shader uniform value (matrix 4x4)
 
+void SetMatrixProjection(Matrix proj);                              // Set a custom projection matrix (replaces internal projection matrix)
+void SetMatrixModelview(Matrix view);                               // Set a custom modelview matrix (replaces internal modelview matrix)
+
 void BeginShaderMode(Shader shader);                                // Begin custom shader drawing
 void EndShaderMode(void);                                           // End custom shader drawing (use default shader)
 void BeginBlendMode(int mode);                                      // Begin blending mode (alpha, additive, multiplied)
diff --git a/src/raymath.h b/src/raymath.h
index 188bd610..4075a1a9 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -339,15 +339,14 @@ RMDEF Vector3 VectorReflect(Vector3 vector, Vector3 normal)
     return result;
 }
 
-// Transforms a Vector3 with a given Matrix
+// Transforms a Vector3 by a given Matrix
+// TODO: Review math (matrix transpose required?)
 RMDEF void VectorTransform(Vector3 *v, Matrix mat)
 {
     float x = v->x;
     float y = v->y;
     float z = v->z;
 
-    //MatrixTranspose(&mat);
-
     v->x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;
     v->y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;
     v->z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14;
diff --git a/src/rlgl.c b/src/rlgl.c
index cfa6e2e6..6beececb 100644
--- a/src/rlgl.c
+++ b/src/rlgl.c
@@ -28,7 +28,7 @@
 
 #include "rlgl.h"
 
-#include <stdio.h>                  // Standard input / output lib
+#include <stdio.h>                  // Required for: fopen(), fclose(), fread()... [Used only on ReadTextFile()]
 #include <stdlib.h>                 // Required for: malloc(), free(), rand()
 #include <string.h>                 // Required for: strcmp(), strlen(), strtok()
 
@@ -59,8 +59,8 @@
 #endif
 
 #if defined(RLGL_STANDALONE)
-    #include <stdarg.h>             // Required for: va_list, va_start(), vfprintf(), va_end()
-#endif                              // NOTE: Used on TraceLog()
+    #include <stdarg.h>             // Required for: va_list, va_start(), vfprintf(), va_end() [Used only on TraceLog()]
+#endif
 
 //----------------------------------------------------------------------------------
 // Defines and Macros
@@ -355,7 +355,6 @@ void rlRotatef(float angleDeg, float x, float y, float z)
     Vector3 axis = (Vector3){ x, y, z };
     VectorNormalize(&axis);
     matRotation = MatrixRotate(axis, angleDeg*DEG2RAD);
-
     MatrixTranspose(&matRotation);
 
     *currentMatrix = MatrixMultiply(*currentMatrix, matRotation);
@@ -2153,7 +2152,7 @@ void UnloadShader(Shader shader)
     }
 }
 
-// Set custom shader to be used on batch draw
+// Begin custom shader mode
 void BeginShaderMode(Shader shader)
 {
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
@@ -2165,7 +2164,7 @@ void BeginShaderMode(Shader shader)
 #endif
 }
 
-// Set default shader to be used in batch draw
+// End custom shader mode (returns to default shader)
 void EndShaderMode(void)
 {
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
@@ -2251,6 +2250,18 @@ void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat)
 #endif
 }
 
+// Set a custom projection matrix (replaces internal projection matrix)
+void SetMatrixProjection(Matrix proj)
+{
+    projection = proj;
+}
+
+// Set a custom modelview matrix (replaces internal modelview matrix)
+void SetMatrixModelview(Matrix view)
+{
+    modelview = view;
+}
+
 // Begin blending mode (alpha, additive, multiplied)
 // NOTE: Only 3 blending modes supported, default blend mode is alpha
 void BeginBlendMode(int mode)
@@ -3068,7 +3079,7 @@ static void UnloadDefaultBuffers(void)
     free(quads.indices);
 }
 
-// Sets shader uniform values for lights array
+// Setup shader uniform values for lights array
 // NOTE: It would be far easier with shader UBOs but are not supported on OpenGL ES 2.0f
 static void SetShaderLights(Shader shader)
 {
diff --git a/src/rlgl.h b/src/rlgl.h
index 00482d2e..2a578a1f 100644
--- a/src/rlgl.h
+++ b/src/rlgl.h
@@ -329,6 +329,9 @@ void SetShaderValue(Shader shader, int uniformLoc, float *value, int size); // S
 void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size);  // Set shader uniform value (int)
 void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat);       // Set shader uniform value (matrix 4x4)
 
+void SetMatrixProjection(Matrix proj);                              // Set a custom projection matrix (replaces internal projection matrix)
+void SetMatrixModelview(Matrix view);                               // Set a custom modelview matrix (replaces internal modelview matrix)
+
 void BeginShaderMode(Shader shader);                                // Begin custom shader drawing
 void EndShaderMode(void);                                           // End custom shader drawing (use default shader)
 void BeginBlendMode(int mode);                                      // Begin blending mode (alpha, additive, multiplied)
-- 
cgit v1.2.3


From c46c0fc6520914d6e9488282c02c96395d8bea9f Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Sat, 11 Jun 2016 12:18:08 +0200
Subject: Corrected keywords usage

---
 src/physac.h  |  8 --------
 src/raygui.h  |  8 --------
 src/raymath.h | 18 ++++++++----------
 3 files changed, 8 insertions(+), 26 deletions(-)

(limited to 'src/raymath.h')

diff --git a/src/physac.h b/src/physac.h
index f576ad8a..6a90dc29 100644
--- a/src/physac.h
+++ b/src/physac.h
@@ -142,10 +142,6 @@ typedef struct PhysicBodyData {
     bool enabled;
 } PhysicBodyData, *PhysicBody;
 
-#ifdef __cplusplus
-extern "C" {            // Prevents name mangling of functions
-#endif
-
 //----------------------------------------------------------------------------------
 // Module Functions Declaration
 //----------------------------------------------------------------------------------
@@ -161,10 +157,6 @@ PHYSACDEF void ApplyForceAtPosition(Vector2 position, float force, float radius)
 
 PHYSACDEF Rectangle TransformToRectangle(Transform transform);                          // Convert Transform data type to Rectangle (position and scale)
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif // PHYSAC_H
 
 
diff --git a/src/raygui.h b/src/raygui.h
index f13b68cd..74f131d5 100644
--- a/src/raygui.h
+++ b/src/raygui.h
@@ -239,10 +239,6 @@ typedef enum GuiProperty {
     TEXTBOX_TEXT_FONTSIZE
 } GuiProperty;
 
-#ifdef __cplusplus
-extern "C" {            
-#endif
-
 //----------------------------------------------------------------------------------
 // Global Variables Definition
 //----------------------------------------------------------------------------------
@@ -369,10 +365,6 @@ RAYGUIDEF void LoadGuiStyle(const char *fileName);                        // Loa
 RAYGUIDEF void SetStyleProperty(int guiProperty, int value);              // Set one style property
 RAYGUIDEF int GetStyleProperty(int guiProperty);                          // Get one style property
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif // RAYGUI_H
 
 
diff --git a/src/raymath.h b/src/raymath.h
index 4075a1a9..10eabb6b 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -47,10 +47,16 @@
     #include "raylib.h"             // Required for structs: Vector3, Matrix
 #endif
 
+#ifdef __cplusplus
+    #define RMEXTERN extern "C"     // Functions visible from other files (no name mangling of functions in C++)
+#else
+    #define RMEXTERN extern         // Functions visible from other files
+#endif
+
 #if defined(RAYMATH_EXTERN_INLINE)
-    #define RMDEF extern inline
+    #define RMDEF RMEXTERN inline   // Functions are embeded inline (compiler generated code)
 #else
-    #define RMDEF extern
+    #define RMDEF RMEXTERN
 #endif
 
 //----------------------------------------------------------------------------------
@@ -105,10 +111,6 @@ typedef struct Quaternion {
 
 #ifndef RAYMATH_EXTERN_INLINE
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 //------------------------------------------------------------------------------------
 // Functions Declaration to work with Vector3
 //------------------------------------------------------------------------------------
@@ -166,10 +168,6 @@ RMDEF Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle);  // Returns
 RMDEF void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle); // Returns the rotation angle and axis for a given quaternion
 RMDEF void QuaternionTransform(Quaternion *q, Matrix mat);            // Transform a quaternion given a transformation matrix
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif  // notdef RAYMATH_EXTERN_INLINE
 
 #endif  // RAYMATH_H
-- 
cgit v1.2.3


From 377dcb025fb6957f73263e1913dfc5f29ba21a58 Mon Sep 17 00:00:00 2001
From: Ray <raysan5@gmail.com>
Date: Mon, 5 Dec 2016 01:14:18 +0100
Subject: Corrected some warnings

---
 src/audio.c    | 16 ++++++++------
 src/camera.h   | 70 ++++++++++++++++++++++++++++++----------------------------
 src/core.c     |  4 ++--
 src/gestures.h | 12 +++++-----
 src/models.c   |  6 +++--
 src/raymath.h  | 16 +++++++-------
 src/rlgl.c     | 10 ++++++---
 src/shapes.c   | 15 +++++++------
 src/text.c     | 33 +++++++++++++--------------
 src/textures.c | 25 +++++++++++----------
 10 files changed, 108 insertions(+), 99 deletions(-)

(limited to 'src/raymath.h')

diff --git a/src/audio.c b/src/audio.c
index 49aca4b0..eef07154 100644
--- a/src/audio.c
+++ b/src/audio.c
@@ -411,6 +411,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
                 else
                 {
                     // Depending on type, skip the right amount of parameters
+					/* TODO: Review
                     switch (infoHeader.type)
                     {
                         case 0: fseek(rresFile, 6, SEEK_CUR); break;   // IMAGE: Jump 6 bytes of parameters
@@ -420,6 +421,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
                         case 4: break;   // RAW: No parameters
                         default: break;
                     }
+					*/
 
                     // Jump DATA to read next infoHeader
                     fseek(rresFile, infoHeader.size, SEEK_CUR);
@@ -604,7 +606,7 @@ void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels)
 // Copy a wave to a new wave
 Wave WaveCopy(Wave wave)
 {
-    Wave newWave;
+	Wave newWave = { 0 };
 
     if (wave.sampleSize == 8) newWave.data = (unsigned char *)malloc(wave.sampleCount*wave.channels*sizeof(unsigned char));
     else if (wave.sampleSize == 16) newWave.data = (short *)malloc(wave.sampleCount*wave.channels*sizeof(short));
@@ -822,8 +824,8 @@ void UpdateMusicStream(Music music)
     if (processed > 0)
     {
         bool active = true;
-        short pcm[AUDIO_BUFFER_SIZE];
-        float pcmf[AUDIO_BUFFER_SIZE];
+        short pcm[AUDIO_BUFFER_SIZE];				// TODO: Dynamic allocation (uses more than 16KB of stack)
+        float pcmf[AUDIO_BUFFER_SIZE];				// TODO: Dynamic allocation (uses more than 16KB of stack)
         int numBuffersToProcess = processed;
 
         int numSamples = 0;     // Total size of data steamed in L+R samples for xm floats,
@@ -952,7 +954,7 @@ float GetMusicTimePlayed(Music music)
     float secondsPlayed = 0.0f;
 
     unsigned int samplesPlayed = music->totalSamples - music->samplesLeft;
-    secondsPlayed = (float)samplesPlayed/(music->stream.sampleRate*music->stream.channels);
+    secondsPlayed = (float)(samplesPlayed/(music->stream.sampleRate*music->stream.channels));
 
     return secondsPlayed;
 }
@@ -1004,17 +1006,17 @@ AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, un
     {
         if (stream.sampleSize == 8)
         {
-            unsigned char pcm[AUDIO_BUFFER_SIZE] = { 0 };
+            unsigned char pcm[AUDIO_BUFFER_SIZE] = { 0 };	// TODO: Dynamic allocation (uses more than 16KB of stack)
             alBufferData(stream.buffers[i], stream.format, pcm, AUDIO_BUFFER_SIZE*sizeof(unsigned char), stream.sampleRate);
         }
         else if (stream.sampleSize == 16)
         {
-            short pcm[AUDIO_BUFFER_SIZE] = { 0 };
+            short pcm[AUDIO_BUFFER_SIZE] = { 0 };	// TODO: Dynamic allocation (uses more than 16KB of stack)
             alBufferData(stream.buffers[i], stream.format, pcm, AUDIO_BUFFER_SIZE*sizeof(short), stream.sampleRate);
         }
         else if (stream.sampleSize == 32)
         {
-            float pcm[AUDIO_BUFFER_SIZE] = { 0.0f };
+            float pcm[AUDIO_BUFFER_SIZE] = { 0.0f };	// TODO: Dynamic allocation (uses more than 16KB of stack)
             alBufferData(stream.buffers[i], stream.format, pcm, AUDIO_BUFFER_SIZE*sizeof(float), stream.sampleRate);
         }
     }
diff --git a/src/camera.h b/src/camera.h
index 33220390..cf542288 100644
--- a/src/camera.h
+++ b/src/camera.h
@@ -223,15 +223,15 @@ void SetCameraMode(Camera camera, int mode)
     float dy = v2.y - v1.y;
     float dz = v2.z - v1.z;
     
-    cameraTargetDistance = sqrt(dx*dx + dy*dy + dz*dz);
+    cameraTargetDistance = sqrtf(dx*dx + dy*dy + dz*dz);
     
     Vector2 distance = { 0.0f, 0.0f };
-    distance.x = sqrt(dx*dx + dz*dz);
-    distance.y = sqrt(dx*dx + dy*dy);
+    distance.x = sqrtf(dx*dx + dz*dz);
+    distance.y = sqrtf(dx*dx + dy*dy);
     
     // Camera angle calculation
-    cameraAngle.x = asin(fabs(dx)/distance.x);  // Camera angle in plane XZ (0 aligned with Z, move positive CCW)
-    cameraAngle.y = -asin(fabs(dy)/distance.y); // Camera angle in plane XY (0 aligned with X, move positive CW)
+    cameraAngle.x = asinf(fabsf(dx)/distance.x);  // Camera angle in plane XZ (0 aligned with Z, move positive CCW)
+    cameraAngle.y = -asinf(fabsf(dy)/distance.y); // Camera angle in plane XY (0 aligned with X, move positive CW)
     
     // NOTE: Just testing what cameraAngle means
     //cameraAngle.x = 0.0f*DEG2RAD;      // Camera angle in plane XZ (0 aligned with Z, move positive CCW)
@@ -285,10 +285,10 @@ void UpdateCamera(Camera *camera)
         {
             HideCursor();
 
-            if (mousePosition.x < screenHeight/3) SetMousePosition((Vector2){ screenWidth - screenHeight/3, mousePosition.y });
-            else if (mousePosition.y < screenHeight/3) SetMousePosition((Vector2){ mousePosition.x, screenHeight - screenHeight/3 });
-            else if (mousePosition.x > (screenWidth - screenHeight/3)) SetMousePosition((Vector2){ screenHeight/3, mousePosition.y });
-            else if (mousePosition.y > (screenHeight - screenHeight/3)) SetMousePosition((Vector2){ mousePosition.x, screenHeight/3 });
+            if (mousePosition.x < (float)screenHeight/3.0f) SetMousePosition((Vector2){ screenWidth - screenHeight/3, mousePosition.y });
+            else if (mousePosition.y < (float)screenHeight/3.0f) SetMousePosition((Vector2){ mousePosition.x, screenHeight - screenHeight/3 });
+            else if (mousePosition.x > (screenWidth - (float)screenHeight/3.0f)) SetMousePosition((Vector2){ screenHeight/3, mousePosition.y });
+            else if (mousePosition.y > (screenHeight - (float)screenHeight/3.0f)) SetMousePosition((Vector2){ mousePosition.x, screenHeight/3 });
             else
             {
                 mousePositionDelta.x = mousePosition.x - previousMousePosition.x;
@@ -321,6 +321,7 @@ void UpdateCamera(Camera *camera)
                 if (cameraTargetDistance > CAMERA_FREE_DISTANCE_MAX_CLAMP) cameraTargetDistance = CAMERA_FREE_DISTANCE_MAX_CLAMP;
             }
             // Camera looking down
+			// TODO: Review, weird comparisson of cameraTargetDistance == 120.0f?
             else if ((camera->position.y > camera->target.y) && (cameraTargetDistance == CAMERA_FREE_DISTANCE_MAX_CLAMP) && (mouseWheelMove < 0))
             {
                 camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/cameraTargetDistance;
@@ -341,6 +342,7 @@ void UpdateCamera(Camera *camera)
                 if (cameraTargetDistance < CAMERA_FREE_DISTANCE_MIN_CLAMP) cameraTargetDistance = CAMERA_FREE_DISTANCE_MIN_CLAMP;
             }
             // Camera looking up
+			// TODO: Review, weird comparisson of cameraTargetDistance == 120.0f?
             else if ((camera->position.y < camera->target.y) && (cameraTargetDistance == CAMERA_FREE_DISTANCE_MAX_CLAMP) && (mouseWheelMove < 0))
             {
                 camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/cameraTargetDistance;
@@ -385,9 +387,9 @@ void UpdateCamera(Camera *camera)
                 else
                 {
                     // Camera panning
-                    camera->target.x += ((mousePositionDelta.x*-CAMERA_FREE_MOUSE_SENSITIVITY)*cos(cameraAngle.x) + (mousePositionDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY)*sin(cameraAngle.x)*sin(cameraAngle.y))*(cameraTargetDistance/CAMERA_FREE_PANNING_DIVIDER);
-                    camera->target.y += ((mousePositionDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY)*cos(cameraAngle.y))*(cameraTargetDistance/CAMERA_FREE_PANNING_DIVIDER);
-                    camera->target.z += ((mousePositionDelta.x*CAMERA_FREE_MOUSE_SENSITIVITY)*sin(cameraAngle.x) + (mousePositionDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY)*cos(cameraAngle.x)*sin(cameraAngle.y))*(cameraTargetDistance/CAMERA_FREE_PANNING_DIVIDER);
+                    camera->target.x += ((mousePositionDelta.x*-CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(cameraAngle.x) + (mousePositionDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY)*sinf(cameraAngle.x)*sinf(cameraAngle.y))*(cameraTargetDistance/CAMERA_FREE_PANNING_DIVIDER);
+                    camera->target.y += ((mousePositionDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(cameraAngle.y))*(cameraTargetDistance/CAMERA_FREE_PANNING_DIVIDER);
+                    camera->target.z += ((mousePositionDelta.x*CAMERA_FREE_MOUSE_SENSITIVITY)*sinf(cameraAngle.x) + (mousePositionDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(cameraAngle.x)*sinf(cameraAngle.y))*(cameraTargetDistance/CAMERA_FREE_PANNING_DIVIDER);
                 }
             }
 
@@ -404,19 +406,19 @@ void UpdateCamera(Camera *camera)
         case CAMERA_FIRST_PERSON:
         case CAMERA_THIRD_PERSON:
         {
-            camera->position.x += (sin(cameraAngle.x)*direction[MOVE_BACK] -
-                                   sin(cameraAngle.x)*direction[MOVE_FRONT] -
-                                   cos(cameraAngle.x)*direction[MOVE_LEFT] +
-                                   cos(cameraAngle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
+            camera->position.x += (sinf(cameraAngle.x)*direction[MOVE_BACK] -
+                                   sinf(cameraAngle.x)*direction[MOVE_FRONT] -
+                                   cosf(cameraAngle.x)*direction[MOVE_LEFT] +
+                                   cosf(cameraAngle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
                                    
-            camera->position.y += (sin(cameraAngle.y)*direction[MOVE_FRONT] -
-                                   sin(cameraAngle.y)*direction[MOVE_BACK] +
+            camera->position.y += (sinf(cameraAngle.y)*direction[MOVE_FRONT] -
+                                   sinf(cameraAngle.y)*direction[MOVE_BACK] +
                                    1.0f*direction[MOVE_UP] - 1.0f*direction[MOVE_DOWN])/PLAYER_MOVEMENT_SENSITIVITY;
                                    
-            camera->position.z += (cos(cameraAngle.x)*direction[MOVE_BACK] -
-                                   cos(cameraAngle.x)*direction[MOVE_FRONT] +
-                                   sin(cameraAngle.x)*direction[MOVE_LEFT] -
-                                   sin(cameraAngle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
+            camera->position.z += (cosf(cameraAngle.x)*direction[MOVE_BACK] -
+                                   cosf(cameraAngle.x)*direction[MOVE_FRONT] +
+                                   sinf(cameraAngle.x)*direction[MOVE_LEFT] -
+                                   sinf(cameraAngle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
 
             bool isMoving = false;  // Required for swinging
 
@@ -439,9 +441,9 @@ void UpdateCamera(Camera *camera)
                 if (cameraTargetDistance < CAMERA_THIRD_PERSON_DISTANCE_CLAMP) cameraTargetDistance = CAMERA_THIRD_PERSON_DISTANCE_CLAMP;
 
                 // Camera is always looking at player
-                camera->target.x = camera->position.x + CAMERA_THIRD_PERSON_OFFSET.x*cos(cameraAngle.x) + CAMERA_THIRD_PERSON_OFFSET.z*sin(cameraAngle.x);
+                camera->target.x = camera->position.x + CAMERA_THIRD_PERSON_OFFSET.x*cosf(cameraAngle.x) + CAMERA_THIRD_PERSON_OFFSET.z*sinf(cameraAngle.x);
                 camera->target.y = camera->position.y + CAMERA_THIRD_PERSON_OFFSET.y;
-                camera->target.z = camera->position.z + CAMERA_THIRD_PERSON_OFFSET.z*sin(cameraAngle.x) - CAMERA_THIRD_PERSON_OFFSET.x*sin(cameraAngle.x);
+                camera->target.z = camera->position.z + CAMERA_THIRD_PERSON_OFFSET.z*sinf(cameraAngle.x) - CAMERA_THIRD_PERSON_OFFSET.x*sinf(cameraAngle.x);
             }
             else    // CAMERA_FIRST_PERSON
             {
@@ -450,18 +452,18 @@ void UpdateCamera(Camera *camera)
                 else if (cameraAngle.y < CAMERA_FIRST_PERSON_MAX_CLAMP*DEG2RAD) cameraAngle.y = CAMERA_FIRST_PERSON_MAX_CLAMP*DEG2RAD;
 
                 // Camera is always looking at player
-                camera->target.x = camera->position.x - sin(cameraAngle.x)*CAMERA_FIRST_PERSON_FOCUS_DISTANCE;
-                camera->target.y = camera->position.y + sin(cameraAngle.y)*CAMERA_FIRST_PERSON_FOCUS_DISTANCE;
-                camera->target.z = camera->position.z - cos(cameraAngle.x)*CAMERA_FIRST_PERSON_FOCUS_DISTANCE;
+                camera->target.x = camera->position.x - sinf(cameraAngle.x)*CAMERA_FIRST_PERSON_FOCUS_DISTANCE;
+                camera->target.y = camera->position.y + sinf(cameraAngle.y)*CAMERA_FIRST_PERSON_FOCUS_DISTANCE;
+                camera->target.z = camera->position.z - cosf(cameraAngle.x)*CAMERA_FIRST_PERSON_FOCUS_DISTANCE;
                 
                 if (isMoving) swingCounter++;
 
                 // Camera position update
                 // NOTE: On CAMERA_FIRST_PERSON player Y-movement is limited to player 'eyes position'
-                camera->position.y = playerEyesPosition - sin(swingCounter/CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER)/CAMERA_FIRST_PERSON_STEP_DIVIDER;
+                camera->position.y = playerEyesPosition - sinf(swingCounter/CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER)/CAMERA_FIRST_PERSON_STEP_DIVIDER;
 
-                camera->up.x = sin(swingCounter/(CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER*2))/CAMERA_FIRST_PERSON_WAVING_DIVIDER;
-                camera->up.z = -sin(swingCounter/(CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER*2))/CAMERA_FIRST_PERSON_WAVING_DIVIDER;
+                camera->up.x = sinf(swingCounter/(CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER*2))/CAMERA_FIRST_PERSON_WAVING_DIVIDER;
+                camera->up.z = -sinf(swingCounter/(CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER*2))/CAMERA_FIRST_PERSON_WAVING_DIVIDER;
             }
         } break;
         default: break;
@@ -473,10 +475,10 @@ void UpdateCamera(Camera *camera)
         (cameraMode == CAMERA_THIRD_PERSON))
     {
         // TODO: It seems camera->position is not correctly updated or some rounding issue makes the camera move straight to camera->target...
-        camera->position.x = sin(cameraAngle.x)*cameraTargetDistance*cos(cameraAngle.y) + camera->target.x;
-        if (cameraAngle.y <= 0.0f) camera->position.y = sin(cameraAngle.y)*cameraTargetDistance*sin(cameraAngle.y) + camera->target.y;
-        else camera->position.y = -sin(cameraAngle.y)*cameraTargetDistance*sin(cameraAngle.y) + camera->target.y;
-        camera->position.z = cos(cameraAngle.x)*cameraTargetDistance*cos(cameraAngle.y) + camera->target.z;
+        camera->position.x = sinf(cameraAngle.x)*cameraTargetDistance*cosf(cameraAngle.y) + camera->target.x;
+        if (cameraAngle.y <= 0.0f) camera->position.y = sinf(cameraAngle.y)*cameraTargetDistance*sinf(cameraAngle.y) + camera->target.y;
+        else camera->position.y = -sinf(cameraAngle.y)*cameraTargetDistance*sinf(cameraAngle.y) + camera->target.y;
+        camera->position.z = cosf(cameraAngle.x)*cameraTargetDistance*cosf(cameraAngle.y) + camera->target.z;
     }
 }
 
diff --git a/src/core.c b/src/core.c
index 241772ec..7fa20979 100644
--- a/src/core.c
+++ b/src/core.c
@@ -779,7 +779,7 @@ float GetFrameTime(void)
     // As we are operate quite a lot with frameTime,
     // it could be no stable, so we round it before passing it around
     // NOTE: There are still problems with high framerates (>500fps)
-    double roundedFrameTime =  round(frameTime*10000)/10000.0;
+    double roundedFrameTime = round(frameTime*10000)/10000.0;
 
     return (float)roundedFrameTime;    // Time in seconds to run a frame
 }
@@ -1089,7 +1089,7 @@ Vector2 GetWorldToScreen(Vector3 position, Camera camera)
     QuaternionTransform(&worldPos, matProj);
 
     // Calculate normalized device coordinates (inverted y)
-    Vector3 ndcPos = { worldPos.x/worldPos.w, -worldPos.y/worldPos.w, worldPos.z/worldPos.z };
+    Vector3 ndcPos = { worldPos.x/worldPos.w, -worldPos.y/worldPos.w, worldPos.z/worldPos.w };
 
     // Calculate 2d screen position vector
     Vector2 screenPosition = { (ndcPos.x + 1.0f)/2.0f*(float)GetScreenWidth(), (ndcPos.y + 1.0f)/2.0f*(float)GetScreenHeight() };
diff --git a/src/gestures.h b/src/gestures.h
index 481ef317..19b09269 100644
--- a/src/gestures.h
+++ b/src/gestures.h
@@ -179,7 +179,7 @@ static int tapCounter = 0;                      // TAP counter (one tap implies
 
 // Hold gesture variables
 static bool resetHold = false;                  // HOLD reset to get first touch point again
-static float timeHold = 0.0f;                   // HOLD duration in milliseconds
+static double timeHold = 0.0f;                  // HOLD duration in milliseconds
 
 // Drag gesture variables
 static Vector2 dragVector = { 0.0f , 0.0f };    // DRAG vector (between initial and current position)
@@ -423,11 +423,11 @@ float GetGestureHoldDuration(void)
 {
     // NOTE: time is calculated on current gesture HOLD
     
-    float time = 0.0f;
+    double time = 0.0;
     
-    if (currentGesture == GESTURE_HOLD) time = (float)GetCurrentTime() - timeHold;
+    if (currentGesture == GESTURE_HOLD) time = GetCurrentTime() - timeHold;
     
-    return time;
+    return (float)time;
 }
 
 // Get drag vector (between initial touch point to current)
@@ -474,7 +474,7 @@ static float Vector2Angle(Vector2 initialPosition, Vector2 finalPosition)
 {
     float angle;
 
-    angle = atan2(finalPosition.y - initialPosition.y, finalPosition.x - initialPosition.x)*(180.0f/PI);
+    angle = atan2f(finalPosition.y - initialPosition.y, finalPosition.x - initialPosition.x)*(180.0f/PI);
     
     if (angle < 0) angle += 360.0f;
 
@@ -489,7 +489,7 @@ static float Vector2Distance(Vector2 v1, Vector2 v2)
     float dx = v2.x - v1.x;
     float dy = v2.y - v1.y;
 
-    result = sqrt(dx*dx + dy*dy);
+    result = (float)sqrt(dx*dx + dy*dy);
 
     return result;
 }
diff --git a/src/models.c b/src/models.c
index 48f8b813..97c84abc 100644
--- a/src/models.c
+++ b/src/models.c
@@ -707,6 +707,7 @@ Model LoadModelFromRES(const char *rresName, int resId)
                 else
                 {
                     // Depending on type, skip the right amount of parameters
+					/* Review
                     switch (infoHeader.type)
                     {
                         case 0: fseek(rresFile, 6, SEEK_CUR); break;    // IMAGE: Jump 6 bytes of parameters
@@ -716,6 +717,7 @@ Model LoadModelFromRES(const char *rresName, int resId)
                         case 4: break;                                  // RAW: No parameters
                         default: break;
                     }
+					*/
 
                     // Jump DATA to read next infoHeader
                     fseek(rresFile, infoHeader.size, SEEK_CUR);
@@ -1517,8 +1519,8 @@ bool CheckCollisionRayBox(Ray ray, BoundingBox box)
     t[3] = (box.max.y - ray.position.y)/ray.direction.y;
     t[4] = (box.min.z - ray.position.z)/ray.direction.z;
     t[5] = (box.max.z - ray.position.z)/ray.direction.z;
-    t[6] = fmax(fmax(fmin(t[0], t[1]), fmin(t[2], t[3])), fmin(t[4], t[5]));
-    t[7] = fmin(fmin(fmax(t[0], t[1]), fmax(t[2], t[3])), fmax(t[4], t[5]));
+    t[6] = (float)fmax(fmax(fmin(t[0], t[1]), fmin(t[2], t[3])), fmin(t[4], t[5]));
+    t[7] = (float)fmin(fmin(fmax(t[0], t[1]), fmax(t[2], t[3])), fmax(t[4], t[5]));
 
     collision = !(t[7] < 0 || t[6] > t[7]);
 
diff --git a/src/raymath.h b/src/raymath.h
index 10eabb6b..3cd1394e 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -222,16 +222,16 @@ RMDEF Vector3 VectorPerpendicular(Vector3 v)
 {
     Vector3 result;
 
-    float min = fabs(v.x);
+    float min = fabsf(v.x);
     Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f};
 
-    if (fabs(v.y) < min)
+    if (fabsf(v.y) < min)
     {
-        min = fabs(v.y);
+        min = fabsf(v.y);
         cardinalAxis = (Vector3){0.0f, 1.0f, 0.0f};
     }
 
-    if(fabs(v.z) < min)
+    if(fabsf(v.z) < min)
     {
         cardinalAxis = (Vector3){0.0f, 0.0f, 1.0f};
     }
@@ -256,7 +256,7 @@ RMDEF float VectorLength(const Vector3 v)
 {
     float length;
 
-    length = sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
+    length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
 
     return length;
 }
@@ -284,7 +284,7 @@ RMDEF void VectorNormalize(Vector3 *v)
 
     length = VectorLength(*v);
 
-    if (length == 0) length = 1.0f;
+    if (length == 0.0f) length = 1.0f;
 
     ilength = 1.0f/length;
 
@@ -302,7 +302,7 @@ RMDEF float VectorDistance(Vector3 v1, Vector3 v2)
     float dy = v2.y - v1.y;
     float dz = v2.z - v1.z;
 
-    result = sqrt(dx*dx + dy*dy + dz*dz);
+    result = sqrtf(dx*dx + dy*dy + dz*dz);
 
     return result;
 }
@@ -590,7 +590,7 @@ RMDEF Matrix MatrixRotate(Vector3 axis, float angle)
 
     float x = axis.x, y = axis.y, z = axis.z;
 
-    float length = sqrt(x*x + y*y + z*z);
+    float length = sqrtf(x*x + y*y + z*z);
 
     if ((length != 1.0f) && (length != 0.0f))
     {
diff --git a/src/rlgl.c b/src/rlgl.c
index 47e2a57d..83cc7050 100644
--- a/src/rlgl.c
+++ b/src/rlgl.c
@@ -902,6 +902,10 @@ void rlDisableTexture(void)
 #if defined(GRAPHICS_API_OPENGL_11)
     glDisable(GL_TEXTURE_2D);
     glBindTexture(GL_TEXTURE_2D, 0);
+#else
+    // NOTE: If quads batch limit is reached, 
+    // we force a draw call and next batch starts
+    if (quads.vCounter/4 >= MAX_QUADS_BATCH) rlglDraw();
 #endif
 }
 
@@ -922,11 +926,11 @@ void rlTextureParameters(unsigned int id, int param, int value)
         case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_2D, param, value); break;
         case RL_TEXTURE_ANISOTROPIC_FILTER:
         {
-            if (value <= maxAnisotropicLevel) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, value);
+            if (value <= maxAnisotropicLevel) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
             else if (maxAnisotropicLevel > 0.0f)
             {
                 TraceLog(WARNING, "[TEX ID %i] Maximum anisotropic filter level supported is %iX", id, maxAnisotropicLevel);
-                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, value);
+                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
             }
             else TraceLog(WARNING, "Anisotropic filtering not supported");
         } break;
@@ -1776,7 +1780,7 @@ void rlglGenerateMipmaps(Texture2D *texture)
         #define MIN(a,b) (((a)<(b))?(a):(b))
         #define MAX(a,b) (((a)>(b))?(a):(b))
         
-        texture->mipmaps =  1 + floor(log2(MAX(texture->width, texture->height)));
+        texture->mipmaps =  1 + (int)floor(log2(MAX(texture->width, texture->height)));
 #endif
     }
     else TraceLog(WARNING, "[TEX ID %i] Mipmaps can not be generated", texture->id);
diff --git a/src/shapes.c b/src/shapes.c
index 70aad59a..3d3333c1 100644
--- a/src/shapes.c
+++ b/src/shapes.c
@@ -453,16 +453,17 @@ bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec)
     int recCenterX = rec.x + rec.width/2;
     int recCenterY = rec.y + rec.height/2;
     
-    float dx = fabs(center.x - recCenterX);
-    float dy = fabs(center.y - recCenterY);
+    float dx = fabsf(center.x - recCenterX);
+    float dy = fabsf(center.y - recCenterY);
 
-    if (dx > (rec.width/2 + radius)) { return false; }
-    if (dy > (rec.height/2 + radius)) { return false; }
+    if (dx > ((float)rec.width/2.0f + radius)) { return false; }
+    if (dy > ((float)rec.height/2.0f + radius)) { return false; }
 
-    if (dx <= (rec.width/2)) { return true; } 
-    if (dy <= (rec.height/2)) { return true; }
+    if (dx <= ((float)rec.width/2.0f)) { return true; }
+    if (dy <= ((float)rec.height/2.0f)) { return true; }
 
-    float cornerDistanceSq = (dx - rec.width/2)*(dx - rec.width/2) + (dy - rec.height/2)*(dy - rec.height/2);
+    float cornerDistanceSq = (dx - (float)rec.width/2.0f)*(dx - (float)rec.width/2.0f) + 
+						     (dy - (float)rec.height/2.0f)*(dy - (float)rec.height/2.0f);
 
     return (cornerDistanceSq <= (radius*radius));
 }
diff --git a/src/text.c b/src/text.c
index c394889e..27b0a9ce 100644
--- a/src/text.c
+++ b/src/text.c
@@ -367,7 +367,7 @@ void DrawTextEx(SpriteFont spriteFont, const char *text, Vector2 position, float
         if ((unsigned char)text[i] == '\n')
         {
             // NOTE: Fixed line spacing of 1.5 lines
-            textOffsetY += ((spriteFont.size + spriteFont.size/2)*scaleFactor);
+            textOffsetY += (int)((spriteFont.size + spriteFont.size/2)*scaleFactor);
             textOffsetX = 0;
         }
         else
@@ -394,8 +394,8 @@ void DrawTextEx(SpriteFont spriteFont, const char *text, Vector2 position, float
                                         spriteFont.charRecs[index].width*scaleFactor, 
                                         spriteFont.charRecs[index].height*scaleFactor }, (Vector2){ 0, 0 }, 0.0f, tint);
 
-            if (spriteFont.charAdvanceX[index] == 0) textOffsetX += (spriteFont.charRecs[index].width*scaleFactor + spacing);
-            else textOffsetX += (spriteFont.charAdvanceX[index]*scaleFactor + spacing);
+            if (spriteFont.charAdvanceX[index] == 0) textOffsetX += (int)(spriteFont.charRecs[index].width*scaleFactor + spacing);
+            else textOffsetX += (int)(spriteFont.charAdvanceX[index]*scaleFactor + spacing);
         }
     }
 }
@@ -460,14 +460,14 @@ int MeasureText(const char *text, int fontSize)
 Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, float fontSize, int spacing)
 {
     int len = strlen(text);
-    int tempLen = 0;            // Used to count longer text line num chars
+    int tempLen = 0;				// Used to count longer text line num chars
     int lenCounter = 0;
 
-    int textWidth = 0;
-    int tempTextWidth = 0;      // Used to count longer text line width
+    float textWidth = 0;
+	float tempTextWidth = 0;		// Used to count longer text line width
 
-    int textHeight = spriteFont.size;
-    float scaleFactor = fontSize/spriteFont.size;
+	float textHeight = (float)spriteFont.size;
+    float scaleFactor = fontSize/(float)spriteFont.size;
 
     for (int i = 0; i < len; i++)
     {
@@ -485,7 +485,7 @@ Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, float fontSize, i
             if (tempTextWidth < textWidth) tempTextWidth = textWidth;
             lenCounter = 0;
             textWidth = 0;
-            textHeight += (spriteFont.size + spriteFont.size/2); // NOTE: Fixed line spacing of 1.5 lines
+            textHeight += ((float)spriteFont.size*1.5f); // NOTE: Fixed line spacing of 1.5 lines
         }
 
         if (tempLen < lenCounter) tempLen = lenCounter;
@@ -494,8 +494,8 @@ Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, float fontSize, i
     if (tempTextWidth < textWidth) tempTextWidth = textWidth;
 
     Vector2 vec;
-    vec.x = (float)tempTextWidth*scaleFactor + (tempLen - 1)*spacing; // Adds chars spacing to measure
-    vec.y = (float)textHeight*scaleFactor;
+    vec.x = tempTextWidth*scaleFactor + (float)((tempLen - 1)*spacing); // Adds chars spacing to measure
+    vec.y = textHeight*scaleFactor;
 
     return vec;
 }
@@ -504,10 +504,8 @@ Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, float fontSize, i
 // NOTE: Uses default font
 void DrawFPS(int posX, int posY)
 {
-    char buffer[20];
-
     // NOTE: We are rendering fps every second for better viewing on high framerates
-    // TODO: Not working properly on ANDROID and RPI
+    // TODO: Not working properly on ANDROID and RPI (for high framerates)
 
     static float fps = 0.0f;
     static int counter = 0;
@@ -520,12 +518,11 @@ void DrawFPS(int posX, int posY)
     else
     {
         fps = GetFPS();
-        refreshRate = fps;
+        refreshRate = (int)fps;
         counter = 0;
     }
-
-    sprintf(buffer, "%2.0f FPS", fps);
-    DrawText(buffer, posX, posY, 20, LIME);
+    
+    DrawText(FormatText("%2.0f FPS", fps), posX, posY, 20, LIME);
 }
 
 //----------------------------------------------------------------------------------
diff --git a/src/textures.c b/src/textures.c
index 126adad3..631468f9 100644
--- a/src/textures.c
+++ b/src/textures.c
@@ -317,6 +317,7 @@ Image LoadImageFromRES(const char *rresName, int resId)
                 else
                 {
                     // Depending on type, skip the right amount of parameters
+					/* TODO: Review
                     switch (infoHeader.type)
                     {
                         case 0: fseek(rresFile, 6, SEEK_CUR); break;    // IMAGE: Jump 6 bytes of parameters
@@ -326,7 +327,7 @@ Image LoadImageFromRES(const char *rresName, int resId)
                         case 4: break;                                  // RAW: No parameters
                         default: break;
                     }
-
+					*/
                     // Jump DATA to read next infoHeader
                     fseek(rresFile, infoHeader.size, SEEK_CUR);
                 }
@@ -1100,18 +1101,18 @@ void ImageResizeNN(Image *image,int newWidth,int newHeight)
     Color *output = (Color *)malloc(newWidth*newHeight*sizeof(Color));
 
     // EDIT: added +1 to account for an early rounding problem
-    int x_ratio = (int)((image->width<<16)/newWidth) + 1;
-    int y_ratio = (int)((image->height<<16)/newHeight) + 1;
+    int xRatio = (int)((image->width << 16)/newWidth) + 1;
+    int yRatio = (int)((image->height << 16)/newHeight) + 1;
 
     int x2, y2;
-    for (int i = 0; i < newHeight; i++)
+    for (int y = 0; y < newHeight; y++)
     {
-        for (int j = 0; j < newWidth; j++)
+        for (int x = 0; x < newWidth; x++)
         {
-            x2 = ((j*x_ratio) >> 16);
-            y2 = ((i*y_ratio) >> 16);
+            x2 = ((x*xRatio) >> 16);
+            y2 = ((y*yRatio) >> 16);
 
-            output[(i*newWidth) + j] = pixels[(y2*image->width) + x2] ;
+            output[(y*newWidth) + x] = pixels[(y2*image->width) + x2] ;
         }
     }
 
@@ -1584,7 +1585,7 @@ void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, V
         rlEnableTexture(texture.id);
 
         rlPushMatrix();
-            rlTranslatef(destRec.x, destRec.y, 0);
+            rlTranslatef((float)destRec.x, (float)destRec.y, 0);
             rlRotatef(rotation, 0, 0, 1);
             rlTranslatef(-origin.x, -origin.y, 0);
 
@@ -1598,15 +1599,15 @@ void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, V
 
                 // 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);
+                rlVertex2f(0.0f, (float)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);
+                rlVertex2f((float)destRec.width, (float)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);
+                rlVertex2f((float)destRec.width, 0.0f);
             rlEnd();
         rlPopMatrix();
 
-- 
cgit v1.2.3


From d5d391faaf69027b8fecb26f30754c3bff83c311 Mon Sep 17 00:00:00 2001
From: Joel Davis <joeld42@gmail.com>
Date: Mon, 2 Jan 2017 21:56:25 -0800
Subject: Added RaycastMesh function and example test case

---
 examples/core_3d_raypick.c                 | 159 +++++++---
 examples/resources/model/lowpoly-tower.obj | 456 +++++++++++++++++++++++++++++
 examples/resources/model/lowpoly-tower.png | Bin 0 -> 24939 bytes
 src/models.c                               |  38 +++
 src/raylib.h                               |   3 +
 src/raymath.h                              |  26 ++
 src/shapes.c                               |  73 ++++-
 7 files changed, 708 insertions(+), 47 deletions(-)
 create mode 100644 examples/resources/model/lowpoly-tower.obj
 create mode 100644 examples/resources/model/lowpoly-tower.png

(limited to 'src/raymath.h')

diff --git a/examples/core_3d_raypick.c b/examples/core_3d_raypick.c
index c1c32771..cf56b277 100644
--- a/examples/core_3d_raypick.c
+++ b/examples/core_3d_raypick.c
@@ -1,15 +1,21 @@
 /*******************************************************************************************
 *
-*   raylib [core] example - Ray-Picking in 3d mode, also ground plane
+*   raylib [core] example - Ray-Picking in 3d mode, ground plane, triangle, mesh
 *
 *   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)
+*   Example contributed by Joel Davis (@joeld42)
 *
 ********************************************************************************************/
 
 #include "raylib.h"
+#include "raymath.h"
+
+#include <stdio.h>
+#include <float.h>
+
 
 int main()
 {
@@ -22,24 +28,36 @@ int main()
 
     // Define the camera to look into our 3d world
     Camera camera;
-    camera.position = (Vector3){ 10.0f, 10.0f, 10.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.position = (Vector3){ 10.0f, 8.0f, 10.0f }; // Camera position
+    camera.target = (Vector3){ 0.0f, 2.3f, 0.0f };      // Camera looking at point
+    camera.up = (Vector3){ 0.0f, 1.6f, 0.0f };          // Camera up vector (rotation towards target)
     camera.fovy = 45.0f;                                // Camera field-of-view Y
 
     Vector3 cubePosition = { 0.0f, 1.0f, 0.0f };
     Vector3 cubeSize = { 2.0f, 2.0f, 2.0f };
-    Vector3 groundCursorPos = { 0 };
     
     Ray ray;        // Picking line ray
     
-    bool collision = false;
-    
+    Model tower = LoadModel("resources/model/lowpoly-tower.obj");           // Load OBJ model
+    Texture2D texture = LoadTexture("resources/model/lowpoly-tower.png");   // Load model texture
+    tower.material.texDiffuse = texture;                                    // Set model diffuse texture
+    Vector3 towerPos = { 0.0f, 0.0f, 0.0f };                                // Set model position
+    BoundingBox towerBBox = CalculateBoundingBox( tower.mesh );    
+    bool hitMeshBBox;
+    bool hitTriangle;
+
+    // Test triangle
+    Vector3 ta = (Vector3){ -25.0, 0.5, 0.0 };    
+    Vector3 tb = (Vector3){ -4.0, 2.5, 1.0 };
+    Vector3 tc = (Vector3){ -8.0, 6.5, 0.0 };
+
+    Vector3 bary = {0};
+
     SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
 
     SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
-    //--------------------------------------------------------------------------------------
 
+    //--------------------------------------------------------------------------------------
     // Main game loop
     while (!WindowShouldClose())        // Detect window close button or ESC key
     {
@@ -47,22 +65,52 @@ int main()
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera);          // Update camera
         
-        // if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
-        // {
-        //     // NOTE: This function is NOT WORKING properly!
-        //     ray = GetMouseRay(GetMousePosition(), camera);
-            
-        //     // Check collision between ray and box
-        //     collision = CheckCollisionRayBox(ray,
-        //                 (BoundingBox){(Vector3){ cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2 },
-        //                               (Vector3){ cubePosition.x + cubeSize.x/2, cubePosition.y + cubeSize.y/2, cubePosition.z + cubeSize.z/2 }});
-        // }
 
+        // Display information about closest hit
+        RayHitInfo nearestHit;
+        char *hitObjectName = "None";
+        nearestHit.distance = FLT_MAX;
+        nearestHit.hit = false;
+        Color cursorColor = WHITE;
+
+        // Get ray and test against ground, triangle, and mesh
         ray = GetMouseRay(GetMousePosition(), camera);
-        RayHitInfo hitinfo = RaycastGroundPlane( ray, 0.0 );
+        
+        RayHitInfo groundHitInfo = RaycastGroundPlane( ray, 0.0 );
+        if ((groundHitInfo.hit) && (groundHitInfo.distance < nearestHit.distance)) {
+            nearestHit = groundHitInfo;
+            cursorColor = GREEN;
+            hitObjectName = "Ground";
+        }
+
+        RayHitInfo triHitInfo = RaycastTriangle( ray, ta, tb, tc );
+        if ((triHitInfo.hit) && (triHitInfo.distance < nearestHit.distance)) {
+            nearestHit = triHitInfo;
+            cursorColor = PURPLE;
+            hitObjectName = "Triangle";
+
+            bary = Barycentric( nearestHit.hitPosition, ta, tb, tc );
+            hitTriangle = true;
+        } else {
+            hitTriangle = false;
+        }
+
+        RayHitInfo meshHitInfo;
+
+        // check the bounding box first, before trying the full ray/mesh test
+        if (CheckCollisionRayBox( ray, towerBBox )) {
+            hitMeshBBox = true;
+            meshHitInfo = RaycastMesh( ray, &tower.mesh );    
+            if ((meshHitInfo.hit) && (meshHitInfo.distance < nearestHit.distance)) {
+                nearestHit = meshHitInfo;
+                cursorColor = ORANGE;
+                hitObjectName = "Mesh";
+            }
+        } else {
+            hitMeshBBox = false;
+        }    
 
         //----------------------------------------------------------------------------------
-
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
@@ -71,37 +119,66 @@ int main()
 
             Begin3dMode(camera);
 
-                if (collision) 
-                {
-                    DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, RED);
-                    DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, MAROON);
-
-                    DrawCubeWires(cubePosition, cubeSize.x + 0.2f, cubeSize.y + 0.2f, cubeSize.z + 0.2f, GREEN);
-                }
-                else
-                {
-                    DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, GRAY);
-                    DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, DARKGRAY);
+                // Draw the tower
+                DrawModel( tower, towerPos, 1.0, WHITE );
+                
+                // Draw the test triangle
+                DrawLine3D( ta, tb, PURPLE );
+                DrawLine3D( tb, tc, PURPLE );
+                DrawLine3D( tc, ta, PURPLE );
+
+                // Draw the mesh bbox if we hit it
+                if (hitMeshBBox) {
+                    DrawBoundingBox( towerBBox, LIME );
                 }
 
-                if (hitinfo.hit) {
+                // If we hit something, draw the cursor at the hit point
+                if (nearestHit.hit) {
+                    DrawCube( nearestHit.hitPosition, 0.5, 0.5, 0.5, cursorColor );
+                    DrawCubeWires( nearestHit.hitPosition, 0.5, 0.5, 0.5, YELLOW );
 
-                    groundCursorPos = hitinfo.hitPosition;
-                    groundCursorPos.y += 0.25; // Offset so the cube rests on the ground
-                    printf("Hit: groundpos %3.2f %3.2f %3.2f\n", 
-                        groundCursorPos.x, groundCursorPos.y, groundCursorPos.z );
-                    DrawCubeWires( groundCursorPos, 0.5, 0.5, 0.5, RED );
+                    Vector3 normalEnd;
+                    normalEnd.x = nearestHit.hitPosition.x + nearestHit.hitNormal.x;
+                    normalEnd.y = nearestHit.hitPosition.y + nearestHit.hitNormal.y;
+                    normalEnd.z = nearestHit.hitPosition.z + nearestHit.hitNormal.z;
+                    DrawLine3D( nearestHit.hitPosition, normalEnd, YELLOW );
                 }
-                
+
                 DrawRay(ray, MAROON);
                 
                 DrawGrid(10, 1.0f);
 
             End3dMode();
             
-            //DrawText("Try selecting the box with mouse!", 240, 10, 20, DARKGRAY);
-            
-            //if(collision) DrawText("BOX SELECTED", (screenWidth - MeasureText("BOX SELECTED", 30)) / 2, screenHeight * 0.1f, 30, GREEN);
+            // Show some debug text
+            char line[1024];
+            sprintf( line, "Hit Object: %s\n", hitObjectName );
+            DrawText( line, 10, 30, 15, BLACK );
+
+            if (nearestHit.hit) {
+                int ypos = 45;
+                sprintf( line, "Distance: %3.2f", nearestHit.distance );
+                DrawText( line, 10, ypos, 15, BLACK );
+                ypos += 15;
+
+                sprintf( line, "Hit Pos: %3.2f %3.2f %3.2f", 
+                    nearestHit.hitPosition.x, nearestHit.hitPosition.y, nearestHit.hitPosition.z );
+                DrawText( line, 10, ypos, 15, BLACK );
+                ypos += 15;
+
+                sprintf( line, "Hit Norm: %3.2f %3.2f %3.2f", 
+                    nearestHit.hitNormal.x, nearestHit.hitNormal.y, nearestHit.hitNormal.z );
+                DrawText( line, 10, ypos, 15, BLACK );
+                ypos += 15;
+
+                if (hitTriangle) {
+                    sprintf( line, "Barycentric: %3.2f %3.2f %3.2f", 
+                        bary.x, bary.y, bary.z );
+                    DrawText( line, 10, ypos, 15, BLACK );
+                }
+            }
+
+            DrawText( "Use Mouse to Move Camera", 10, 420, 15, LIGHTGRAY );
 
             DrawFPS(10, 10);
 
diff --git a/examples/resources/model/lowpoly-tower.obj b/examples/resources/model/lowpoly-tower.obj
new file mode 100644
index 00000000..ea03a9fc
--- /dev/null
+++ b/examples/resources/model/lowpoly-tower.obj
@@ -0,0 +1,456 @@
+# Blender v2.78 (sub 0) OBJ File: 'lowpoly-tower.blend'
+# www.blender.org
+o Grid
+v -4.000000 0.000000 4.000000
+v -2.327363 0.000000 4.654725
+v 0.000000 0.000000 4.654725
+v 2.327363 0.000000 4.654725
+v 4.000000 0.000000 4.000000
+v -4.654725 0.955085 2.327363
+v -2.000000 0.815050 2.000000
+v 0.000000 0.476341 2.423448
+v 2.000000 0.476341 2.000000
+v 4.654725 0.000000 2.327363
+v -4.654725 1.649076 0.000000
+v -2.423448 1.092402 0.000000
+v 2.423448 0.198579 0.000000
+v 4.654725 0.000000 0.000000
+v -4.654725 1.649076 -2.327363
+v -2.000000 1.092402 -2.000000
+v 0.000000 0.476341 -2.423448
+v 2.000000 -0.012791 -2.000000
+v 4.654725 0.000000 -2.612731
+v -4.000000 0.955085 -4.000000
+v -2.327363 0.955085 -4.654725
+v 0.000000 0.955085 -4.654725
+v 2.327363 0.000000 -4.654725
+v 4.000000 0.000000 -4.000000
+v 2.423448 0.682825 0.000000
+v 2.000000 0.565423 -2.000000
+v -4.654725 -0.020560 2.327363
+v -4.654725 0.000000 0.000000
+v -4.654725 0.000000 -2.327363
+v -4.000000 0.000000 -4.000000
+v -2.327363 0.000000 -4.654725
+v 0.000000 -0.020560 -4.654725
+v 0.000000 0.709880 -1.230535
+v -0.000000 7.395413 0.000000
+v 0.962071 0.709880 -0.767226
+v -0.533909 0.709880 1.108674
+v -1.199683 0.709880 0.273820
+v -0.962071 0.709880 -0.767226
+v 1.506076 0.859071 1.325337
+v 1.199683 0.709880 0.273820
+v 0.533909 0.709880 1.108674
+v 0.000000 1.875340 -1.177842
+v -0.000000 2.293973 -0.649884
+v -0.000000 4.365648 -0.627970
+v 0.000000 6.167194 -0.942957
+v 0.000000 6.232434 -1.708677
+v 1.335898 6.232434 -1.065343
+v 0.737233 6.167195 -0.587924
+v 0.490966 4.365648 -0.391533
+v 0.508100 2.293973 -0.405196
+v 0.920874 1.875340 -0.734372
+v -0.741367 6.232434 1.539465
+v -0.409133 6.167195 0.849574
+v -0.272466 4.365648 0.565781
+v -0.281974 2.293973 0.585526
+v -0.511047 1.875340 1.061199
+v -1.665837 6.232434 0.380217
+v -0.919314 6.167195 0.209828
+v -0.612225 4.365648 0.139736
+v -0.633590 2.293973 0.144613
+v -1.148311 1.875340 0.262095
+v -1.335898 6.232434 -1.065343
+v -0.737233 6.167195 -0.587924
+v -0.490967 4.365648 -0.391533
+v -0.508100 2.293973 -0.405196
+v -0.920874 1.875340 -0.734372
+v 1.665837 6.232434 0.380216
+v 0.919315 6.167195 0.209828
+v 0.612225 4.365648 0.139736
+v 0.633590 2.293973 0.144613
+v 1.148311 1.875340 0.262095
+v 0.741367 6.232434 1.539465
+v 0.409133 6.167195 0.849575
+v 0.272466 4.365648 0.565781
+v 0.281974 2.293973 0.585526
+v 0.511046 1.875340 1.061199
+v 0.000000 5.012550 -0.969733
+v 0.758168 5.012550 -0.604618
+v -0.420751 5.012550 0.873699
+v -0.945419 5.012550 0.215786
+v -0.758168 5.012550 -0.604618
+v 0.945419 5.012550 0.215786
+v 0.420751 5.012550 0.873699
+vt 0.0523 0.5444
+vt 0.1817 0.4284
+vt 0.1641 0.5859
+vt 0.0177 0.4451
+vt 0.1526 0.3090
+vt 0.0189 0.1737
+vt 0.0188 0.3088
+vt 0.0561 0.0762
+vt 0.1757 0.1924
+vt 0.3024 0.4534
+vt 0.3071 0.5902
+vt 0.3413 0.2459
+vt 0.2906 0.1614
+vt 0.4116 0.1801
+vt 0.2834 0.3774
+vt 0.1526 0.0362
+vt 0.2917 0.1622
+vt 0.4446 0.5865
+vt 0.4443 0.2989
+vt 0.3711 0.3021
+vt 0.4396 0.0275
+vt 0.4094 0.1829
+vt 0.4219 0.4255
+vt 0.5474 0.5381
+vt 0.5811 0.4376
+vt 0.5715 0.1505
+vt 0.5811 0.2997
+vt 0.5272 0.0533
+vt 0.2208 0.2194
+vt 0.3456 0.3610
+vt 0.2878 0.0321
+vt 0.2321 0.3392
+vt 0.4432 0.0177
+vt 0.7347 0.7934
+vt 0.7382 0.7595
+vt 0.8982 0.7768
+vt 0.6169 0.7595
+vt 0.6139 0.7879
+vt 0.4951 0.7634
+vt 0.1551 0.6832
+vt 0.2925 0.6268
+vt 0.2925 0.6832
+vt 0.7795 0.6832
+vt 0.6421 0.6268
+vt 0.7795 0.6255
+vt 0.5046 0.7241
+vt 0.6421 0.7241
+vt 0.3986 0.6268
+vt 0.3986 0.6832
+vt 0.5046 0.6268
+vt 0.0177 0.6268
+vt 0.1551 0.6255
+vt 0.8856 0.6268
+vt 0.1899 0.9579
+vt 0.1194 0.8696
+vt 0.2324 0.8696
+vt 0.1899 0.7813
+vt 0.0943 0.7595
+vt 0.0177 0.8206
+vt 0.0177 0.9186
+vt 0.0943 0.9797
+vt 0.2793 0.2349
+vt 0.2304 0.2758
+vt 0.6597 0.0177
+vt 0.6954 0.0993
+vt 0.6367 0.0768
+vt 0.7558 0.0777
+vt 0.7238 0.0440
+vt 0.8840 0.1330
+vt 0.7385 0.1141
+vt 0.9157 0.0886
+vt 0.9781 0.1232
+vt 0.9224 0.1276
+vt 0.2677 0.8141
+vt 0.3463 0.8037
+vt 0.3086 0.8339
+vt 0.6387 0.3550
+vt 0.7130 0.3801
+vt 0.6596 0.4053
+vt 0.7245 0.3245
+vt 0.6919 0.3383
+vt 0.8655 0.3566
+vt 0.7351 0.3577
+vt 0.9770 0.3365
+vt 0.9078 0.3751
+vt 0.9174 0.3282
+vt 0.2677 0.9018
+vt 0.3086 0.8821
+vt 0.6803 0.2948
+vt 0.6251 0.3035
+vt 0.7194 0.2854
+vt 0.8764 0.2832
+vt 0.9221 0.2861
+vt 0.3363 0.9565
+vt 0.3464 0.9122
+vt 0.6751 0.2482
+vt 0.6178 0.2499
+vt 0.7179 0.2431
+vt 0.9823 0.2484
+vt 0.9247 0.2452
+vt 0.3935 0.9014
+vt 0.6755 0.1996
+vt 0.6164 0.1941
+vt 0.7201 0.1992
+vt 0.8793 0.2446
+vt 0.9823 0.2060
+vt 0.9257 0.2051
+vt 0.4598 0.8580
+vt 0.4144 0.8579
+vt 0.6819 0.1498
+vt 0.6222 0.1361
+vt 0.7266 0.1555
+vt 0.8831 0.1684
+vt 0.9252 0.1659
+vt 0.4218 0.7790
+vt 0.3934 0.8145
+vt 0.3363 0.7595
+vt 0.8815 0.2060
+vt 0.8720 0.3208
+vt 0.8825 0.1012
+vt 0.9735 0.0816
+vt 0.9718 0.3817
+vt 0.9807 0.2918
+vt 0.4218 0.9370
+vt 0.9810 0.1644
+vn 0.1035 0.8806 0.4623
+vn 0.0964 0.9481 0.3030
+vn 0.0000 0.9780 0.2088
+vn 0.0659 0.9835 0.1683
+vn 0.2325 0.9320 0.2779
+vn 0.0553 0.9960 -0.0702
+vn 0.2827 0.9564 0.0728
+vn 0.1873 0.9776 -0.0961
+vn 0.2421 0.9703 0.0000
+vn 0.0921 0.9772 -0.1913
+vn -0.0277 0.9947 -0.0993
+vn 0.2308 0.9274 -0.2944
+vn 0.2771 0.9572 -0.0837
+vn 0.3724 0.9074 0.1947
+vn 0.0777 0.9770 -0.1985
+vn -0.1094 0.9539 0.2794
+vn 0.0364 0.9844 0.1721
+vn 0.1683 0.9835 0.0659
+vn 0.0674 0.9901 0.1230
+vn 0.4338 0.8823 0.1829
+vn 0.2845 0.9565 0.0649
+vn 0.0886 0.9961 0.0000
+vn 0.2000 0.9789 0.0424
+vn 0.1417 0.9830 0.1171
+vn 0.3021 0.9524 0.0412
+vn -0.0193 0.9986 -0.0493
+vn 0.0000 0.9777 0.2098
+vn 0.0005 0.9781 -0.2083
+vn 0.1879 0.9782 -0.0887
+vn 0.2249 0.0000 0.9744
+vn 0.9783 0.0000 -0.2071
+vn 0.9783 0.0000 0.2071
+vn 0.0000 0.0000 -1.0000
+vn -1.0000 0.0000 0.0000
+vn -0.3645 0.0000 -0.9312
+vn -0.9312 0.0000 -0.3645
+vn -0.9312 0.0000 0.3645
+vn 0.2615 0.7979 -0.5431
+vn 0.5877 0.7979 -0.1341
+vn 0.4713 0.7979 0.3758
+vn -0.0000 0.7979 0.6028
+vn -0.4713 0.7979 0.3758
+vn -0.5877 0.7979 -0.1341
+vn -0.2615 0.7979 -0.5431
+vn -0.1285 0.9864 -0.1025
+vn 0.0929 0.8937 0.4389
+vn -0.4335 0.0407 -0.9002
+vn -0.2867 0.7507 -0.5952
+vn -0.4339 0.0095 -0.9009
+vn -0.4338 0.0209 -0.9008
+vn -0.0408 -0.9956 -0.0848
+vn -0.9741 0.0407 -0.2223
+vn -0.6441 0.7507 -0.1470
+vn -0.9749 0.0095 -0.2225
+vn -0.9747 0.0209 -0.2225
+vn -0.0918 -0.9956 -0.0209
+vn -0.7812 0.0407 0.6230
+vn -0.5165 0.7507 0.4119
+vn -0.7818 0.0095 0.6235
+vn -0.7817 0.0209 0.6234
+vn -0.0736 -0.9956 0.0587
+vn -0.0000 0.0407 0.9992
+vn 0.0000 0.7507 0.6607
+vn 0.0000 0.0095 1.0000
+vn -0.0000 0.0209 0.9998
+vn -0.0000 -0.9956 0.0941
+vn 0.7812 0.0407 0.6230
+vn 0.5165 0.7507 0.4119
+vn 0.7818 0.0095 0.6235
+vn 0.7817 0.0209 0.6234
+vn 0.0736 -0.9956 0.0587
+vn 0.9741 0.0407 -0.2223
+vn 0.6441 0.7507 -0.1470
+vn 0.9749 0.0095 -0.2225
+vn 0.9747 0.0209 -0.2225
+vn 0.0918 -0.9956 -0.0209
+vn 0.4335 0.0407 -0.9002
+vn 0.2867 0.7507 -0.5952
+vn 0.4339 0.0095 -0.9009
+vn 0.4338 0.0209 -0.9008
+vn 0.0408 -0.9956 -0.0848
+vn 0.3918 -0.4298 -0.8135
+vn 0.8803 -0.4298 -0.2009
+vn 0.7059 -0.4298 0.5630
+vn -0.0000 -0.4298 0.9029
+vn -0.7059 -0.4298 0.5630
+vn -0.8803 -0.4298 -0.2009
+vn -0.3918 -0.4298 -0.8135
+vn 0.0210 0.9998 -0.0048
+vn 0.0482 0.9981 -0.0385
+vn -0.0166 0.9914 -0.1301
+vn -0.0090 0.9904 -0.1379
+vn 0.2820 0.9576 0.0597
+vn -0.0000 0.9846 0.1749
+vn -0.0921 0.9772 -0.1913
+vn -0.1734 0.9794 0.1036
+s off
+f 1/1/1 7/2/1 6/3/1
+f 2/4/2 8/5/2 7/2/2
+f 4/6/3 8/5/3 3/7/3
+f 5/8/4 9/9/4 4/6/4
+f 6/3/5 12/10/5 11/11/5
+f 35/12/6 25/13/6 26/14/6
+f 7/2/7 37/15/7 12/10/7
+f 10/16/8 13/17/8 9/9/8
+f 12/10/9 15/18/9 11/11/9
+f 35/12/10 17/19/10 33/20/10
+f 13/17/11 19/21/11 18/22/11
+f 16/23/12 20/24/12 15/18/12
+f 17/19/13 21/25/13 16/23/13
+f 17/19/14 23/26/14 22/27/14
+f 26/14/15 24/28/15 23/26/15
+f 1/1/16 2/4/16 7/2/16
+f 2/4/3 3/7/3 8/5/3
+f 4/6/17 9/9/17 8/5/17
+f 5/8/18 10/16/18 9/9/18
+f 6/3/19 7/2/19 12/10/19
+f 25/13/20 39/29/20 9/9/20
+f 38/30/21 12/10/21 37/15/21
+f 10/16/22 14/31/22 13/17/22
+f 12/10/23 16/23/23 15/18/23
+f 8/5/24 36/32/24 7/2/24
+f 38/30/25 17/19/25 16/23/25
+f 13/17/22 14/31/22 19/21/22
+f 16/23/26 21/25/26 20/24/26
+f 17/19/27 22/27/27 21/25/27
+f 17/19/28 26/14/28 23/26/28
+f 26/14/29 19/33/29 24/28/29
+f 26/34/30 18/35/30 19/36/30
+f 26/34/31 13/37/31 18/35/31
+f 25/38/32 9/39/32 13/37/32
+f 22/40/33 31/41/33 21/42/33
+f 6/43/34 28/44/34 27/45/34
+f 15/46/34 28/44/34 11/47/34
+f 21/42/35 30/48/35 20/49/35
+f 20/49/36 29/50/36 15/46/36
+f 22/40/33 23/51/33 32/52/33
+f 6/43/37 27/45/37 1/53/37
+f 46/54/38 34/55/38 47/56/38
+f 47/56/39 34/55/39 67/57/39
+f 67/57/40 34/55/40 72/58/40
+f 72/58/41 34/55/41 52/59/41
+f 52/59/42 34/55/42 57/60/42
+f 57/60/43 34/55/43 62/61/43
+f 62/61/44 34/55/44 46/54/44
+f 40/62/45 41/63/45 39/29/45
+f 39/29/46 8/5/46 9/9/46
+f 38/64/47 42/65/47 33/66/47
+f 65/67/48 42/65/48 66/68/48
+f 65/67/49 44/69/49 43/70/49
+f 81/71/50 45/72/50 77/73/50
+f 62/74/51 45/75/51 63/76/51
+f 37/77/52 66/78/52 38/79/52
+f 60/80/53 66/78/53 61/81/53
+f 60/80/54 64/82/54 65/83/54
+f 58/84/55 81/85/55 80/86/55
+f 57/87/56 63/76/56 58/88/56
+f 56/89/57 37/77/57 36/90/57
+f 55/91/58 61/81/58 56/89/58
+f 54/92/59 60/80/59 55/91/59
+f 79/93/60 58/84/60 80/86/60
+f 52/94/61 58/88/61 53/95/61
+f 76/96/62 36/90/62 41/97/62
+f 75/98/63 56/89/63 76/96/63
+f 75/98/64 54/92/64 55/91/64
+f 73/99/65 79/93/65 83/100/65
+f 73/101/66 52/94/66 53/95/66
+f 71/102/67 41/97/67 40/103/67
+f 70/104/68 76/96/68 71/102/68
+f 70/104/69 74/105/69 75/98/69
+f 68/106/70 83/100/70 82/107/70
+f 67/108/71 73/101/71 68/109/71
+f 51/110/72 40/103/72 35/111/72
+f 50/112/73 71/102/73 51/110/73
+f 49/113/74 70/104/74 50/112/74
+f 78/114/75 68/106/75 82/107/75
+f 47/115/76 68/109/76 48/116/76
+f 42/65/77 35/111/77 33/66/77
+f 43/70/78 51/110/78 42/65/78
+f 44/69/79 50/112/79 43/70/79
+f 45/72/80 78/114/80 77/73/80
+f 46/117/81 48/116/81 45/75/81
+f 44/69/82 78/114/82 49/113/82
+f 49/113/83 82/107/83 69/118/83
+f 82/107/84 74/105/84 69/118/84
+f 83/100/85 54/92/85 74/105/85
+f 79/93/86 59/119/86 54/92/86
+f 80/86/87 64/82/87 59/119/87
+f 64/120/88 77/73/88 44/69/88
+f 35/12/89 40/62/89 25/13/89
+f 7/2/90 36/32/90 37/15/90
+f 35/12/91 26/14/91 17/19/91
+f 25/13/92 40/62/92 39/29/92
+f 38/30/93 16/23/93 12/10/93
+f 8/5/94 41/63/94 36/32/94
+f 38/30/95 33/20/95 17/19/95
+f 26/34/31 25/38/31 13/37/31
+f 22/40/33 32/52/33 31/41/33
+f 6/43/34 11/47/34 28/44/34
+f 15/46/34 29/50/34 28/44/34
+f 21/42/35 31/41/35 30/48/35
+f 20/49/36 30/48/36 29/50/36
+f 39/29/96 41/63/96 8/5/96
+f 38/64/47 66/68/47 42/65/47
+f 65/67/48 43/70/48 42/65/48
+f 65/67/49 64/120/49 44/69/49
+f 81/71/50 63/121/50 45/72/50
+f 62/74/51 46/117/51 45/75/51
+f 37/77/52 61/81/52 66/78/52
+f 60/80/53 65/83/53 66/78/53
+f 60/80/54 59/119/54 64/82/54
+f 58/84/55 63/122/55 81/85/55
+f 57/87/56 62/74/56 63/76/56
+f 56/89/57 61/81/57 37/77/57
+f 55/91/58 60/80/58 61/81/58
+f 54/92/59 59/119/59 60/80/59
+f 79/93/60 53/123/60 58/84/60
+f 52/94/61 57/87/61 58/88/61
+f 76/96/62 56/89/62 36/90/62
+f 75/98/63 55/91/63 56/89/63
+f 75/98/64 74/105/64 54/92/64
+f 73/99/65 53/123/65 79/93/65
+f 73/101/66 72/124/66 52/94/66
+f 71/102/67 76/96/67 41/97/67
+f 70/104/68 75/98/68 76/96/68
+f 70/104/69 69/118/69 74/105/69
+f 68/106/70 73/99/70 83/100/70
+f 67/108/71 72/124/71 73/101/71
+f 51/110/72 71/102/72 40/103/72
+f 50/112/73 70/104/73 71/102/73
+f 49/113/74 69/118/74 70/104/74
+f 78/114/75 48/125/75 68/106/75
+f 47/115/76 67/108/76 68/109/76
+f 42/65/77 51/110/77 35/111/77
+f 43/70/78 50/112/78 51/110/78
+f 44/69/79 49/113/79 50/112/79
+f 45/72/80 48/125/80 78/114/80
+f 46/117/81 47/115/81 48/116/81
+f 44/69/82 77/73/82 78/114/82
+f 49/113/83 78/114/83 82/107/83
+f 82/107/84 83/100/84 74/105/84
+f 83/100/85 79/93/85 54/92/85
+f 79/93/86 80/86/86 59/119/86
+f 80/86/87 81/85/87 64/82/87
+f 64/120/88 81/71/88 77/73/88
diff --git a/examples/resources/model/lowpoly-tower.png b/examples/resources/model/lowpoly-tower.png
new file mode 100644
index 00000000..7c9239e2
Binary files /dev/null and b/examples/resources/model/lowpoly-tower.png differ
diff --git a/src/models.c b/src/models.c
index a2043913..41e527dc 100644
--- a/src/models.c
+++ b/src/models.c
@@ -1918,3 +1918,41 @@ static Material LoadMTL(const char *fileName)
 
     return material;
 }
+
+RayHitInfo RaycastMesh( Ray ray, Mesh *mesh )
+{
+    RayHitInfo result = {0};
+
+    // If mesh doesn't have vertex data on CPU, can't test it.
+    if (!mesh->vertices) {
+        return result;
+    }
+
+    // mesh->triangleCount may not be set, vertexCount is more reliable
+    int triangleCount = mesh->vertexCount / 3;
+
+    // Test against all triangles in mesh
+    for (int i=0; i < triangleCount; i++) {
+        Vector3 a, b, c;
+        Vector3 *vertdata = (Vector3*)mesh->vertices;
+        if (mesh->indices) {
+            a = vertdata[ mesh->indices[i*3+0] ];
+            b = vertdata[ mesh->indices[i*3+1] ];
+            c = vertdata[ mesh->indices[i*3+2] ];            
+        } else {            
+            a = vertdata[i*3+0];
+            b = vertdata[i*3+1];
+            c = vertdata[i*3+2];
+        }
+
+        RayHitInfo triHitInfo = RaycastTriangle( ray, a, b, c );
+        if (triHitInfo.hit) {
+            // Save the closest hit triangle
+            if ((!result.hit)||(result.distance > triHitInfo.distance)) {
+                result = triHitInfo;
+            }
+        }
+    }
+
+    return result; 
+}
diff --git a/src/raylib.h b/src/raylib.h
index f291ce85..7252ba4e 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -497,6 +497,7 @@ typedef struct Ray {
 // Information returned from a raycast
 typedef struct RayHitInfo {
     bool hit;             // Did the ray hit something?
+    float distance;       // Distance to nearest hit
     Vector3 hitPosition;  // Position of nearest hit
     Vector3 hitNormal;    // Surface normal of hit
 } RayHitInfo;
@@ -924,6 +925,8 @@ RLAPI bool CheckCollisionRayBox(Ray ray, BoundingBox box);
 // Ray Casts
 //------------------------------------------------------------------------------------
 RLAPI RayHitInfo RaycastGroundPlane( Ray ray, float groundHeight );
+RLAPI RayHitInfo RaycastTriangle( Ray ray, Vector3 a, Vector3 b, Vector3 c );
+RLAPI RayHitInfo RaycastMesh( Ray ray, Mesh *mesh );
 
 //------------------------------------------------------------------------------------
 // Shaders System Functions (Module: rlgl)
diff --git a/src/raymath.h b/src/raymath.h
index 3cd1394e..5871e350 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -130,6 +130,7 @@ RMDEF void VectorTransform(Vector3 *v, Matrix mat);           // Transforms a Ve
 RMDEF Vector3 VectorZero(void);                               // Return a Vector3 init to zero
 RMDEF Vector3 VectorMin(Vector3 vec1, Vector3 vec2);          // Return min value for each pair of components
 RMDEF Vector3 VectorMax(Vector3 vec1, Vector3 vec2);          // Return max value for each pair of components
+RMDEF Vector3 Barycentric(Vector3 p, Vector3 a, Vector3 b, Vector3 c); // Barycentric coords for p in triangle abc
 
 //------------------------------------------------------------------------------------
 // Functions Declaration to work with Matrix
@@ -382,6 +383,31 @@ RMDEF Vector3 VectorMax(Vector3 vec1, Vector3 vec2)
     return result;
 }
 
+// Compute barycentric coordinates (u, v, w) for
+// point p with respect to triangle (a, b, c)
+// Assumes P is on the plane of the triangle
+RMDEF Vector3 Barycentric(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
+{
+
+    //Vector v0 = b - a, v1 = c - a, v2 = p - a;
+    Vector3 v0 = VectorSubtract( b, a );
+    Vector3 v1 = VectorSubtract( c, a );
+    Vector3 v2 = VectorSubtract( p, a );
+    float d00 = VectorDotProduct(v0, v0);
+    float d01 = VectorDotProduct(v0, v1);
+    float d11 = VectorDotProduct(v1, v1);
+    float d20 = VectorDotProduct(v2, v0);
+    float d21 = VectorDotProduct(v2, v1);
+    float denom = d00 * d11 - d01 * d01;
+    
+    Vector3 result;
+    result.y = (d11 * d20 - d01 * d21) / denom;
+    result.z = (d00 * d21 - d01 * d20) / denom;
+    result.x = 1.0f - (result.z + result.y);
+    
+    return result;
+}
+
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Matrix math
 //----------------------------------------------------------------------------------
diff --git a/src/shapes.c b/src/shapes.c
index 4b2de4f2..74480c83 100644
--- a/src/shapes.c
+++ b/src/shapes.c
@@ -544,13 +544,74 @@ RayHitInfo RaycastGroundPlane( Ray ray, float groundHeight )
     {
         float t = (ray.position.y - groundHeight) / -ray.direction.y;
         if (t >= 0.0) {
-        Vector3 camDir = ray.direction;
-        VectorScale( &camDir, t );
-        result.hit = true;
-        result.hitNormal = (Vector3){ 0.0, 1.0, 0.0};
-        result.hitPosition = VectorAdd( ray.position, camDir );
+            Vector3 rayDir = ray.direction;
+            VectorScale( &rayDir, t );
+            result.hit = true;
+            result.distance = t;
+            result.hitNormal = (Vector3){ 0.0, 1.0, 0.0};
+            result.hitPosition = VectorAdd( ray.position, rayDir );
         }
     }
+    return result;
+}
+// Adapted from: 
+// https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
+RayHitInfo RaycastTriangle( Ray ray, Vector3 a, Vector3 b, Vector3 c )
+{
+    Vector3 e1, e2;  //Edge1, Edge2
+    Vector3 p, q, tv;
+    float det, inv_det, u, v;
+    float t;
+    RayHitInfo result = {0};
+    
+    //Find vectors for two edges sharing V1
+    e1 = VectorSubtract( b, a);
+    e2 = VectorSubtract( c, a);
+    
+    //Begin calculating determinant - also used to calculate u parameter
+    p = VectorCrossProduct( ray.direction, e2);
+    
+    //if determinant is near zero, ray lies in plane of triangle or ray is parallel to plane of triangle
+    det = VectorDotProduct(e1, p);
+    
+    //NOT CULLING
+    if(det > -EPSILON && det < EPSILON) return result;
+    inv_det = 1.f / det;
+    
+    //calculate distance from V1 to ray origin
+    tv = VectorSubtract( ray.position, a );
+    
+    //Calculate u parameter and test bound
+    u = VectorDotProduct(tv, p) * inv_det;
+    
+    //The intersection lies outside of the triangle
+    if(u < 0.f || u > 1.f) return result;
+    
+    //Prepare to test v parameter
+    q = VectorCrossProduct( tv, e1 );
+    
+    //Calculate V parameter and test bound
+    v = VectorDotProduct( ray.direction, q) * inv_det;
+    
+    //The intersection lies outside of the triangle
+    if(v < 0.f || (u + v)  > 1.f) return result;
+    
+    t = VectorDotProduct(e2, q) * inv_det;
+    
+    
+    if(t > EPSILON) { 
+        // ray hit, get hit point and normal
+        result.hit = true;
+        result.distance = t;
 
+        result.hit = true;
+        result.hitNormal = VectorCrossProduct( e1, e2 );
+        VectorNormalize( &result.hitNormal );
+        Vector3 rayDir = ray.direction;
+        VectorScale( &rayDir, t );        
+        result.hitPosition = VectorAdd( ray.position, rayDir );
+    }
+    
     return result;
-}
\ No newline at end of file
+}
+
-- 
cgit v1.2.3


From 658c2806690ace34a0dae6b6ed12d0ea52d2d6e4 Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Thu, 5 Jan 2017 19:33:05 +0100
Subject: Lattest PR review

Function names, code formatting...
---
 examples/Makefile             |  11 ++-
 examples/core_3d_raypick.c    | 195 -----------------------------------------
 examples/models_ray_picking.c | 197 ++++++++++++++++++++++++++++++++++++++++++
 src/models.c                  | 167 +++++++++++++++++++++++++++--------
 src/raylib.h                  |  21 ++---
 src/raymath.h                 |  25 +++---
 src/shapes.c                  |  81 -----------------
 7 files changed, 351 insertions(+), 346 deletions(-)
 delete mode 100644 examples/core_3d_raypick.c
 create mode 100644 examples/models_ray_picking.c

(limited to 'src/raymath.h')

diff --git a/examples/Makefile b/examples/Makefile
index 676529c7..80437590 100644
--- a/examples/Makefile
+++ b/examples/Makefile
@@ -203,7 +203,6 @@ EXAMPLES = \
     core_gestures_detection \
     core_3d_mode \
     core_3d_picking \
-    core_3d_raypick \
     core_3d_camera_free \
     core_3d_camera_first_person \
     core_2d_camera \
@@ -237,6 +236,7 @@ EXAMPLES = \
     models_obj_loading \
     models_heightmap \
     models_cubicmap \
+    models_ray_picking \
     shaders_model_shader \
     shaders_shapes_textures \
     shaders_custom_uniform \
@@ -321,11 +321,6 @@ core_3d_mode: core_3d_mode.c
 core_3d_picking: core_3d_picking.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
-# compile [core] example - 3d ray picking
-core_3d_raypick: core_3d_raypick.c
-	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
-
-
 # compile [core] example - 3d camera free
 core_3d_camera_free: core_3d_camera_free.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
@@ -462,6 +457,10 @@ models_heightmap: models_heightmap.c
 models_cubicmap: models_cubicmap.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
+# compile [models] example - model ray picking
+models_ray_picking: models_ray_picking.c
+	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
+
 # compile [shaders] example - model shader
 shaders_model_shader: shaders_model_shader.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
diff --git a/examples/core_3d_raypick.c b/examples/core_3d_raypick.c
deleted file mode 100644
index cf56b277..00000000
--- a/examples/core_3d_raypick.c
+++ /dev/null
@@ -1,195 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib [core] example - Ray-Picking in 3d mode, ground plane, triangle, mesh
-*
-*   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)
-*   Example contributed by Joel Davis (@joeld42)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-#include "raymath.h"
-
-#include <stdio.h>
-#include <float.h>
-
-
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
-
-    InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d ray picking");
-
-    // Define the camera to look into our 3d world
-    Camera camera;
-    camera.position = (Vector3){ 10.0f, 8.0f, 10.0f }; // Camera position
-    camera.target = (Vector3){ 0.0f, 2.3f, 0.0f };      // Camera looking at point
-    camera.up = (Vector3){ 0.0f, 1.6f, 0.0f };          // Camera up vector (rotation towards target)
-    camera.fovy = 45.0f;                                // Camera field-of-view Y
-
-    Vector3 cubePosition = { 0.0f, 1.0f, 0.0f };
-    Vector3 cubeSize = { 2.0f, 2.0f, 2.0f };
-    
-    Ray ray;        // Picking line ray
-    
-    Model tower = LoadModel("resources/model/lowpoly-tower.obj");           // Load OBJ model
-    Texture2D texture = LoadTexture("resources/model/lowpoly-tower.png");   // Load model texture
-    tower.material.texDiffuse = texture;                                    // Set model diffuse texture
-    Vector3 towerPos = { 0.0f, 0.0f, 0.0f };                                // Set model position
-    BoundingBox towerBBox = CalculateBoundingBox( tower.mesh );    
-    bool hitMeshBBox;
-    bool hitTriangle;
-
-    // Test triangle
-    Vector3 ta = (Vector3){ -25.0, 0.5, 0.0 };    
-    Vector3 tb = (Vector3){ -4.0, 2.5, 1.0 };
-    Vector3 tc = (Vector3){ -8.0, 6.5, 0.0 };
-
-    Vector3 bary = {0};
-
-    SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
-
-    SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
-
-    //--------------------------------------------------------------------------------------
-    // Main game loop
-    while (!WindowShouldClose())        // Detect window close button or ESC key
-    {
-        // Update
-        //----------------------------------------------------------------------------------
-        UpdateCamera(&camera);          // Update camera
-        
-
-        // Display information about closest hit
-        RayHitInfo nearestHit;
-        char *hitObjectName = "None";
-        nearestHit.distance = FLT_MAX;
-        nearestHit.hit = false;
-        Color cursorColor = WHITE;
-
-        // Get ray and test against ground, triangle, and mesh
-        ray = GetMouseRay(GetMousePosition(), camera);
-        
-        RayHitInfo groundHitInfo = RaycastGroundPlane( ray, 0.0 );
-        if ((groundHitInfo.hit) && (groundHitInfo.distance < nearestHit.distance)) {
-            nearestHit = groundHitInfo;
-            cursorColor = GREEN;
-            hitObjectName = "Ground";
-        }
-
-        RayHitInfo triHitInfo = RaycastTriangle( ray, ta, tb, tc );
-        if ((triHitInfo.hit) && (triHitInfo.distance < nearestHit.distance)) {
-            nearestHit = triHitInfo;
-            cursorColor = PURPLE;
-            hitObjectName = "Triangle";
-
-            bary = Barycentric( nearestHit.hitPosition, ta, tb, tc );
-            hitTriangle = true;
-        } else {
-            hitTriangle = false;
-        }
-
-        RayHitInfo meshHitInfo;
-
-        // check the bounding box first, before trying the full ray/mesh test
-        if (CheckCollisionRayBox( ray, towerBBox )) {
-            hitMeshBBox = true;
-            meshHitInfo = RaycastMesh( ray, &tower.mesh );    
-            if ((meshHitInfo.hit) && (meshHitInfo.distance < nearestHit.distance)) {
-                nearestHit = meshHitInfo;
-                cursorColor = ORANGE;
-                hitObjectName = "Mesh";
-            }
-        } else {
-            hitMeshBBox = false;
-        }    
-
-        //----------------------------------------------------------------------------------
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
-
-            ClearBackground(RAYWHITE);
-
-            Begin3dMode(camera);
-
-                // Draw the tower
-                DrawModel( tower, towerPos, 1.0, WHITE );
-                
-                // Draw the test triangle
-                DrawLine3D( ta, tb, PURPLE );
-                DrawLine3D( tb, tc, PURPLE );
-                DrawLine3D( tc, ta, PURPLE );
-
-                // Draw the mesh bbox if we hit it
-                if (hitMeshBBox) {
-                    DrawBoundingBox( towerBBox, LIME );
-                }
-
-                // If we hit something, draw the cursor at the hit point
-                if (nearestHit.hit) {
-                    DrawCube( nearestHit.hitPosition, 0.5, 0.5, 0.5, cursorColor );
-                    DrawCubeWires( nearestHit.hitPosition, 0.5, 0.5, 0.5, YELLOW );
-
-                    Vector3 normalEnd;
-                    normalEnd.x = nearestHit.hitPosition.x + nearestHit.hitNormal.x;
-                    normalEnd.y = nearestHit.hitPosition.y + nearestHit.hitNormal.y;
-                    normalEnd.z = nearestHit.hitPosition.z + nearestHit.hitNormal.z;
-                    DrawLine3D( nearestHit.hitPosition, normalEnd, YELLOW );
-                }
-
-                DrawRay(ray, MAROON);
-                
-                DrawGrid(10, 1.0f);
-
-            End3dMode();
-            
-            // Show some debug text
-            char line[1024];
-            sprintf( line, "Hit Object: %s\n", hitObjectName );
-            DrawText( line, 10, 30, 15, BLACK );
-
-            if (nearestHit.hit) {
-                int ypos = 45;
-                sprintf( line, "Distance: %3.2f", nearestHit.distance );
-                DrawText( line, 10, ypos, 15, BLACK );
-                ypos += 15;
-
-                sprintf( line, "Hit Pos: %3.2f %3.2f %3.2f", 
-                    nearestHit.hitPosition.x, nearestHit.hitPosition.y, nearestHit.hitPosition.z );
-                DrawText( line, 10, ypos, 15, BLACK );
-                ypos += 15;
-
-                sprintf( line, "Hit Norm: %3.2f %3.2f %3.2f", 
-                    nearestHit.hitNormal.x, nearestHit.hitNormal.y, nearestHit.hitNormal.z );
-                DrawText( line, 10, ypos, 15, BLACK );
-                ypos += 15;
-
-                if (hitTriangle) {
-                    sprintf( line, "Barycentric: %3.2f %3.2f %3.2f", 
-                        bary.x, bary.y, bary.z );
-                    DrawText( line, 10, ypos, 15, BLACK );
-                }
-            }
-
-            DrawText( "Use Mouse to Move Camera", 10, 420, 15, LIGHTGRAY );
-
-            DrawFPS(10, 10);
-
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
-}
\ No newline at end of file
diff --git a/examples/models_ray_picking.c b/examples/models_ray_picking.c
new file mode 100644
index 00000000..c578a185
--- /dev/null
+++ b/examples/models_ray_picking.c
@@ -0,0 +1,197 @@
+/*******************************************************************************************
+*
+*   raylib [models] example - Ray picking in 3d mode, ground plane, triangle, mesh
+*
+*   This example has been created using raylib 1.7 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*   Example contributed by Joel Davis (@joeld42)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+#include "../src/raymath.h"
+
+#include <stdio.h>
+#include <float.h>
+
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [models] example - 3d ray picking");
+
+    // Define the camera to look into our 3d world
+    Camera camera;
+    camera.position = (Vector3){ 10.0f, 8.0f, 10.0f }; // Camera position
+    camera.target = (Vector3){ 0.0f, 2.3f, 0.0f };      // Camera looking at point
+    camera.up = (Vector3){ 0.0f, 1.6f, 0.0f };          // Camera up vector (rotation towards target)
+    camera.fovy = 45.0f;                                // Camera field-of-view Y
+
+    Vector3 cubePosition = { 0.0f, 1.0f, 0.0f };
+    Vector3 cubeSize = { 2.0f, 2.0f, 2.0f };
+    
+    Ray ray;        // Picking line ray
+    
+    Model tower = LoadModel("resources/model/lowpoly-tower.obj");           // Load OBJ model
+    Texture2D texture = LoadTexture("resources/model/lowpoly-tower.png");   // Load model texture
+    tower.material.texDiffuse = texture;                                    // Set model diffuse texture
+    
+    Vector3 towerPos = { 0.0f, 0.0f, 0.0f };                                // Set model position
+    BoundingBox towerBBox = CalculateBoundingBox( tower.mesh );    
+    bool hitMeshBBox = false;
+    bool hitTriangle = false;
+
+    // Test triangle
+    Vector3 ta = (Vector3){ -25.0, 0.5, 0.0 };    
+    Vector3 tb = (Vector3){ -4.0, 2.5, 1.0 };
+    Vector3 tc = (Vector3){ -8.0, 6.5, 0.0 };
+
+    Vector3 bary = { 0.0f, 0.0f, 0.0f }; 
+
+    SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
+
+    SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+    // Main game loop
+    while (!WindowShouldClose())        // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateCamera(&camera);          // Update camera
+        
+        // Display information about closest hit
+        RayHitInfo nearestHit;
+        char *hitObjectName = "None";
+        nearestHit.distance = FLT_MAX;
+        nearestHit.hit = false;
+        Color cursorColor = WHITE;
+
+        // Get ray and test against ground, triangle, and mesh
+        ray = GetMouseRay(GetMousePosition(), camera);
+        
+        // Check ray collision aginst ground plane
+        RayHitInfo groundHitInfo = GetCollisionRayGround(ray, 0.0f);
+        
+        if ((groundHitInfo.hit) && (groundHitInfo.distance < nearestHit.distance))
+        {
+            nearestHit = groundHitInfo;
+            cursorColor = GREEN;
+            hitObjectName = "Ground";
+        }
+
+        // Check ray collision against test triangle
+        RayHitInfo triHitInfo = GetCollisionRayTriangle(ray, ta, tb, tc);
+        
+        if ((triHitInfo.hit) && (triHitInfo.distance < nearestHit.distance)) 
+        {
+            nearestHit = triHitInfo;
+            cursorColor = PURPLE;
+            hitObjectName = "Triangle";
+
+            bary = Barycenter(nearestHit.hitPosition, ta, tb, tc);
+            hitTriangle = true;
+        } 
+        else hitTriangle = false;
+
+        RayHitInfo meshHitInfo;
+
+        // Check ray collision against bounding box first, before trying the full ray-mesh test
+        if (CheckCollisionRayBox(ray, towerBBox)) 
+        {
+            hitMeshBBox = true;
+            
+            // Check ray collision against mesh
+            meshHitInfo = GetCollisionRayMesh(ray, &tower.mesh);    
+            
+            if ((meshHitInfo.hit) && (meshHitInfo.distance < nearestHit.distance)) 
+            {
+                nearestHit = meshHitInfo;
+                cursorColor = ORANGE;
+                hitObjectName = "Mesh";
+            }
+            
+        } hitMeshBBox = false; 
+        //----------------------------------------------------------------------------------
+        
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            Begin3dMode(camera);
+
+                // Draw the tower
+                DrawModel(tower, towerPos, 1.0, WHITE);
+                
+                // Draw the test triangle
+                DrawLine3D(ta, tb, PURPLE);
+                DrawLine3D(tb, tc, PURPLE);
+                DrawLine3D(tc, ta, PURPLE);
+
+                // Draw the mesh bbox if we hit it
+                if (hitMeshBBox) DrawBoundingBox(towerBBox, LIME);
+
+                // If we hit something, draw the cursor at the hit point
+                if (nearestHit.hit) 
+                {
+                    DrawCube(nearestHit.hitPosition, 0.5, 0.5, 0.5, cursorColor);
+                    DrawCubeWires(nearestHit.hitPosition, 0.5, 0.5, 0.5, YELLOW);
+
+                    Vector3 normalEnd;
+                    normalEnd.x = nearestHit.hitPosition.x + nearestHit.hitNormal.x;
+                    normalEnd.y = nearestHit.hitPosition.y + nearestHit.hitNormal.y;
+                    normalEnd.z = nearestHit.hitPosition.z + nearestHit.hitNormal.z;
+                    
+                    DrawLine3D(nearestHit.hitPosition, normalEnd, YELLOW);
+                }
+
+                DrawRay(ray, MAROON);
+                
+                DrawGrid(100, 1.0f);
+
+            End3dMode();
+            
+            // Draw some debug GUI text
+            DrawText(FormatText("Hit Object: %s", hitObjectName), 10, 50, 10, BLACK);
+
+            if (nearestHit.hit) 
+            {
+                int ypos = 70;
+
+                DrawText(FormatText("Distance: %3.2f", nearestHit.distance), 10, ypos, 10, BLACK);
+                
+                DrawText(FormatText("Hit Pos: %3.2f %3.2f %3.2f", 
+                                    nearestHit.hitPosition.x, 
+                                    nearestHit.hitPosition.y, 
+                                    nearestHit.hitPosition.z), 10, ypos + 15, 10, BLACK);
+                                    
+                DrawText(FormatText("Hit Norm: %3.2f %3.2f %3.2f", 
+                                    nearestHit.hitNormal.x, 
+                                    nearestHit.hitNormal.y, 
+                                    nearestHit.hitNormal.z), 10, ypos + 30, 10, BLACK);
+
+                if (hitTriangle) DrawText(FormatText("Barycenter: %3.2f %3.2f %3.2f",  bary.x, bary.y, bary.z), 10, ypos + 45, 10, BLACK);
+            }
+
+            DrawText("Use Mouse to Move Camera", 10, 430, 10, GRAY);
+
+            DrawFPS(10, 10);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
\ No newline at end of file
diff --git a/src/models.c b/src/models.c
index 41e527dc..0673874b 100644
--- a/src/models.c
+++ b/src/models.c
@@ -1474,6 +1474,135 @@ bool CheckCollisionRayBox(Ray ray, BoundingBox box)
     return collision;
 }
 
+// Get collision info between ray and mesh
+RayHitInfo GetCollisionRayMesh(Ray ray, Mesh *mesh)
+{
+    RayHitInfo result = { 0 };
+
+    // If mesh doesn't have vertex data on CPU, can't test it.
+    if (!mesh->vertices) return result;
+
+    // mesh->triangleCount may not be set, vertexCount is more reliable
+    int triangleCount = mesh->vertexCount/3;
+
+    // Test against all triangles in mesh
+    for (int i = 0; i < triangleCount; i++) 
+    {
+        Vector3 a, b, c;
+        Vector3 *vertdata = (Vector3 *)mesh->vertices;
+        
+        if (mesh->indices) 
+        {
+            a = vertdata[mesh->indices[i*3 + 0]];
+            b = vertdata[mesh->indices[i*3 + 1]];
+            c = vertdata[mesh->indices[i*3 + 2]];            
+        } 
+        else 
+        {            
+            a = vertdata[i*3 + 0];
+            b = vertdata[i*3 + 1];
+            c = vertdata[i*3 + 2];
+        }
+
+        RayHitInfo triHitInfo = GetCollisionRayTriangle(ray, a, b, c);
+        
+        if (triHitInfo.hit) 
+        {
+            // Save the closest hit triangle
+            if ((!result.hit) || (result.distance > triHitInfo.distance)) result = triHitInfo;
+        }
+    }
+
+    return result; 
+}
+
+// Get collision info between ray and triangle
+// NOTE: Based on https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
+RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3)
+{
+    #define EPSILON 0.000001        // A small number
+
+    Vector3 edge1, edge2;
+    Vector3 p, q, tv;
+    float det, invDet, u, v, t;
+    RayHitInfo result = {0};
+    
+    // Find vectors for two edges sharing V1
+    edge1 = VectorSubtract(p2, p1);
+    edge2 = VectorSubtract(p3, p1);
+    
+    // Begin calculating determinant - also used to calculate u parameter
+    p = VectorCrossProduct(ray.direction, edge2);
+    
+    // If determinant is near zero, ray lies in plane of triangle or ray is parallel to plane of triangle
+    det = VectorDotProduct(edge1, p);
+    
+    // Avoid culling!
+    if ((det > -EPSILON) && (det < EPSILON)) return result;
+    
+    invDet = 1.0f/det;
+    
+    // Calculate distance from V1 to ray origin
+    tv = VectorSubtract(ray.position, p1);
+    
+    // Calculate u parameter and test bound
+    u = VectorDotProduct(tv, p)*invDet;
+    
+    // The intersection lies outside of the triangle
+    if ((u < 0.0f) || (u > 1.0f)) return result;
+    
+    // Prepare to test v parameter
+    q = VectorCrossProduct(tv, edge1);
+    
+    // Calculate V parameter and test bound
+    v = VectorDotProduct(ray.direction, q)*invDet;
+    
+    // The intersection lies outside of the triangle
+    if ((v < 0.0f) || ((u + v) > 1.0f)) return result;
+    
+    t = VectorDotProduct(edge2, q)*invDet;
+    
+    if (t > EPSILON) 
+    { 
+        // Ray hit, get hit point and normal
+        result.hit = true;
+        result.distance = t;
+        result.hit = true;
+        result.hitNormal = VectorCrossProduct(edge1, edge2);
+        VectorNormalize(&result.hitNormal);
+        Vector3 rayDir = ray.direction;
+        VectorScale(&rayDir, t);        
+        result.hitPosition = VectorAdd(ray.position, rayDir);
+    }
+    
+    return result;
+}
+
+// Get collision info between ray and ground plane (Y-normal plane)
+RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight)
+{
+    #define EPSILON 0.000001        // A small number
+
+    RayHitInfo result = { 0 };
+
+    if (fabsf(ray.direction.y) > EPSILON)
+    {
+        float t = (ray.position.y - groundHeight)/-ray.direction.y;
+        
+        if (t >= 0.0) 
+        {
+            Vector3 rayDir = ray.direction;
+            VectorScale(&rayDir, t);
+            result.hit = true;
+            result.distance = t;
+            result.hitNormal = (Vector3){ 0.0, 1.0, 0.0 };
+            result.hitPosition = VectorAdd(ray.position, rayDir);
+        }
+    }
+    
+    return result;
+}
+
 // Calculate mesh bounding box limits
 // NOTE: minVertex and maxVertex should be transformed by model transform matrix (position, scale, rotate)
 BoundingBox CalculateBoundingBox(Mesh mesh)
@@ -1918,41 +2047,3 @@ static Material LoadMTL(const char *fileName)
 
     return material;
 }
-
-RayHitInfo RaycastMesh( Ray ray, Mesh *mesh )
-{
-    RayHitInfo result = {0};
-
-    // If mesh doesn't have vertex data on CPU, can't test it.
-    if (!mesh->vertices) {
-        return result;
-    }
-
-    // mesh->triangleCount may not be set, vertexCount is more reliable
-    int triangleCount = mesh->vertexCount / 3;
-
-    // Test against all triangles in mesh
-    for (int i=0; i < triangleCount; i++) {
-        Vector3 a, b, c;
-        Vector3 *vertdata = (Vector3*)mesh->vertices;
-        if (mesh->indices) {
-            a = vertdata[ mesh->indices[i*3+0] ];
-            b = vertdata[ mesh->indices[i*3+1] ];
-            c = vertdata[ mesh->indices[i*3+2] ];            
-        } else {            
-            a = vertdata[i*3+0];
-            b = vertdata[i*3+1];
-            c = vertdata[i*3+2];
-        }
-
-        RayHitInfo triHitInfo = RaycastTriangle( ray, a, b, c );
-        if (triHitInfo.hit) {
-            // Save the closest hit triangle
-            if ((!result.hit)||(result.distance > triHitInfo.distance)) {
-                result = triHitInfo;
-            }
-        }
-    }
-
-    return result; 
-}
diff --git a/src/raylib.h b/src/raylib.h
index 7252ba4e..fa4f44e6 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -97,9 +97,6 @@
 #define DEG2RAD (PI/180.0f)
 #define RAD2DEG (180.0f/PI)
 
-// A small number
-#define EPSILON 0.000001
-
 // raylib Config Flags
 #define FLAG_FULLSCREEN_MODE    1
 #define FLAG_RESIZABLE_WINDOW   2
@@ -496,10 +493,10 @@ typedef struct Ray {
 
 // Information returned from a raycast
 typedef struct RayHitInfo {
-    bool hit;             // Did the ray hit something?
-    float distance;       // Distance to nearest hit
-    Vector3 hitPosition;  // Position of nearest hit
-    Vector3 hitNormal;    // Surface normal of hit
+    bool hit;               // Did the ray hit something?
+    float distance;         // Distance to nearest hit
+    Vector3 hitPosition;    // Position of nearest hit
+    Vector3 hitNormal;      // Surface normal of hit
 } RayHitInfo;
 
 // Wave type, defines audio wave data
@@ -920,13 +917,9 @@ RLAPI bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphere
 RLAPI bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadius, 
                                      Vector3 *collisionPoint);                                          // Detect collision between ray and sphere, returns collision point
 RLAPI bool CheckCollisionRayBox(Ray ray, BoundingBox box);                                              // Detect collision between ray and box
-
-//------------------------------------------------------------------------------------
-// Ray Casts
-//------------------------------------------------------------------------------------
-RLAPI RayHitInfo RaycastGroundPlane( Ray ray, float groundHeight );
-RLAPI RayHitInfo RaycastTriangle( Ray ray, Vector3 a, Vector3 b, Vector3 c );
-RLAPI RayHitInfo RaycastMesh( Ray ray, Mesh *mesh );
+RLAPI RayHitInfo GetCollisionRayMesh(Ray ray, Mesh *mesh);                                              // Get collision info between ray and mesh
+RLAPI RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);                  // Get collision info between ray and triangle
+RLAPI RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight);                                    // Get collision info between ray and ground plane (Y-normal plane)
 
 //------------------------------------------------------------------------------------
 // Shaders System Functions (Module: rlgl)
diff --git a/src/raymath.h b/src/raymath.h
index 5871e350..c073b72d 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -130,7 +130,7 @@ RMDEF void VectorTransform(Vector3 *v, Matrix mat);           // Transforms a Ve
 RMDEF Vector3 VectorZero(void);                               // Return a Vector3 init to zero
 RMDEF Vector3 VectorMin(Vector3 vec1, Vector3 vec2);          // Return min value for each pair of components
 RMDEF Vector3 VectorMax(Vector3 vec1, Vector3 vec2);          // Return max value for each pair of components
-RMDEF Vector3 Barycentric(Vector3 p, Vector3 a, Vector3 b, Vector3 c); // Barycentric coords for p in triangle abc
+RMDEF Vector3 Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c); // Barycenter coords for p in triangle abc
 
 //------------------------------------------------------------------------------------
 // Functions Declaration to work with Matrix
@@ -383,26 +383,27 @@ RMDEF Vector3 VectorMax(Vector3 vec1, Vector3 vec2)
     return result;
 }
 
-// Compute barycentric coordinates (u, v, w) for
-// point p with respect to triangle (a, b, c)
-// Assumes P is on the plane of the triangle
-RMDEF Vector3 Barycentric(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
+// Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c)
+// NOTE: Assumes P is on the plane of the triangle
+RMDEF Vector3 Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
 {
-
     //Vector v0 = b - a, v1 = c - a, v2 = p - a;
-    Vector3 v0 = VectorSubtract( b, a );
-    Vector3 v1 = VectorSubtract( c, a );
-    Vector3 v2 = VectorSubtract( p, a );
+    
+    Vector3 v0 = VectorSubtract(b, a);
+    Vector3 v1 = VectorSubtract(c, a);
+    Vector3 v2 = VectorSubtract(p, a);
     float d00 = VectorDotProduct(v0, v0);
     float d01 = VectorDotProduct(v0, v1);
     float d11 = VectorDotProduct(v1, v1);
     float d20 = VectorDotProduct(v2, v0);
     float d21 = VectorDotProduct(v2, v1);
-    float denom = d00 * d11 - d01 * d01;
+    
+    float denom = d00*d11 - d01*d01;
     
     Vector3 result;
-    result.y = (d11 * d20 - d01 * d21) / denom;
-    result.z = (d00 * d21 - d01 * d20) / denom;
+    
+    result.y = (d11*d20 - d01*d21)/denom;
+    result.z = (d00*d21 - d01*d20)/denom;
     result.x = 1.0f - (result.z + result.y);
     
     return result;
diff --git a/src/shapes.c b/src/shapes.c
index 74480c83..8c6c4be0 100644
--- a/src/shapes.c
+++ b/src/shapes.c
@@ -534,84 +534,3 @@ Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2)
 
     return retRec;
 }
-
-
-RayHitInfo RaycastGroundPlane( Ray ray, float groundHeight )
-{
-    RayHitInfo result = {0};
-
-    if (fabs(ray.direction.y) > EPSILON)
-    {
-        float t = (ray.position.y - groundHeight) / -ray.direction.y;
-        if (t >= 0.0) {
-            Vector3 rayDir = ray.direction;
-            VectorScale( &rayDir, t );
-            result.hit = true;
-            result.distance = t;
-            result.hitNormal = (Vector3){ 0.0, 1.0, 0.0};
-            result.hitPosition = VectorAdd( ray.position, rayDir );
-        }
-    }
-    return result;
-}
-// Adapted from: 
-// https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
-RayHitInfo RaycastTriangle( Ray ray, Vector3 a, Vector3 b, Vector3 c )
-{
-    Vector3 e1, e2;  //Edge1, Edge2
-    Vector3 p, q, tv;
-    float det, inv_det, u, v;
-    float t;
-    RayHitInfo result = {0};
-    
-    //Find vectors for two edges sharing V1
-    e1 = VectorSubtract( b, a);
-    e2 = VectorSubtract( c, a);
-    
-    //Begin calculating determinant - also used to calculate u parameter
-    p = VectorCrossProduct( ray.direction, e2);
-    
-    //if determinant is near zero, ray lies in plane of triangle or ray is parallel to plane of triangle
-    det = VectorDotProduct(e1, p);
-    
-    //NOT CULLING
-    if(det > -EPSILON && det < EPSILON) return result;
-    inv_det = 1.f / det;
-    
-    //calculate distance from V1 to ray origin
-    tv = VectorSubtract( ray.position, a );
-    
-    //Calculate u parameter and test bound
-    u = VectorDotProduct(tv, p) * inv_det;
-    
-    //The intersection lies outside of the triangle
-    if(u < 0.f || u > 1.f) return result;
-    
-    //Prepare to test v parameter
-    q = VectorCrossProduct( tv, e1 );
-    
-    //Calculate V parameter and test bound
-    v = VectorDotProduct( ray.direction, q) * inv_det;
-    
-    //The intersection lies outside of the triangle
-    if(v < 0.f || (u + v)  > 1.f) return result;
-    
-    t = VectorDotProduct(e2, q) * inv_det;
-    
-    
-    if(t > EPSILON) { 
-        // ray hit, get hit point and normal
-        result.hit = true;
-        result.distance = t;
-
-        result.hit = true;
-        result.hitNormal = VectorCrossProduct( e1, e2 );
-        VectorNormalize( &result.hitNormal );
-        Vector3 rayDir = ray.direction;
-        VectorScale( &rayDir, t );        
-        result.hitPosition = VectorAdd( ray.position, rayDir );
-    }
-    
-    return result;
-}
-
-- 
cgit v1.2.3


From 05cff44d0a9af5bcb41ddd0baa6b7693f6ac116b Mon Sep 17 00:00:00 2001
From: Ray <raysan5@gmail.com>
Date: Thu, 16 Feb 2017 00:50:02 +0100
Subject: Improved modules description -IN PROGRESS-

Working in modules configuration flags...
---
 src/audio.c    | 56 +++++++++++++++++++++++++++++++++++++-------------------
 src/audio.h    |  4 +++-
 src/camera.h   | 14 +++++++++++---
 src/core.c     | 55 +++++++++++++++++++++++++++++++++++++------------------
 src/gestures.h | 17 +++++++++++++----
 src/models.c   | 13 +++++++------
 src/physac.h   | 15 +++++++++------
 src/raylib.h   | 44 +++++++++++++++++++++++++++-----------------
 src/raymath.h  | 25 +++++++++++++------------
 src/rlgl.c     | 46 ++++++++++++++++++++++++++++++++++++----------
 src/rres.h     | 18 +++++++++++-------
 src/shapes.c   | 11 ++++-------
 src/text.c     | 36 +++++++++++++++++++++---------------
 src/textures.c | 35 +++++++++++++++++++++++++++--------
 src/utils.c    | 19 +++++++++++++------
 15 files changed, 269 insertions(+), 139 deletions(-)

(limited to 'src/raymath.h')

diff --git a/src/audio.c b/src/audio.c
index 58699035..690a41eb 100644
--- a/src/audio.c
+++ b/src/audio.c
@@ -3,32 +3,50 @@
 *   raylib.audio
 *
 *   This module provides basic functionality to work with audio:
-*       Manage audio device (init/close)
-*       Load and Unload audio files (WAV, OGG, FLAC, XM, MOD)
-*       Play/Stop/Pause/Resume loaded audio
-*       Manage mixing channels
-*       Manage raw audio context
+*     Manage audio device (init/close)
+*     Load and Unload audio files (WAV, OGG, FLAC, XM, MOD)
+*     Play/Stop/Pause/Resume loaded audio
+*     Manage mixing channels
+*     Manage raw audio context
 *
-*   External libs:
+*   NOTES:
+*
+*   Only up to two channels supported: MONO and STEREO (for additional channels, use AL_EXT_MCFORMATS)
+*   Only the following sample sizes supported: 8bit PCM, 16bit PCM, 32-bit float PCM (using AL_EXT_FLOAT32)
+*
+*   CONFIGURATION:
+*   
+*   #define AUDIO_STANDALONE
+*       If defined, the module can be used as standalone library (independently of raylib).
+*       Required types and functions are defined in the same module.
+*
+*   #define SUPPORT_FILEFORMAT_WAV  / SUPPORT_LOAD_WAV / ENABLE_LOAD_WAV
+*   #define SUPPORT_FILEFORMAT_OGG
+*   #define SUPPORT_FILEFORMAT_XM
+*   #define SUPPORT_FILEFORMAT_MOD
+*   #define SUPPORT_FILEFORMAT_FLAC
+*       Selected desired fileformats to be supported for loading. Some of those formats are 
+*       supported by default, to remove support, just comment unrequired #define in this module
+*
+*   #define SUPPORT_RAW_AUDIO_BUFFERS
+*
+*   DEPENDENCIES:
 *       OpenAL Soft - Audio device management (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
 *       dr_flac     - FLAC audio file loading
 *
-*   Module Configuration Flags:
-*       AUDIO_STANDALONE    - Use this module as standalone library (independently of raylib)
-*
-*   Some design decisions:
-*       Support only up to two channels: MONO and STEREO (for additional channels, AL_EXT_MCFORMATS)
-*       Support only the following sample sizes: 8bit PCM, 16bit PCM, 32-bit float PCM (using AL_EXT_FLOAT32)
+*   CONTRIBUTORS:
 *
 *   Many thanks to Joshua Reisenauer (github: @kd7tck) for the following additions:
-*       XM audio module support (jar_xm)
-*       MOD audio module support (jar_mod)
-*       Mixing channels support
-*       Raw audio context support
+*     XM audio module support (jar_xm)
+*     MOD audio module support (jar_mod)
+*     Mixing channels support
+*     Raw audio context support
+*
 *
+*   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
 *
@@ -246,11 +264,11 @@ Wave LoadWave(const char *fileName)
     else if (strcmp(GetExtension(fileName), "flac") == 0) wave = LoadFLAC(fileName);
     else if (strcmp(GetExtension(fileName),"rres") == 0)
     {
-        RRESData rres = LoadResource(fileName);
+        RRES rres = LoadResource(fileName, 0);
 
-        // NOTE: Parameters for RRES_WAVE type are: sampleCount, sampleRate, sampleSize, channels
+        // NOTE: Parameters for RRES_TYPE_WAVE are: sampleCount, sampleRate, sampleSize, channels
 
-        if (rres.type == RRES_WAVE) wave = LoadWaveEx(rres.data, rres.param1, rres.param2, rres.param3, rres.param4);
+        if (rres[0].type == RRES_TYPE_WAVE) wave = LoadWaveEx(rres[0].data, rres[0].param1, rres[0].param2, rres[0].param3, rres[0].param4);
         else TraceLog(WARNING, "[%s] Resource file does not contain wave data", fileName);
 
         UnloadResource(rres);
diff --git a/src/audio.h b/src/audio.h
index 99b58e15..01ed9f72 100644
--- a/src/audio.h
+++ b/src/audio.h
@@ -9,7 +9,7 @@
 *       Manage mixing channels
 *       Manage raw audio context
 *
-*   External libs:
+*   DEPENDENCIES:
 *       OpenAL Soft - Audio device management (http://kcat.strangesoft.net/openal.html)
 *       stb_vorbis  - OGG audio files loading (http://www.nothings.org/stb_vorbis/)
 *       jar_xm      - XM module file loading
@@ -23,6 +23,8 @@
 *       Raw audio context support
 *
 *
+*   LICENSE: zlib/libpng
+*
 *   Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
 *
 *   This software is provided "as-is", without any express or implied warranty. In no event
diff --git a/src/camera.h b/src/camera.h
index cf542288..87ba1942 100644
--- a/src/camera.h
+++ b/src/camera.h
@@ -2,6 +2,10 @@
 *
 *   raylib Camera System - Camera Modes Setup and Control Functions
 *
+*   NOTE: Memory footprint of this library is aproximately 52 bytes (global variables)
+*
+*   CONFIGURATION:
+*
 *   #define CAMERA_IMPLEMENTATION
 *       Generates the implementation of the library into the included file.
 *       If not defined, the library is in header only mode and can be included in other headers 
@@ -11,10 +15,14 @@
 *       If defined, the library can be used as standalone as a camera system but some
 *       functions must be redefined to manage inputs accordingly.
 *
-*   NOTE: Memory footprint of this library is aproximately 52 bytes (global variables)
+*   CONTRIBUTORS:
+*       Marc Palau:         Initial implementation (2014)
+*       Ramon Santamaria:   Supervision, review, update and maintenance
+*
+*
+*   LICENSE: zlib/libpng
 *
-*   Initial design by Marc Palau (2014)
-*   Reviewed by Ramon Santamaria (2015-2016)
+*   Copyright (c) 2015-2016 Ramon Santamaria (@raysan5)
 *
 *   This software is provided "as-is", without any express or implied warranty. In no event
 *   will the authors be held liable for any damages arising from the use of this software.
diff --git a/src/core.c b/src/core.c
index 28f73345..9d40edcc 100644
--- a/src/core.c
+++ b/src/core.c
@@ -1,27 +1,46 @@
 /**********************************************************************************************
 *
-*   raylib.core
-*
-*   Basic functions to manage windows, OpenGL context and input on multiple platforms
+*   raylib.core - Basic functions to manage windows, OpenGL context and input on multiple platforms
 *
 *   The following platforms are supported: Windows, Linux, Mac (OSX), Android, Raspberry Pi, HTML5, Oculus Rift CV1
 *
-*   External libs:
+*   CONFIGURATION:
+*
+*   #define PLATFORM_DESKTOP
+*       Windowing and input system configured for desktop platforms: Windows, Linux, OSX (managed by GLFW3 library)
+*       NOTE: Oculus Rift CV1 requires PLATFORM_DESKTOP for mirror rendering - View [rlgl] module to enable it
+*
+*   #define PLATFORM_ANDROID
+*       Windowing and input system configured for Android device, app activity managed internally in this module.
+*       NOTE: OpenGL ES 2.0 is required and graphic device is managed by EGL
+*
+*   #define PLATFORM_RPI
+*       Windowing and input system configured for Raspberry Pi (tested on Raspbian), graphic device is managed by EGL 
+*       and inputs are processed is raw mode, reading from /dev/input/
+*
+*   #define PLATFORM_WEB
+*       Windowing and input system configured for HTML5 (run on browser), code converted from C to asm.js
+*       using emscripten compiler. OpenGL ES 2.0 required for direct translation to WebGL equivalent code.
+*
+*   #define LOAD_DEFAULT_FONT (defined by default)
+*       Default font is loaded on window initialization to be available for the user to render simple text.
+*       NOTE: If enabled, uses external module functions to load default raylib font (module: text)
+*
+*   #define INCLUDE_CAMERA_SYSTEM / SUPPORT_CAMERA_SYSTEM
+*
+*   #define INCLUDE_GESTURES_SYSTEM / SUPPORT_GESTURES_SYSTEM
+*
+*   #define SUPPORT_MOUSE_GESTURES
+*       Mouse gestures are directly mapped like touches and processed by gestures system.
+*
+*   DEPENDENCIES:
 *       GLFW3    - Manage graphic device, OpenGL context and inputs on PLATFORM_DESKTOP (Windows, Linux, OSX)
 *       raymath  - 3D math functionality (Vector3, Matrix, Quaternion)
 *       camera   - Multiple 3D camera modes (free, orbital, 1st person, 3rd person)
 *       gestures - Gestures system for touch-ready devices (or simulated from mouse inputs)
 *
-*   Module Configuration Flags:
-*       PLATFORM_DESKTOP     - Windows, Linux, Mac (OSX)
-*       PLATFORM_ANDROID     - Android (only OpenGL ES 2.0 devices), graphic device is managed by EGL and input system by Android activity.
-*       PLATFORM_RPI         - Rapsberry Pi (tested on Raspbian), graphic device is managed by EGL and input system is coded in raw mode.
-*       PLATFORM_WEB         - HTML5 (using emscripten compiler)
-*
-*       RL_LOAD_DEFAULT_FONT - Use external module functions to load default raylib font (module: text)
-*
-*   NOTE: Oculus Rift CV1 requires PLATFORM_DESKTOP for render mirror - View [rlgl] module to enable it
 *
+*   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
 *
@@ -140,7 +159,7 @@
 #define MAX_GAMEPAD_BUTTONS       32        // Max bumber of buttons supported (per gamepad)
 #define MAX_GAMEPAD_AXIS          8         // Max number of axis supported (per gamepad)
 
-#define RL_LOAD_DEFAULT_FONT        // Load default font on window initialization (module: text)
+#define LOAD_DEFAULT_FONT        // Load default font on window initialization (module: text)
 
 //----------------------------------------------------------------------------------
 // Types and Structures Definition
@@ -256,7 +275,7 @@ static bool showLogo = false;               // Track if showing logo at init is
 //----------------------------------------------------------------------------------
 // Other Modules Functions Declaration (required by core)
 //----------------------------------------------------------------------------------
-#if defined(RL_LOAD_DEFAULT_FONT)
+#if defined(LOAD_DEFAULT_FONT)
 extern void LoadDefaultFont(void);          // [Module: text] Loads default font on InitWindow()
 extern void UnloadDefaultFont(void);        // [Module: text] Unloads default font from GPU memory
 #endif
@@ -338,7 +357,7 @@ void InitWindow(int width, int height, const char *title)
     // Init graphics device (display device and OpenGL context)
     InitGraphicsDevice(width, height);
 
-#if defined(RL_LOAD_DEFAULT_FONT)
+#if defined(LOAD_DEFAULT_FONT)
     // Load default font
     // NOTE: External function (defined in module: text)
     LoadDefaultFont();
@@ -450,7 +469,7 @@ void InitWindow(int width, int height, void *state)
 // Close Window and Terminate Context
 void CloseWindow(void)
 {
-#if defined(RL_LOAD_DEFAULT_FONT)
+#if defined(LOAD_DEFAULT_FONT)
     UnloadDefaultFont();
 #endif
 
@@ -2410,7 +2429,7 @@ static void AndroidCommandCallback(struct android_app *app, int32_t cmd)
                     // Init graphics device (display device and OpenGL context)
                     InitGraphicsDevice(screenWidth, screenHeight);
 
-                    #if defined(RL_LOAD_DEFAULT_FONT)
+                    #if defined(LOAD_DEFAULT_FONT)
                     // Load default font
                     // NOTE: External function (defined in module: text)
                     LoadDefaultFont();
diff --git a/src/gestures.h b/src/gestures.h
index f4dcb133..99f49d2a 100644
--- a/src/gestures.h
+++ b/src/gestures.h
@@ -2,6 +2,10 @@
 *
 *   raylib Gestures System - Gestures Processing based on input gesture events (touch/mouse)
 *
+*   NOTE: Memory footprint of this library is aproximately 128 bytes (global variables)
+*
+*   CONFIGURATION:
+*
 *   #define GESTURES_IMPLEMENTATION
 *       Generates the implementation of the library into the included file.
 *       If not defined, the library is in header only mode and can be included in other headers 
@@ -11,11 +15,16 @@
 *       If defined, the library can be used as standalone to process gesture events with
 *       no external dependencies.
 *
-*   NOTE: Memory footprint of this library is aproximately 128 bytes
+*   CONTRIBUTORS:
+*       Marc Palau:         Initial implementation (2014)
+*       Albert Martos:      Complete redesign and testing (2015)
+*       Ian Eito:           Complete redesign and testing (2015)
+*       Ramon Santamaria:   Supervision, review, update and maintenance
+*
+*
+*   LICENSE: zlib/libpng
 *
-*   Initial design by Marc Palau (2014)
-*   Redesigned by Albert Martos and Ian Eito (2015)
-*   Reviewed by Ramon Santamaria (2015-2016)
+*   Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
 *
 *   This software is provided "as-is", without any express or implied warranty. In no event
 *   will the authors be held liable for any damages arising from the use of this software.
diff --git a/src/models.c b/src/models.c
index 43821691..bef19e10 100644
--- a/src/models.c
+++ b/src/models.c
@@ -1,14 +1,15 @@
 /**********************************************************************************************
 *
-*   raylib.models
+*   raylib.models - Basic functions to draw 3d shapes and 3d models
 *
-*   Basic functions to draw 3d shapes and load/draw 3d models (.OBJ)
+*   CONFIGURATION:
 *
-*   External libs:
-*       rlgl     - raylib OpenGL abstraction layer
+*   #define SUPPORT_FILEFORMAT_OBJ / SUPPORT_LOAD_OBJ
 *
-*   Module Configuration Flags:
-*       ...
+*   #define SUPPORT_FILEFORMAT_MTL
+*
+*
+*   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
 *
diff --git a/src/physac.h b/src/physac.h
index d958c701..cb0e3f3c 100644
--- a/src/physac.h
+++ b/src/physac.h
@@ -1,11 +1,13 @@
 /**********************************************************************************************
 *
-*   Physac - 2D Physics library for videogames
+*   Physac v1.0 - 2D Physics library for videogames
 *
-*   Description: Physac is a small 2D physics engine written in pure C. The engine uses a fixed time-step thread loop 
-*   to simluate physics. A physics step contains the following phases: get collision information, apply dynamics, 
-*   collision solving and position correction. It uses a very simple struct for physic bodies with a position vector 
-*   to be used in any 3D rendering API.
+*   DESCRIPTION: 
+*
+*   Physac is a small 2D physics engine written in pure C. The engine uses a fixed time-step thread loop 
+*   to simluate physics. A physics step contains the following phases: get collision information, 
+*   apply dynamics, collision solving and position correction. It uses a very simple struct for physic 
+*   bodies with a position vector to be used in any 3D rendering API.
 * 
 *   CONFIGURATION:
 *   
@@ -37,7 +39,8 @@
 *       Otherwise it will include stdlib.h and use the C standard library malloc()/free() function.
 *
 *   VERY THANKS TO:
-*       - Ramón Santamaria (@raysan5)
+*       Ramón Santamaria (@raysan5)
+*
 *
 *   LICENSE: zlib/libpng
 *
diff --git a/src/raylib.h b/src/raylib.h
index 800ab2be..3ff0d28f 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -1,10 +1,10 @@
 /**********************************************************************************************
 *
-*   raylib 1.7.0 (www.raylib.com)
+*   raylib v1.7.0 (www.raylib.com)
 *
 *   A simple and easy-to-use library to learn videogames programming
 *
-*   Features:
+*   FEATURES:
 *     Library written in plain C code (C99)
 *     Uses PascalCase/camelCase notation
 *     Hardware accelerated with OpenGL (1.1, 2.1, 3.3 or ES 2.0)
@@ -20,7 +20,13 @@
 *     Minimal external dependencies (GLFW3, OpenGL, OpenAL)
 *     Complete binding for Lua [rlua]
 *
-*   External libs:
+*   NOTES:
+*     32bit Colors - All defined color are always RGBA (struct Color is 4 byte)
+*     One custom default font could be loaded automatically when InitWindow() [core]
+*     If using OpenGL 3.3 or ES2, several vertex buffers (VAO/VBO) are created to manage lines-triangles-quads
+*     If using OpenGL 3.3 or ES2, two default shaders could be loaded automatically (internally defined)
+*
+*   DEPENDENCIES:
 *     GLFW3 (www.glfw.org) for window/context management and input [core]
 *     GLAD for OpenGL extensions loading (3.3 Core profile, only PLATFORM_DESKTOP) [rlgl]
 *     stb_image (Sean Barret) for images loading (JPEG, PNG, BMP, TGA) [textures]
@@ -33,13 +39,8 @@
 *     OpenAL Soft for audio device/context management [audio]
 *     tinfl for data decompression (DEFLATE algorithm) [utils]
 *
-*   Some design decisions:
-*     32bit Colors - All defined color are always RGBA (struct Color is 4 byte)
-*     One custom default font could be loaded automatically when InitWindow() [core]
-*     If using OpenGL 3.3 or ES2, several vertex buffers (VAO/VBO) are created to manage lines-triangles-quads
-*     If using OpenGL 3.3 or ES2, two default shaders could be loaded automatically (internally defined)
 *
-*   -- LICENSE --
+*   LICENSE: zlib/libpng
 *
 *   raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
 *   BSD-like license that allows static linking with closed source software:
@@ -592,8 +593,9 @@ typedef enum {
     HMD_FOVE_VR,
 } VrDevice;
 
-// rRES data returned when reading a resource, it contains all required data for user (24 byte)
-typedef struct {
+// rRES data returned when reading a resource, 
+// it contains all required data for user (24 byte)
+typedef struct RRESData {
     unsigned int type;          // Resource type (4 byte)
 
     unsigned int param1;        // Resouce parameter 1 (4 byte)
@@ -604,14 +606,21 @@ typedef struct {
     void *data;                 // Resource data pointer (4 byte)
 } RRESData;
 
-typedef enum {
-    RRES_RAW = 0,
-    RRES_IMAGE,
-    RRES_WAVE,
-    RRES_VERTEX,
-    RRES_TEXT
+// RRESData type
+typedef enum { 
+    RRES_TYPE_RAW = 0, 
+    RRES_TYPE_IMAGE, 
+    RRES_TYPE_WAVE, 
+    RRES_TYPE_VERTEX, 
+    RRES_TYPE_TEXT,
+    RRES_TYPE_FONT_IMAGE,
+    RRES_TYPE_FONT_CHARDATA,    // CharInfo data array
+    RRES_TYPE_DIRECTORY
 } RRESDataType;
 
+// RRES type (pointer to RRESData array)
+typedef struct RRESData *RRES;
+
 #ifdef __cplusplus
 extern "C" {            // Prevents name mangling of functions
 #endif
@@ -758,6 +767,7 @@ RLAPI void DrawCircleV(Vector2 center, float radius, Color color);
 RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color);                         // Draw circle outline
 RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color);                        // Draw a color-filled rectangle
 RLAPI void DrawRectangleRec(Rectangle rec, Color color);                                                 // Draw a color-filled rectangle
+RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color);                 // Draw a color-filled rectangle with pro parameters
 RLAPI void DrawRectangleGradient(int posX, int posY, int width, int height, Color color1, Color color2); // Draw a gradient-filled rectangle
 RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                  // Draw a color-filled rectangle (Vector version)
 RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                   // Draw rectangle outline
diff --git a/src/raymath.h b/src/raymath.h
index c073b72d..a2263f19 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -1,22 +1,23 @@
 /**********************************************************************************************
 *
-*   raymath (header only file)
+*   raymath v1.0 - Some useful functions to work with Vector3, Matrix and Quaternions
 *
-*   Some useful functions to work with Vector3, Matrix and Quaternions
+*   CONFIGURATION:
 *
-*   You must:
-*       #define RAYMATH_IMPLEMENTATION
-*   before you include this file in *only one* C or C++ file to create the implementation.
+*   #define RAYMATH_IMPLEMENTATION
+*       Generates the implementation of the library into the included file.
+*       If not defined, the library is in header only mode and can be included in other headers
+*       or source files without problems. But only ONE file should hold the implementation.
 *
-*   Example:
-*       #define RAYMATH_IMPLEMENTATION
-*       #include "raymath.h"
+*   #define RAYMATH_EXTERN_INLINE
+*       Inlines all functions code, so it runs faster. This requires lots of memory on system.
+*   
+*   #define RAYMATH_STANDALONE
+*       Avoid raylib.h header inclusion in this file. 
+*       Vector3 and Matrix data types are defined internally in raymath module.
 *
-*   You can also use:
-*       #define RAYMATH_EXTERN_INLINE       // Inlines all functions code, so it runs faster.
-*                                           // This requires lots of memory on system.
-*       #define RAYMATH_STANDALONE          // Not dependent on raylib.h structs: Vector3, Matrix.
 *
+*   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
 *
diff --git a/src/rlgl.c b/src/rlgl.c
index ce17adc3..ffc9d741 100644
--- a/src/rlgl.c
+++ b/src/rlgl.c
@@ -2,6 +2,8 @@
 *
 *   rlgl - raylib OpenGL abstraction layer
 *
+*   DESCRIPTION:
+*
 *   rlgl allows usage of OpenGL 1.1 style functions (rlVertex) that are internally mapped to
 *   selected OpenGL version (1.1, 2.1, 3.3 Core, ES 2.0).
 *
@@ -11,20 +13,44 @@
 *       rlglDraw()  - Process internal buffers and send required draw calls
 *       rlglClose() - De-initialize internal buffers data and other auxiliar resources
 *
-*   External libs:
+*   CONFIGURATION:
+*
+*   #define GRAPHICS_API_OPENGL_11
+*       Use OpenGL 1.1 backend
+*
+*   #define GRAPHICS_API_OPENGL_21
+*       Use OpenGL 2.1 backend
+*
+*   #define GRAPHICS_API_OPENGL_33
+*       Use OpenGL 3.3 Core profile backend
+*
+*   #define GRAPHICS_API_OPENGL_ES2
+*       Use OpenGL ES 2.0 backend
+*
+*   #define RLGL_STANDALONE
+*       Use rlgl as standalone library (no raylib dependency)
+*
+*   #define RLGL_NO_DISTORTION_SHADER
+*       Avoid stereo rendering distortion sahder (shader_distortion.h) inclusion
+*
+*   #define SUPPORT_SHADER_DEFAULT / ENABLE_SHADER_DEFAULT
+*
+*   #define SUPPORT_SHADER_DISTORTION
+*
+*
+*   #define SUPPORT_OCULUS_RIFT_CV1 / RLGL_OCULUS_SUPPORT
+*       Enable Oculus Rift CV1 functionality
+*
+*   #define SUPPORT_STEREO_RENDERING
+*
+*   #define RLGL_NO_DEFAULT_SHADER
+*
+*   DEPENDENCIES:
 *       raymath     - 3D math functionality (Vector3, Matrix, Quaternion)
 *       GLAD        - OpenGL extensions loading (OpenGL 3.3 Core only)
 *
-*   Module Configuration Flags:
-*       GRAPHICS_API_OPENGL_11  - Use OpenGL 1.1 backend
-*       GRAPHICS_API_OPENGL_21  - Use OpenGL 2.1 backend
-*       GRAPHICS_API_OPENGL_33  - Use OpenGL 3.3 Core profile backend
-*       GRAPHICS_API_OPENGL_ES2 - Use OpenGL ES 2.0 backend
-*
-*       RLGL_STANDALONE             - Use rlgl as standalone library (no raylib dependency)
-*       RLGL_NO_DISTORTION_SHADER   - Avoid stereo rendering distortion sahder (shader_distortion.h) inclusion
-*       RLGL_OCULUS_SUPPORT         - Enable Oculus Rift CV1 functionality
 *
+*   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
 *
diff --git a/src/rres.h b/src/rres.h
index bed28723..362da10d 100644
--- a/src/rres.h
+++ b/src/rres.h
@@ -4,14 +4,18 @@
 *
 *   Basic functions to load/save rRES resource files
 *
-*   External libs:
-*       tinfl   -  DEFLATE decompression functions
+*   CONFIGURATION:
+*
+*   #define RREM_IMPLEMENTATION
+*       Generates the implementation of the library into the included file.
+*       If not defined, the library is in header only mode and can be included in other headers
+*       or source files without problems. But only ONE file should hold the implementation.
 *
-*   Module Configuration Flags:
+*   DEPENDENCIES:
+*       tinfl   -  DEFLATE decompression functions
 *
-*       #define RREM_IMPLEMENTATION
-*           Generates the implementation of the library into the included file.
 *
+*   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2016-2017 Ramon Santamaria (@raysan5)
 *
@@ -81,7 +85,7 @@
         RRES_TYPE_VERTEX, 
         RRES_TYPE_TEXT,
         RRES_TYPE_FONT_IMAGE,
-        RRES_TYPE_FONT_DATA,        // Character { int value, recX, recY, recWidth, recHeight, offsetX, offsetY, xAdvance } 
+        RRES_TYPE_FONT_CHARDATA,        // Character { int value, recX, recY, recWidth, recHeight, offsetX, offsetY, xAdvance } 
         RRES_TYPE_DIRECTORY
     } RRESDataType;
     
@@ -243,7 +247,7 @@ static void *DecompressData(const unsigned char *data, unsigned long compSize, i
 // NOTE: Returns uncompressed data with parameters, search resource by id
 RRESDEF RRES LoadResource(const char *fileName, int rresId)
 {
-    RRES rres;
+    RRES rres = { 0 };
 
     RRESFileHeader fileHeader;
     RRESInfoHeader infoHeader;
diff --git a/src/shapes.c b/src/shapes.c
index 83b80182..a42b0551 100644
--- a/src/shapes.c
+++ b/src/shapes.c
@@ -1,17 +1,14 @@
 /**********************************************************************************************
 *
-*   raylib.shapes
-*
-*   Basic functions to draw 2d Shapes and check collisions
-*
-*   DEPENDENCIES:
-*       rlgl     - raylib OpenGL abstraction layer
+*   raylib.shapes - Basic functions to draw 2d Shapes and check collisions
 *
 *   CONFIGURATION:
 *
 *   #define SUPPORT_QUADS_ONLY
+*       Draw shapes using only QUADS, vertex are accumulated in QUADS arrays (like textures)
 *
-    #define SUPPORT_TRIANGLES_ONLY
+*   #define SUPPORT_TRIANGLES_ONLY
+*       Draw shapes using only TRIANGLES, vertex are accumulated in TRIANGLES arrays
 *
 *
 *   LICENSE: zlib/libpng
diff --git a/src/text.c b/src/text.c
index 4deae25c..6f18b391 100644
--- a/src/text.c
+++ b/src/text.c
@@ -1,14 +1,22 @@
 /**********************************************************************************************
 *
-*   raylib.text
+*   raylib.text - Basic functions to load SpriteFonts and draw Text
 *
-*   Basic functions to load SpriteFonts and draw Text
+*   CONFIGURATION:
 *
-*   External libs:
+*   #define SUPPORT_FILEFORMAT_FNT
+*   #define SUPPORT_FILEFORMAT_TTF / INCLUDE_STB_TRUETYPE
+*   #define SUPPORT_FILEFORMAT_IMAGE_FONT
+*       Selected desired fileformats to be supported for loading. Some of those formats are 
+*       supported by default, to remove support, just comment unrequired #define in this module
+*
+*   #define INCLUDE_DEFAULT_FONT / SUPPORT_DEFAULT_FONT
+*
+*   DEPENDENCIES:
 *       stb_truetype - Load TTF file and rasterize characters data
 *
-*   Module Configuration Flags:
-*       ...
+*
+*   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
 *
@@ -262,30 +270,28 @@ SpriteFont LoadSpriteFont(const char *fileName)
     else if (strcmp(GetExtension(fileName),"rres") == 0)
     {
         // TODO: Read multiple resource blocks from file (RRES_FONT_IMAGE, RRES_FONT_CHARDATA)
-        RRESData rres = LoadResource(fileName);
+        RRES rres = LoadResource(fileName, 0);
 
         // Load sprite font texture
-        /*
-        if (rres.type == RRES_FONT_IMAGE) 
+        if (rres[0].type == RRES_TYPE_FONT_IMAGE) 
         {
             // NOTE: Parameters for RRES_FONT_IMAGE type are: width, height, format, mipmaps
-            Image image = LoadImagePro(rres.data, rres.param1, rres.param2, rres.param3);
+            Image image = LoadImagePro(rres[0].data, rres[0].param1, rres[0].param2, rres[0].param3);
             spriteFont.texture = LoadTextureFromImage(image);
             UnloadImage(image);
         }
         
         // Load sprite characters data
-        if (rres.type == RRES_FONT_CHARDATA) 
+        if (rres[1].type == RRES_TYPE_FONT_CHARDATA) 
         {
             // NOTE: Parameters for RRES_FONT_CHARDATA type are: fontSize, charsCount
-            spriteFont.baseSize = rres.param1;
-            spriteFont.charsCount = rres.param2;
-            spriteFont.chars = rres.data;
+            spriteFont.baseSize = rres[1].param1;
+            spriteFont.charsCount = rres[1].param2;
+            spriteFont.chars = rres[1].data;
         }
-        */
 
         // TODO: Do not free rres.data memory (chars info data!)
-        UnloadResource(rres);
+        //UnloadResource(rres[0]);
     }
     else
     {
diff --git a/src/textures.c b/src/textures.c
index 5b2e4775..7db3bf56 100644
--- a/src/textures.c
+++ b/src/textures.c
@@ -1,16 +1,35 @@
 /**********************************************************************************************
 *
-*   raylib.textures
+*   raylib.textures - Basic functions to load and draw Textures (2d)
 *
-*   Basic functions to load and draw Textures (2d)
+*   CONFIGURATION:
 *
-*   External libs:
+*   #define SUPPORT_STB_IMAGE / INCLUDE_STB_IMAGE
+*
+*   #define SUPPORT_FILEFORMAT_BMP / SUPPORT_LOAD_BMP
+*   #define SUPPORT_FILEFORMAT_PNG / SUPPORT_LOAD_PNG
+*   #define SUPPORT_FILEFORMAT_TGA
+*   #define SUPPORT_FILEFORMAT_JPG / ENABLE_LOAD_JPG
+*   #define SUPPORT_FILEFORMAT_GIF
+*   #define SUPPORT_FILEFORMAT_HDR
+*   #define SUPPORT_FILEFORMAT_DDS / ENABLE_LOAD_DDS
+*   #define SUPPORT_FILEFORMAT_PKM
+*   #define SUPPORT_FILEFORMAT_KTX
+*   #define SUPPORT_FILEFORMAT_PVR
+*   #define SUPPORT_FILEFORMAT_ASTC
+*       Selected desired fileformats to be supported for loading. Some of those formats are 
+*       supported by default, to remove support, just comment unrequired #define in this module
+*
+*   #define SUPPORT_IMAGE_RESIZE / INCLUDE_STB_IMAGE_RESIZE
+*   #define SUPPORT_IMAGE_MANIPULATION
+*
+*   DEPENDENCIES:
 *       stb_image        - Multiple image formats loading (JPEG, PNG, BMP, TGA, PSD, GIF, PIC)
 *                          NOTE: stb_image has been slightly modified to support Android platform.
 *       stb_image_resize - Multiple image resize algorythms
 *
-*   Module Configuration Flags:
-*       ...
+*
+*   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
 *
@@ -143,11 +162,11 @@ Image LoadImage(const char *fileName)
     else if (strcmp(GetExtension(fileName),"astc") == 0) image = LoadASTC(fileName);
     else if (strcmp(GetExtension(fileName),"rres") == 0)
     {
-        RRESData rres = LoadResource(fileName);
+        RRES rres = LoadResource(fileName, 0);
 
-        // NOTE: Parameters for RRES_IMAGE type are: width, height, format, mipmaps
+        // NOTE: Parameters for RRES_TYPE_IMAGE are: width, height, format, mipmaps
 
-        if (rres.type == RRES_IMAGE) image = LoadImagePro(rres.data, rres.param1, rres.param2, rres.param3);
+        if (rres[0].type == RRES_TYPE_IMAGE) image = LoadImagePro(rres[0].data, rres[0].param1, rres[0].param2, rres[0].param3);
         else TraceLog(WARNING, "[%s] Resource file does not contain image data", fileName);
 
         UnloadResource(rres);
diff --git a/src/utils.c b/src/utils.c
index e5e05955..9a2a723a 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -1,16 +1,23 @@
 /**********************************************************************************************
 *
-*   raylib.utils
+*   raylib.utils - Some common utility functions
 *
-*   Some utility functions
+*   CONFIGURATION:
 *
-*   External libs:
-*       tinfl           - zlib DEFLATE algorithm decompression
+*   #define SUPPORT_SAVE_PNG
+*       Enable saving PNG fileformat
+*       NOTE: Requires stb_image_write library
+*
+*   #define SUPPORT_SAVE_BMP
+*
+*   #define DO_NOT_TRACE_DEBUG_MSGS
+*       Avoid showing DEBUG TraceLog() messages
+*
+*   DEPENDENCIES:
 *       stb_image_write - PNG writting functions
 *
-*   Module Configuration Flags:
-*       DO_NOT_TRACE_DEBUG_MSGS - Avoid showing DEBUG TraceLog() messages
 *
+*   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
 *
-- 
cgit v1.2.3