Raylib.Util.Math

Bindings to raymath

These were rewritten in Haskell instead of binding to C. All the functions are pure. This may not be an exact one-to-one mapping to the C code; some of the functions and high-level structures have been changed to be more idiomatic Haskell.

Utility constants

epsilon :: Float

deg2Rad :: Float

rad2Deg :: Float

Float math

clamp

Arguments

:: Float

Lower bound

-> Float

Upper bound

-> Float

Value to clamp

-> Float

Clamp float to range (WARNING: this does not use the same argument order as raymath)

lerp

Arguments

:: Float

Starting value

-> Float

Ending value

-> Float

Lerp amount

-> Float

Calculate linear interpolation between two floats

normalize

Arguments

:: Float

Starting value of range

-> Float

Ending value of range

-> Float

Value to normalize

-> Float

Normalize input value within input range

remap

Arguments

:: Float

Input range start

-> Float

Input range end

-> Float

Output range start

-> Float

Output range end

-> Float

Input value

-> Float

Remap input value within input range to output range

wrap

Arguments

:: Float

Min value

-> Float

Max value

-> Float

Input value

-> Float

Wrap input value from min to max

floatEquals :: Float -> Float -> Bool

Check if two floats are close to equal

Vector math

class Vector a where

Minimal complete definition

asList, fromList, foldlV, foldrV, mapV, zipWithV, zipWithV3, constant

Methods

asList :: a -> [Float]

List representation of a vector

fromList :: [Float] -> a

Vector representation of a list

foldlV :: (b -> Float -> b) -> b -> a -> b

Left fold over a vector

foldrV :: (Float -> b -> b) -> b -> a -> b

Right fold over a vector

mapV :: (Float -> Float) -> a -> a

Map over a vector

zipWithV :: (Float -> Float -> Float) -> a -> a -> a

Equivalent of zipWith over a vector

zipWithV3 :: (Float -> Float -> Float -> Float) -> a -> a -> a -> a

Equivalent of zipWith3 over a vector

(|+|) :: a -> a -> a

Vector-vector addition

(|-|) :: a -> a -> a

Vector-vector subtraction

(|+) :: a -> Float -> a

Vector-scalar addition

(|-) :: a -> Float -> a

Vector-scalar subtraction

(|*|) :: a -> a -> a

Vector-vector multiplication

(|/|) :: a -> a -> a

Vector-vector division

(|*) :: a -> Float -> a

Vector-scalar multiplication

(|/) :: a -> Float -> a

Vector-scalar division

(|.|) :: a -> a -> Float

Vector-vector dot product

zero :: a

Zero vector

one :: a

One vector

constant :: Float -> a

Scalar to vector (all elements are set to the scalar)

vectorSum :: Foldable t => t a -> a

Sum of all vectors in a structure

additiveInverse :: a -> a

Vector additive inverse

multiplicativeInverse :: a -> a

Vector multiplicative inverse

magnitudeSqr :: a -> Float

Squared magnitude of a vector

magnitude :: a -> Float

Vector magnitude

vectorDistanceSqr :: a -> a -> Float

Squared distance between two vectors

vectorDistance :: a -> a -> Float

Distance between two vectors

vectorNormalize :: a -> a

Normalize vector (same direction, magnitude 1)

vectorLerp :: a -> a -> Float -> a

Lerp between two vectors

vectorMoveTowards

Arguments

:: a

Vector to move

-> a

Target vector

-> Float

Max distance to move by

-> a

Move vector towards target

vectorClamp

Arguments

:: a

Vector to clamp

-> a

Lower bound

-> a

Upper bound

-> a

Clamp vector to range

vectorClampValue

Arguments

:: a

Vector to clamp

-> Float

Lower bound

-> Float

Upper bound

-> a

Clamp the magnitude of a vector to a range

vectorMin :: a -> a -> a

Min value for each pair of components

vectorMax :: a -> a -> a

Max value for each pair of components

Instances

Vector Vector2

Defined in Raylib.Util.Math

Methods

asList :: Vector2 -> [Float]

fromList :: [Float] -> Vector2

foldlV :: (b -> Float -> b) -> b -> Vector2 -> b

foldrV :: (Float -> b -> b) -> b -> Vector2 -> b

mapV :: (Float -> Float) -> Vector2 -> Vector2

zipWithV :: (Float -> Float -> Float) -> Vector2 -> Vector2 -> Vector2

zipWithV3 :: (Float -> Float -> Float -> Float) -> Vector2 -> Vector2 -> Vector2 -> Vector2

(|+|) :: Vector2 -> Vector2 -> Vector2

(|-|) :: Vector2 -> Vector2 -> Vector2

(|+) :: Vector2 -> Float -> Vector2

