package core:math/linalg

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 ¶

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

Matrix1x1f16 ¶

Matrix1x1f16 :: distinct matrix[1, 1]f16

Matrix1x1f32 ¶

Matrix1x1f32 :: distinct matrix[1, 1]f32

Matrix1x1f64 ¶

Matrix1x1f64 :: distinct matrix[1, 1]f64

Matrix1x2f16 ¶

Matrix1x2f16 :: distinct matrix[1, 2]f16

Matrix1x2f32 ¶

Matrix1x2f32 :: distinct matrix[1, 2]f32

Matrix1x2f64 ¶

Matrix1x2f64 :: distinct matrix[1, 2]f64

Matrix1x3f16 ¶

Matrix1x3f16 :: distinct matrix[1, 3]f16

Matrix1x3f32 ¶

Matrix1x3f32 :: distinct matrix[1, 3]f32

Matrix1x3f64 ¶

Matrix1x3f64 :: distinct matrix[1, 3]f64

Matrix1x4f16 ¶

Matrix1x4f16 :: distinct matrix[1, 4]f16

Matrix1x4f32 ¶

Matrix1x4f32 :: distinct matrix[1, 4]f32

Matrix1x4f64 ¶

Matrix1x4f64 :: distinct matrix[1, 4]f64

Matrix2x1f16 ¶

Matrix2x1f16 :: distinct matrix[2, 1]f16

Matrix2x1f32 ¶

Matrix2x1f32 :: distinct matrix[2, 1]f32

Matrix2x1f64 ¶

Matrix2x1f64 :: distinct matrix[2, 1]f64

Matrix2x2f16 ¶

Matrix2x2f16 :: distinct matrix[2, 2]f16

Matrix2x2f32 ¶

Matrix2x2f32 :: distinct matrix[2, 2]f32

Matrix2x2f64 ¶

Matrix2x2f64 :: distinct matrix[2, 2]f64

Matrix2x3f16 ¶

Matrix2x3f16 :: distinct matrix[2, 3]f16

Matrix2x3f32 ¶

Matrix2x3f32 :: distinct matrix[2, 3]f32

Matrix2x3f64 ¶

Matrix2x3f64 :: distinct matrix[2, 3]f64

Matrix2x4f16 ¶

Matrix2x4f16 :: distinct matrix[2, 4]f16

Matrix2x4f32 ¶

Matrix2x4f32 :: distinct matrix[2, 4]f32

Matrix2x4f64 ¶

Matrix2x4f64 :: distinct matrix[2, 4]f64

Matrix3x1f16 ¶

Matrix3x1f16 :: distinct matrix[3, 1]f16

Matrix3x1f32 ¶

Matrix3x1f32 :: distinct matrix[3, 1]f32

Matrix3x1f64 ¶

Matrix3x1f64 :: distinct matrix[3, 1]f64

Matrix3x2f16 ¶

Matrix3x2f16 :: distinct matrix[3, 2]f16

Matrix3x2f32 ¶

Matrix3x2f32 :: distinct matrix[3, 2]f32

Matrix3x2f64 ¶

Matrix3x2f64 :: distinct matrix[3, 2]f64

Matrix3x3f16 ¶

Matrix3x3f16 :: distinct matrix[3, 3]f16

Matrix3x3f32 ¶

Matrix3x3f32 :: distinct matrix[3, 3]f32

Matrix3x3f64 ¶

Matrix3x3f64 :: distinct matrix[3, 3]f64

Matrix3x4f16 ¶

Matrix3x4f16 :: distinct matrix[3, 4]f16

Matrix3x4f32 ¶

Matrix3x4f32 :: distinct matrix[3, 4]f32

Matrix3x4f64 ¶

Matrix3x4f64 :: distinct matrix[3, 4]f64

Matrix4x1f16 ¶

Matrix4x1f16 :: distinct matrix[4, 1]f16

Matrix4x1f32 ¶

Matrix4x1f32 :: distinct matrix[4, 1]f32

Matrix4x1f64 ¶

Matrix4x1f64 :: distinct matrix[4, 1]f64

Matrix4x2f16 ¶

Matrix4x2f16 :: distinct matrix[4, 2]f16

Matrix4x2f32 ¶

Matrix4x2f32 :: distinct matrix[4, 2]f32

Matrix4x2f64 ¶

Matrix4x2f64 :: distinct matrix[4, 2]f64

Matrix4x3f16 ¶

Matrix4x3f16 :: distinct matrix[4, 3]f16

Matrix4x3f32 ¶

Matrix4x3f32 :: distinct matrix[4, 3]f32

Matrix4x3f64 ¶

Matrix4x3f64 :: distinct matrix[4, 3]f64

Matrix4x4f16 ¶

Matrix4x4f16 :: distinct matrix[4, 4]f16

Matrix4x4f32 ¶

Matrix4x4f32 :: distinct matrix[4, 4]f32

Matrix4x4f64 ¶

Matrix4x4f64 :: distinct matrix[4, 4]f64

Quaternionf16 ¶

Quaternionf16 :: distinct quaternion64

Quaternionf32 ¶

Quaternionf32 :: distinct quaternion128

Quaternionf64 ¶

Quaternionf64 :: distinct quaternion256

Scalar_Components ¶

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

Vector2_Components ¶

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

Vector2f16 ¶

Vector2f16 :: distinct [2]f16

Vector2f32 ¶

Vector2f32 :: distinct [2]f32

Vector2f64 ¶

Vector2f64 :: distinct [2]f64

Vector3_Components ¶

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

Vector3f16 ¶

Vector3f16 :: distinct [3]f16

