Module providing various structure to manipulate vectors, matrix as well as quaternion. In addition the module include multiply utility functions to handle color space conversion, interpolation etc...

Functions

Name	Description
`InverseSqrtf`	Calculate the inverse square root of a value.
Declaration float InverseSqrtf( float x )
`Project`	Project a 3d point to screen components.
Declaration vec3 Project( float objx, float objy, float objz, mat4 modelview_matrix, mat4 projection_matrix, quad viewport )
`Unproject`	Unproject an arbitraty screen component back to a 3d point.
Declaration vec3 Unproject( float winx, float winy, float winz, mat4 modelview_matrix, mat4 projection_matrix, quad viewport )
`GetNearestPoint`	Return the nearest point on a line.
Declaration vec3 GetNearestPoint( vec3 ray_from, vec3 ray_to, vec3 point )
`HitBSphere`	Function that check wether or not a ray hit a sphere.
Declaration bool HitBSphere( vec3 ray_from, vec3 ray_to, vec3 center, float radius )
`HitBSphere2`	Function that return the hit point between a ray and a sphere.
Declaration vec3 HitBSphere2( vec3 ray_from, vec3 ray_to, vec3 center, float radius ) Return Value If not hit occur return a zeroed vector.
`HitAABB`	Function that return if a ray hit an axis align bounding box.
Declaration bool HitAABB( vec3 ray_from, vec3 ray_to, vec3 min, vec3 max )
`HitAABB2`	Function that returns the hit point between a ray and an AABB.
Declaration vec3 HitAABB2( vec3 ray_from, vec3 ray_to, vec3 min, vec3 max ) Return Value If not hit occur return a zeroed vector.
`HitAABBNormal`	Function that return the hit normal between a ray and an AABB.
Declaration vec3 HitAABBNormal( vec3 hit_point, vec3 min, vec3 max ) Return Value If not hit occur return a zeroed vector.
`PointInAABB`	Determine if an arbitrary point is inside an AABB.
Declaration bool PointInAABB( vec3 point, vec3 min, vec3 max )
`PointInBSphere`	Determine if an arbitrary point is inside a bounding sphere.
Declaration bool PointInBSphere( vec3 point, vec3 center, float radius )
`PointInCylinder`	Determine if an arbitrary point is inside a cylinder.
Declaration bool PointInCylinder( vec3 point, vec3 base, vec3 top, float height, float radius )
`PointInBBox`	Determine if an arbitrary point is inside a bounding box.
Declaration bool PointInBBox( vec3 point, vec3 size, mat4 m )
`IntersectTriangle`	Function that determine if a ray intersect a triangle.
Declaration float IntersectTriangle( vec3 ray_from, vec3 ray_dir, vec3 v0, vec3 v1, vec3 v2 ) Return Value The hit fraction between the ray and the triangle.
`IntersectTriangleCull`	Function that determine if a ray intersect a triangle taking in consideration back face culling.
Declaration float IntersectTriangleCull( vec3 ray_from, vec3 ray_dir, vec3 v0, vec3 v1, vec3 v2 ) Return Value The hit fraction between the ray and the triangle.
`IntersectPlane`	Function that return the hit point between a ray and a plane.
Declaration vec3 IntersectPlane( vec3 ray_from, vec3 ray_to, vec3 pco, vec3 pno ) Return Value If not hit occur return a zeroed vector.
`HitBBox`	Return the hit point between a ray and a bounding box.
Declaration vec3 HitBBox( bbox box, vec3 ray_from, vec3 ray_to ) Return Value If not hit occur return a zeroed vector.
`HitBBoxNormal`	Return the hit normal between a ray and a bounding box.
Declaration vec3 HitBBoxNormal( bbox box, vec3 hit_point, vec3 ray_from, vec3 ray_to ) Return Value If not hit occur return a zeroed vector.
`TriOverlapAABB`	Return wether or not a triangle is intersecting an AABB.
Declaration bool TriOverlapAABB( vec3 center, vec3 size, vec3 v0, vec3 v1, vec3 v2 )
`ClosestPointOnTri`	Function that returns the closests point on a triangle.
Declaration vec3 ClosestPointOnTri( vec3 p, vec3 v0, vec3 v1, vec3 v2 )
`ClosestBarycentricOnTri`	Function that returns the closests barycentric component of a point on a triangle.
Declaration vec3 ClosestBarycentricOnTri( vec3 p, vec3 v0, vec3 v1, vec3 v2 )
`Perlin1d`	Perlin noise function.
Declaration float Perlin1d( float x, int seed, float freq, int depth )
`Perlin2d`	Two dimensional Perlin noise function.
Declaration float Perlin2d( float x, float y, int seed, float freq, int depth )
`OverlapAABB`	Function that check if two AABB overlap.
Declaration bool OverlapAABB( vec3 min0, vec3 max0, vec3 min1, vec3 max1 )
`OverlapBSphere`	Function that check if two bounding sphere overlap.
Declaration bool OverlapBSphere( vec3 center0, float radius0, vec3 center1, float radius1 )
`OverlapAABBBSphere`	Return the hit distance between an AABB and a BSphere.
Declaration float OverlapAABBBSphere( vec3 min, vec3 max, vec3 center, float radius )
`NormalizeFloat`	Round up the digits of a floating point value.
Declaration float NormalizeFloat( float f, unsigned char d )
`NormalizeAngle`	Normalize a Euler angle in the range of `0.0` to `360.0` degree.
Declaration float NormalizeAngle( float angle )
`ValueInRange`	Helper function that check if a value is inside a specific range.
Declaration bool ValueInRange( float v, float min, float max )
`Wrapf`	Wrap around an arbitrary value to a specific range.
Declaration float Wrapf( float v, float min, float max ) Remarks If the value `v` goes above the higher limit it warp back to the lower limit and vice versa.
`Wrapi`	Return the active modelview matrix multiplied by the projection matrix.
Declaration int Wrapi( int v, int min, int max ) Remarks If the value `v` goes above the higher limit it warp back to the lower limit and vice versa.
`Clampf`	Clamp a floating point value to a specific range.
Declaration float Clampf( float v, float min, float max )
`Clampi`	Clamp an integer value to a specific range.
Declaration int Clampi( int v, int min, int max )
`LookAt`	Function that build a look at matrix.
Declaration mat4 LookAt( vec3 eye, vec3 center, vec3 up )
`RotateAround`	Return the orbit position of an arbitrary point around pivot.
Declaration vec3 RotateAround( vec3 point, vec3 pivot, vec3 axis, float angle )
`Randomui`	Return a random integer value between `0` and `max`.
Declaration unsigned int Randomui( unsigned int max )
`Randomf`	Function that return a random floating point in the range of `0.0` to `1.0`.
Declaration float Randomf( void )
`Snap`	Snap a component `v` to an arbitrary unit grid.
Declaration int Snap( int v, unsigned int units )
`Smoothstep`	Perform a smooth Hermite interpolation between two values.
Declaration float Smoothstep( float e0, float e1, float v )

