package core:math/linalg/hlsl

Overview

core:math/linalg/hlsl implements a HLSL-like mathematics library plus numerous other utility procedures

Index

Variables (0)

This section is empty.

Procedures (738)

Types

bool2 ¶

bool2 :: distinct [2]bool

bool3 ¶

bool3 :: distinct [3]bool

bool4 ¶

bool4 :: distinct [4]bool

double ¶

double :: f64

double1x1 ¶

double1x1 :: distinct matrix[1, 1]f64

double1x2 ¶

double1x2 :: distinct matrix[1, 2]f64

double1x3 ¶

double1x3 :: distinct matrix[1, 3]f64

double1x4 ¶

double1x4 :: distinct matrix[1, 4]f64

double2 ¶

double2 :: distinct [2]f64

double2x1 ¶

double2x1 :: distinct matrix[2, 1]f64

double2x2 ¶

double2x2 :: distinct matrix[2, 2]f64

double2x3 ¶

double2x3 :: distinct matrix[2, 3]f64

double2x4 ¶

double2x4 :: distinct matrix[2, 4]f64

double3 ¶

double3 :: distinct [3]f64

double3x1 ¶

double3x1 :: distinct matrix[3, 1]f64

double3x2 ¶

double3x2 :: distinct matrix[3, 2]f64

double3x3 ¶

double3x3 :: distinct matrix[3, 3]f64

double3x4 ¶

double3x4 :: distinct matrix[3, 4]f64

double4 ¶

double4 :: distinct [4]f64

double4x1 ¶

double4x1 :: distinct matrix[4, 1]f64

double4x2 ¶

double4x2 :: distinct matrix[4, 2]f64

double4x3 ¶

double4x3 :: distinct matrix[4, 3]f64

double4x4 ¶

double4x4 :: distinct matrix[4, 4]f64

float ¶

float :: f32
 

Aliases (not distinct) of types

float1x1 ¶

float1x1 :: distinct matrix[1, 1]f32
 

Odin matrices are stored internally as Column-Major, which matches the internal layout of HLSL by default

float1x2 ¶

float1x2 :: distinct matrix[1, 2]f32

float1x3 ¶

float1x3 :: distinct matrix[1, 3]f32

float1x4 ¶

float1x4 :: distinct matrix[1, 4]f32

float2 ¶

float2 :: distinct [2]f32

float2x1 ¶

float2x1 :: distinct matrix[2, 1]f32

float2x2 ¶

float2x2 :: distinct matrix[2, 2]f32

float2x3 ¶

float2x3 :: distinct matrix[2, 3]f32

float2x4 ¶

float2x4 :: distinct matrix[2, 4]f32

float3 ¶

float3 :: distinct [3]f32

float3x1 ¶

float3x1 :: distinct matrix[3, 1]f32

float3x2 ¶

float3x2 :: distinct matrix[3, 2]f32

float3x3 ¶

float3x3 :: distinct matrix[3, 3]f32

float3x4 ¶

float3x4 :: distinct matrix[3, 4]f32

float4 ¶

float4 :: distinct [4]f32

float4x1 ¶

float4x1 :: distinct matrix[4, 1]f32

float4x2 ¶

float4x2 :: distinct matrix[4, 2]f32

float4x3 ¶

float4x3 :: distinct matrix[4, 3]f32

float4x4 ¶

float4x4 :: distinct matrix[4, 4]f32

int ¶

int :: i32

int1x1 ¶

int1x1 :: distinct matrix[1, 1]i32

int1x2 ¶

int1x2 :: distinct matrix[1, 2]i32

int1x3 ¶

int1x3 :: distinct matrix[1, 3]i32

int1x4 ¶

int1x4 :: distinct matrix[1, 4]i32

int2 ¶

int2 :: distinct [2]i32

int2x1 ¶

int2x1 :: distinct matrix[2, 1]i32

int2x2 ¶

int2x2 :: distinct matrix[2, 2]i32

int2x3 ¶

int2x3 :: distinct matrix[2, 3]i32

int2x4 ¶

int2x4 :: distinct matrix[2, 4]i32

int3 ¶

int3 :: distinct [3]i32

int3x1 ¶

int3x1 :: distinct matrix[3, 1]i32

int3x2 ¶

int3x2 :: distinct matrix[3, 2]i32

int3x3 ¶

int3x3 :: distinct matrix[3, 3]i32

int3x4 ¶

int3x4 :: distinct matrix[3, 4]i32

int4 ¶

int4 :: distinct [4]i32

int4x1 ¶

int4x1 :: distinct matrix[4, 1]i32

int4x2 ¶

int4x2 :: distinct matrix[4, 2]i32

int4x3 ¶

int4x3 :: distinct matrix[4, 3]i32

int4x4 ¶

int4x4 :: distinct matrix[4, 4]i32

uint ¶

uint :: u32

uint2 ¶

uint2 :: distinct [2]u32

uint3 ¶

uint3 :: distinct [3]u32

uint4 ¶

uint4 :: distinct [4]u32

Constants

DOUBLE_EPSILON ¶

DOUBLE_EPSILON :: 1e-15

E ¶

E :: 2.71828182845904523536

FLOAT_EPSILON ¶

FLOAT_EPSILON :: 1e-7

LN10 ¶

LN10 :: 2.30258509299404568401799145468436421

LN2 ¶

LN2 :: 0.693147180559945309417232121458176568

PI ¶

PI :: 3.14159265358979323846264338327950288

SQRT_FIVE ¶

SQRT_FIVE :: 2.23606797749978969640917366873127623

SQRT_THREE ¶

SQRT_THREE :: 1.73205080756887729352744634150587236

SQRT_TWO ¶

SQRT_TWO :: 1.41421356237309504880168872420969808

TAU ¶

TAU :: 6.28318530717958647692528676655900576

e ¶

e :: E

π ¶

π :: PI

τ ¶

τ :: TAU

Variables

This section is empty.

Procedures

abs_double ¶

abs_double :: proc "cdecl" (degrees: f64) -> f64 {…}

abs_double2 ¶

abs_double2 :: proc "cdecl" (x: double2) -> double2 {…}

abs_double3 ¶

abs_double3 :: proc "cdecl" (x: double3) -> double3 {…}

abs_double4 ¶

abs_double4 :: proc "cdecl" (x: double4) -> double4 {…}

abs_float ¶

abs_float :: proc "cdecl" (degrees: f32) -> f32 {…}

abs_float2 ¶

abs_float2 :: proc "cdecl" (x: float2) -> float2 {…}

abs_float3 ¶

abs_float3 :: proc "cdecl" (x: float3) -> float3 {…}

abs_float4 ¶

abs_float4 :: proc "cdecl" (x: float4) -> float4 {…}

abs_int ¶

abs_int :: proc "cdecl" (c: i32) -> i32 {…}

abs_int2 ¶

abs_int2 :: proc "cdecl" (x: int2) -> int2 {…}

abs_int3 ¶

abs_int3 :: proc "cdecl" (x: int3) -> int3 {…}

abs_int4 ¶

abs_int4 :: proc "cdecl" (x: int4) -> int4 {…}

abs_uint ¶

abs_uint :: proc "cdecl" (x: u32) -> u32 {…}

abs_uint2 ¶

abs_uint2 :: proc "cdecl" (x: uint2) -> uint2 {…}

abs_uint3 ¶

abs_uint3 :: proc "cdecl" (x: uint3) -> uint3 {…}

abs_uint4 ¶

abs_uint4 :: proc "cdecl" (x: uint4) -> uint4 {…}

acos_double ¶

acos_double :: proc "cdecl" (degrees: f64) -> f64 {…}

acos_double2 ¶

acos_double2 :: proc "cdecl" (x: double2) -> double2 {…}

acos_double3 ¶

acos_double3 :: proc "cdecl" (x: double3) -> double3 {…}

acos_double4 ¶

acos_double4 :: proc "cdecl" (x: double4) -> double4 {…}

acos_float ¶

acos_float :: proc "cdecl" (degrees: f32) -> f32 {…}

acos_float2 ¶

acos_float2 :: proc "cdecl" (x: float2) -> float2 {…}

acos_float3 ¶

acos_float3 :: proc "cdecl" (x: float3) -> float3 {…}

acos_float4 ¶

acos_float4 :: proc "cdecl" (x: float4) -> float4 {…}

acosh_double ¶

acosh_double :: proc "cdecl" (degrees: f64) -> f64 {…}

acosh_double2 ¶

acosh_double2 :: proc "cdecl" (x: double2) -> double2 {…}

acosh_double3 ¶

acosh_double3 :: proc "cdecl" (x: double3) -> double3 {…}

acosh_double4 ¶

acosh_double4 :: proc "cdecl" (x: double4) -> double4 {…}

acosh_float ¶

acosh_float :: proc "cdecl" (degrees: f32) -> f32 {…}

acosh_float2 ¶

acosh_float2 :: proc "cdecl" (x: float2) -> float2 {…}

acosh_float3 ¶

acosh_float3 :: proc "cdecl" (x: float3) -> float3 {…}

acosh_float4 ¶

acosh_float4 :: proc "cdecl" (x: float4) -> float4 {…}

all_bool ¶

all_bool :: proc "cdecl" (v: bool) -> bool {…}

all_bool2 ¶

all_bool2 :: proc "cdecl" (v: bool2) -> bool {…}

all_bool3 ¶

all_bool3 :: proc "cdecl" (v: bool3) -> bool {…}

all_bool4 ¶

all_bool4 :: proc "cdecl" (v: bool4) -> bool {…}

any_bool ¶

any_bool :: proc "cdecl" (v: bool) -> bool {…}

any_bool2 ¶

any_bool2 :: proc "cdecl" (v: bool2) -> bool {…}

any_bool3 ¶

any_bool3 :: proc "cdecl" (v: bool3) -> bool {…}

any_bool4 ¶

any_bool4 :: proc "cdecl" (v: bool4) -> bool {…}

asdouble_bool2 ¶

asdouble_bool2 :: proc "cdecl" (v: bool2) -> double2 {…}

asdouble_bool3 ¶

asdouble_bool3 :: proc "cdecl" (v: bool3) -> double3 {…}

asdouble_bool4 ¶

asdouble_bool4 :: proc "cdecl" (v: bool4) -> double4 {…}

asdouble_double ¶

asdouble_double :: proc "cdecl" (degrees: f64) -> f64 {…}

asdouble_double1x1 ¶

asdouble_double1x1 :: proc "cdecl" (m: double1x1) -> double1x1 {…}

asdouble_double1x2 ¶

asdouble_double1x2 :: proc "cdecl" (v: double1x2) -> double1x2 {…}

asdouble_double1x3 ¶

asdouble_double1x3 :: proc "cdecl" (v: double1x3) -> double1x3 {…}

asdouble_double1x4 ¶

asdouble_double1x4 :: proc "cdecl" (v: double1x4) -> double1x4 {…}

asdouble_double2 ¶

asdouble_double2 :: proc "cdecl" (x: double2) -> double2 {…}

