diff options
Diffstat (limited to 'src/rmath.c')
| -rw-r--r-- | src/rmath.c | 480 |
1 files changed, 480 insertions, 0 deletions
diff --git a/src/rmath.c b/src/rmath.c index 15d5323..40e8cb8 100644 --- a/src/rmath.c +++ b/src/rmath.c @@ -483,6 +483,38 @@ int lmathVector2Reflect( lua_State* L ) { } /* +> result = RL.Vector2Min( Vector2 v1, Vector2 v2 ) + +Get min value for each pair of components + +- Success return Vector2 +*/ +int lmathVector2Min( lua_State* L ) { + Vector2 v1 = uluaGetVector2( L, 1 ); + Vector2 v2 = uluaGetVector2( L, 2 ); + + uluaPushVector2( L, Vector2Min( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector2Max( Vector2 v1, Vector2 v2 ) + +Get max value for each pair of components + +- Success return Vector2 +*/ +int lmathVector2Max( lua_State* L ) { + Vector2 v1 = uluaGetVector2( L, 1 ); + Vector2 v2 = uluaGetVector2( L, 2 ); + + uluaPushVector2( L, Vector2Max( v1, v2 ) ); + + return 1; +} + +/* > result = RL.Vector2Rotate( Vector2 v, float angle ) Rotate vector by angle @@ -582,6 +614,27 @@ int lmathVector2Equals( lua_State* L ) { } /* +> result = RL.Vector2Refract( Vector2 v, Vector2 n, float r ) + +Compute the direction of a refracted ray +v: normalized direction of the incoming ray +n: normalized normal vector of the interface of two optical media +r: ratio of the refractive index of the medium from where the ray comes + to the refractive index of the medium on the other side of the surface + +- Success return Vector2 +*/ +int lmathVector2Refract( lua_State* L ) { + Vector2 v = uluaGetVector2( L, 1 ); + Vector2 n = uluaGetVector2( L, 2 ); + float r = luaL_checknumber( L, 3 ); + + uluaPushVector2( L, Vector2Refract( v, n, r ) ); + + return 1; +} + +/* ## Math - Vector 3 */ @@ -980,6 +1033,23 @@ int lmathVector3RotateByAxisAngle( lua_State* L ) { } /* +> result = RL.Vector3MoveTowards( Vector3 v, Vector3 target, float maxDistance ) + +Move Vector towards target + +- Success return Vector3 +*/ +int lmathVector3MoveTowards( lua_State* L ) { + Vector3 v = uluaGetVector3( L, 1 ); + Vector3 target = uluaGetVector3( L, 2 ); + float maxDistance = luaL_checknumber( L, 3 ); + + uluaPushVector3( L, Vector3MoveTowards( v, target, maxDistance ) ); + + return 1; +} + +/* > result = RL.Vector3Lerp( Vector3 v1, Vector3 v2, float amount ) Calculate linear interpolation between two vectors @@ -997,6 +1067,26 @@ int lmathVector3Lerp( lua_State* L ) { } /* +> result = RL.Vector3CubicHermite( Vector3 v1, Vector3 tangent1, Vector3 v2, Vector3 tangent2, float amount ) + +Calculate cubic hermite interpolation between two vectors and their tangents +as described in the GLTF 2.0 specification: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#interpolation-cubic + +- Success return Vector3 +*/ +int lmathVector3CubicHermite( lua_State* L ) { + Vector3 v1 = uluaGetVector3( L, 1 ); + Vector3 tangent1 = uluaGetVector3( L, 2 ); + Vector3 v2 = uluaGetVector3( L, 3 ); + Vector3 tangent2 = uluaGetVector3( L, 4 ); + float amount = luaL_checknumber( L, 5 ); + + uluaPushVector3( L, Vector3CubicHermite( v1, tangent1, v2, tangent2, amount ) ); + + return 1; +} + +/* > result = RL.Vector3Reflect( Vector3 v, Vector3 normal ) Calculate reflected vector to normal @@ -1170,6 +1260,353 @@ int lmathVector3Refract( lua_State* L ) { } /* +## Math - Vector4 +*/ + +/* +> result = RL.Vector4Zero() + +Vector with components value 0.0f + +- Success return Vector4 +*/ +int lmathVector4Zero( lua_State* L ) { + uluaPushVector4( L, Vector4Zero() ); + + return 1; +} + +/* +> result = RL.Vector4One() + +Vector with components value 1.0f + +- Success return Vector4 +*/ +int lmathVector4One( lua_State* L ) { + uluaPushVector4( L, Vector4One() ); + + return 1; +} + +/* +> result = RL.Vector4Add( Vector4 v1, Vector4 v2 ) + +Add two vectors + +- Success return Vector4 +*/ +int lmathVector4Add( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + uluaPushVector4( L, Vector4Add( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector4AddValue( Vector4 v, float add ) + +Add vector and float value + +- Success return Vector4 +*/ +int lmathVector4AddValue( lua_State* L ) { + Vector4 v = uluaGetVector4( L, 1 ); + float add = luaL_checknumber( L, 2 ); + + uluaPushVector4( L, Vector4AddValue( v, add ) ); + + return 1; +} + +/* +> result = RL.Vector4Subtract( Vector4 v1, Vector4 v2 ) + +Subtract two vectors + +- Success return Vector4 +*/ +int lmathVector4Subtract( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + uluaPushVector4( L, Vector4Subtract( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector4SubtractValue( Vector4 v, float sub ) + +Subtract vector by float value + +- Success return Vector4 +*/ +int lmathVector4SubtractValue( lua_State* L ) { + Vector4 v = uluaGetVector4( L, 1 ); + float sub = luaL_checknumber( L, 2 ); + + uluaPushVector4( L, Vector4SubtractValue( v, sub ) ); + + return 1; +} + +/* +> result = RL.Vector4Length( Vector4 v ) + +Calculate vector length + +- Success return float +*/ +int lmathVector4Length( lua_State* L ) { + Vector4 v = uluaGetVector4( L, 1 ); + + lua_pushnumber( L, Vector4Length( v ) ); + + return 1; +} + +/* +> result = RL.Vector4LengthSqr( Vector4 v ) + +Calculate vector square length + +- Success return float +*/ +int lmathVector4LengthSqr( lua_State* L ) { + Vector4 v = uluaGetVector4( L, 1 ); + + lua_pushnumber( L, Vector4LengthSqr( v ) ); + + return 1; +} + +/* +> result = RL.Vector4DotProduct( Vector4 v1, Vector4 v2 ) + +Calculate two vectors dot product + +- Success return float +*/ +int lmathVector4DotProduct( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + lua_pushnumber( L, Vector4DotProduct( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector4Distance( Vector4 v1, Vector4 v2 ) + +Calculate distance between two vectors + +- Success return float +*/ +int lmathVector4Distance( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + lua_pushnumber( L, Vector4Distance( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector4DistanceSqr( Vector4 v1, Vector4 v2 ) + +Calculate square distance between two vectors + +- Success return float +*/ +int lmathVector4DistanceSqr( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + lua_pushnumber( L, Vector4DistanceSqr( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector4Scale( Vector4 v, float scalar ) + +Multiply vector by scalar + +- Success return Vector4 +*/ +int lmathVector4Scale( lua_State* L ) { + Vector4 v = uluaGetVector4( L, 1 ); + float scalar = luaL_checknumber( L, 2 ); + + uluaPushVector4( L, Vector4Scale( v, scalar ) ); + + return 1; +} + +/* +> result = RL.Vector4Multiply( Vector4 v1, Vector4 v2 ) + +Multiply vector by vector + +- Success return Vector4 +*/ +int lmathVector4Multiply( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + uluaPushVector4( L, Vector4Multiply( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector4Negate( Vector4 v ) + +Negate provided vector (invert direction) + +- Success return Vector4 +*/ +int lmathVector4Negate( lua_State* L ) { + Vector4 v = uluaGetVector4( L, 1 ); + + uluaPushVector4( L, Vector4Negate( v ) ); + + return 1; +} + +/* +> result = RL.Vector4Divide( Vector4 v1, Vector4 v2 ) + +Divide vector by vector + +- Success return Vector4 +*/ +int lmathVector4Divide( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + uluaPushVector4( L, Vector4Divide( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector4Normalize( Vector4 v ) + +Normalize provided vector + +- Success return Vector4 +*/ +int lmathVector4Normalize( lua_State* L ) { + Vector4 v = uluaGetVector4( L, 1 ); + + uluaPushVector4( L, Vector4Normalize( v ) ); + + return 1; +} + +/* +> result = RL.Vector4Min( Vector4 v1, Vector4 v2 ) + +Get min value for each pair of components + +- Success return Vector4 +*/ +int lmathVector4Min( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + uluaPushVector4( L, Vector4Min( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector4Max( Vector4 v1, Vector4 v2 ) + +Get max value for each pair of components + +- Success return Vector4 +*/ +int lmathVector4Max( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + uluaPushVector4( L, Vector4Max( v1, v2 ) ); + + return 1; +} + +/* +> result = RL.Vector4Lerp( Vector4 v1, Vector4 v2, float amount ) + +Calculate linear interpolation between two vectors + +- Success return Vector4 +*/ +int lmathVector4Lerp( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + float amount = luaL_checknumber( L, 3 ); + + uluaPushVector4( L, Vector4Lerp( v1, v2, amount ) ); + + return 1; +} + +/* +> result = RL.Vector4MoveTowards( Vector4 v, Vector4 target, float maxDistance ) + +Move Vector towards target + +- Success return Vector4 +*/ +int lmathVector4MoveTowards( lua_State* L ) { + Vector4 v = uluaGetVector4( L, 1 ); + Vector4 target = uluaGetVector4( L, 2 ); + float maxDistance = luaL_checknumber( L, 3 ); + + uluaPushVector4( L, Vector4MoveTowards( v, target, maxDistance ) ); + + return 1; +} + +/* +> result = RL.Vector4Invert( Vector4 v ) + +Invert the given vector + +- Success return Vector4 +*/ +int lmathVector4Invert( lua_State* L ) { + Vector4 v = uluaGetVector4( L, 1 ); + + uluaPushVector4( L, Vector4Invert( v ) ); + + return 1; +} + +/* +> result = RL.Vector4Equals( Vector4 v1, Vector4 v2 ) + +Check whether two given vectors are almost equal + +- Success return bool +*/ +int lmathVector4Equals( lua_State* L ) { + Vector4 v1 = uluaGetVector4( L, 1 ); + Vector4 v2 = uluaGetVector4( L, 2 ); + + lua_pushboolean( L, Vector4Equals( v1, v2 ) == 1 ); + + return 1; +} + +/* ## Math - Matrix */ @@ -1491,6 +1928,29 @@ int lmathMatrixLookAt( lua_State* L ) { } /* +> translation, rotation, scale = RL.MatrixDecompose( Matrix mat ) + +Decompose a transformation matrix into its rotational, translational and scaling components + +- Success return Vector3, Quaternion, Vector3 +*/ +int lmathMatrixDecompose( lua_State* L ) { + Matrix mat = uluaGetMatrix( L, 1 ); + + Vector3 translation = { 0 }; + Quaternion rotation = { 0 }; + Vector3 scale = { 0 }; + + MatrixDecompose( mat, &translation, &rotation, &scale ); + + uluaPushVector3( L, translation ); + uluaPushQuaternion( L, rotation ); + uluaPushVector3( L, scale ); + + return 3; +} + +/* ## Math - Quaternion */ @@ -1716,6 +2176,26 @@ int lmathQuaternionSlerp( lua_State* L ) { } /* +> result = RL.QuaternionCubicHermiteSpline( Quaternion q1, Quaternion outTangent1, Quaternion q2, Quaternion inTangent2, float t ) + +Calculate quaternion cubic spline interpolation using Cubic Hermite Spline algorithm +as described in the GLTF 2.0 specification: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#interpolation-cubic + +- Success return Quaternion +*/ +int lmathQuaternionCubicHermiteSpline( lua_State* L ) { + Quaternion q1 = uluaGetQuaternion( L, 1 ); + Quaternion outTangent1 = uluaGetQuaternion( L, 2 ); + Quaternion q2 = uluaGetQuaternion( L, 3 ); + Quaternion inTangent2 = uluaGetQuaternion( L, 4 ); + float t = luaL_checknumber( L, 5 ); + + uluaPushQuaternion( L, QuaternionCubicHermiteSpline( q1, outTangent1, q2, inTangent2, t ) ); + + return 1; +} + +/* > result = RL.QuaternionFromVector3ToVector3( Vector3 from, Vector3 to ) Calculate quaternion based on the rotation from one vector to another |