IVec2

Two-dimensional vector or integers.

Variables

Name	Description
`x`	The `X` component of the vector.
Declaration int x
`y`	The `Y` component of the vector.
Declaration int y

Functions

Name Description

Set Set the XY components of the vector.

Declaration

ivec2 Set( int x, int y )

Vec2

Two-dimensional vector.

Variables

Name	Description
`x`	The `X` component of the vector.
Declaration float x
`y`	The `Y` component of the vector.
Declaration float y

Functions

Name	Description
`Set`	Set the `XY` components of the vector.
Declaration vec2 Set( float x, float y )
`Setf`	Set the same value to both `XY` components of the vector.
Declaration vec2 Setf( float v )
`Zero`	Set the vector to zero.
Declaration vec2 Zero( void )
`One`	Set the vector to one.
Declaration vec2 One( void )
`Invert`	Invert the vector values.
Declaration vec2 Invert( vec2 v )
`Print`	Print the vector value on the console.
Declaration void Print( vec2 v )
`IsZero`	Check if the vector is set to zero.
Declaration bool IsZero( vec2 v )
`Equal`	Check for equality.
Declaration bool Equal( vec2 v0, vec2 v1 )
`Add`	Adds two vectors.
Declaration vec2 Add( vec2 v0, vec2 v1 )
`Sub`	Subtracts one vector from another.
Declaration vec2 Sub( vec2 v0, vec2 v1 )
`Mulf`	Multiplies a vector by a number.
Declaration vec2 Mulf( vec2 v, float f )
`Mul`	Multiplies a vector by a vector.
Declaration vec2 Mul( vec2 v0, vec2 v1 )
`Div`	Divides a vector by a vector.
Declaration vec2 Div( vec2 v0, vec2 v1 )
`Divf`	Divides a vector by a number.
Declaration vec2 Divf( vec2 v, float f )
`Length`	Return the dot product of the vector.
Declaration float Length( vec2 v )
`Magnitude`	Return the square length of the vector.
Declaration float Magnitude( vec2 v )
`NormalizeFast`	Normalize the vector using approximation.
Declaration vec2 NormalizeFast( vec2 v )
`Normalize`	Normalize the vector.
Declaration vec2 Normalize( vec2 v )
`Distance`	Calculate the distance between two vector.
Declaration float Distance( vec2 v0, vec2 v1 )
`Dot`	Return the dot product of two vector.
Declaration float Dot( vec2 v0, vec2 v1 )
`Cross`	Return the cross product of two vector.
Declaration vec2 Cross( vec2 v0, vec2 v1 )
`Angle`	Return the Euler angle between two normalized vector.
Declaration float Angle( vec2 v0, vec2 v1 )
`Lerp`	Linearly interpolate between one vector to another.
Declaration vec2 Lerp( vec2 v0, vec2 v1, float t )
`Mid`	Return the middle point between two vector.
Declaration vec2 Mid( vec2 v0, vec2 v1 )
`Min`	Return the minimum `XY` value between two vector.
Declaration vec2 Min( vec2 v0, vec2 v1 )
`Max`	Return the minimum `XY` value between two vector.
Declaration vec2 Max( vec2 v0, vec2 v1 )
`Low`	Return the lowest value of the vector.
Declaration float Low( vec2 v )
`High`	Return the highest value of the vector.
Declaration float High( vec2 v )
`ToVec3`	Convert to a tri-dimensional vector..
Declaration vec3 ToVec3( vec2 v, float z )

