package core:math/linalg
Source

Overview

core:math/linalg implements linear algebra procedures useful for 3D spatial transformations

Index

Types (77)
Variables (0)

This section is empty.

Procedures (637)
Procedure Groups (205)

Types

Euler_Angle_Order ¶
Source

Euler_Angle_Order :: enum int {
	// Tait-Bryan
	XYZ, 
	XZY, 
	YXZ, 
	YZX, 
	ZXY, 
	ZYX, 
	// Proper Euler
	XYX, 
	XZX, 
	YXY, 
	YZY, 
	ZXZ, 
	ZYZ, 
}

Matrix1f16 ¶
Source

Matrix1f16 :: Matrix1x1f16

Matrix1f32 ¶
Source

Matrix1f32 :: Matrix1x1f32

Matrix1f64 ¶
Source

Matrix1f64 :: Matrix1x1f64

Matrix1x1f16 ¶
Source

Matrix1x1f16 :: distinct matrix[1, 1]f16

Matrix1x1f32 ¶
Source

Matrix1x1f32 :: distinct matrix[1, 1]f32

Matrix1x1f64 ¶
Source

Matrix1x1f64 :: distinct matrix[1, 1]f64

Matrix1x2f16 ¶
Source

Matrix1x2f16 :: distinct matrix[1, 2]f16

Matrix1x2f32 ¶
Source

Matrix1x2f32 :: distinct matrix[1, 2]f32

Matrix1x2f64 ¶
Source

Matrix1x2f64 :: distinct matrix[1, 2]f64

Matrix1x3f16 ¶
Source

Matrix1x3f16 :: distinct matrix[1, 3]f16

Matrix1x3f32 ¶
Source

Matrix1x3f32 :: distinct matrix[1, 3]f32

Matrix1x3f64 ¶
Source

Matrix1x3f64 :: distinct matrix[1, 3]f64

Matrix1x4f16 ¶
Source

Matrix1x4f16 :: distinct matrix[1, 4]f16

Matrix1x4f32 ¶
Source

Matrix1x4f32 :: distinct matrix[1, 4]f32

Matrix1x4f64 ¶
Source

Matrix1x4f64 :: distinct matrix[1, 4]f64

Matrix2f16 ¶
Source

Matrix2f16 :: Matrix2x2f16

Matrix2f32 ¶
Source

Matrix2f32 :: Matrix2x2f32

Matrix2f64 ¶
Source

Matrix2f64 :: Matrix2x2f64

Matrix2x1f16 ¶
Source

Matrix2x1f16 :: distinct matrix[2, 1]f16

Matrix2x1f32 ¶
Source

Matrix2x1f32 :: distinct matrix[2, 1]f32

Matrix2x1f64 ¶
Source

Matrix2x1f64 :: distinct matrix[2, 1]f64

Matrix2x2f16 ¶
Source

Matrix2x2f16 :: distinct matrix[2, 2]f16

Matrix2x2f32 ¶
Source

Matrix2x2f32 :: distinct matrix[2, 2]f32

Matrix2x2f64 ¶
Source

Matrix2x2f64 :: distinct matrix[2, 2]f64

Matrix2x3f16 ¶
Source

Matrix2x3f16 :: distinct matrix[2, 3]f16

Matrix2x3f32 ¶
Source

Matrix2x3f32 :: distinct matrix[2, 3]f32

Matrix2x3f64 ¶
Source

Matrix2x3f64 :: distinct matrix[2, 3]f64

Matrix2x4f16 ¶
Source

Matrix2x4f16 :: distinct matrix[2, 4]f16

Matrix2x4f32 ¶
Source

Matrix2x4f32 :: distinct matrix[2, 4]f32

Matrix2x4f64 ¶
Source

Matrix2x4f64 :: distinct matrix[2, 4]f64

Matrix3f16 ¶
Source

Matrix3f16 :: Matrix3x3f16

Matrix3f32 ¶
Source

Matrix3f32 :: Matrix3x3f32

Matrix3f64 ¶
Source

Matrix3f64 :: Matrix3x3f64

Matrix3x1f16 ¶
Source

Matrix3x1f16 :: distinct matrix[3, 1]f16

Matrix3x1f32 ¶
Source

Matrix3x1f32 :: distinct matrix[3, 1]f32

Matrix3x1f64 ¶
Source

Matrix3x1f64 :: distinct matrix[3, 1]f64

Matrix3x2f16 ¶
Source

Matrix3x2f16 :: distinct matrix[3, 2]f16

Matrix3x2f32 ¶
Source

Matrix3x2f32 :: distinct matrix[3, 2]f32

Matrix3x2f64 ¶
Source

Matrix3x2f64 :: distinct matrix[3, 2]f64

Matrix3x3f16 ¶
Source

Matrix3x3f16 :: distinct matrix[3, 3]f16

Matrix3x3f32 ¶
Source

Matrix3x3f32 :: distinct matrix[3, 3]f32

Matrix3x3f64 ¶
Source

Matrix3x3f64 :: distinct matrix[3, 3]f64

Matrix3x4f16 ¶
Source

Matrix3x4f16 :: distinct matrix[3, 4]f16

Matrix3x4f32 ¶
Source

Matrix3x4f32 :: distinct matrix[3, 4]f32

Matrix3x4f64 ¶
Source

Matrix3x4f64 :: distinct matrix[3, 4]f64

Matrix4f16 ¶
Source

Matrix4f16 :: Matrix4x4f16

Matrix4f32 ¶
Source

Matrix4f32 :: Matrix4x4f32

Matrix4f64 ¶
Source

Matrix4f64 :: Matrix4x4f64

Matrix4x1f16 ¶
Source

Matrix4x1f16 :: distinct matrix[4, 1]f16

Matrix4x1f32 ¶
Source

Matrix4x1f32 :: distinct matrix[4, 1]f32

Matrix4x1f64 ¶
Source

Matrix4x1f64 :: distinct matrix[4, 1]f64

Matrix4x2f16 ¶
Source

Matrix4x2f16 :: distinct matrix[4, 2]f16

Matrix4x2f32 ¶
Source

Matrix4x2f32 :: distinct matrix[4, 2]f32

Matrix4x2f64 ¶
Source

Matrix4x2f64 :: distinct matrix[4, 2]f64

Matrix4x3f16 ¶
Source

Matrix4x3f16 :: distinct matrix[4, 3]f16

Matrix4x3f32 ¶
Source

Matrix4x3f32 :: distinct matrix[4, 3]f32

Matrix4x3f64 ¶
Source

Matrix4x3f64 :: distinct matrix[4, 3]f64

Matrix4x4f16 ¶
Source

Matrix4x4f16 :: distinct matrix[4, 4]f16

Matrix4x4f32 ¶
Source

Matrix4x4f32 :: distinct matrix[4, 4]f32

Matrix4x4f64 ¶
Source

Matrix4x4f64 :: distinct matrix[4, 4]f64

Quaternionf16 ¶
Source

Quaternionf16 :: distinct quaternion64

Quaternionf32 ¶
Source

Quaternionf32 :: distinct quaternion128

Quaternionf64 ¶
Source

Quaternionf64 :: distinct quaternion256

Scalar_Components ¶
Source

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

Vector2_Components ¶
Source

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

Vector2f16 ¶
Source

Vector2f16 :: distinct [2]f16

Vector2f32 ¶
Source

Vector2f32 :: distinct [2]f32

Vector2f64 ¶
Source

Vector2f64 :: distinct [2]f64

Vector3_Components ¶
Source

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

Vector3f16 ¶
Source

Vector3f16 :: distinct [3]f16

Vector3f32 ¶
Source

Vector3f32 :: distinct [3]f32

Vector3f64 ¶
Source

Vector3f64 :: distinct [3]f64

Vector4_Components ¶
Source

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

Vector4f16 ¶
Source

Vector4f16 :: distinct [4]f16

Vector4f32 ¶
Source

Vector4f32 :: distinct [4]f32

Vector4f64 ¶
Source

Vector4f64 :: distinct [4]f64

Constants

DEG_PER_RAD ¶
Source

DEG_PER_RAD :: 360.0 / TAU

E ¶
Source

E :: 2.71828182845904523536

F16_EPSILON ¶
Source

F16_EPSILON :: 1e-3

F32_EPSILON ¶
Source

F32_EPSILON :: 1e-7

F64_EPSILON ¶
Source

F64_EPSILON :: 1e-15

LN10 ¶
Source

LN10 :: 2.30258509299404568401799145468436421

LN2 ¶
Source

LN2 :: 0.693147180559945309417232121458176568

MATRIX1F16_IDENTITY ¶
Source

MATRIX1F16_IDENTITY: Matrix1x1f16 : Matrix1f16(1)

MATRIX1F32_IDENTITY ¶
Source

MATRIX1F32_IDENTITY: Matrix1x1f32 : Matrix1f32(1)

MATRIX1F64_IDENTITY ¶
Source

MATRIX1F64_IDENTITY: Matrix1x1f64 : Matrix1f64(1)

MATRIX2F16_IDENTITY ¶
Source

MATRIX2F16_IDENTITY: Matrix2x2f16 : Matrix2f16(1)

MATRIX2F32_IDENTITY ¶
Source

MATRIX2F32_IDENTITY: Matrix2x2f32 : Matrix2f32(1)

MATRIX2F64_IDENTITY ¶
Source

MATRIX2F64_IDENTITY: Matrix2x2f64 : Matrix2f64(1)

MATRIX3F16_IDENTITY ¶
Source

MATRIX3F16_IDENTITY: Matrix3x3f16 : Matrix3f16(1)

MATRIX3F32_IDENTITY ¶
Source

MATRIX3F32_IDENTITY: Matrix3x3f32 : Matrix3f32(1)

MATRIX3F64_IDENTITY ¶
Source

MATRIX3F64_IDENTITY: Matrix3x3f64 : Matrix3f64(1)

MATRIX4F16_IDENTITY ¶
Source

MATRIX4F16_IDENTITY: Matrix4x4f16 : Matrix4f16(1)

MATRIX4F32_IDENTITY ¶
Source

MATRIX4F32_IDENTITY: Matrix4x4f32 : Matrix4f32(1)

MATRIX4F64_IDENTITY ¶
Source

MATRIX4F64_IDENTITY: Matrix4x4f64 : Matrix4f64(1)

MAX_F32_PRECISION ¶
Source

MAX_F32_PRECISION :: 8
 

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

MAX_F64_PRECISION ¶
Source

MAX_F64_PRECISION :: 16
 

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

PI ¶
Source

PI :: 3.14159265358979323846264338327950288

QUATERNIONF16_IDENTITY ¶
Source

QUATERNIONF16_IDENTITY :: Quaternionf16(1)

QUATERNIONF32_IDENTITY ¶
Source

QUATERNIONF32_IDENTITY :: Quaternionf32(1)

QUATERNIONF64_IDENTITY ¶
Source

QUATERNIONF64_IDENTITY :: Quaternionf64(1)

RAD_PER_DEG ¶
Source

RAD_PER_DEG :: TAU / 360.0

SQRT_FIVE ¶
Source

SQRT_FIVE :: 2.23606797749978969640917366873127623

SQRT_THREE ¶
Source

SQRT_THREE :: 1.73205080756887729352744634150587236

SQRT_TWO ¶
Source

SQRT_TWO :: 1.41421356237309504880168872420969808

TAU ¶
Source

TAU :: 6.28318530717958647692528676655900576

VECTOR3F16_X_AXIS ¶
Source

VECTOR3F16_X_AXIS :: Vector3f16{1, 0, 0}

VECTOR3F16_Y_AXIS ¶
Source

VECTOR3F16_Y_AXIS :: Vector3f16{0, 1, 0}

VECTOR3F16_Z_AXIS ¶
Source

VECTOR3F16_Z_AXIS :: Vector3f16{0, 0, 1}

VECTOR3F32_X_AXIS ¶
Source

VECTOR3F32_X_AXIS :: Vector3f32{1, 0, 0}

VECTOR3F32_Y_AXIS ¶
Source

VECTOR3F32_Y_AXIS :: Vector3f32{0, 1, 0}

VECTOR3F32_Z_AXIS ¶
Source

VECTOR3F32_Z_AXIS :: Vector3f32{0, 0, 1}

VECTOR3F64_X_AXIS ¶
Source

VECTOR3F64_X_AXIS :: Vector3f64{1, 0, 0}

VECTOR3F64_Y_AXIS ¶
Source

VECTOR3F64_Y_AXIS :: Vector3f64{0, 1, 0}

VECTOR3F64_Z_AXIS ¶
Source

VECTOR3F64_Z_AXIS :: Vector3f64{0, 0, 1}

e ¶
Source

e :: E

π ¶
Source

π :: PI

τ ¶
Source

τ :: TAU

Variables

This section is empty.

Procedures

abs ¶
Source

abs :: proc "odin" (a: $T) -> (out: $T) {…}

acos ¶
Source

acos :: proc "odin" (x: $T) -> (out: $T) {…}

all ¶
Source

all :: proc "odin" (x: $A/[0]bool) -> (out: bool) {…}

angle_axis_from_quaternion_f16 ¶
Source

angle_axis_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (angle: f16, axis: Vector3f16) {…}

angle_axis_from_quaternion_f32 ¶
Source

angle_axis_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (angle: f32, axis: Vector3f32) {…}

angle_axis_from_quaternion_f64 ¶
Source

angle_axis_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (angle: f64, axis: Vector3f64) {…}

angle_from_quaternion_f16 ¶
Source