(|-) :: Vector2 -> Float -> Vector2

(|*|) :: Vector2 -> Vector2 -> Vector2

(|/|) :: Vector2 -> Vector2 -> Vector2

(|*) :: Vector2 -> Float -> Vector2

(|/) :: Vector2 -> Float -> Vector2

(|.|) :: Vector2 -> Vector2 -> Float

zero :: Vector2

one :: Vector2

constant :: Float -> Vector2

vectorSum :: Foldable t => t Vector2 -> Vector2

additiveInverse :: Vector2 -> Vector2

multiplicativeInverse :: Vector2 -> Vector2

magnitudeSqr :: Vector2 -> Float

magnitude :: Vector2 -> Float

vectorDistanceSqr :: Vector2 -> Vector2 -> Float

vectorDistance :: Vector2 -> Vector2 -> Float

vectorNormalize :: Vector2 -> Vector2

vectorLerp :: Vector2 -> Vector2 -> Float -> Vector2

vectorMoveTowards :: Vector2 -> Vector2 -> Float -> Vector2

vectorClamp :: Vector2 -> Vector2 -> Vector2 -> Vector2

vectorClampValue :: Vector2 -> Float -> Float -> Vector2

vectorMin :: Vector2 -> Vector2 -> Vector2

vectorMax :: Vector2 -> Vector2 -> Vector2

Vector Vector3

Defined in Raylib.Util.Math

Methods

asList :: Vector3 -> [Float]

fromList :: [Float] -> Vector3

foldlV :: (b -> Float -> b) -> b -> Vector3 -> b

foldrV :: (Float -> b -> b) -> b -> Vector3 -> b

mapV :: (Float -> Float) -> Vector3 -> Vector3

zipWithV :: (Float -> Float -> Float) -> Vector3 -> Vector3 -> Vector3

zipWithV3 :: (Float -> Float -> Float -> Float) -> Vector3 -> Vector3 -> Vector3 -> Vector3

(|+|) :: Vector3 -> Vector3 -> Vector3

(|-|) :: Vector3 -> Vector3 -> Vector3

(|+) :: Vector3 -> Float -> Vector3

(|-) :: Vector3 -> Float -> Vector3

(|*|) :: Vector3 -> Vector3 -> Vector3

(|/|) :: Vector3 -> Vector3 -> Vector3

(|*) :: Vector3 -> Float -> Vector3

(|/) :: Vector3 -> Float -> Vector3

(|.|) :: Vector3 -> Vector3 -> Float

zero :: Vector3

one :: Vector3

constant :: Float -> Vector3

vectorSum :: Foldable t => t Vector3 -> Vector3

additiveInverse :: Vector3 -> Vector3

multiplicativeInverse :: Vector3 -> Vector3

magnitudeSqr :: Vector3 -> Float

magnitude :: Vector3 -> Float

vectorDistanceSqr :: Vector3 -> Vector3 -> Float

vectorDistance :: Vector3 -> Vector3 -> Float

vectorNormalize :: Vector3 -> Vector3

vectorLerp :: Vector3 -> Vector3 -> Float -> Vector3

vectorMoveTowards :: Vector3 -> Vector3 -> Float -> Vector3

vectorClamp :: Vector3 -> Vector3 -> Vector3 -> Vector3

vectorClampValue :: Vector3 -> Float -> Float -> Vector3

vectorMin :: Vector3 -> Vector3 -> Vector3

vectorMax :: Vector3 -> Vector3 -> Vector3

Vector Vector4

Defined in Raylib.Util.Math

Methods

asList :: Vector4 -> [Float]

fromList :: [Float] -> Vector4

foldlV :: (b -> Float -> b) -> b -> Vector4 -> b

foldrV :: (Float -> b -> b) -> b -> Vector4 -> b

mapV :: (Float -> Float) -> Vector4 -> Vector4

zipWithV :: (Float -> Float -> Float) -> Vector4 -> Vector4 -> Vector4

zipWithV3 :: (Float -> Float -> Float -> Float) -> Vector4 -> Vector4 -> Vector4 -> Vector4

(|+|) :: Vector4 -> Vector4 -> Vector4

(|-|) :: Vector4 -> Vector4 -> Vector4

(|+) :: Vector4 -> Float -> Vector4

(|-) :: Vector4 -> Float -> Vector4

(|*|) :: Vector4 -> Vector4 -> Vector4

(|/|) :: Vector4 -> Vector4 -> Vector4

(|*) :: Vector4 -> Float -> Vector4

(|/) :: Vector4 -> Float -> Vector4

(|.|) :: Vector4 -> Vector4 -> Float

zero :: Vector4

one :: Vector4

constant :: Float -> Vector4

vectorSum :: Foldable t => t Vector4 -> Vector4