IVec3

Three-dimensional vector or integers.

Variables

Name	Description
`x`	The `X` component of the vector.
Declaration int x
`y`	The `Y` component of the vector.
Declaration int y

Functions

Name Description

Set Set the XY components of the vector.

Declaration

ivec3 Set( int x, int y )

Vec3

Tri-dimensional vector.

Variables

Name	Description
`x`	The `X` component of the vector.
Declaration float x
`y`	The `Y` component of the vector.
Declaration float y
`z`	The `Z` component of the vector.
Declaration float z

Functions

Name	Description
`Set`	Set the `XYZ` components of the vector.
Declaration vec3 Set( float x, float y )
`Setf`	Set the same value to both `XYZ` components of the vector.
Declaration vec3 Setf( float v )
`Zero`	Set the vector to zero.
Declaration vec3 Zero( void )
`One`	Set the vector to one.
Declaration vec3 One( void )
`Invert`	Invert the vector values.
Declaration vec3 Invert( vec3 v )
`Print`	Print the vector value on the console.
Declaration void Print( vec3 v )
`IsZero`	Check if the vector is set to zero.
Declaration bool IsZero( vec3 v )
`Equal`	Check for equality.
Declaration bool Equal( vec3 v0, vec3 v1 )
`Add`	Adds two vectors.
Declaration vec3 Add( vec3 v0, vec3 v1 )
`Sub`	Subtracts one vector from another.
Declaration vec3 Sub( vec3 v0, vec3 v1 )
`Mulf`	Multiplies a vector by a number.
Declaration vec3 Mulf( vec3 v, float f )
`Mul`	Multiplies a vector by a vector.
Declaration vec3 Mul( vec3 v0, vec3 v1 )
`Div`	Divides a vector by a vector.
Declaration vec3 Div( vec3 v0, vec3 v1 )
`Divf`	Divides a vector by a number.
Declaration vec3 Divf( vec3 v, float f )
`Length`	Return the dot product of the vector.
Declaration float Length( vec3 v )
`Magnitude`	Return the square length of the vector.
Declaration float Magnitude( vec3 v )
`NormalizeFast`	Normalize the vector using approximation.
Declaration vec3 NormalizeFast( vec3 v )
`Normalize`	Normalize the vector.
Declaration vec3 Normalize( vec3 v )
`NormalizeSafe`	Normalize the vector avoid division by zero.
Declaration vec3 NormalizeSafe( vec3 v )
`Distance`	Calculate the distance between two vector.
Declaration float Distance( vec3 v0, vec3 v1 )
`Dot`	Return the dot product of two vector.
Declaration float Dot( vec3 v0, vec3 v1 )
`Cross`	Return the cross product of two vector.
Declaration vec3 Cross( vec3 v0, vec3 v1 )
`Angle`	Return the Euler angle between two normalized vector.
Declaration float Angle( vec3 v0, vec3 v1 )
`Lerp`	Linearly interpolate between one vector to another.
Declaration vec3 Lerp( vec3 v0, vec3 v1, float t )
`Mid`	Return the middle point between two vector.
Declaration vec3 Mid( vec3 v0, vec3 v1 )
`Min`	Return the minimum `XYZ` value between two vector.
Declaration vec3 Min( vec3 v0, vec3 v1 )
`Max`	Return the minimum `XYZ` value between two vector.
Declaration vec3 Max( vec3 v0, vec3 v1 )
`Low`	Return the lowest value of the vector.
Declaration float Low( vec3 v )
`High`	Return the highest value of the vector.
Declaration float High( vec3 v )
`MulMat3`	Multiply the vector by a 3x3 matrix.
Declaration vec3 MulMat3( vec3 v, mat3 m )
`MulMat4`	Multiple the vector by a 4x4 transformation matrix.
Declaration vec3 MulMat4( vec3 v, mat4 m )
`MulMat4`	Multiple the vector by the rotation part of a 4x4 transformation matrix.
Declaration vec3 MulMat4( vec3 v, mat4 m )
`MulQuat`	Multiple the vector by a quaternion.
Declaration vec3 MulQuat( vec3 v, quat q )
`AxisToMat3`	Create a 3x3 rotation matrix from normalized vector around the up axis (`Z`).
Declaration mat3 AxisToMat3( vec3 v, float sin, float cos )
`GetDominantAxis`	Return the vector dominant axis.
Declaration unsigned char GetDominantAxis( vec3 v )
`Ortho`	Ortho. project the current vector.
Declaration vec3 Ortho( vec3 v )
`Reflect`	Calculate the reflection direction between a vector and a normal.
Declaration vec3 Reflect( vec3 v, vec3 n )
`Bounce`	Return the bounce direction of a vector and a normal biased by paramater `b`.
Declaration vec3 Bounce( vec3 v, vec3 n, float b ) Note The `b` variable represents the restitution factor which is usually from the of `0.0` to `1.0`.
`Project`	Project a vector onto a plane normal.
Declaration vec3 Project( vec3 v, vec3 n )
`AngleX`	Retrieve the angle `X` of a normalized direction vector.
Declaration float AngleX( vec3 v )
`AngleZ`	Retrieve the angle `Z` of a normalized direction vector.
Declaration float AngleZ( vec3 v )
`ToVec4`	Convert the 3D vector to a 4D vector.
Declaration vec4 ToVec4( vec3 v, float w )
`ToQuat`	Convert Euler angles based vector to a quaternion.
Declaration quat ToQuat( vec3 euler )

