twix/raylib
1
0
Fork 0
mirror of https://github.com/raysan5/raylib.git synced 2025-12-25 10:22:33 -05:00
Code Issues Packages Projects Releases Wiki Activity

Lattest PR review

Browse Source 
Function names, code formatting...
This commit is contained in:
raysan5
2017-01-05 19:33:05 +01:00
parent 0369bb4c8c
commit 658c280669
6 changed files with 217 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
src/models.c
View File

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

21
src/raylib.h
View File

@ -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)

25
src/raymath.h
View File

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

81
src/shapes.c
View File

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