additiveInverse :: Vector4 -> Vector4

multiplicativeInverse :: Vector4 -> Vector4

magnitudeSqr :: Vector4 -> Float

magnitude :: Vector4 -> Float

vectorDistanceSqr :: Vector4 -> Vector4 -> Float

vectorDistance :: Vector4 -> Vector4 -> Float

vectorNormalize :: Vector4 -> Vector4

vectorLerp :: Vector4 -> Vector4 -> Float -> Vector4

vectorMoveTowards :: Vector4 -> Vector4 -> Float -> Vector4

vectorClamp :: Vector4 -> Vector4 -> Vector4 -> Vector4

vectorClampValue :: Vector4 -> Float -> Float -> Vector4

vectorMin :: Vector4 -> Vector4 -> Vector4

vectorMax :: Vector4 -> Vector4 -> Vector4

Vector2 math

vector2Angle :: Vector2 -> Vector2 -> Float

Angle between two 2D vectors

vector2LineAngle :: Vector2 -> Vector2 -> Float

Angle created by the line between two 2D vectors (parameters must be normalized)

vector2Transform :: Vector2 -> Matrix -> Vector2

Transform a 2D vector by the given matrix

vector2Reflect

Arguments

:: Vector2

Input vector

-> Vector2

Normal vector

-> Vector2

Reflect 2D vector to normal

vector2Rotate :: Vector2 -> Float -> Vector2

Rotate 2D vector by angle

vector2Refract

Arguments

:: Vector2

Normalized direction of the incoming ray

-> Vector2

Normalized normal vector of the interface of two optical media

-> Float

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

-> Vector2

Compute the direction of a refracted ray

Vector3 math

vector3CrossProduct :: Vector3 -> Vector3 -> Vector3

3D vector cross-product

vector3Perpendicular :: Vector3 -> Vector3

Perpendicular to given 3D vector

vector3Angle :: Vector3 -> Vector3 -> Float

Angle between two 3D vectors

vector3OrthoNormalize :: Vector3 -> Vector3 -> (Vector3, Vector3)

Orthonormalize provided vectors. Makes vectors normalized and orthogonal to each other. Gram-Schmidt function implementation.

vector3Transform :: Vector3 -> Matrix -> Vector3

Transform a 3D vector by a matrix

vector3RotateByQuaternion :: Vector3 -> Quaternion -> Vector3

Transform a 3D vector by quaternion rotation

vector3RotateByAxisAngle

Arguments

:: Vector3

Vector to rotate

-> Vector3

Axis to rotate around

-> Float

Angle to rotate by

-> Vector3

Rotate a 3D vector around an axis

vector3CubicHermite

Arguments

:: Vector3

Vector 1

-> Vector3

Tangent for vector 1

-> Vector3

Vector 2

-> Vector3

Tangent for vector 2

-> Float

Interpolation amount

-> Vector3

Cubic hermite interpolation between two vectors and their tangents as described in the GLTF 2.0 specification

vector3Reflect

Arguments

:: Vector3

Input vector

-> Vector3

Normal vector

-> Vector3

Reflect 3D vector to normal

vector3Barycenter

Arguments

:: Vector3

Input point

-> (Vector3, Vector3, Vector3)

Triangle vertices

-> Vector3

Compute barycenter coordinates (u, v, w) for a point with respect to a triangle. NOTE: Assumes the point is on the plane of the triangle.

vector3Unproject

Arguments

:: Vector3

Vector to unproject

-> Matrix

Projection matrix

-> Matrix

View matrix

-> Vector3

Project a Vector3 from screen space into object space

vector3Refract

Arguments

:: Vector3

Normalized direction of the incoming ray

-> Vector3

Normalized normal vector of the interface of two optical media

-> Float

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

-> Vector3

Compute the direction of a refracted ray

Matrix math

matrixToList :: Matrix -> [Float]

Utility function

matrixFromList :: [Float] -> Matrix

Utility function

matrixConstant :: Float -> Matrix

Scalar to matrix (all elements are set to the scalar)

matrixDeterminant :: Matrix -> Float

Compute matrix determinant

matrixTrace :: Matrix -> Float

Trace of a matrix (sum of the values along the diagonal)

matrixTranspose :: Matrix -> Matrix

Transpose a matrix

matrixInvert :: Matrix -> Matrix

Invert a matrix

matrixIdentity :: Matrix

Identity matrix

matrixAdd :: Matrix -> Matrix -> Matrix

Add two matrices

(/+/) :: Matrix -> Matrix -> Matrix

Alias for matrixAdd

matrixSubtract :: Matrix -> Matrix -> Matrix

Subtract two matrices

(/-/) :: Matrix -> Matrix -> Matrix