Vec4

4D vector class.

Variables

Name	Description
`x`	The `X` component of the vector.
Declaration float x
`y`	The `Y` component of the vector.
Declaration float y
`z`	The `Z` component of the vector.
Declaration float z
`w`	The `W` component of the vector.
Declaration float w

Functions

Name	Description
`Set`	Set the `XYZW` components of the vector.
Declaration vec4 Set( float x, float y )
`Setf`	Set the same value to both `XYZW` components of the vector.
Declaration vec4 Setf( float v )
`Zero`	Set the vector to zero.
Declaration vec4 Zero( void )
`One`	Set the vector to one.
Declaration vec4 One( void )
`Invert`	Invert the vector values.
Declaration vec4 Invert( vec4 v )
`Print`	Print the vector value on the console.
Declaration void Print( vec4 v )
`IsZero`	Check if the vector is set to zero.
Declaration bool IsZero( vec4 v )
`Equal`	Check for equality.
Declaration bool Equal( vec4 v0, vec4 v1 )
`Add`	Adds two vectors.
Declaration vec4 Add( vec4 v0, vec4 v1 )
`Sub`	Subtracts one vector from another.
Declaration vec4 Sub( vec4 v0, vec4 v1 )
`Mulf`	Multiplies a vector by a number.
Declaration vec4 Mulf( vec4 v, float f )
`Mul`	Multiplies a vector by a vector.
Declaration vec4 Mul( vec4 v0, vec4 v1 )
`Div`	Divides a vector by a vector.
Declaration vec4 Div( vec4 v0, vec4 v1 )
`Divf`	Divides a vector by a number.
Declaration vec4 Divf( vec4 v, float f )
`DivVec3`	Divides a 4D vector by a 3D vector.
Declaration vec4 DivVec3( vec4 v0, vec3 v1 )
`Length`	Return the dot product of the 4D vector.
Declaration float Length( vec4 v )
`Length3`	Return the dot product of the 3D part of the vector.
Declaration float Length3( vec4 v )
`Magnitude`	Return the square length of the vector.
Declaration float Magnitude( vec4 v )
`NormalizeFast`	Normalize the vector using approximation.
Declaration vec4 NormalizeFast( vec4 v )
`Normalize`	Normalize the vector.
Declaration vec4 Normalize( vec4 v )
`NormalizeSafe`	Normalize the vector avoid division by zero.
Declaration vec4 NormalizeSafe( vec4 v )
`Dot`	Return the dot product of two vector.
Declaration float Dot( vec4 v0, vec4 v1 )
`Lerp`	Linearly interpolate between one vector to another.
Declaration vec4 Lerp( vec4 v0, vec4 v1, float t )
`Min`	Return the minimum `XYZW` value between two vector.
Declaration vec4 Min( vec4 v0, vec4 v1 )
`Max`	Return the minimum `XYZW` value between two vector.
Declaration vec4 Max( vec4 v0, vec4 v1 )
`Low`	Return the lowest value of the vector.
Declaration float Low( vec4 v )
`High`	Return the highest value of the vector.
Declaration float High( vec4 v )
`MulVec4`	Multiply the tri-dimensional part of the vector with another.
Declaration vec4 MulVec4( vec4 v0, vec3 v1 )
`MulMat4`	Multiply the vector by a transformation matrix.
Declaration vec4 MulMat4( vec4 v0, mat4 m )
`ToVec3`	Convert to a 3D vector.
Declaration vec3 ToVec3( vec4 v )
`SetVec3`	Set the `XYZ` part using a 3D vector.
Declaration vec4 SetVec3( vec3 v, float w )
`SetColor`	Assign the vector as a color.
Declaration vec4 SetColor( vec4 color )
`ToQuat`	Convert the vector to a quaternion.
Declaration quat ToQuat( vec4 v )