asdouble_double2x1 ¶

asdouble_double2x1 :: proc "cdecl" (v: double2x1) -> double2x1 {…}

asdouble_double2x2 ¶

asdouble_double2x2 :: proc "cdecl" (m: double2x2) -> double2x2 {…}

asdouble_double2x3 ¶

asdouble_double2x3 :: proc "cdecl" (v: double2x3) -> double2x3 {…}

asdouble_double2x4 ¶

asdouble_double2x4 :: proc "cdecl" (v: double2x4) -> double2x4 {…}

asdouble_double3 ¶

asdouble_double3 :: proc "cdecl" (x: double3) -> double3 {…}

asdouble_double3x1 ¶

asdouble_double3x1 :: proc "cdecl" (v: double3x1) -> double3x1 {…}

asdouble_double3x2 ¶

asdouble_double3x2 :: proc "cdecl" (v: double3x2) -> double3x2 {…}

asdouble_double3x3 ¶

asdouble_double3x3 :: proc "cdecl" (m: double3x3) -> double3x3 {…}

asdouble_double3x4 ¶

asdouble_double3x4 :: proc "cdecl" (v: double3x4) -> double3x4 {…}

asdouble_double4 ¶

asdouble_double4 :: proc "cdecl" (x: double4) -> double4 {…}

asdouble_double4x1 ¶

asdouble_double4x1 :: proc "cdecl" (v: double4x1) -> double4x1 {…}

asdouble_double4x2 ¶

asdouble_double4x2 :: proc "cdecl" (v: double4x2) -> double4x2 {…}

asdouble_double4x3 ¶

asdouble_double4x3 :: proc "cdecl" (v: double4x3) -> double4x3 {…}

asdouble_double4x4 ¶

asdouble_double4x4 :: proc "cdecl" (m: double4x4) -> double4x4 {…}

asdouble_float ¶

asdouble_float :: proc "cdecl" (v: f32) -> f64 {…}

asdouble_float1x1 ¶

asdouble_float1x1 :: proc "cdecl" (v: float1x1) -> double1x1 {…}

asdouble_float1x2 ¶

asdouble_float1x2 :: proc "cdecl" (v: float1x2) -> double1x2 {…}

asdouble_float1x3 ¶

asdouble_float1x3 :: proc "cdecl" (v: float1x3) -> double1x3 {…}

asdouble_float1x4 ¶

asdouble_float1x4 :: proc "cdecl" (v: float1x4) -> double1x4 {…}

asdouble_float2 ¶

asdouble_float2 :: proc "cdecl" (v: float2) -> double2 {…}

asdouble_float2x1 ¶

asdouble_float2x1 :: proc "cdecl" (v: float2x1) -> double2x1 {…}

asdouble_float2x2 ¶

asdouble_float2x2 :: proc "cdecl" (v: float2x2) -> double2x2 {…}

asdouble_float2x3 ¶

asdouble_float2x3 :: proc "cdecl" (v: float2x3) -> double2x3 {…}

asdouble_float2x4 ¶

asdouble_float2x4 :: proc "cdecl" (v: float2x4) -> double2x4 {…}

asdouble_float3 ¶

asdouble_float3 :: proc "cdecl" (v: float3) -> double3 {…}

asdouble_float3x1 ¶

asdouble_float3x1 :: proc "cdecl" (v: float3x1) -> double3x1 {…}

asdouble_float3x2 ¶

asdouble_float3x2 :: proc "cdecl" (v: float3x2) -> double3x2 {…}

asdouble_float3x3 ¶

asdouble_float3x3 :: proc "cdecl" (v: float3x3) -> double3x3 {…}

asdouble_float3x4 ¶

asdouble_float3x4 :: proc "cdecl" (v: float3x4) -> double3x4 {…}

asdouble_float4 ¶

asdouble_float4 :: proc "cdecl" (v: float4) -> double4 {…}

asdouble_float4x1 ¶

asdouble_float4x1 :: proc "cdecl" (v: float4x1) -> double4x1 {…}

asdouble_float4x2 ¶

asdouble_float4x2 :: proc "cdecl" (v: float4x2) -> double4x2 {…}

asdouble_float4x3 ¶

asdouble_float4x3 :: proc "cdecl" (v: float4x3) -> double4x3 {…}

asdouble_float4x4 ¶

asdouble_float4x4 :: proc "cdecl" (v: float4x4) -> double4x4 {…}

asdouble_int ¶

asdouble_int :: proc "cdecl" (v: i32) -> f64 {…}

asdouble_int2 ¶

asdouble_int2 :: proc "cdecl" (v: int2) -> double2 {…}

asdouble_int3 ¶

asdouble_int3 :: proc "cdecl" (v: int3) -> double3 {…}

asdouble_int4 ¶

asdouble_int4 :: proc "cdecl" (v: int4) -> double4 {…}

asdouble_uint ¶

asdouble_uint :: proc "cdecl" (v: u32) -> f64 {…}

asdouble_uint2 ¶

asdouble_uint2 :: proc "cdecl" (v: uint2) -> double2 {…}

asdouble_uint3 ¶

asdouble_uint3 :: proc "cdecl" (v: uint3) -> double3 {…}

asdouble_uint4 ¶

asdouble_uint4 :: proc "cdecl" (v: uint4) -> double4 {…}

asfloat_bool2 ¶

asfloat_bool2 :: proc "cdecl" (v: bool2) -> float2 {…}

asfloat_bool3 ¶

asfloat_bool3 :: proc "cdecl" (v: bool3) -> float3 {…}

asfloat_bool4 ¶

asfloat_bool4 :: proc "cdecl" (v: bool4) -> float4 {…}

asfloat_double ¶

asfloat_double :: proc "cdecl" (v: f64) -> f32 {…}

asfloat_double1x1 ¶

asfloat_double1x1 :: proc "cdecl" (v: double1x1) -> float1x1 {…}

asfloat_double1x2 ¶

asfloat_double1x2 :: proc "cdecl" (v: double1x2) -> float1x2 {…}

asfloat_double1x3 ¶

asfloat_double1x3 :: proc "cdecl" (v: double1x3) -> float1x3 {…}

asfloat_double1x4 ¶

asfloat_double1x4 :: proc "cdecl" (v: double1x4) -> float1x4 {…}

asfloat_double2 ¶

asfloat_double2 :: proc "cdecl" (v: double2) -> float2 {…}

asfloat_double2x1 ¶

asfloat_double2x1 :: proc "cdecl" (v: double2x1) -> float2x1 {…}

asfloat_double2x2 ¶

asfloat_double2x2 :: proc "cdecl" (v: double2x2) -> float2x2 {…}

asfloat_double2x3 ¶

asfloat_double2x3 :: proc "cdecl" (v: double2x3) -> float2x3 {…}

asfloat_double2x4 ¶

asfloat_double2x4 :: proc "cdecl" (v: double2x4) -> float2x4 {…}

asfloat_double3 ¶

asfloat_double3 :: proc "cdecl" (v: double3) -> float3 {…}

asfloat_double3x1 ¶

asfloat_double3x1 :: proc "cdecl" (v: double3x1) -> float3x1 {…}

asfloat_double3x2 ¶

asfloat_double3x2 :: proc "cdecl" (v: double3x2) -> float3x2 {…}

asfloat_double3x3 ¶

asfloat_double3x3 :: proc "cdecl" (v: double3x3) -> float3x3 {…}

asfloat_double3x4 ¶

asfloat_double3x4 :: proc "cdecl" (v: double3x4) -> float3x4 {…}

asfloat_double4 ¶

asfloat_double4 :: proc "cdecl" (v: double4) -> float4 {…}

asfloat_double4x1 ¶

asfloat_double4x1 :: proc "cdecl" (v: double4x1) -> float4x1 {…}

asfloat_double4x2 ¶

asfloat_double4x2 :: proc "cdecl" (v: double4x2) -> float4x2 {…}

asfloat_double4x3 ¶

asfloat_double4x3 :: proc "cdecl" (v: double4x3) -> float4x3 {…}

asfloat_double4x4 ¶

asfloat_double4x4 :: proc "cdecl" (v: double4x4) -> float4x4 {…}

asfloat_float ¶

asfloat_float :: proc "cdecl" (degrees: f32) -> f32 {…}

asfloat_float1x1 ¶

asfloat_float1x1 :: proc "cdecl" (m: float1x1) -> float1x1 {…}

asfloat_float1x2 ¶

asfloat_float1x2 :: proc "cdecl" (v: float1x2) -> float1x2 {…}

asfloat_float1x3 ¶

asfloat_float1x3 :: proc "cdecl" (v: float1x3) -> float1x3 {…}

asfloat_float1x4 ¶

asfloat_float1x4 :: proc "cdecl" (v: float1x4) -> float1x4 {…}

asfloat_float2 ¶

asfloat_float2 :: proc "cdecl" (x: float2) -> float2 {…}

asfloat_float2x1 ¶

asfloat_float2x1 :: proc "cdecl" (v: float2x1) -> float2x1 {…}

asfloat_float2x2 ¶

asfloat_float2x2 :: proc "cdecl" (m: float2x2) -> float2x2 {…}

asfloat_float2x3 ¶

asfloat_float2x3 :: proc "cdecl" (v: float2x3) -> float2x3 {…}

asfloat_float2x4 ¶

asfloat_float2x4 :: proc "cdecl" (v: float2x4) -> float2x4 {…}

asfloat_float3 ¶

asfloat_float3 :: proc "cdecl" (x: float3) -> float3 {…}

asfloat_float3x1 ¶

asfloat_float3x1 :: proc "cdecl" (v: float3x1) -> float3x1 {…}

asfloat_float3x2 ¶

asfloat_float3x2 :: proc "cdecl" (v: float3x2) -> float3x2 {…}

asfloat_float3x3 ¶

asfloat_float3x3 :: proc "cdecl" (m: float3x3) -> float3x3 {…}

asfloat_float3x4 ¶

asfloat_float3x4 :: proc "cdecl" (v: float3x4) -> float3x4 {…}

asfloat_float4 ¶

asfloat_float4 :: proc "cdecl" (x: float4) -> float4 {…}

asfloat_float4x1 ¶

asfloat_float4x1 :: proc "cdecl" (v: float4x1) -> float4x1 {…}

asfloat_float4x2 ¶

asfloat_float4x2 :: proc "cdecl" (v: float4x2) -> float4x2 {…}

asfloat_float4x3 ¶

asfloat_float4x3 :: proc "cdecl" (v: float4x3) -> float4x3 {…}

asfloat_float4x4 ¶

asfloat_float4x4 :: proc "cdecl" (m: float4x4) -> float4x4 {…}

asfloat_int ¶

asfloat_int :: proc "cdecl" (v: i32) -> f32 {…}

asfloat_int2 ¶

asfloat_int2 :: proc "cdecl" (v: int2) -> float2 {…}

asfloat_int3 ¶

asfloat_int3 :: proc "cdecl" (v: int3) -> float3 {…}

asfloat_int4 ¶

