core/math/linalg

linalg

Types

Euler_Angle_Order :: enum int {
	// Tait-Bryan
	XYZ = 0,
	XZY = 1,
	YXZ = 2,
	YZX = 3,
	ZXY = 4,
	ZYX = 5,
	// Proper Euler
	XYX = 6,
	XZX = 7,
	YXY = 8,
	YZY = 9,
	ZXZ = 10,
	ZYZ = 11,
}

Source

Matrix1f16 :: Matrix1x1f16Source

Matrix1f32 :: Matrix1x1f32Source

Matrix1f64 :: Matrix1x1f64Source

Matrix1x1f16 :: matrix[1, 1]f16Source

Matrix1x1f32 :: matrix[1, 1]f32Source

Matrix1x1f64 :: matrix[1, 1]f64Source

Matrix1x2f16 :: matrix[1, 2]f16Source

Matrix1x2f32 :: matrix[1, 2]f32Source

Matrix1x2f64 :: matrix[1, 2]f64Source

Matrix1x3f16 :: matrix[1, 3]f16Source

Matrix1x3f32 :: matrix[1, 3]f32Source

Matrix1x3f64 :: matrix[1, 3]f64Source

Matrix1x4f16 :: matrix[1, 4]f16Source

Matrix1x4f32 :: matrix[1, 4]f32Source

Matrix1x4f64 :: matrix[1, 4]f64Source

Matrix2f16 :: Matrix2x2f16Source

Matrix2f32 :: Matrix2x2f32Source

Matrix2f64 :: Matrix2x2f64Source

Matrix2x1f16 :: matrix[2, 1]f16Source

Matrix2x1f32 :: matrix[2, 1]f32Source

Matrix2x1f64 :: matrix[2, 1]f64Source

Matrix2x2f16 :: matrix[2, 2]f16Source

Matrix2x2f32 :: matrix[2, 2]f32Source

Matrix2x2f64 :: matrix[2, 2]f64Source

Matrix2x3f16 :: matrix[2, 3]f16Source

Matrix2x3f32 :: matrix[2, 3]f32Source

Matrix2x3f64 :: matrix[2, 3]f64Source

Matrix2x4f16 :: matrix[2, 4]f16Source

Matrix2x4f32 :: matrix[2, 4]f32Source

Matrix2x4f64 :: matrix[2, 4]f64Source

Matrix3f16 :: Matrix3x3f16Source

Matrix3f32 :: Matrix3x3f32Source

Matrix3f64 :: Matrix3x3f64Source

Matrix3x1f16 :: matrix[3, 1]f16Source

Matrix3x1f32 :: matrix[3, 1]f32Source

Matrix3x1f64 :: matrix[3, 1]f64Source

Matrix3x2f16 :: matrix[3, 2]f16Source

Matrix3x2f32 :: matrix[3, 2]f32Source

Matrix3x2f64 :: matrix[3, 2]f64Source

Matrix3x3f16 :: matrix[3, 3]f16Source

Matrix3x3f32 :: matrix[3, 3]f32Source

Matrix3x3f64 :: matrix[3, 3]f64Source

Matrix3x4f16 :: matrix[3, 4]f16Source

Matrix3x4f32 :: matrix[3, 4]f32Source

Matrix3x4f64 :: matrix[3, 4]f64Source

Matrix4f16 :: Matrix4x4f16Source

Matrix4f32 :: Matrix4x4f32Source

Matrix4f64 :: Matrix4x4f64Source

Matrix4x1f16 :: matrix[4, 1]f16Source

Matrix4x1f32 :: matrix[4, 1]f32Source

Matrix4x1f64 :: matrix[4, 1]f64Source

Matrix4x2f16 :: matrix[4, 2]f16Source

Matrix4x2f32 :: matrix[4, 2]f32Source

Matrix4x2f64 :: matrix[4, 2]f64Source

Matrix4x3f16 :: matrix[4, 3]f16Source

Matrix4x3f32 :: matrix[4, 3]f32Source

Matrix4x3f64 :: matrix[4, 3]f64Source

Matrix4x4f16 :: matrix[4, 4]f16Source

Matrix4x4f32 :: matrix[4, 4]f32Source

Matrix4x4f64 :: matrix[4, 4]f64Source

Quaternionf16 :: quaternion64Source

Quaternionf32 :: quaternion128Source

Quaternionf64 :: quaternion256Source

Scalar_Components :: enum u8 {
	x = 0,
	r = 0,
}

Source

Vector2_Components :: enum u8 {
	x = 0,
	y = 1,
	r = 0,
	g = 1,
}

Source

Vector2f16 :: [2]f16Source

Vector2f32 :: [2]f32Source

Vector2f64 :: [2]f64Source

Vector3_Components :: enum u8 {
	x = 0,
	y = 1,
	z = 2,
	r = 0,
	g = 1,
	b = 2,
}

Source

Vector3f16 :: [3]f16Source

Vector3f32 :: [3]f32Source

Vector3f64 :: [3]f64Source

Vector4_Components :: enum u8 {
	x = 0,
	y = 1,
	z = 2,
	w = 3,
	r = 0,
	g = 1,
	b = 2,
	a = 3,
}

Source

Vector4f16 :: [4]f16Source

Vector4f32 :: [4]f32Source

Vector4f64 :: [4]f64Source

Constants

DEG_PER_RAD :: _ = 360.0/TAUSource

E :: 2.71828182845904523536Source

F16_EPSILON :: 1e-3Source

F32_EPSILON :: 1e-7Source

F64_EPSILON :: 1e-15Source

LN10 :: 2.30258509299404568401799145468436421Source

LN2 :: 0.693147180559945309417232121458176568Source

MATRIX1F16_IDENTITY :: matrix[1, 1]f16 = Matrix1f16(1)Source

MATRIX1F32_IDENTITY :: matrix[1, 1]f32 = Matrix1f32(1)Source

MATRIX1F64_IDENTITY :: matrix[1, 1]f64 = Matrix1f64(1)Source

MATRIX2F16_IDENTITY :: matrix[2, 2]f16 = Matrix2f16(1)Source

MATRIX2F32_IDENTITY :: matrix[2, 2]f32 = Matrix2f32(1)Source

MATRIX2F64_IDENTITY :: matrix[2, 2]f64 = Matrix2f64(1)Source

MATRIX3F16_IDENTITY :: matrix[3, 3]f16 = Matrix3f16(1)Source

MATRIX3F32_IDENTITY :: matrix[3, 3]f32 = Matrix3f32(1)Source

MATRIX3F64_IDENTITY :: matrix[3, 3]f64 = Matrix3f64(1)Source

MATRIX4F16_IDENTITY :: matrix[4, 4]f16 = Matrix4f16(1)Source

MATRIX4F32_IDENTITY :: matrix[4, 4]f32 = Matrix4f32(1)Source

MATRIX4F64_IDENTITY :: matrix[4, 4]f64 = Matrix4f64(1)Source

MAX_F32_PRECISION :: 8Source

Maximum number of meaningful digits after the decimal point for 'f32'

MAX_F64_PRECISION :: 16Source

Maximum number of meaningful digits after the decimal point for 'f64'

PI :: 3.14159265358979323846264338327950288Source

QUATERNIONF16_IDENTITY :: quaternion64 = Quaternionf16(1)Source

QUATERNIONF32_IDENTITY :: quaternion128 = Quaternionf32(1)Source

QUATERNIONF64_IDENTITY :: quaternion256 = Quaternionf64(1)Source

RAD_PER_DEG :: _ = TAU/360.0Source

SQRT_FIVE :: 2.23606797749978969640917366873127623Source

SQRT_THREE :: 1.73205080756887729352744634150587236Source

SQRT_TWO :: 1.41421356237309504880168872420969808Source

TAU :: 6.28318530717958647692528676655900576Source

Generic

VECTOR3F16_X_AXIS :: Vector3f16 = Vector3f16{1, 0, 0}Source

VECTOR3F16_Y_AXIS :: Vector3f16 = Vector3f16{0, 1, 0}Source

VECTOR3F16_Z_AXIS :: Vector3f16 = Vector3f16{0, 0, 1}Source

VECTOR3F32_X_AXIS :: Vector3f32 = Vector3f32{1, 0, 0}Source

VECTOR3F32_Y_AXIS :: Vector3f32 = Vector3f32{0, 1, 0}Source

VECTOR3F32_Z_AXIS :: Vector3f32 = Vector3f32{0, 0, 1}Source

VECTOR3F64_X_AXIS :: Vector3f64 = Vector3f64{1, 0, 0}Source

VECTOR3F64_Y_AXIS :: Vector3f64 = Vector3f64{0, 1, 0}Source

VECTOR3F64_Z_AXIS :: Vector3f64 = Vector3f64{0, 0, 1}Source

e :: ESource

hadamard_product :: intrinsics.hadamard_productSource

inner_product :: dotSource

matrix_flatten :: intrinsics.matrix_flattenSource

outer_product :: intrinsics.outer_productSource

transpose :: intrinsics.transposeSource

π :: PISource

τ :: TAUSource

Procedures

704

_from_simd4 :: proc(T: typeid, a) -> (T)Source

_to_simd4 :: proc(a: T) -> (out)Source

abs :: proc(a: T) -> (out: T)Source

acos :: proc(x: T) -> (out: T)Source

all :: proc(x: A) -> (out: bool)Source

angle_axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> (angle: f16, axis: Vector3f16)Source

angle_axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> (angle: f32, axis: Vector3f32)Source

angle_axis_from_quaternion_f64 :: proc(q: Quaternionf64) -> (angle: f64, axis: Vector3f64)Source

angle_from_quaternion_f16 :: proc(q: Quaternionf16) -> (f16)Source

angle_from_quaternion_f32 :: proc(q: Quaternionf32) -> (f32)Source

angle_from_quaternion_f64 :: proc(q: Quaternionf64) -> (f64)Source

any :: proc(x: A) -> (out: bool)Source

array_cast :: proc(v: A, Elem_Type: typeid) -> ([N]Elem_Type)Source

asin :: proc(x: T) -> (out: T)Source

atan :: proc(x: T) -> (out: T)Source

atan2 :: proc(y: T, x: T) -> (out: T)Source

axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> (Vector3f16)Source

axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> (Vector3f32)Source

axis_from_quaternion_f64 :: proc(q: Quaternionf64) -> (Vector3f64)Source

catmull_rom :: proc(v1: T, v2: T, v3: T, v4: T, s: E) -> (T)Source

ceil :: proc(x: T) -> (out: T)Source

clamp :: proc(x: T, a: T, b: T) -> (out: T)Source

clamp_length :: proc(v: T, a: E) -> (T)Source

classify_array :: proc(x: A) -> (out: [N]math.Float_Class)Source

classify_single :: proc(x: T) -> (math.Float_Class)Source

cos :: proc(x: T) -> (out: T)Source

cubic :: proc(v1: T, v2: T, v3: T, v4: T, s: E) -> (T)Source

distance :: proc(p0: V, p1: V) -> (E)Source

equal_array :: proc(x: A, y: A) -> (out: [N]bool)Source

equal_single :: proc(x: T, y: T) -> (out: bool)Source

euclidean_from_polar_f16 :: proc(polar: Vector2f16) -> (Vector3f16)Source

euclidean_from_polar_f32 :: proc(polar: Vector2f32) -> (Vector3f32)Source

euclidean_from_polar_f64 :: proc(polar: Vector2f64) -> (Vector3f64)Source

euler_angles_from_matrix3_f16 :: proc(m: Matrix3f16, order: Euler_Angle_Order) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_from_matrix3_f32 :: proc(m: Matrix3f32, order: Euler_Angle_Order) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_from_matrix3_f64 :: proc(m: Matrix3f64, order: Euler_Angle_Order) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_from_matrix4_f16 :: proc(m: Matrix4f16, order: Euler_Angle_Order) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_from_matrix4_f32 :: proc(m: Matrix4f32, order: Euler_Angle_Order) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_from_matrix4_f64 :: proc(m: Matrix4f64, order: Euler_Angle_Order) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_from_quaternion_f16 :: proc(m: Quaternionf16, order: Euler_Angle_Order) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_from_quaternion_f32 :: proc(m: Quaternionf32, order: Euler_Angle_Order) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_from_quaternion_f64 :: proc(m: Quaternionf64, order: Euler_Angle_Order) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xyx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xyz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xzx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_xzy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_xzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_xzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yxz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yzx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_yzy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_yzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_yzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zxz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zyx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1: f64, t2: f64, t3: f64)Source