Quad

A class that handles box operations in 2D.

Variables

Name	Description
`x`	The `X` coordinate of the quad.
Declaration float x
`y`	The `Y` coordinate of the quad.
Declaration float y
`width`	The size of the quad on the `X` axis.
Declaration float width
`height`	The size of the quad on the `Y` axis.
Declaration float height

Functions

Name	Description
`Set`	Set the coordinates of the box.
Declaration quad Set( int x, int y, int width, int height )
`Zero`	Set box values back to zero.
Declaration quad Zero( void )
`Print`	Print the quad coordinates on the console.
Declaration void Print( quad r )
`Equal`	Check for equality between two quads.
Declaration bool Equal( quad r0, quad r1 )
`Hit`	Function that check if an `XY` position hit the box avoiding the edges.
Declaration bool Hit( quad r, int x, int y )
`HitInclusive`	Function that check if an `XY` position hit the box avoiding including the edges.
Declaration bool HitInclusive( quad r, int x, int y )
`Inside`	Helper that check if a quad is in a quad.
Declaration bool Inside( quad r0, quad r1 )
`Overlap`	Check if two quads overlap.
Declaration bool Overlap( quad r0, quad r1 )
`Diff`	Function that calculate the difference between two quads.
Declaration quad Diff( quad r0, quad r1 )

Quat

Quaternion manipulation class.

Variables

Name	Description
`x`	The `X` component of the quaternion.
Declaration float x
`y`	The `Y` component of the vector.
Declaration float y
`z`	The `Z` component of the vector.
Declaration float z
`w`	The `W` component of the vector.
Declaration float w

Functions

Name	Description
`Set`	Set the `XYZW` components of the quaternion.
Declaration quat Set( float x, float y, float z, float w )
`Zero`	Reset the quaternion back to zero.
Declaration quat Zero( void )
`Identity`	Reset the quaternion back to identity.
Declaration quat Identity( void )
`Invert`	Invert the quaternion values.
Declaration quat Invert( quat q )
`Print`	Print the quaternion value on the console.
Declaration void Print( quat q )
`Equal`	Check for quaternion equality.
Declaration bool Equal( quat q0, quat q1 )
`Add`	Adds two quaternions.
Declaration quat Add( quat q0, quat q1 )
`Sub`	Subtracts one quaternion from another.
Declaration quat Sub( quat q0, quat q1 )
`Mulf`	Multiplies a quaternion by a value.
Declaration quat Mulf( quat q, float f )
`Mul`	Multiplies a quaternion by a quaternion.
Declaration quat Mul( quat q0, quat q1 )
`Length`	Return the dot product of the quaternion.
Declaration float Length( quat q )
`Magnitude`	Return the square length of the quaternion.
Declaration float Magnitude( quat q )
`NormalizeFast`	Normalize the quaternion using approximation.
Declaration quat NormalizeFast( quat v )
`Normalize`	Normalize the quaternion.
Declaration quat Normalize( quat v )
`Dot`	Return the dot product of two quaternion.
Declaration float Dot( quat q0, quat q1 )
`MulVec3`	Multiply a 3D vector by a quaternion.
Declaration quat MulVec3( quat q, vec3 v )
`Conjugate`	Invert the quaternion `XYZ` components.
Declaration quat Conjugate( quat q )
`ToEuler`	Convert a quaternion to Euler angles.
Declaration vec3 ToEuler( quat q )
`ToVec4`	Convert the quaternion to a 4D vector.
Declaration vec4 ToVec4( quat q )
`Lerp`	Linearly interpolate from one quaternion to another.
Declaration quat Lerp( quat q0, quat q1, float t )
`Slerp`	Spherically interpolate from one quaternion to another.
Declaration quat Slerp( quat q0, quat q1, float t )
`Rotate`	Rotate a quaternion around a specific axis.
Declaration quat Rotate( float angle, vec3 axis )
`Build`	Calculat the `W` component of the quaternion.
Declaration quat Build( quat q )
`ToMat3`	Convert a quaternion to a 3x3 rotation matrix.
Declaration mat3 ToMat3( quat q )

Mat2

Class to manipulate a 2x2 matrix.

Variables

Name	Description
`r0`	The first row of the matrix.
Declaration vec2 r0
`r1`	The second row of the matrix.
Declaration vec2 r1