asfloat_int4 :: proc "cdecl" (v: int4) -> float4 {…}

asfloat_uint ¶

asfloat_uint :: proc "cdecl" (v: u32) -> f32 {…}

asfloat_uint2 ¶

asfloat_uint2 :: proc "cdecl" (v: uint2) -> float2 {…}

asfloat_uint3 ¶

asfloat_uint3 :: proc "cdecl" (v: uint3) -> float3 {…}

asfloat_uint4 ¶

asfloat_uint4 :: proc "cdecl" (v: uint4) -> float4 {…}

asin_double ¶

asin_double :: proc "cdecl" (degrees: f64) -> f64 {…}

asin_double2 ¶

asin_double2 :: proc "cdecl" (x: double2) -> double2 {…}

asin_double3 ¶

asin_double3 :: proc "cdecl" (x: double3) -> double3 {…}

asin_double4 ¶

asin_double4 :: proc "cdecl" (x: double4) -> double4 {…}

asin_float ¶

asin_float :: proc "cdecl" (degrees: f32) -> f32 {…}

asin_float2 ¶

asin_float2 :: proc "cdecl" (x: float2) -> float2 {…}

asin_float3 ¶

asin_float3 :: proc "cdecl" (x: float3) -> float3 {…}

asin_float4 ¶

asin_float4 :: proc "cdecl" (x: float4) -> float4 {…}

asinh_double ¶

asinh_double :: proc "cdecl" (degrees: f64) -> f64 {…}

asinh_double2 ¶

asinh_double2 :: proc "cdecl" (x: double2) -> double2 {…}

asinh_double3 ¶

asinh_double3 :: proc "cdecl" (x: double3) -> double3 {…}

asinh_double4 ¶

asinh_double4 :: proc "cdecl" (x: double4) -> double4 {…}

asinh_float ¶

asinh_float :: proc "cdecl" (degrees: f32) -> f32 {…}

asinh_float2 ¶

asinh_float2 :: proc "cdecl" (x: float2) -> float2 {…}

asinh_float3 ¶

asinh_float3 :: proc "cdecl" (x: float3) -> float3 {…}

asinh_float4 ¶

asinh_float4 :: proc "cdecl" (x: float4) -> float4 {…}

asint_bool2 ¶

asint_bool2 :: proc "cdecl" (v: bool2) -> int2 {…}

asint_bool3 ¶

asint_bool3 :: proc "cdecl" (v: bool3) -> int3 {…}

asint_bool4 ¶

asint_bool4 :: proc "cdecl" (v: bool4) -> int4 {…}

asint_double ¶

asint_double :: proc "cdecl" (v: f64) -> i32 {…}

asint_double1x1 ¶

asint_double1x1 :: proc "cdecl" (v: double1x1) -> int1x1 {…}

asint_double1x2 ¶

asint_double1x2 :: proc "cdecl" (v: double1x2) -> int1x2 {…}

asint_double1x3 ¶

asint_double1x3 :: proc "cdecl" (v: double1x3) -> int1x3 {…}

asint_double1x4 ¶

asint_double1x4 :: proc "cdecl" (v: double1x4) -> int1x4 {…}

asint_double2 ¶

asint_double2 :: proc "cdecl" (v: double2) -> int2 {…}

asint_double2x1 ¶

asint_double2x1 :: proc "cdecl" (v: double2x1) -> int2x1 {…}

asint_double2x2 ¶

asint_double2x2 :: proc "cdecl" (v: double2x2) -> int2x2 {…}

asint_double2x3 ¶

asint_double2x3 :: proc "cdecl" (v: double2x3) -> int2x3 {…}

asint_double2x4 ¶

asint_double2x4 :: proc "cdecl" (v: double2x4) -> int2x4 {…}

asint_double3 ¶

asint_double3 :: proc "cdecl" (v: double3) -> int3 {…}

asint_double3x1 ¶

asint_double3x1 :: proc "cdecl" (v: double3x1) -> int3x1 {…}

asint_double3x2 ¶

asint_double3x2 :: proc "cdecl" (v: double3x2) -> int3x2 {…}

asint_double3x3 ¶

asint_double3x3 :: proc "cdecl" (v: double3x3) -> int3x3 {…}

asint_double3x4 ¶

asint_double3x4 :: proc "cdecl" (v: double3x4) -> int3x4 {…}

asint_double4 ¶

asint_double4 :: proc "cdecl" (v: double4) -> int4 {…}

asint_double4x1 ¶

asint_double4x1 :: proc "cdecl" (v: double4x1) -> int4x1 {…}

asint_double4x2 ¶

asint_double4x2 :: proc "cdecl" (v: double4x2) -> int4x2 {…}

asint_double4x3 ¶

asint_double4x3 :: proc "cdecl" (v: double4x3) -> int4x3 {…}

asint_double4x4 ¶

asint_double4x4 :: proc "cdecl" (v: double4x4) -> int4x4 {…}

asint_float ¶

asint_float :: proc "cdecl" (v: f32) -> i32 {…}

asint_float1x1 ¶

asint_float1x1 :: proc "cdecl" (v: float1x1) -> int1x1 {…}

asint_float1x2 ¶

asint_float1x2 :: proc "cdecl" (v: float1x2) -> int1x2 {…}

asint_float1x3 ¶

asint_float1x3 :: proc "cdecl" (v: float1x3) -> int1x3 {…}

asint_float1x4 ¶

asint_float1x4 :: proc "cdecl" (v: float1x4) -> int1x4 {…}

asint_float2 ¶

asint_float2 :: proc "cdecl" (v: float2) -> int2 {…}

asint_float2x1 ¶

asint_float2x1 :: proc "cdecl" (v: float2x1) -> int2x1 {…}

asint_float2x2 ¶

asint_float2x2 :: proc "cdecl" (v: float2x2) -> int2x2 {…}

asint_float2x3 ¶

asint_float2x3 :: proc "cdecl" (v: float2x3) -> int2x3 {…}

asint_float2x4 ¶

asint_float2x4 :: proc "cdecl" (v: float2x4) -> int2x4 {…}

asint_float3 ¶

asint_float3 :: proc "cdecl" (v: float3) -> int3 {…}

asint_float3x1 ¶

asint_float3x1 :: proc "cdecl" (v: float3x1) -> int3x1 {…}

asint_float3x2 ¶

asint_float3x2 :: proc "cdecl" (v: float3x2) -> int3x2 {…}

asint_float3x3 ¶

asint_float3x3 :: proc "cdecl" (v: float3x3) -> int3x3 {…}

asint_float3x4 ¶

asint_float3x4 :: proc "cdecl" (v: float3x4) -> int3x4 {…}

asint_float4 ¶

asint_float4 :: proc "cdecl" (v: float4) -> int4 {…}

asint_float4x1 ¶

asint_float4x1 :: proc "cdecl" (v: float4x1) -> int4x1 {…}

asint_float4x2 ¶

asint_float4x2 :: proc "cdecl" (v: float4x2) -> int4x2 {…}

asint_float4x3 ¶

asint_float4x3 :: proc "cdecl" (v: float4x3) -> int4x3 {…}

asint_float4x4 ¶

asint_float4x4 :: proc "cdecl" (v: float4x4) -> int4x4 {…}

asint_int ¶

asint_int :: proc "cdecl" (c: i32) -> i32 {…}

asint_int2 ¶

asint_int2 :: proc "cdecl" (x: int2) -> int2 {…}

asint_int3 ¶

asint_int3 :: proc "cdecl" (x: int3) -> int3 {…}

asint_int4 ¶

asint_int4 :: proc "cdecl" (x: int4) -> int4 {…}

asint_uint ¶

asint_uint :: proc "cdecl" (v: u32) -> i32 {…}

asint_uint2 ¶

asint_uint2 :: proc "cdecl" (v: uint2) -> int2 {…}

asint_uint3 ¶

asint_uint3 :: proc "cdecl" (v: uint3) -> int3 {…}

asint_uint4 ¶

asint_uint4 :: proc "cdecl" (v: uint4) -> int4 {…}

asuint_bool2 ¶

asuint_bool2 :: proc "cdecl" (v: bool2) -> uint2 {…}

asuint_bool3 ¶

asuint_bool3 :: proc "cdecl" (v: bool3) -> uint3 {…}

asuint_bool4 ¶

asuint_bool4 :: proc "cdecl" (v: bool4) -> uint4 {…}

asuint_double ¶

asuint_double :: proc "cdecl" (v: f64) -> u32 {…}

asuint_double2 ¶

asuint_double2 :: proc "cdecl" (v: double2) -> uint2 {…}

asuint_double3 ¶

asuint_double3 :: proc "cdecl" (v: double3) -> uint3 {…}

asuint_double4 ¶

asuint_double4 :: proc "cdecl" (v: double4) -> uint4 {…}

asuint_float ¶

asuint_float :: proc "cdecl" (v: f32) -> u32 {…}

asuint_float2 ¶

asuint_float2 :: proc "cdecl" (v: float2) -> uint2 {…}

asuint_float3 ¶

asuint_float3 :: proc "cdecl" (v: float3) -> uint3 {…}

asuint_float4 ¶

asuint_float4 :: proc "cdecl" (v: float4) -> uint4 {…}

asuint_int ¶

asuint_int :: proc "cdecl" (v: i32) -> u32 {…}

asuint_int2 ¶

asuint_int2 :: proc "cdecl" (v: int2) -> uint2 {…}

asuint_int3 ¶

asuint_int3 :: proc "cdecl" (v: int3) -> uint3 {…}

asuint_int4 ¶

asuint_int4 :: proc "cdecl" (v: int4) -> uint4 {…}

asuint_uint ¶

asuint_uint :: proc "cdecl" (x: u32) -> u32 {…}

asuint_uint2 ¶

asuint_uint2 :: proc "cdecl" (x: uint2) -> uint2 {…}

asuint_uint3 ¶

asuint_uint3 :: proc "cdecl" (x: uint3) -> uint3 {…}

asuint_uint4 ¶

asuint_uint4 :: proc "cdecl" (x: uint4) -> uint4 {…}

atan2_double ¶

atan2_double :: proc "cdecl" (x, y: f64) -> f64 {…}

atan2_double2 ¶

atan2_double2 :: proc "cdecl" (y, x: double2) -> double2 {…}

atan2_double3 ¶

atan2_double3 :: proc "cdecl" (y, x: double3) -> double3 {…}

atan2_double4 ¶

atan2_double4 :: proc "cdecl" (y, x: double4) -> double4 {…}

atan2_float ¶

atan2_float :: proc "cdecl" (x, y: f32) -> f32 {…}

atan2_float2 ¶

atan2_float2 :: proc "cdecl" (y, x: float2) -> float2 {…}

atan2_float3 ¶

atan2_float3 :: proc "cdecl" (y, x: float3) -> float3 {…}

atan2_float4 ¶

atan2_float4 :: proc "cdecl" (y, x: float4) -> float4 {…}

atan_double ¶

atan_double :: proc "cdecl" (degrees: f64) -> f64 {…}

