VMath

Collection of math routines for 2d and 3d graphics.

Has functions for Vec2, Vec3, Vec4, Mat3, Mat4 and Quat.

API: vmath

import vmath

proc clamp

Clamps n to min, else returns max if n is higher.

proc clamp(n, min, max: float32): float32

proc between

Returns true if value is between min and max or equal to them.

proc between(value, min, max: float32): bool

proc sign

Returns the sign of a number, -1 or 1.

proc sign(v: float32): float32

proc quantize

Makes v be multipe of n. Rounding to integer quantize by 1.0.

proc quantize(v: float32; n: float32): float32

proc lerp

Interpolates value between a and b.

• 0 -> a
• 1 -> b
• 0.5 -> between a and b

proc lerp(a: float32; b: float32; v: float32): float32

type Vec2

2D vector

Vec2 = object
 x*: float32
 y*: float32

proc vec2

proc vec2(x, y: float32): Vec2

proc vec2

proc vec2(a: Vec2): Vec2

proc +

proc `+`(a: Vec2; b: Vec2): Vec2

proc -

proc `-`(a: Vec2; b: Vec2): Vec2

proc *

proc `*`(a: Vec2; b: float32): Vec2

proc *

proc `*`(a: float32; b: Vec2): Vec2

proc /

proc `/`(a: Vec2; b: float32): Vec2

proc +=

proc `+=`(a: var Vec2; b: Vec2)

proc -=

proc `-=`(a: var Vec2; b: Vec2)

proc *=

proc `*=`(a: var Vec2; b: float32)

proc /=

proc `/=`(a: var Vec2; b: float32)

proc zero

proc zero(a: var Vec2)

proc -

proc `-`(a: Vec2): Vec2

proc lengthSq

proc lengthSq(a: Vec2): float32

proc length

proc length(a: Vec2): float32

proc length=

proc length=(a: var Vec2; b: float32)

proc normalize

proc normalize(a: Vec2): Vec2

proc dot

proc dot(a: Vec2; b: Vec2): float32

proc dir

proc dir(at: Vec2; to: Vec2): Vec2

proc dir

proc dir(th: float32): Vec2

proc dist

proc dist(at: Vec2; to: Vec2): float32

proc distSq

proc distSq(at: Vec2; to: Vec2): float32

proc lerp

proc lerp(a: Vec2; b: Vec2; v: float32): Vec2

proc quantize

proc quantize(v: Vec2; n: float32): Vec2

proc inRect

Check to see if v is inside a rectange formed by a and b. It does not matter how a and b are arranged.

proc inRect(v: Vec2; a: Vec2; b: Vec2): bool

proc []

proc `[]`(a: Vec2; i: int): float32

proc []=

proc `[]=`(a: var Vec2; i: int; b: float32)

proc randVec2

proc randVec2(): Vec2

proc $

proc `$`(a: Vec2): string

proc fixAngle

Make angle be from -PI to PI radians.

proc fixAngle(angle: float32): float32

proc angle

Angle of a Vec2.

proc angle(a: Vec2): float32

proc angleBetween

Angle between 2 Vec2.

proc angleBetween(a: Vec2; b: Vec2): float32

proc angleBetween

Angle between angle a and angle b.

proc angleBetween(a, b: float32): float32

proc turnAngle

Move from angle a to angle b with step of v.

proc turnAngle(a, b, speed: float32): float32

type Vec3

3D vector

Vec3 = object
 x*: float32
 y*: float32
 z*: float32

proc vec3

proc vec3(x, y, z: float32): Vec3

proc vec3

proc vec3(a: Vec3): Vec3

const X_DIR

X_DIR = (x: 1.0, y: 0.0, z: 0.0)

const Y_DIR

Y_DIR = (x: 0.0, y: 1.0, z: 0.0)

const Z_DIR

Z_DIR = (x: 0.0, y: 0.0, z: 1.0)

proc +

proc `+`(a: Vec3; b: Vec3): Vec3

proc -

proc `-`(a: Vec3; b: Vec3): Vec3

proc -

proc `-`(a: Vec3): Vec3

proc *

proc `*`(a: Vec3; b: float32): Vec3

proc *

proc `*`(a: float32; b: Vec3): Vec3

proc /

proc `/`(a: Vec3; b: float32): Vec3

proc /

proc `/`(a: float32; b: Vec3): Vec3

proc +=

proc `+=`(a: var Vec3; b: Vec3)

proc -=

proc `-=`(a: var Vec3; b: Vec3)