Functions

Name	Description
`Set`	Set each element of the matrix.
Declaration mat2 Set( float m00, float m01, float m10, float m11 )
`Zero`	Reset the matrix back to zero.
Declaration mat2 Zero( void )
`Identity`	Reset the matrix back to identity.
Declaration mat2 Identity( void )
`Equal`	Check for matrix equality.
Declaration bool Equal( mat2 m0, mat2 m1 )
`Print`	Print the current matrix values on the console.
Declaration void Print( mat2 m )
`SetRow`	Set a specific row of the matrix.
Declaration mat2 SetRow( mat2 m, vec2 v, unsigned char row_index )

Mat3

Class to manipulate a 3x3 matrix.

Variables

Name	Description
`r0`	The first row of the matrix.
Declaration vec3 r0
`r1`	The second row of the matrix.
Declaration vec3 r1
`r2`	Third row of the matrix.
Declaration vec3 r2

Functions

Name	Description
`Set`	Set each element of the matrix.
Declaration mat3 Set( float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22 )
`Zero`	Reset the matrix back to zero.
Declaration mat3 Zero( void )
`Identity`	Reset the matrix back to identity.
Declaration mat3 Identity( void )
`Print`	Set a specific row of the matrix.
Declaration mat3 SetRow( mat3 m, vec3 v, unsigned char row_index )
`Inverse`	Calculate the inverse a of 3x3 matrix.
Declaration mat3 Inverse( mat3 m )
`Normalize`	Normalize the current matrix.
Declaration mat3 Normalize( mat3 m )
`Mul`	Multiply a 3x3 matrix by another 3x3 matrix.
Declaration mat3 Mul( mat3 m0, mat3 m1 )
`Rotate`	Rotate the current 3x3 matrix by a Euler angle.
Declaration mat3 Rotate( mat3 m, float a, float x, float y, float z )
`SetRot`	Use a Euler angle vector to set the rotation of the matrix.
Declaration mat3 SetRot( mat3 m, vec3 rot )
`SetScl`	Set the scale of a 3x3 matrix.
Declaration mat3 SetScl( mat3 m, vec3 scl )
`Scale`	Scale the matrix using a scale factor for each axis.
Declaration mat3 Scale( mat3 m, float x, float y, float z )
`Transpose`	Transpose the current matrix.
Declaration mat3 Transpose( mat3 m )
`GetRot`	Convert the rotation matrix to a vector of Euler angles.
Declaration vec3 GetRot( mat3 m )
`GetRot`	Convert the rotation matrix to a vector of Euler angles using the previously used angles to get a better approximation of the current angles.
Declaration vec3 GetRot( mat3 m, vec3 prev_eul )
`GetScl`	Retrieve the current scale of the matrix.
Declaration vec3 GetScl( mat3 m )
`GetDir`	Retrieve the direction vector of the matrix.
Declaration vec3 GetDir( mat3 m, vec3 forward )
`ToMat4`	Convert the matrix to a 4x4 transformation matrix.
Declaration mat4 ToMat4( mat3 m, vec4 loc )
`ToQuat`	Convert the matrix to a quaternion.
Declaration quat ToQuat( mat3 m )
`ToQuat2`	Convert the matrix to quaternion using the previous quaternion used to create the matrix to better approximate the current result.
Declaration quat ToQuat( mat3 m, quat prev_quat )
`ToQuatAlt`	Alternate method to convert the matrix to a quaternion.
Declaration quat ToQuatAlt( mat3 m )
`ToQuatAlt2`	Alternative to convert the 3x3 matrix to quaternion using the previous quaternion used to create the matrix to better approximate the current result.
Declaration quat ToQuatAlt2( mat3 m, quat prev_quat )
`ToQuatSafe`	Safeley convert the matrix to a quaternion avoiding possible division by zero.
Declaration quat ToQuatSafe( mat3 m )
`FromNormal`	Generate a 3x3 matrix from a normal vector.
Declaration mat3 FromNormal( vec3 normal )
`Align`	Create a 3x3 matrix from two direction vector.
Declaration mat3 Align( vec3 v0, vec3 v1 )
`ToArray`	Convert the matrix to an array or table (Lua).
Declaration float *ToArray( const mat3 m )

Mat4

Class to manipulate a 4x4 matrix.

Variables

Name	Description
`r0`	The first row of the matrix.
Declaration vec4 r0
`r1`	The second row of the matrix.
Declaration vec4 r1
`r2`	Third row of the matrix.
Declaration vec4 r2
`r3`	Forth row of the matrix.
Declaration vec4 r3

Functions