atan_double2 ¶

atan_double2 :: proc "cdecl" (x: double2) -> double2 {…}

atan_double3 ¶

atan_double3 :: proc "cdecl" (x: double3) -> double3 {…}

atan_double4 ¶

atan_double4 :: proc "cdecl" (x: double4) -> double4 {…}

atan_float ¶

atan_float :: proc "cdecl" (degrees: f32) -> f32 {…}

atan_float2 ¶

atan_float2 :: proc "cdecl" (x: float2) -> float2 {…}

atan_float3 ¶

atan_float3 :: proc "cdecl" (x: float3) -> float3 {…}

atan_float4 ¶

atan_float4 :: proc "cdecl" (x: float4) -> float4 {…}

atanh_double ¶

atanh_double :: proc "cdecl" (degrees: f64) -> f64 {…}

atanh_double2 ¶

atanh_double2 :: proc "cdecl" (x: double2) -> double2 {…}

atanh_double3 ¶

atanh_double3 :: proc "cdecl" (x: double3) -> double3 {…}

atanh_double4 ¶

atanh_double4 :: proc "cdecl" (x: double4) -> double4 {…}

atanh_float ¶

atanh_float :: proc "cdecl" (degrees: f32) -> f32 {…}

atanh_float2 ¶

atanh_float2 :: proc "cdecl" (x: float2) -> float2 {…}

atanh_float3 ¶

atanh_float3 :: proc "cdecl" (x: float3) -> float3 {…}

atanh_float4 ¶

atanh_float4 :: proc "cdecl" (x: float4) -> float4 {…}

ceil_double ¶

ceil_double :: proc "cdecl" (degrees: f64) -> f64 {…}

ceil_double2 ¶

ceil_double2 :: proc "cdecl" (x: double2) -> double2 {…}

ceil_double3 ¶

ceil_double3 :: proc "cdecl" (x: double3) -> double3 {…}

ceil_double4 ¶

ceil_double4 :: proc "cdecl" (x: double4) -> double4 {…}

ceil_float ¶

ceil_float :: proc "cdecl" (degrees: f32) -> f32 {…}

ceil_float2 ¶

ceil_float2 :: proc "cdecl" (x: float2) -> float2 {…}

ceil_float3 ¶

ceil_float3 :: proc "cdecl" (x: float3) -> float3 {…}

ceil_float4 ¶

ceil_float4 :: proc "cdecl" (x: float4) -> float4 {…}

clamp_double ¶

clamp_double :: proc "cdecl" (x, y, z: f64) -> f64 {…}

clamp_double2 ¶

clamp_double2 :: proc "cdecl" (x, y, z: double2) -> double2 {…}

clamp_double3 ¶

clamp_double3 :: proc "cdecl" (x, y, z: double3) -> double3 {…}

clamp_double4 ¶

clamp_double4 :: proc "cdecl" (x, y, z: double4) -> double4 {…}

clamp_float ¶

clamp_float :: proc "cdecl" (x, y, z: f32) -> f32 {…}

clamp_float2 ¶

clamp_float2 :: proc "cdecl" (x, y, z: float2) -> float2 {…}

clamp_float3 ¶

clamp_float3 :: proc "cdecl" (x, y, z: float3) -> float3 {…}

clamp_float4 ¶

clamp_float4 :: proc "cdecl" (x, y, z: float4) -> float4 {…}

clamp_int ¶

clamp_int :: proc "cdecl" (x, y, z: i32) -> i32 {…}

clamp_int2 ¶

clamp_int2 :: proc "cdecl" (x, y, z: int2) -> int2 {…}

clamp_int3 ¶

clamp_int3 :: proc "cdecl" (x, y, z: int3) -> int3 {…}

clamp_int4 ¶

clamp_int4 :: proc "cdecl" (x, y, z: int4) -> int4 {…}

clamp_uint ¶

clamp_uint :: proc "cdecl" (x, y, z: u32) -> u32 {…}

clamp_uint2 ¶

clamp_uint2 :: proc "cdecl" (x, y, z: uint2) -> uint2 {…}

clamp_uint3 ¶

clamp_uint3 :: proc "cdecl" (x, y, z: uint3) -> uint3 {…}

clamp_uint4 ¶

clamp_uint4 :: proc "cdecl" (x, y, z: uint4) -> uint4 {…}

cos_double ¶

cos_double :: proc "cdecl" (degrees: f64) -> f64 {…}

cos_double2 ¶

cos_double2 :: proc "cdecl" (x: double2) -> double2 {…}

cos_double3 ¶

cos_double3 :: proc "cdecl" (x: double3) -> double3 {…}

cos_double4 ¶

cos_double4 :: proc "cdecl" (x: double4) -> double4 {…}

cos_float ¶

cos_float :: proc "cdecl" (degrees: f32) -> f32 {…}

cos_float2 ¶

cos_float2 :: proc "cdecl" (x: float2) -> float2 {…}

cos_float3 ¶

cos_float3 :: proc "cdecl" (x: float3) -> float3 {…}

cos_float4 ¶

cos_float4 :: proc "cdecl" (x: float4) -> float4 {…}

cosh_double ¶

cosh_double :: proc "cdecl" (degrees: f64) -> f64 {…}

cosh_double2 ¶

cosh_double2 :: proc "cdecl" (x: double2) -> double2 {…}

cosh_double3 ¶

cosh_double3 :: proc "cdecl" (x: double3) -> double3 {…}

cosh_double4 ¶

cosh_double4 :: proc "cdecl" (x: double4) -> double4 {…}

cosh_float ¶

cosh_float :: proc "cdecl" (degrees: f32) -> f32 {…}

cosh_float2 ¶

cosh_float2 :: proc "cdecl" (x: float2) -> float2 {…}

cosh_float3 ¶

cosh_float3 :: proc "cdecl" (x: float3) -> float3 {…}

cosh_float4 ¶

cosh_float4 :: proc "cdecl" (x: float4) -> float4 {…}

cross_double3 ¶

cross_double3 :: proc "cdecl" (y, x: double3) -> double3 {…}

cross_float3 ¶

cross_float3 :: proc "cdecl" (y, x: float3) -> float3 {…}

cross_int3 ¶

cross_int3 :: proc "cdecl" (x, y: int3) -> int3 {…}

degrees_double ¶

degrees_double :: proc "cdecl" (degrees: f64) -> f64 {…}

degrees_double2 ¶

degrees_double2 :: proc "cdecl" (x: double2) -> double2 {…}

degrees_double3 ¶

degrees_double3 :: proc "cdecl" (x: double3) -> double3 {…}

degrees_double4 ¶

degrees_double4 :: proc "cdecl" (x: double4) -> double4 {…}

degrees_float ¶

degrees_float :: proc "cdecl" (degrees: f32) -> f32 {…}

degrees_float2 ¶

degrees_float2 :: proc "cdecl" (x: float2) -> float2 {…}

degrees_float3 ¶

degrees_float3 :: proc "cdecl" (x: float3) -> float3 {…}

degrees_float4 ¶

degrees_float4 :: proc "cdecl" (x: float4) -> float4 {…}

distance_double ¶

distance_double :: proc "cdecl" (x, y: f64) -> f64 {…}

distance_double2 ¶

distance_double2 :: proc "cdecl" (a, b: double2) -> f64 {…}

distance_double3 ¶

distance_double3 :: proc "cdecl" (a, b: double3) -> f64 {…}

distance_double4 ¶

distance_double4 :: proc "cdecl" (a, b: double4) -> f64 {…}

distance_float ¶

distance_float :: proc "cdecl" (x, y: f32) -> f32 {…}

distance_float2 ¶

distance_float2 :: proc "cdecl" (a, b: float2) -> f32 {…}

distance_float3 ¶

distance_float3 :: proc "cdecl" (a, b: float3) -> f32 {…}

distance_float4 ¶

distance_float4 :: proc "cdecl" (a, b: float4) -> f32 {…}

dot_double ¶

dot_double :: proc "cdecl" (x, y: f64) -> f64 {…}

dot_double2 ¶

dot_double2 :: proc "cdecl" (a, b: double2) -> f64 {…}

dot_double3 ¶

dot_double3 :: proc "cdecl" (a, b: double3) -> f64 {…}

dot_double4 ¶

dot_double4 :: proc "cdecl" (a, b: double4) -> f64 {…}

dot_float ¶

dot_float :: proc "cdecl" (x, y: f32) -> f32 {…}

dot_float2 ¶

dot_float2 :: proc "cdecl" (a, b: float2) -> f32 {…}

dot_float3 ¶

dot_float3 :: proc "cdecl" (a, b: float3) -> f32 {…}

dot_float4 ¶

dot_float4 :: proc "cdecl" (a, b: float4) -> f32 {…}

dot_int ¶

dot_int :: proc "cdecl" (x, y: i32) -> i32 {…}

dot_int2 ¶

dot_int2 :: proc "cdecl" (a, b: int2) -> i32 {…}

dot_int3 ¶

dot_int3 :: proc "cdecl" (a, b: int3) -> i32 {…}

dot_int4 ¶

dot_int4 :: proc "cdecl" (a, b: int4) -> i32 {…}

dot_uint ¶

dot_uint :: proc "cdecl" (x, y: u32) -> u32 {…}

dot_uint2 ¶

dot_uint2 :: proc "cdecl" (a, b: uint2) -> u32 {…}

dot_uint3 ¶

dot_uint3 :: proc "cdecl" (a, b: uint3) -> u32 {…}

dot_uint4 ¶

dot_uint4 :: proc "cdecl" (a, b: uint4) -> u32 {…}

equal_double ¶

equal_double :: proc "cdecl" (a, b: f64) -> bool {…}

equal_double2 ¶

equal_double2 :: proc "cdecl" (a, b: double2) -> bool2 {…}

equal_double3 ¶

equal_double3 :: proc "cdecl" (a, b: double3) -> bool3 {…}

equal_double4 ¶

equal_double4 :: proc "cdecl" (a, b: double4) -> bool4 {…}

equal_float ¶

equal_float :: proc "cdecl" (a, b: f32) -> bool {…}

equal_float2 ¶

equal_float2 :: proc "cdecl" (a, b: float2) -> bool2 {…}

equal_float3 ¶

equal_float3 :: proc "cdecl" (a, b: float3) -> bool3 {…}

equal_float4 ¶

equal_float4 :: proc "cdecl" (a, b: float4) -> bool4 {…}

equal_int ¶

equal_int :: proc "cdecl" (a, b: i32) -> bool {…}

equal_int2 ¶

equal_int2 :: proc "cdecl" (a, b: int2) -> bool2 {…}

equal_int3 ¶

equal_int3 :: proc "cdecl" (a, b: int3) -> bool3 {…}

equal_int4 ¶

equal_int4 :: proc "cdecl" (a, b: int4) -> bool4 {…}

equal_uint ¶

equal_uint :: proc "cdecl" (a, b: u32) -> bool {…}

equal_uint2 ¶

equal_uint2 :: proc "cdecl" (a, b: uint2) -> bool2 {…}