Vector3f32 ¶

Vector3f32 :: distinct [3]f32

Vector3f64 ¶

Vector3f64 :: distinct [3]f64

Vector4_Components ¶

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

Vector4f16 ¶

Vector4f16 :: distinct [4]f16

Vector4f32 ¶

Vector4f32 :: distinct [4]f32

Vector4f64 ¶

Vector4f64 :: distinct [4]f64

Constants

DEG_PER_RAD ¶

DEG_PER_RAD :: 360.0 / TAU

E ¶

E :: 2.71828182845904523536

F16_EPSILON ¶

F16_EPSILON :: 1e-3

F32_EPSILON ¶

F32_EPSILON :: 1e-7

F64_EPSILON ¶

F64_EPSILON :: 1e-15

LN10 ¶

LN10 :: 2.30258509299404568401799145468436421

LN2 ¶

LN2 :: 0.693147180559945309417232121458176568

MATRIX1F16_IDENTITY ¶

MATRIX1F16_IDENTITY: Matrix1x1f16 : Matrix1f16(1)

MATRIX1F32_IDENTITY ¶

MATRIX1F32_IDENTITY: Matrix1x1f32 : Matrix1f32(1)

MATRIX1F64_IDENTITY ¶

MATRIX1F64_IDENTITY: Matrix1x1f64 : Matrix1f64(1)

MATRIX2F16_IDENTITY ¶

MATRIX2F16_IDENTITY: Matrix2x2f16 : Matrix2f16(1)

MATRIX2F32_IDENTITY ¶

MATRIX2F32_IDENTITY: Matrix2x2f32 : Matrix2f32(1)

MATRIX2F64_IDENTITY ¶

MATRIX2F64_IDENTITY: Matrix2x2f64 : Matrix2f64(1)

MATRIX3F16_IDENTITY ¶

MATRIX3F16_IDENTITY: Matrix3x3f16 : Matrix3f16(1)

MATRIX3F32_IDENTITY ¶

MATRIX3F32_IDENTITY: Matrix3x3f32 : Matrix3f32(1)

MATRIX3F64_IDENTITY ¶

MATRIX3F64_IDENTITY: Matrix3x3f64 : Matrix3f64(1)

MATRIX4F16_IDENTITY ¶

MATRIX4F16_IDENTITY: Matrix4x4f16 : Matrix4f16(1)

MATRIX4F32_IDENTITY ¶

MATRIX4F32_IDENTITY: Matrix4x4f32 : Matrix4f32(1)

MATRIX4F64_IDENTITY ¶

MATRIX4F64_IDENTITY: Matrix4x4f64 : Matrix4f64(1)

MAX_F32_PRECISION ¶

MAX_F32_PRECISION :: 8

MAX_F64_PRECISION ¶

MAX_F64_PRECISION :: 16

PI ¶

PI :: 3.14159265358979323846264338327950288

QUATERNIONF16_IDENTITY ¶

QUATERNIONF16_IDENTITY :: Quaternionf16(1)

QUATERNIONF32_IDENTITY ¶

QUATERNIONF32_IDENTITY :: Quaternionf32(1)

QUATERNIONF64_IDENTITY ¶

QUATERNIONF64_IDENTITY :: Quaternionf64(1)

RAD_PER_DEG ¶

RAD_PER_DEG :: TAU / 360.0

SQRT_FIVE ¶

SQRT_FIVE :: 2.23606797749978969640917366873127623

SQRT_THREE ¶

SQRT_THREE :: 1.73205080756887729352744634150587236

SQRT_TWO ¶

SQRT_TWO :: 1.41421356237309504880168872420969808

TAU ¶

TAU :: 6.28318530717958647692528676655900576

VECTOR3F16_X_AXIS ¶

VECTOR3F16_X_AXIS :: Vector3f16{1, 0, 0}

VECTOR3F16_Y_AXIS ¶

VECTOR3F16_Y_AXIS :: Vector3f16{0, 1, 0}

VECTOR3F16_Z_AXIS ¶

VECTOR3F16_Z_AXIS :: Vector3f16{0, 0, 1}

VECTOR3F32_X_AXIS ¶

VECTOR3F32_X_AXIS :: Vector3f32{1, 0, 0}

VECTOR3F32_Y_AXIS ¶

VECTOR3F32_Y_AXIS :: Vector3f32{0, 1, 0}

VECTOR3F32_Z_AXIS ¶

VECTOR3F32_Z_AXIS :: Vector3f32{0, 0, 1}

VECTOR3F64_X_AXIS ¶

VECTOR3F64_X_AXIS :: Vector3f64{1, 0, 0}

VECTOR3F64_Y_AXIS ¶

VECTOR3F64_Y_AXIS :: Vector3f64{0, 1, 0}

VECTOR3F64_Z_AXIS ¶

VECTOR3F64_Z_AXIS :: Vector3f64{0, 0, 1}

e ¶

e :: E

π ¶

π :: PI

τ ¶

τ :: TAU

Variables

This section is empty.

Procedures

abs ¶

abs :: proc "odin" (value: $) -> $ {…}

acos ¶

acos :: proc "odin" (value: $) -> $ {…}

all ¶

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

angle_axis_from_quaternion_f16 ¶

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

angle_axis_from_quaternion_f32 ¶

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

angle_axis_from_quaternion_f64 ¶

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

angle_from_quaternion_f16 ¶

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

angle_from_quaternion_f32 ¶

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

angle_from_quaternion_f64 ¶

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

any ¶

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

array_cast ¶

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

asin ¶

asin :: proc "odin" (value: $) -> $ {…}