euler_angles_zyz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1: f16, t2: f16, t3: f16)Source

euler_angles_zyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1: f32, t2: f32, t3: f32)Source

euler_angles_zyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1: f64, t2: f64, t3: f64)Source

exp :: proc(x: T) -> (out: T)Source

exp10 :: proc(x: T) -> (out: T)Source

exp2 :: proc(x: T) -> (out: T)Source

face_forward :: proc(N: T, I: T, N_ref: T) -> (out: T)Source

floor :: proc(x: T) -> (out: T)Source

fract :: proc(x: T) -> (T)Source

greater_than_array :: proc(x: A, y: A) -> (out: [N]bool)Source

greater_than_equal_array :: proc(x: A, y: A) -> (out: [N]bool)Source

greater_than_equal_single :: proc(x: T, y: T) -> (out: bool)Source

greater_than_single :: proc(x: T, y: T) -> (out: bool)Source

hermite :: proc(v1: T, t1: T, v2: T, t2: T, s: E) -> (T)Source

hermitian_adjoint :: proc(m) -> (M)Source

identity_array_based_matrix :: proc(T: typeid) -> (m: T)Source

identity_matrix :: proc(T: typeid) -> (T)Source

inverse_sqrt :: proc(x: T) -> (out: T)Source

is_inf_array :: proc(x: A) -> (out: [N]bool)Source

is_inf_single :: proc(x: T) -> (bool)Source

is_nan_array :: proc(x: A) -> (out: [N]bool)Source

is_nan_single :: proc(x: T) -> (bool)Source

lerp :: proc(a: T, b: T, t: T) -> (out: T)Source

less_than_array :: proc(x: A, y: A) -> (out: [N]bool)Source

less_than_equal_array :: proc(x: A, y: A) -> (out: [N]bool)Source

less_than_equal_single :: proc(x: T, y: T) -> (out: bool)Source

less_than_single :: proc(x: T, y: T) -> (out: bool)Source

ln :: proc(x: T) -> (out: T)Source

log :: proc(x: T, b: T) -> (out: T)Source

log10 :: proc(x: T) -> (out: T)Source

log2 :: proc(x: T) -> (out: T)Source

matrix1x1_adjugate :: proc(x: M) -> (y: M)Source

matrix1x1_cofactor :: proc(x: M) -> (y: M)Source

matrix1x1_determinant :: proc(m: M) -> (det: T)Source

matrix1x1_inverse :: proc(x: M) -> (y: M)Source

matrix1x1_inverse_transpose :: proc(x: M) -> (y: M)Source

matrix2_adjoint_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16)Source

matrix2_adjoint_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32)Source

matrix2_adjoint_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64)Source

matrix2_determinant_f16 :: proc(m: Matrix2f16) -> (f16)Source

matrix2_determinant_f32 :: proc(m: Matrix2f32) -> (f32)Source

matrix2_determinant_f64 :: proc(m: Matrix2f64) -> (f64)Source

matrix2_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix2f16)Source

matrix2_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix2f32)Source

matrix2_from_matrix3_f64 :: proc(m: Matrix3f64) -> (r: Matrix2f64)Source

matrix2_from_matrix4_f16 :: proc(m: Matrix4f16) -> (r: Matrix2f16)Source

matrix2_from_matrix4_f32 :: proc(m: Matrix4f32) -> (r: Matrix2f32)Source

matrix2_from_matrix4_f64 :: proc(m: Matrix4f64) -> (r: Matrix2f64)Source

matrix2_from_scalar_f16 :: proc(f: f16) -> (m: Matrix2f16)Source

matrix2_from_scalar_f32 :: proc(f: f32) -> (m: Matrix2f32)Source

matrix2_from_scalar_f64 :: proc(f: f64) -> (m: Matrix2f64)Source

matrix2_inverse_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16)Source

matrix2_inverse_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32)Source

matrix2_inverse_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64)Source

matrix2_inverse_transpose_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16)Source

matrix2_inverse_transpose_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32)Source

matrix2_inverse_transpose_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64)Source

matrix2_orthonormalize_f16 :: proc(m: Matrix2f16) -> (r: Matrix2f16)Source

matrix2_orthonormalize_f32 :: proc(m: Matrix2f32) -> (r: Matrix2f32)Source

matrix2_orthonormalize_f64 :: proc(m: Matrix2f64) -> (r: Matrix2f64)Source

matrix2_rotate_f16 :: proc(angle_radians: f16) -> (Matrix2f16)Source

matrix2_rotate_f32 :: proc(angle_radians: f32) -> (Matrix2f32)Source

matrix2_rotate_f64 :: proc(angle_radians: f64) -> (Matrix2f64)Source

matrix2x2_adjugate :: proc(x: M) -> (y: M)Source

matrix2x2_cofactor :: proc(x: M) -> (y: M)Source

matrix2x2_determinant :: proc(m: M) -> (det: T)Source

matrix2x2_inverse :: proc(x: M) -> (y: M)Source

matrix2x2_inverse_transpose :: proc(x: M) -> (y: M)Source

matrix3_adjoint_f16 :: proc(m: Matrix3f16) -> (adjoint: Matrix3f16)Source

matrix3_adjoint_f32 :: proc(m: Matrix3f32) -> (adjoint: Matrix3f32)Source

matrix3_adjoint_f64 :: proc(m: Matrix3f64) -> (adjoint: Matrix3f64)Source

matrix3_determinant_f16 :: proc(m: Matrix3f16) -> (f16)Source

matrix3_determinant_f32 :: proc(m: Matrix3f32) -> (f32)Source

matrix3_determinant_f64 :: proc(m: Matrix3f64) -> (f64)Source

matrix3_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: f16) -> (m: Matrix3f16)Source

matrix3_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: f32) -> (m: Matrix3f32)Source

matrix3_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: f64) -> (m: Matrix3f64)Source

matrix3_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: f16) -> (m: Matrix3f16)Source

matrix3_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: f32) -> (m: Matrix3f32)Source

matrix3_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: f64) -> (m: Matrix3f64)Source

matrix3_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: f16) -> (m: Matrix3f16)Source

matrix3_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: f32) -> (m: Matrix3f32)Source