equal_uint3 ¶

equal_uint3 :: proc "cdecl" (a, b: uint3) -> bool3 {…}

equal_uint4 ¶

equal_uint4 :: proc "cdecl" (a, b: uint4) -> bool4 {…}

exp2_double ¶

exp2_double :: proc "cdecl" (degrees: f64) -> f64 {…}

exp2_double2 ¶

exp2_double2 :: proc "cdecl" (x: double2) -> double2 {…}

exp2_double3 ¶

exp2_double3 :: proc "cdecl" (x: double3) -> double3 {…}

exp2_double4 ¶

exp2_double4 :: proc "cdecl" (x: double4) -> double4 {…}

exp2_float ¶

exp2_float :: proc "cdecl" (degrees: f32) -> f32 {…}

exp2_float2 ¶

exp2_float2 :: proc "cdecl" (x: float2) -> float2 {…}

exp2_float3 ¶

exp2_float3 :: proc "cdecl" (x: float3) -> float3 {…}

exp2_float4 ¶

exp2_float4 :: proc "cdecl" (x: float4) -> float4 {…}

exp_double ¶

exp_double :: proc "cdecl" (degrees: f64) -> f64 {…}

exp_double2 ¶

exp_double2 :: proc "cdecl" (x: double2) -> double2 {…}

exp_double3 ¶

exp_double3 :: proc "cdecl" (x: double3) -> double3 {…}

exp_double4 ¶

exp_double4 :: proc "cdecl" (x: double4) -> double4 {…}

exp_float ¶

exp_float :: proc "cdecl" (degrees: f32) -> f32 {…}

exp_float2 ¶

exp_float2 :: proc "cdecl" (x: float2) -> float2 {…}

exp_float3 ¶

exp_float3 :: proc "cdecl" (x: float3) -> float3 {…}

exp_float4 ¶

exp_float4 :: proc "cdecl" (x: float4) -> float4 {…}

faceforward_double ¶

faceforward_double :: proc "cdecl" (x, y, z: f64) -> f64 {…}

faceforward_double2 ¶

faceforward_double2 :: proc "cdecl" (x, y, z: double2) -> double2 {…}

faceforward_double3 ¶

faceforward_double3 :: proc "cdecl" (x, y, z: double3) -> double3 {…}

faceforward_double4 ¶

faceforward_double4 :: proc "cdecl" (x, y, z: double4) -> double4 {…}

faceforward_float ¶

faceforward_float :: proc "cdecl" (x, y, z: f32) -> f32 {…}

faceforward_float2 ¶

faceforward_float2 :: proc "cdecl" (x, y, z: float2) -> float2 {…}

faceforward_float3 ¶

faceforward_float3 :: proc "cdecl" (x, y, z: float3) -> float3 {…}

faceforward_float4 ¶

faceforward_float4 :: proc "cdecl" (x, y, z: float4) -> float4 {…}

floor_double ¶

floor_double :: proc "cdecl" (degrees: f64) -> f64 {…}

floor_double2 ¶

floor_double2 :: proc "cdecl" (x: double2) -> double2 {…}

floor_double3 ¶

floor_double3 :: proc "cdecl" (x: double3) -> double3 {…}

floor_double4 ¶

floor_double4 :: proc "cdecl" (x: double4) -> double4 {…}

floor_float ¶

floor_float :: proc "cdecl" (degrees: f32) -> f32 {…}

floor_float2 ¶

floor_float2 :: proc "cdecl" (x: float2) -> float2 {…}

floor_float3 ¶

floor_float3 :: proc "cdecl" (x: float3) -> float3 {…}

floor_float4 ¶

floor_float4 :: proc "cdecl" (x: float4) -> float4 {…}

fmod_double ¶

fmod_double :: proc "cdecl" (x, y: f64) -> f64 {…}

fmod_double2 ¶

fmod_double2 :: proc "cdecl" (y, x: double2) -> double2 {…}

fmod_double3 ¶

fmod_double3 :: proc "cdecl" (y, x: double3) -> double3 {…}

fmod_double4 ¶

fmod_double4 :: proc "cdecl" (y, x: double4) -> double4 {…}

fmod_float ¶

fmod_float :: proc "cdecl" (x, y: f32) -> f32 {…}

fmod_float2 ¶

fmod_float2 :: proc "cdecl" (y, x: float2) -> float2 {…}

fmod_float3 ¶

fmod_float3 :: proc "cdecl" (y, x: float3) -> float3 {…}

fmod_float4 ¶

fmod_float4 :: proc "cdecl" (y, x: float4) -> float4 {…}

frac_double ¶

frac_double :: proc "cdecl" (degrees: f64) -> f64 {…}

frac_double2 ¶

frac_double2 :: proc "cdecl" (x: double2) -> double2 {…}

frac_double3 ¶

frac_double3 :: proc "cdecl" (x: double3) -> double3 {…}

frac_double4 ¶

frac_double4 :: proc "cdecl" (x: double4) -> double4 {…}

frac_float ¶

frac_float :: proc "cdecl" (degrees: f32) -> f32 {…}

frac_float2 ¶

frac_float2 :: proc "cdecl" (x: float2) -> float2 {…}

frac_float3 ¶

frac_float3 :: proc "cdecl" (x: float3) -> float3 {…}

frac_float4 ¶

frac_float4 :: proc "cdecl" (x: float4) -> float4 {…}

greaterThanEqual_double ¶

greaterThanEqual_double :: proc "cdecl" (a, b: f64) -> bool {…}

greaterThanEqual_double2 ¶

greaterThanEqual_double2 :: proc "cdecl" (a, b: double2) -> bool2 {…}

greaterThanEqual_double3 ¶

greaterThanEqual_double3 :: proc "cdecl" (a, b: double3) -> bool3 {…}

greaterThanEqual_double4 ¶

greaterThanEqual_double4 :: proc "cdecl" (a, b: double4) -> bool4 {…}

greaterThanEqual_float ¶

greaterThanEqual_float :: proc "cdecl" (a, b: f32) -> bool {…}

greaterThanEqual_float2 ¶

greaterThanEqual_float2 :: proc "cdecl" (a, b: float2) -> bool2 {…}

greaterThanEqual_float3 ¶

greaterThanEqual_float3 :: proc "cdecl" (a, b: float3) -> bool3 {…}

greaterThanEqual_float4 ¶

greaterThanEqual_float4 :: proc "cdecl" (a, b: float4) -> bool4 {…}

greaterThanEqual_int ¶

greaterThanEqual_int :: proc "cdecl" (a, b: i32) -> bool {…}

greaterThanEqual_int2 ¶

greaterThanEqual_int2 :: proc "cdecl" (a, b: int2) -> bool2 {…}

greaterThanEqual_int3 ¶

greaterThanEqual_int3 :: proc "cdecl" (a, b: int3) -> bool3 {…}

greaterThanEqual_int4 ¶

greaterThanEqual_int4 :: proc "cdecl" (a, b: int4) -> bool4 {…}

greaterThanEqual_uint ¶

greaterThanEqual_uint :: proc "cdecl" (a, b: u32) -> bool {…}

greaterThanEqual_uint2 ¶

greaterThanEqual_uint2 :: proc "cdecl" (a, b: uint2) -> bool2 {…}

greaterThanEqual_uint3 ¶

greaterThanEqual_uint3 :: proc "cdecl" (a, b: uint3) -> bool3 {…}

greaterThanEqual_uint4 ¶

greaterThanEqual_uint4 :: proc "cdecl" (a, b: uint4) -> bool4 {…}

greaterThan_double ¶

greaterThan_double :: proc "cdecl" (a, b: f64) -> bool {…}

greaterThan_double2 ¶

greaterThan_double2 :: proc "cdecl" (a, b: double2) -> bool2 {…}

greaterThan_double3 ¶

greaterThan_double3 :: proc "cdecl" (a, b: double3) -> bool3 {…}

greaterThan_double4 ¶

greaterThan_double4 :: proc "cdecl" (a, b: double4) -> bool4 {…}

greaterThan_float ¶

greaterThan_float :: proc "cdecl" (a, b: f32) -> bool {…}

greaterThan_float2 ¶

greaterThan_float2 :: proc "cdecl" (a, b: float2) -> bool2 {…}

greaterThan_float3 ¶

greaterThan_float3 :: proc "cdecl" (a, b: float3) -> bool3 {…}

greaterThan_float4 ¶

greaterThan_float4 :: proc "cdecl" (a, b: float4) -> bool4 {…}

greaterThan_int ¶

greaterThan_int :: proc "cdecl" (a, b: i32) -> bool {…}

greaterThan_int2 ¶

greaterThan_int2 :: proc "cdecl" (a, b: int2) -> bool2 {…}

greaterThan_int3 ¶

greaterThan_int3 :: proc "cdecl" (a, b: int3) -> bool3 {…}

greaterThan_int4 ¶

greaterThan_int4 :: proc "cdecl" (a, b: int4) -> bool4 {…}

greaterThan_uint ¶

greaterThan_uint :: proc "cdecl" (a, b: u32) -> bool {…}

greaterThan_uint2 ¶

greaterThan_uint2 :: proc "cdecl" (a, b: uint2) -> bool2 {…}

greaterThan_uint3 ¶

greaterThan_uint3 :: proc "cdecl" (a, b: uint3) -> bool3 {…}

greaterThan_uint4 ¶

greaterThan_uint4 :: proc "cdecl" (a, b: uint4) -> bool4 {…}

inverse_double1x1 ¶

inverse_double1x1 :: proc "cdecl" (m: double1x1) -> double1x1 {…}

inverse_double2x2 ¶

inverse_double2x2 :: proc "cdecl" (m: double2x2) -> double2x2 {…}

inverse_double3x3 ¶

inverse_double3x3 :: proc "cdecl" (m: double3x3) -> double3x3 {…}

inverse_double4x4 ¶

inverse_double4x4 :: proc "cdecl" (m: double4x4) -> double4x4 {…}

inverse_float1x1 ¶

inverse_float1x1 :: proc "cdecl" (m: float1x1) -> float1x1 {…}

inverse_float2x2 ¶

inverse_float2x2 :: proc "cdecl" (m: float2x2) -> float2x2 {…}

inverse_float3x3 ¶

inverse_float3x3 :: proc "cdecl" (m: float3x3) -> float3x3 {…}

inverse_float4x4 ¶

inverse_float4x4 :: proc "cdecl" (m: float4x4) -> float4x4 {…}

isfinite_double ¶

isfinite_double :: proc "cdecl" (x: f64) -> bool {…}

isfinite_double2 ¶

isfinite_double2 :: proc "cdecl" (x: double2) -> bool2 {…}

isfinite_double3 ¶

isfinite_double3 :: proc "cdecl" (x: double3) -> bool3 {…}

isfinite_double4 ¶

isfinite_double4 :: proc "cdecl" (x: double4) -> bool4 {…}

isfinite_float ¶

isfinite_float :: proc "cdecl" (x: f32) -> bool {…}