atan ¶

atan :: proc "odin" (value: $) -> $ {…}

atan2 ¶

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

axis_from_quaternion_f16 ¶

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

axis_from_quaternion_f32 ¶

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

axis_from_quaternion_f64 ¶

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

catmull_rom ¶

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

ceil ¶

ceil :: proc "odin" (value: $) -> $ {…}

clamp ¶

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

classify_array ¶

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

classify_single ¶

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

cos ¶

cos :: proc "odin" (value: $) -> $ {…}

cubic ¶

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

degrees ¶

degrees :: proc "odin" (value: $) -> $ {…}

distance ¶

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

equal_array ¶

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

equal_single ¶

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

euclidean_from_polar_f16 ¶

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

euclidean_from_polar_f32 ¶

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

euclidean_from_polar_f64 ¶

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

euler_angles_from_matrix3_f16 ¶

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

euler_angles_from_matrix3_f32 ¶

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

euler_angles_from_matrix3_f64 ¶

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

euler_angles_from_matrix4_f16 ¶

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

euler_angles_from_matrix4_f32 ¶

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

euler_angles_from_matrix4_f64 ¶

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

euler_angles_from_quaternion_f16 ¶

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

euler_angles_from_quaternion_f32 ¶

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

euler_angles_from_quaternion_f64 ¶

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

euler_angles_xyx_from_matrix3_f16 ¶

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

euler_angles_xyx_from_matrix3_f32 ¶

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

euler_angles_xyx_from_matrix3_f64 ¶

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

euler_angles_xyx_from_matrix4_f16 ¶

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

euler_angles_xyx_from_matrix4_f32 ¶

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

euler_angles_xyx_from_matrix4_f64 ¶

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

euler_angles_xyx_from_quaternion_f16 ¶

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

euler_angles_xyx_from_quaternion_f32 ¶

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

euler_angles_xyx_from_quaternion_f64 ¶

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

euler_angles_xyz_from_matrix3_f16 ¶

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

euler_angles_xyz_from_matrix3_f32 ¶

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

euler_angles_xyz_from_matrix3_f64 ¶

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

euler_angles_xyz_from_matrix4_f16 ¶

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

euler_angles_xyz_from_matrix4_f32 ¶

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

euler_angles_xyz_from_matrix4_f64 ¶

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

euler_angles_xyz_from_quaternion_f16 ¶

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

euler_angles_xyz_from_quaternion_f32 ¶

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

euler_angles_xyz_from_quaternion_f64 ¶

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

euler_angles_xzx_from_matrix3_f16 ¶

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

euler_angles_xzx_from_matrix3_f32 ¶

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

euler_angles_xzx_from_matrix3_f64 ¶

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

euler_angles_xzx_from_matrix4_f16 ¶

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

euler_angles_xzx_from_matrix4_f32 ¶

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

euler_angles_xzx_from_matrix4_f64 ¶

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

euler_angles_xzx_from_quaternion_f16 ¶

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

euler_angles_xzx_from_quaternion_f32 ¶

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

euler_angles_xzx_from_quaternion_f64 ¶

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

euler_angles_xzy_from_matrix3_f16 ¶

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

euler_angles_xzy_from_matrix3_f32 ¶

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

euler_angles_xzy_from_matrix3_f64 ¶

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

euler_angles_xzy_from_matrix4_f16 ¶

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

euler_angles_xzy_from_matrix4_f32 ¶

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

euler_angles_xzy_from_matrix4_f64 ¶

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

euler_angles_xzy_from_quaternion_f16 ¶

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

euler_angles_xzy_from_quaternion_f32 ¶

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

euler_angles_xzy_from_quaternion_f64 ¶

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

euler_angles_yxy_from_matrix3_f16 ¶

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

euler_angles_yxy_from_matrix3_f32 ¶

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

euler_angles_yxy_from_matrix3_f64 ¶

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

euler_angles_yxy_from_matrix4_f16 ¶

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

euler_angles_yxy_from_matrix4_f32 ¶

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

euler_angles_yxy_from_matrix4_f64 ¶

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

euler_angles_yxy_from_quaternion_f16 ¶

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

euler_angles_yxy_from_quaternion_f32 ¶

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

euler_angles_yxy_from_quaternion_f64 ¶

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

euler_angles_yxz_from_matrix3_f16 ¶

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

euler_angles_yxz_from_matrix3_f32 ¶

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

euler_angles_yxz_from_matrix3_f64 ¶

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

euler_angles_yxz_from_matrix4_f16 ¶

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

euler_angles_yxz_from_matrix4_f32 ¶

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

euler_angles_yxz_from_matrix4_f64 ¶

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

euler_angles_yxz_from_quaternion_f16 ¶

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

euler_angles_yxz_from_quaternion_f32 ¶

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

euler_angles_yxz_from_quaternion_f64 ¶

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

euler_angles_yzx_from_matrix3_f16 ¶

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

euler_angles_yzx_from_matrix3_f32 ¶

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

euler_angles_yzx_from_matrix3_f64 ¶

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

euler_angles_yzx_from_matrix4_f16 ¶

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

euler_angles_yzx_from_matrix4_f32 ¶

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

euler_angles_yzx_from_matrix4_f64 ¶

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

euler_angles_yzx_from_quaternion_f16 ¶

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

euler_angles_yzx_from_quaternion_f32 ¶

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

euler_angles_yzx_from_quaternion_f64 ¶

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

euler_angles_yzy_from_matrix3_f16 ¶

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

euler_angles_yzy_from_matrix3_f32 ¶

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