proc *=

proc `*=`(a: var Vec3; b: float32)

proc /=

proc `/=`(a: var Vec3; b: float32)

proc zero

proc zero(a: var Vec3)

proc -

proc `-`(a: var Vec3): Vec3

proc lengthSq

proc lengthSq(a: Vec3): float32

proc length

proc length(a: Vec3): float32

proc length=

proc length=(a: var Vec3; b: float32)

proc normalize

proc normalize(a: Vec3): Vec3

proc cross

proc cross(a: Vec3; b: Vec3): Vec3

proc computeNormal

proc computeNormal(a, b, c: Vec3): Vec3

proc dot

proc dot(a: Vec3; b: Vec3): float32

proc dir

proc dir(at: Vec3; to: Vec3): Vec3

proc dist

proc dist(at: Vec3; to: Vec3): float32

proc distSq

proc distSq(at: Vec3; to: Vec3): float32

proc lerp

proc lerp(a: Vec3; b: Vec3; v: float32): Vec3

proc angleBetween

proc angleBetween(a, b: Vec3): float32

proc []

proc `[]`(a: Vec3; i: int): float32

proc []=

proc `[]=`(a: var Vec3; i: int; b: float32)

proc xy

proc xy(a: Vec3): Vec2

proc xz

proc xz(a: Vec3): Vec2

proc yx

proc yx(a: Vec3): Vec2

proc yz

proc yz(a: Vec3): Vec2

proc zx

proc zx(a: Vec3): Vec2

proc zy

proc zy(a: Vec3): Vec2

proc almostEquals

proc almostEquals(a, b: Vec3; precision = 1e-006): bool

proc randVec3

Generates a random vector based on http://mathworld.wolfram.com/SpherePointPicking.html

proc randVec3(): Vec3

proc $

proc `$`(a: Vec3): string

type Vec4

4D Vector.

Vec4 = object
 x*: float32
 y*: float32
 z*: float32
 w*: float32

proc vec4

proc vec4(x, y, z, w: float32): Vec4

proc +

proc `+`(a: Vec4; b: Vec4): Vec4

proc -

proc `-`(a: Vec4; b: Vec4): Vec4

proc -

proc `-`(a: Vec4): Vec4

proc *

proc `*`(a: Vec4; b: float32): Vec4

proc *

proc `*`(a: float32; b: Vec4): Vec4

proc /

proc `/`(a: Vec4; b: float32): Vec4

proc /

proc `/`(a: float32; b: Vec4): Vec4

proc +=

proc `+=`(a: var Vec4; b: Vec4)

proc -=

proc `-=`(a: var Vec4; b: Vec4)

proc *=

proc `*=`(a: var Vec4; b: float32)

proc /=

proc `/=`(a: var Vec4; b: float32)

proc zero

proc zero(a: var Vec4)

proc xyz

proc xyz(a: Vec4): Vec3

proc $

proc `$`(a: Vec4): string

proc vec3

proc vec3(a: Vec2; z = 0.0): Vec3

proc vec4

proc vec4(a: Vec3; w = 0.0): Vec4

proc vec4

proc vec4(a: Vec2; z = 0.0; w = 0.0): Vec4

type Mat3

3x3 Matrix

Mat3 = array[9, float32]

proc mat3

proc mat3(a, b, c, d, e, f, g, h, i: float32): Mat3

proc mat3

proc mat3(a: Mat3): Mat3

proc identity

proc identity(a: var Mat3)

proc mat3

proc mat3(): Mat3

proc transpose

proc transpose(a: Mat3): Mat3

proc $

proc `$`(a: Mat3): string

proc *

proc `*`(a: Mat3; b: Mat3): Mat3

proc *

proc `*`(m: Mat3; v: Vec3): Vec3

proc scale

proc scale(a: Mat3; v: Vec2): Mat3

proc scale

proc scale(a: Mat3; v: Vec3): Mat3

proc rotationMat3

proc rotationMat3(angle: float32): Mat3

proc rotate

proc rotate(a: Mat3; angle: float32): Mat3

proc *

proc `*`(a: Mat3; b: Vec2): Vec2

type Mat4

4x4 Matrix - OpenGL row order

Mat4 = array[16, float32]

proc mat4

proc mat4(v0, v1, Vec2, Vec3, Vec4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15: float32): Mat4

proc mat4

proc mat4(a: Mat4): Mat4

proc identity

proc identity(): Mat4

proc mat4

proc mat4(): Mat4

proc transpose