isfinite_float2 ¶

isfinite_float2 :: proc "cdecl" (x: float2) -> bool2 {…}

isfinite_float3 ¶

isfinite_float3 :: proc "cdecl" (x: float3) -> bool3 {…}

isfinite_float4 ¶

isfinite_float4 :: proc "cdecl" (x: float4) -> bool4 {…}

isinf_double ¶

isinf_double :: proc "cdecl" (x: f64) -> bool {…}

isinf_double2 ¶

isinf_double2 :: proc "cdecl" (x: double2) -> bool2 {…}

isinf_double3 ¶

isinf_double3 :: proc "cdecl" (x: double3) -> bool3 {…}

isinf_double4 ¶

isinf_double4 :: proc "cdecl" (x: double4) -> bool4 {…}

isinf_float ¶

isinf_float :: proc "cdecl" (x: f32) -> bool {…}

isinf_float2 ¶

isinf_float2 :: proc "cdecl" (x: float2) -> bool2 {…}

isinf_float3 ¶

isinf_float3 :: proc "cdecl" (x: float3) -> bool3 {…}

isinf_float4 ¶

isinf_float4 :: proc "cdecl" (x: float4) -> bool4 {…}

isnan_double ¶

isnan_double :: proc "cdecl" (x: f64) -> bool {…}

isnan_double2 ¶

isnan_double2 :: proc "cdecl" (x: double2) -> bool2 {…}

isnan_double3 ¶

isnan_double3 :: proc "cdecl" (x: double3) -> bool3 {…}

isnan_double4 ¶

isnan_double4 :: proc "cdecl" (x: double4) -> bool4 {…}

isnan_float ¶

isnan_float :: proc "cdecl" (x: f32) -> bool {…}

isnan_float2 ¶

isnan_float2 :: proc "cdecl" (x: float2) -> bool2 {…}

isnan_float3 ¶

isnan_float3 :: proc "cdecl" (x: float3) -> bool3 {…}

isnan_float4 ¶

isnan_float4 :: proc "cdecl" (x: float4) -> bool4 {…}

length_double ¶

length_double :: proc "cdecl" (degrees: f64) -> f64 {…}

length_double2 ¶

length_double2 :: proc "cdecl" (x: double2) -> f64 {…}

length_double3 ¶

length_double3 :: proc "cdecl" (x: double3) -> f64 {…}

length_double4 ¶

length_double4 :: proc "cdecl" (x: double4) -> f64 {…}

length_float ¶

length_float :: proc "cdecl" (degrees: f32) -> f32 {…}

length_float2 ¶

length_float2 :: proc "cdecl" (x: float2) -> f32 {…}

length_float3 ¶

length_float3 :: proc "cdecl" (x: float3) -> f32 {…}

length_float4 ¶

length_float4 :: proc "cdecl" (x: float4) -> f32 {…}

lerp_double ¶

lerp_double :: proc "cdecl" (x, y, z: f64) -> f64 {…}

lerp_double2 ¶

lerp_double2 :: proc "cdecl" (x, y, z: double2) -> double2 {…}

lerp_double3 ¶

lerp_double3 :: proc "cdecl" (x, y, z: double3) -> double3 {…}

lerp_double4 ¶

lerp_double4 :: proc "cdecl" (x, y, z: double4) -> double4 {…}

lerp_float ¶

lerp_float :: proc "cdecl" (x, y, z: f32) -> f32 {…}

lerp_float2 ¶

lerp_float2 :: proc "cdecl" (x, y, z: float2) -> float2 {…}

lerp_float3 ¶

lerp_float3 :: proc "cdecl" (x, y, z: float3) -> float3 {…}

lerp_float4 ¶

lerp_float4 :: proc "cdecl" (x, y, z: float4) -> float4 {…}

lessThanEqual_double ¶

lessThanEqual_double :: proc "cdecl" (a, b: f64) -> bool {…}

lessThanEqual_double2 ¶

lessThanEqual_double2 :: proc "cdecl" (a, b: double2) -> bool2 {…}

lessThanEqual_double3 ¶

lessThanEqual_double3 :: proc "cdecl" (a, b: double3) -> bool3 {…}

lessThanEqual_double4 ¶

lessThanEqual_double4 :: proc "cdecl" (a, b: double4) -> bool4 {…}

lessThanEqual_float ¶

lessThanEqual_float :: proc "cdecl" (a, b: f32) -> bool {…}

lessThanEqual_float2 ¶

lessThanEqual_float2 :: proc "cdecl" (a, b: float2) -> bool2 {…}

lessThanEqual_float3 ¶

lessThanEqual_float3 :: proc "cdecl" (a, b: float3) -> bool3 {…}

lessThanEqual_float4 ¶

lessThanEqual_float4 :: proc "cdecl" (a, b: float4) -> bool4 {…}

lessThanEqual_int ¶

lessThanEqual_int :: proc "cdecl" (a, b: i32) -> bool {…}

lessThanEqual_int2 ¶

lessThanEqual_int2 :: proc "cdecl" (a, b: int2) -> bool2 {…}

lessThanEqual_int3 ¶

lessThanEqual_int3 :: proc "cdecl" (a, b: int3) -> bool3 {…}

lessThanEqual_int4 ¶

lessThanEqual_int4 :: proc "cdecl" (a, b: int4) -> bool4 {…}

lessThanEqual_uint ¶

lessThanEqual_uint :: proc "cdecl" (a, b: u32) -> bool {…}

lessThanEqual_uint2 ¶

lessThanEqual_uint2 :: proc "cdecl" (a, b: uint2) -> bool2 {…}

lessThanEqual_uint3 ¶

lessThanEqual_uint3 :: proc "cdecl" (a, b: uint3) -> bool3 {…}

lessThanEqual_uint4 ¶

lessThanEqual_uint4 :: proc "cdecl" (a, b: uint4) -> bool4 {…}

lessThan_double ¶

lessThan_double :: proc "cdecl" (a, b: f64) -> bool {…}

lessThan_double2 ¶

lessThan_double2 :: proc "cdecl" (a, b: double2) -> bool2 {…}

lessThan_double3 ¶

lessThan_double3 :: proc "cdecl" (a, b: double3) -> bool3 {…}

lessThan_double4 ¶

lessThan_double4 :: proc "cdecl" (a, b: double4) -> bool4 {…}

lessThan_float ¶

lessThan_float :: proc "cdecl" (a, b: f32) -> bool {…}

lessThan_float2 ¶

lessThan_float2 :: proc "cdecl" (a, b: float2) -> bool2 {…}

lessThan_float3 ¶

lessThan_float3 :: proc "cdecl" (a, b: float3) -> bool3 {…}

lessThan_float4 ¶

lessThan_float4 :: proc "cdecl" (a, b: float4) -> bool4 {…}

lessThan_int ¶

lessThan_int :: proc "cdecl" (a, b: i32) -> bool {…}

lessThan_int2 ¶

lessThan_int2 :: proc "cdecl" (a, b: int2) -> bool2 {…}

lessThan_int3 ¶

lessThan_int3 :: proc "cdecl" (a, b: int3) -> bool3 {…}

lessThan_int4 ¶

lessThan_int4 :: proc "cdecl" (a, b: int4) -> bool4 {…}

lessThan_uint ¶

lessThan_uint :: proc "cdecl" (a, b: u32) -> bool {…}

lessThan_uint2 ¶

lessThan_uint2 :: proc "cdecl" (a, b: uint2) -> bool2 {…}

lessThan_uint3 ¶

lessThan_uint3 :: proc "cdecl" (a, b: uint3) -> bool3 {…}

lessThan_uint4 ¶

lessThan_uint4 :: proc "cdecl" (a, b: uint4) -> bool4 {…}

log10_double ¶

log10_double :: proc "cdecl" (degrees: f64) -> f64 {…}

log10_double2 ¶

log10_double2 :: proc "cdecl" (x: double2) -> double2 {…}

log10_double3 ¶

log10_double3 :: proc "cdecl" (x: double3) -> double3 {…}

log10_double4 ¶

log10_double4 :: proc "cdecl" (x: double4) -> double4 {…}

log10_float ¶

log10_float :: proc "cdecl" (degrees: f32) -> f32 {…}

log10_float2 ¶

log10_float2 :: proc "cdecl" (x: float2) -> float2 {…}

log10_float3 ¶

log10_float3 :: proc "cdecl" (x: float3) -> float3 {…}

log10_float4 ¶

log10_float4 :: proc "cdecl" (x: float4) -> float4 {…}

log2_double ¶

log2_double :: proc "cdecl" (degrees: f64) -> f64 {…}

log2_double2 ¶

log2_double2 :: proc "cdecl" (x: double2) -> double2 {…}

log2_double3 ¶

log2_double3 :: proc "cdecl" (x: double3) -> double3 {…}

log2_double4 ¶

log2_double4 :: proc "cdecl" (x: double4) -> double4 {…}

log2_float ¶

log2_float :: proc "cdecl" (degrees: f32) -> f32 {…}

log2_float2 ¶

log2_float2 :: proc "cdecl" (x: float2) -> float2 {…}

log2_float3 ¶

log2_float3 :: proc "cdecl" (x: float3) -> float3 {…}

log2_float4 ¶

log2_float4 :: proc "cdecl" (x: float4) -> float4 {…}

log_double ¶

log_double :: proc "cdecl" (degrees: f64) -> f64 {…}

log_double2 ¶

log_double2 :: proc "cdecl" (x: double2) -> double2 {…}

log_double3 ¶

log_double3 :: proc "cdecl" (x: double3) -> double3 {…}

log_double4 ¶

log_double4 :: proc "cdecl" (x: double4) -> double4 {…}

log_float ¶

log_float :: proc "cdecl" (degrees: f32) -> f32 {…}

log_float2 ¶

log_float2 :: proc "cdecl" (x: float2) -> float2 {…}

log_float3 ¶

log_float3 :: proc "cdecl" (x: float3) -> float3 {…}

log_float4 ¶

log_float4 :: proc "cdecl" (x: float4) -> float4 {…}

max_double ¶

max_double :: proc "cdecl" (x, y: f64) -> f64 {…}

max_double2 ¶

max_double2 :: proc "cdecl" (y, x: double2) -> double2 {…}

max_double3 ¶

max_double3 :: proc "cdecl" (y, x: double3) -> double3 {…}

max_double4 ¶

max_double4 :: proc "cdecl" (y, x: double4) -> double4 {…}

max_float ¶

max_float :: proc "cdecl" (x, y: f32) -> f32 {…}

max_float2 ¶

max_float2 :: proc "cdecl" (y, x: float2) -> float2 {…}

max_float3 ¶

max_float3 :: proc "cdecl" (y, x: float3) -> float3 {…}

max_float4 ¶

max_float4 :: proc "cdecl" (y, x: float4) -> float4 {…}

max_int ¶

max_int :: proc "cdecl" (x, y: i32) -> i32 {…}

max_int2 ¶

max_int2 :: proc "cdecl" (x, y: int2) -> int2 {…}

max_int3 ¶