euler_angles_yzy_from_matrix3_f64 ¶

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

euler_angles_yzy_from_matrix4_f16 ¶

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

euler_angles_yzy_from_matrix4_f32 ¶

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

euler_angles_yzy_from_matrix4_f64 ¶

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

euler_angles_yzy_from_quaternion_f16 ¶

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

euler_angles_yzy_from_quaternion_f32 ¶

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

euler_angles_yzy_from_quaternion_f64 ¶

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

euler_angles_zxy_from_matrix3_f16 ¶

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

euler_angles_zxy_from_matrix3_f32 ¶

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

euler_angles_zxy_from_matrix3_f64 ¶

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

euler_angles_zxy_from_matrix4_f16 ¶

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

euler_angles_zxy_from_matrix4_f32 ¶

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

euler_angles_zxy_from_matrix4_f64 ¶

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

euler_angles_zxy_from_quaternion_f16 ¶

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

euler_angles_zxy_from_quaternion_f32 ¶

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

euler_angles_zxy_from_quaternion_f64 ¶

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

euler_angles_zxz_from_matrix3_f16 ¶

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

euler_angles_zxz_from_matrix3_f32 ¶

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

euler_angles_zxz_from_matrix3_f64 ¶

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

euler_angles_zxz_from_matrix4_f16 ¶

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

euler_angles_zxz_from_matrix4_f32 ¶

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

euler_angles_zxz_from_matrix4_f64 ¶

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

euler_angles_zxz_from_quaternion_f16 ¶

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

euler_angles_zxz_from_quaternion_f32 ¶

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

euler_angles_zxz_from_quaternion_f64 ¶

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

euler_angles_zyx_from_matrix3_f16 ¶

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

euler_angles_zyx_from_matrix3_f32 ¶

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

euler_angles_zyx_from_matrix3_f64 ¶

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

euler_angles_zyx_from_matrix4_f16 ¶

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

euler_angles_zyx_from_matrix4_f32 ¶

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

euler_angles_zyx_from_matrix4_f64 ¶

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

euler_angles_zyx_from_quaternion_f16 ¶

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

euler_angles_zyx_from_quaternion_f32 ¶

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

euler_angles_zyx_from_quaternion_f64 ¶

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

euler_angles_zyz_from_matrix3_f16 ¶

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

euler_angles_zyz_from_matrix3_f32 ¶

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

euler_angles_zyz_from_matrix3_f64 ¶

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

euler_angles_zyz_from_matrix4_f16 ¶

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

euler_angles_zyz_from_matrix4_f32 ¶

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

euler_angles_zyz_from_matrix4_f64 ¶

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

euler_angles_zyz_from_quaternion_f16 ¶

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

euler_angles_zyz_from_quaternion_f32 ¶

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

euler_angles_zyz_from_quaternion_f64 ¶

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

exp ¶

exp :: proc "odin" (value: $) -> $ {…}

exp10 ¶

exp10 :: proc "odin" (value: $) -> $ {…}

exp2 ¶

exp2 :: proc "odin" (value: $) -> $ {…}

face_forward ¶

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

floor ¶

floor :: proc "odin" (value: $) -> $ {…}

fract ¶

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

greater_than_array ¶

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

greater_than_equal_array ¶

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

greater_than_equal_single ¶

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

greater_than_single ¶

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

hermite ¶

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

identity ¶

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

inverse_sqrt ¶

inverse_sqrt :: proc "odin" (value: $) -> $ {…}

is_inf_array ¶

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

is_inf_single ¶

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

is_nan_array ¶

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

is_nan_single ¶

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

lerp ¶

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

less_than_array ¶

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

less_than_equal_array ¶

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

less_than_equal_single ¶

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

less_than_single ¶

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

ln ¶

ln :: proc "odin" (value: $) -> $ {…}

log ¶

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

log10 ¶

log10 :: proc "odin" (value: $) -> $ {…}

log2 ¶

log2 :: proc "odin" (value: $) -> $ {…}

matrix2_adjoint_f16 ¶

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

matrix2_adjoint_f32 ¶

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

matrix2_adjoint_f64 ¶

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

matrix2_determinant_f16 ¶

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

matrix2_determinant_f32 ¶

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

matrix2_determinant_f64 ¶

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

matrix2_from_matrix3_f16 ¶

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

matrix2_from_matrix3_f32 ¶

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

matrix2_from_matrix3_f64 ¶

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

matrix2_from_matrix4_f16 ¶

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

matrix2_from_matrix4_f32 ¶

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

matrix2_from_matrix4_f64 ¶

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

matrix2_from_scalar_f16 ¶

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

matrix2_from_scalar_f32 ¶

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

matrix2_from_scalar_f64 ¶

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

matrix2_inverse_f16 ¶

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

matrix2_inverse_f32 ¶

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

matrix2_inverse_f64 ¶

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

matrix2_inverse_transpose_f16 ¶

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

matrix2_inverse_transpose_f32 ¶

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

matrix2_inverse_transpose_f64 ¶

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

matrix2_orthonormalize_f16 ¶

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

matrix2_orthonormalize_f32 ¶

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

matrix2_orthonormalize_f64 ¶

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

matrix3_adjoint_f16 ¶

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

matrix3_adjoint_f32 ¶

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

matrix3_adjoint_f64 ¶

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

matrix3_determinant_f16 ¶

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

matrix3_determinant_f32 ¶

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

matrix3_determinant_f64 ¶

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

matrix3_from_derived_euler_angle_x_f16 ¶

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 ¶

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 ¶

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 ¶

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

matrix3_from_derived_euler_angle_y_f32 ¶

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