angle_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> f16 {…}

angle_from_quaternion_f32 ¶
Source

angle_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> f32 {…}

angle_from_quaternion_f64 ¶
Source

angle_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> f64 {…}

any ¶
Source

any :: proc "odin" (x: $A/[0]bool) -> (out: bool) {…}

array_cast ¶
Source

array_cast :: proc "odin" (v: $V/[0]$T, $Elem_Type: typeid) -> (w: [0]typeid) {…}

asin ¶
Source

asin :: proc "odin" (x: $T) -> (out: $T) {…}

atan ¶
Source

atan :: proc "odin" (x: $T) -> (out: $T) {…}

atan2 ¶
Source

atan2 :: proc "odin" (y, x: $T) -> (out: $T) {…}

axis_from_quaternion_f16 ¶
Source

axis_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> Vector3f16 {…}

axis_from_quaternion_f32 ¶
Source

axis_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> Vector3f32 {…}

axis_from_quaternion_f64 ¶
Source

axis_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> Vector3f64 {…}

catmull_rom ¶
Source

catmull_rom :: proc "odin" (v1, v2, v3, v4: $V/[0]$T, s: $T) -> $V/[0]$T {…}

ceil ¶
Source

ceil :: proc "odin" (x: $T) -> (out: $T) {…}

clamp ¶
Source

clamp :: proc "odin" (x, a, b: $T) -> (out: $T) {…}

classify_array ¶
Source

classify_array :: proc "odin" (x: $V/[0]$T) -> (out: [0]math.Float_Class) {…}

classify_single ¶
Source

classify_single :: proc "odin" (x: $T) -> math.Float_Class {…}

cos ¶
Source

cos :: proc "odin" (x: $T) -> (out: $T) {…}

cubic ¶
Source

cubic :: proc "odin" (v1, v2, v3, v4: $V/[0]$T, s: $T) -> $V/[0]$T {…}

degrees ¶
Source

degrees :: proc "odin" (radians: $T) -> (out: $T) {…}

distance ¶
Source

distance :: proc "odin" (p0, p1: $V/[0]$T) -> $T {…}

equal_array ¶
Source

equal_array :: proc "odin" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

equal_single ¶
Source

equal_single :: proc "odin" (x, y: $T) -> (out: bool) {…}

euclidean_from_polar_f16 ¶
Source

euclidean_from_polar_f16 :: proc "odin" (polar: Vector2f16) -> Vector3f16 {…}

euclidean_from_polar_f32 ¶
Source

euclidean_from_polar_f32 :: proc "odin" (polar: Vector2f32) -> Vector3f32 {…}

euclidean_from_polar_f64 ¶
Source

euclidean_from_polar_f64 :: proc "odin" (polar: Vector2f64) -> Vector3f64 {…}

euler_angles_from_matrix3_f16 ¶
Source

euler_angles_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) {…}

euler_angles_from_matrix3_f32 ¶
Source

euler_angles_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {…}

euler_angles_from_matrix3_f64 ¶
Source

euler_angles_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {…}

euler_angles_from_matrix4_f16 ¶
Source

euler_angles_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) {…}

euler_angles_from_matrix4_f32 ¶
Source

euler_angles_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {…}

euler_angles_from_matrix4_f64 ¶
Source

euler_angles_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {…}

euler_angles_from_quaternion_f16 ¶
Source

euler_angles_from_quaternion_f16 :: proc "odin" (m: Quaternionf16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) {…}

euler_angles_from_quaternion_f32 ¶
Source