max_int3 :: proc "cdecl" (x, y: int3) -> int3 {…}

max_int4 ¶

max_int4 :: proc "cdecl" (x, y: int4) -> int4 {…}

max_uint ¶

max_uint :: proc "cdecl" (x, y: u32) -> u32 {…}

max_uint2 ¶

max_uint2 :: proc "cdecl" (x, y: uint2) -> uint2 {…}

max_uint3 ¶

max_uint3 :: proc "cdecl" (x, y: uint3) -> uint3 {…}

max_uint4 ¶

max_uint4 :: proc "cdecl" (x, y: uint4) -> uint4 {…}

min_double ¶

min_double :: proc "cdecl" (x, y: f64) -> f64 {…}

min_double2 ¶

min_double2 :: proc "cdecl" (y, x: double2) -> double2 {…}

min_double3 ¶

min_double3 :: proc "cdecl" (y, x: double3) -> double3 {…}

min_double4 ¶

min_double4 :: proc "cdecl" (y, x: double4) -> double4 {…}

min_float ¶

min_float :: proc "cdecl" (x, y: f32) -> f32 {…}

min_float2 ¶

min_float2 :: proc "cdecl" (y, x: float2) -> float2 {…}

min_float3 ¶

min_float3 :: proc "cdecl" (y, x: float3) -> float3 {…}

min_float4 ¶

min_float4 :: proc "cdecl" (y, x: float4) -> float4 {…}

min_int ¶

min_int :: proc "cdecl" (x, y: i32) -> i32 {…}

min_int2 ¶

min_int2 :: proc "cdecl" (x, y: int2) -> int2 {…}

min_int3 ¶

min_int3 :: proc "cdecl" (x, y: int3) -> int3 {…}

min_int4 ¶

min_int4 :: proc "cdecl" (x, y: int4) -> int4 {…}

min_uint ¶

min_uint :: proc "cdecl" (x, y: u32) -> u32 {…}

min_uint2 ¶

min_uint2 :: proc "cdecl" (x, y: uint2) -> uint2 {…}

min_uint3 ¶

min_uint3 :: proc "cdecl" (x, y: uint3) -> uint3 {…}

min_uint4 ¶

min_uint4 :: proc "cdecl" (x, y: uint4) -> uint4 {…}

normalize_double ¶

normalize_double :: proc "cdecl" (degrees: f64) -> f64 {…}

normalize_double2 ¶

normalize_double2 :: proc "cdecl" (x: double2) -> double2 {…}

normalize_double3 ¶

normalize_double3 :: proc "cdecl" (x: double3) -> double3 {…}

normalize_double4 ¶

normalize_double4 :: proc "cdecl" (x: double4) -> double4 {…}

normalize_float ¶

normalize_float :: proc "cdecl" (degrees: f32) -> f32 {…}

normalize_float2 ¶

normalize_float2 :: proc "cdecl" (x: float2) -> float2 {…}

normalize_float3 ¶

normalize_float3 :: proc "cdecl" (x: float3) -> float3 {…}

normalize_float4 ¶

normalize_float4 :: proc "cdecl" (x: float4) -> float4 {…}

notEqual_double ¶

notEqual_double :: proc "cdecl" (a, b: f64) -> bool {…}

notEqual_double2 ¶

notEqual_double2 :: proc "cdecl" (a, b: double2) -> bool2 {…}

notEqual_double3 ¶

notEqual_double3 :: proc "cdecl" (a, b: double3) -> bool3 {…}

notEqual_double4 ¶

notEqual_double4 :: proc "cdecl" (a, b: double4) -> bool4 {…}

notEqual_float ¶

notEqual_float :: proc "cdecl" (a, b: f32) -> bool {…}

notEqual_float2 ¶

notEqual_float2 :: proc "cdecl" (a, b: float2) -> bool2 {…}

notEqual_float3 ¶

notEqual_float3 :: proc "cdecl" (a, b: float3) -> bool3 {…}

notEqual_float4 ¶

notEqual_float4 :: proc "cdecl" (a, b: float4) -> bool4 {…}

notEqual_int ¶

notEqual_int :: proc "cdecl" (a, b: i32) -> bool {…}

notEqual_int2 ¶

notEqual_int2 :: proc "cdecl" (a, b: int2) -> bool2 {…}

notEqual_int3 ¶

notEqual_int3 :: proc "cdecl" (a, b: int3) -> bool3 {…}

notEqual_int4 ¶

notEqual_int4 :: proc "cdecl" (a, b: int4) -> bool4 {…}

notEqual_uint ¶

notEqual_uint :: proc "cdecl" (a, b: u32) -> bool {…}

notEqual_uint2 ¶

notEqual_uint2 :: proc "cdecl" (a, b: uint2) -> bool2 {…}

notEqual_uint3 ¶

notEqual_uint3 :: proc "cdecl" (a, b: uint3) -> bool3 {…}

notEqual_uint4 ¶

notEqual_uint4 :: proc "cdecl" (a, b: uint4) -> bool4 {…}

not_bool ¶

not_bool :: proc "cdecl" (v: bool) -> bool {…}

not_bool2 ¶

not_bool2 :: proc "cdecl" (v: bool2) -> bool2 {…}

not_bool3 ¶

not_bool3 :: proc "cdecl" (v: bool3) -> bool3 {…}

not_bool4 ¶

not_bool4 :: proc "cdecl" (v: bool4) -> bool4 {…}

pow_double ¶

pow_double :: proc "cdecl" (x, y: f64) -> f64 {…}

pow_double2 ¶

pow_double2 :: proc "cdecl" (y, x: double2) -> double2 {…}

pow_double3 ¶

pow_double3 :: proc "cdecl" (y, x: double3) -> double3 {…}

pow_double4 ¶

pow_double4 :: proc "cdecl" (y, x: double4) -> double4 {…}

pow_float ¶

pow_float :: proc "cdecl" (x, y: f32) -> f32 {…}

pow_float2 ¶

pow_float2 :: proc "cdecl" (y, x: float2) -> float2 {…}

pow_float3 ¶

pow_float3 :: proc "cdecl" (y, x: float3) -> float3 {…}

pow_float4 ¶

pow_float4 :: proc "cdecl" (y, x: float4) -> float4 {…}

radians_double ¶

radians_double :: proc "cdecl" (degrees: f64) -> f64 {…}

radians_double2 ¶

radians_double2 :: proc "cdecl" (x: double2) -> double2 {…}

radians_double3 ¶

radians_double3 :: proc "cdecl" (x: double3) -> double3 {…}

radians_double4 ¶

radians_double4 :: proc "cdecl" (x: double4) -> double4 {…}

radians_float ¶

radians_float :: proc "cdecl" (degrees: f32) -> f32 {…}

radians_float2 ¶

radians_float2 :: proc "cdecl" (x: float2) -> float2 {…}

radians_float3 ¶

radians_float3 :: proc "cdecl" (x: float3) -> float3 {…}

radians_float4 ¶

radians_float4 :: proc "cdecl" (x: float4) -> float4 {…}

rcp_double ¶

rcp_double :: proc "cdecl" (degrees: f64) -> f64 {…}

rcp_double2 ¶

rcp_double2 :: proc "cdecl" (x: double2) -> double2 {…}

rcp_double3 ¶

rcp_double3 :: proc "cdecl" (x: double3) -> double3 {…}

rcp_double4 ¶

rcp_double4 :: proc "cdecl" (x: double4) -> double4 {…}

rcp_float ¶

rcp_float :: proc "cdecl" (degrees: f32) -> f32 {…}

rcp_float2 ¶

rcp_float2 :: proc "cdecl" (x: float2) -> float2 {…}

rcp_float3 ¶

rcp_float3 :: proc "cdecl" (x: float3) -> float3 {…}

rcp_float4 ¶

rcp_float4 :: proc "cdecl" (x: float4) -> float4 {…}

reflect_double ¶

reflect_double :: proc "cdecl" (x, y: f64) -> f64 {…}

reflect_double2 ¶

reflect_double2 :: proc "cdecl" (y, x: double2) -> double2 {…}

reflect_double3 ¶

reflect_double3 :: proc "cdecl" (y, x: double3) -> double3 {…}

reflect_double4 ¶

reflect_double4 :: proc "cdecl" (y, x: double4) -> double4 {…}

reflect_float ¶

reflect_float :: proc "cdecl" (x, y: f32) -> f32 {…}

reflect_float2 ¶

reflect_float2 :: proc "cdecl" (y, x: float2) -> float2 {…}

reflect_float3 ¶

reflect_float3 :: proc "cdecl" (y, x: float3) -> float3 {…}

reflect_float4 ¶

reflect_float4 :: proc "cdecl" (y, x: float4) -> float4 {…}

refract_double ¶

refract_double :: proc "cdecl" (x, y, z: f64) -> f64 {…}

refract_double2 ¶

refract_double2 :: proc "cdecl" (x, y, z: double2) -> double2 {…}

refract_double3 ¶

refract_double3 :: proc "cdecl" (x, y, z: double3) -> double3 {…}

refract_double4 ¶

refract_double4 :: proc "cdecl" (x, y, z: double4) -> double4 {…}

refract_float ¶

refract_float :: proc "cdecl" (x, y, z: f32) -> f32 {…}

refract_float2 ¶

refract_float2 :: proc "cdecl" (x, y, z: float2) -> float2 {…}

refract_float3 ¶

refract_float3 :: proc "cdecl" (x, y, z: float3) -> float3 {…}

refract_float4 ¶

refract_float4 :: proc "cdecl" (x, y, z: float4) -> float4 {…}

round_double ¶

round_double :: proc "cdecl" (degrees: f64) -> f64 {…}

round_double2 ¶

round_double2 :: proc "cdecl" (x: double2) -> double2 {…}

round_double3 ¶

round_double3 :: proc "cdecl" (x: double3) -> double3 {…}

round_double4 ¶

round_double4 :: proc "cdecl" (x: double4) -> double4 {…}

round_float ¶

round_float :: proc "cdecl" (degrees: f32) -> f32 {…}

round_float2 ¶

round_float2 :: proc "cdecl" (x: float2) -> float2 {…}

round_float3 ¶

round_float3 :: proc "cdecl" (x: float3) -> float3 {…}

round_float4 ¶

round_float4 :: proc "cdecl" (x: float4) -> float4 {…}

rsqrt_double ¶

rsqrt_double :: proc "cdecl" (degrees: f64) -> f64 {…}

rsqrt_double2 ¶

rsqrt_double2 :: proc "cdecl" (x: double2) -> double2 {…}

rsqrt_double3 ¶

rsqrt_double3 :: proc "cdecl" (x: double3) -> double3 {…}

rsqrt_double4 ¶

rsqrt_double4 :: proc "cdecl" (x: double4) -> double4 {…}

rsqrt_float ¶

rsqrt_float :: proc "cdecl" (degrees: f32) -> f32 {…}

rsqrt_float2 ¶

rsqrt_float2 :: proc "cdecl" (x: float2) -> float2 {…}