matrix3_from_derived_euler_angle_y_f64 ¶

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

matrix3_from_derived_euler_angle_z_f16 ¶

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

matrix3_from_derived_euler_angle_z_f32 ¶

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

matrix3_from_derived_euler_angle_z_f64 ¶

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

matrix3_from_euler_angle_x_f16 ¶

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

matrix3_from_euler_angle_x_f32 ¶

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

matrix3_from_euler_angle_x_f64 ¶

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

matrix3_from_euler_angle_y_f16 ¶

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

matrix3_from_euler_angle_y_f32 ¶

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

matrix3_from_euler_angle_y_f64 ¶

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

matrix3_from_euler_angle_z_f16 ¶

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

matrix3_from_euler_angle_z_f32 ¶

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

matrix3_from_euler_angle_z_f64 ¶

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

matrix3_from_euler_angles_f16 ¶

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

matrix3_from_euler_angles_f32 ¶

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

matrix3_from_euler_angles_f64 ¶

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

matrix3_from_euler_angles_xy_f16 ¶

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

matrix3_from_euler_angles_xy_f32 ¶

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

matrix3_from_euler_angles_xy_f64 ¶

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

matrix3_from_euler_angles_xyx_f16 ¶

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

matrix3_from_euler_angles_xyx_f32 ¶

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

matrix3_from_euler_angles_xyx_f64 ¶

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

matrix3_from_euler_angles_xyz_f16 ¶

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

matrix3_from_euler_angles_xyz_f32 ¶

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

matrix3_from_euler_angles_xyz_f64 ¶

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

matrix3_from_euler_angles_xz_f16 ¶

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

matrix3_from_euler_angles_xz_f32 ¶

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

matrix3_from_euler_angles_xz_f64 ¶

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

matrix3_from_euler_angles_xzx_f16 ¶

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

matrix3_from_euler_angles_xzx_f32 ¶

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

matrix3_from_euler_angles_xzx_f64 ¶

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

matrix3_from_euler_angles_xzy_f16 ¶

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

matrix3_from_euler_angles_xzy_f32 ¶

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

matrix3_from_euler_angles_xzy_f64 ¶

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

matrix3_from_euler_angles_yx_f16 ¶

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

matrix3_from_euler_angles_yx_f32 ¶

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

matrix3_from_euler_angles_yx_f64 ¶

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

matrix3_from_euler_angles_yxy_f16 ¶

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

matrix3_from_euler_angles_yxy_f32 ¶

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

matrix3_from_euler_angles_yxy_f64 ¶

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

matrix3_from_euler_angles_yxz_f16 ¶

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

matrix3_from_euler_angles_yxz_f32 ¶

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

matrix3_from_euler_angles_yxz_f64 ¶

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

matrix3_from_euler_angles_yz_f16 ¶

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

matrix3_from_euler_angles_yz_f32 ¶

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

matrix3_from_euler_angles_yz_f64 ¶

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

matrix3_from_euler_angles_yzx_f16 ¶

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

matrix3_from_euler_angles_yzx_f32 ¶

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

matrix3_from_euler_angles_yzx_f64 ¶

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

matrix3_from_euler_angles_yzy_f16 ¶

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

matrix3_from_euler_angles_yzy_f32 ¶

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

matrix3_from_euler_angles_yzy_f64 ¶

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

matrix3_from_euler_angles_zx_f16 ¶

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

matrix3_from_euler_angles_zx_f32 ¶

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

matrix3_from_euler_angles_zx_f64 ¶

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

matrix3_from_euler_angles_zxy_f16 ¶

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

matrix3_from_euler_angles_zxy_f32 ¶

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

matrix3_from_euler_angles_zxy_f64 ¶

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

matrix3_from_euler_angles_zxz_f16 ¶

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

matrix3_from_euler_angles_zxz_f32 ¶

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

matrix3_from_euler_angles_zxz_f64 ¶

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

matrix3_from_euler_angles_zy_f16 ¶

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

matrix3_from_euler_angles_zy_f32 ¶

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

matrix3_from_euler_angles_zy_f64 ¶

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

matrix3_from_euler_angles_zyx_f16 ¶

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

matrix3_from_euler_angles_zyx_f32 ¶

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

matrix3_from_euler_angles_zyx_f64 ¶

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

matrix3_from_euler_angles_zyz_f16 ¶

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

matrix3_from_euler_angles_zyz_f32 ¶

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

matrix3_from_euler_angles_zyz_f64 ¶

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

matrix3_from_matrix2_f16 ¶

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

matrix3_from_matrix2_f32 ¶

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

matrix3_from_matrix2_f64 ¶

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

matrix3_from_matrix4_f16 ¶

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

matrix3_from_matrix4_f32 ¶

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

matrix3_from_matrix4_f64 ¶

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

matrix3_from_quaternion_f16 ¶

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

matrix3_from_quaternion_f32 ¶

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

matrix3_from_quaternion_f64 ¶

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

matrix3_from_scalar_f16 ¶

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

matrix3_from_scalar_f32 ¶

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

matrix3_from_scalar_f64 ¶

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

matrix3_from_yaw_pitch_roll_f16 ¶

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

matrix3_from_yaw_pitch_roll_f32 ¶

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

matrix3_from_yaw_pitch_roll_f64 ¶

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

matrix3_inverse_f16 ¶

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

matrix3_inverse_f32 ¶

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

matrix3_inverse_f64 ¶

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

matrix3_inverse_transpose_f16 ¶

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

matrix3_inverse_transpose_f32 ¶

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

matrix3_inverse_transpose_f64 ¶

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