Name	Description
`Zero`	Set the matrix back to zero.
Declaration mat4 Zero( void )
`Identity`	Set the matrix to identity.
Declaration mat4 Identity( void )
`Bias`	Create a bias matrix usually used for shadow maps and projectors.
Declaration mat4 Bias( void )
`Equal`	Check for matrix equality.
Declaration bool Equal( mat4 m0, mat4 m1 )
`Print`	Print the content of the matrix on the console.
Declaration void Print( mat4 m )
`Inverse`	Calculate the inverse of the current matrix.
Declaration mat4 Inverse( mat4 m )
`SetRow`	Set a specific matrix row.
Declaration mat4 SetRow( mat4 m, vec4 v, unsigned char row_index )
`Set`	Manually set the value of each row of the matrix.
Declaration mat4 Set( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 )
`GetMat3`	Convert the matrix to a 3x3 matrix.
Declaration mat3 GetMat3( mat4 m )
`Normalize`	Normalize a 4x4 matrix.
Declaration mat4 Normalize( mat4 m )
`Mul`	Multiply two 4x4 matrix.
Declaration mat4 Mul( mat4 m0, mat4 m1 )
`MulMat3`	Multiply a the rotational part of 4x4 matrix with a 3x3 matrix.
Declaration mat4 MulMat3( mat4 m0, mat3 m1 )
`Translate`	Multiply the current matrix by a translation matrix.
Declaration mat4 Translate( mat4 m, float x, float y, float z )
`Rotate`	Multiply the current matrix by a rotation matrix.
Declaration mat4 Rotate( mat4 m, float a, float x, float y, float z )
`Scale`	Multiply the current matrix by a general scaling matrix.
Declaration mat4 Scale( mat4 m, float x, float y, float z )
`Transpose`	Tanspose a 4x4 matrix.
Declaration mat4 Transpose( mat4 m )
`Ortho`	Create an orthographic matrix.
Declaration mat4 Ortho( float left, float right, float bottom, float top, float clip_start, float clip_end )
`Perspective`	Create a perspective matrix.
Declaration mat4 Perspective( float fovy, float aspect_ratio, float clip_start, float clip_end )
`GetLoc`	Extract the location of a 4x4 matrix.
Declaration vec3 GetLoc( mat4 m )
`GetRot`	Extract the Euler angle rotation of a 4x4 matrix.
Declaration vec3 GetRot( mat4 m )
`GetScl`	Extract the scale of a 4x4 matrix.
Declaration vec3 GetScl( mat4 m )
`SetLoc`	Set the location of a transformation matrix.
Declaration mat4 SetLoc( mat4 m, vec3 loc )
`SetRot`	Set the Euler angle rotation of a transformation matrix.
Declaration mat4 SetRot( mat4 m, vec3 rot )
`SetQuat`	Set the rotational part of a transformation matrix using a quaternion.
Declaration mat4 SetQuat( mat4 m, quat q )
`SetScl`	Set the scale of a transformation matrix.
Declaration mat4 SetScl( mat4 m, vec3 scl )
`SetLocRotScl`	Create a matrix specifying a location/rotation and scale.
Declaration mat4 SetLocRotScl( vec3 loc, vec3 rot, vec3 scl )
`SetLocQuatScl`	Create a matrix specifying a location/rotation and scale.
Declaration mat4 SetLocQuatScl( vec3 loc, quat rot, vec3 scl )
`SetMat3`	Manually set the rotational part of a 4x4 matrix using a 3x3 matrix.
Declaration mat4 SetMat3( mat4 m0, mat3 m1 )
`GetQuat`	Return the rotational part of a 4x4 using a quaternion.
Declaration quat GetQuat( mat4 m )
`ToMat3`	Convert a 4x4 matrix to a 3x3 matrix.
Declaration mat3 ToMat3( mat4 m )
`Lerp`	Linearly interpolate between one matrix to another.
Declaration mat4 Lerp( mat4 m0, mat4 m1, float v )
`ToArray`	Convert the matrix to an array or table (Lua).
Declaration float *ToArray( const mat4 m )

Clip

A structure to manipulate frustum clipping planes.

Variables

Name	Description
`p0`	Up clipping plane.
Declaration vec4 p0
`p1`	Down clipping plane.
Declaration vec4 p1
`p2`	Left clipping plane.
Declaration vec4 p2
`p3`	Right clipping plane.
Declaration vec4 p3
`p4`	Top clipping plane.
Declaration vec4 p4
`p5`	Bottom clipping plane.
Declaration vec4 p5

Functions

Name	Description
`Build`	Build a frustum out of a view-projection matrix.
Declaration clip Build( mat4 m )
`Point`	Test if a point is inside a frustum.
Declaration bool Point( clip c, vec3 p )
`BSphere`	Test if a bounding sphere intersect with the frustum.
Declaration bool BSphere( clip c, vec3 center, float radius )
`BBox`	Test if a bounding box is intersecting with the frustum.
Declaration bool BBox( clip c, bbox box )
`AABB`	Test if an axis aligned bounding box intersect with the frustum.
Declaration bool AABB( clip c, vec3 center, vec3 size )

