semicongine/core

Search:
Group by:

Types

HorizontalAlignment = enum
  Left, Center, Right
Mat2 = TMat2[float32]
Mat3 = TMat3[float32]
Mat4 = TMat4[float32]
Mat23 = TMat23[float32]
Mat32 = TMat32[float32]
Mat34 = TMat34[float32]
Mat43 = TMat43[float32]
TMat2[T] = object
  data*: array[4, T]
TMat3[T] = object
  data*: array[9, T]
TMat4[T] = object
  data*: array[16, T]
TMat23[T] = object
  data*: array[6, T]
TMat32[T] = object
  data*: array[6, T]
TMat34[T] = object
  data*: array[12, T]
TMat43[T] = object
  data*: array[12, T]
TVec1[T] = array[1, T]
TVec2[T] = array[2, T]
TVec3[T] = array[3, T]
TVec4[T] = array[4, T]
Vec1f = TVec1[float32]
Vec1i = TVec1[int32]
Vec1u = TVec1[uint32]
Vec2f = TVec2[float32]
Vec2i = TVec2[int32]
Vec2i8 = TVec2[int8]
Vec2u = TVec2[uint32]
Vec3f = TVec3[float32]
Vec3i = TVec3[int32]
Vec3i8 = TVec3[int8]
Vec3u = TVec3[uint32]
Vec4f = TVec4[float32]
Vec4i = TVec4[int32]
Vec4u = TVec4[uint32]
VerticalAlignment = enum
  Top, Center, Bottom

Consts

B = [1.0, 0.0, 0.0, 1.0]
DEFAULT_PACKAGE = "default"
ENGINE_LOGLEVEL = lvlDebug
G = [1.0, 0.0, 0.0, 1.0]
O = [0.0, 0.0, 0.0]
Oi = [0, 0, 0]
Oi8 = [0, 0, 0]
PACKAGETYPE {.strdefine.}: string = "exe"
R = [1.0, 0.0, 0.0, 1.0]
RESOURCEROOT = "resources"
Unit2 = (data: [1.0, 0.0, 0.0, 1.0])
Unit2f = (data: [1.0, 0.0, 0.0, 1.0])
Unit2f32 = (data: [1.0, 0.0, 0.0, 1.0])
Unit2f64 = (data: [1.0, 0.0, 0.0, 1.0])
Unit2i = (data: [1, 0, 0, 1])
Unit2i8 = (data: [1, 0, 0, 1])
Unit2i16 = (data: [1, 0, 0, 1])
Unit2i32 = (data: [1, 0, 0, 1])
Unit2i64 = (data: [1, 0, 0, 1])
Unit3 = (data: [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0])
Unit3f = (data: [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0])
Unit3f32 = (data: [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0])
Unit3f64 = (data: [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0])
Unit3i = (data: [1, 0, 0, 0, 1, 0, 0, 0, 1])
Unit3i8 = (data: [1, 0, 0, 0, 1, 0, 0, 0, 1])
Unit3i16 = (data: [1, 0, 0, 0, 1, 0, 0, 0, 1])
Unit3i32 = (data: [1, 0, 0, 0, 1, 0, 0, 0, 1])
Unit3i64 = (data: [1, 0, 0, 0, 1, 0, 0, 0, 1])
Unit4 = (data: [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0,
                0.0, 0.0, 1.0])
Unit4f = (data: [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0,
                 0.0, 0.0, 0.0, 1.0])
Unit4f32 = (data: [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0,
                   0.0, 0.0, 0.0, 1.0])
Unit4f64 = (data: [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0,
                   0.0, 0.0, 0.0, 1.0])