matrix3_look_at_f16 ¶

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

matrix3_look_at_f32 ¶

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

matrix3_look_at_f64 ¶

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

matrix3_orthonormalize_f16 ¶

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

matrix3_orthonormalize_f32 ¶

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

matrix3_orthonormalize_f64 ¶

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

matrix3_rotate_f16 ¶

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

matrix3_rotate_f32 ¶

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

matrix3_rotate_f64 ¶

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

matrix3_scale_f16 ¶

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

matrix3_scale_f32 ¶

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

matrix3_scale_f64 ¶

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

matrix4_adjoint_f16 ¶

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

matrix4_adjoint_f32 ¶

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

matrix4_adjoint_f64 ¶

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

matrix4_cofactor_f16 ¶

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

matrix4_cofactor_f32 ¶

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

matrix4_cofactor_f64 ¶

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

matrix4_determinant_f16 ¶

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

matrix4_determinant_f32 ¶

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

matrix4_determinant_f64 ¶

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

matrix4_from_derived_euler_angle_x_f16 ¶

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 ¶

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 ¶

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 ¶

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

matrix4_from_derived_euler_angle_y_f32 ¶

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

matrix4_from_derived_euler_angle_y_f64 ¶

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

matrix4_from_derived_euler_angle_z_f16 ¶

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

matrix4_from_derived_euler_angle_z_f32 ¶

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

matrix4_from_derived_euler_angle_z_f64 ¶

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

matrix4_from_euler_angle_x_f16 ¶

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

matrix4_from_euler_angle_x_f32 ¶

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

matrix4_from_euler_angle_x_f64 ¶

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

matrix4_from_euler_angle_y_f16 ¶

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

matrix4_from_euler_angle_y_f32 ¶

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

matrix4_from_euler_angle_y_f64 ¶

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

matrix4_from_euler_angle_z_f16 ¶

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

matrix4_from_euler_angle_z_f32 ¶

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

matrix4_from_euler_angle_z_f64 ¶

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

matrix4_from_euler_angles_f16 ¶

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

matrix4_from_euler_angles_f32 ¶

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

matrix4_from_euler_angles_f64 ¶

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

matrix4_from_euler_angles_xy_f16 ¶

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

matrix4_from_euler_angles_xy_f32 ¶

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

matrix4_from_euler_angles_xy_f64 ¶

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

matrix4_from_euler_angles_xyx_f16 ¶

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

matrix4_from_euler_angles_xyx_f32 ¶

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

matrix4_from_euler_angles_xyx_f64 ¶

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

matrix4_from_euler_angles_xyz_f16 ¶

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

matrix4_from_euler_angles_xyz_f32 ¶

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

matrix4_from_euler_angles_xyz_f64 ¶

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

matrix4_from_euler_angles_xz_f16 ¶

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

matrix4_from_euler_angles_xz_f32 ¶

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

matrix4_from_euler_angles_xz_f64 ¶

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

matrix4_from_euler_angles_xzx_f16 ¶

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

matrix4_from_euler_angles_xzx_f32 ¶

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

matrix4_from_euler_angles_xzx_f64 ¶

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

matrix4_from_euler_angles_xzy_f16 ¶

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

matrix4_from_euler_angles_xzy_f32 ¶

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

matrix4_from_euler_angles_xzy_f64 ¶

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

matrix4_from_euler_angles_yx_f16 ¶

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

matrix4_from_euler_angles_yx_f32 ¶

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

matrix4_from_euler_angles_yx_f64 ¶

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

matrix4_from_euler_angles_yxy_f16 ¶

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

matrix4_from_euler_angles_yxy_f32 ¶

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

matrix4_from_euler_angles_yxy_f64 ¶

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

matrix4_from_euler_angles_yxz_f16 ¶

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

matrix4_from_euler_angles_yxz_f32 ¶

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

matrix4_from_euler_angles_yxz_f64 ¶

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

matrix4_from_euler_angles_yz_f16 ¶

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

matrix4_from_euler_angles_yz_f32 ¶

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

matrix4_from_euler_angles_yz_f64 ¶

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

matrix4_from_euler_angles_yzx_f16 ¶

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

matrix4_from_euler_angles_yzx_f32 ¶

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

matrix4_from_euler_angles_yzx_f64 ¶

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

matrix4_from_euler_angles_yzy_f16 ¶

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

matrix4_from_euler_angles_yzy_f32 ¶

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

matrix4_from_euler_angles_yzy_f64 ¶

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

matrix4_from_euler_angles_zx_f16 ¶

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

matrix4_from_euler_angles_zx_f32 ¶

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

matrix4_from_euler_angles_zx_f64 ¶

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

matrix4_from_euler_angles_zxy_f16 ¶

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

matrix4_from_euler_angles_zxy_f32 ¶

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

matrix4_from_euler_angles_zxy_f64 ¶

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

matrix4_from_euler_angles_zxz_f16 ¶

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

matrix4_from_euler_angles_zxz_f32 ¶

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

matrix4_from_euler_angles_zxz_f64 ¶

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

matrix4_from_euler_angles_zy_f16 ¶

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

matrix4_from_euler_angles_zy_f32 ¶

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

matrix4_from_euler_angles_zy_f64 ¶

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

matrix4_from_euler_angles_zyx_f16 ¶

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

matrix4_from_euler_angles_zyx_f32 ¶

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

matrix4_from_euler_angles_zyx_f64 ¶

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

matrix4_from_euler_angles_zyz_f16 ¶

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

matrix4_from_euler_angles_zyz_f32 ¶

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