Alias for matrixSubtract

matrixMultiply :: Matrix -> Matrix -> Matrix

Multiply two matrices (order matters!)

(/*/) :: Matrix -> Matrix -> Matrix

Alias for matrixMultiply

matrixTranslate

Arguments

:: Float

x translation

-> Float

y translation

-> Float

z translation

-> Matrix

Translation matrix

matrixRotate

Arguments

:: Vector3

Axis to rotate around

-> Float

Angle to rotate by

-> Matrix

Axis-angle rotation matrix (angle should be in radians)

matrixRotateX :: Float -> Matrix

x-rotation matrix (angle should be in radians)

matrixRotateY :: Float -> Matrix

y-rotation matrix (angle should be in radians)

matrixRotateZ :: Float -> Matrix

z-rotation matrix (angle should be in radians)

matrixRotateXYZ :: Vector3 -> Matrix

Euler angle xyz rotation matrix (angles should be in radians)

matrixRotateZYX :: Vector3 -> Matrix

Euler angle zyx rotation matrix (angles should be in radians)

matrixScale :: Vector3 -> Matrix

Scaling matrix

matrixFrustum

Arguments

:: Float

Left edge distance

-> Float

Right edge distance

-> Float

Bottom edge distance

-> Float

Top edge distance

-> Float

Near clipping plane distance

-> Float

Far clipping plane distance

-> Matrix

Frustum projection matrix

matrixPerspective

Arguments

:: Float

y-fov angle (should be in radians)

-> Float

Aspect ratio

-> Float

Near clipping plane distance

-> Float

Far clipping plane distance

-> Matrix

Perspective projection matrix

matrixOrtho

Arguments

:: Float

Left edge distance

-> Float

Right edge distance

-> Float

Bottom edge distance

-> Float

Top edge distance

-> Float

Near clipping plane distance

-> Float

Far clipping plane distance

-> Matrix

Orthographic projection matrix

matrixLookAt

Arguments

:: Vector3

Camera position

-> Vector3

Camera target

-> Vector3

World up vector

-> Matrix

Camera look-at matrix (view matrix)

matrixDecompose :: Matrix -> (Vector3, Quaternion, Vector3)

Decompose a transformation matrix into its rotational, translational and scaling components

Quaternion math

quaternionIdentity :: Quaternion

Identity quaternion

quaternionInvert :: Quaternion -> Quaternion

Invert a quaternion

quaternionMultiply :: Quaternion -> Quaternion -> Quaternion

Multiply two quaternions

quaternionNormalize :: Quaternion -> Quaternion

Normalize a quaternion (alias for vectorNormalize)

quaternionLerp

Arguments

:: Quaternion

Lerp start value

-> Quaternion

Lerp end value

-> Float

Lerp amount

-> Quaternion

Lerp between two quaternions (alias for quaternionLerp)

quaternionNLerp

Arguments

:: Quaternion

Lerp start value

-> Quaternion

Lerp end value

-> Float

Lerp amount

-> Quaternion

Slerp-optimized interpolation between two quaternions

quaternionSLerp

Arguments

:: Quaternion

Lerp start value

-> Quaternion

Lerp end value

-> Float

Lerp amount

-> Quaternion

Spherical linear interpolation between two quaternions

quaternionCubicHermiteSpline

Arguments

:: Quaternion

Quaternion 1

-> Quaternion

Out tangent 1

-> Quaternion

Quaternion 2

-> Quaternion

In tangent 2

-> Float

Interpolation amount

-> Quaternion

Quaternion cubic spline interpolation using the Cubic Hermite Spline algorithm as described in the GLTF 2.0 specification

quaternionFromVector3ToVector3 :: Vector3 -> Vector3 -> Quaternion

Quaternion based on the rotation between two vectors

quaternionFromMatrix :: Matrix -> Quaternion

Create a quaternion from a rotation matrix

quaternionToMatrix :: Quaternion -> Matrix

Create a rotation matrix from a quaternion

quaternionFromAxisAngle

Arguments

:: Vector3

Rotation axis

-> Float

Angle in radians

-> Quaternion

Create a quaternion for an angle and axis

quaternionToAxisAngle :: Quaternion -> (Vector3, Float)

Convert a quaternion to axis-angle representation

quaternionFromEuler

Arguments

:: Float

Pitch

-> Float

Yaw

-> Float

Roll

-> Quaternion

Create a quaternion from Euler angles (ZYX rotation order, angles should be in radians)

quaternionToEuler :: Quaternion -> Vector3

Convert a quaternion to Euler angle representation (Vector3 roll pitch yaw, all angles in radians)

quaternionTransform :: Quaternion -> Matrix -> Quaternion

Transform a quaternion given a transformation matrix