euler_angles_from_quaternion_f32 :: proc "odin" (m: Quaternionf32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {…}

euler_angles_from_quaternion_f64 ¶
Source

euler_angles_from_quaternion_f64 :: proc "odin" (m: Quaternionf64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {…}

euler_angles_xyx_from_matrix3_f16 ¶
Source

euler_angles_xyx_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_xyx_from_matrix3_f32 ¶
Source

euler_angles_xyx_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_xyx_from_matrix3_f64 ¶
Source

euler_angles_xyx_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_xyx_from_matrix4_f16 ¶
Source

euler_angles_xyx_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_xyx_from_matrix4_f32 ¶
Source

euler_angles_xyx_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_xyx_from_matrix4_f64 ¶
Source

euler_angles_xyx_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_xyx_from_quaternion_f16 ¶
Source

euler_angles_xyx_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_xyx_from_quaternion_f32 ¶
Source

euler_angles_xyx_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_xyx_from_quaternion_f64 ¶
Source

euler_angles_xyx_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_xyz_from_matrix3_f16 ¶
Source

euler_angles_xyz_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_xyz_from_matrix3_f32 ¶
Source

euler_angles_xyz_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_xyz_from_matrix3_f64 ¶
Source

euler_angles_xyz_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_xyz_from_matrix4_f16 ¶
Source

euler_angles_xyz_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_xyz_from_matrix4_f32 ¶
Source

euler_angles_xyz_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_xyz_from_matrix4_f64 ¶
Source

euler_angles_xyz_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_xyz_from_quaternion_f16 ¶
Source

euler_angles_xyz_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_xyz_from_quaternion_f32 ¶
Source

euler_angles_xyz_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_xyz_from_quaternion_f64 ¶
Source

euler_angles_xyz_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_xzx_from_matrix3_f16 ¶
Source

euler_angles_xzx_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_xzx_from_matrix3_f32 ¶
Source

euler_angles_xzx_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_xzx_from_matrix3_f64 ¶
Source

euler_angles_xzx_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_xzx_from_matrix4_f16 ¶
Source

euler_angles_xzx_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_xzx_from_matrix4_f32 ¶
Source

euler_angles_xzx_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_xzx_from_matrix4_f64 ¶
Source

euler_angles_xzx_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_xzx_from_quaternion_f16 ¶
Source

euler_angles_xzx_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_xzx_from_quaternion_f32 ¶
Source

euler_angles_xzx_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_xzx_from_quaternion_f64 ¶
Source

euler_angles_xzx_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_xzy_from_matrix3_f16 ¶
Source

euler_angles_xzy_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_xzy_from_matrix3_f32 ¶
Source

euler_angles_xzy_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_xzy_from_matrix3_f64 ¶
Source

euler_angles_xzy_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_xzy_from_matrix4_f16 ¶
Source

euler_angles_xzy_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_xzy_from_matrix4_f32 ¶
Source

euler_angles_xzy_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_xzy_from_matrix4_f64 ¶
Source

euler_angles_xzy_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_xzy_from_quaternion_f16 ¶
Source

euler_angles_xzy_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_xzy_from_quaternion_f32 ¶
Source

euler_angles_xzy_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_xzy_from_quaternion_f64 ¶
Source

euler_angles_xzy_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_yxy_from_matrix3_f16 ¶
Source

euler_angles_yxy_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_yxy_from_matrix3_f32 ¶
Source

euler_angles_yxy_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_yxy_from_matrix3_f64 ¶
Source

euler_angles_yxy_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_yxy_from_matrix4_f16 ¶
Source

euler_angles_yxy_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_yxy_from_matrix4_f32 ¶
Source

euler_angles_yxy_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_yxy_from_matrix4_f64 ¶
Source

euler_angles_yxy_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_yxy_from_quaternion_f16 ¶
Source

euler_angles_yxy_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_yxy_from_quaternion_f32 ¶
Source

euler_angles_yxy_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_yxy_from_quaternion_f64 ¶
Source

euler_angles_yxy_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_yxz_from_matrix3_f16 ¶
Source

euler_angles_yxz_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_yxz_from_matrix3_f32 ¶
Source

euler_angles_yxz_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_yxz_from_matrix3_f64 ¶
Source

euler_angles_yxz_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_yxz_from_matrix4_f16 ¶
Source

euler_angles_yxz_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_yxz_from_matrix4_f32 ¶
Source

euler_angles_yxz_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_yxz_from_matrix4_f64 ¶
Source

euler_angles_yxz_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_yxz_from_quaternion_f16 ¶
Source

euler_angles_yxz_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_yxz_from_quaternion_f32 ¶
Source

euler_angles_yxz_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_yxz_from_quaternion_f64 ¶
Source

euler_angles_yxz_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_yzx_from_matrix3_f16 ¶
Source

euler_angles_yzx_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_yzx_from_matrix3_f32 ¶
Source

euler_angles_yzx_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_yzx_from_matrix3_f64 ¶
Source

euler_angles_yzx_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_yzx_from_matrix4_f16 ¶
Source

euler_angles_yzx_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_yzx_from_matrix4_f32 ¶
Source

euler_angles_yzx_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_yzx_from_matrix4_f64 ¶
Source

euler_angles_yzx_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_yzx_from_quaternion_f16 ¶
Source

euler_angles_yzx_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_yzx_from_quaternion_f32 ¶
Source

euler_angles_yzx_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_yzx_from_quaternion_f64 ¶
Source

euler_angles_yzx_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_yzy_from_matrix3_f16 ¶
Source

euler_angles_yzy_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_yzy_from_matrix3_f32 ¶
Source

euler_angles_yzy_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_yzy_from_matrix3_f64 ¶
Source

euler_angles_yzy_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_yzy_from_matrix4_f16 ¶
Source

euler_angles_yzy_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_yzy_from_matrix4_f32 ¶
Source

euler_angles_yzy_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_yzy_from_matrix4_f64 ¶
Source

euler_angles_yzy_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_yzy_from_quaternion_f16 ¶
Source

euler_angles_yzy_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_yzy_from_quaternion_f32 ¶
Source

euler_angles_yzy_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_yzy_from_quaternion_f64 ¶
Source

euler_angles_yzy_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_zxy_from_matrix3_f16 ¶
Source

euler_angles_zxy_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_zxy_from_matrix3_f32 ¶
Source

euler_angles_zxy_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_zxy_from_matrix3_f64 ¶
Source

euler_angles_zxy_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_zxy_from_matrix4_f16 ¶
Source

euler_angles_zxy_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_zxy_from_matrix4_f32 ¶
Source

euler_angles_zxy_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_zxy_from_matrix4_f64 ¶
Source

euler_angles_zxy_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_zxy_from_quaternion_f16 ¶
Source

euler_angles_zxy_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_zxy_from_quaternion_f32 ¶
Source

euler_angles_zxy_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_zxy_from_quaternion_f64 ¶
Source

euler_angles_zxy_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_zxz_from_matrix3_f16 ¶
Source

euler_angles_zxz_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_zxz_from_matrix3_f32 ¶
Source

euler_angles_zxz_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_zxz_from_matrix3_f64 ¶
Source

euler_angles_zxz_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_zxz_from_matrix4_f16 ¶
Source

euler_angles_zxz_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_zxz_from_matrix4_f32 ¶
Source

euler_angles_zxz_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_zxz_from_matrix4_f64 ¶
Source

euler_angles_zxz_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_zxz_from_quaternion_f16 ¶
Source

euler_angles_zxz_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_zxz_from_quaternion_f32 ¶
Source

euler_angles_zxz_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_zxz_from_quaternion_f64 ¶
Source

euler_angles_zxz_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_zyx_from_matrix3_f16 ¶
Source

euler_angles_zyx_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_zyx_from_matrix3_f32 ¶
Source

euler_angles_zyx_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_zyx_from_matrix3_f64 ¶
Source

euler_angles_zyx_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_zyx_from_matrix4_f16 ¶
Source

euler_angles_zyx_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_zyx_from_matrix4_f32 ¶
Source

euler_angles_zyx_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_zyx_from_matrix4_f64 ¶
Source

euler_angles_zyx_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_zyx_from_quaternion_f16 ¶
Source

euler_angles_zyx_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_zyx_from_quaternion_f32 ¶
Source

euler_angles_zyx_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_zyx_from_quaternion_f64 ¶
Source

euler_angles_zyx_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

euler_angles_zyz_from_matrix3_f16 ¶
Source

euler_angles_zyz_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (t1, t2, t3: f16) {…}

euler_angles_zyz_from_matrix3_f32 ¶
Source

euler_angles_zyz_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (t1, t2, t3: f32) {…}

euler_angles_zyz_from_matrix3_f64 ¶
Source

euler_angles_zyz_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (t1, t2, t3: f64) {…}

euler_angles_zyz_from_matrix4_f16 ¶
Source

euler_angles_zyz_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (t1, t2, t3: f16) {…}

euler_angles_zyz_from_matrix4_f32 ¶
Source

euler_angles_zyz_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (t1, t2, t3: f32) {…}

euler_angles_zyz_from_matrix4_f64 ¶
Source

euler_angles_zyz_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (t1, t2, t3: f64) {…}

euler_angles_zyz_from_quaternion_f16 ¶
Source

euler_angles_zyz_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (t1, t2, t3: f16) {…}

euler_angles_zyz_from_quaternion_f32 ¶
Source

euler_angles_zyz_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (t1, t2, t3: f32) {…}

euler_angles_zyz_from_quaternion_f64 ¶
Source

euler_angles_zyz_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (t1, t2, t3: f64) {…}

exp ¶
Source

exp :: proc "odin" (x: $T) -> (out: $T) {…}

exp10 ¶
Source

exp10 :: proc "odin" (x: $T) -> (out: $T) {…}

exp2 ¶
Source

exp2 :: proc "odin" (x: $T) -> (out: $T) {…}

face_forward ¶
Source

face_forward :: proc "odin" (N, I, N_ref: $T) -> (out: $T) {…}

floor ¶
Source

floor :: proc "odin" (x: $T) -> (out: $T) {…}

fract ¶
Source

fract :: proc "odin" (x: $T) -> $T {…}

greater_than_array ¶
Source

greater_than_array :: proc "odin" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

greater_than_equal_array ¶
Source

greater_than_equal_array :: proc "odin" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

greater_than_equal_single ¶
Source

greater_than_equal_single :: proc "odin" (x, y: $T) -> (out: bool) {…}

greater_than_single ¶
Source

greater_than_single :: proc "odin" (x, y: $T) -> (out: bool) {…}

hermite ¶
Source

hermite :: proc "odin" (v1, t1, v2, t2: $V/[0]$T, s: $T) -> $V/[0]$T {…}

identity ¶
Source

identity :: proc "odin" ($T: typeid/[0][0]T) -> (m: $/[0][0]T) {…}

inverse_sqrt ¶
Source

inverse_sqrt :: proc "odin" (x: $T) -> (out: $T) {…}

is_inf_array ¶
Source

is_inf_array :: proc "odin" (x: $V/[0]$T) -> (out: [0]bool) {…}

is_inf_single ¶
Source

is_inf_single :: proc "odin" (x: $T) -> bool {…}

is_nan_array ¶
Source

is_nan_array :: proc "odin" (x: $V/[0]$T) -> (out: [0]bool) {…}

is_nan_single ¶
Source

is_nan_single :: proc "odin" (x: $T) -> bool {…}

lerp ¶
Source

lerp :: proc "odin" (a, b, t: $T) -> (out: $T) {…}

less_than_array ¶
Source

less_than_array :: proc "odin" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

less_than_equal_array ¶
Source

less_than_equal_array :: proc "odin" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

less_than_equal_single ¶
Source

less_than_equal_single :: proc "odin" (x, y: $T) -> (out: bool) {…}

less_than_single ¶
Source

less_than_single :: proc "odin" (x, y: $T) -> (out: bool) {…}

ln ¶
Source

ln :: proc "odin" (x: $T) -> (out: $T) {…}

log ¶
Source

log :: proc "odin" (x, b: $T) -> (out: $T) {…}

log10 ¶
Source

log10 :: proc "odin" (x: $T) -> (out: $T) {…}

log2 ¶
Source

log2 :: proc "odin" (x: $T) -> (out: $T) {…}

matrix2_adjoint_f16 ¶
Source

matrix2_adjoint_f16 :: proc "odin" (m: Matrix2x2f16) -> (c: Matrix2x2f16) {…}

matrix2_adjoint_f32 ¶
Source

matrix2_adjoint_f32 :: proc "odin" (m: Matrix2x2f32) -> (c: Matrix2x2f32) {…}

matrix2_adjoint_f64 ¶
Source

matrix2_adjoint_f64 :: proc "odin" (m: Matrix2x2f64) -> (c: Matrix2x2f64) {…}

matrix2_determinant_f16 ¶
Source

matrix2_determinant_f16 :: proc "odin" (m: Matrix2x2f16) -> f16 {…}

matrix2_determinant_f32 ¶
Source

matrix2_determinant_f32 :: proc "odin" (m: Matrix2x2f32) -> f32 {…}

matrix2_determinant_f64 ¶
Source

matrix2_determinant_f64 :: proc "odin" (m: Matrix2x2f64) -> f64 {…}

matrix2_from_matrix3_f16 ¶
Source

matrix2_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (r: Matrix2x2f16) {…}

matrix2_from_matrix3_f32 ¶
Source

matrix2_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (r: Matrix2x2f32) {…}

matrix2_from_matrix3_f64 ¶
Source

matrix2_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (r: Matrix2x2f64) {…}

matrix2_from_matrix4_f16 ¶
Source

matrix2_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (r: Matrix2x2f16) {…}

matrix2_from_matrix4_f32 ¶
Source

matrix2_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (r: Matrix2x2f32) {…}

matrix2_from_matrix4_f64 ¶
Source

matrix2_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (r: Matrix2x2f64) {…}

matrix2_from_scalar_f16 ¶
Source

matrix2_from_scalar_f16 :: proc "odin" (f: f16) -> (m: Matrix2x2f16) {…}

matrix2_from_scalar_f32 ¶
Source

matrix2_from_scalar_f32 :: proc "odin" (f: f32) -> (m: Matrix2x2f32) {…}

matrix2_from_scalar_f64 ¶
Source

matrix2_from_scalar_f64 :: proc "odin" (f: f64) -> (m: Matrix2x2f64) {…}

matrix2_inverse_f16 ¶
Source

matrix2_inverse_f16 :: proc "odin" (m: Matrix2x2f16) -> (c: Matrix2x2f16) {…}

matrix2_inverse_f32 ¶
Source

matrix2_inverse_f32 :: proc "odin" (m: Matrix2x2f32) -> (c: Matrix2x2f32) {…}

matrix2_inverse_f64 ¶
Source

matrix2_inverse_f64 :: proc "odin" (m: Matrix2x2f64) -> (c: Matrix2x2f64) {…}

matrix2_inverse_transpose_f16 ¶
Source

matrix2_inverse_transpose_f16 :: proc "odin" (m: Matrix2x2f16) -> (c: Matrix2x2f16) {…}

matrix2_inverse_transpose_f32 ¶
Source

matrix2_inverse_transpose_f32 :: proc "odin" (m: Matrix2x2f32) -> (c: Matrix2x2f32) {…}

matrix2_inverse_transpose_f64 ¶
Source

matrix2_inverse_transpose_f64 :: proc "odin" (m: Matrix2x2f64) -> (c: Matrix2x2f64) {…}

matrix2_orthonormalize_f16 ¶
Source

matrix2_orthonormalize_f16 :: proc "odin" (m: Matrix2x2f16) -> (r: Matrix2x2f16) {…}

matrix2_orthonormalize_f32 ¶
Source

matrix2_orthonormalize_f32 :: proc "odin" (m: Matrix2x2f32) -> (r: Matrix2x2f32) {…}

matrix2_orthonormalize_f64 ¶
Source

matrix2_orthonormalize_f64 :: proc "odin" (m: Matrix2x2f64) -> (r: Matrix2x2f64) {…}

matrix3_adjoint_f16 ¶
Source

matrix3_adjoint_f16 :: proc "odin" (m: Matrix3x3f16) -> (adjoint: Matrix3x3f16) {…}

matrix3_adjoint_f32 ¶
Source

matrix3_adjoint_f32 :: proc "odin" (m: Matrix3x3f32) -> (adjoint: Matrix3x3f32) {…}

matrix3_adjoint_f64 ¶
Source

matrix3_adjoint_f64 :: proc "odin" (m: Matrix3x3f64) -> (adjoint: Matrix3x3f64) {…}

matrix3_determinant_f16 ¶
Source

matrix3_determinant_f16 :: proc "odin" (m: Matrix3x3f16) -> f16 {…}

matrix3_determinant_f32 ¶
Source

matrix3_determinant_f32 :: proc "odin" (m: Matrix3x3f32) -> f32 {…}

matrix3_determinant_f64 ¶
Source

matrix3_determinant_f64 :: proc "odin" (m: Matrix3x3f64) -> f64 {…}

matrix3_from_derived_euler_angle_x_f16 ¶
Source

matrix3_from_derived_euler_angle_x_f16 :: proc "odin" (angle_x: f16, angular_velocity_x: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_derived_euler_angle_x_f32 ¶
Source

matrix3_from_derived_euler_angle_x_f32 :: proc "odin" (angle_x: f32, angular_velocity_x: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_derived_euler_angle_x_f64 ¶
Source

matrix3_from_derived_euler_angle_x_f64 :: proc "odin" (angle_x: f64, angular_velocity_x: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_derived_euler_angle_y_f16 ¶
Source

matrix3_from_derived_euler_angle_y_f16 :: proc "odin" (angle_y: f16, angular_velocity_y: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_derived_euler_angle_y_f32 ¶
Source

matrix3_from_derived_euler_angle_y_f32 :: proc "odin" (angle_y: f32, angular_velocity_y: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_derived_euler_angle_y_f64 ¶
Source

matrix3_from_derived_euler_angle_y_f64 :: proc "odin" (angle_y: f64, angular_velocity_y: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_derived_euler_angle_z_f16 ¶
Source

matrix3_from_derived_euler_angle_z_f16 :: proc "odin" (angle_z: f16, angular_velocity_z: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_derived_euler_angle_z_f32 ¶
Source

matrix3_from_derived_euler_angle_z_f32 :: proc "odin" (angle_z: f32, angular_velocity_z: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_derived_euler_angle_z_f64 ¶
Source

matrix3_from_derived_euler_angle_z_f64 :: proc "odin" (angle_z: f64, angular_velocity_z: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angle_x_f16 ¶
Source

matrix3_from_euler_angle_x_f16 :: proc "odin" (angle_x: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angle_x_f32 ¶
Source

matrix3_from_euler_angle_x_f32 :: proc "odin" (angle_x: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angle_x_f64 ¶
Source

matrix3_from_euler_angle_x_f64 :: proc "odin" (angle_x: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angle_y_f16 ¶
Source

matrix3_from_euler_angle_y_f16 :: proc "odin" (angle_y: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angle_y_f32 ¶
Source

matrix3_from_euler_angle_y_f32 :: proc "odin" (angle_y: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angle_y_f64 ¶
Source

matrix3_from_euler_angle_y_f64 :: proc "odin" (angle_y: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angle_z_f16 ¶
Source

matrix3_from_euler_angle_z_f16 :: proc "odin" (angle_z: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angle_z_f32 ¶
Source

matrix3_from_euler_angle_z_f32 :: proc "odin" (angle_z: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angle_z_f64 ¶
Source

matrix3_from_euler_angle_z_f64 :: proc "odin" (angle_z: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_f16 ¶
Source

matrix3_from_euler_angles_f16 :: proc "odin" (t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_f32 ¶
Source

matrix3_from_euler_angles_f32 :: proc "odin" (t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_f64 ¶
Source

matrix3_from_euler_angles_f64 :: proc "odin" (t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_xy_f16 ¶
Source

matrix3_from_euler_angles_xy_f16 :: proc "odin" (angle_x, angle_y: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_xy_f32 ¶
Source

matrix3_from_euler_angles_xy_f32 :: proc "odin" (angle_x, angle_y: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_xy_f64 ¶
Source

matrix3_from_euler_angles_xy_f64 :: proc "odin" (angle_x, angle_y: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_xyx_f16 ¶
Source

matrix3_from_euler_angles_xyx_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_xyx_f32 ¶
Source

matrix3_from_euler_angles_xyx_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_xyx_f64 ¶
Source

matrix3_from_euler_angles_xyx_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_xyz_f16 ¶
Source

matrix3_from_euler_angles_xyz_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_xyz_f32 ¶
Source

matrix3_from_euler_angles_xyz_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_xyz_f64 ¶
Source

matrix3_from_euler_angles_xyz_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_xz_f16 ¶
Source

matrix3_from_euler_angles_xz_f16 :: proc "odin" (angle_x, angle_z: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_xz_f32 ¶
Source

matrix3_from_euler_angles_xz_f32 :: proc "odin" (angle_x, angle_z: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_xz_f64 ¶
Source

matrix3_from_euler_angles_xz_f64 :: proc "odin" (angle_x, angle_z: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_xzx_f16 ¶
Source

matrix3_from_euler_angles_xzx_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_xzx_f32 ¶
Source

matrix3_from_euler_angles_xzx_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_xzx_f64 ¶
Source

matrix3_from_euler_angles_xzx_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_xzy_f16 ¶
Source

matrix3_from_euler_angles_xzy_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_xzy_f32 ¶
Source

matrix3_from_euler_angles_xzy_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_xzy_f64 ¶
Source

matrix3_from_euler_angles_xzy_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_yx_f16 ¶
Source

matrix3_from_euler_angles_yx_f16 :: proc "odin" (angle_y, angle_x: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_yx_f32 ¶
Source

matrix3_from_euler_angles_yx_f32 :: proc "odin" (angle_y, angle_x: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_yx_f64 ¶
Source

matrix3_from_euler_angles_yx_f64 :: proc "odin" (angle_y, angle_x: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_yxy_f16 ¶
Source

matrix3_from_euler_angles_yxy_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_yxy_f32 ¶
Source

matrix3_from_euler_angles_yxy_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_yxy_f64 ¶
Source

matrix3_from_euler_angles_yxy_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_yxz_f16 ¶
Source

matrix3_from_euler_angles_yxz_f16 :: proc "odin" (yaw, pitch, roll: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_yxz_f32 ¶
Source

matrix3_from_euler_angles_yxz_f32 :: proc "odin" (yaw, pitch, roll: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_yxz_f64 ¶
Source

matrix3_from_euler_angles_yxz_f64 :: proc "odin" (yaw, pitch, roll: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_yz_f16 ¶
Source

matrix3_from_euler_angles_yz_f16 :: proc "odin" (angle_y, angle_z: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_yz_f32 ¶
Source

matrix3_from_euler_angles_yz_f32 :: proc "odin" (angle_y, angle_z: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_yz_f64 ¶
Source

matrix3_from_euler_angles_yz_f64 :: proc "odin" (angle_y, angle_z: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_yzx_f16 ¶
Source

matrix3_from_euler_angles_yzx_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_yzx_f32 ¶
Source

matrix3_from_euler_angles_yzx_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_yzx_f64 ¶
Source

matrix3_from_euler_angles_yzx_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_yzy_f16 ¶
Source

matrix3_from_euler_angles_yzy_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_yzy_f32 ¶
Source

matrix3_from_euler_angles_yzy_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_yzy_f64 ¶
Source

matrix3_from_euler_angles_yzy_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_zx_f16 ¶
Source

matrix3_from_euler_angles_zx_f16 :: proc "odin" (angle_z, angle_x: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_zx_f32 ¶
Source

matrix3_from_euler_angles_zx_f32 :: proc "odin" (angle_z, angle_x: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_zx_f64 ¶
Source

matrix3_from_euler_angles_zx_f64 :: proc "odin" (angle_z, angle_x: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_zxy_f16 ¶
Source

matrix3_from_euler_angles_zxy_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_zxy_f32 ¶
Source

matrix3_from_euler_angles_zxy_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_zxy_f64 ¶
Source

matrix3_from_euler_angles_zxy_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_zxz_f16 ¶
Source

matrix3_from_euler_angles_zxz_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_zxz_f32 ¶
Source

matrix3_from_euler_angles_zxz_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_zxz_f64 ¶
Source

matrix3_from_euler_angles_zxz_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_zy_f16 ¶
Source

matrix3_from_euler_angles_zy_f16 :: proc "odin" (angle_z, angle_y: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_zy_f32 ¶
Source

matrix3_from_euler_angles_zy_f32 :: proc "odin" (angle_z, angle_y: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_zy_f64 ¶
Source

matrix3_from_euler_angles_zy_f64 :: proc "odin" (angle_z, angle_y: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_zyx_f16 ¶
Source

matrix3_from_euler_angles_zyx_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_zyx_f32 ¶
Source

matrix3_from_euler_angles_zyx_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_zyx_f64 ¶
Source

matrix3_from_euler_angles_zyx_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_euler_angles_zyz_f16 ¶
Source

matrix3_from_euler_angles_zyz_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_euler_angles_zyz_f32 ¶
Source

matrix3_from_euler_angles_zyz_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_euler_angles_zyz_f64 ¶
Source

matrix3_from_euler_angles_zyz_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_matrix2_f16 ¶
Source

matrix3_from_matrix2_f16 :: proc "odin" (m: Matrix2x2f16) -> (r: Matrix3x3f16) {…}

matrix3_from_matrix2_f32 ¶
Source

matrix3_from_matrix2_f32 :: proc "odin" (m: Matrix2x2f32) -> (r: Matrix3x3f32) {…}

matrix3_from_matrix2_f64 ¶
Source

matrix3_from_matrix2_f64 :: proc "odin" (m: Matrix2x2f64) -> (r: Matrix3x3f64) {…}

matrix3_from_matrix4_f16 ¶
Source

matrix3_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (r: Matrix3x3f16) {…}

matrix3_from_matrix4_f32 ¶
Source

matrix3_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (r: Matrix3x3f32) {…}

matrix3_from_matrix4_f64 ¶
Source

matrix3_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (r: Matrix3x3f64) {…}

matrix3_from_quaternion_f16 ¶
Source

matrix3_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (m: Matrix3x3f16) {…}

matrix3_from_quaternion_f32 ¶
Source

matrix3_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (m: Matrix3x3f32) {…}

matrix3_from_quaternion_f64 ¶
Source

matrix3_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (m: Matrix3x3f64) {…}

matrix3_from_scalar_f16 ¶
Source

matrix3_from_scalar_f16 :: proc "odin" (f: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_scalar_f32 ¶
Source

matrix3_from_scalar_f32 :: proc "odin" (f: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_scalar_f64 ¶
Source

matrix3_from_scalar_f64 :: proc "odin" (f: f64) -> (m: Matrix3x3f64) {…}

matrix3_from_yaw_pitch_roll_f16 ¶
Source

matrix3_from_yaw_pitch_roll_f16 :: proc "odin" (yaw, pitch, roll: f16) -> (m: Matrix3x3f16) {…}

matrix3_from_yaw_pitch_roll_f32 ¶
Source

matrix3_from_yaw_pitch_roll_f32 :: proc "odin" (yaw, pitch, roll: f32) -> (m: Matrix3x3f32) {…}

matrix3_from_yaw_pitch_roll_f64 ¶
Source

matrix3_from_yaw_pitch_roll_f64 :: proc "odin" (yaw, pitch, roll: f64) -> (m: Matrix3x3f64) {…}

matrix3_inverse_f16 ¶
Source

matrix3_inverse_f16 :: proc "odin" (m: Matrix3x3f16) -> Matrix3x3f16 {…}

matrix3_inverse_f32 ¶
Source

matrix3_inverse_f32 :: proc "odin" (m: Matrix3x3f32) -> Matrix3x3f32 {…}

matrix3_inverse_f64 ¶
Source

matrix3_inverse_f64 :: proc "odin" (m: Matrix3x3f64) -> Matrix3x3f64 {…}

matrix3_inverse_transpose_f16 ¶
Source

matrix3_inverse_transpose_f16 :: proc "odin" (m: Matrix3x3f16) -> (inverse_transpose: Matrix3x3f16) {…}

matrix3_inverse_transpose_f32 ¶
Source

matrix3_inverse_transpose_f32 :: proc "odin" (m: Matrix3x3f32) -> (inverse_transpose: Matrix3x3f32) {…}

matrix3_inverse_transpose_f64 ¶
Source

matrix3_inverse_transpose_f64 :: proc "odin" (m: Matrix3x3f64) -> (inverse_transpose: Matrix3x3f64) {…}

matrix3_look_at_f16 ¶
Source

matrix3_look_at_f16 :: proc "odin" (eye, centre: Vector3f16, up: Vector3f16) -> Matrix3x3f16 {…}

matrix3_look_at_f32 ¶
Source

matrix3_look_at_f32 :: proc "odin" (eye, centre: Vector3f32, up: Vector3f32) -> Matrix3x3f32 {…}

matrix3_look_at_f64 ¶
Source

matrix3_look_at_f64 :: proc "odin" (eye, centre: Vector3f64, up: Vector3f64) -> Matrix3x3f64 {…}

matrix3_orthonormalize_f16 ¶
Source

matrix3_orthonormalize_f16 :: proc "odin" (m: Matrix3x3f16) -> (r: Matrix3x3f16) {…}

matrix3_orthonormalize_f32 ¶
Source

matrix3_orthonormalize_f32 :: proc "odin" (m: Matrix3x3f32) -> (r: Matrix3x3f32) {…}

matrix3_orthonormalize_f64 ¶
Source

matrix3_orthonormalize_f64 :: proc "odin" (m: Matrix3x3f64) -> (r: Matrix3x3f64) {…}

matrix3_rotate_f16 ¶
Source

matrix3_rotate_f16 :: proc "odin" (angle_radians: f16, v: Vector3f16) -> (rot: Matrix3x3f16) {…}

matrix3_rotate_f32 ¶
Source

matrix3_rotate_f32 :: proc "odin" (angle_radians: f32, v: Vector3f32) -> (rot: Matrix3x3f32) {…}

matrix3_rotate_f64 ¶
Source

matrix3_rotate_f64 :: proc "odin" (angle_radians: f64, v: Vector3f64) -> (rot: Matrix3x3f64) {…}

matrix3_scale_f16 ¶
Source

matrix3_scale_f16 :: proc "odin" (s: Vector3f16) -> (m: Matrix3x3f16) {…}

matrix3_scale_f32 ¶
Source

matrix3_scale_f32 :: proc "odin" (s: Vector3f32) -> (m: Matrix3x3f32) {…}

matrix3_scale_f64 ¶
Source

matrix3_scale_f64 :: proc "odin" (s: Vector3f64) -> (m: Matrix3x3f64) {…}

matrix4_adjoint_f16 ¶
Source

matrix4_adjoint_f16 :: proc "odin" (m: Matrix4x4f16) -> (adjoint: Matrix4x4f16) {…}

matrix4_adjoint_f32 ¶
Source

matrix4_adjoint_f32 :: proc "odin" (m: Matrix4x4f32) -> (adjoint: Matrix4x4f32) {…}

matrix4_adjoint_f64 ¶
Source

matrix4_adjoint_f64 :: proc "odin" (m: Matrix4x4f64) -> (adjoint: Matrix4x4f64) {…}

matrix4_cofactor_f16 ¶
Source

matrix4_cofactor_f16 :: proc "odin" (m: Matrix4x4f16, c, r: int) -> f16 {…}

matrix4_cofactor_f32 ¶
Source

matrix4_cofactor_f32 :: proc "odin" (m: Matrix4x4f32, c, r: int) -> f32 {…}

matrix4_cofactor_f64 ¶
Source

matrix4_cofactor_f64 :: proc "odin" (m: Matrix4x4f64, c, r: int) -> f64 {…}

matrix4_determinant_f16 ¶
Source

matrix4_determinant_f16 :: proc "odin" (m: Matrix4x4f16) -> (determinant: f16) {…}

matrix4_determinant_f32 ¶
Source

matrix4_determinant_f32 :: proc "odin" (m: Matrix4x4f32) -> (determinant: f32) {…}

matrix4_determinant_f64 ¶
Source

matrix4_determinant_f64 :: proc "odin" (m: Matrix4x4f64) -> (determinant: f64) {…}

matrix4_from_derived_euler_angle_x_f16 ¶
Source

matrix4_from_derived_euler_angle_x_f16 :: proc "odin" (angle_x: f16, angular_velocity_x: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_derived_euler_angle_x_f32 ¶
Source

matrix4_from_derived_euler_angle_x_f32 :: proc "odin" (angle_x: f32, angular_velocity_x: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_derived_euler_angle_x_f64 ¶
Source

matrix4_from_derived_euler_angle_x_f64 :: proc "odin" (angle_x: f64, angular_velocity_x: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_derived_euler_angle_y_f16 ¶
Source

matrix4_from_derived_euler_angle_y_f16 :: proc "odin" (angle_y: f16, angular_velocity_y: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_derived_euler_angle_y_f32 ¶
Source

matrix4_from_derived_euler_angle_y_f32 :: proc "odin" (angle_y: f32, angular_velocity_y: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_derived_euler_angle_y_f64 ¶
Source

matrix4_from_derived_euler_angle_y_f64 :: proc "odin" (angle_y: f64, angular_velocity_y: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_derived_euler_angle_z_f16 ¶
Source

matrix4_from_derived_euler_angle_z_f16 :: proc "odin" (angle_z: f16, angular_velocity_z: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_derived_euler_angle_z_f32 ¶
Source

matrix4_from_derived_euler_angle_z_f32 :: proc "odin" (angle_z: f32, angular_velocity_z: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_derived_euler_angle_z_f64 ¶
Source

matrix4_from_derived_euler_angle_z_f64 :: proc "odin" (angle_z: f64, angular_velocity_z: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angle_x_f16 ¶
Source

matrix4_from_euler_angle_x_f16 :: proc "odin" (angle_x: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angle_x_f32 ¶
Source

matrix4_from_euler_angle_x_f32 :: proc "odin" (angle_x: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angle_x_f64 ¶
Source

matrix4_from_euler_angle_x_f64 :: proc "odin" (angle_x: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angle_y_f16 ¶
Source

matrix4_from_euler_angle_y_f16 :: proc "odin" (angle_y: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angle_y_f32 ¶
Source

matrix4_from_euler_angle_y_f32 :: proc "odin" (angle_y: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angle_y_f64 ¶
Source

matrix4_from_euler_angle_y_f64 :: proc "odin" (angle_y: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angle_z_f16 ¶
Source

matrix4_from_euler_angle_z_f16 :: proc "odin" (angle_z: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angle_z_f32 ¶
Source

matrix4_from_euler_angle_z_f32 :: proc "odin" (angle_z: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angle_z_f64 ¶
Source

matrix4_from_euler_angle_z_f64 :: proc "odin" (angle_z: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_f16 ¶
Source

matrix4_from_euler_angles_f16 :: proc "odin" (t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_f32 ¶
Source

matrix4_from_euler_angles_f32 :: proc "odin" (t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_f64 ¶
Source

matrix4_from_euler_angles_f64 :: proc "odin" (t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_xy_f16 ¶
Source

matrix4_from_euler_angles_xy_f16 :: proc "odin" (angle_x, angle_y: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_xy_f32 ¶
Source

matrix4_from_euler_angles_xy_f32 :: proc "odin" (angle_x, angle_y: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_xy_f64 ¶
Source

matrix4_from_euler_angles_xy_f64 :: proc "odin" (angle_x, angle_y: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_xyx_f16 ¶
Source

matrix4_from_euler_angles_xyx_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_xyx_f32 ¶
Source

matrix4_from_euler_angles_xyx_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_xyx_f64 ¶
Source

matrix4_from_euler_angles_xyx_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_xyz_f16 ¶
Source

matrix4_from_euler_angles_xyz_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_xyz_f32 ¶
Source

matrix4_from_euler_angles_xyz_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_xyz_f64 ¶
Source

matrix4_from_euler_angles_xyz_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_xz_f16 ¶
Source

matrix4_from_euler_angles_xz_f16 :: proc "odin" (angle_x, angle_z: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_xz_f32 ¶
Source

matrix4_from_euler_angles_xz_f32 :: proc "odin" (angle_x, angle_z: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_xz_f64 ¶
Source

matrix4_from_euler_angles_xz_f64 :: proc "odin" (angle_x, angle_z: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_xzx_f16 ¶
Source

matrix4_from_euler_angles_xzx_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_xzx_f32 ¶
Source

matrix4_from_euler_angles_xzx_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_xzx_f64 ¶
Source

matrix4_from_euler_angles_xzx_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_xzy_f16 ¶
Source

matrix4_from_euler_angles_xzy_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_xzy_f32 ¶
Source

matrix4_from_euler_angles_xzy_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_xzy_f64 ¶
Source

matrix4_from_euler_angles_xzy_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_yx_f16 ¶
Source

matrix4_from_euler_angles_yx_f16 :: proc "odin" (angle_y, angle_x: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_yx_f32 ¶
Source

matrix4_from_euler_angles_yx_f32 :: proc "odin" (angle_y, angle_x: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_yx_f64 ¶
Source

matrix4_from_euler_angles_yx_f64 :: proc "odin" (angle_y, angle_x: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_yxy_f16 ¶
Source

matrix4_from_euler_angles_yxy_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_yxy_f32 ¶
Source

matrix4_from_euler_angles_yxy_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_yxy_f64 ¶
Source

matrix4_from_euler_angles_yxy_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_yxz_f16 ¶
Source

matrix4_from_euler_angles_yxz_f16 :: proc "odin" (yaw, pitch, roll: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_yxz_f32 ¶
Source

matrix4_from_euler_angles_yxz_f32 :: proc "odin" (yaw, pitch, roll: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_yxz_f64 ¶
Source

matrix4_from_euler_angles_yxz_f64 :: proc "odin" (yaw, pitch, roll: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_yz_f16 ¶
Source

matrix4_from_euler_angles_yz_f16 :: proc "odin" (angle_y, angle_z: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_yz_f32 ¶
Source

matrix4_from_euler_angles_yz_f32 :: proc "odin" (angle_y, angle_z: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_yz_f64 ¶
Source

matrix4_from_euler_angles_yz_f64 :: proc "odin" (angle_y, angle_z: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_yzx_f16 ¶
Source

matrix4_from_euler_angles_yzx_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_yzx_f32 ¶
Source

matrix4_from_euler_angles_yzx_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_yzx_f64 ¶
Source

matrix4_from_euler_angles_yzx_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_yzy_f16 ¶
Source

matrix4_from_euler_angles_yzy_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_yzy_f32 ¶
Source

matrix4_from_euler_angles_yzy_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_yzy_f64 ¶
Source

matrix4_from_euler_angles_yzy_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_zx_f16 ¶
Source

matrix4_from_euler_angles_zx_f16 :: proc "odin" (angle_z, angle_x: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_zx_f32 ¶
Source

matrix4_from_euler_angles_zx_f32 :: proc "odin" (angle_z, angle_x: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_zx_f64 ¶
Source

matrix4_from_euler_angles_zx_f64 :: proc "odin" (angle_z, angle_x: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_zxy_f16 ¶
Source

matrix4_from_euler_angles_zxy_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_zxy_f32 ¶
Source

matrix4_from_euler_angles_zxy_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_zxy_f64 ¶
Source

matrix4_from_euler_angles_zxy_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_zxz_f16 ¶
Source

matrix4_from_euler_angles_zxz_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_zxz_f32 ¶
Source

matrix4_from_euler_angles_zxz_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_zxz_f64 ¶
Source

matrix4_from_euler_angles_zxz_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_zy_f16 ¶
Source

matrix4_from_euler_angles_zy_f16 :: proc "odin" (angle_z, angle_y: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_zy_f32 ¶
Source

matrix4_from_euler_angles_zy_f32 :: proc "odin" (angle_z, angle_y: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_zy_f64 ¶
Source

matrix4_from_euler_angles_zy_f64 :: proc "odin" (angle_z, angle_y: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_zyx_f16 ¶
Source

matrix4_from_euler_angles_zyx_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_zyx_f32 ¶
Source

matrix4_from_euler_angles_zyx_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_zyx_f64 ¶
Source

matrix4_from_euler_angles_zyx_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_euler_angles_zyz_f16 ¶
Source

matrix4_from_euler_angles_zyz_f16 :: proc "odin" (t1, t2, t3: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_euler_angles_zyz_f32 ¶
Source

matrix4_from_euler_angles_zyz_f32 :: proc "odin" (t1, t2, t3: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_euler_angles_zyz_f64 ¶
Source

matrix4_from_euler_angles_zyz_f64 :: proc "odin" (t1, t2, t3: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_matrix2_f16 ¶
Source

matrix4_from_matrix2_f16 :: proc "odin" (m: Matrix2x2f16) -> (r: Matrix4x4f16) {…}

matrix4_from_matrix2_f32 ¶
Source

matrix4_from_matrix2_f32 :: proc "odin" (m: Matrix2x2f32) -> (r: Matrix4x4f32) {…}

matrix4_from_matrix2_f64 ¶
Source

matrix4_from_matrix2_f64 :: proc "odin" (m: Matrix2x2f64) -> (r: Matrix4x4f64) {…}

matrix4_from_matrix3_f16 ¶
Source

matrix4_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (r: Matrix4x4f16) {…}

matrix4_from_matrix3_f32 ¶
Source

matrix4_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (r: Matrix4x4f32) {…}

matrix4_from_matrix3_f64 ¶
Source

matrix4_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (r: Matrix4x4f64) {…}

matrix4_from_quaternion_f16 ¶
Source

matrix4_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (m: Matrix4x4f16) {…}

matrix4_from_quaternion_f32 ¶
Source

matrix4_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (m: Matrix4x4f32) {…}

matrix4_from_quaternion_f64 ¶
Source

matrix4_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (m: Matrix4x4f64) {…}

matrix4_from_scalar_f16 ¶
Source

matrix4_from_scalar_f16 :: proc "odin" (f: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_scalar_f32 ¶
Source

matrix4_from_scalar_f32 :: proc "odin" (f: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_scalar_f64 ¶
Source

matrix4_from_scalar_f64 :: proc "odin" (f: f64) -> (m: Matrix4x4f64) {…}

matrix4_from_trs_f16 ¶
Source

matrix4_from_trs_f16 :: proc "odin" (t: Vector3f16, r: Quaternionf16, s: Vector3f16) -> Matrix4x4f16 {…}

matrix4_from_trs_f32 ¶
Source

matrix4_from_trs_f32 :: proc "odin" (t: Vector3f32, r: Quaternionf32, s: Vector3f32) -> Matrix4x4f32 {…}

matrix4_from_trs_f64 ¶
Source

matrix4_from_trs_f64 :: proc "odin" (t: Vector3f64, r: Quaternionf64, s: Vector3f64) -> Matrix4x4f64 {…}

matrix4_from_yaw_pitch_roll_f16 ¶
Source

matrix4_from_yaw_pitch_roll_f16 :: proc "odin" (yaw, pitch, roll: f16) -> (m: Matrix4x4f16) {…}

matrix4_from_yaw_pitch_roll_f32 ¶
Source

matrix4_from_yaw_pitch_roll_f32 :: proc "odin" (yaw, pitch, roll: f32) -> (m: Matrix4x4f32) {…}

matrix4_from_yaw_pitch_roll_f64 ¶
Source

matrix4_from_yaw_pitch_roll_f64 :: proc "odin" (yaw, pitch, roll: f64) -> (m: Matrix4x4f64) {…}

matrix4_infinite_perspective_f16 ¶
Source

matrix4_infinite_perspective_f16 :: proc "odin" (fovy, aspect, near: f16, flip_z_axis: bool = true) -> (m: Matrix4x4f16) {…}

matrix4_infinite_perspective_f32 ¶
Source

matrix4_infinite_perspective_f32 :: proc "odin" (fovy, aspect, near: f32, flip_z_axis: bool = true) -> (m: Matrix4x4f32) {…}

matrix4_infinite_perspective_f64 ¶
Source

matrix4_infinite_perspective_f64 :: proc "odin" (fovy, aspect, near: f64, flip_z_axis: bool = true) -> (m: Matrix4x4f64) {…}

matrix4_inverse_f16 ¶
Source

matrix4_inverse_f16 :: proc "odin" (m: Matrix4x4f16) -> Matrix4x4f16 {…}

matrix4_inverse_f32 ¶
Source

matrix4_inverse_f32 :: proc "odin" (m: Matrix4x4f32) -> Matrix4x4f32 {…}

matrix4_inverse_f64 ¶
Source

matrix4_inverse_f64 :: proc "odin" (m: Matrix4x4f64) -> Matrix4x4f64 {…}

matrix4_inverse_transpose_f16 ¶
Source

matrix4_inverse_transpose_f16 :: proc "odin" (m: Matrix4x4f16) -> (inverse_transpose: Matrix4x4f16) {…}

matrix4_inverse_transpose_f32 ¶
Source

matrix4_inverse_transpose_f32 :: proc "odin" (m: Matrix4x4f32) -> (inverse_transpose: Matrix4x4f32) {…}

matrix4_inverse_transpose_f64 ¶
Source

matrix4_inverse_transpose_f64 :: proc "odin" (m: Matrix4x4f64) -> (inverse_transpose: Matrix4x4f64) {…}

matrix4_look_at_f16 ¶
Source

matrix4_look_at_f16 :: proc "odin" (eye, centre, up: Vector3f16, flip_z_axis: bool = true) -> (m: Matrix4x4f16) {…}

matrix4_look_at_f32 ¶
Source

matrix4_look_at_f32 :: proc "odin" (eye, centre, up: Vector3f32, flip_z_axis: bool = true) -> (m: Matrix4x4f32) {…}

matrix4_look_at_f64 ¶
Source

matrix4_look_at_f64 :: proc "odin" (eye, centre, up: Vector3f64, flip_z_axis: bool = true) -> (m: Matrix4x4f64) {…}

matrix4_look_at_from_fru_f16 ¶
Source

matrix4_look_at_from_fru_f16 :: proc "odin" (eye, f, r, u: Vector3f16, flip_z_axis: bool = true) -> (m: Matrix4x4f16) {…}

matrix4_look_at_from_fru_f32 ¶
Source

matrix4_look_at_from_fru_f32 :: proc "odin" (eye, f, r, u: Vector3f32, flip_z_axis: bool = true) -> (m: Matrix4x4f32) {…}

matrix4_look_at_from_fru_f64 ¶
Source

matrix4_look_at_from_fru_f64 :: proc "odin" (eye, f, r, u: Vector3f64, flip_z_axis: bool = true) -> (m: Matrix4x4f64) {…}

matrix4_minor_f16 ¶
Source

matrix4_minor_f16 :: proc "odin" (m: Matrix4x4f16, c, r: int) -> f16 {…}

matrix4_minor_f32 ¶
Source

matrix4_minor_f32 :: proc "odin" (m: Matrix4x4f32, c, r: int) -> f32 {…}

matrix4_minor_f64 ¶
Source

matrix4_minor_f64 :: proc "odin" (m: Matrix4x4f64, c, r: int) -> f64 {…}

matrix4_orientation_f16 ¶
Source

matrix4_orientation_f16 :: proc "odin" (normal, up: Vector3f16) -> Matrix4x4f16 {…}

matrix4_orientation_f32 ¶
Source

matrix4_orientation_f32 :: proc "odin" (normal, up: Vector3f32) -> Matrix4x4f32 {…}

matrix4_orientation_f64 ¶
Source

matrix4_orientation_f64 :: proc "odin" (normal, up: Vector3f64) -> Matrix4x4f64 {…}

matrix4_perspective_f16 ¶
Source

matrix4_perspective_f16 :: proc "odin" (fovy, aspect, near, far: f16, flip_z_axis: bool = true) -> (m: Matrix4x4f16) {…}

matrix4_perspective_f32 ¶
Source

matrix4_perspective_f32 :: proc "odin" (fovy, aspect, near, far: f32, flip_z_axis: bool = true) -> (m: Matrix4x4f32) {…}

matrix4_perspective_f64 ¶
Source

matrix4_perspective_f64 :: proc "odin" (fovy, aspect, near, far: f64, flip_z_axis: bool = true) -> (m: Matrix4x4f64) {…}

matrix4_rotate_f16 ¶
Source

matrix4_rotate_f16 :: proc "odin" (angle_radians: f16, v: Vector3f16) -> Matrix4x4f16 {…}

matrix4_rotate_f32 ¶
Source

matrix4_rotate_f32 :: proc "odin" (angle_radians: f32, v: Vector3f32) -> Matrix4x4f32 {…}

matrix4_rotate_f64 ¶
Source

matrix4_rotate_f64 :: proc "odin" (angle_radians: f64, v: Vector3f64) -> Matrix4x4f64 {…}

matrix4_scale_f16 ¶
Source

matrix4_scale_f16 :: proc "odin" (v: Vector3f16) -> (m: Matrix4x4f16) {…}

matrix4_scale_f32 ¶
Source

matrix4_scale_f32 :: proc "odin" (v: Vector3f32) -> (m: Matrix4x4f32) {…}

matrix4_scale_f64 ¶
Source

matrix4_scale_f64 :: proc "odin" (v: Vector3f64) -> (m: Matrix4x4f64) {…}

matrix4_translate_f16 ¶
Source

matrix4_translate_f16 :: proc "odin" (v: Vector3f16) -> Matrix4x4f16 {…}

matrix4_translate_f32 ¶
Source

matrix4_translate_f32 :: proc "odin" (v: Vector3f32) -> Matrix4x4f32 {…}

matrix4_translate_f64 ¶
Source

matrix4_translate_f64 :: proc "odin" (v: Vector3f64) -> Matrix4x4f64 {…}

matrix_cast ¶
Source

matrix_cast :: proc "odin" (v: $M/matrix[0, 0]$T, $Elem_Type: typeid) -> (w: matrix[0, 0]typeid) {…}

matrix_comp_mul ¶
Source

matrix_comp_mul :: proc "odin" (a, b: $M/matrix[0, 0]$T) -> (c: $M/matrix[0, 0]$T) {…}

matrix_mul ¶
Source

matrix_mul :: proc "odin" (a, b: $M/matrix[0, 0]$T) -> (c: $M/matrix[0, 0]$T) {…}

matrix_mul_differ ¶
Source

matrix_mul_differ :: proc "odin" (a, b: $M/matrix[0, 0]$T) -> (c: matrix[0, 0]$T) {…}

matrix_mul_vector ¶
Source

matrix_mul_vector :: proc "odin" (a: $A/matrix[4, 4]$T, b: $V/[0]$T) -> (c: $V/[0]$T) {…}

matrix_ortho3d_f16 ¶
Source

matrix_ortho3d_f16 :: proc "odin" (
	left, right, bottom, top, near, far: f16, 
	flip_z_axis:                         bool = true, 
) -> (m: Matrix4x4f16) {…}

matrix_ortho3d_f32 ¶
Source

matrix_ortho3d_f32 :: proc "odin" (
	left, right, bottom, top, near, far: f32, 
	flip_z_axis:                         bool = true, 
) -> (m: Matrix4x4f32) {…}

matrix_ortho3d_f64 ¶
Source

matrix_ortho3d_f64 :: proc "odin" (
	left, right, bottom, top, near, far: f64, 
	flip_z_axis:                         bool = true, 
) -> (m: Matrix4x4f64) {…}

matrix_to_ptr ¶
Source

matrix_to_ptr :: proc "odin" (m: ^$M/matrix[0, 0]$T) -> ^$T {…}

max_double ¶
Source

max_double :: proc "odin" (a, b: $T) -> (out: $T) {…}

max_single ¶
Source

max_single :: proc "odin" (a: $T) -> (out: $T) {…}

max_triple ¶
Source

max_triple :: proc "odin" (a, b, c: $T) -> $T {…}

min_double ¶
Source

min_double :: proc "odin" (a, b: $T) -> (out: $T) {…}

min_single ¶
Source

min_single :: proc "odin" (a: $T) -> (out: $T) {…}

min_triple ¶
Source

min_triple :: proc "odin" (a, b, c: $T) -> $T {…}

mix ¶
Source

mix :: proc "odin" (a, b, t: $T) -> (out: $T) {…}

mod ¶
Source

mod :: proc "odin" (x, m: $T) -> $T {…}

not ¶
Source

not :: proc "odin" (x: $A/[0]bool) -> (out: $A/[0]bool) {…}

not_equal_array ¶
Source

not_equal_array :: proc "odin" (x, y: $V/[0]$T) -> (out: [0]bool) {…}

not_equal_single ¶
Source

not_equal_single :: proc "odin" (x, y: $T) -> (out: bool) {…}

outer_product ¶

outer_product :: builtin.outer_product

pitch_from_quaternion_f16 ¶
Source

pitch_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> f16 {…}

pitch_from_quaternion_f32 ¶
Source

pitch_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> f32 {…}

pitch_from_quaternion_f64 ¶
Source

pitch_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> f64 {…}

pitch_yaw_roll_from_quaternion_f16 ¶
Source

pitch_yaw_roll_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> (pitch, yaw, roll: f16) {…}

pitch_yaw_roll_from_quaternion_f32 ¶
Source

pitch_yaw_roll_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> (pitch, yaw, roll: f32) {…}

pitch_yaw_roll_from_quaternion_f64 ¶
Source

pitch_yaw_roll_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> (pitch, yaw, roll: f64) {…}

polar_from_euclidean_f16 ¶
Source

polar_from_euclidean_f16 :: proc "odin" (euclidean: Vector3f16) -> Vector3f16 {…}

polar_from_euclidean_f32 ¶
Source

polar_from_euclidean_f32 :: proc "odin" (euclidean: Vector3f32) -> Vector3f32 {…}

polar_from_euclidean_f64 ¶
Source

polar_from_euclidean_f64 :: proc "odin" (euclidean: Vector3f64) -> Vector3f64 {…}

pow ¶
Source

pow :: proc "odin" (x, e: $T) -> (out: $T) {…}

projection ¶
Source

projection :: proc "odin" (x, normal: $V/[0]$T) -> $V/[0]$T {…}

quaternion128_dot ¶
Source

quaternion128_dot :: proc "odin" (a, b: $T/quaternion128) -> (c: f32) {…}

quaternion128_mul_vector3 ¶
Source

quaternion128_mul_vector3 :: proc "odin" (q: $T/quaternion128, v: $V/[3]$F/f32) -> $V/[3]$F/f32 {…}

quaternion256_dot ¶
Source

quaternion256_dot :: proc "odin" (a, b: $T/quaternion256) -> (c: f64) {…}

quaternion256_mul_vector3 ¶
Source

quaternion256_mul_vector3 :: proc "odin" (q: $T/quaternion256, v: $V/[3]$F/f64) -> $V/[3]$F/f64 {…}

quaternion64_dot ¶
Source

quaternion64_dot :: proc "odin" (a, b: $T/quaternion64) -> (c: f16) {…}

quaternion64_mul_vector3 ¶
Source

quaternion64_mul_vector3 :: proc "odin" (q: $T/quaternion64, v: $V/[3]$F/f16) -> $V/[3]$F/f16 {…}

quaternion_angle_axis_f16 ¶
Source

quaternion_angle_axis_f16 :: proc "odin" (angle_radians: f16, axis: Vector3f16) -> (q: Quaternionf16) {…}

quaternion_angle_axis_f32 ¶
Source

quaternion_angle_axis_f32 :: proc "odin" (angle_radians: f32, axis: Vector3f32) -> (q: Quaternionf32) {…}

quaternion_angle_axis_f64 ¶
Source

quaternion_angle_axis_f64 :: proc "odin" (angle_radians: f64, axis: Vector3f64) -> (q: Quaternionf64) {…}

quaternion_between_two_vector3_f16 ¶
Source

quaternion_between_two_vector3_f16 :: proc "odin" (from, to: Vector3f16) -> (q: Quaternionf16) {…}

quaternion_between_two_vector3_f32 ¶
Source

quaternion_between_two_vector3_f32 :: proc "odin" (from, to: Vector3f32) -> (q: Quaternionf32) {…}

quaternion_between_two_vector3_f64 ¶
Source

quaternion_between_two_vector3_f64 :: proc "odin" (from, to: Vector3f64) -> (q: Quaternionf64) {…}

quaternion_cross ¶
Source

quaternion_cross :: proc "odin" (q1, q2: $T) -> (q3: $T) {…}

quaternion_from_euler_angle_x_f16 ¶
Source

quaternion_from_euler_angle_x_f16 :: proc "odin" (angle_x: f16) -> (q: Quaternionf16) {…}

quaternion_from_euler_angle_x_f32 ¶
Source

quaternion_from_euler_angle_x_f32 :: proc "odin" (angle_x: f32) -> (q: Quaternionf32) {…}

quaternion_from_euler_angle_x_f64 ¶
Source

quaternion_from_euler_angle_x_f64 :: proc "odin" (angle_x: f64) -> (q: Quaternionf64) {…}

quaternion_from_euler_angle_y_f16 ¶
Source

quaternion_from_euler_angle_y_f16 :: proc "odin" (angle_y: f16) -> (q: Quaternionf16) {…}

quaternion_from_euler_angle_y_f32 ¶
Source

quaternion_from_euler_angle_y_f32 :: proc "odin" (angle_y: f32) -> (q: Quaternionf32) {…}

quaternion_from_euler_angle_y_f64 ¶
Source

quaternion_from_euler_angle_y_f64 :: proc "odin" (angle_y: f64) -> (q: Quaternionf64) {…}

quaternion_from_euler_angle_z_f16 ¶
Source

quaternion_from_euler_angle_z_f16 :: proc "odin" (angle_z: f16) -> (q: Quaternionf16) {…}

quaternion_from_euler_angle_z_f32 ¶
Source

quaternion_from_euler_angle_z_f32 :: proc "odin" (angle_z: f32) -> (q: Quaternionf32) {…}

quaternion_from_euler_angle_z_f64 ¶
Source

quaternion_from_euler_angle_z_f64 :: proc "odin" (angle_z: f64) -> (q: Quaternionf64) {…}

quaternion_from_euler_angles_f16 ¶
Source

quaternion_from_euler_angles_f16 :: proc "odin" (t1, t2, t3: f16, order: Euler_Angle_Order) -> Quaternionf16 {…}

quaternion_from_euler_angles_f32 ¶
Source

quaternion_from_euler_angles_f32 :: proc "odin" (t1, t2, t3: f32, order: Euler_Angle_Order) -> Quaternionf32 {…}

quaternion_from_euler_angles_f64 ¶
Source

quaternion_from_euler_angles_f64 :: proc "odin" (t1, t2, t3: f64, order: Euler_Angle_Order) -> Quaternionf64 {…}

quaternion_from_forward_and_up_f16 ¶
Source

quaternion_from_forward_and_up_f16 :: proc "odin" (forward, up: Vector3f16) -> Quaternionf16 {…}

quaternion_from_forward_and_up_f32 ¶
Source

quaternion_from_forward_and_up_f32 :: proc "odin" (forward, up: Vector3f32) -> Quaternionf32 {…}

quaternion_from_forward_and_up_f64 ¶
Source

quaternion_from_forward_and_up_f64 :: proc "odin" (forward, up: Vector3f64) -> Quaternionf64 {…}

quaternion_from_matrix3_f16 ¶
Source

quaternion_from_matrix3_f16 :: proc "odin" (m: Matrix3x3f16) -> (q: Quaternionf16) {…}

quaternion_from_matrix3_f32 ¶
Source

quaternion_from_matrix3_f32 :: proc "odin" (m: Matrix3x3f32) -> (q: Quaternionf32) {…}

quaternion_from_matrix3_f64 ¶
Source

quaternion_from_matrix3_f64 :: proc "odin" (m: Matrix3x3f64) -> (q: Quaternionf64) {…}

quaternion_from_matrix4_f16 ¶
Source

quaternion_from_matrix4_f16 :: proc "odin" (m: Matrix4x4f16) -> (q: Quaternionf16) {…}

quaternion_from_matrix4_f32 ¶
Source

quaternion_from_matrix4_f32 :: proc "odin" (m: Matrix4x4f32) -> (q: Quaternionf32) {…}

quaternion_from_matrix4_f64 ¶
Source

quaternion_from_matrix4_f64 :: proc "odin" (m: Matrix4x4f64) -> (q: Quaternionf64) {…}

quaternion_from_pitch_yaw_roll_f16 ¶
Source

quaternion_from_pitch_yaw_roll_f16 :: proc "odin" (pitch, yaw, roll: f16) -> Quaternionf16 {…}

quaternion_from_pitch_yaw_roll_f32 ¶
Source

quaternion_from_pitch_yaw_roll_f32 :: proc "odin" (pitch, yaw, roll: f32) -> Quaternionf32 {…}

quaternion_from_pitch_yaw_roll_f64 ¶
Source

quaternion_from_pitch_yaw_roll_f64 :: proc "odin" (pitch, yaw, roll: f64) -> Quaternionf64 {…}

quaternion_from_scalar_f16 ¶
Source

quaternion_from_scalar_f16 :: proc "odin" (f: f16) -> (q: Quaternionf16) {…}

quaternion_from_scalar_f32 ¶
Source

quaternion_from_scalar_f32 :: proc "odin" (f: f32) -> (q: Quaternionf32) {…}

quaternion_from_scalar_f64 ¶
Source

quaternion_from_scalar_f64 :: proc "odin" (f: f64) -> (q: Quaternionf64) {…}

quaternion_inverse ¶
Source

quaternion_inverse :: proc "odin" (q: $T) -> $T {…}

quaternion_length ¶
Source

quaternion_length :: proc "odin" (q: $T) -> $T {…}

quaternion_length2 ¶
Source

quaternion_length2 :: proc "odin" (q: $T) -> $T {…}

quaternion_look_at_f16 ¶
Source

quaternion_look_at_f16 :: proc "odin" (eye, centre: Vector3f16, up: Vector3f16) -> Quaternionf16 {…}

quaternion_look_at_f32 ¶
Source

quaternion_look_at_f32 :: proc "odin" (eye, centre: Vector3f32, up: Vector3f32) -> Quaternionf32 {…}

quaternion_look_at_f64 ¶
Source

quaternion_look_at_f64 :: proc "odin" (eye, centre: Vector3f64, up: Vector3f64) -> Quaternionf64 {…}

quaternion_mul_quaternion ¶
Source

quaternion_mul_quaternion :: proc "odin" (q1, q2: $T) -> $T {…}

quaternion_nlerp_f16 ¶
Source

quaternion_nlerp_f16 :: proc "odin" (a, b: Quaternionf16, t: f16) -> (c: Quaternionf16) {…}

quaternion_nlerp_f32 ¶
Source

quaternion_nlerp_f32 :: proc "odin" (a, b: Quaternionf32, t: f32) -> (c: Quaternionf32) {…}

quaternion_nlerp_f64 ¶
Source

quaternion_nlerp_f64 :: proc "odin" (a, b: Quaternionf64, t: f64) -> (c: Quaternionf64) {…}

quaternion_normalize ¶
Source

quaternion_normalize :: proc "odin" (q: $T) -> $T {…}

quaternion_normalize0 ¶
Source

quaternion_normalize0 :: proc "odin" (q: $T) -> $T {…}

quaternion_slerp_f16 ¶
Source

quaternion_slerp_f16 :: proc "odin" (x, y: Quaternionf16, t: f16) -> (q: Quaternionf16) {…}

quaternion_slerp_f32 ¶
Source

quaternion_slerp_f32 :: proc "odin" (x, y: Quaternionf32, t: f32) -> (q: Quaternionf32) {…}

quaternion_slerp_f64 ¶
Source

quaternion_slerp_f64 :: proc "odin" (x, y: Quaternionf64, t: f64) -> (q: Quaternionf64) {…}

quaternion_squad_f16 ¶
Source

quaternion_squad_f16 :: proc "odin" (q1, q2, s1, s2: Quaternionf16, h: f16) -> Quaternionf16 {…}

quaternion_squad_f32 ¶
Source

quaternion_squad_f32 :: proc "odin" (q1, q2, s1, s2: Quaternionf32, h: f32) -> Quaternionf32 {…}

quaternion_squad_f64 ¶
Source

quaternion_squad_f64 :: proc "odin" (q1, q2, s1, s2: Quaternionf64, h: f64) -> Quaternionf64 {…}

radians ¶
Source

radians :: proc "odin" (degrees: $T) -> (out: $T) {…}

reflect ¶
Source

reflect :: proc "odin" (I, N: $T) -> (out: $T) {…}

refract ¶
Source

refract :: proc "odin" (I, Normal: $V/[0]$T, eta: $T) -> (out: $V/[0]$T) {…}

roll_from_quaternion_f16 ¶
Source

roll_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> f16 {…}

roll_from_quaternion_f32 ¶
Source

roll_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> f32 {…}

roll_from_quaternion_f64 ¶
Source

roll_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> f64 {…}

round ¶
Source

round :: proc "odin" (x: $T) -> (out: $T) {…}

saturate ¶
Source

saturate :: proc "odin" (x: $T) -> $T {…}

scalar_cross ¶
Source

scalar_cross :: proc "odin" (a, b: $T) -> $T {…}

scalar_dot ¶
Source

scalar_dot :: proc "odin" (a, b: $T) -> $T {…}

scalar_f32_swizzle1 ¶
Source

scalar_f32_swizzle1 :: proc "odin" (f: f32, c0: Scalar_Components) -> f32 {…}

scalar_f32_swizzle2 ¶
Source

scalar_f32_swizzle2 :: proc "odin" (f: f32, c0, c1: Scalar_Components) -> Vector2f32 {…}

scalar_f32_swizzle3 ¶
Source

scalar_f32_swizzle3 :: proc "odin" (f: f32, c0, c1, c2: Scalar_Components) -> Vector3f32 {…}

scalar_f32_swizzle4 ¶
Source

scalar_f32_swizzle4 :: proc "odin" (f: f32, c0, c1, c2, c3: Scalar_Components) -> Vector4f32 {…}

scalar_f64_swizzle1 ¶
Source

scalar_f64_swizzle1 :: proc "odin" (f: f64, c0: Scalar_Components) -> f64 {…}

scalar_f64_swizzle2 ¶
Source

scalar_f64_swizzle2 :: proc "odin" (f: f64, c0, c1: Scalar_Components) -> Vector2f64 {…}

scalar_f64_swizzle3 ¶
Source

scalar_f64_swizzle3 :: proc "odin" (f: f64, c0, c1, c2: Scalar_Components) -> Vector3f64 {…}

scalar_f64_swizzle4 ¶
Source

scalar_f64_swizzle4 :: proc "odin" (f: f64, c0, c1, c2, c3: Scalar_Components) -> Vector4f64 {…}

scalar_triple_product ¶
Source

scalar_triple_product :: proc "odin" (a, b, c: $V/[0]$T) -> $T {…}

sign ¶
Source

sign :: proc "odin" (a: $T) -> (out: $T) {…}

sin ¶
Source

sin :: proc "odin" (x: $T) -> (out: $T) {…}

smootherstep ¶
Source

smootherstep :: proc "odin" (e0, e1, x: $T) -> $T {…}

smoothstep ¶
Source

smoothstep :: proc "odin" (e0, e1, x: $T) -> $T {…}

sqrt ¶
Source

sqrt :: proc "odin" (x: $T) -> (out: $T) {…}

step ¶
Source

step :: proc "odin" (e, x: $T) -> (out: $T) {…}

tan ¶
Source

tan :: proc "odin" (x: $T) -> (out: $T) {…}

to_complex128 ¶
Source

to_complex128 :: proc "odin" (v: $V/[0]$T) -> [0]complex128 {…}

to_complex32 ¶
Source

to_complex32 :: proc "odin" (v: $V/[0]$T) -> [0]complex32 {…}

to_complex64 ¶
Source

to_complex64 :: proc "odin" (v: $V/[0]$T) -> [0]complex64 {…}

to_f32 ¶
Source

to_f32 :: proc "odin" (v: $V/[0]$T) -> [0]f32 {…}

to_f64 ¶
Source

to_f64 :: proc "odin" (v: $V/[0]$T) -> [0]f64 {…}

to_i16 ¶
Source

to_i16 :: proc "odin" (v: $V/[0]$T) -> [0]i16 {…}

to_i32 ¶
Source

to_i32 :: proc "odin" (v: $V/[0]$T) -> [0]i32 {…}

to_i64 ¶
Source

to_i64 :: proc "odin" (v: $V/[0]$T) -> [0]i64 {…}

to_i8 ¶
Source

to_i8 :: proc "odin" (v: $V/[0]$T) -> [0]i8 {…}

to_int ¶
Source

to_int :: proc "odin" (v: $V/[0]$T) -> [0]int {…}

to_quaternion128 ¶
Source

to_quaternion128 :: proc "odin" (v: $V/[0]$T) -> [0]quaternion128 {…}

to_quaternion256 ¶
Source

to_quaternion256 :: proc "odin" (v: $V/[0]$T) -> [0]quaternion256 {…}

to_quaternion64 ¶
Source

to_quaternion64 :: proc "odin" (v: $V/[0]$T) -> [0]quaternion64 {…}

to_u16 ¶
Source

to_u16 :: proc "odin" (v: $V/[0]$T) -> [0]u16 {…}

to_u32 ¶
Source

to_u32 :: proc "odin" (v: $V/[0]$T) -> [0]u32 {…}

to_u64 ¶
Source

to_u64 :: proc "odin" (v: $V/[0]$T) -> [0]u64 {…}

to_u8 ¶
Source

to_u8 :: proc "odin" (v: $V/[0]$T) -> [0]u8 {…}

to_uint ¶
Source

to_uint :: proc "odin" (v: $V/[0]$T) -> [0]uint {…}

transpose ¶

transpose :: builtin.transpose

unlerp ¶
Source

unlerp :: proc "odin" (a, b, x: $T) -> $T {…}

vector2_orthogonal ¶
Source

vector2_orthogonal :: proc "odin" (v: $T/[2]$T) -> $T/[2]$T {…}

vector2f32_swizzle1 ¶
Source

vector2f32_swizzle1 :: proc "odin" (v: Vector2f32, c0: Vector2_Components) -> f32 {…}

vector2f32_swizzle2 ¶
Source

vector2f32_swizzle2 :: proc "odin" (v: Vector2f32, c0, c1: Vector2_Components) -> Vector2f32 {…}

vector2f32_swizzle3 ¶
Source

vector2f32_swizzle3 :: proc "odin" (v: Vector2f32, c0, c1, c2: Vector2_Components) -> Vector3f32 {…}

vector2f32_swizzle4 ¶
Source

vector2f32_swizzle4 :: proc "odin" (v: Vector2f32, c0, c1, c2, c3: Vector2_Components) -> Vector4f32 {…}

vector2f64_swizzle1 ¶
Source

vector2f64_swizzle1 :: proc "odin" (v: Vector2f64, c0: Vector2_Components) -> f64 {…}

vector2f64_swizzle2 ¶
Source

vector2f64_swizzle2 :: proc "odin" (v: Vector2f64, c0, c1: Vector2_Components) -> Vector2f64 {…}

vector2f64_swizzle3 ¶
Source

vector2f64_swizzle3 :: proc "odin" (v: Vector2f64, c0, c1, c2: Vector2_Components) -> Vector3f64 {…}

vector2f64_swizzle4 ¶
Source

vector2f64_swizzle4 :: proc "odin" (v: Vector2f64, c0, c1, c2, c3: Vector2_Components) -> Vector4f64 {…}

vector3_orthogonal ¶
Source

vector3_orthogonal :: proc "odin" (v: $T/[3]$T) -> $T/[3]$T {…}

vector3_orthonormalize_f16 ¶
Source

vector3_orthonormalize_f16 :: proc "odin" (x, y: Vector3f16) -> (z: Vector3f16) {…}

vector3_orthonormalize_f32 ¶
Source

vector3_orthonormalize_f32 :: proc "odin" (x, y: Vector3f32) -> (z: Vector3f32) {…}

vector3_orthonormalize_f64 ¶
Source

vector3_orthonormalize_f64 :: proc "odin" (x, y: Vector3f64) -> (z: Vector3f64) {…}

vector3f32_swizzle1 ¶
Source

vector3f32_swizzle1 :: proc "odin" (v: Vector3f32, c0: Vector3_Components) -> f32 {…}

vector3f32_swizzle2 ¶
Source

vector3f32_swizzle2 :: proc "odin" (v: Vector3f32, c0, c1: Vector3_Components) -> Vector2f32 {…}

vector3f32_swizzle3 ¶
Source

vector3f32_swizzle3 :: proc "odin" (v: Vector3f32, c0, c1, c2: Vector3_Components) -> Vector3f32 {…}

vector3f32_swizzle4 ¶
Source

vector3f32_swizzle4 :: proc "odin" (v: Vector3f32, c0, c1, c2, c3: Vector3_Components) -> Vector4f32 {…}

vector3f64_swizzle1 ¶
Source

vector3f64_swizzle1 :: proc "odin" (v: Vector3f64, c0: Vector3_Components) -> f64 {…}

vector3f64_swizzle2 ¶
Source

vector3f64_swizzle2 :: proc "odin" (v: Vector3f64, c0, c1: Vector3_Components) -> Vector2f64 {…}

vector3f64_swizzle3 ¶
Source

vector3f64_swizzle3 :: proc "odin" (v: Vector3f64, c0, c1, c2: Vector3_Components) -> Vector3f64 {…}

vector3f64_swizzle4 ¶
Source

vector3f64_swizzle4 :: proc "odin" (v: Vector3f64, c0, c1, c2, c3: Vector3_Components) -> Vector4f64 {…}

vector4_hsl_to_rgb_f16 ¶
Source

vector4_hsl_to_rgb_f16 :: proc "odin" (h, s, l: f16, a: f16 = 1) -> Vector4f16 {…}

vector4_hsl_to_rgb_f32 ¶
Source

vector4_hsl_to_rgb_f32 :: proc "odin" (h, s, l: f32, a: f32 = 1) -> Vector4f32 {…}

vector4_hsl_to_rgb_f64 ¶
Source

vector4_hsl_to_rgb_f64 :: proc "odin" (h, s, l: f64, a: f64 = 1) -> Vector4f64 {…}

vector4_linear_to_srgb_f16 ¶
Source

vector4_linear_to_srgb_f16 :: proc "odin" (col: Vector4f16) -> Vector4f16 {…}

vector4_linear_to_srgb_f32 ¶
Source

vector4_linear_to_srgb_f32 :: proc "odin" (col: Vector4f32) -> Vector4f32 {…}

vector4_linear_to_srgb_f64 ¶
Source

vector4_linear_to_srgb_f64 :: proc "odin" (col: Vector4f64) -> Vector4f64 {…}

vector4_rgb_to_hsl_f16 ¶
Source

vector4_rgb_to_hsl_f16 :: proc "odin" (col: Vector4f16) -> Vector4f16 {…}

vector4_rgb_to_hsl_f32 ¶
Source

vector4_rgb_to_hsl_f32 :: proc "odin" (col: Vector4f32) -> Vector4f32 {…}

vector4_rgb_to_hsl_f64 ¶
Source

vector4_rgb_to_hsl_f64 :: proc "odin" (col: Vector4f64) -> Vector4f64 {…}

vector4_srgb_to_linear_f16 ¶
Source

vector4_srgb_to_linear_f16 :: proc "odin" (col: Vector4f16) -> Vector4f16 {…}

vector4_srgb_to_linear_f32 ¶
Source

vector4_srgb_to_linear_f32 :: proc "odin" (col: Vector4f32) -> Vector4f32 {…}

vector4_srgb_to_linear_f64 ¶
Source

vector4_srgb_to_linear_f64 :: proc "odin" (col: Vector4f64) -> Vector4f64 {…}

vector4f32_swizzle1 ¶
Source

vector4f32_swizzle1 :: proc "odin" (v: Vector4f32, c0: Vector4_Components) -> f32 {…}

vector4f32_swizzle2 ¶
Source

vector4f32_swizzle2 :: proc "odin" (v: Vector4f32, c0, c1: Vector4_Components) -> Vector2f32 {…}

vector4f32_swizzle3 ¶
Source

vector4f32_swizzle3 :: proc "odin" (v: Vector4f32, c0, c1, c2: Vector4_Components) -> Vector3f32 {…}

vector4f32_swizzle4 ¶
Source

vector4f32_swizzle4 :: proc "odin" (v: Vector4f32, c0, c1, c2, c3: Vector4_Components) -> Vector4f32 {…}

vector4f64_swizzle1 ¶
Source

vector4f64_swizzle1 :: proc "odin" (v: Vector4f64, c0: Vector4_Components) -> f64 {…}

vector4f64_swizzle2 ¶
Source

vector4f64_swizzle2 :: proc "odin" (v: Vector4f64, c0, c1: Vector4_Components) -> Vector2f64 {…}

vector4f64_swizzle3 ¶
Source

vector4f64_swizzle3 :: proc "odin" (v: Vector4f64, c0, c1, c2: Vector4_Components) -> Vector3f64 {…}

vector4f64_swizzle4 ¶
Source

vector4f64_swizzle4 :: proc "odin" (v: Vector4f64, c0, c1, c2, c3: Vector4_Components) -> Vector4f64 {…}

vector_cross2 ¶
Source

vector_cross2 :: proc "odin" (a, b: $T/[2]$T) -> $T {…}

vector_cross3 ¶
Source

vector_cross3 :: proc "odin" (a, b: $T/[3]$T) -> (c: $T/[3]$T) {…}

vector_dot ¶
Source

vector_dot :: proc "odin" (a, b: $V/[0]$T) -> (c: $T) {…}

vector_length ¶
Source

vector_length :: proc "odin" (v: $V/[0]$T) -> $T {…}

vector_length2 ¶
Source

vector_length2 :: proc "odin" (v: $V/[0]$T) -> $T {…}

vector_normalize ¶
Source

vector_normalize :: proc "odin" (v: $V/[0]$T) -> $V/[0]$T {…}

vector_normalize0 ¶
Source

vector_normalize0 :: proc "odin" (v: $V/[0]$T) -> $V/[0]$T {…}

vector_slerp ¶
Source

vector_slerp :: proc "odin" (x, y: $V/[0]$T, a: $T) -> $V/[0]$T {…}

vector_to_ptr ¶
Source

vector_to_ptr :: proc "odin" (v: ^$V/[0]$T) -> ^$T {…}

vector_triple_product ¶
Source

vector_triple_product :: proc "odin" (a, b, c: $V/[0]$T) -> $V/[0]$T {…}

yaw_from_quaternion_f16 ¶
Source

yaw_from_quaternion_f16 :: proc "odin" (q: Quaternionf16) -> f16 {…}

yaw_from_quaternion_f32 ¶
Source

yaw_from_quaternion_f32 :: proc "odin" (q: Quaternionf32) -> f32 {…}

yaw_from_quaternion_f64 ¶
Source

yaw_from_quaternion_f64 :: proc "odin" (q: Quaternionf64) -> f64 {…}

Procedure Groups

angle_axis_from_quaternion ¶
Source

angle_from_quaternion ¶
Source

axis_from_quaternion ¶
Source

classify ¶
Source

classify :: proc{
	classify_single,
	classify_array,
}

cross ¶
Source

dot ¶
Source

equal ¶
Source

equal :: proc{
	equal_single,
	equal_array,
}

euclidean_from_polar ¶
Source

euler_angles_from_matrix3 ¶
Source

euler_angles_from_matrix4 ¶
Source

euler_angles_from_quaternion ¶
Source

euler_angles_xyx_from_matrix3 ¶
Source

euler_angles_xyx_from_matrix4 ¶
Source

euler_angles_xyx_from_quaternion ¶
Source

euler_angles_xyz_from_matrix3 ¶
Source

euler_angles_xyz_from_matrix4 ¶
Source

euler_angles_xyz_from_quaternion ¶
Source

euler_angles_xzx_from_matrix3 ¶
Source

euler_angles_xzx_from_matrix4 ¶
Source

euler_angles_xzx_from_quaternion ¶
Source

euler_angles_xzy_from_matrix3 ¶
Source

euler_angles_xzy_from_matrix4 ¶
Source

euler_angles_xzy_from_quaternion ¶
Source

euler_angles_yxy_from_matrix3 ¶
Source

euler_angles_yxy_from_matrix4 ¶
Source

euler_angles_yxy_from_quaternion ¶
Source

euler_angles_yxz_from_matrix3 ¶
Source

euler_angles_yxz_from_matrix4 ¶
Source

euler_angles_yxz_from_quaternion ¶
Source

euler_angles_yzx_from_matrix3 ¶
Source

euler_angles_yzx_from_matrix4 ¶
Source

euler_angles_yzx_from_quaternion ¶
Source

euler_angles_yzy_from_matrix3 ¶
Source

euler_angles_yzy_from_matrix4 ¶
Source

euler_angles_yzy_from_quaternion ¶
Source

euler_angles_zxy_from_matrix3 ¶
Source

euler_angles_zxy_from_matrix4 ¶
Source

euler_angles_zxy_from_quaternion ¶
Source

euler_angles_zxz_from_matrix3 ¶
Source

euler_angles_zxz_from_matrix4 ¶
Source

euler_angles_zxz_from_quaternion ¶
Source

euler_angles_zyx_from_matrix3 ¶
Source

euler_angles_zyx_from_matrix4 ¶
Source

euler_angles_zyx_from_quaternion ¶
Source

euler_angles_zyz_from_matrix3 ¶
Source

euler_angles_zyz_from_matrix4 ¶
Source

euler_angles_zyz_from_quaternion ¶
Source

greater_than ¶
Source

greater_than :: proc{
	greater_than_single,
	greater_than_array,
}

greater_than_equal ¶
Source

greater_than_equal :: proc{
	greater_than_equal_single,
	greater_than_equal_array,
}

inner_product ¶
Source

is_inf ¶
Source

is_inf :: proc{
	is_inf_single,
	is_inf_array,
}

is_nan ¶
Source

is_nan :: proc{
	is_nan_single,
	is_nan_array,
}

length ¶
Source

length :: proc{
	vector_length,
	quaternion_length,
}

length2 ¶
Source

length2 :: proc{
	vector_length2,
	quaternion_length2,
}

less_than ¶
Source

less_than :: proc{
	less_than_single,
	less_than_array,
}

less_than_equal ¶
Source

less_than_equal :: proc{
	less_than_equal_single,
	less_than_equal_array,
}

matrix2_adjoint ¶
Source

matrix2_determinant ¶
Source

matrix2_from_matrix3 ¶
Source

matrix2_from_matrix4 ¶
Source

matrix2_from_scalar ¶
Source

matrix2_inverse ¶
Source

matrix2_inverse_transpose ¶
Source

matrix2_orthonormalize ¶
Source

matrix3_adjoint ¶
Source

matrix3_determinant ¶
Source

matrix3_from_derived_euler_angle_x ¶
Source

matrix3_from_derived_euler_angle_y ¶
Source

matrix3_from_derived_euler_angle_z ¶
Source

matrix3_from_euler_angle_x ¶
Source

matrix3_from_euler_angle_y ¶
Source

matrix3_from_euler_angle_z ¶
Source

matrix3_from_euler_angles ¶
Source

matrix3_from_euler_angles_xy ¶
Source

matrix3_from_euler_angles_xyx ¶
Source

matrix3_from_euler_angles_xyz ¶
Source

matrix3_from_euler_angles_xz ¶
Source

matrix3_from_euler_angles_xzx ¶
Source

matrix3_from_euler_angles_xzy ¶
Source

matrix3_from_euler_angles_yx ¶
Source

matrix3_from_euler_angles_yxy ¶
Source

matrix3_from_euler_angles_yxz ¶
Source

matrix3_from_euler_angles_yz ¶
Source

matrix3_from_euler_angles_yzx ¶
Source

matrix3_from_euler_angles_yzy ¶
Source

matrix3_from_euler_angles_zx ¶
Source

matrix3_from_euler_angles_zxy ¶
Source

matrix3_from_euler_angles_zxz ¶
Source

matrix3_from_euler_angles_zy ¶
Source

matrix3_from_euler_angles_zyx ¶
Source

matrix3_from_euler_angles_zyz ¶
Source

matrix3_from_matrix2 ¶
Source

matrix3_from_matrix4 ¶
Source

matrix3_from_quaternion ¶
Source

matrix3_from_scalar ¶
Source

matrix3_from_yaw_pitch_roll ¶
Source

matrix3_inverse ¶
Source

matrix3_inverse_transpose ¶
Source

matrix3_look_at ¶
Source

matrix3_orthonormalize ¶
Source

matrix3_rotate ¶
Source

matrix3_scale ¶
Source

matrix4_adjoint ¶
Source

matrix4_cofactor ¶
Source

matrix4_determinant ¶
Source

matrix4_from_derived_euler_angle_x ¶
Source

matrix4_from_derived_euler_angle_y ¶
Source

matrix4_from_derived_euler_angle_z ¶
Source

matrix4_from_euler_angle_x ¶
Source

matrix4_from_euler_angle_y ¶
Source

matrix4_from_euler_angle_z ¶
Source

matrix4_from_euler_angles ¶
Source

matrix4_from_euler_angles_xy ¶
Source

matrix4_from_euler_angles_xyx ¶
Source

matrix4_from_euler_angles_xyz ¶
Source

matrix4_from_euler_angles_xz ¶
Source

matrix4_from_euler_angles_xzx ¶
Source

matrix4_from_euler_angles_xzy ¶
Source

matrix4_from_euler_angles_yx ¶
Source

matrix4_from_euler_angles_yxy ¶
Source

matrix4_from_euler_angles_yxz ¶
Source

matrix4_from_euler_angles_yz ¶
Source

matrix4_from_euler_angles_yzx ¶
Source

matrix4_from_euler_angles_yzy ¶
Source

matrix4_from_euler_angles_zx ¶
Source

matrix4_from_euler_angles_zxy ¶
Source

matrix4_from_euler_angles_zxz ¶
Source

matrix4_from_euler_angles_zy ¶
Source

matrix4_from_euler_angles_zyx ¶
Source

matrix4_from_euler_angles_zyz ¶
Source

matrix4_from_matrix2 ¶
Source

matrix4_from_matrix3 ¶
Source

matrix4_from_quaternion ¶
Source

matrix4_from_scalar ¶
Source

matrix4_from_trs ¶
Source

matrix4_from_yaw_pitch_roll ¶
Source

matrix4_infinite_perspective ¶
Source

matrix4_inverse ¶
Source

matrix4_inverse_transpose ¶
Source

matrix4_look_at ¶
Source

matrix4_look_at_from_fru ¶
Source

matrix4_minor ¶
Source

matrix4_orientation ¶
Source

matrix4_perspective ¶
Source

matrix4_rotate ¶
Source

matrix4_scale ¶
Source

matrix4_translate ¶
Source

matrix_ortho3d ¶
Source

max ¶
Source

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

min ¶
Source

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

mul ¶
Source

normalize ¶
Source

normalize :: proc{
	vector_normalize,
	quaternion_normalize,
}

normalize0 ¶
Source

normalize0 :: proc{
	vector_normalize0,
	quaternion_normalize0,
}

not_equal ¶
Source

not_equal :: proc{
	not_equal_single,
	not_equal_array,
}

orthogonal ¶
Source

orthogonal :: proc{
	vector2_orthogonal,
	vector3_orthogonal,
}

orthonormalize ¶
Source

pitch_from_quaternion ¶
Source

pitch_yaw_roll_from_quaternion ¶
Source

polar_from_euclidean ¶
Source

quaternion_angle_axis ¶
Source

quaternion_between_two_vector3 ¶
Source

quaternion_from_euler_angle_x ¶
Source

quaternion_from_euler_angle_y ¶
Source

quaternion_from_euler_angle_z ¶
Source

quaternion_from_euler_angles ¶
Source

quaternion_from_forward_and_up ¶
Source

quaternion_from_matrix3 ¶
Source

quaternion_from_matrix4 ¶
Source

quaternion_from_pitch_yaw_roll ¶
Source

quaternion_from_scalar ¶
Source

quaternion_look_at ¶
Source

quaternion_mul_vector3 ¶
Source

quaternion_nlerp ¶
Source

quaternion_slerp ¶
Source

quaternion_squad ¶
Source

roll_from_quaternion ¶
Source

scalar_swizzle ¶
Source

swizzle ¶
Source

to_matrix2f ¶
Source

to_matrix2f16 ¶
Source

to_matrix2f32 ¶
Source

to_matrix2f64 ¶
Source

to_matrix3 ¶
Source

to_matrix3f16 ¶
Source

to_matrix3f32 ¶
Source

to_matrix3f64 ¶
Source

to_matrix4 ¶
Source

to_matrix4f16 ¶
Source

to_matrix4f32 ¶
Source

to_matrix4f64 ¶
Source

to_ptr ¶
Source

to_ptr :: proc{
	vector_to_ptr,
	matrix_to_ptr,
}

to_quaternion ¶
Source

to_quaternionf16 ¶
Source

to_quaternionf32 ¶
Source

to_quaternionf64 ¶
Source

vector2_swizzle ¶
Source

vector3_orthonormalize ¶
Source

vector3_swizzle ¶
Source

vector4_hsl_to_rgb ¶
Source

vector4_linear_to_srgb ¶
Source

vector4_rgb_to_hsl ¶
Source

vector4_srgb_to_linear ¶
Source

vector4_swizzle ¶
Source

vector_cross ¶
Source

vector_cross :: proc{
	scalar_cross,
	vector_cross2,
	vector_cross3,
}

yaw_from_quaternion ¶
Source

Source Files

Generation Information

Generated with odin version dev-2023-03 (vendor "odin") Windows_amd64 @ 2023-03-29 21:09:05.324122800 +0000 UTC