matrix4_from_euler_angles_zyz_f64 ¶

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

matrix4_from_matrix2_f16 ¶

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

matrix4_from_matrix2_f32 ¶

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

matrix4_from_matrix2_f64 ¶

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

matrix4_from_matrix3_f16 ¶

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

matrix4_from_matrix3_f32 ¶

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

matrix4_from_matrix3_f64 ¶

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

matrix4_from_quaternion_f16 ¶

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

matrix4_from_quaternion_f32 ¶

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

matrix4_from_quaternion_f64 ¶

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

matrix4_from_scalar_f16 ¶

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

matrix4_from_scalar_f32 ¶

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

matrix4_from_scalar_f64 ¶

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

matrix4_from_trs_f16 ¶

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

matrix4_from_trs_f32 ¶

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

matrix4_from_trs_f64 ¶

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

matrix4_from_yaw_pitch_roll_f16 ¶

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

matrix4_from_yaw_pitch_roll_f32 ¶

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

matrix4_from_yaw_pitch_roll_f64 ¶

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

matrix4_infinite_perspective_f16 ¶

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

matrix4_infinite_perspective_f32 ¶

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

matrix4_infinite_perspective_f64 ¶

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

matrix4_inverse_f16 ¶

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

matrix4_inverse_f32 ¶

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

matrix4_inverse_f64 ¶

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

matrix4_inverse_transpose_f16 ¶

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

matrix4_inverse_transpose_f32 ¶

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

matrix4_inverse_transpose_f64 ¶

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

matrix4_look_at_f16 ¶

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

matrix4_look_at_f32 ¶

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

matrix4_look_at_f64 ¶

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

matrix4_look_at_from_fru_f16 ¶

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 ¶

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 ¶

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

matrix4_minor_f16 ¶

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

matrix4_minor_f32 ¶

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

matrix4_minor_f64 ¶

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

matrix4_orientation_f16 ¶

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

matrix4_orientation_f32 ¶

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

matrix4_orientation_f64 ¶

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

matrix4_perspective_f16 ¶

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

matrix4_perspective_f32 ¶

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

matrix4_perspective_f64 ¶

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

matrix4_rotate_f16 ¶

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

matrix4_rotate_f32 ¶

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

matrix4_rotate_f64 ¶

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

matrix4_scale_f16 ¶

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

matrix4_scale_f32 ¶

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

matrix4_scale_f64 ¶

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

matrix4_translate_f16 ¶

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

matrix4_translate_f32 ¶

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

matrix4_translate_f64 ¶

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

matrix_cast ¶

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

matrix_comp_mul ¶

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

matrix_mul ¶

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

matrix_mul_differ ¶

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

matrix_mul_vector ¶

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

matrix_ortho3d_f16 ¶

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

matrix_ortho3d_f32 ¶

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

matrix_ortho3d_f64 ¶

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

matrix_to_ptr ¶

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

max_double ¶

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

max_single ¶

max_single :: proc "odin" (value: $) -> $ {…}

max_triple ¶

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

min_double ¶

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

min_single ¶

min_single :: proc "odin" (value: $) -> $ {…}

min_triple ¶

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

mix ¶

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

mod ¶

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

not ¶

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

not_equal_array ¶

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

not_equal_single ¶

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

outer_product ¶

outer_product :: builtin.outer_product

pitch_from_quaternion_f16 ¶

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

pitch_from_quaternion_f32 ¶

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

pitch_from_quaternion_f64 ¶

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

pitch_yaw_roll_from_quaternion_f16 ¶

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

pitch_yaw_roll_from_quaternion_f32 ¶

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

pitch_yaw_roll_from_quaternion_f64 ¶

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

polar_from_euclidean_f16 ¶

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

polar_from_euclidean_f32 ¶

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

polar_from_euclidean_f64 ¶

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

pow ¶

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

projection ¶

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

quaternion128_dot ¶

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

quaternion128_mul_vector3 ¶

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

quaternion256_dot ¶

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

quaternion256_mul_vector3 ¶

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

quaternion64_dot ¶

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

quaternion64_mul_vector3 ¶

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

quaternion_angle_axis_f16 ¶

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

quaternion_angle_axis_f32 ¶

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

quaternion_angle_axis_f64 ¶

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

quaternion_between_two_vector3_f16 ¶

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

quaternion_between_two_vector3_f32 ¶

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

quaternion_between_two_vector3_f64 ¶

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

quaternion_cross ¶

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

quaternion_from_euler_angle_x_f16 ¶

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

quaternion_from_euler_angle_x_f32 ¶

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

quaternion_from_euler_angle_x_f64 ¶

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

quaternion_from_euler_angle_y_f16 ¶

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

quaternion_from_euler_angle_y_f32 ¶

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

quaternion_from_euler_angle_y_f64 ¶

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

quaternion_from_euler_angle_z_f16 ¶

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

quaternion_from_euler_angle_z_f32 ¶

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

quaternion_from_euler_angle_z_f64 ¶

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

quaternion_from_euler_angles_f16 ¶

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

quaternion_from_euler_angles_f32 ¶

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

quaternion_from_euler_angles_f64 ¶

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

quaternion_from_forward_and_up_f16 ¶

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

quaternion_from_forward_and_up_f32 ¶

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

quaternion_from_forward_and_up_f64 ¶

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

quaternion_from_matrix3_f16 ¶

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

quaternion_from_matrix3_f32 ¶

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

quaternion_from_matrix3_f64 ¶

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

quaternion_from_matrix4_f16 ¶

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

quaternion_from_matrix4_f32 ¶

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