matrix3_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_f16 :: proc(t1: f16, t2: f16, t3: f16, order: Euler_Angle_Order) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_f32 :: proc(t1: f32, t2: f32, t3: f32, order: Euler_Angle_Order) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_f64 :: proc(t1: f64, t2: f64, t3: f64, order: Euler_Angle_Order) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_xy_f16 :: proc(angle_x: f16, angle_y: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_xy_f32 :: proc(angle_x: f32, angle_y: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_xy_f64 :: proc(angle_x: f64, angle_y: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_xyx_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_xyx_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_xyx_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_xyz_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_xyz_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_xyz_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_xz_f16 :: proc(angle_x: f16, angle_z: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_xz_f32 :: proc(angle_x: f32, angle_z: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_xz_f64 :: proc(angle_x: f64, angle_z: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_xzx_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_xzx_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_xzx_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_xzy_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_xzy_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_xzy_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_yx_f16 :: proc(angle_y: f16, angle_x: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_yx_f32 :: proc(angle_y: f32, angle_x: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_yx_f64 :: proc(angle_y: f64, angle_x: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_yxy_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_yxy_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_yxy_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_yxz_f16 :: proc(yaw: f16, pitch: f16, roll: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_yxz_f32 :: proc(yaw: f32, pitch: f32, roll: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_yxz_f64 :: proc(yaw: f64, pitch: f64, roll: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_yz_f16 :: proc(angle_y: f16, angle_z: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_yz_f32 :: proc(angle_y: f32, angle_z: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_yz_f64 :: proc(angle_y: f64, angle_z: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_yzx_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_yzx_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_yzx_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_yzy_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_yzy_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_yzy_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_zx_f16 :: proc(angle_z: f16, angle_x: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_zx_f32 :: proc(angle_z: f32, angle_x: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_zx_f64 :: proc(angle_z: f64, angle_x: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_zxy_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_zxy_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_zxy_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_zxz_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_zxz_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_zxz_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_zy_f16 :: proc(angle_z: f16, angle_y: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_zy_f32 :: proc(angle_z: f32, angle_y: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_zy_f64 :: proc(angle_z: f64, angle_y: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_zyx_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_zyx_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_zyx_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_euler_angles_zyz_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix3f16)Source

matrix3_from_euler_angles_zyz_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix3f32)Source

matrix3_from_euler_angles_zyz_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix3f64)Source

matrix3_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix3f16)Source

matrix3_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix3f32)Source

matrix3_from_matrix2_f64 :: proc(m: Matrix2f64) -> (r: Matrix3f64)Source

matrix3_from_matrix4_f16 :: proc(m: Matrix4f16) -> (r: Matrix3f16)Source

matrix3_from_matrix4_f32 :: proc(m: Matrix4f32) -> (r: Matrix3f32)Source

matrix3_from_matrix4_f64 :: proc(m: Matrix4f64) -> (r: Matrix3f64)Source

matrix3_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix3f16)Source

matrix3_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix3f32)Source

matrix3_from_quaternion_f64 :: proc(q: Quaternionf64) -> (m: Matrix3f64)Source

matrix3_from_scalar_f16 :: proc(f: f16) -> (m: Matrix3f16)Source

matrix3_from_scalar_f32 :: proc(f: f32) -> (m: Matrix3f32)Source

matrix3_from_scalar_f64 :: proc(f: f64) -> (m: Matrix3f64)Source

matrix3_from_yaw_pitch_roll_f16 :: proc(yaw: f16, pitch: f16, roll: f16) -> (m: Matrix3f16)Source

matrix3_from_yaw_pitch_roll_f32 :: proc(yaw: f32, pitch: f32, roll: f32) -> (m: Matrix3f32)Source

matrix3_from_yaw_pitch_roll_f64 :: proc(yaw: f64, pitch: f64, roll: f64) -> (m: Matrix3f64)Source

matrix3_gram_schmidt :: proc(m: matrix[3, 3]E, A: int, B: int, C: int) -> (r: matrix[3, 3]E)Source

matrix3_inverse_f16 :: proc(m: Matrix3f16) -> (Matrix3f16)Source

matrix3_inverse_f32 :: proc(m: Matrix3f32) -> (Matrix3f32)Source

matrix3_inverse_f64 :: proc(m: Matrix3f64) -> (Matrix3f64)Source

matrix3_inverse_transpose_f16 :: proc(m: Matrix3f16) -> (p: Matrix3f16)Source

matrix3_inverse_transpose_f32 :: proc(m: Matrix3f32) -> (p: Matrix3f32)Source

matrix3_inverse_transpose_f64 :: proc(m: Matrix3f64) -> (p: Matrix3f64)Source

matrix3_look_at_f16 :: proc(eye: Vector3f16, centre: Vector3f16, up: Vector3f16) -> (Matrix3f16)Source

matrix3_look_at_f32 :: proc(eye: Vector3f32, centre: Vector3f32, up: Vector3f32) -> (Matrix3f32)Source

matrix3_look_at_f64 :: proc(eye: Vector3f64, centre: Vector3f64, up: Vector3f64) -> (Matrix3f64)Source

matrix3_orthonormalize_f16 :: proc(m: Matrix3f16) -> (Matrix3f16)Source

matrix3_orthonormalize_f32 :: proc(m: Matrix3f32) -> (Matrix3f32)Source

matrix3_orthonormalize_f64 :: proc(m: Matrix3f64) -> (Matrix3f64)Source

matrix3_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> (rot: Matrix3f16)Source

matrix3_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> (rot: Matrix3f32)Source

matrix3_rotate_f64 :: proc(angle_radians: f64, v: Vector3f64) -> (rot: Matrix3f64)Source

matrix3_scale_f16 :: proc(s: Vector3f16) -> (m: Matrix3f16)Source

matrix3_scale_f32 :: proc(s: Vector3f32) -> (m: Matrix3f32)Source

matrix3_scale_f64 :: proc(s: Vector3f64) -> (m: Matrix3f64)Source

matrix3x3_adjugate :: proc(m: M) -> (y: M)Source

matrix3x3_cofactor :: proc(m: M) -> (y: M)Source

matrix3x3_determinant :: proc(m: M) -> (det: T)Source

matrix3x3_inverse :: proc(x: M) -> (y: M)Source

matrix3x3_inverse_transpose :: proc(x: M) -> (y: M)Source

matrix4_adjoint_f16 :: proc(m: Matrix4f16) -> (adjoint: Matrix4f16)Source

matrix4_adjoint_f32 :: proc(m: Matrix4f32) -> (adjoint: Matrix4f32)Source

matrix4_adjoint_f64 :: proc(m: Matrix4f64) -> (adjoint: Matrix4f64)Source

matrix4_cofactor_f16 :: proc(m: Matrix4f16, c: int, r: int) -> (f16)Source

matrix4_cofactor_f32 :: proc(m: Matrix4f32, c: int, r: int) -> (f32)Source

matrix4_cofactor_f64 :: proc(m: Matrix4f64, c: int, r: int) -> (f64)Source

matrix4_determinant_f16 :: proc(m: Matrix4f16) -> (determinant: f16)Source

matrix4_determinant_f32 :: proc(m: Matrix4f32) -> (determinant: f32)Source

matrix4_determinant_f64 :: proc(m: Matrix4f64) -> (determinant: f64)Source

matrix4_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: f16) -> (m: Matrix4f16)Source

matrix4_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: f32) -> (m: Matrix4f32)Source

matrix4_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: f64) -> (m: Matrix4f64)Source

matrix4_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: f16) -> (m: Matrix4f16)Source

matrix4_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: f32) -> (m: Matrix4f32)Source

matrix4_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: f64) -> (m: Matrix4f64)Source

matrix4_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: f16) -> (m: Matrix4f16)Source

matrix4_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: f32) -> (m: Matrix4f32)Source

matrix4_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_f16 :: proc(t1: f16, t2: f16, t3: f16, order: Euler_Angle_Order) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_f32 :: proc(t1: f32, t2: f32, t3: f32, order: Euler_Angle_Order) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_f64 :: proc(t1: f64, t2: f64, t3: f64, order: Euler_Angle_Order) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_xy_f16 :: proc(angle_x: f16, angle_y: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_xy_f32 :: proc(angle_x: f32, angle_y: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_xy_f64 :: proc(angle_x: f64, angle_y: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_xyx_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_xyx_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_xyx_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_xyz_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_xyz_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_xyz_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_xz_f16 :: proc(angle_x: f16, angle_z: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_xz_f32 :: proc(angle_x: f32, angle_z: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_xz_f64 :: proc(angle_x: f64, angle_z: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_xzx_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_xzx_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_xzx_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_xzy_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_xzy_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_xzy_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_yx_f16 :: proc(angle_y: f16, angle_x: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_yx_f32 :: proc(angle_y: f32, angle_x: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_yx_f64 :: proc(angle_y: f64, angle_x: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_yxy_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_yxy_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_yxy_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_yxz_f16 :: proc(yaw: f16, pitch: f16, roll: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_yxz_f32 :: proc(yaw: f32, pitch: f32, roll: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_yxz_f64 :: proc(yaw: f64, pitch: f64, roll: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_yz_f16 :: proc(angle_y: f16, angle_z: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_yz_f32 :: proc(angle_y: f32, angle_z: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_yz_f64 :: proc(angle_y: f64, angle_z: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_yzx_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_yzx_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_yzx_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_yzy_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_yzy_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_yzy_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_zx_f16 :: proc(angle_z: f16, angle_x: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_zx_f32 :: proc(angle_z: f32, angle_x: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_zx_f64 :: proc(angle_z: f64, angle_x: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_zxy_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_zxy_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_zxy_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_zxz_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_zxz_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_zxz_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_zy_f16 :: proc(angle_z: f16, angle_y: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_zy_f32 :: proc(angle_z: f32, angle_y: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_zy_f64 :: proc(angle_z: f64, angle_y: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_zyx_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_zyx_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_zyx_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_euler_angles_zyz_f16 :: proc(t1: f16, t2: f16, t3: f16) -> (m: Matrix4f16)Source

matrix4_from_euler_angles_zyz_f32 :: proc(t1: f32, t2: f32, t3: f32) -> (m: Matrix4f32)Source

matrix4_from_euler_angles_zyz_f64 :: proc(t1: f64, t2: f64, t3: f64) -> (m: Matrix4f64)Source

matrix4_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix4f16)Source

matrix4_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix4f32)Source

matrix4_from_matrix2_f64 :: proc(m: Matrix2f64) -> (r: Matrix4f64)Source

matrix4_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix4f16)Source

matrix4_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix4f32)Source

matrix4_from_matrix3_f64 :: proc(m: Matrix3f64) -> (r: Matrix4f64)Source

matrix4_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix4f16)Source

matrix4_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix4f32)Source

matrix4_from_quaternion_f64 :: proc(q: Quaternionf64) -> (m: Matrix4f64)Source

matrix4_from_scalar_f16 :: proc(f: f16) -> (m: Matrix4f16)Source

matrix4_from_scalar_f32 :: proc(f: f32) -> (m: Matrix4f32)Source

matrix4_from_scalar_f64 :: proc(f: f64) -> (m: Matrix4f64)Source

matrix4_from_trs_f16 :: proc(t: Vector3f16, r: Quaternionf16, s: Vector3f16) -> (Matrix4f16)Source

matrix4_from_trs_f32 :: proc(t: Vector3f32, r: Quaternionf32, s: Vector3f32) -> (Matrix4f32)Source

matrix4_from_trs_f64 :: proc(t: Vector3f64, r: Quaternionf64, s: Vector3f64) -> (Matrix4f64)Source

matrix4_from_yaw_pitch_roll_f16 :: proc(yaw: f16, pitch: f16, roll: f16) -> (m: Matrix4f16)Source

matrix4_from_yaw_pitch_roll_f32 :: proc(yaw: f32, pitch: f32, roll: f32) -> (m: Matrix4f32)Source

matrix4_from_yaw_pitch_roll_f64 :: proc(yaw: f64, pitch: f64, roll: f64) -> (m: Matrix4f64)Source

matrix4_infinite_perspective_f16 :: proc(fovy: f16, aspect: f16, near: f16, flip_z_axis: untyped boolean = true) -> (m: Matrix4f16)

Source

matrix4_infinite_perspective_f32 :: proc(fovy: f32, aspect: f32, near: f32, flip_z_axis: untyped boolean = true) -> (m: Matrix4f32)

Source

matrix4_infinite_perspective_f64 :: proc(fovy: f64, aspect: f64, near: f64, flip_z_axis: untyped boolean = true) -> (m: Matrix4f64)

Source

matrix4_inverse_f16 :: proc(m: Matrix4f16) -> (Matrix4f16)Source

matrix4_inverse_f32 :: proc(m: Matrix4f32) -> (Matrix4f32)Source

matrix4_inverse_f64 :: proc(m: Matrix4f64) -> (Matrix4f64)Source

matrix4_inverse_transpose_f16 :: proc(m: Matrix4f16) -> (inverse_transpose: Matrix4f16)Source

matrix4_inverse_transpose_f32 :: proc(m: Matrix4f32) -> (inverse_transpose: Matrix4f32)Source

matrix4_inverse_transpose_f64 :: proc(m: Matrix4f64) -> (inverse_transpose: Matrix4f64)Source

matrix4_look_at_f16 :: proc(eye: Vector3f16, centre: Vector3f16, up: Vector3f16, flip_z_axis: untyped boolean = true) -> (m: Matrix4f16)

Source

matrix4_look_at_f32 :: proc(eye: Vector3f32, centre: Vector3f32, up: Vector3f32, flip_z_axis: untyped boolean = true) -> (m: Matrix4f32)

Source

matrix4_look_at_f64 :: proc(eye: Vector3f64, centre: Vector3f64, up: Vector3f64, flip_z_axis: untyped boolean = true) -> (m: Matrix4f64)

Source

matrix4_look_at_from_fru_f16 :: proc(eye: Vector3f16, f: Vector3f16, r: Vector3f16, u: Vector3f16, flip_z_axis: untyped boolean = true) -> (m: Matrix4f16)

Source

matrix4_look_at_from_fru_f32 :: proc(eye: Vector3f32, f: Vector3f32, r: Vector3f32, u: Vector3f32, flip_z_axis: untyped boolean = true) -> (m: Matrix4f32)

Source

matrix4_look_at_from_fru_f64 :: proc(eye: Vector3f64, f: Vector3f64, r: Vector3f64, u: Vector3f64, flip_z_axis: untyped boolean = true) -> (m: Matrix4f64)

Source

matrix4_minor_f16 :: proc(m: Matrix4f16, c: int, r: int) -> (f16)Source

matrix4_minor_f32 :: proc(m: Matrix4f32, c: int, r: int) -> (f32)Source

matrix4_minor_f64 :: proc(m: Matrix4f64, c: int, r: int) -> (f64)Source

matrix4_orientation_f16 :: proc(normal: Vector3f16, up: Vector3f16) -> (Matrix4f16)Source

matrix4_orientation_f32 :: proc(normal: Vector3f32, up: Vector3f32) -> (Matrix4f32)Source

matrix4_orientation_f64 :: proc(normal: Vector3f64, up: Vector3f64) -> (Matrix4f64)Source

matrix4_perspective_f16 :: proc(fovy: f16, aspect: f16, near: f16, far: f16, flip_z_axis: untyped boolean = true) -> (m: Matrix4f16)

Source

matrix4_perspective_f32 :: proc(fovy: f32, aspect: f32, near: f32, far: f32, flip_z_axis: untyped boolean = true) -> (m: Matrix4f32)

Source

matrix4_perspective_f64 :: proc(fovy: f64, aspect: f64, near: f64, far: f64, flip_z_axis: untyped boolean = true) -> (m: Matrix4f64)

Source

matrix4_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> (Matrix4f16)Source

matrix4_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> (Matrix4f32)Source

matrix4_rotate_f64 :: proc(angle_radians: f64, v: Vector3f64) -> (Matrix4f64)Source

matrix4_scale_f16 :: proc(v: Vector3f16) -> (m: Matrix4f16)Source

matrix4_scale_f32 :: proc(v: Vector3f32) -> (m: Matrix4f32)Source

matrix4_scale_f64 :: proc(v: Vector3f64) -> (m: Matrix4f64)Source

matrix4_translate_f16 :: proc(v: Vector3f16) -> (Matrix4f16)Source

matrix4_translate_f32 :: proc(v: Vector3f32) -> (Matrix4f32)Source

matrix4_translate_f64 :: proc(v: Vector3f64) -> (Matrix4f64)Source

matrix4x4_adjugate :: proc(x: M) -> (y: M)Source

matrix4x4_cofactor :: proc(x: M) -> (y: M)Source

matrix4x4_determinant :: proc(m: M) -> (det: T)Source

matrix4x4_inverse :: proc(x: M) -> (y: M)Source

matrix4x4_inverse_transpose :: proc(x: M) -> (y: M)Source

matrix5x5_adjugate :: proc(x: M) -> (y: M)Source

matrix5x5_cofactor :: proc(x: M) -> (y: M)Source

matrix5x5_determinant :: proc(m: M) -> (det: T)Source

matrix5x5_inverse :: proc(x: M) -> (y: M)Source

matrix5x5_inverse_transpose :: proc(x: M) -> (y: M)Source

matrix6x6_adjugate :: proc(x: M) -> (y: M)Source

matrix6x6_cofactor :: proc(x: M) -> (y: M)Source

matrix6x6_determinant :: proc(m: M) -> (det: T)Source

matrix6x6_inverse :: proc(x: M) -> (y: M)Source

matrix6x6_inverse_transpose :: proc(x: M) -> (y: M)Source

matrix7x7_adjugate :: proc(x: M) -> (y: M)Source

matrix7x7_cofactor :: proc(x: M) -> (y: M)Source

matrix7x7_determinant :: proc(m: M) -> (det: T)Source

matrix7x7_inverse :: proc(x: M) -> (y: M)Source

matrix7x7_inverse_transpose :: proc(x: M) -> (y: M)Source

matrix8x8_adjugate :: proc(x: M) -> (y: M)Source

matrix8x8_cofactor :: proc(x: M) -> (y: M)Source

matrix8x8_determinant :: proc(m: M) -> (det: T)Source

matrix8x8_inverse :: proc(x: M) -> (y: M)Source

matrix8x8_inverse_transpose :: proc(x: M) -> (y: M)Source

matrix_adjugate_general :: proc(x) -> (y: M)Source

matrix_cast :: proc(v, Elem_Type: typeid) -> (w)Source

matrix_cofactor_general :: proc(x) -> (y: M)Source

matrix_comp_mul :: proc(a, b) -> (c: M)Source

matrix_determinant_generic :: proc(a) -> (T)Source

matrix_inverse_gauss_jordan :: proc(A) -> (b: M, non_singular: bool)Source

matrix_inverse_lu_decomposition :: proc(A) -> (b: M, non_singular: bool)Source

matrix_minor :: proc(m, any_int, column: int) -> (minor: T)Source

matrix_mul :: proc(a, b) -> (c: M)Source

matrix_mul_differ :: proc(a, b) -> (c)Source

matrix_mul_vector :: proc(a, b: B) -> (c: B)Source

matrix_ortho3d_f16 :: proc(
	left:        f16,
	right:       f16,
	bottom:      f16,
	top:         f16,
	near:        f16,
	far:         f16,
	flip_z_axis: untyped boolean = true,
) -> (m: Matrix4f16)

Source

matrix_ortho3d_f32 :: proc(
	left:        f32,
	right:       f32,
	bottom:      f32,
	top:         f32,
	near:        f32,
	far:         f32,
	flip_z_axis: untyped boolean = true,
) -> (m: Matrix4f32)

Source

matrix_ortho3d_f64 :: proc(
	left:        f64,
	right:       f64,
	bottom:      f64,
	top:         f64,
	near:        f64,
	far:         f64,
	flip_z_axis: untyped boolean = true,
) -> (m: Matrix4f64)

Source

matrix_pseudo_inverse :: proc(A) -> (B, not_singular: bool)Source

Moore-Penrose Pseudo-Inverse

matrix_to_ptr :: proc(m) -> (^E)Source

max_double :: proc(a: T, b: T) -> (out: T)Source

max_single :: proc(a: T) -> (out: ELEM_TYPE(T))Source

max_triple :: proc(a: T, b: T, c: T) -> (T)Source

min_double :: proc(a: T, b: T) -> (out: T)Source

min_single :: proc(a: T) -> (out: ELEM_TYPE(T))Source

min_triple :: proc(a: T, b: T, c: T) -> (T)Source

mix :: proc(a: T, b: T, t: T) -> (out: T)Source

mod :: proc(x: T, m: T) -> (T)Source

not :: proc(x: A) -> (out: A)Source

not_equal_array :: proc(x: A, y: A) -> (out: [N]bool)Source

not_equal_single :: proc(x: T, y: T) -> (out: bool)Source

pitch_from_quaternion_f16 :: proc(q: Quaternionf16) -> (f16)Source

pitch_from_quaternion_f32 :: proc(q: Quaternionf32) -> (f32)Source

pitch_from_quaternion_f64 :: proc(q: Quaternionf64) -> (f64)Source

pitch_yaw_roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> (pitch: f16, yaw: f16, roll: f16)Source

pitch_yaw_roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> (pitch: f32, yaw: f32, roll: f32)Source

pitch_yaw_roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> (pitch: f64, yaw: f64, roll: f64)Source

polar_from_euclidean_f16 :: proc(euclidean: Vector3f16) -> (Vector3f16)Source

polar_from_euclidean_f32 :: proc(euclidean: Vector3f32) -> (Vector3f32)Source

polar_from_euclidean_f64 :: proc(euclidean: Vector3f64) -> (Vector3f64)Source

pow :: proc(x: T, e: T) -> (out: T)Source

projection :: proc(x: T, normal: T) -> (T)Source

quaternion128_angle_between :: proc(a: Q, b: Q) -> (f32)Source

quaternion128_dot :: proc(a: T, b: T) -> (c: f32)Source

quaternion128_mul_vector3 :: proc(q: Q, v: V) -> (V)Source

quaternion256_angle_between :: proc(a: Q, b: Q) -> (f64)Source

quaternion256_dot :: proc(a: T, b: T) -> (c: f64)Source

quaternion256_mul_vector3 :: proc(q: Q, v: V) -> (V)Source

quaternion64_angle_between :: proc(a: Q, b: Q) -> (f16)Source

quaternion64_dot :: proc(a: T, b: T) -> (c: f16)Source

quaternion64_mul_vector3 :: proc(q: Q, v: V) -> (V)Source

quaternion_angle_axis_f16 :: proc(angle_radians: f16, axis: Vector3f16) -> (q: Quaternionf16)Source

quaternion_angle_axis_f32 :: proc(angle_radians: f32, axis: Vector3f32) -> (q: Quaternionf32)Source

quaternion_angle_axis_f64 :: proc(angle_radians: f64, axis: Vector3f64) -> (q: Quaternionf64)Source

quaternion_between_two_vector3_f16 :: proc(from: Vector3f16, to: Vector3f16) -> (q: Quaternionf16)Source

quaternion_between_two_vector3_f32 :: proc(from: Vector3f32, to: Vector3f32) -> (q: Quaternionf32)Source

quaternion_between_two_vector3_f64 :: proc(from: Vector3f64, to: Vector3f64) -> (q: Quaternionf64)Source

quaternion_cross :: proc(q1: Q, q2: Q) -> (q3: Q)Source

quaternion_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (q: Quaternionf16)Source

Quaternionf16s

quaternion_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (q: Quaternionf32)Source

Quaternionf32s

quaternion_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (q: Quaternionf64)Source

Quaternionf64s

quaternion_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (q: Quaternionf16)Source

quaternion_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (q: Quaternionf32)Source

quaternion_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (q: Quaternionf64)Source

quaternion_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (q: Quaternionf16)Source

quaternion_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (q: Quaternionf32)Source

quaternion_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (q: Quaternionf64)Source

quaternion_from_euler_angles_f16 :: proc(t1: f16, t2: f16, t3: f16, order: Euler_Angle_Order) -> (Quaternionf16)Source

quaternion_from_euler_angles_f32 :: proc(t1: f32, t2: f32, t3: f32, order: Euler_Angle_Order) -> (Quaternionf32)Source

quaternion_from_euler_angles_f64 :: proc(t1: f64, t2: f64, t3: f64, order: Euler_Angle_Order) -> (Quaternionf64)Source

quaternion_from_forward_and_up_f16 :: proc(forward: Vector3f16, up: Vector3f16) -> (Quaternionf16)Source

quaternion_from_forward_and_up_f32 :: proc(forward: Vector3f32, up: Vector3f32) -> (Quaternionf32)Source

quaternion_from_forward_and_up_f64 :: proc(forward: Vector3f64, up: Vector3f64) -> (Quaternionf64)Source

quaternion_from_matrix3_f16 :: proc(m: Matrix3f16) -> (q: Quaternionf16)Source

quaternion_from_matrix3_f32 :: proc(m: Matrix3f32) -> (q: Quaternionf32)Source

quaternion_from_matrix3_f64 :: proc(m: Matrix3f64) -> (q: Quaternionf64)Source

quaternion_from_matrix4_f16 :: proc(m: Matrix4f16) -> (q: Quaternionf16)Source

quaternion_from_matrix4_f32 :: proc(m: Matrix4f32) -> (q: Quaternionf32)Source

quaternion_from_matrix4_f64 :: proc(m: Matrix4f64) -> (q: Quaternionf64)Source

quaternion_from_pitch_yaw_roll_f16 :: proc(pitch: f16, yaw: f16, roll: f16) -> (Quaternionf16)Source

quaternion_from_pitch_yaw_roll_f32 :: proc(pitch: f32, yaw: f32, roll: f32) -> (Quaternionf32)Source

quaternion_from_pitch_yaw_roll_f64 :: proc(pitch: f64, yaw: f64, roll: f64) -> (Quaternionf64)Source

quaternion_from_scalar_f16 :: proc(f: f16) -> (q: Quaternionf16)Source

quaternion_from_scalar_f32 :: proc(f: f32) -> (q: Quaternionf32)Source

quaternion_from_scalar_f64 :: proc(f: f64) -> (q: Quaternionf64)Source

quaternion_inverse :: proc(q: Q) -> (Q)Source

quaternion_length :: proc(q: Q) -> (Q)Source

quaternion_length2 :: proc(q: Q) -> (Q)Source

quaternion_look_at_f16 :: proc(eye: Vector3f16, centre: Vector3f16, up: Vector3f16) -> (Quaternionf16)Source

quaternion_look_at_f32 :: proc(eye: Vector3f32, centre: Vector3f32, up: Vector3f32) -> (Quaternionf32)Source

quaternion_look_at_f64 :: proc(eye: Vector3f64, centre: Vector3f64, up: Vector3f64) -> (Quaternionf64)Source

quaternion_mul_quaternion :: proc(q1: Q, q2: Q) -> (Q)Source

quaternion_nlerp_f16 :: proc(a: Quaternionf16, b: Quaternionf16, t: f16) -> (c: Quaternionf16)Source

quaternion_nlerp_f32 :: proc(a: Quaternionf32, b: Quaternionf32, t: f32) -> (c: Quaternionf32)Source

quaternion_nlerp_f64 :: proc(a: Quaternionf64, b: Quaternionf64, t: f64) -> (c: Quaternionf64)Source

quaternion_normalize :: proc(q: Q) -> (Q)Source

quaternion_normalize0 :: proc(q: Q) -> (Q)Source

quaternion_slerp_f16 :: proc(x: Quaternionf16, y: Quaternionf16, t: f16) -> (q: Quaternionf16)Source

quaternion_slerp_f32 :: proc(x: Quaternionf32, y: Quaternionf32, t: f32) -> (q: Quaternionf32)Source

quaternion_slerp_f64 :: proc(x: Quaternionf64, y: Quaternionf64, t: f64) -> (q: Quaternionf64)Source

quaternion_squad_f16 :: proc(q1: Quaternionf16, q2: Quaternionf16, s1: Quaternionf16, s2: Quaternionf16, h: f16) -> (Quaternionf16)

Source

quaternion_squad_f32 :: proc(q1: Quaternionf32, q2: Quaternionf32, s1: Quaternionf32, s2: Quaternionf32, h: f32) -> (Quaternionf32)

Source

quaternion_squad_f64 :: proc(q1: Quaternionf64, q2: Quaternionf64, s1: Quaternionf64, s2: Quaternionf64, h: f64) -> (Quaternionf64)

Source

reflect :: proc(I: T, N: T) -> (out: T)Source

refract :: proc(I: V, Normal: V, eta: E) -> (out: V)Source

roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> (f16)Source

roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> (f32)Source

roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> (f64)Source

round :: proc(x: T) -> (out: T)Source

saturate :: proc(x: T) -> (T)Source

scalar_cross :: proc(a: T, b: T) -> (T)Source

scalar_dot :: proc(a: T, b: T) -> (T)Source

scalar_f32_swizzle1 :: proc(f: f32, c0: Scalar_Components) -> (f32)Source

scalar_f32_swizzle2 :: proc(f: f32, c0: Scalar_Components, c1: Scalar_Components) -> (Vector2f32)Source

scalar_f32_swizzle3 :: proc(f: f32, c0: Scalar_Components, c1: Scalar_Components, c2: Scalar_Components) -> (Vector3f32)Source

scalar_f32_swizzle4 :: proc(f: f32, c0: Scalar_Components, c1: Scalar_Components, c2: Scalar_Components, c3: Scalar_Components) -> (Vector4f32)

Source

scalar_f64_swizzle1 :: proc(f: f64, c0: Scalar_Components) -> (f64)Source

scalar_f64_swizzle2 :: proc(f: f64, c0: Scalar_Components, c1: Scalar_Components) -> (Vector2f64)Source

scalar_f64_swizzle3 :: proc(f: f64, c0: Scalar_Components, c1: Scalar_Components, c2: Scalar_Components) -> (Vector3f64)Source

scalar_f64_swizzle4 :: proc(f: f64, c0: Scalar_Components, c1: Scalar_Components, c2: Scalar_Components, c3: Scalar_Components) -> (Vector4f64)

Source

scalar_triple_product :: proc(a: T, b: T, c: T) -> (E)Source

sign :: proc(a: T) -> (out: T)Source

sin :: proc(x: T) -> (out: T)Source

smootherstep :: proc(e0: T, e1: T, x: T) -> (T)Source

smoothstep :: proc(e0: T, e1: T, x: T) -> (T)Source

sqrt :: proc(x: T) -> (out: T)Source

step :: proc(e: T, x: T) -> (out: T)Source

tan :: proc(x: T) -> (out: T)Source

to_complex128 :: proc(v: A) -> ([N]complex128)Source

to_complex32 :: proc(v: A) -> ([N]complex32)Source

to_complex64 :: proc(v: A) -> ([N]complex64)Source

to_degrees :: proc(radians: T) -> (out: T)Source

to_f16 :: proc(v: A) -> ([N]f16)Source

to_f32 :: proc(v: A) -> ([N]f32)Source

to_f64 :: proc(v: A) -> ([N]f64)Source

to_i16 :: proc(v: A) -> ([N]i16)Source

to_i32 :: proc(v: A) -> ([N]i32)Source

to_i64 :: proc(v: A) -> ([N]i64)Source

to_i8 :: proc(v: A) -> ([N]i8)Source

to_int :: proc(v: A) -> ([N]int)Source

to_quaternion128 :: proc(v: A) -> ([N]quaternion128)Source

to_quaternion256 :: proc(v: A) -> ([N]quaternion256)Source

to_quaternion64 :: proc(v: A) -> ([N]quaternion64)Source

to_radians :: proc(degrees: T) -> (out: T)Source

to_u16 :: proc(v: A) -> ([N]u16)Source

to_u32 :: proc(v: A) -> ([N]u32)Source

to_u64 :: proc(v: A) -> ([N]u64)Source

to_u8 :: proc(v: A) -> ([N]u8)Source

to_uint :: proc(v: A) -> ([N]uint)Source

trace :: proc(m) -> (trace: T)Source

trunc :: proc(x: T) -> (out: T)Source

unlerp :: proc(a: T, b: T, x: T) -> (T)Source

vector2_orthogonal :: proc(v: V) -> (V)Source

vector2f32_swizzle1 :: proc(v: Vector2f32, c0: Vector2_Components) -> (f32)Source

vector2f32_swizzle2 :: proc(v: Vector2f32, c0: Vector2_Components, c1: Vector2_Components) -> (Vector2f32)Source

vector2f32_swizzle3 :: proc(v: Vector2f32, c0: Vector2_Components, c1: Vector2_Components, c2: Vector2_Components) -> (Vector3f32)

Source

vector2f32_swizzle4 :: proc(v: Vector2f32, c0: Vector2_Components, c1: Vector2_Components, c2: Vector2_Components, c3: Vector2_Components) -> (Vector4f32)

Source

vector2f64_swizzle1 :: proc(v: Vector2f64, c0: Vector2_Components) -> (f64)Source

vector2f64_swizzle2 :: proc(v: Vector2f64, c0: Vector2_Components, c1: Vector2_Components) -> (Vector2f64)Source

vector2f64_swizzle3 :: proc(v: Vector2f64, c0: Vector2_Components, c1: Vector2_Components, c2: Vector2_Components) -> (Vector3f64)

Source

vector2f64_swizzle4 :: proc(v: Vector2f64, c0: Vector2_Components, c1: Vector2_Components, c2: Vector2_Components, c3: Vector2_Components) -> (Vector4f64)

Source

vector3_linear_to_srgb_f16 :: proc(col: Vector3f16) -> (Vector3f16)Source

vector3_linear_to_srgb_f32 :: proc(col: Vector3f32) -> (Vector3f32)Source

vector3_linear_to_srgb_f64 :: proc(col: Vector3f64) -> (Vector3f64)Source

vector3_orthogonal :: proc(v: V) -> (V)Source

vector3_orthonormalize_f16 :: proc(x: Vector3f16, y: Vector3f16) -> (z: Vector3f16)Source

vector3_orthonormalize_f32 :: proc(x: Vector3f32, y: Vector3f32) -> (z: Vector3f32)Source

vector3_orthonormalize_f64 :: proc(x: Vector3f64, y: Vector3f64) -> (z: Vector3f64)Source

vector3_srgb_to_linear_f16 :: proc(col: Vector3f16) -> (Vector3f16)Source

vector3_srgb_to_linear_f32 :: proc(col: Vector3f32) -> (Vector3f32)Source

vector3_srgb_to_linear_f64 :: proc(col: Vector3f64) -> (Vector3f64)Source

vector3f32_swizzle1 :: proc(v: Vector3f32, c0: Vector3_Components) -> (f32)Source

vector3f32_swizzle2 :: proc(v: Vector3f32, c0: Vector3_Components, c1: Vector3_Components) -> (Vector2f32)Source

vector3f32_swizzle3 :: proc(v: Vector3f32, c0: Vector3_Components, c1: Vector3_Components, c2: Vector3_Components) -> (Vector3f32)

Source

vector3f32_swizzle4 :: proc(v: Vector3f32, c0: Vector3_Components, c1: Vector3_Components, c2: Vector3_Components, c3: Vector3_Components) -> (Vector4f32)

Source

vector3f64_swizzle1 :: proc(v: Vector3f64, c0: Vector3_Components) -> (f64)Source

vector3f64_swizzle2 :: proc(v: Vector3f64, c0: Vector3_Components, c1: Vector3_Components) -> (Vector2f64)Source

vector3f64_swizzle3 :: proc(v: Vector3f64, c0: Vector3_Components, c1: Vector3_Components, c2: Vector3_Components) -> (Vector3f64)

Source

vector3f64_swizzle4 :: proc(v: Vector3f64, c0: Vector3_Components, c1: Vector3_Components, c2: Vector3_Components, c3: Vector3_Components) -> (Vector4f64)

Source

vector4_hsl_to_rgb_f16 :: proc(h: f16, s: f16, l: f16, a: f16) -> (Vector4f16)Source

vector4_hsl_to_rgb_f32 :: proc(h: f32, s: f32, l: f32, a: f32) -> (Vector4f32)Source

vector4_hsl_to_rgb_f64 :: proc(h: f64, s: f64, l: f64, a: f64) -> (Vector4f64)Source

vector4_linear_to_srgb_f16 :: proc(col: Vector4f16) -> (Vector4f16)Source

vector4_linear_to_srgb_f32 :: proc(col: Vector4f32) -> (Vector4f32)Source

vector4_linear_to_srgb_f64 :: proc(col: Vector4f64) -> (Vector4f64)Source

vector4_rgb_to_hsl_f16 :: proc(col: Vector4f16) -> (Vector4f16)Source

vector4_rgb_to_hsl_f32 :: proc(col: Vector4f32) -> (Vector4f32)Source

vector4_rgb_to_hsl_f64 :: proc(col: Vector4f64) -> (Vector4f64)Source

vector4_srgb_to_linear_f16 :: proc(col: Vector4f16) -> (Vector4f16)Source

vector4_srgb_to_linear_f32 :: proc(col: Vector4f32) -> (Vector4f32)Source

vector4_srgb_to_linear_f64 :: proc(col: Vector4f64) -> (Vector4f64)Source

vector4f32_swizzle1 :: proc(v: Vector4f32, c0: Vector4_Components) -> (f32)Source

vector4f32_swizzle2 :: proc(v: Vector4f32, c0: Vector4_Components, c1: Vector4_Components) -> (Vector2f32)Source

vector4f32_swizzle3 :: proc(v: Vector4f32, c0: Vector4_Components, c1: Vector4_Components, c2: Vector4_Components) -> (Vector3f32)

Source

vector4f32_swizzle4 :: proc(v: Vector4f32, c0: Vector4_Components, c1: Vector4_Components, c2: Vector4_Components, c3: Vector4_Components) -> (Vector4f32)

Source

vector4f64_swizzle1 :: proc(v: Vector4f64, c0: Vector4_Components) -> (f64)Source

vector4f64_swizzle2 :: proc(v: Vector4f64, c0: Vector4_Components, c1: Vector4_Components) -> (Vector2f64)Source

vector4f64_swizzle3 :: proc(v: Vector4f64, c0: Vector4_Components, c1: Vector4_Components, c2: Vector4_Components) -> (Vector3f64)

Source

vector4f64_swizzle4 :: proc(v: Vector4f64, c0: Vector4_Components, c1: Vector4_Components, c2: Vector4_Components, c3: Vector4_Components) -> (Vector4f64)

Source

vector_angle_between :: proc(a: V, b: V) -> (E)Source

vector_cross2 :: proc(a: T, b: T) -> (E)Source

vector_cross3 :: proc(a: T, b: T) -> (c: T)Source

vector_dot :: proc(a: T, b: T) -> (c: E)Source

vector_length :: proc(v: T) -> (E)Source

vector_length2 :: proc(v: T) -> (E)Source

vector_normalize :: proc(v: T) -> (T)Source

vector_normalize0 :: proc(v: T) -> (T)Source

vector_slerp :: proc(x: T, y: T, a: E) -> (T)Source

Splines

vector_to_ptr :: proc(v: ^V) -> (^E)Source

vector_triple_product :: proc(a: T, b: T, c: T) -> (T)Source

yaw_from_quaternion_f16 :: proc(q: Quaternionf16) -> (f16)Source

yaw_from_quaternion_f32 :: proc(q: Quaternionf32) -> (f32)Source

yaw_from_quaternion_f64 :: proc(q: Quaternionf64) -> (f64)Source

Procedure Groups

215

adjugate :: proc{matrix1x1_adjugate, matrix2x2_adjugate, matrix3x3_adjugate, matrix4x4_adjugate, matrix5x5_adjugate, matrix6x6_adjugate, matrix7x7_adjugate, matrix8x8_adjugate}

Source

angle_axis_from_quaternion :: proc{angle_axis_from_quaternion_f16, angle_axis_from_quaternion_f32, angle_axis_from_quaternion_f64}

Source

angle_between :: proc{vector_angle_between, quaternion64_angle_between, quaternion128_angle_between, quaternion256_angle_between}

Source

angle_from_quaternion :: proc{angle_from_quaternion_f16, angle_from_quaternion_f32, angle_from_quaternion_f64}Source

axis_from_quaternion :: proc{axis_from_quaternion_f16, axis_from_quaternion_f32, axis_from_quaternion_f64}Source

classify :: proc{classify_single, classify_array}Source

cofactor :: proc{matrix1x1_cofactor, matrix2x2_cofactor, matrix3x3_cofactor, matrix4x4_cofactor, matrix5x5_cofactor, matrix6x6_cofactor, matrix7x7_cofactor, matrix8x8_cofactor}

Source

cross :: proc{scalar_cross, vector_cross2, vector_cross3, quaternion_cross}Source

determinant :: proc{matrix1x1_determinant, matrix2x2_determinant, matrix3x3_determinant, matrix4x4_determinant, matrix5x5_determinant, matrix6x6_determinant, matrix7x7_determinant, matrix8x8_determinant}

Source

dot :: proc{scalar_dot, vector_dot, quaternion64_dot, quaternion128_dot, quaternion256_dot}Source

equal :: proc{equal_single, equal_array}Source

euclidean_from_polar :: proc{euclidean_from_polar_f16, euclidean_from_polar_f32, euclidean_from_polar_f64}Source

euler_angles_from_matrix3 :: proc{euler_angles_from_matrix3_f16, euler_angles_from_matrix3_f32, euler_angles_from_matrix3_f64}

Source

euler_angles_from_matrix4 :: proc{euler_angles_from_matrix4_f16, euler_angles_from_matrix4_f32, euler_angles_from_matrix4_f64}

Source

euler_angles_from_quaternion :: proc{euler_angles_from_quaternion_f16, euler_angles_from_quaternion_f32, euler_angles_from_quaternion_f64}

Source

euler_angles_xyx_from_matrix3 :: proc{euler_angles_xyx_from_matrix3_f16, euler_angles_xyx_from_matrix3_f32, euler_angles_xyx_from_matrix3_f64}

Source

euler_angles_xyx_from_matrix4 :: proc{euler_angles_xyx_from_matrix4_f16, euler_angles_xyx_from_matrix4_f32, euler_angles_xyx_from_matrix4_f64}

Source

euler_angles_xyx_from_quaternion :: proc{euler_angles_xyx_from_quaternion_f16, euler_angles_xyx_from_quaternion_f32, euler_angles_xyx_from_quaternion_f64}

Source

euler_angles_xyz_from_matrix3 :: proc{euler_angles_xyz_from_matrix3_f16, euler_angles_xyz_from_matrix3_f32, euler_angles_xyz_from_matrix3_f64}

Source

euler_angles_xyz_from_matrix4 :: proc{euler_angles_xyz_from_matrix4_f16, euler_angles_xyz_from_matrix4_f32, euler_angles_xyz_from_matrix4_f64}

Source

euler_angles_xyz_from_quaternion :: proc{euler_angles_xyz_from_quaternion_f16, euler_angles_xyz_from_quaternion_f32, euler_angles_xyz_from_quaternion_f64}

Source

euler_angles_xzx_from_matrix3 :: proc{euler_angles_xzx_from_matrix3_f16, euler_angles_xzx_from_matrix3_f32, euler_angles_xzx_from_matrix3_f64}

Source

euler_angles_xzx_from_matrix4 :: proc{euler_angles_xzx_from_matrix4_f16, euler_angles_xzx_from_matrix4_f32, euler_angles_xzx_from_matrix4_f64}

Source

euler_angles_xzx_from_quaternion :: proc{euler_angles_xzx_from_quaternion_f16, euler_angles_xzx_from_quaternion_f32, euler_angles_xzx_from_quaternion_f64}

Source

euler_angles_xzy_from_matrix3 :: proc{euler_angles_xzy_from_matrix3_f16, euler_angles_xzy_from_matrix3_f32, euler_angles_xzy_from_matrix3_f64}

Source

euler_angles_xzy_from_matrix4 :: proc{euler_angles_xzy_from_matrix4_f16, euler_angles_xzy_from_matrix4_f32, euler_angles_xzy_from_matrix4_f64}

Source

euler_angles_xzy_from_quaternion :: proc{euler_angles_xzy_from_quaternion_f16, euler_angles_xzy_from_quaternion_f32, euler_angles_xzy_from_quaternion_f64}

Source

euler_angles_yxy_from_matrix3 :: proc{euler_angles_yxy_from_matrix3_f16, euler_angles_yxy_from_matrix3_f32, euler_angles_yxy_from_matrix3_f64}

Source

euler_angles_yxy_from_matrix4 :: proc{euler_angles_yxy_from_matrix4_f16, euler_angles_yxy_from_matrix4_f32, euler_angles_yxy_from_matrix4_f64}

Source

euler_angles_yxy_from_quaternion :: proc{euler_angles_yxy_from_quaternion_f16, euler_angles_yxy_from_quaternion_f32, euler_angles_yxy_from_quaternion_f64}

Source

euler_angles_yxz_from_matrix3 :: proc{euler_angles_yxz_from_matrix3_f16, euler_angles_yxz_from_matrix3_f32, euler_angles_yxz_from_matrix3_f64}

Source

euler_angles_yxz_from_matrix4 :: proc{euler_angles_yxz_from_matrix4_f16, euler_angles_yxz_from_matrix4_f32, euler_angles_yxz_from_matrix4_f64}

Source

euler_angles_yxz_from_quaternion :: proc{euler_angles_yxz_from_quaternion_f16, euler_angles_yxz_from_quaternion_f32, euler_angles_yxz_from_quaternion_f64}

Source

euler_angles_yzx_from_matrix3 :: proc{euler_angles_yzx_from_matrix3_f16, euler_angles_yzx_from_matrix3_f32, euler_angles_yzx_from_matrix3_f64}

Source

euler_angles_yzx_from_matrix4 :: proc{euler_angles_yzx_from_matrix4_f16, euler_angles_yzx_from_matrix4_f32, euler_angles_yzx_from_matrix4_f64}

Source

euler_angles_yzx_from_quaternion :: proc{euler_angles_yzx_from_quaternion_f16, euler_angles_yzx_from_quaternion_f32, euler_angles_yzx_from_quaternion_f64}

Source

euler_angles_yzy_from_matrix3 :: proc{euler_angles_yzy_from_matrix3_f16, euler_angles_yzy_from_matrix3_f32, euler_angles_yzy_from_matrix3_f64}

Source

euler_angles_yzy_from_matrix4 :: proc{euler_angles_yzy_from_matrix4_f16, euler_angles_yzy_from_matrix4_f32, euler_angles_yzy_from_matrix4_f64}

Source

euler_angles_yzy_from_quaternion :: proc{euler_angles_yzy_from_quaternion_f16, euler_angles_yzy_from_quaternion_f32, euler_angles_yzy_from_quaternion_f64}

Source

euler_angles_zxy_from_matrix3 :: proc{euler_angles_zxy_from_matrix3_f16, euler_angles_zxy_from_matrix3_f32, euler_angles_zxy_from_matrix3_f64}

Source

euler_angles_zxy_from_matrix4 :: proc{euler_angles_zxy_from_matrix4_f16, euler_angles_zxy_from_matrix4_f32, euler_angles_zxy_from_matrix4_f64}

Source

euler_angles_zxy_from_quaternion :: proc{euler_angles_zxy_from_quaternion_f16, euler_angles_zxy_from_quaternion_f32, euler_angles_zxy_from_quaternion_f64}

Source

euler_angles_zxz_from_matrix3 :: proc{euler_angles_zxz_from_matrix3_f16, euler_angles_zxz_from_matrix3_f32, euler_angles_zxz_from_matrix3_f64}

Source

euler_angles_zxz_from_matrix4 :: proc{euler_angles_zxz_from_matrix4_f16, euler_angles_zxz_from_matrix4_f32, euler_angles_zxz_from_matrix4_f64}

Source

euler_angles_zxz_from_quaternion :: proc{euler_angles_zxz_from_quaternion_f16, euler_angles_zxz_from_quaternion_f32, euler_angles_zxz_from_quaternion_f64}

Source

euler_angles_zyx_from_matrix3 :: proc{euler_angles_zyx_from_matrix3_f16, euler_angles_zyx_from_matrix3_f32, euler_angles_zyx_from_matrix3_f64}

Source

euler_angles_zyx_from_matrix4 :: proc{euler_angles_zyx_from_matrix4_f16, euler_angles_zyx_from_matrix4_f32, euler_angles_zyx_from_matrix4_f64}

Source

euler_angles_zyx_from_quaternion :: proc{euler_angles_zyx_from_quaternion_f16, euler_angles_zyx_from_quaternion_f32, euler_angles_zyx_from_quaternion_f64}

Source

euler_angles_zyz_from_matrix3 :: proc{euler_angles_zyz_from_matrix3_f16, euler_angles_zyz_from_matrix3_f32, euler_angles_zyz_from_matrix3_f64}

Source

euler_angles_zyz_from_matrix4 :: proc{euler_angles_zyz_from_matrix4_f16, euler_angles_zyz_from_matrix4_f32, euler_angles_zyz_from_matrix4_f64}

Source

euler_angles_zyz_from_quaternion :: proc{euler_angles_zyz_from_quaternion_f16, euler_angles_zyz_from_quaternion_f32, euler_angles_zyz_from_quaternion_f64}

Source

greater_than :: proc{greater_than_single, greater_than_array}Source

greater_than_equal :: proc{greater_than_equal_single, greater_than_equal_array}Source

identity :: proc{identity_array_based_matrix, identity_matrix}Source

inverse :: proc{matrix1x1_inverse, matrix2x2_inverse, matrix3x3_inverse, matrix4x4_inverse, matrix5x5_inverse, matrix6x6_inverse, matrix7x7_inverse, matrix8x8_inverse}

Source

inverse_transpose :: proc{matrix1x1_inverse_transpose, matrix2x2_inverse_transpose, matrix3x3_inverse_transpose, matrix4x4_inverse_transpose, matrix5x5_inverse_transpose, matrix6x6_inverse_transpose, matrix7x7_inverse_transpose, matrix8x8_inverse_transpose}

Source

is_inf :: proc{is_inf_single, is_inf_array}Source

is_nan :: proc{is_nan_single, is_nan_array}Source

length :: proc{vector_length, quaternion_length}Source

length2 :: proc{vector_length2, quaternion_length2}Source

less_than :: proc{less_than_single, less_than_array}Source

less_than_equal :: proc{less_than_equal_single, less_than_equal_array}Source

matrix2_adjoint :: proc{matrix2_adjoint_f16, matrix2_adjoint_f32, matrix2_adjoint_f64}Source

matrix2_determinant :: proc{matrix2_determinant_f16, matrix2_determinant_f32, matrix2_determinant_f64}Source

matrix2_from_matrix3 :: proc{matrix2_from_matrix3_f16, matrix2_from_matrix3_f32, matrix2_from_matrix3_f64}Source

matrix2_from_matrix4 :: proc{matrix2_from_matrix4_f16, matrix2_from_matrix4_f32, matrix2_from_matrix4_f64}Source

matrix2_from_scalar :: proc{matrix2_from_scalar_f16, matrix2_from_scalar_f32, matrix2_from_scalar_f64}Source

matrix2_inverse :: proc{matrix2_inverse_f16, matrix2_inverse_f32, matrix2_inverse_f64}Source

matrix2_inverse_transpose :: proc{matrix2_inverse_transpose_f16, matrix2_inverse_transpose_f32, matrix2_inverse_transpose_f64}

Source

matrix2_orthonormalize :: proc{matrix2_orthonormalize_f16, matrix2_orthonormalize_f32, matrix2_orthonormalize_f64}Source

matrix2_rotate :: proc{matrix2_rotate_f16, matrix2_rotate_f32, matrix2_rotate_f64}Source

matrix3_adjoint :: proc{matrix3_adjoint_f16, matrix3_adjoint_f32, matrix3_adjoint_f64}Source

matrix3_determinant :: proc{matrix3_determinant_f16, matrix3_determinant_f32, matrix3_determinant_f64}Source

matrix3_from_derived_euler_angle_x :: proc{matrix3_from_derived_euler_angle_x_f16, matrix3_from_derived_euler_angle_x_f32, matrix3_from_derived_euler_angle_x_f64}

Source

matrix3_from_derived_euler_angle_y :: proc{matrix3_from_derived_euler_angle_y_f16, matrix3_from_derived_euler_angle_y_f32, matrix3_from_derived_euler_angle_y_f64}

Source

matrix3_from_derived_euler_angle_z :: proc{matrix3_from_derived_euler_angle_z_f16, matrix3_from_derived_euler_angle_z_f32, matrix3_from_derived_euler_angle_z_f64}

Source

matrix3_from_euler_angle_x :: proc{matrix3_from_euler_angle_x_f16, matrix3_from_euler_angle_x_f32, matrix3_from_euler_angle_x_f64}

Source

matrix3_from_euler_angle_y :: proc{matrix3_from_euler_angle_y_f16, matrix3_from_euler_angle_y_f32, matrix3_from_euler_angle_y_f64}

Source

matrix3_from_euler_angle_z :: proc{matrix3_from_euler_angle_z_f16, matrix3_from_euler_angle_z_f32, matrix3_from_euler_angle_z_f64}

Source

matrix3_from_euler_angles :: proc{matrix3_from_euler_angles_f16, matrix3_from_euler_angles_f32, matrix3_from_euler_angles_f64}

Source

matrix3_from_euler_angles_xy :: proc{matrix3_from_euler_angles_xy_f16, matrix3_from_euler_angles_xy_f32, matrix3_from_euler_angles_xy_f64}

Source

matrix3_from_euler_angles_xyx :: proc{matrix3_from_euler_angles_xyx_f16, matrix3_from_euler_angles_xyx_f32, matrix3_from_euler_angles_xyx_f64}

Source

matrix3_from_euler_angles_xyz :: proc{matrix3_from_euler_angles_xyz_f16, matrix3_from_euler_angles_xyz_f32, matrix3_from_euler_angles_xyz_f64}

Source

matrix3_from_euler_angles_xz :: proc{matrix3_from_euler_angles_xz_f16, matrix3_from_euler_angles_xz_f32, matrix3_from_euler_angles_xz_f64}

Source

matrix3_from_euler_angles_xzx :: proc{matrix3_from_euler_angles_xzx_f16, matrix3_from_euler_angles_xzx_f32, matrix3_from_euler_angles_xzx_f64}

Source

matrix3_from_euler_angles_xzy :: proc{matrix3_from_euler_angles_xzy_f16, matrix3_from_euler_angles_xzy_f32, matrix3_from_euler_angles_xzy_f64}

Source

matrix3_from_euler_angles_yx :: proc{matrix3_from_euler_angles_yx_f16, matrix3_from_euler_angles_yx_f32, matrix3_from_euler_angles_yx_f64}

Source

matrix3_from_euler_angles_yxy :: proc{matrix3_from_euler_angles_yxy_f16, matrix3_from_euler_angles_yxy_f32, matrix3_from_euler_angles_yxy_f64}

Source

matrix3_from_euler_angles_yxz :: proc{matrix3_from_euler_angles_yxz_f16, matrix3_from_euler_angles_yxz_f32, matrix3_from_euler_angles_yxz_f64}

Source

matrix3_from_euler_angles_yz :: proc{matrix3_from_euler_angles_yz_f16, matrix3_from_euler_angles_yz_f32, matrix3_from_euler_angles_yz_f64}

Source

matrix3_from_euler_angles_yzx :: proc{matrix3_from_euler_angles_yzx_f16, matrix3_from_euler_angles_yzx_f32, matrix3_from_euler_angles_yzx_f64}

Source

matrix3_from_euler_angles_yzy :: proc{matrix3_from_euler_angles_yzy_f16, matrix3_from_euler_angles_yzy_f32, matrix3_from_euler_angles_yzy_f64}

Source

matrix3_from_euler_angles_zx :: proc{matrix3_from_euler_angles_zx_f16, matrix3_from_euler_angles_zx_f32, matrix3_from_euler_angles_zx_f64}

Source

matrix3_from_euler_angles_zxy :: proc{matrix3_from_euler_angles_zxy_f16, matrix3_from_euler_angles_zxy_f32, matrix3_from_euler_angles_zxy_f64}

Source

matrix3_from_euler_angles_zxz :: proc{matrix3_from_euler_angles_zxz_f16, matrix3_from_euler_angles_zxz_f32, matrix3_from_euler_angles_zxz_f64}

Source

matrix3_from_euler_angles_zy :: proc{matrix3_from_euler_angles_zy_f16, matrix3_from_euler_angles_zy_f32, matrix3_from_euler_angles_zy_f64}

Source

matrix3_from_euler_angles_zyx :: proc{matrix3_from_euler_angles_zyx_f16, matrix3_from_euler_angles_zyx_f32, matrix3_from_euler_angles_zyx_f64}

Source

matrix3_from_euler_angles_zyz :: proc{matrix3_from_euler_angles_zyz_f16, matrix3_from_euler_angles_zyz_f32, matrix3_from_euler_angles_zyz_f64}

Source

matrix3_from_matrix2 :: proc{matrix3_from_matrix2_f16, matrix3_from_matrix2_f32, matrix3_from_matrix2_f64}Source

matrix3_from_matrix4 :: proc{matrix3_from_matrix4_f16, matrix3_from_matrix4_f32, matrix3_from_matrix4_f64}Source

matrix3_from_quaternion :: proc{matrix3_from_quaternion_f16, matrix3_from_quaternion_f32, matrix3_from_quaternion_f64}Source

matrix3_from_scalar :: proc{matrix3_from_scalar_f16, matrix3_from_scalar_f32, matrix3_from_scalar_f64}Source

matrix3_from_yaw_pitch_roll :: proc{matrix3_from_yaw_pitch_roll_f16, matrix3_from_yaw_pitch_roll_f32, matrix3_from_yaw_pitch_roll_f64}

Source

matrix3_inverse :: proc{matrix3_inverse_f16, matrix3_inverse_f32, matrix3_inverse_f64}Source

matrix3_inverse_transpose :: proc{matrix3_inverse_transpose_f16, matrix3_inverse_transpose_f32, matrix3_inverse_transpose_f64}

Source

matrix3_look_at :: proc{matrix3_look_at_f16, matrix3_look_at_f32, matrix3_look_at_f64}Source

matrix3_orthonormalize :: proc{matrix3_orthonormalize_f16, matrix3_orthonormalize_f32, matrix3_orthonormalize_f64}Source

matrix3_rotate :: proc{matrix3_rotate_f16, matrix3_rotate_f32, matrix3_rotate_f64}Source

matrix3_scale :: proc{matrix3_scale_f16, matrix3_scale_f32, matrix3_scale_f64}Source

matrix4_adjoint :: proc{matrix4_adjoint_f16, matrix4_adjoint_f32, matrix4_adjoint_f64}Source

matrix4_cofactor :: proc{matrix4_cofactor_f16, matrix4_cofactor_f32, matrix4_cofactor_f64}Source

matrix4_determinant :: proc{matrix4_determinant_f16, matrix4_determinant_f32, matrix4_determinant_f64}Source

matrix4_from_derived_euler_angle_x :: proc{matrix4_from_derived_euler_angle_x_f16, matrix4_from_derived_euler_angle_x_f32, matrix4_from_derived_euler_angle_x_f64}

Source

matrix4_from_derived_euler_angle_y :: proc{matrix4_from_derived_euler_angle_y_f16, matrix4_from_derived_euler_angle_y_f32, matrix4_from_derived_euler_angle_y_f64}

Source

matrix4_from_derived_euler_angle_z :: proc{matrix4_from_derived_euler_angle_z_f16, matrix4_from_derived_euler_angle_z_f32, matrix4_from_derived_euler_angle_z_f64}

Source

matrix4_from_euler_angle_x :: proc{matrix4_from_euler_angle_x_f16, matrix4_from_euler_angle_x_f32, matrix4_from_euler_angle_x_f64}

Source

matrix4_from_euler_angle_y :: proc{matrix4_from_euler_angle_y_f16, matrix4_from_euler_angle_y_f32, matrix4_from_euler_angle_y_f64}

Source

matrix4_from_euler_angle_z :: proc{matrix4_from_euler_angle_z_f16, matrix4_from_euler_angle_z_f32, matrix4_from_euler_angle_z_f64}

Source

matrix4_from_euler_angles :: proc{matrix4_from_euler_angles_f16, matrix4_from_euler_angles_f32, matrix4_from_euler_angles_f64}

Source

matrix4_from_euler_angles_xy :: proc{matrix4_from_euler_angles_xy_f16, matrix4_from_euler_angles_xy_f32, matrix4_from_euler_angles_xy_f64}

Source

matrix4_from_euler_angles_xyx :: proc{matrix4_from_euler_angles_xyx_f16, matrix4_from_euler_angles_xyx_f32, matrix4_from_euler_angles_xyx_f64}

Source

matrix4_from_euler_angles_xyz :: proc{matrix4_from_euler_angles_xyz_f16, matrix4_from_euler_angles_xyz_f32, matrix4_from_euler_angles_xyz_f64}

Source

matrix4_from_euler_angles_xz :: proc{matrix4_from_euler_angles_xz_f16, matrix4_from_euler_angles_xz_f32, matrix4_from_euler_angles_xz_f64}

Source

matrix4_from_euler_angles_xzx :: proc{matrix4_from_euler_angles_xzx_f16, matrix4_from_euler_angles_xzx_f32, matrix4_from_euler_angles_xzx_f64}

Source

matrix4_from_euler_angles_xzy :: proc{matrix4_from_euler_angles_xzy_f16, matrix4_from_euler_angles_xzy_f32, matrix4_from_euler_angles_xzy_f64}

Source

matrix4_from_euler_angles_yx :: proc{matrix4_from_euler_angles_yx_f16, matrix4_from_euler_angles_yx_f32, matrix4_from_euler_angles_yx_f64}

Source

matrix4_from_euler_angles_yxy :: proc{matrix4_from_euler_angles_yxy_f16, matrix4_from_euler_angles_yxy_f32, matrix4_from_euler_angles_yxy_f64}

Source

matrix4_from_euler_angles_yxz :: proc{matrix4_from_euler_angles_yxz_f16, matrix4_from_euler_angles_yxz_f32, matrix4_from_euler_angles_yxz_f64}

Source

matrix4_from_euler_angles_yz :: proc{matrix4_from_euler_angles_yz_f16, matrix4_from_euler_angles_yz_f32, matrix4_from_euler_angles_yz_f64}

Source

matrix4_from_euler_angles_yzx :: proc{matrix4_from_euler_angles_yzx_f16, matrix4_from_euler_angles_yzx_f32, matrix4_from_euler_angles_yzx_f64}

Source

matrix4_from_euler_angles_yzy :: proc{matrix4_from_euler_angles_yzy_f16, matrix4_from_euler_angles_yzy_f32, matrix4_from_euler_angles_yzy_f64}

Source

matrix4_from_euler_angles_zx :: proc{matrix4_from_euler_angles_zx_f16, matrix4_from_euler_angles_zx_f32, matrix4_from_euler_angles_zx_f64}

Source

matrix4_from_euler_angles_zxy :: proc{matrix4_from_euler_angles_zxy_f16, matrix4_from_euler_angles_zxy_f32, matrix4_from_euler_angles_zxy_f64}

Source

matrix4_from_euler_angles_zxz :: proc{matrix4_from_euler_angles_zxz_f16, matrix4_from_euler_angles_zxz_f32, matrix4_from_euler_angles_zxz_f64}

Source

matrix4_from_euler_angles_zy :: proc{matrix4_from_euler_angles_zy_f16, matrix4_from_euler_angles_zy_f32, matrix4_from_euler_angles_zy_f64}

Source

matrix4_from_euler_angles_zyx :: proc{matrix4_from_euler_angles_zyx_f16, matrix4_from_euler_angles_zyx_f32, matrix4_from_euler_angles_zyx_f64}

Source

matrix4_from_euler_angles_zyz :: proc{matrix4_from_euler_angles_zyz_f16, matrix4_from_euler_angles_zyz_f32, matrix4_from_euler_angles_zyz_f64}

Source

matrix4_from_matrix2 :: proc{matrix4_from_matrix2_f16, matrix4_from_matrix2_f32, matrix4_from_matrix2_f64}Source

matrix4_from_matrix3 :: proc{matrix4_from_matrix3_f16, matrix4_from_matrix3_f32, matrix4_from_matrix3_f64}Source

matrix4_from_quaternion :: proc{matrix4_from_quaternion_f16, matrix4_from_quaternion_f32, matrix4_from_quaternion_f64}Source

matrix4_from_scalar :: proc{matrix4_from_scalar_f16, matrix4_from_scalar_f32, matrix4_from_scalar_f64}Source

matrix4_from_trs :: proc{matrix4_from_trs_f16, matrix4_from_trs_f32, matrix4_from_trs_f64}Source

matrix4_from_yaw_pitch_roll :: proc{matrix4_from_yaw_pitch_roll_f16, matrix4_from_yaw_pitch_roll_f32, matrix4_from_yaw_pitch_roll_f64}

Source

matrix4_infinite_perspective :: proc{matrix4_infinite_perspective_f16, matrix4_infinite_perspective_f32, matrix4_infinite_perspective_f64}

Source

matrix4_inverse :: proc{matrix4_inverse_f16, matrix4_inverse_f32, matrix4_inverse_f64}Source

matrix4_inverse_transpose :: proc{matrix4_inverse_transpose_f16, matrix4_inverse_transpose_f32, matrix4_inverse_transpose_f64}

Source

matrix4_look_at :: proc{matrix4_look_at_f16, matrix4_look_at_f32, matrix4_look_at_f64}Source

matrix4_look_at_from_fru :: proc{matrix4_look_at_from_fru_f16, matrix4_look_at_from_fru_f32, matrix4_look_at_from_fru_f64}

Source

matrix4_minor :: proc{matrix4_minor_f16, matrix4_minor_f32, matrix4_minor_f64}Source

matrix4_orientation :: proc{matrix4_orientation_f16, matrix4_orientation_f32, matrix4_orientation_f64}Source

matrix4_perspective :: proc{matrix4_perspective_f16, matrix4_perspective_f32, matrix4_perspective_f64}Source

matrix4_rotate :: proc{matrix4_rotate_f16, matrix4_rotate_f32, matrix4_rotate_f64}Source

matrix4_scale :: proc{matrix4_scale_f16, matrix4_scale_f32, matrix4_scale_f64}Source

matrix4_translate :: proc{matrix4_translate_f16, matrix4_translate_f32, matrix4_translate_f64}Source

matrix_ortho3d :: proc{matrix_ortho3d_f16, matrix_ortho3d_f32, matrix_ortho3d_f64}Source

max :: proc{max_single, max_double, max_triple}Source

min :: proc{min_single, min_double, min_triple}Source

mul :: proc{matrix_mul, matrix_mul_differ, matrix_mul_vector, quaternion64_mul_vector3, quaternion128_mul_vector3, quaternion256_mul_vector3, quaternion_mul_quaternion}

Source

normalize :: proc{vector_normalize, quaternion_normalize}Source

normalize0 :: proc{vector_normalize0, quaternion_normalize0}Source

not_equal :: proc{not_equal_single, not_equal_array}Source

orthogonal :: proc{vector2_orthogonal, vector3_orthogonal}Source

orthonormalize :: proc{matrix2_orthonormalize_f16, matrix3_orthonormalize_f16, vector3_orthonormalize_f16, matrix2_orthonormalize_f32, matrix3_orthonormalize_f32, vector3_orthonormalize_f32, matrix2_orthonormalize_f64, matrix3_orthonormalize_f64, vector3_orthonormalize_f64}

Source

pitch_from_quaternion :: proc{pitch_from_quaternion_f16, pitch_from_quaternion_f32, pitch_from_quaternion_f64}Source

pitch_yaw_roll_from_quaternion :: proc{pitch_yaw_roll_from_quaternion_f16, pitch_yaw_roll_from_quaternion_f32, pitch_yaw_roll_from_quaternion_f64}

Source

polar_from_euclidean :: proc{polar_from_euclidean_f16, polar_from_euclidean_f32, polar_from_euclidean_f64}Source

pseudo_inverse :: proc{matrix_pseudo_inverse}Source

quaternion_angle_axis :: proc{quaternion_angle_axis_f16, quaternion_angle_axis_f32, quaternion_angle_axis_f64}Source

quaternion_between_two_vector3 :: proc{quaternion_between_two_vector3_f16, quaternion_between_two_vector3_f32, quaternion_between_two_vector3_f64}

Source

quaternion_from_euler_angle_x :: proc{quaternion_from_euler_angle_x_f16, quaternion_from_euler_angle_x_f32, quaternion_from_euler_angle_x_f64}

Source

quaternion_from_euler_angle_y :: proc{quaternion_from_euler_angle_y_f16, quaternion_from_euler_angle_y_f32, quaternion_from_euler_angle_y_f64}

Source

quaternion_from_euler_angle_z :: proc{quaternion_from_euler_angle_z_f16, quaternion_from_euler_angle_z_f32, quaternion_from_euler_angle_z_f64}

Source

quaternion_from_euler_angles :: proc{quaternion_from_euler_angles_f16, quaternion_from_euler_angles_f32, quaternion_from_euler_angles_f64}

Source

quaternion_from_forward_and_up :: proc{quaternion_from_forward_and_up_f16, quaternion_from_forward_and_up_f32, quaternion_from_forward_and_up_f64}

Source

quaternion_from_matrix3 :: proc{quaternion_from_matrix3_f16, quaternion_from_matrix3_f32, quaternion_from_matrix3_f64}Source

quaternion_from_matrix4 :: proc{quaternion_from_matrix4_f16, quaternion_from_matrix4_f32, quaternion_from_matrix4_f64}Source

quaternion_from_pitch_yaw_roll :: proc{quaternion_from_pitch_yaw_roll_f16, quaternion_from_pitch_yaw_roll_f32, quaternion_from_pitch_yaw_roll_f64}

Source

quaternion_from_scalar :: proc{quaternion_from_scalar_f16, quaternion_from_scalar_f32, quaternion_from_scalar_f64}Source

quaternion_look_at :: proc{quaternion_look_at_f16, quaternion_look_at_f32, quaternion_look_at_f64}Source

quaternion_mul_vector3 :: proc{quaternion64_mul_vector3, quaternion128_mul_vector3, quaternion256_mul_vector3}Source

quaternion_nlerp :: proc{quaternion_nlerp_f16, quaternion_nlerp_f32, quaternion_nlerp_f64}Source

quaternion_slerp :: proc{quaternion_slerp_f16, quaternion_slerp_f32, quaternion_slerp_f64}Source

quaternion_squad :: proc{quaternion_squad_f16, quaternion_squad_f32, quaternion_squad_f64}Source

roll_from_quaternion :: proc{roll_from_quaternion_f16, roll_from_quaternion_f32, roll_from_quaternion_f64}Source

scalar_swizzle :: proc{scalar_f32_swizzle1, scalar_f32_swizzle2, scalar_f32_swizzle3, scalar_f32_swizzle4, scalar_f64_swizzle1, scalar_f64_swizzle2, scalar_f64_swizzle3, scalar_f64_swizzle4}

Source

swizzle :: proc{scalar_f32_swizzle1, scalar_f32_swizzle2, scalar_f32_swizzle3, scalar_f32_swizzle4, scalar_f64_swizzle1, scalar_f64_swizzle2, scalar_f64_swizzle3, scalar_f64_swizzle4, vector2f32_swizzle1, vector2f32_swizzle2, vector2f32_swizzle3, vector2f32_swizzle4, vector2f64_swizzle1, vector2f64_swizzle2, vector2f64_swizzle3, vector2f64_swizzle4, vector3f32_swizzle1, vector3f32_swizzle2, vector3f32_swizzle3, vector3f32_swizzle4, vector3f64_swizzle1, vector3f64_swizzle2, vector3f64_swizzle3, vector3f64_swizzle4, vector4f32_swizzle1, vector4f32_swizzle2, vector4f32_swizzle3, vector4f32_swizzle4, vector4f64_swizzle1, vector4f64_swizzle2, vector4f64_swizzle3, vector4f64_swizzle4}

Source

to_matrix2f :: proc{matrix2_from_scalar_f16, matrix2_from_matrix3_f16, matrix2_from_matrix4_f16, matrix2_from_scalar_f32, matrix2_from_matrix3_f32, matrix2_from_matrix4_f32, matrix2_from_scalar_f64, matrix2_from_matrix3_f64, matrix2_from_matrix4_f64}

Source

to_matrix2f16 :: proc{matrix2_from_scalar_f16, matrix2_from_matrix3_f16, matrix2_from_matrix4_f16}Source

to_matrix2f32 :: proc{matrix2_from_scalar_f32, matrix2_from_matrix3_f32, matrix2_from_matrix4_f32}Source

to_matrix2f64 :: proc{matrix2_from_scalar_f64, matrix2_from_matrix3_f64, matrix2_from_matrix4_f64}Source

to_matrix3 :: proc{matrix3_from_scalar_f16, matrix3_from_matrix2_f16, matrix3_from_matrix4_f16, matrix3_from_quaternion_f16, matrix3_from_scalar_f32, matrix3_from_matrix2_f32, matrix3_from_matrix4_f32, matrix3_from_quaternion_f32, matrix3_from_scalar_f64, matrix3_from_matrix2_f64, matrix3_from_matrix4_f64, matrix3_from_quaternion_f64}

Source

to_matrix3f16 :: proc{matrix3_from_scalar_f16, matrix3_from_matrix2_f16, matrix3_from_matrix4_f16, matrix3_from_quaternion_f16}

Source

to_matrix3f32 :: proc{matrix3_from_scalar_f32, matrix3_from_matrix2_f32, matrix3_from_matrix4_f32, matrix3_from_quaternion_f32}

Source

to_matrix3f64 :: proc{matrix3_from_scalar_f64, matrix3_from_matrix2_f64, matrix3_from_matrix4_f64, matrix3_from_quaternion_f64}

Source

to_matrix4 :: proc{matrix4_from_scalar_f16, matrix4_from_matrix2_f16, matrix4_from_matrix3_f16, matrix4_from_quaternion_f16, matrix4_from_scalar_f32, matrix4_from_matrix2_f32, matrix4_from_matrix3_f32, matrix4_from_quaternion_f32, matrix4_from_scalar_f64, matrix4_from_matrix2_f64, matrix4_from_matrix3_f64, matrix4_from_quaternion_f64}

Source

to_matrix4f16 :: proc{matrix4_from_scalar_f16, matrix4_from_matrix2_f16, matrix4_from_matrix3_f16, matrix4_from_quaternion_f16}

Source

to_matrix4f32 :: proc{matrix4_from_scalar_f32, matrix4_from_matrix2_f32, matrix4_from_matrix3_f32, matrix4_from_quaternion_f32}

Source

to_matrix4f64 :: proc{matrix4_from_scalar_f64, matrix4_from_matrix2_f64, matrix4_from_matrix3_f64, matrix4_from_quaternion_f64}

Source

to_ptr :: proc{vector_to_ptr, matrix_to_ptr}Source

to_quaternion :: proc{quaternion_from_scalar_f16, quaternion_from_matrix3_f16, quaternion_from_matrix4_f16, quaternion_from_scalar_f32, quaternion_from_matrix3_f32, quaternion_from_matrix4_f32, quaternion_from_scalar_f64, quaternion_from_matrix3_f64, quaternion_from_matrix4_f64}

Source

to_quaternionf16 :: proc{quaternion_from_scalar_f16, quaternion_from_matrix3_f16, quaternion_from_matrix4_f16}Source

to_quaternionf32 :: proc{quaternion_from_scalar_f32, quaternion_from_matrix3_f32, quaternion_from_matrix4_f32}Source

to_quaternionf64 :: proc{quaternion_from_scalar_f64, quaternion_from_matrix3_f64, quaternion_from_matrix4_f64}Source

vector2_swizzle :: proc{vector2f32_swizzle1, vector2f32_swizzle2, vector2f32_swizzle3, vector2f32_swizzle4, vector2f64_swizzle1, vector2f64_swizzle2, vector2f64_swizzle3, vector2f64_swizzle4}

Source

vector3_linear_to_srgb :: proc{vector3_linear_to_srgb_f16, vector3_linear_to_srgb_f32, vector3_linear_to_srgb_f64}Source

vector3_orthonormalize :: proc{vector3_orthonormalize_f16, vector3_orthonormalize_f32, vector3_orthonormalize_f64}Source

vector3_srgb_to_linear :: proc{vector3_srgb_to_linear_f16, vector3_srgb_to_linear_f32, vector3_srgb_to_linear_f64}Source

vector3_swizzle :: proc{vector3f32_swizzle1, vector3f32_swizzle2, vector3f32_swizzle3, vector3f32_swizzle4, vector3f64_swizzle1, vector3f64_swizzle2, vector3f64_swizzle3, vector3f64_swizzle4}

Source

vector4_hsl_to_rgb :: proc{vector4_hsl_to_rgb_f16, vector4_hsl_to_rgb_f32, vector4_hsl_to_rgb_f64}Source

vector4_linear_to_srgb :: proc{vector4_linear_to_srgb_f16, vector4_linear_to_srgb_f32, vector4_linear_to_srgb_f64}Source

vector4_rgb_to_hsl :: proc{vector4_rgb_to_hsl_f16, vector4_rgb_to_hsl_f32, vector4_rgb_to_hsl_f64}Source

vector4_srgb_to_linear :: proc{vector4_srgb_to_linear_f16, vector4_srgb_to_linear_f32, vector4_srgb_to_linear_f64}Source

vector4_swizzle :: proc{vector4f32_swizzle1, vector4f32_swizzle2, vector4f32_swizzle3, vector4f32_swizzle4, vector4f64_swizzle1, vector4f64_swizzle2, vector4f64_swizzle3, vector4f64_swizzle4}

Source

vector_cross :: proc{scalar_cross, vector_cross2, vector_cross3}Source

yaw_from_quaternion :: proc{yaw_from_quaternion_f16, yaw_from_quaternion_f32, yaw_from_quaternion_f64}Source

linalg

Types

Constants

Procedures

Procedure Groups

Find anything

Settings