rsqrt_float3 ¶

rsqrt_float3 :: proc "cdecl" (x: float3) -> float3 {…}

rsqrt_float4 ¶

rsqrt_float4 :: proc "cdecl" (x: float4) -> float4 {…}

saturate_double ¶

saturate_double :: proc "cdecl" (degrees: f64) -> f64 {…}

saturate_double2 ¶

saturate_double2 :: proc "cdecl" (x: double2) -> double2 {…}

saturate_double3 ¶

saturate_double3 :: proc "cdecl" (x: double3) -> double3 {…}

saturate_double4 ¶

saturate_double4 :: proc "cdecl" (x: double4) -> double4 {…}

saturate_float ¶

saturate_float :: proc "cdecl" (degrees: f32) -> f32 {…}

saturate_float2 ¶

saturate_float2 :: proc "cdecl" (x: float2) -> float2 {…}

saturate_float3 ¶

saturate_float3 :: proc "cdecl" (x: float3) -> float3 {…}

saturate_float4 ¶

saturate_float4 :: proc "cdecl" (x: float4) -> float4 {…}

saturate_int ¶

saturate_int :: proc "cdecl" (c: i32) -> i32 {…}

saturate_int2 ¶

saturate_int2 :: proc "cdecl" (x: int2) -> int2 {…}

saturate_int3 ¶

saturate_int3 :: proc "cdecl" (x: int3) -> int3 {…}

saturate_int4 ¶

saturate_int4 :: proc "cdecl" (x: int4) -> int4 {…}

saturate_uint ¶

saturate_uint :: proc "cdecl" (x: u32) -> u32 {…}

saturate_uint2 ¶

saturate_uint2 :: proc "cdecl" (x: uint2) -> uint2 {…}

saturate_uint3 ¶

saturate_uint3 :: proc "cdecl" (x: uint3) -> uint3 {…}

saturate_uint4 ¶

saturate_uint4 :: proc "cdecl" (x: uint4) -> uint4 {…}

scalarTripleProduct_double3 ¶

scalarTripleProduct_double3 :: proc "cdecl" (a, b, c: double3) -> f64 {…}

scalarTripleProduct_float3 ¶

scalarTripleProduct_float3 :: proc "cdecl" (a, b, c: float3) -> f32 {…}

scalarTripleProduct_int3 ¶

scalarTripleProduct_int3 :: proc "cdecl" (a, b, c: int3) -> i32 {…}

sign_double ¶

sign_double :: proc "cdecl" (degrees: f64) -> f64 {…}

sign_double2 ¶

sign_double2 :: proc "cdecl" (x: double2) -> double2 {…}

sign_double3 ¶

sign_double3 :: proc "cdecl" (x: double3) -> double3 {…}

sign_double4 ¶

sign_double4 :: proc "cdecl" (x: double4) -> double4 {…}

sign_float ¶

sign_float :: proc "cdecl" (degrees: f32) -> f32 {…}

sign_float2 ¶

sign_float2 :: proc "cdecl" (x: float2) -> float2 {…}

sign_float3 ¶

sign_float3 :: proc "cdecl" (x: float3) -> float3 {…}

sign_float4 ¶

sign_float4 :: proc "cdecl" (x: float4) -> float4 {…}

sign_int ¶

sign_int :: proc "cdecl" (c: i32) -> i32 {…}

sign_int2 ¶

sign_int2 :: proc "cdecl" (x: int2) -> int2 {…}

sign_int3 ¶

sign_int3 :: proc "cdecl" (x: int3) -> int3 {…}

sign_int4 ¶

sign_int4 :: proc "cdecl" (x: int4) -> int4 {…}

sign_uint ¶

sign_uint :: proc "cdecl" (x: u32) -> u32 {…}

sign_uint2 ¶

sign_uint2 :: proc "cdecl" (x: uint2) -> uint2 {…}

sign_uint3 ¶

sign_uint3 :: proc "cdecl" (x: uint3) -> uint3 {…}

sign_uint4 ¶

sign_uint4 :: proc "cdecl" (x: uint4) -> uint4 {…}

sin_double ¶

sin_double :: proc "cdecl" (degrees: f64) -> f64 {…}

sin_double2 ¶

sin_double2 :: proc "cdecl" (x: double2) -> double2 {…}

sin_double3 ¶

sin_double3 :: proc "cdecl" (x: double3) -> double3 {…}

sin_double4 ¶

sin_double4 :: proc "cdecl" (x: double4) -> double4 {…}

sin_float ¶

sin_float :: proc "cdecl" (degrees: f32) -> f32 {…}

sin_float2 ¶

sin_float2 :: proc "cdecl" (x: float2) -> float2 {…}

sin_float3 ¶

sin_float3 :: proc "cdecl" (x: float3) -> float3 {…}

sin_float4 ¶

sin_float4 :: proc "cdecl" (x: float4) -> float4 {…}

sinh_double ¶

sinh_double :: proc "cdecl" (degrees: f64) -> f64 {…}

sinh_double2 ¶

sinh_double2 :: proc "cdecl" (x: double2) -> double2 {…}

sinh_double3 ¶

sinh_double3 :: proc "cdecl" (x: double3) -> double3 {…}

sinh_double4 ¶

sinh_double4 :: proc "cdecl" (x: double4) -> double4 {…}

sinh_float ¶

sinh_float :: proc "cdecl" (degrees: f32) -> f32 {…}

sinh_float2 ¶

sinh_float2 :: proc "cdecl" (x: float2) -> float2 {…}

sinh_float3 ¶

sinh_float3 :: proc "cdecl" (x: float3) -> float3 {…}

sinh_float4 ¶

sinh_float4 :: proc "cdecl" (x: float4) -> float4 {…}

smoothstep_double ¶

smoothstep_double :: proc "cdecl" (x, y, z: f64) -> f64 {…}

smoothstep_double2 ¶

smoothstep_double2 :: proc "cdecl" (x, y, z: double2) -> double2 {…}

smoothstep_double3 ¶

smoothstep_double3 :: proc "cdecl" (x, y, z: double3) -> double3 {…}

smoothstep_double4 ¶

smoothstep_double4 :: proc "cdecl" (x, y, z: double4) -> double4 {…}

smoothstep_float ¶

smoothstep_float :: proc "cdecl" (x, y, z: f32) -> f32 {…}

smoothstep_float2 ¶

smoothstep_float2 :: proc "cdecl" (x, y, z: float2) -> float2 {…}

smoothstep_float3 ¶

smoothstep_float3 :: proc "cdecl" (x, y, z: float3) -> float3 {…}

smoothstep_float4 ¶

smoothstep_float4 :: proc "cdecl" (x, y, z: float4) -> float4 {…}

sqrt_double ¶

sqrt_double :: proc "cdecl" (degrees: f64) -> f64 {…}

sqrt_double2 ¶

sqrt_double2 :: proc "cdecl" (x: double2) -> double2 {…}

sqrt_double3 ¶

sqrt_double3 :: proc "cdecl" (x: double3) -> double3 {…}

sqrt_double4 ¶

sqrt_double4 :: proc "cdecl" (x: double4) -> double4 {…}

sqrt_float ¶

sqrt_float :: proc "cdecl" (degrees: f32) -> f32 {…}

sqrt_float2 ¶

sqrt_float2 :: proc "cdecl" (x: float2) -> float2 {…}

sqrt_float3 ¶

sqrt_float3 :: proc "cdecl" (x: float3) -> float3 {…}

sqrt_float4 ¶

sqrt_float4 :: proc "cdecl" (x: float4) -> float4 {…}

step_double ¶

step_double :: proc "cdecl" (x, y: f64) -> f64 {…}

step_double2 ¶

step_double2 :: proc "cdecl" (y, x: double2) -> double2 {…}

step_double3 ¶

step_double3 :: proc "cdecl" (y, x: double3) -> double3 {…}

step_double4 ¶

step_double4 :: proc "cdecl" (y, x: double4) -> double4 {…}

step_float ¶

step_float :: proc "cdecl" (x, y: f32) -> f32 {…}

step_float2 ¶

step_float2 :: proc "cdecl" (y, x: float2) -> float2 {…}

step_float3 ¶

step_float3 :: proc "cdecl" (y, x: float3) -> float3 {…}

step_float4 ¶

step_float4 :: proc "cdecl" (y, x: float4) -> float4 {…}

tan_double ¶

tan_double :: proc "cdecl" (degrees: f64) -> f64 {…}

tan_double2 ¶

tan_double2 :: proc "cdecl" (x: double2) -> double2 {…}

tan_double3 ¶

tan_double3 :: proc "cdecl" (x: double3) -> double3 {…}

tan_double4 ¶

tan_double4 :: proc "cdecl" (x: double4) -> double4 {…}

tan_float ¶

tan_float :: proc "cdecl" (degrees: f32) -> f32 {…}

tan_float2 ¶

tan_float2 :: proc "cdecl" (x: float2) -> float2 {…}

tan_float3 ¶

tan_float3 :: proc "cdecl" (x: float3) -> float3 {…}

tan_float4 ¶

tan_float4 :: proc "cdecl" (x: float4) -> float4 {…}

tanh_double ¶

tanh_double :: proc "cdecl" (degrees: f64) -> f64 {…}

tanh_double2 ¶

tanh_double2 :: proc "cdecl" (x: double2) -> double2 {…}

tanh_double3 ¶

tanh_double3 :: proc "cdecl" (x: double3) -> double3 {…}

tanh_double4 ¶

tanh_double4 :: proc "cdecl" (x: double4) -> double4 {…}

tanh_float ¶

tanh_float :: proc "cdecl" (degrees: f32) -> f32 {…}

tanh_float2 ¶

tanh_float2 :: proc "cdecl" (x: float2) -> float2 {…}

tanh_float3 ¶

tanh_float3 :: proc "cdecl" (x: float3) -> float3 {…}

tanh_float4 ¶

tanh_float4 :: proc "cdecl" (x: float4) -> float4 {…}

transpose ¶

transpose :: builtin.transpose

vectorTripleProduct_double3 ¶

vectorTripleProduct_double3 :: proc "cdecl" (x, y, z: double3) -> double3 {…}

vectorTripleProduct_float3 ¶

vectorTripleProduct_float3 :: proc "cdecl" (x, y, z: float3) -> float3 {…}

vectorTripleProduct_int3 ¶

vectorTripleProduct_int3 :: proc "cdecl" (x, y, z: int3) -> int3 {…}

Procedure Groups

adjugate ¶

adjugate :: proc{
	runtime.matrix1x1_adjugate,
	runtime.matrix2x2_adjugate,
	runtime.matrix3x3_adjugate,
	runtime.matrix4x4_adjugate,
}

isfinite ¶

 

isfinite is the opposite of isinf and returns true if the number is neither positive-infinite or negative-infinite

isinf ¶

 

isinf is the opposite of isfinite and returns true if the number is either positive-infinite or negative-infinite

isnan ¶

 

isnan returns true if the input value is the special case of Not-A-Number

Source Files

Generation Information

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