Lattest PR review

Function names, code formatting...

4 files changed, 149 insertions, 145 deletions

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;
-}
-