proc transpose(a: Mat4): Mat4

proc determinant

proc determinant(a: Mat4): float32

proc inverse

proc inverse(a: Mat4): Mat4

proc *

proc `*`(a, b: Mat4): Mat4

proc *

proc `*`(a: Mat4; b: Vec3): Vec3

proc right

proc right(a: Mat4): Vec3

proc right=

proc right=(a: var Mat4; b: Vec3)

proc up

proc up(a: Mat4): Vec3

proc up=

proc up=(a: var Mat4; b: Vec3)

proc fov

proc fov(a: Mat4): Vec3

proc fov=

proc fov=(a: var Mat4; b: Vec3)

proc pos

proc pos(a: Mat4): Vec3

proc pos=

proc pos=(a: var Mat4; b: Vec3)

proc rotationOnly

proc rotationOnly(a: Mat4): Mat4

proc dist

proc dist(a, b: Mat4): float32

proc translate

proc translate(v: Vec3): Mat4

proc scale

proc scale(v: Vec3): Mat4

proc close

proc close(a: Mat4; b: Mat4): bool

proc hrp

proc hrp(m: Mat4): Vec3

proc frustum

proc frustum(left, right, bottom, top, near, far: float32): Mat4

proc perspective

proc perspective(fovy, aspect, near, far: float32): Mat4

proc ortho

proc ortho(left, right, bottom, top, near, far: float32): Mat4

proc lookAt

proc lookAt(eye, center, up: Vec3): Mat4

proc tofloat32

proc tofloat32(m: Mat4): array[16, float32]

proc $

proc `$`(a: Mat4): string

type Quat

Quat = object
 x*: float32
 y*: float32
 z*: float32
 w*: float32

proc quat

proc quat(x, y, z, w: float32): Quat

proc conjugate

proc conjugate(q: Quat): Quat

proc length

proc length(q: Quat): float32

proc normalize

proc normalize(q: Quat): Quat

proc xyz

proc xyz(q: Quat): Vec3

proc xyz=

proc xyz=(q: var Quat; v: Vec3)

proc *

Multiply the quaternion by a quaternion.

proc `*`(a, b: Quat): Quat

proc *

Multiply the quaternion by a float32.

proc `*`(q: Quat; v: float32): Quat

proc *

Multiply the quaternion by a vector.

proc `*`(q: Quat; v: Vec3): Vec3

proc mat3

proc mat3(q: Quat): Mat3

proc mat4

proc mat4(q: Quat): Mat4

proc reciprocalSqrt

proc reciprocalSqrt(x: float32): float32

proc quat

proc quat(m: Mat4): Quat

proc fromAxisAngle

proc fromAxisAngle(axis: Vec3; angle: float32): Quat

proc toAxisAngle

proc toAxisAngle(q: Quat; axis: var Vec3; angle: var float32)

proc quat

proc quat(heading, pitch, roll: float32): Quat

proc hrp

proc hrp(q: Quat): Vec3

proc $

proc `$`(a: Quat): string

proc rotate

proc rotate(angle: float32; axis: Vec3): Mat4

proc rotateX

proc rotateX(angle: float32): Mat4

proc rotateY

proc rotateY(angle: float32): Mat4

proc rotateZ

proc rotateZ(angle: float32): Mat4

proc scaleMat

proc scaleMat(scale: Vec3): Mat4

proc scaleMat

proc scaleMat(scale: float32): Mat4

type Rect

Rect = object
 x*: float32
 y*: float32
 w*: float32
 h*: float32

proc rect

proc rect(x, y, w, h: float32): Rect

proc rect

proc rect(pos, size: Vec2): Rect

proc xy

Gets the xy as a Vec2.

proc xy(rect: Rect): Vec2

proc xy=

Sets the xy from Vec2.

proc xy=(rect: var Rect; v: Vec2)

proc wh

Gets the wh as a Vec2.

proc wh(rect: Rect): Vec2

proc wh=

Sets the wh from Vec2.

proc wh=(rect: var Rect; v: Vec2)

proc *

• all elements of a Rect.

proc `*`(r: Rect; v: float): Rect

proc /

/ all elements of a Rect.

proc `/`(r: Rect; v: float): Rect

proc +

Add two boxes together.

proc `+`(a, b: Rect): Rect

proc $

proc `$`(a: Rect): string

proc inside

Checks if pos is inside rect.

proc inside(pos: Vec2; rect: Rect): bool

proc overlap

Returns true if box a overlaps box b.

proc overlap(a, b: Rect): bool