Unit4i = (data: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
Unit4i8 = (data: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
Unit4i16 = (data: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
Unit4i32 = (data: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
Unit4i64 = (data: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
X = [1.0, 0.0, 0.0]
Xi = [1, 0, 0]
Xi8 = [1, 0, 0]
XY = [1.0, 1.0, 0.0]
XYi = [1, 1, 0]
XYi8 = [1, 1, 0]
XYZ = [1.0, 1.0, 1.0]
XYZi = [1, 1, 1]
XYZi8 = [1, 1, 1]
XZ = [1.0, 0.0, 1.0]
XZi = [1, 0, 1]
XZi8 = [1, 0, 1]
Y = [0.0, 1.0, 0.0]
Yi = [0, 1, 0]
Yi8 = [0, 1, 0]
YZ = [0.0, 1.0, 1.0]
YZi = [0, 1, 1]
YZi8 = [0, 1, 1]
Z = [0.0, 0.0, 1.0]
Zi = [0, 0, 1]
Zi8 = [0, 0, 1]

Procs

func `$`(v: TMat2[SomeNumber]): string
func `$`(v: TMat3[SomeNumber]): string
func `$`(v: TMat4[SomeNumber]): string
func `$`(v: TMat23[SomeNumber]): string
func `$`(v: TMat32[SomeNumber]): string
func `$`(v: TMat34[SomeNumber]): string
func `$`(v: TMat43[SomeNumber]): string
func `$`(v: TVec1[SomeNumber]): string
func `$`(v: TVec2[SomeNumber]): string
func `$`(v: TVec3[SomeNumber]): string
func `$`(v: TVec4[SomeNumber]): string
func `*`(a, b: TVec1): auto
func `*`(a, b: TVec2): auto
func `*`(a, b: TVec3): auto
func `*`(a, b: TVec4): auto
func `*`(a: SomeNumber; b: TVec1): auto
func `*`(a: SomeNumber; b: TVec2): auto
func `*`(a: SomeNumber; b: TVec3): auto
func `*`(a: SomeNumber; b: TVec4): auto
func `*`(a: TMat2; b: SomeNumber): auto
func `*`(a: TMat2; b: TMat2): auto
func `*`(a: TMat2; b: TMat23): auto
func `*`(a: TMat3; b: SomeNumber): auto
func `*`(a: TMat3; b: TMat3): auto
func `*`(a: TMat3; b: TMat32): auto
func `*`(a: TMat3; b: TMat34): auto
func `*`(a: TMat4; b: SomeNumber): auto
func `*`(a: TMat4; b: TMat4): auto
func `*`(a: TMat4; b: TMat43): auto
func `*`(a: TMat23; b: SomeNumber): auto
func `*`(a: TMat23; b: TMat3): auto
func `*`(a: TMat23; b: TMat32): auto
func `*`(a: TMat32; b: SomeNumber): auto
func `*`(a: TMat32; b: TMat2): auto
func `*`(a: TMat32; b: TMat23): auto
func `*`(a: TMat34; b: SomeNumber): auto
func `*`(a: TMat43; b: SomeNumber): auto
func `*`(a: TMat43; b: TMat3): auto
func `*`(a: TMat43; b: TMat34): auto
func `*`(a: TVec1; b: SomeNumber): auto
func `*`(a: TVec2; b: SomeNumber): auto
func `*`(a: TVec3; b: SomeNumber): auto
func `*`(a: TVec4; b: SomeNumber): auto
func `*`(b: SomeNumber; a: TMat2): auto
func `*`(b: SomeNumber; a: TMat3): auto
func `*`(b: SomeNumber; a: TMat4): auto
func `*`(b: SomeNumber; a: TMat23): auto
func `*`(b: SomeNumber; a: TMat32): auto
func `*`(b: SomeNumber; a: TMat34): auto
func `*`(b: SomeNumber; a: TMat43): auto
func `*`(mat: Mat3; vec: Vec2f): Vec2f {....raises: [], tags: [], forbids: [].}
func `*`(mat: Mat4; vec: Vec3f): Vec3f {....raises: [], tags: [], forbids: [].}
func `*`[T: SomeNumber](m: TMat2[T]; v: TVec2[T]): auto
func `*`[T: SomeNumber](m: TMat3[T]; v: TVec3[T]): auto
func `*`[T: SomeNumber](m: TMat4[T]; v: TVec4[T]): auto
func `*=`(a: var TVec1; b: SomeNumber)
func `*=`(a: var TVec1; b: TVec1)
func `*=`(a: var TVec2; b: SomeNumber)
func `*=`(a: var TVec2; b: TVec2)
func `*=`(a: var TVec3; b: SomeNumber)
func `*=`(a: var TVec3; b: TVec3)
func `*=`(a: var TVec4; b: SomeNumber)
func `*=`(a: var TVec4; b: TVec4)
proc `*=`[T1: TSquareMat; T2: TSquareMat | SomeNumber](a: var T1; b: T2)
func `+`(a, b: TVec1): auto
func `+`(a, b: TVec2): auto
func `+`(a, b: TVec3): auto
func `+`(a, b: TVec4): auto
func `+`(a: SomeNumber; b: TVec1): auto
func `+`(a: SomeNumber; b: TVec2): auto
func `+`(a: SomeNumber; b: TVec3): auto
func `+`(a: SomeNumber; b: TVec4): auto
func `+`(a: TMat2; b: SomeNumber): auto
func `+`(a: TMat2; b: TMat2): auto
func `+`(a: TMat3; b: SomeNumber): auto
func `+`(a: TMat3; b: TMat3): auto
func `+`(a: TMat4; b: SomeNumber): auto
func `+`(a: TMat4; b: TMat4): auto
func `+`(a: TMat23; b: SomeNumber): auto
func `+`(a: TMat23; b: TMat23): auto
func `+`(a: TMat32; b: SomeNumber): auto
func `+`(a: TMat32; b: TMat32): auto
func `+`(a: TMat34; b: SomeNumber): auto
func `+`(a: TMat34; b: TMat34): auto
func `+`(a: TMat43; b: SomeNumber): auto
func `+`(a: TMat43; b: TMat43): auto
func `+`(a: TVec1; b: SomeNumber): auto
func `+`(a: TVec2; b: SomeNumber): auto
func `+`(a: TVec3; b: SomeNumber): auto
func `+`(a: TVec4; b: SomeNumber): auto
func `+`(b: SomeNumber; a: TMat2): auto
func `+`(b: SomeNumber; a: TMat3): auto
func `+`(b: SomeNumber; a: TMat4): auto
func `+`(b: SomeNumber; a: TMat23): auto
func `+`(b: SomeNumber; a: TMat32): auto
func `+`(b: SomeNumber; a: TMat34): auto
func `+`(b: SomeNumber; a: TMat43): auto
func `+=`(a: var TVec1; b: SomeNumber)
func `+=`(a: var TVec1; b: TVec1)
func `+=`(a: var TVec2; b: SomeNumber)
func `+=`(a: var TVec2; b: TVec2)
func `+=`(a: var TVec3; b: SomeNumber)
func `+=`(a: var TVec3; b: TVec3)
func `+=`(a: var TVec4; b: SomeNumber)
func `+=`(a: var TVec4; b: TVec4)
proc `+=`[T1: TSquareMat; T2: TSquareMat | SomeNumber](a: var T1; b: T2)
func `-`(a, b: TVec1): auto
func `-`(a, b: TVec2): auto
func `-`(a, b: TVec3): auto
func `-`(a, b: TVec4): auto
func `-`(a: SomeNumber; b: TVec1): auto
func `-`(a: SomeNumber; b: TVec2): auto
func `-`(a: SomeNumber; b: TVec3): auto
func `-`(a: SomeNumber; b: TVec4): auto
func `-`(a: TMat2): auto
func `-`(a: TMat2; b: SomeNumber): auto
func `-`(a: TMat3): auto
func `-`(a: TMat3; b: SomeNumber): auto
func `-`(a: TMat4): auto
func `-`(a: TMat4; b: SomeNumber): auto
func `-`(a: TMat23): auto
func `-`(a: TMat23; b: SomeNumber): auto
func `-`(a: TMat32): auto
func `-`(a: TMat32; b: SomeNumber): auto
func `-`(a: TMat34): auto
func `-`(a: TMat34; b: SomeNumber): auto
func `-`(a: TMat43): auto
func `-`(a: TMat43; b: SomeNumber): auto
func `-`(a: TVec1): auto
func `-`(a: TVec1; b: SomeNumber): auto
func `-`(a: TVec2): auto
func `-`(a: TVec2; b: SomeNumber): auto
func `-`(a: TVec3): auto
func `-`(a: TVec3; b: SomeNumber): auto
func `-`(a: TVec4): auto
func `-`(a: TVec4; b: SomeNumber): auto
func `-`(b: SomeNumber; a: TMat2): auto
func `-`(b: SomeNumber; a: TMat3): auto
func `-`(b: SomeNumber; a: TMat4): auto
func `-`(b: SomeNumber; a: TMat23): auto
func `-`(b: SomeNumber; a: TMat32): auto
func `-`(b: SomeNumber; a: TMat34): auto
func `-`(b: SomeNumber; a: TMat43): auto
func `-=`(a: var TVec1; b: SomeNumber)
func `-=`(a: var TVec1; b: TVec1)
func `-=`(a: var TVec2; b: SomeNumber)
func `-=`(a: var TVec2; b: TVec2)
func `-=`(a: var TVec3; b: SomeNumber)
func `-=`(a: var TVec3; b: TVec3)
func `-=`(a: var TVec4; b: SomeNumber)
func `-=`(a: var TVec4; b: TVec4)
proc `-=`[T1: TSquareMat; T2: TSquareMat | SomeNumber](a: var T1; b: T2)
func `/`(a: TMat2; b: SomeNumber): auto
func `/`(a: TMat3; b: SomeNumber): auto
func `/`(a: TMat4; b: SomeNumber): auto
func `/`(a: TMat23; b: SomeNumber): auto
func `/`(a: TMat32; b: SomeNumber): auto
func `/`(a: TMat34; b: SomeNumber): auto
func `/`(a: TMat43; b: SomeNumber): auto
func `/`(b: SomeNumber; a: TMat2): auto
func `/`(b: SomeNumber; a: TMat3): auto
func `/`(b: SomeNumber; a: TMat4): auto
func `/`(b: SomeNumber; a: TMat23): auto
func `/`(b: SomeNumber; a: TMat32): auto
func `/`(b: SomeNumber; a: TMat34): auto
func `/`(b: SomeNumber; a: TMat43): auto
func `/`[T, S: SomeFloat](a: TVec1[T]; b: S): auto
func `/`[T, S: SomeFloat](a: TVec2[T]; b: S): auto
func `/`[T, S: SomeFloat](a: TVec3[T]; b: S): auto
func `/`[T, S: SomeFloat](a: TVec4[T]; b: S): auto
func `/`[T: SomeFloat](a, b: TVec1[T]): auto
func `/`[T: SomeFloat](a, b: TVec2[T]): auto
func `/`[T: SomeFloat](a, b: TVec3[T]): auto
func `/`[T: SomeFloat](a, b: TVec4[T]): auto
func `/`[T: SomeFloat](a: SomeFloat; b: TVec1[T]): auto
func `/`[T: SomeFloat](a: SomeFloat; b: TVec2[T]): auto
func `/`[T: SomeFloat](a: SomeFloat; b: TVec3[T]): auto
func `/`[T: SomeFloat](a: SomeFloat; b: TVec4[T]): auto
func `/`[T: SomeInteger](a, b: TVec1[T]): auto
func `/`[T: SomeInteger](a, b: TVec2[T]): auto
func `/`[T: SomeInteger](a, b: TVec3[T]): auto
func `/`[T: SomeInteger](a, b: TVec4[T]): auto
func `/`[T: SomeInteger](a: SomeInteger; b: TVec1[T]): auto
func `/`[T: SomeInteger](a: SomeInteger; b: TVec2[T]): auto
func `/`[T: SomeInteger](a: SomeInteger; b: TVec3[T]): auto
func `/`[T: SomeInteger](a: SomeInteger; b: TVec4[T]): auto
func `/=`(a: var TVec1; b: SomeNumber)
func `/=`(a: var TVec1; b: TVec1)
func `/=`(a: var TVec2; b: SomeNumber)
func `/=`(a: var TVec2; b: TVec2)
func `/=`(a: var TVec3; b: SomeNumber)
func `/=`(a: var TVec3; b: TVec3)
func `/=`(a: var TVec4; b: SomeNumber)
func `/=`(a: var TVec4; b: TVec4)
func `[]`[T: TMat](m: T; i: int): auto
func `[]`[T: TMat](m: T; row, col: int): auto
func `[]=`[T: TMat; U](m: var T; i: int; value: U)
func `[]=`[T: TMat; U](m: var T; row, col: int; value: U)
func a(vec: TVec): auto
func a=[T](vec: var TVec; value: T)
func aa(vec: TVec): auto
func aa=[T](vec: var TVec; value: T)
func aaa(vec: TVec): auto
func aaa=[T](vec: var TVec; value: T)
func aaaa(vec: TVec): auto
func aaaa=[T](vec: var TVec; value: T)
func aaab(vec: TVec): auto
func aaab=[T](vec: var TVec; value: T)
func aaag(vec: TVec): auto
func aaag=[T](vec: var TVec; value: T)
func aaar(vec: TVec): auto
func aaar=[T](vec: var TVec; value: T)
func aab(vec: TVec): auto
func aab=[T](vec: var TVec; value: T)
func aaba(vec: TVec): auto
func aaba=[T](vec: var TVec; value: T)
func aabb(vec: TVec): auto
func aabb=[T](vec: var TVec; value: T)
func aabg(vec: TVec): auto
func aabg=[T](vec: var TVec; value: T)
func aabr(vec: TVec): auto
func aabr=[T](vec: var TVec; value: T)
func aag(vec: TVec): auto
func aag=[T](vec: var TVec; value: T)
func aaga(vec: TVec): auto
func aaga=[T](vec: var TVec; value: T)
func aagb(vec: TVec): auto
func aagb=[T](vec: var TVec; value: T)
func aagg(vec: TVec): auto
func aagg=[T](vec: var TVec; value: T)
func aagr(vec: TVec): auto
func aagr=[T](vec: var TVec; value: T)
func aar(vec: TVec): auto
func aar=[T](vec: var TVec; value: T)
func aara(vec: TVec): auto
func aara=[T](vec: var TVec; value: T)
func aarb(vec: TVec): auto
func aarb=[T](vec: var TVec; value: T)
func aarg(vec: TVec): auto
func aarg=[T](vec: var TVec; value: T)
func aarr(vec: TVec): auto
func aarr=[T](vec: var TVec; value: T)
func ab(vec: TVec): auto
func ab=[T](vec: var TVec; value: T)
func aba(vec: TVec): auto
func aba=[T](vec: var TVec; value: T)
func abaa(vec: TVec): auto
func abaa=[T](vec: var TVec; value: T)
func abab(vec: TVec): auto
func abab=[T](vec: var TVec; value: T)
func abag(vec: TVec): auto
func abag=[T](vec: var TVec; value: T)
func abar(vec: TVec): auto
func abar=[T](vec: var TVec; value: T)
func abb(vec: TVec): auto
func abb=[T](vec: var TVec; value: T)
func abba(vec: TVec): auto
func abba=[T](vec: var TVec; value: T)
func abbb(vec: TVec): auto
func abbb=[T](vec: var TVec; value: T)
func abbg(vec: TVec): auto
func abbg=[T](vec: var TVec; value: T)
func abbr(vec: TVec): auto
func abbr=[T](vec: var TVec; value: T)
func abg(vec: TVec): auto
func abg=[T](vec: var TVec; value: T)
func abga(vec: TVec): auto
func abga=[T](vec: var TVec; value: T)
func abgb(vec: TVec): auto
func abgb=[T](vec: var TVec; value: T)
func abgg(vec: TVec): auto
func abgg=[T](vec: var TVec; value: T)
func abgr(vec: TVec): auto
func abgr=[T](vec: var TVec; value: T)
func abr(vec: TVec): auto
func abr=[T](vec: var TVec; value: T)
func abra(vec: TVec): auto
func abra=[T](vec: var TVec; value: T)
func abrb(vec: TVec): auto
func abrb=[T](vec: var TVec; value: T)
func abrg(vec: TVec): auto
func abrg=[T](vec: var TVec; value: T)
func abrr(vec: TVec): auto
func abrr=[T](vec: var TVec; value: T)
func abs[T](vec: TVec1[T]): auto
func abs[T](vec: TVec2[T]): auto
func abs[T](vec: TVec3[T]): auto
func abs[T](vec: TVec4[T]): auto
func ag(vec: TVec): auto
func ag=[T](vec: var TVec; value: T)
func aga(vec: TVec): auto
func aga=[T](vec: var TVec; value: T)
func agaa(vec: TVec): auto
func agaa=[T](vec: var TVec; value: T)
func agab(vec: TVec): auto
func agab=[T](vec: var TVec; value: T)
func agag(vec: TVec): auto
func agag=[T](vec: var TVec; value: T)
func agar(vec: TVec): auto
func agar=[T](vec: var TVec; value: T)
func agb(vec: TVec): auto
func agb=[T](vec: var TVec; value: T)
func agba(vec: TVec): auto
func agba=[T](vec: var TVec; value: T)
func agbb(vec: TVec): auto
func agbb=[T](vec: var TVec; value: T)
func agbg(vec: TVec): auto
func agbg=[T](vec: var TVec; value: T)
func agbr(vec: TVec): auto
func agbr=[T](vec: var TVec; value: T)
func agg(vec: TVec): auto
func agg=[T](vec: var TVec; value: T)
func agga(vec: TVec): auto
func agga=[T](vec: var TVec; value: T)
func aggb(vec: TVec): auto
func aggb=[T](vec: var TVec; value: T)
func aggg(vec: TVec): auto
func aggg=[T](vec: var TVec; value: T)
func aggr(vec: TVec): auto
func aggr=[T](vec: var TVec; value: T)
func agr(vec: TVec): auto
func agr=[T](vec: var TVec; value: T)
func agra(vec: TVec): auto
func agra=[T](vec: var TVec; value: T)
func agrb(vec: TVec): auto
func agrb=[T](vec: var TVec; value: T)
func agrg(vec: TVec): auto
func agrg=[T](vec: var TVec; value: T)
func agrr(vec: TVec): auto
func agrr=[T](vec: var TVec; value: T)
func angleBetween(a, b: Vec3f): float32 {....raises: [], tags: [], forbids: [].}
proc AppName(): string {....raises: [], tags: [ReadIOEffect], forbids: [].}
func ar(vec: TVec): auto
func ar=[T](vec: var TVec; value: T)
func ara(vec: TVec): auto
func ara=[T](vec: var TVec; value: T)
func araa(vec: TVec): auto
func araa=[T](vec: var TVec; value: T)
func arab(vec: TVec): auto
func arab=[T](vec: var TVec; value: T)
func arag(vec: TVec): auto
func arag=[T](vec: var TVec; value: T)
func arar(vec: TVec): auto
func arar=[T](vec: var TVec; value: T)
func arb(vec: TVec): auto
func arb=[T](vec: var TVec; value: T)
func arba(vec: TVec): auto
func arba=[T](vec: var TVec; value: T)
func arbb(vec: TVec): auto
func arbb=[T](vec: var TVec; value: T)
func arbg(vec: TVec): auto
func arbg=[T](vec: var TVec; value: T)
func arbr(vec: TVec): auto
func arbr=[T](vec: var TVec; value: T)
func arg(vec: TVec): auto
func arg=[T](vec: var TVec; value: T)
func arga(vec: TVec): auto
func arga=[T](vec: var TVec; value: T)
func argb(vec: TVec): auto
func argb=[T](vec: var TVec; value: T)
func argg(vec: TVec): auto
func argg=[T](vec: var TVec; value: T)
func argr(vec: TVec): auto
func argr=[T](vec: var TVec; value: T)
func arr(vec: TVec): auto
func arr=[T](vec: var TVec; value: T)
func arra(vec: TVec): auto
func arra=[T](vec: var TVec; value: T)
func arrb(vec: TVec): auto
func arrb=[T](vec: var TVec; value: T)
func arrg(vec: TVec): auto
func arrg=[T](vec: var TVec; value: T)
func arrr(vec: TVec): auto
func arrr=[T](vec: var TVec; value: T)
func b(vec: TVec): auto
func b=[T](vec: var TVec; value: T)
func ba(vec: TVec): auto
func ba=[T](vec: var TVec; value: T)
func baa(vec: TVec): auto
func baa=[T](vec: var TVec; value: T)
func baaa(vec: TVec): auto
func baaa=[T](vec: var TVec; value: T)
func baab(vec: TVec): auto
func baab=[T](vec: var TVec; value: T)
func baag(vec: TVec): auto
func baag=[T](vec: var TVec; value: T)
func baar(vec: TVec): auto
func baar=[T](vec: var TVec; value: T)
func bab(vec: TVec): auto
func bab=[T](vec: var TVec; value: T)
func baba(vec: TVec): auto
func baba=[T](vec: var TVec; value: T)
func babb(vec: TVec): auto
func babb=[T](vec: var TVec; value: T)
func babg(vec: TVec): auto
func babg=[T](vec: var TVec; value: T)
func babr(vec: TVec): auto
func babr=[T](vec: var TVec; value: T)
func bag(vec: TVec): auto
func bag=[T](vec: var TVec; value: T)
func baga(vec: TVec): auto
func baga=[T](vec: var TVec; value: T)
func bagb(vec: TVec): auto
func bagb=[T](vec: var TVec; value: T)
func bagg(vec: TVec): auto
func bagg=[T](vec: var TVec; value: T)
func bagr(vec: TVec): auto
func bagr=[T](vec: var TVec; value: T)
func bar(vec: TVec): auto
func bar=[T](vec: var TVec; value: T)
func bara(vec: TVec): auto
func bara=[T](vec: var TVec; value: T)
func barb(vec: TVec): auto
func barb=[T](vec: var TVec; value: T)
func barg(vec: TVec): auto
func barg=[T](vec: var TVec; value: T)
func barr(vec: TVec): auto
func barr=[T](vec: var TVec; value: T)
func bb(vec: TVec): auto
func bb=[T](vec: var TVec; value: T)
func bba(vec: TVec): auto
func bba=[T](vec: var TVec; value: T)
func bbaa(vec: TVec): auto
func bbaa=[T](vec: var TVec; value: T)
func bbab(vec: TVec): auto
func bbab=[T](vec: var TVec; value: T)
func bbag(vec: TVec): auto
func bbag=[T](vec: var TVec; value: T)
func bbar(vec: TVec): auto
func bbar=[T](vec: var TVec; value: T)
func bbb(vec: TVec): auto
func bbb=[T](vec: var TVec; value: T)
func bbba(vec: TVec): auto
func bbba=[T](vec: var TVec; value: T)
func bbbb(vec: TVec): auto
func bbbb=[T](vec: var TVec; value: T)
func bbbg(vec: TVec): auto
func bbbg=[T](vec: var TVec; value: T)
func bbbr(vec: TVec): auto
func bbbr=[T](vec: var TVec; value: T)
func bbg(vec: TVec): auto
func bbg=[T](vec: var TVec; value: T)
func bbga(vec: TVec): auto
func bbga=[T](vec: var TVec; value: T)
func bbgb(vec: TVec): auto
func bbgb=[T](vec: var TVec; value: T)
func bbgg(vec: TVec): auto
func bbgg=[T](vec: var TVec; value: T)
func bbgr(vec: TVec): auto
func bbgr=[T](vec: var TVec; value: T)
func bbr(vec: TVec): auto
func bbr=[T](vec: var TVec; value: T)
func bbra(vec: TVec): auto
func bbra=[T](vec: var TVec; value: T)
func bbrb(vec: TVec): auto
func bbrb=[T](vec: var TVec; value: T)
func bbrg(vec: TVec): auto
func bbrg=[T](vec: var TVec; value: T)
func bbrr(vec: TVec): auto
func bbrr=[T](vec: var TVec; value: T)
func bg(vec: TVec): auto
func bg=[T](vec: var TVec; value: T)
func bga(vec: TVec): auto
func bga=[T](vec: var TVec; value: T)
func bgaa(vec: TVec): auto
func bgaa=[T](vec: var TVec; value: T)
func bgab(vec: TVec): auto
func bgab=[T](vec: var TVec; value: T)
func bgag(vec: TVec): auto
func bgag=[T](vec: var TVec; value: T)
func bgar(vec: TVec): auto
func bgar=[T](vec: var TVec; value: T)
func bgb(vec: TVec): auto
func bgb=[T](vec: var TVec; value: T)
func bgba(vec: TVec): auto
func bgba=[T](vec: var TVec; value: T)
func bgbb(vec: TVec): auto
func bgbb=[T](vec: var TVec; value: T)
func bgbg(vec: TVec): auto
func bgbg=[T](vec: var TVec; value: T)
func bgbr(vec: TVec): auto
func bgbr=[T](vec: var TVec; value: T)
func bgg(vec: TVec): auto
func bgg=[T](vec: var TVec; value: T)
func bgga(vec: TVec): auto
func bgga=[T](vec: var TVec; value: T)
func bggb(vec: TVec): auto
func bggb=[T](vec: var TVec; value: T)
func bggg(vec: TVec): auto
func bggg=[T](vec: var TVec; value: T)
func bggr(vec: TVec): auto
func bggr=[T](vec: var TVec; value: T)
func bgr(vec: TVec): auto
func bgr=[T](vec: var TVec; value: T)
func bgra(vec: TVec): auto
func bgra=[T](vec: var TVec; value: T)
func bgrb(vec: TVec): auto
func bgrb=[T](vec: var TVec; value: T)
func bgrg(vec: TVec): auto
func bgrg=[T](vec: var TVec; value: T)
func bgrr(vec: TVec): auto
func bgrr=[T](vec: var TVec; value: T)
func br(vec: TVec): auto
func br=[T](vec: var TVec; value: T)
func bra(vec: TVec): auto
func bra=[T](vec: var TVec; value: T)
func braa(vec: TVec): auto
func braa=[T](vec: var TVec; value: T)
func brab(vec: TVec): auto
func brab=[T](vec: var TVec; value: T)
func brag(vec: TVec): auto
func brag=[T](vec: var TVec; value: T)
func brar(vec: TVec): auto
func brar=[T](vec: var TVec; value: T)
func brb(vec: TVec): auto
func brb=[T](vec: var TVec; value: T)
func brba(vec: TVec): auto
func brba=[T](vec: var TVec; value: T)
func brbb(vec: TVec): auto
func brbb=[T](vec: var TVec; value: T)
func brbg(vec: TVec): auto
func brbg=[T](vec: var TVec; value: T)
func brbr(vec: TVec): auto
func brbr=[T](vec: var TVec; value: T)
func brg(vec: TVec): auto
func brg=[T](vec: var TVec; value: T)
func brga(vec: TVec): auto
func brga=[T](vec: var TVec; value: T)
func brgb(vec: TVec): auto
func brgb=[T](vec: var TVec; value: T)
func brgg(vec: TVec): auto
func brgg=[T](vec: var TVec; value: T)
func brgr(vec: TVec): auto
func brgr=[T](vec: var TVec; value: T)
func brr(vec: TVec): auto
func brr=[T](vec: var TVec; value: T)
func brra(vec: TVec): auto
func brra=[T](vec: var TVec; value: T)
func brrb(vec: TVec): auto
func brrb=[T](vec: var TVec; value: T)
func brrg(vec: TVec): auto
func brrg=[T](vec: var TVec; value: T)
func brrr(vec: TVec): auto
func brrr=[T](vec: var TVec; value: T)
func ceil[T](vec: TVec1[T]): auto
func ceil[T](vec: TVec2[T]): auto
func ceil[T](vec: TVec3[T]): auto
func ceil[T](vec: TVec4[T]): auto
func clamp[T, S: SomeNumber](vec: TVec1[T]; a, b: S): auto
func clamp[T, S: SomeNumber](vec: TVec1[T]; a, b: TVec1[S]): auto
func clamp[T, S: SomeNumber](vec: TVec2[T]; a, b: S): auto
func clamp[T, S: SomeNumber](vec: TVec2[T]; a, b: TVec2[S]): auto
func clamp[T, S: SomeNumber](vec: TVec3[T]; a, b: S): auto
func clamp[T, S: SomeNumber](vec: TVec3[T]; a, b: TVec3[S]): auto
func clamp[T, S: SomeNumber](vec: TVec4[T]; a, b: S): auto
func clamp[T, S: SomeNumber](vec: TVec4[T]; a, b: TVec4[S]): auto
func CleanString(str: openArray[char]): string {....raises: [], tags: [],
    forbids: [].}
func col[T: TMat2](m: T; i: 0 .. 1): auto
func col[T: TMat3](m: T; i: 0 .. 2): auto
func col[T: TMat4](m: T; i: 0 .. 3): auto
func col[T: TMat23](m: T; i: 0 .. 2): auto
func col[T: TMat32](m: T; i: 0 .. 1): auto
func col[T: TMat34](m: T; i: 0 .. 3): auto
func col[T: TMat43](m: T; i: 0 .. 2): auto
func cross(a, b: TVec3): auto
func `div`[T, S: SomeInteger](a: TVec1[T]; b: S): auto
func `div`[T, S: SomeInteger](a: TVec2[T]; b: S): auto
func `div`[T, S: SomeInteger](a: TVec3[T]; b: S): auto
func `div`[T, S: SomeInteger](a: TVec4[T]; b: S): auto
func `div`[T: SomeInteger](a, b: TVec1[T]): auto
func `div`[T: SomeInteger](a, b: TVec2[T]): auto
func `div`[T: SomeInteger](a, b: TVec3[T]): auto
func `div`[T: SomeInteger](a, b: TVec4[T]): auto
func dot(a, b: TVec1): auto
func dot(a, b: TVec2): auto
func dot(a, b: TVec3): auto
func dot(a, b: TVec4): auto
func f32(v: TVec1): auto
func f32(v: TVec2): auto
func f32(v: TVec3): auto
func f32(v: TVec4): auto
func floor[T](vec: TVec1[T]): auto
func floor[T](vec: TVec2[T]): auto
func floor[T](vec: TVec3[T]): auto
func floor[T](vec: TVec4[T]): auto
func floorDiv[T: SomeInteger](a, b: TVec1[T]): auto
func floorDiv[T: SomeInteger](a, b: TVec2[T]): auto
func floorDiv[T: SomeInteger](a, b: TVec3[T]): auto
func floorDiv[T: SomeInteger](a, b: TVec4[T]): auto
func floorMod[T: SomeInteger](a, b: TVec1[T]): auto
func floorMod[T: SomeInteger](a, b: TVec2[T]): auto
func floorMod[T: SomeInteger](a, b: TVec3[T]): auto
func floorMod[T: SomeInteger](a, b: TVec4[T]): auto
func g(vec: TVec): auto
func g=[T](vec: var TVec; value: T)
func ga(vec: TVec): auto
func ga=[T](vec: var TVec; value: T)
func gaa(vec: TVec): auto
func gaa=[T](vec: var TVec; value: T)
func gaaa(vec: TVec): auto
func gaaa=[T](vec: var TVec; value: T)
func gaab(vec: TVec): auto
func gaab=[T](vec: var TVec; value: T)
func gaag(vec: TVec): auto
func gaag=[T](vec: var TVec; value: T)
func gaar(vec: TVec): auto
func gaar=[T](vec: var TVec; value: T)
func gab(vec: TVec): auto
func gab=[T](vec: var TVec; value: T)
func gaba(vec: TVec): auto
func gaba=[T](vec: var TVec; value: T)
func gabb(vec: TVec): auto
func gabb=[T](vec: var TVec; value: T)
func gabg(vec: TVec): auto
func gabg=[T](vec: var TVec; value: T)
func gabr(vec: TVec): auto
func gabr=[T](vec: var TVec; value: T)
func gag(vec: TVec): auto
func gag=[T](vec: var TVec; value: T)
func gaga(vec: TVec): auto
func gaga=[T](vec: var TVec; value: T)
func gagb(vec: TVec): auto
func gagb=[T](vec: var TVec; value: T)
func gagg(vec: TVec): auto
func gagg=[T](vec: var TVec; value: T)
func gagr(vec: TVec): auto
func gagr=[T](vec: var TVec; value: T)
func gar(vec: TVec): auto
func gar=[T](vec: var TVec; value: T)
func gara(vec: TVec): auto
func gara=[T](vec: var TVec; value: T)
func garb(vec: TVec): auto
func garb=[T](vec: var TVec; value: T)
func garg(vec: TVec): auto
func garg=[T](vec: var TVec; value: T)
func garr(vec: TVec): auto
func garr=[T](vec: var TVec; value: T)
func gb(vec: TVec): auto
func gb=[T](vec: var TVec; value: T)
func gba(vec: TVec): auto
func gba=[T](vec: var TVec; value: T)
func gbaa(vec: TVec): auto
func gbaa=[T](vec: var TVec; value: T)
func gbab(vec: TVec): auto
func gbab=[T](vec: var TVec; value: T)
func gbag(vec: TVec): auto
func gbag=[T](vec: var TVec; value: T)
func gbar(vec: TVec): auto
func gbar=[T](vec: var TVec; value: T)
func gbb(vec: TVec): auto
func gbb=[T](vec: var TVec; value: T)
func gbba(vec: TVec): auto
func gbba=[T](vec: var TVec; value: T)
func gbbb(vec: TVec): auto
func gbbb=[T](vec: var TVec; value: T)
func gbbg(vec: TVec): auto
func gbbg=[T](vec: var TVec; value: T)
func gbbr(vec: TVec): auto
func gbbr=[T](vec: var TVec; value: T)
func gbg(vec: TVec): auto
func gbg=[T](vec: var TVec; value: T)
func gbga(vec: TVec): auto
func gbga=[T](vec: var TVec; value: T)
func gbgb(vec: TVec): auto
func gbgb=[T](vec: var TVec; value: T)
func gbgg(vec: TVec): auto
func gbgg=[T](vec: var TVec; value: T)
func gbgr(vec: TVec): auto
func gbgr=[T](vec: var TVec; value: T)
func gbr(vec: TVec): auto
func gbr=[T](vec: var TVec; value: T)
func gbra(vec: TVec): auto
func gbra=[T](vec: var TVec; value: T)
func gbrb(vec: TVec): auto
func gbrb=[T](vec: var TVec; value: T)
func gbrg(vec: TVec): auto
func gbrg=[T](vec: var TVec; value: T)
func gbrr(vec: TVec): auto
func gbrr=[T](vec: var TVec; value: T)
func gg(vec: TVec): auto
func gg=[T](vec: var TVec; value: T)
func gga(vec: TVec): auto
func gga=[T](vec: var TVec; value: T)
func ggaa(vec: TVec): auto
func ggaa=[T](vec: var TVec; value: T)
func ggab(vec: TVec): auto
func ggab=[T](vec: var TVec; value: T)
func ggag(vec: TVec): auto
func ggag=[T](vec: var TVec; value: T)
func ggar(vec: TVec): auto
func ggar=[T](vec: var TVec; value: T)
func ggb(vec: TVec): auto
func ggb=[T](vec: var TVec; value: T)
func ggba(vec: TVec): auto
func ggba=[T](vec: var TVec; value: T)
func ggbb(vec: TVec): auto
func ggbb=[T](vec: var TVec; value: T)
func ggbg(vec: TVec): auto
func ggbg=[T](vec: var TVec; value: T)
func ggbr(vec: TVec): auto
func ggbr=[T](vec: var TVec; value: T)
func ggg(vec: TVec): auto
func ggg=[T](vec: var TVec; value: T)
func ggga(vec: TVec): auto
func ggga=[T](vec: var TVec; value: T)
func gggb(vec: TVec): auto
func gggb=[T](vec: var TVec; value: T)
func gggg(vec: TVec): auto
func gggg=[T](vec: var TVec; value: T)
func gggr(vec: TVec): auto
func gggr=[T](vec: var TVec; value: T)
func ggr(vec: TVec): auto
func ggr=[T](vec: var TVec; value: T)
func ggra(vec: TVec): auto
func ggra=[T](vec: var TVec; value: T)
func ggrb(vec: TVec): auto
func ggrb=[T](vec: var TVec; value: T)
func ggrg(vec: TVec): auto
func ggrg=[T](vec: var TVec; value: T)
func ggrr(vec: TVec): auto
func ggrr=[T](vec: var TVec; value: T)
func gr(vec: TVec): auto
func gr=[T](vec: var TVec; value: T)
func gra(vec: TVec): auto
func gra=[T](vec: var TVec; value: T)
func graa(vec: TVec): auto
func graa=[T](vec: var TVec; value: T)
func grab(vec: TVec): auto
func grab=[T](vec: var TVec; value: T)
func grag(vec: TVec): auto
func grag=[T](vec: var TVec; value: T)
func grar(vec: TVec): auto
func grar=[T](vec: var TVec; value: T)
func grb(vec: TVec): auto
func grb=[T](vec: var TVec; value: T)
func grba(vec: TVec): auto
func grba=[T](vec: var TVec; value: T)
func grbb(vec: TVec): auto
func grbb=[T](vec: var TVec; value: T)
func grbg(vec: TVec): auto
func grbg=[T](vec: var TVec; value: T)
func grbr(vec: TVec): auto
func grbr=[T](vec: var TVec; value: T)
func grg(vec: TVec): auto
func grg=[T](vec: var TVec; value: T)
func grga(vec: TVec): auto
func grga=[T](vec: var TVec; value: T)
func grgb(vec: TVec): auto
func grgb=[T](vec: var TVec; value: T)
func grgg(vec: TVec): auto
func grgg=[T](vec: var TVec; value: T)
func grgr(vec: TVec): auto
func grgr=[T](vec: var TVec; value: T)
func grr(vec: TVec): auto
func grr=[T](vec: var TVec; value: T)
func grra(vec: TVec): auto
func grra=[T](vec: var TVec; value: T)
func grrb(vec: TVec): auto
func grrb=[T](vec: var TVec; value: T)
func grrg(vec: TVec): auto
func grrg=[T](vec: var TVec; value: T)
func grrr(vec: TVec): auto
func grrr=[T](vec: var TVec; value: T)
func i8(v: TVec1): auto
func i8(v: TVec2): auto
func i8(v: TVec3): auto
func i8(v: TVec4): auto
func i32(v: TVec1): auto
func i32(v: TVec2): auto
func i32(v: TVec3): auto
func i32(v: TVec4): auto
func inversed(a: Mat4): Mat4 {....raises: [], tags: [], forbids: [].}
func length(vec: TVec1): auto
func length(vec: TVec2[SomeFloat]): auto
func length(vec: TVec2[SomeInteger]): auto
func length(vec: TVec3[SomeFloat]): auto
func length(vec: TVec3[SomeInteger]): auto
func length(vec: TVec4[SomeFloat]): auto
func length(vec: TVec4[SomeInteger]): auto
func manhattan(vec: TVec1): auto
func manhattan(vec: TVec2): auto
func manhattan(vec: TVec3): auto
func manhattan(vec: TVec4): auto
func `mod`[T: SomeInteger](a, b: TVec1[T]): auto
func `mod`[T: SomeInteger](a, b: TVec2[T]): auto
func `mod`[T: SomeInteger](a, b: TVec3[T]): auto
func `mod`[T: SomeInteger](a, b: TVec4[T]): auto
proc nativeFree(p: pointer) {.importc: "free", ...raises: [], tags: [], forbids: [].}
func normal[T: SomeFloat](vec: TVec2[T]): auto
func normalized[T: SomeFloat](vec: TVec1[T]): auto
func normalized[T: SomeFloat](vec: TVec2[T]): auto
func normalized[T: SomeFloat](vec: TVec3[T]): auto
func normalized[T: SomeFloat](vec: TVec4[T]): auto
func ortho(left, right, top, bottom, zNear, zFar: float32): Mat4 {....raises: [],
    tags: [], forbids: [].}
func pow(a: TVec1; b: SomeNumber): auto
func pow(a: TVec2; b: SomeNumber): auto
func pow(a: TVec3; b: SomeNumber): auto
func pow(a: TVec4; b: SomeNumber): auto
func projection(fovy, aspect, zNear, zFar: float32): Mat4 {....raises: [],
    tags: [], forbids: [].}
func r(vec: TVec): auto
func r=[T](vec: var TVec; value: T)
func ra(vec: TVec): auto
func ra=[T](vec: var TVec; value: T)
func raa(vec: TVec): auto
func raa=[T](vec: var TVec; value: T)
func raaa(vec: TVec): auto
func raaa=[T](vec: var TVec; value: T)
func raab(vec: TVec): auto
func raab=[T](vec: var TVec; value: T)
func raag(vec: TVec): auto
func raag=[T](vec: var TVec; value: T)
func raar(vec: TVec): auto
func raar=[T](vec: var TVec; value: T)
func rab(vec: TVec): auto
func rab=[T](vec: var TVec; value: T)
func raba(vec: TVec): auto
func raba=[T](vec: var TVec; value: T)
func rabb(vec: TVec): auto
func rabb=[T](vec: var TVec; value: T)
func rabg(vec: TVec): auto
func rabg=[T](vec: var TVec; value: T)
func rabr(vec: TVec): auto
func rabr=[T](vec: var TVec; value: T)
func rag(vec: TVec): auto
func rag=[T](vec: var TVec; value: T)
func raga(vec: TVec): auto
func raga=[T](vec: var TVec; value: T)
func ragb(vec: TVec): auto
func ragb=[T](vec: var TVec; value: T)
func ragg(vec: TVec): auto
func ragg=[T](vec: var TVec; value: T)
func ragr(vec: TVec): auto
func ragr=[T](vec: var TVec; value: T)
func rar(vec: TVec): auto
func rar=[T](vec: var TVec; value: T)
func rara(vec: TVec): auto
func rara=[T](vec: var TVec; value: T)
func rarb(vec: TVec): auto
func rarb=[T](vec: var TVec; value: T)
func rarg(vec: TVec): auto
func rarg=[T](vec: var TVec; value: T)
func rarr(vec: TVec): auto
func rarr=[T](vec: var TVec; value: T)
func rb(vec: TVec): auto
func rb=[T](vec: var TVec; value: T)
func rba(vec: TVec): auto
func rba=[T](vec: var TVec; value: T)
func rbaa(vec: TVec): auto
func rbaa=[T](vec: var TVec; value: T)
func rbab(vec: TVec): auto
func rbab=[T](vec: var TVec; value: T)
func rbag(vec: TVec): auto
func rbag=[T](vec: var TVec; value: T)
func rbar(vec: TVec): auto
func rbar=[T](vec: var TVec; value: T)
func rbb(vec: TVec): auto
func rbb=[T](vec: var TVec; value: T)
func rbba(vec: TVec): auto
func rbba=[T](vec: var TVec; value: T)
func rbbb(vec: TVec): auto
func rbbb=[T](vec: var TVec; value: T)
func rbbg(vec: TVec): auto
func rbbg=[T](vec: var TVec; value: T)
func rbbr(vec: TVec): auto
func rbbr=[T](vec: var TVec; value: T)
func rbg(vec: TVec): auto
func rbg=[T](vec: var TVec; value: T)
func rbga(vec: TVec): auto
func rbga=[T](vec: var TVec; value: T)
func rbgb(vec: TVec): auto
func rbgb=[T](vec: var TVec; value: T)
func rbgg(vec: TVec): auto
func rbgg=[T](vec: var TVec; value: T)
func rbgr(vec: TVec): auto
func rbgr=[T](vec: var TVec; value: T)
func rbr(vec: TVec): auto
func rbr=[T](vec: var TVec; value: T)
func rbra(vec: TVec): auto
func rbra=[T](vec: var TVec; value: T)
func rbrb(vec: TVec): auto
func rbrb=[T](vec: var TVec; value: T)
func rbrg(vec: TVec): auto
func rbrg=[T](vec: var TVec; value: T)
func rbrr(vec: TVec): auto
func rbrr=[T](vec: var TVec; value: T)
func rg(vec: TVec): auto
func rg=[T](vec: var TVec; value: T)
func rga(vec: TVec): auto
func rga=[T](vec: var TVec; value: T)
func rgaa(vec: TVec): auto
func rgaa=[T](vec: var TVec; value: T)
func rgab(vec: TVec): auto
func rgab=[T](vec: var TVec; value: T)
func rgag(vec: TVec): auto
func rgag=[T](vec: var TVec; value: T)
func rgar(vec: TVec): auto
func rgar=[T](vec: var TVec; value: T)
func rgb(vec: TVec): auto
func rgb=[T](vec: var TVec; value: T)
func rgba(vec: TVec): auto
func rgba=[T](vec: var TVec; value: T)
func rgbb(vec: TVec): auto
func rgbb=[T](vec: var TVec; value: T)
func rgbg(vec: TVec): auto
func rgbg=[T](vec: var TVec; value: T)
func rgbr(vec: TVec): auto
func rgbr=[T](vec: var TVec; value: T)
func rgg(vec: TVec): auto
func rgg=[T](vec: var TVec; value: T)
func rgga(vec: TVec): auto
func rgga=[T](vec: var TVec; value: T)
func rggb(vec: TVec): auto
func rggb=[T](vec: var TVec; value: T)
func rggg(vec: TVec): auto
func rggg=[T](vec: var TVec; value: T)
func rggr(vec: TVec): auto
func rggr=[T](vec: var TVec; value: T)
func rgr(vec: TVec): auto
func rgr=[T](vec: var TVec; value: T)
func rgra(vec: TVec): auto
func rgra=[T](vec: var TVec; value: T)
func rgrb(vec: TVec): auto
func rgrb=[T](vec: var TVec; value: T)
func rgrg(vec: TVec): auto
func rgrg=[T](vec: var TVec; value: T)
func rgrr(vec: TVec): auto
func rgrr=[T](vec: var TVec; value: T)
func rotate(angle: float32; a: Vec3f): Mat4 {....raises: [], tags: [], forbids: [].}
func rotate2d[T](angle: T): TMat3[T]
func round[T](vec: TVec1[T]): auto
func round[T](vec: TVec2[T]): auto
func round[T](vec: TVec3[T]): auto
func round[T](vec: TVec4[T]): auto
func row[T: TMat2](m: T; i: 0 .. 1): auto
func row[T: TMat3](m: T; i: 0 .. 2): auto
func row[T: TMat4](m: T; i: 0 .. 3): auto
func row[T: TMat23](m: T; i: 0 .. 1): auto
func row[T: TMat32](m: T; i: 0 .. 2): auto
func row[T: TMat34](m: T; i: 0 .. 2): auto
func row[T: TMat43](m: T; i: 0 .. 3): auto
func rr(vec: TVec): auto
func rr=[T](vec: var TVec; value: T)
func rra(vec: TVec): auto
func rra=[T](vec: var TVec; value: T)
func rraa(vec: TVec): auto
func rraa=[T](vec: var TVec; value: T)
func rrab(vec: TVec): auto
func rrab=[T](vec: var TVec; value: T)
func rrag(vec: TVec): auto
func rrag=[T](vec: var TVec; value: T)
func rrar(vec: TVec): auto
func rrar=[T](vec: var TVec; value: T)
func rrb(vec: TVec): auto
func rrb=[T](vec: var TVec; value: T)
func rrba(vec: TVec): auto
func rrba=[T](vec: var TVec; value: T)
func rrbb(vec: TVec): auto
func rrbb=[T](vec: var TVec; value: T)
func rrbg(vec: TVec): auto
func rrbg=[T](vec: var TVec; value: T)
func rrbr(vec: TVec): auto
func rrbr=[T](vec: var TVec; value: T)
func rrg(vec: TVec): auto
func rrg=[T](vec: var TVec; value: T)
func rrga(vec: TVec): auto
func rrga=[T](vec: var TVec; value: T)
func rrgb(vec: TVec): auto
func rrgb=[T](vec: var TVec; value: T)
func rrgg(vec: TVec): auto
func rrgg=[T](vec: var TVec; value: T)
func rrgr(vec: TVec): auto
func rrgr=[T](vec: var TVec; value: T)
func rrr(vec: TVec): auto
func rrr=[T](vec: var TVec; value: T)
func rrra(vec: TVec): auto
func rrra=[T](vec: var TVec; value: T)
func rrrb(vec: TVec): auto
func rrrb=[T](vec: var TVec; value: T)
func rrrg(vec: TVec): auto
func rrrg=[T](vec: var TVec; value: T)
func rrrr(vec: TVec): auto
func rrrr=[T](vec: var TVec; value: T)
func scale(x = 1.0'f32; y = 1.0'f32; z = 1.0'f32): Mat4 {....raises: [], tags: [],
    forbids: [].}
func scale[T: TVec3](v: T): TMat4[float32]
func scale2d[T](sx, sy: T): TMat3[T]
func Size[T: seq](list: T): uint64
proc StaticExecChecked(command: string; input = ""): string {.compileTime,
    ...raises: [Exception], tags: [], forbids: [].}
func to[T](v: TVec1): auto
func to[T](v: TVec2): auto
func to[T](v: TVec3): auto
func to[T](v: TVec4): auto
func ToCPointer[T](list: openArray[T]): ptr T
func toVec(value: string; gamma = 2.2'f32): Vec4f {....raises: [ValueError],
    tags: [], forbids: [].}
func toVec1[T: SomeNumber](orig: TVec3[T] | TVec4[T]): TVec1[T]
func toVec2[T: SomeNumber](orig: TVec1[T]; value: T = default(T)): TVec2[T]
func toVec2[T: SomeNumber](orig: TVec3[T] | TVec4[T]): TVec2[T]
func toVec3[T: SomeNumber](orig: TVec2[T]; value: T = default(T)): TVec3[T]
func toVec3[T: SomeNumber](orig: TVec4[T]): TVec3[T]
func toVec4[T: SomeNumber](orig: TVec3[T]; value: T = default(T)): TVec4[T]
func transform[T, S](points: var openArray[S]; mat: TMat4[T])
func transformed[T, S](points: openArray[S]; mat: TMat4[T]): seq[S]
func translate(x = 0.0'f32; y = 0.0'f32; z = 0.0'f32): TMat4[float32] {.
    ...raises: [], tags: [], forbids: [].}
func translate[T: TVec3](v: T): TMat4[float32]
func translate2d[T](x, y: T): TMat3[T]
func transposed[T](m: TMat2[T]): TMat2[T]
func transposed[T](m: TMat3[T]): TMat3[T]
func transposed[T](m: TMat4[T]): TMat4[T]
func transposed[T](m: TMat23[T]): TMat32[T]
func transposed[T](m: TMat32[T]): TMat23[T]
func transposed[T](m: TMat34[T]): TMat43[T]
func transposed[T](m: TMat43[T]): TMat34[T]
func vec1[T: SomeNumber](x: T): Vec1f
func vec1i[T: SomeInteger](x: T): Vec1i
func vec2(): Vec2f {....raises: [], tags: [], forbids: [].}
func vec2[T, S: SomeNumber](x: T; y: S): Vec2f
func vec2[T: SomeNumber](x: T): Vec2f
func vec2i(): Vec2i {....raises: [], tags: [], forbids: [].}
func vec2i[T, S: SomeInteger](x: T; y: S): Vec2i
func vec2i[T: SomeInteger](x: T): Vec2i
func vec2i8(): Vec2i8 {....raises: [], tags: [], forbids: [].}
func vec2i8[T, S: SomeInteger](x: T; y: S): Vec2i8
func vec2i8[T: SomeInteger](x: T): Vec2i8
func vec3(): Vec3f {....raises: [], tags: [], forbids: [].}
func vec3[T, S, U: SomeNumber](x: T; y: S; z: U): Vec3f
func vec3[T, S: SomeNumber](x: T; y: S): Vec3f
func vec3[T: SomeNumber](x: T): Vec3f
func vec3i(): Vec3i {....raises: [], tags: [], forbids: [].}
func vec3i[T, S, U: SomeInteger](x: T; y: S; z: U): Vec3i
func vec3i[T, S: SomeInteger](x: T; y: S): Vec3i
func vec3i[T: SomeInteger](x: T): Vec3i
func vec3i8(): Vec3i8 {....raises: [], tags: [], forbids: [].}
func vec3i8[T, S, U: SomeInteger](x: T; y: S; z: U): Vec3i8
func vec3i8[T, S: SomeInteger](x: T; y: S): Vec3i8
func vec3i8[T: SomeInteger](x: T): Vec3i8
func vec4(): Vec4f {....raises: [], tags: [], forbids: [].}
func vec4[T, S, U, V: SomeNumber](x: T; y: S; z: U; w: V): Vec4f
func vec4[T, S, U: SomeNumber](x: T; y: S; z: U): Vec4f
func vec4[T, S: SomeNumber](x: T; y: S): Vec4f
func vec4[T: SomeNumber](x: T): Vec4f
func vec4i(): Vec4i {....raises: [], tags: [], forbids: [].}
func vec4i[T, S, U, V: SomeInteger](x: T; y: S; z: U; w: V): Vec4i
func vec4i[T, S, U: SomeInteger](x: T; y: S; z: U): Vec4i
func vec4i[T, S: SomeInteger](x: T; y: S): Vec4i
func vec4i[T: SomeInteger](x: T): Vec4i
func w(vec: TVec): auto
func w=[T](vec: var TVec; value: T)
func ww(vec: TVec): auto
func ww=[T](vec: var TVec; value: T)
func www(vec: TVec): auto
func www=[T](vec: var TVec; value: T)
func wwww(vec: TVec): auto
func wwww=[T](vec: var TVec; value: T)
func wwwx(vec: TVec): auto
func wwwx=[T](vec: var TVec; value: T)
func wwwy(vec: TVec): auto
func wwwy=[T](vec: var TVec; value: T)
func wwwz(vec: TVec): auto
func wwwz=[T](vec: var TVec; value: T)
func wwx(vec: TVec): auto
func wwx=[T](vec: var TVec; value: T)
func wwxw(vec: TVec): auto
func wwxw=[T](vec: var TVec; value: T)
func wwxx(vec: TVec): auto
func wwxx=[T](vec: var TVec; value: T)
func wwxy(vec: TVec): auto
func wwxy=[T](vec: var TVec; value: T)
func wwxz(vec: TVec): auto
func wwxz=[T](vec: var TVec; value: T)
func wwy(vec: TVec): auto
func wwy=[T](vec: var TVec; value: T)
func wwyw(vec: TVec): auto
func wwyw=[T](vec: var TVec; value: T)
func wwyx(vec: TVec): auto
func wwyx=[T](vec: var TVec; value: T)
func wwyy(vec: TVec): auto
func wwyy=[T](vec: var TVec; value: T)
func wwyz(vec: TVec): auto
func wwyz=[T](vec: var TVec; value: T)
func wwz(vec: TVec): auto
func wwz=[T](vec: var TVec; value: T)
func wwzw(vec: TVec): auto
func wwzw=[T](vec: var TVec; value: T)
func wwzx(vec: TVec): auto
func wwzx=[T](vec: var TVec; value: T)
func wwzy(vec: TVec): auto
func wwzy=[T](vec: var TVec; value: T)
func wwzz(vec: TVec): auto
func wwzz=[T](vec: var TVec; value: T)
func wx(vec: TVec): auto
func wx=[T](vec: var TVec; value: T)
func wxw(vec: TVec): auto
func wxw=[T](vec: var TVec; value: T)
func wxww(vec: TVec): auto
func wxww=[T](vec: var TVec; value: T)
func wxwx(vec: TVec): auto
func wxwx=[T](vec: var TVec; value: T)
func wxwy(vec: TVec): auto
func wxwy=[T](vec: var TVec; value: T)
func wxwz(vec: TVec): auto
func wxwz=[T](vec: var TVec; value: T)
func wxx(vec: TVec): auto
func wxx=[T](vec: var TVec; value: T)
func wxxw(vec: TVec): auto
func wxxw=[T](vec: var TVec; value: T)
func wxxx(vec: TVec): auto
func wxxx=[T](vec: var TVec; value: T)
func wxxy(vec: TVec): auto
func wxxy=[T](vec: var TVec; value: T)
func wxxz(vec: TVec): auto
func wxxz=[T](vec: var TVec; value: T)
func wxy(vec: TVec): auto
func wxy=[T](vec: var TVec; value: T)
func wxyw(vec: TVec): auto
func wxyw=[T](vec: var TVec; value: T)
func wxyx(vec: TVec): auto
func wxyx=[T](vec: var TVec; value: T)
func wxyy(vec: TVec): auto
func wxyy=[T](vec: var TVec; value: T)
func wxyz(vec: TVec): auto
func wxyz=[T](vec: var TVec; value: T)
func wxz(vec: TVec): auto
func wxz=[T](vec: var TVec; value: T)
func wxzw(vec: TVec): auto
func wxzw=[T](vec: var TVec; value: T)
func wxzx(vec: TVec): auto
func wxzx=[T](vec: var TVec; value: T)
func wxzy(vec: TVec): auto
func wxzy=[T](vec: var TVec; value: T)
func wxzz(vec: TVec): auto
func wxzz=[T](vec: var TVec; value: T)
func wy(vec: TVec): auto
func wy=[T](vec: var TVec; value: T)
func wyw(vec: TVec): auto
func wyw=[T](vec: var TVec; value: T)
func wyww(vec: TVec): auto
func wyww=[T](vec: var TVec; value: T)
func wywx(vec: TVec): auto
func wywx=[T](vec: var TVec; value: T)
func wywy(vec: TVec): auto
func wywy=[T](vec: var TVec; value: T)
func wywz(vec: TVec): auto
func wywz=[T](vec: var TVec; value: T)
func wyx(vec: TVec): auto
func wyx=[T](vec: var TVec; value: T)
func wyxw(vec: TVec): auto
func wyxw=[T](vec: var TVec; value: T)
func wyxx(vec: TVec): auto
func wyxx=[T](vec: var TVec; value: T)
func wyxy(vec: TVec): auto
func wyxy=[T](vec: var TVec; value: T)
func wyxz(vec: TVec): auto
func wyxz=[T](vec: var TVec; value: T)
func wyy(vec: TVec): auto
func wyy=[T](vec: var TVec; value: T)
func wyyw(vec: TVec): auto
func wyyw=[T](vec: var TVec; value: T)
func wyyx(vec: TVec): auto
func wyyx=[T](vec: var TVec; value: T)
func wyyy(vec: TVec): auto
func wyyy=[T](vec: var TVec; value: T)
func wyyz(vec: TVec): auto
func wyyz=[T](vec: var TVec; value: T)
func wyz(vec: TVec): auto
func wyz=[T](vec: var TVec; value: T)
func wyzw(vec: TVec): auto
func wyzw=[T](vec: var TVec; value: T)
func wyzx(vec: TVec): auto
func wyzx=[T](vec: var TVec; value: T)
func wyzy(vec: TVec): auto
func wyzy=[T](vec: var TVec; value: T)
func wyzz(vec: TVec): auto
func wyzz=[T](vec: var TVec; value: T)
func wz(vec: TVec): auto
func wz=[T](vec: var TVec; value: T)
func wzw(vec: TVec): auto
func wzw=[T](vec: var TVec; value: T)
func wzww(vec: TVec): auto
func wzww=[T](vec: var TVec; value: T)
func wzwx(vec: TVec): auto
func wzwx=[T](vec: var TVec; value: T)
func wzwy(vec: TVec): auto
func wzwy=[T](vec: var TVec; value: T)
func wzwz(vec: TVec): auto
func wzwz=[T](vec: var TVec; value: T)
func wzx(vec: TVec): auto
func wzx=[T](vec: var TVec; value: T)
func wzxw(vec: TVec): auto
func wzxw=[T](vec: var TVec; value: T)
func wzxx(vec: TVec): auto
func wzxx=[T](vec: var TVec; value: T)
func wzxy(vec: TVec): auto
func wzxy=[T](vec: var TVec; value: T)
func wzxz(vec: TVec): auto
func wzxz=[T](vec: var TVec; value: T)
func wzy(vec: TVec): auto
func wzy=[T](vec: var TVec; value: T)
func wzyw(vec: TVec): auto
func wzyw=[T](vec: var TVec; value: T)
func wzyx(vec: TVec): auto
func wzyx=[T](vec: var TVec; value: T)
func wzyy(vec: TVec): auto
func wzyy=[T](vec: var TVec; value: T)
func wzyz(vec: TVec): auto
func wzyz=[T](vec: var TVec; value: T)
func wzz(vec: TVec): auto
func wzz=[T](vec: var TVec; value: T)
func wzzw(vec: TVec): auto
func wzzw=[T](vec: var TVec; value: T)
func wzzx(vec: TVec): auto
func wzzx=[T](vec: var TVec; value: T)
func wzzy(vec: TVec): auto
func wzzy=[T](vec: var TVec; value: T)
func wzzz(vec: TVec): auto
func wzzz=[T](vec: var TVec; value: T)
func x(vec: TVec): auto
func x=[T](vec: var TVec; value: T)
func xw(vec: TVec): auto
func xw=[T](vec: var TVec; value: T)
func xww(vec: TVec): auto
func xww=[T](vec: var TVec; value: T)
func xwww(vec: TVec): auto
func xwww=[T](vec: var TVec; value: T)
func xwwx(vec: TVec): auto
func xwwx=[T](vec: var TVec; value: T)
func xwwy(vec: TVec): auto
func xwwy=[T](vec: var TVec; value: T)
func xwwz(vec: TVec): auto
func xwwz=[T](vec: var TVec; value: T)
func xwx(vec: TVec): auto
func xwx=[T](vec: var TVec; value: T)
func xwxw(vec: TVec): auto
func xwxw=[T](vec: var TVec; value: T)
func xwxx(vec: TVec): auto
func xwxx=[T](vec: var TVec; value: T)
func xwxy(vec: TVec): auto
func xwxy=[T](vec: var TVec; value: T)
func xwxz(vec: TVec): auto
func xwxz=[T](vec: var TVec; value: T)
func xwy(vec: TVec): auto
func xwy=[T](vec: var TVec; value: T)
func xwyw(vec: TVec): auto
func xwyw=[T](vec: var TVec; value: T)
func xwyx(vec: TVec): auto
func xwyx=[T](vec: var TVec; value: T)
func xwyy(vec: TVec): auto
func xwyy=[T](vec: var TVec; value: T)
func xwyz(vec: TVec): auto
func xwyz=[T](vec: var TVec; value: T)
func xwz(vec: TVec): auto
func xwz=[T](vec: var TVec; value: T)
func xwzw(vec: TVec): auto
func xwzw=[T](vec: var TVec; value: T)
func xwzx(vec: TVec): auto
func xwzx=[T](vec: var TVec; value: T)
func xwzy(vec: TVec): auto
func xwzy=[T](vec: var TVec; value: T)
func xwzz(vec: TVec): auto
func xwzz=[T](vec: var TVec; value: T)
func xx(vec: TVec): auto
func xx=[T](vec: var TVec; value: T)
func xxw(vec: TVec): auto
func xxw=[T](vec: var TVec; value: T)
func xxww(vec: TVec): auto
func xxww=[T](vec: var TVec; value: T)
func xxwx(vec: TVec): auto
func xxwx=[T](vec: var TVec; value: T)
func xxwy(vec: TVec): auto
func xxwy=[T](vec: var TVec; value: T)
func xxwz(vec: TVec): auto
func xxwz=[T](vec: var TVec; value: T)
func xxx(vec: TVec): auto
func xxx=[T](vec: var TVec; value: T)
func xxxw(vec: TVec): auto
func xxxw=[T](vec: var TVec; value: T)
func xxxx(vec: TVec): auto
func xxxx=[T](vec: var TVec; value: T)
func xxxy(vec: TVec): auto
func xxxy=[T](vec: var TVec; value: T)
func xxxz(vec: TVec): auto
func xxxz=[T](vec: var TVec; value: T)
func xxy(vec: TVec): auto
func xxy=[T](vec: var TVec; value: T)
func xxyw(vec: TVec): auto
func xxyw=[T](vec: var TVec; value: T)
func xxyx(vec: TVec): auto
func xxyx=[T](vec: var TVec; value: T)
func xxyy(vec: TVec): auto
func xxyy=[T](vec: var TVec; value: T)
func xxyz(vec: TVec): auto
func xxyz=[T](vec: var TVec; value: T)
func xxz(vec: TVec): auto
func xxz=[T](vec: var TVec; value: T)
func xxzw(vec: TVec): auto
func xxzw=[T](vec: var TVec; value: T)
func xxzx(vec: TVec): auto
func xxzx=[T](vec: var TVec; value: T)
func xxzy(vec: TVec): auto
func xxzy=[T](vec: var TVec; value: T)
func xxzz(vec: TVec): auto
func xxzz=[T](vec: var TVec; value: T)
func xy(vec: TVec): auto
func xy=[T](vec: var TVec; value: T)
func xyw(vec: TVec): auto
func xyw=[T](vec: var TVec; value: T)
func xyww(vec: TVec): auto
func xyww=[T](vec: var TVec; value: T)
func xywx(vec: TVec): auto
func xywx=[T](vec: var TVec; value: T)
func xywy(vec: TVec): auto
func xywy=[T](vec: var TVec; value: T)
func xywz(vec: TVec): auto
func xywz=[T](vec: var TVec; value: T)
func xyx(vec: TVec): auto
func xyx=[T](vec: var TVec; value: T)
func xyxw(vec: TVec): auto
func xyxw=[T](vec: var TVec; value: T)
func xyxx(vec: TVec): auto
func xyxx=[T](vec: var TVec; value: T)
func xyxy(vec: TVec): auto
func xyxy=[T](vec: var TVec; value: T)
func xyxz(vec: TVec): auto
func xyxz=[T](vec: var TVec; value: T)
func xyy(vec: TVec): auto
func xyy=[T](vec: var TVec; value: T)
func xyyw(vec: TVec): auto
func xyyw=[T](vec: var TVec; value: T)
func xyyx(vec: TVec): auto
func xyyx=[T](vec: var TVec; value: T)
func xyyy(vec: TVec): auto
func xyyy=[T](vec: var TVec; value: T)
func xyyz(vec: TVec): auto
func xyyz=[T](vec: var TVec; value: T)
func xyz(vec: TVec): auto
func xyz=[T](vec: var TVec; value: T)
func xyzw(vec: TVec): auto
func xyzw=[T](vec: var TVec; value: T)
func xyzx(vec: TVec): auto
func xyzx=[T](vec: var TVec; value: T)
func xyzy(vec: TVec): auto
func xyzy=[T](vec: var TVec; value: T)
func xyzz(vec: TVec): auto
func xyzz=[T](vec: var TVec; value: T)
func xz(vec: TVec): auto
func xz=[T](vec: var TVec; value: T)
func xzw(vec: TVec): auto
func xzw=[T](vec: var TVec; value: T)
func xzww(vec: TVec): auto
func xzww=[T](vec: var TVec; value: T)
func xzwx(vec: TVec): auto
func xzwx=[T](vec: var TVec; value: T)
func xzwy(vec: TVec): auto
func xzwy=[T](vec: var TVec; value: T)
func xzwz(vec: TVec): auto
func xzwz=[T](vec: var TVec; value: T)
func xzx(vec: TVec): auto
func xzx=[T](vec: var TVec; value: T)
func xzxw(vec: TVec): auto
func xzxw=[T](vec: var TVec; value: T)
func xzxx(vec: TVec): auto
func xzxx=[T](vec: var TVec; value: T)
func xzxy(vec: TVec): auto
func xzxy=[T](vec: var TVec; value: T)
func xzxz(vec: TVec): auto
func xzxz=[T](vec: var TVec; value: T)
func xzy(vec: TVec): auto
func xzy=[T](vec: var TVec; value: T)
func xzyw(vec: TVec): auto
func xzyw=[T](vec: var TVec; value: T)
func xzyx(vec: TVec): auto
func xzyx=[T](vec: var TVec; value: T)
func xzyy(vec: TVec): auto
func xzyy=[T](vec: var TVec; value: T)
func xzyz(vec: TVec): auto
func xzyz=[T](vec: var TVec; value: T)
func xzz(vec: TVec): auto
func xzz=[T](vec: var TVec; value: T)
func xzzw(vec: TVec): auto
func xzzw=[T](vec: var TVec; value: T)
func xzzx(vec: TVec): auto
func xzzx=[T](vec: var TVec; value: T)
func xzzy(vec: TVec): auto
func xzzy=[T](vec: var TVec; value: T)
func xzzz(vec: TVec): auto
func xzzz=[T](vec: var TVec; value: T)
func y(vec: TVec): auto
func y=[T](vec: var TVec; value: T)
func yw(vec: TVec): auto
func yw=[T](vec: var TVec; value: T)
func yww(vec: TVec): auto
func yww=[T](vec: var TVec; value: T)
func ywww(vec: TVec): auto
func ywww=[T](vec: var TVec; value: T)
func ywwx(vec: TVec): auto
func ywwx=[T](vec: var TVec; value: T)
func ywwy(vec: TVec): auto
func ywwy=[T](vec: var TVec; value: T)
func ywwz(vec: TVec): auto
func ywwz=[T](vec: var TVec; value: T)
func ywx(vec: TVec): auto
func ywx=[T](vec: var TVec; value: T)
func ywxw(vec: TVec): auto
func ywxw=[T](vec: var TVec; value: T)
func ywxx(vec: TVec): auto
func ywxx=[T](vec: var TVec; value: T)
func ywxy(vec: TVec): auto
func ywxy=[T](vec: var TVec; value: T)
func ywxz(vec: TVec): auto
func ywxz=[T](vec: var TVec; value: T)
func ywy(vec: TVec): auto
func ywy=[T](vec: var TVec; value: T)
func ywyw(vec: TVec): auto
func ywyw=[T](vec: var TVec; value: T)
func ywyx(vec: TVec): auto
func ywyx=[T](vec: var TVec; value: T)
func ywyy(vec: TVec): auto
func ywyy=[T](vec: var TVec; value: T)
func ywyz(vec: TVec): auto
func ywyz=[T](vec: var TVec; value: T)
func ywz(vec: TVec): auto
func ywz=[T](vec: var TVec; value: T)
func ywzw(vec: TVec): auto
func ywzw=[T](vec: var TVec; value: T)
func ywzx(vec: TVec): auto
func ywzx=[T](vec: var TVec; value: T)
func ywzy(vec: TVec): auto
func ywzy=[T](vec: var TVec; value: T)
func ywzz(vec: TVec): auto
func ywzz=[T](vec: var TVec; value: T)
func yx(vec: TVec): auto
func yx=[T](vec: var TVec; value: T)
func yxw(vec: TVec): auto
func yxw=[T](vec: var TVec; value: T)
func yxww(vec: TVec): auto
func yxww=[T](vec: var TVec; value: T)
func yxwx(vec: TVec): auto
func yxwx=[T](vec: var TVec; value: T)
func yxwy(vec: TVec): auto
func yxwy=[T](vec: var TVec; value: T)
func yxwz(vec: TVec): auto
func yxwz=[T](vec: var TVec; value: T)
func yxx(vec: TVec): auto
func yxx=[T](vec: var TVec; value: T)
func yxxw(vec: TVec): auto
func yxxw=[T](vec: var TVec; value: T)
func yxxx(vec: TVec): auto
func yxxx=[T](vec: var TVec; value: T)
func yxxy(vec: TVec): auto
func yxxy=[T](vec: var TVec; value: T)
func yxxz(vec: TVec): auto
func yxxz=[T](vec: var TVec; value: T)
func yxy(vec: TVec): auto
func yxy=[T](vec: var TVec; value: T)
func yxyw(vec: TVec): auto
func yxyw=[T](vec: var TVec; value: T)
func yxyx(vec: TVec): auto
func yxyx=[T](vec: var TVec; value: T)
func yxyy(vec: TVec): auto
func yxyy=[T](vec: var TVec; value: T)
func yxyz(vec: TVec): auto
func yxyz=[T](vec: var TVec; value: T)
func yxz(vec: TVec): auto
func yxz=[T](vec: var TVec; value: T)
func yxzw(vec: TVec): auto
func yxzw=[T](vec: var TVec; value: T)
func yxzx(vec: TVec): auto
func yxzx=[T](vec: var TVec; value: T)
func yxzy(vec: TVec): auto
func yxzy=[T](vec: var TVec; value: T)
func yxzz(vec: TVec): auto
func yxzz=[T](vec: var TVec; value: T)
func yy(vec: TVec): auto
func yy=[T](vec: var TVec; value: T)
func yyw(vec: TVec): auto
func yyw=[T](vec: var TVec; value: T)
func yyww(vec: TVec): auto
func yyww=[T](vec: var TVec; value: T)
func yywx(vec: TVec): auto
func yywx=[T](vec: var TVec; value: T)
func yywy(vec: TVec): auto
func yywy=[T](vec: var TVec; value: T)
func yywz(vec: TVec): auto
func yywz=[T](vec: var TVec; value: T)
func yyx(vec: TVec): auto
func yyx=[T](vec: var TVec; value: T)
func yyxw(vec: TVec): auto
func yyxw=[T](vec: var TVec; value: T)
func yyxx(vec: TVec): auto
func yyxx=[T](vec: var TVec; value: T)
func yyxy(vec: TVec): auto
func yyxy=[T](vec: var TVec; value: T)
func yyxz(vec: TVec): auto
func yyxz=[T](vec: var TVec; value: T)
func yyy(vec: TVec): auto
func yyy=[T](vec: var TVec; value: T)
func yyyw(vec: TVec): auto
func yyyw=[T](vec: var TVec; value: T)
func yyyx(vec: TVec): auto
func yyyx=[T](vec: var TVec; value: T)
func yyyy(vec: TVec): auto
func yyyy=[T](vec: var TVec; value: T)
func yyyz(vec: TVec): auto
func yyyz=[T](vec: var TVec; value: T)
func yyz(vec: TVec): auto
func yyz=[T](vec: var TVec; value: T)
func yyzw(vec: TVec): auto
func yyzw=[T](vec: var TVec; value: T)
func yyzx(vec: TVec): auto
func yyzx=[T](vec: var TVec; value: T)
func yyzy(vec: TVec): auto
func yyzy=[T](vec: var TVec; value: T)
func yyzz(vec: TVec): auto
func yyzz=[T](vec: var TVec; value: T)
func yz(vec: TVec): auto
func yz=[T](vec: var TVec; value: T)
func yzw(vec: TVec): auto
func yzw=[T](vec: var TVec; value: T)
func yzww(vec: TVec): auto
func yzww=[T](vec: var TVec; value: T)
func yzwx(vec: TVec): auto
func yzwx=[T](vec: var TVec; value: T)
func yzwy(vec: TVec): auto
func yzwy=[T](vec: var TVec; value: T)
func yzwz(vec: TVec): auto
func yzwz=[T](vec: var TVec; value: T)
func yzx(vec: TVec): auto
func yzx=[T](vec: var TVec; value: T)
func yzxw(vec: TVec): auto
func yzxw=[T](vec: var TVec; value: T)
func yzxx(vec: TVec): auto
func yzxx=[T](vec: var TVec; value: T)
func yzxy(vec: TVec): auto
func yzxy=[T](vec: var TVec; value: T)
func yzxz(vec: TVec): auto
func yzxz=[T](vec: var TVec; value: T)
func yzy(vec: TVec): auto
func yzy=[T](vec: var TVec; value: T)
func yzyw(vec: TVec): auto
func yzyw=[T](vec: var TVec; value: T)
func yzyx(vec: TVec): auto
func yzyx=[T](vec: var TVec; value: T)
func yzyy(vec: TVec): auto
func yzyy=[T](vec: var TVec; value: T)
func yzyz(vec: TVec): auto
func yzyz=[T](vec: var TVec; value: T)
func yzz(vec: TVec): auto
func yzz=[T](vec: var TVec; value: T)
func yzzw(vec: TVec): auto
func yzzw=[T](vec: var TVec; value: T)
func yzzx(vec: TVec): auto
func yzzx=[T](vec: var TVec; value: T)
func yzzy(vec: TVec): auto
func yzzy=[T](vec: var TVec; value: T)
func yzzz(vec: TVec): auto
func yzzz=[T](vec: var TVec; value: T)
func z(vec: TVec): auto
func z=[T](vec: var TVec; value: T)
func zw(vec: TVec): auto
func zw=[T](vec: var TVec; value: T)
func zww(vec: TVec): auto
func zww=[T](vec: var TVec; value: T)
func zwww(vec: TVec): auto
func zwww=[T](vec: var TVec; value: T)
func zwwx(vec: TVec): auto
func zwwx=[T](vec: var TVec; value: T)
func zwwy(vec: TVec): auto
func zwwy=[T](vec: var TVec; value: T)
func zwwz(vec: TVec): auto
func zwwz=[T](vec: var TVec; value: T)
func zwx(vec: TVec): auto
func zwx=[T](vec: var TVec; value: T)
func zwxw(vec: TVec): auto
func zwxw=[T](vec: var TVec; value: T)
func zwxx(vec: TVec): auto
func zwxx=[T](vec: var TVec; value: T)
func zwxy(vec: TVec): auto
func zwxy=[T](vec: var TVec; value: T)
func zwxz(vec: TVec): auto
func zwxz=[T](vec: var TVec; value: T)
func zwy(vec: TVec): auto
func zwy=[T](vec: var TVec; value: T)
func zwyw(vec: TVec): auto
func zwyw=[T](vec: var TVec; value: T)
func zwyx(vec: TVec): auto
func zwyx=[T](vec: var TVec; value: T)
func zwyy(vec: TVec): auto
func zwyy=[T](vec: var TVec; value: T)
func zwyz(vec: TVec): auto
func zwyz=[T](vec: var TVec; value: T)
func zwz(vec: TVec): auto
func zwz=[T](vec: var TVec; value: T)
func zwzw(vec: TVec): auto
func zwzw=[T](vec: var TVec; value: T)
func zwzx(vec: TVec): auto
func zwzx=[T](vec: var TVec; value: T)
func zwzy(vec: TVec): auto
func zwzy=[T](vec: var TVec; value: T)
func zwzz(vec: TVec): auto
func zwzz=[T](vec: var TVec; value: T)
func zx(vec: TVec): auto
func zx=[T](vec: var TVec; value: T)
func zxw(vec: TVec): auto
func zxw=[T](vec: var TVec; value: T)
func zxww(vec: TVec): auto
func zxww=[T](vec: var TVec; value: T)
func zxwx(vec: TVec): auto
func zxwx=[T](vec: var TVec; value: T)
func zxwy(vec: TVec): auto
func zxwy=[T](vec: var TVec; value: T)
func zxwz(vec: TVec): auto
func zxwz=[T](vec: var TVec; value: T)
func zxx(vec: TVec): auto
func zxx=[T](vec: var TVec; value: T)
func zxxw(vec: TVec): auto
func zxxw=[T](vec: var TVec; value: T)
func zxxx(vec: TVec): auto
func zxxx=[T](vec: var TVec; value: T)
func zxxy(vec: TVec): auto
func zxxy=[T](vec: var TVec; value: T)
func zxxz(vec: TVec): auto
func zxxz=[T](vec: var TVec; value: T)
func zxy(vec: TVec): auto
func zxy=[T](vec: var TVec; value: T)
func zxyw(vec: TVec): auto
func zxyw=[T](vec: var TVec; value: T)
func zxyx(vec: TVec): auto
func zxyx=[T](vec: var TVec; value: T)
func zxyy(vec: TVec): auto
func zxyy=[T](vec: var TVec; value: T)
func zxyz(vec: TVec): auto
func zxyz=[T](vec: var TVec; value: T)
func zxz(vec: TVec): auto
func zxz=[T](vec: var TVec; value: T)
func zxzw(vec: TVec): auto
func zxzw=[T](vec: var TVec; value: T)
func zxzx(vec: TVec): auto
func zxzx=[T](vec: var TVec; value: T)
func zxzy(vec: TVec): auto
func zxzy=[T](vec: var TVec; value: T)
func zxzz(vec: TVec): auto
func zxzz=[T](vec: var TVec; value: T)
func zy(vec: TVec): auto
func zy=[T](vec: var TVec; value: T)
func zyw(vec: TVec): auto
func zyw=[T](vec: var TVec; value: T)
func zyww(vec: TVec): auto
func zyww=[T](vec: var TVec; value: T)
func zywx(vec: TVec): auto
func zywx=[T](vec: var TVec; value: T)
func zywy(vec: TVec): auto
func zywy=[T](vec: var TVec; value: T)
func zywz(vec: TVec): auto
func zywz=[T](vec: var TVec; value: T)
func zyx(vec: TVec): auto
func zyx=[T](vec: var TVec; value: T)
func zyxw(vec: TVec): auto
func zyxw=[T](vec: var TVec; value: T)
func zyxx(vec: TVec): auto
func zyxx=[T](vec: var TVec; value: T)
func zyxy(vec: TVec): auto
func zyxy=[T](vec: var TVec; value: T)
func zyxz(vec: TVec): auto
func zyxz=[T](vec: var TVec; value: T)
func zyy(vec: TVec): auto
func zyy=[T](vec: var TVec; value: T)
func zyyw(vec: TVec): auto
func zyyw=[T](vec: var TVec; value: T)
func zyyx(vec: TVec): auto
func zyyx=[T](vec: var TVec; value: T)
func zyyy(vec: TVec): auto
func zyyy=[T](vec: var TVec; value: T)
func zyyz(vec: TVec): auto
func zyyz=[T](vec: var TVec; value: T)
func zyz(vec: TVec): auto
func zyz=[T](vec: var TVec; value: T)
func zyzw(vec: TVec): auto
func zyzw=[T](vec: var TVec; value: T)
func zyzx(vec: TVec): auto
func zyzx=[T](vec: var TVec; value: T)
func zyzy(vec: TVec): auto
func zyzy=[T](vec: var TVec; value: T)
func zyzz(vec: TVec): auto
func zyzz=[T](vec: var TVec; value: T)
func zz(vec: TVec): auto
func zz=[T](vec: var TVec; value: T)
func zzw(vec: TVec): auto
func zzw=[T](vec: var TVec; value: T)
func zzww(vec: TVec): auto
func zzww=[T](vec: var TVec; value: T)
func zzwx(vec: TVec): auto
func zzwx=[T](vec: var TVec; value: T)
func zzwy(vec: TVec): auto
func zzwy=[T](vec: var TVec; value: T)
func zzwz(vec: TVec): auto
func zzwz=[T](vec: var TVec; value: T)
func zzx(vec: TVec): auto
func zzx=[T](vec: var TVec; value: T)
func zzxw(vec: TVec): auto
func zzxw=[T](vec: var TVec; value: T)
func zzxx(vec: TVec): auto
func zzxx=[T](vec: var TVec; value: T)
func zzxy(vec: TVec): auto
func zzxy=[T](vec: var TVec; value: T)
func zzxz(vec: TVec): auto
func zzxz=[T](vec: var TVec; value: T)
func zzy(vec: TVec): auto
func zzy=[T](vec: var TVec; value: T)
func zzyw(vec: TVec): auto
func zzyw=[T](vec: var TVec; value: T)
func zzyx(vec: TVec): auto
func zzyx=[T](vec: var TVec; value: T)
func zzyy(vec: TVec): auto
func zzyy=[T](vec: var TVec; value: T)
func zzyz(vec: TVec): auto
func zzyz=[T](vec: var TVec; value: T)
func zzz(vec: TVec): auto
func zzz=[T](vec: var TVec; value: T)
func zzzw(vec: TVec): auto
func zzzw=[T](vec: var TVec; value: T)
func zzzx(vec: TVec): auto
func zzzx=[T](vec: var TVec; value: T)
func zzzy(vec: TVec): auto
func zzzy=[T](vec: var TVec; value: T)
func zzzz(vec: TVec): auto
func zzzz=[T](vec: var TVec; value: T)

Iterators

iterator litems[IX, T](a: array[IX, T]): lent T {.inline.}
Iterates over each item of a.

Templates

template ColumnCount(m: typedesc): int
template RowCount(m: typedesc): int
template TimeAndLog(body: untyped): untyped
template TimeAndLog(name: string; body: untyped): untyped

Made with Nim. Generated: 2024-11-05 16:28:31 UTC