quaternion_from_matrix4_f64 ¶

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

quaternion_from_pitch_yaw_roll_f16 ¶

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

quaternion_from_pitch_yaw_roll_f32 ¶

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

quaternion_from_pitch_yaw_roll_f64 ¶

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

quaternion_from_scalar_f16 ¶

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

quaternion_from_scalar_f32 ¶

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

quaternion_from_scalar_f64 ¶

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

quaternion_inverse ¶

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

quaternion_length ¶

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

quaternion_length2 ¶

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

quaternion_look_at_f16 ¶

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

quaternion_look_at_f32 ¶

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

quaternion_look_at_f64 ¶

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

quaternion_mul_quaternion ¶

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

quaternion_nlerp_f16 ¶

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

quaternion_nlerp_f32 ¶

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

quaternion_nlerp_f64 ¶

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

quaternion_normalize ¶

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

quaternion_normalize0 ¶

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

quaternion_slerp_f16 ¶

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

quaternion_slerp_f32 ¶

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

quaternion_slerp_f64 ¶

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

quaternion_squad_f16 ¶

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

quaternion_squad_f32 ¶

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

quaternion_squad_f64 ¶

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

radians ¶

radians :: proc "odin" (value: $) -> $ {…}

reflect ¶

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

refract ¶

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

roll_from_quaternion_f16 ¶

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

roll_from_quaternion_f32 ¶

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

roll_from_quaternion_f64 ¶

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

round ¶

round :: proc "odin" (value: $) -> $ {…}

saturate ¶

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

scalar_cross ¶

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

scalar_dot ¶

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

scalar_f32_swizzle1 ¶

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

scalar_f32_swizzle2 ¶

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

scalar_f32_swizzle3 ¶

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

scalar_f32_swizzle4 ¶

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

scalar_f64_swizzle1 ¶

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

scalar_f64_swizzle2 ¶

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

scalar_f64_swizzle3 ¶

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

scalar_f64_swizzle4 ¶

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

scalar_triple_product ¶

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

sign ¶

sign :: proc "odin" (value: $) -> $ {…}

sin ¶

sin :: proc "odin" (value: $) -> $ {…}

smootherstep ¶

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

smoothstep ¶

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

sqrt ¶

sqrt :: proc "odin" (value: $) -> $ {…}

step ¶

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

tan ¶

tan :: proc "odin" (value: $) -> $ {…}

to_complex128 ¶

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

to_complex32 ¶

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

to_complex64 ¶

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

to_f32 ¶

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

to_f64 ¶

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

to_i16 ¶

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

to_i32 ¶

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

to_i64 ¶

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

to_i8 ¶

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

to_int ¶

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

to_quaternion128 ¶

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

to_quaternion256 ¶

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

to_quaternion64 ¶

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

to_u16 ¶

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

to_u32 ¶

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

to_u64 ¶

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

to_u8 ¶

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

to_uint ¶

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

transpose ¶

transpose :: builtin.transpose

unlerp ¶

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

vector2_orthogonal ¶

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

vector2f32_swizzle1 ¶

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

vector2f32_swizzle2 ¶

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

vector2f32_swizzle3 ¶

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

vector2f32_swizzle4 ¶

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

vector2f64_swizzle1 ¶

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

vector2f64_swizzle2 ¶

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

vector2f64_swizzle3 ¶

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

vector2f64_swizzle4 ¶

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

vector3_orthogonal ¶

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

vector3_orthonormalize_f16 ¶

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

vector3_orthonormalize_f32 ¶

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

vector3_orthonormalize_f64 ¶

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

vector3f32_swizzle1 ¶

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

vector3f32_swizzle2 ¶

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

vector3f32_swizzle3 ¶

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

vector3f32_swizzle4 ¶

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

vector3f64_swizzle1 ¶

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

vector3f64_swizzle2 ¶

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

vector3f64_swizzle3 ¶

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

vector3f64_swizzle4 ¶

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

vector4_hsl_to_rgb_f16 ¶

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

vector4_hsl_to_rgb_f32 ¶

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

vector4_hsl_to_rgb_f64 ¶

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

vector4_linear_to_srgb_f16 ¶

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

vector4_linear_to_srgb_f32 ¶

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

vector4_linear_to_srgb_f64 ¶

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

vector4_rgb_to_hsl_f16 ¶

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

vector4_rgb_to_hsl_f32 ¶

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

vector4_rgb_to_hsl_f64 ¶

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

vector4_srgb_to_linear_f16 ¶

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

vector4_srgb_to_linear_f32 ¶

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

vector4_srgb_to_linear_f64 ¶

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

vector4f32_swizzle1 ¶

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

vector4f32_swizzle2 ¶

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

vector4f32_swizzle3 ¶

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

vector4f32_swizzle4 ¶

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

vector4f64_swizzle1 ¶

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

vector4f64_swizzle2 ¶

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

vector4f64_swizzle3 ¶

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

vector4f64_swizzle4 ¶

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

vector_cross2 ¶

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

vector_cross3 ¶

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

vector_dot ¶

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

vector_length ¶

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

vector_length2 ¶

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

vector_normalize ¶

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

vector_normalize0 ¶

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

vector_slerp ¶

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

vector_to_ptr ¶

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

vector_triple_product ¶

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

yaw_from_quaternion_f16 ¶

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

yaw_from_quaternion_f32 ¶

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

yaw_from_quaternion_f64 ¶

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

Procedure Groups

Source Files

Generation Information

Generated with odin version dev-2022-12 (vendor "odin") Windows_amd64 @ 2022-12-06 21:08:55.049370300 +0000 UTC