BBox

Bounding box manipulation class.

Variables

Name	Description
`p0`	First vertex.
Declaration vec3 p0
`p1`	Second vertex.
Declaration vec3 p1
`p2`	Third vertex.
Declaration vec3 p2
`p3`	Fourth vertex.
Declaration vec3 p3
`p4`	Fifth vertex.
Declaration vec3 p4
`p5`	Sixth vertex.
Declaration vec3 p5
`p6`	Seventh vertex.
Declaration vec3 p6
`p7`	Eight vertex.
Declaration vec3 p5

Functions

Name Description

Set Set the bounding box vertices.

Declaration

bbox Set( float p00, float p01, float p02,
          float p10, float p11, float p12,
          float p20, float p21, float p22,
          float p30, float p31, float p32,
          float p40, float p41, float p42,
          float p50, float p51, float p52,
          float p60, float p61, float p62,
          float p70, float p71, float p72 )

Bez3

Bounding box manipulation class.

Variables

Name	Description
`l`	Left handle.
Declaration vec3 l
`v`	Value.
Declaration vec3 v
`r`	Right handle.
Declaration vec3 r

Functions

Name	Description
`Set`	Manually set the Bezier tripple.
Declaration bez3 Set( float lx, float ly, float vx, float vy, float rx, float ry )
`Equal`	Test for Bezier equality.
Declaration bool Equal( bez3 b0, bez3 b1 )

Hsv

Cylindrical-coordinate representations of points in an RGB color model.

Variables

Name	Description
`h`	Hue.
Declaration float h
`s`	Saturation.
Declaration float s
`v`	Value.
Declaration float v

Functions

Name Description

Set Manually set the hue, saturation and value.

Declaration

hsv Set( float h, float s, float v )

Rect4

A structure that Manages the UVs applied on a quad.

Variables

Name	Description
`uv0`	Bottom left UV.
Declaration vec2 uv0
`uv1`	Bottom right UV.
Declaration vec2 uv1
`uv2`	Top right UV.
Declaration vec2 uv2
`uv3`	Bottom right UV.
Declaration vec2 uv3

Functions

Name Description

Set Manually set the quad UVs.

Declaration

rect4 Set( vec2 uv0, vec2 uv1, vec2 uv2, vec2 uv3 )

Colorspace

Utility function to deal with different color space.

Functions

Name	Description
`HexToRGBA`	Convert from an HTML color representation to RGBA.
Declaration vec4 HexToRGBA( char *hex )
`RGBAToHex`	Convert from RGBA to an HTML color representation.
Declaration char *RGBAToHex( vec4 rgba )
`IndexToRGB`	Convert a 32 bits index to a 24 bits color.
Declaration vec3 IndexToRGB( unsigned int index )
`RGBToIndex`	Convert a 24 bits color to a 32 bits index.
Declaration unsigned int RGBToIndex( unsigned char r, unsigned char g, unsigned char b )
`IndexToRGBA`	Convert a 32 bits index to a color; allowing you to specify the alpha value.
Declaration vec4 IndexToRGBA( unsigned int index, float a )
`Unpack`	Unpack a 32 bits RGBA to a float value.
Declaration float Unpack( vec4 rgba )
`RGBToHSV`	Convert a RGB value to HSV.
Declaration hsv RGBToHSV( vec3 rgb )
`HSVToRGB`	Convert from RGB to HSV.
Declaration vec3 HSVToRGB( hsv h )
`GenRGB`	Randomly generate a RGB value.
Declaration vec3 GenRGB( void )
`GenSRGB`	Randomly generate a smooth RGB value.
Declaration vec3 GenSRGB( void )
`GenRGBA`	Randomly generate a RGB, specifying the alpha.
Declaration vec4 GenRGBA( float alpha )
`GenSRGBA`	Randomly generate a smooth RGB, specifying the alpha.
Declaration vec4 GenSRGBA( float alpha )

Interpolation

Various interpolation routines.

Functions

Name	Description
`Linear`	Linear interpolation.
Declaration float Linear( float y0, float y1, float t )
`Cosine`	Cosine interpolation.
Declaration float Cosine( float y0, float y1, float t )
`Bezier`	Bezier interpolation.
Declaration float Bezier( float y0, float y1, float y2, float y3, float t )
`Cubic`	Cubic Bezier interpolation.
Declaration float Cubic( float y0, float y1, float y2, float y3, float t )
`Catmull`	Catmul interpolation.
Declaration float Catmull( float y0, float y1, float y2, float y3, float t )
`Hermite`	Hermite interpolation.
Declaration float Hermite( float y0, float y1, float y2, float y3, float t, float tension, float bias )