1564 lines
16 KiB
Markdown
1564 lines
16 KiB
Markdown
# VMath
|
|
|
|
Collection of math routines for 2d and 3d graphics.
|
|
|
|
Has functions for Vec2, Vec3, Vec4, Mat3, Mat4 and Quat.
|
|
|
|
# API: vmath
|
|
|
|
```nim
|
|
import vmath
|
|
```
|
|
|
|
## **func** between
|
|
|
|
Returns true if value is between min and max or equal to them.
|
|
|
|
```nim
|
|
func between(value, min, max: float32): bool
|
|
```
|
|
|
|
## **func** sign
|
|
|
|
Returns the sign of a number, -1 or 1.
|
|
|
|
```nim
|
|
func sign(v: float32): float32
|
|
```
|
|
|
|
## **func** quantize
|
|
|
|
Makes v be multipe of n. Rounding to integer quantize by 1.0.
|
|
|
|
```nim
|
|
func quantize(v: float32; n: float32): float32
|
|
```
|
|
|
|
## **func** lerp
|
|
|
|
Interpolates value between a and b.
|
|
* 0 -> a
|
|
* 1 -> b
|
|
* 0.5 -> between a and b
|
|
|
|
```nim
|
|
func lerp(a: float32; b: float32; v: float32): float32
|
|
```
|
|
|
|
## **type** Vec2
|
|
|
|
2D vector
|
|
|
|
```nim
|
|
Vec2 = object
|
|
x*: float32
|
|
y*: float32
|
|
```
|
|
|
|
## **func** vec2
|
|
|
|
|
|
```nim
|
|
func vec2(x, y: float32): Vec2
|
|
```
|
|
|
|
## **func** vec2
|
|
|
|
|
|
```nim
|
|
func vec2(v: float32): Vec2
|
|
```
|
|
|
|
## **func** vec2
|
|
|
|
|
|
```nim
|
|
func vec2(a: Vec2): Vec2
|
|
```
|
|
|
|
## **func** `+`
|
|
|
|
|
|
```nim
|
|
func `+`(a: Vec2; b: Vec2): Vec2
|
|
```
|
|
|
|
## **func** `-`
|
|
|
|
|
|
```nim
|
|
func `-`(a: Vec2; b: Vec2): Vec2
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: Vec2; b: float32): Vec2
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: float32; b: Vec2): Vec2
|
|
```
|
|
|
|
## **func** `/`
|
|
|
|
|
|
```nim
|
|
func `/`(a: Vec2; b: float32): Vec2
|
|
```
|
|
|
|
## **func** `+=`
|
|
|
|
|
|
```nim
|
|
func `+=`(a: var Vec2; b: Vec2)
|
|
```
|
|
|
|
## **func** `-=`
|
|
|
|
|
|
```nim
|
|
func `-=`(a: var Vec2; b: Vec2)
|
|
```
|
|
|
|
## **func** `*=`
|
|
|
|
|
|
```nim
|
|
func `*=`(a: var Vec2; b: float32)
|
|
```
|
|
|
|
## **func** `/=`
|
|
|
|
|
|
```nim
|
|
func `/=`(a: var Vec2; b: float32)
|
|
```
|
|
|
|
## **func** zero
|
|
|
|
|
|
```nim
|
|
func zero(a: var Vec2)
|
|
```
|
|
|
|
## **func** `-`
|
|
|
|
|
|
```nim
|
|
func `-`(a: Vec2): Vec2
|
|
```
|
|
|
|
## **func** hash
|
|
|
|
|
|
```nim
|
|
func hash(a: Vec2): Hash
|
|
```
|
|
|
|
## **func** lengthSq
|
|
|
|
|
|
```nim
|
|
func lengthSq(a: Vec2): float32
|
|
```
|
|
|
|
## **func** length
|
|
|
|
|
|
```nim
|
|
func length(a: Vec2): float32
|
|
```
|
|
|
|
## **func** length=
|
|
|
|
|
|
```nim
|
|
func length=(a: var Vec2; b: float32)
|
|
```
|
|
|
|
## **func** normalize
|
|
|
|
|
|
```nim
|
|
func normalize(a: Vec2): Vec2
|
|
```
|
|
|
|
## **func** dot
|
|
|
|
|
|
```nim
|
|
func dot(a: Vec2; b: Vec2): float32
|
|
```
|
|
|
|
## **func** dir
|
|
|
|
|
|
```nim
|
|
func dir(at: Vec2; to: Vec2): Vec2
|
|
```
|
|
|
|
## **func** dir
|
|
|
|
|
|
```nim
|
|
func dir(th: float32): Vec2
|
|
```
|
|
|
|
## **func** dist
|
|
|
|
|
|
```nim
|
|
func dist(at: Vec2; to: Vec2): float32
|
|
```
|
|
|
|
## **func** distSq
|
|
|
|
|
|
```nim
|
|
func distSq(at: Vec2; to: Vec2): float32
|
|
```
|
|
|
|
## **func** lerp
|
|
|
|
|
|
```nim
|
|
func lerp(a: Vec2; b: Vec2; v: float32): Vec2
|
|
```
|
|
|
|
## **func** quantize
|
|
|
|
|
|
```nim
|
|
func quantize(v: Vec2; n: float32): Vec2
|
|
```
|
|
|
|
## **func** 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.
|
|
|
|
```nim
|
|
func inRect(v: Vec2; a: Vec2; b: Vec2): bool
|
|
```
|
|
|
|
## **func** `[]`
|
|
|
|
|
|
```nim
|
|
func `[]`(a: Vec2; i: int): float32
|
|
```
|
|
|
|
## **func** `[]=`
|
|
|
|
|
|
```nim
|
|
func `[]=`(a: var Vec2; i: int; b: float32)
|
|
```
|
|
|
|
## **proc** randVec2
|
|
|
|
|
|
```nim
|
|
proc randVec2(): Vec2
|
|
```
|
|
|
|
## **func** `$`
|
|
|
|
|
|
```nim
|
|
func `$`(a: Vec2): string {.raises: [ValueError].}
|
|
```
|
|
|
|
## **func** fixAngle
|
|
|
|
Make angle be from -PI to PI radians.
|
|
|
|
```nim
|
|
func fixAngle(angle: float32): float32
|
|
```
|
|
|
|
## **func** angle
|
|
|
|
Angle of a Vec2.
|
|
|
|
```nim
|
|
func angle(a: Vec2): float32
|
|
```
|
|
|
|
## **func** angleBetween
|
|
|
|
Angle between 2 Vec2.
|
|
|
|
```nim
|
|
func angleBetween(a: Vec2; b: Vec2): float32
|
|
```
|
|
|
|
## **func** angleBetween
|
|
|
|
Angle between angle a and angle b.
|
|
|
|
```nim
|
|
func angleBetween(a, b: float32): float32
|
|
```
|
|
|
|
## **func** turnAngle
|
|
|
|
Move from angle a to angle b with step of v.
|
|
|
|
```nim
|
|
func turnAngle(a, b, speed: float32): float32
|
|
```
|
|
|
|
## **type** Vec3
|
|
|
|
3D vector
|
|
|
|
```nim
|
|
Vec3 = object
|
|
x*: float32
|
|
y*: float32
|
|
z*: float32
|
|
```
|
|
|
|
## **func** vec3
|
|
|
|
|
|
```nim
|
|
func vec3(x, y, z: float32): Vec3
|
|
```
|
|
|
|
## **func** vec3
|
|
|
|
|
|
```nim
|
|
func vec3(v: float32): Vec3
|
|
```
|
|
|
|
## **func** vec3
|
|
|
|
|
|
```nim
|
|
func vec3(a: Vec3): Vec3
|
|
```
|
|
|
|
## **const** X_DIR
|
|
|
|
|
|
```nim
|
|
X_DIR = (x: 1.0, y: 0.0, z: 0.0)
|
|
```
|
|
|
|
## **const** Y_DIR
|
|
|
|
|
|
```nim
|
|
Y_DIR = (x: 0.0, y: 1.0, z: 0.0)
|
|
```
|
|
|
|
## **const** Z_DIR
|
|
|
|
|
|
```nim
|
|
Z_DIR = (x: 0.0, y: 0.0, z: 1.0)
|
|
```
|
|
|
|
## **func** `+`
|
|
|
|
|
|
```nim
|
|
func `+`(a: Vec3; b: Vec3): Vec3
|
|
```
|
|
|
|
## **func** `-`
|
|
|
|
|
|
```nim
|
|
func `-`(a: Vec3; b: Vec3): Vec3
|
|
```
|
|
|
|
## **func** `-`
|
|
|
|
|
|
```nim
|
|
func `-`(a: Vec3): Vec3
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: Vec3; b: float32): Vec3
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: float32; b: Vec3): Vec3
|
|
```
|
|
|
|
## **func** `/`
|
|
|
|
|
|
```nim
|
|
func `/`(a: Vec3; b: float32): Vec3
|
|
```
|
|
|
|
## **func** `/`
|
|
|
|
|
|
```nim
|
|
func `/`(a: float32; b: Vec3): Vec3
|
|
```
|
|
|
|
## **func** `+=`
|
|
|
|
|
|
```nim
|
|
func `+=`(a: var Vec3; b: Vec3)
|
|
```
|
|
|
|
## **func** `-=`
|
|
|
|
|
|
```nim
|
|
func `-=`(a: var Vec3; b: Vec3)
|
|
```
|
|
|
|
## **func** `*=`
|
|
|
|
|
|
```nim
|
|
func `*=`(a: var Vec3; b: float32)
|
|
```
|
|
|
|
## **func** `/=`
|
|
|
|
|
|
```nim
|
|
func `/=`(a: var Vec3; b: float32)
|
|
```
|
|
|
|
## **func** zero
|
|
|
|
|
|
```nim
|
|
func zero(a: var Vec3)
|
|
```
|
|
|
|
## **func** `-`
|
|
|
|
|
|
```nim
|
|
func `-`(a: var Vec3): Vec3
|
|
```
|
|
|
|
## **func** hash
|
|
|
|
|
|
```nim
|
|
func hash(a: Vec3): Hash
|
|
```
|
|
|
|
## **func** lengthSq
|
|
|
|
|
|
```nim
|
|
func lengthSq(a: Vec3): float32
|
|
```
|
|
|
|
## **func** length
|
|
|
|
|
|
```nim
|
|
func length(a: Vec3): float32
|
|
```
|
|
|
|
## **func** length=
|
|
|
|
|
|
```nim
|
|
func length=(a: var Vec3; b: float32)
|
|
```
|
|
|
|
## **func** floor
|
|
|
|
|
|
```nim
|
|
func floor(a: Vec3): Vec3
|
|
```
|
|
|
|
## **func** round
|
|
|
|
|
|
```nim
|
|
func round(a: Vec3): Vec3
|
|
```
|
|
|
|
## **func** ceil
|
|
|
|
|
|
```nim
|
|
func ceil(a: Vec3): Vec3
|
|
```
|
|
|
|
## **func** normalize
|
|
|
|
|
|
```nim
|
|
func normalize(a: Vec3): Vec3
|
|
```
|
|
|
|
## **func** cross
|
|
|
|
|
|
```nim
|
|
func cross(a: Vec3; b: Vec3): Vec3
|
|
```
|
|
|
|
## **func** computeNormal
|
|
|
|
|
|
```nim
|
|
func computeNormal(a, b, c: Vec3): Vec3
|
|
```
|
|
|
|
## **func** dot
|
|
|
|
|
|
```nim
|
|
func dot(a: Vec3; b: Vec3): float32
|
|
```
|
|
|
|
## **func** dir
|
|
|
|
|
|
```nim
|
|
func dir(at: Vec3; to: Vec3): Vec3
|
|
```
|
|
|
|
## **func** dist
|
|
|
|
|
|
```nim
|
|
func dist(at: Vec3; to: Vec3): float32
|
|
```
|
|
|
|
## **func** distSq
|
|
|
|
|
|
```nim
|
|
func distSq(at: Vec3; to: Vec3): float32
|
|
```
|
|
|
|
## **func** lerp
|
|
|
|
|
|
```nim
|
|
func lerp(a: Vec3; b: Vec3; v: float32): Vec3
|
|
```
|
|
|
|
## **func** quantize
|
|
|
|
|
|
```nim
|
|
func quantize(v: Vec3; n: float32): Vec3
|
|
```
|
|
|
|
## **func** angleBetween
|
|
|
|
|
|
```nim
|
|
func angleBetween(a, b: Vec3): float32
|
|
```
|
|
|
|
## **func** `[]`
|
|
|
|
|
|
```nim
|
|
func `[]`(a: Vec3; i: int): float32
|
|
```
|
|
|
|
## **func** `[]=`
|
|
|
|
|
|
```nim
|
|
func `[]=`(a: var Vec3; i: int; b: float32)
|
|
```
|
|
|
|
## **func** xy
|
|
|
|
|
|
```nim
|
|
func xy(a: Vec3): Vec2
|
|
```
|
|
|
|
## **func** xz
|
|
|
|
|
|
```nim
|
|
func xz(a: Vec3): Vec2
|
|
```
|
|
|
|
## **func** yx
|
|
|
|
|
|
```nim
|
|
func yx(a: Vec3): Vec2
|
|
```
|
|
|
|
## **func** yz
|
|
|
|
|
|
```nim
|
|
func yz(a: Vec3): Vec2
|
|
```
|
|
|
|
## **func** zx
|
|
|
|
|
|
```nim
|
|
func zx(a: Vec3): Vec2
|
|
```
|
|
|
|
## **func** zy
|
|
|
|
|
|
```nim
|
|
func zy(a: Vec3): Vec2
|
|
```
|
|
|
|
## **func** almostEquals
|
|
|
|
|
|
```nim
|
|
func almostEquals(a, b: Vec3; precision = 1e-006): bool
|
|
```
|
|
|
|
## **proc** randVec3
|
|
|
|
Generates a random unit vector based on <a class="reference external" href="http://mathworld.wolfram.com/SpherePointPicking.html">http://mathworld.wolfram.com/SpherePointPicking.html</a>
|
|
|
|
```nim
|
|
proc randVec3(): Vec3
|
|
```
|
|
|
|
## **func** `$`
|
|
|
|
|
|
```nim
|
|
func `$`(a: Vec3): string {.raises: [ValueError].}
|
|
```
|
|
|
|
## **type** Vec4
|
|
|
|
4D Vector.
|
|
|
|
```nim
|
|
Vec4 = object
|
|
x*: float32
|
|
y*: float32
|
|
z*: float32
|
|
w*: float32
|
|
```
|
|
|
|
## **func** vec4
|
|
|
|
|
|
```nim
|
|
func vec4(x, y, z, w: float32): Vec4
|
|
```
|
|
|
|
## **func** vec4
|
|
|
|
|
|
```nim
|
|
func vec4(v: float32): Vec4
|
|
```
|
|
|
|
## **func** `+`
|
|
|
|
|
|
```nim
|
|
func `+`(a: Vec4; b: Vec4): Vec4
|
|
```
|
|
|
|
## **func** `-`
|
|
|
|
|
|
```nim
|
|
func `-`(a: Vec4; b: Vec4): Vec4
|
|
```
|
|
|
|
## **func** `-`
|
|
|
|
|
|
```nim
|
|
func `-`(a: Vec4): Vec4
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: Vec4; b: float32): Vec4
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: float32; b: Vec4): Vec4
|
|
```
|
|
|
|
## **func** `/`
|
|
|
|
|
|
```nim
|
|
func `/`(a: Vec4; b: float32): Vec4
|
|
```
|
|
|
|
## **func** `/`
|
|
|
|
|
|
```nim
|
|
func `/`(a: float32; b: Vec4): Vec4
|
|
```
|
|
|
|
## **func** `+=`
|
|
|
|
|
|
```nim
|
|
func `+=`(a: var Vec4; b: Vec4)
|
|
```
|
|
|
|
## **func** `-=`
|
|
|
|
|
|
```nim
|
|
func `-=`(a: var Vec4; b: Vec4)
|
|
```
|
|
|
|
## **func** `*=`
|
|
|
|
|
|
```nim
|
|
func `*=`(a: var Vec4; b: float32)
|
|
```
|
|
|
|
## **func** `/=`
|
|
|
|
|
|
```nim
|
|
func `/=`(a: var Vec4; b: float32)
|
|
```
|
|
|
|
## **func** zero
|
|
|
|
|
|
```nim
|
|
func zero(a: var Vec4)
|
|
```
|
|
|
|
## **func** hash
|
|
|
|
|
|
```nim
|
|
func hash(a: Vec4): Hash
|
|
```
|
|
|
|
## **func** `[]`
|
|
|
|
|
|
```nim
|
|
func `[]`(a: Vec4; i: int): float32
|
|
```
|
|
|
|
## **func** `[]=`
|
|
|
|
|
|
```nim
|
|
func `[]=`(a: var Vec4; i: int; b: float32)
|
|
```
|
|
|
|
## **func** lerp
|
|
|
|
|
|
```nim
|
|
func lerp(a: Vec4; b: Vec4; v: float32): Vec4
|
|
```
|
|
|
|
## **func** xyz
|
|
|
|
|
|
```nim
|
|
func xyz(a: Vec4): Vec3
|
|
```
|
|
|
|
## **func** `$`
|
|
|
|
|
|
```nim
|
|
func `$`(a: Vec4): string {.raises: [ValueError].}
|
|
```
|
|
|
|
## **func** vec3
|
|
|
|
|
|
```nim
|
|
func vec3(a: Vec2; z = 0.0): Vec3
|
|
```
|
|
|
|
## **func** vec4
|
|
|
|
|
|
```nim
|
|
func vec4(a: Vec3; w = 0.0): Vec4
|
|
```
|
|
|
|
## **func** vec4
|
|
|
|
|
|
```nim
|
|
func vec4(a: Vec2; z = 0.0; w = 0.0): Vec4
|
|
```
|
|
|
|
## **type** Mat3
|
|
|
|
3x3 Matrix
|
|
|
|
```nim
|
|
Mat3 = array[9, float32]
|
|
```
|
|
|
|
## **template** `[]`
|
|
|
|
|
|
```nim
|
|
template `[]`(a: Mat3; i, j: int): float32
|
|
```
|
|
|
|
## **template** `[]=`
|
|
|
|
|
|
```nim
|
|
template `[]=`(a: Mat3; i, j: int; v: float32)
|
|
```
|
|
|
|
## **func** mat3
|
|
|
|
|
|
```nim
|
|
func mat3(a, b, c, d, e, f, g, h, i: float32): Mat3
|
|
```
|
|
|
|
## **func** mat3
|
|
|
|
|
|
```nim
|
|
func mat3(a: Mat3): Mat3
|
|
```
|
|
|
|
## **func** identity
|
|
|
|
|
|
```nim
|
|
func identity(a: var Mat3)
|
|
```
|
|
|
|
## **func** mat3
|
|
|
|
|
|
```nim
|
|
func mat3(): Mat3
|
|
```
|
|
|
|
## **func** transpose
|
|
|
|
|
|
```nim
|
|
func transpose(a: Mat3): Mat3
|
|
```
|
|
|
|
## **func** `$`
|
|
|
|
|
|
```nim
|
|
func `$`(a: Mat3): string {.raises: [ValueError].}
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: Mat3; b: Mat3): Mat3
|
|
```
|
|
|
|
## **func** scale
|
|
|
|
|
|
```nim
|
|
func scale(a: Mat3; v: Vec2): Mat3
|
|
```
|
|
|
|
## **func** scale
|
|
|
|
|
|
```nim
|
|
func scale(a: Mat3; v: Vec3): Mat3
|
|
```
|
|
|
|
## **func** translate
|
|
|
|
|
|
```nim
|
|
func translate(v: Vec2): Mat3
|
|
```
|
|
|
|
## **func** scale
|
|
|
|
|
|
```nim
|
|
func scale(v: Vec2): Mat3
|
|
```
|
|
|
|
## **func** rotationMat3
|
|
|
|
|
|
```nim
|
|
func rotationMat3(angle: float32): Mat3
|
|
```
|
|
|
|
## **func** rotate
|
|
|
|
|
|
```nim
|
|
func rotate(a: Mat3; angle: float32): Mat3
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: Mat3; b: Vec2): Vec2
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: Mat3; b: Vec3): Vec3
|
|
```
|
|
|
|
## **func** inverse
|
|
|
|
|
|
```nim
|
|
func inverse(a: Mat3): Mat3
|
|
```
|
|
|
|
## **type** Mat4
|
|
|
|
4x4 Matrix - OpenGL row order
|
|
|
|
```nim
|
|
Mat4 = array[16, float32]
|
|
```
|
|
|
|
## **template** `[]`
|
|
|
|
|
|
```nim
|
|
template `[]`(a: Mat4; i, j: int): float32
|
|
```
|
|
|
|
## **template** `[]=`
|
|
|
|
|
|
```nim
|
|
template `[]=`(a: Mat4; i, j: int; v: float32)
|
|
```
|
|
|
|
## **func** mat4
|
|
|
|
|
|
```nim
|
|
func mat4(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15: float32): Mat4
|
|
```
|
|
|
|
## **func** mat4
|
|
|
|
|
|
```nim
|
|
func mat4(a: Mat4): Mat4
|
|
```
|
|
|
|
## **func** identity
|
|
|
|
|
|
```nim
|
|
func identity(): Mat4
|
|
```
|
|
|
|
## **func** mat4
|
|
|
|
|
|
```nim
|
|
func mat4(): Mat4
|
|
```
|
|
|
|
## **func** transpose
|
|
|
|
|
|
```nim
|
|
func transpose(a: Mat4): Mat4
|
|
```
|
|
|
|
## **func** determinant
|
|
|
|
|
|
```nim
|
|
func determinant(a: Mat4): float32
|
|
```
|
|
|
|
## **func** inverse
|
|
|
|
|
|
```nim
|
|
func inverse(a: Mat4): Mat4
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a, b: Mat4): Mat4
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: Mat4; b: Vec3): Vec3
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
|
|
```nim
|
|
func `*`(a: Mat4; b: Vec4): Vec4
|
|
```
|
|
|
|
## **func** right
|
|
|
|
|
|
```nim
|
|
func right(a: Mat4): Vec3
|
|
```
|
|
|
|
## **func** right=
|
|
|
|
|
|
```nim
|
|
func right=(a: var Mat4; b: Vec3)
|
|
```
|
|
|
|
## **func** up
|
|
|
|
|
|
```nim
|
|
func up(a: Mat4): Vec3
|
|
```
|
|
|
|
## **func** up=
|
|
|
|
|
|
```nim
|
|
func up=(a: var Mat4; b: Vec3)
|
|
```
|
|
|
|
## **func** forward
|
|
|
|
|
|
```nim
|
|
func forward(a: Mat4): Vec3
|
|
```
|
|
|
|
## **func** forward=
|
|
|
|
|
|
```nim
|
|
func forward=(a: var Mat4; b: Vec3)
|
|
```
|
|
|
|
## **func** pos
|
|
|
|
|
|
```nim
|
|
func pos(a: Mat4): Vec3
|
|
```
|
|
|
|
## **func** pos=
|
|
|
|
|
|
```nim
|
|
func pos=(a: var Mat4; b: Vec3)
|
|
```
|
|
|
|
## **func** rotationOnly
|
|
|
|
|
|
```nim
|
|
func rotationOnly(a: Mat4): Mat4
|
|
```
|
|
|
|
## **func** dist
|
|
|
|
|
|
```nim
|
|
func dist(a, b: Mat4): float32
|
|
```
|
|
|
|
## **func** translate
|
|
|
|
|
|
```nim
|
|
func translate(v: Vec3): Mat4
|
|
```
|
|
|
|
## **func** scale
|
|
|
|
|
|
```nim
|
|
func scale(v: Vec3): Mat4
|
|
```
|
|
|
|
## **func** close
|
|
|
|
|
|
```nim
|
|
func close(a: Mat4; b: Mat4): bool
|
|
```
|
|
|
|
## **func** hrp
|
|
|
|
|
|
```nim
|
|
func hrp(m: Mat4): Vec3
|
|
```
|
|
|
|
## **func** frustum
|
|
|
|
|
|
```nim
|
|
func frustum(left, right, bottom, top, near, far: float32): Mat4
|
|
```
|
|
|
|
## **func** perspective
|
|
|
|
|
|
```nim
|
|
func perspective(fovy, aspect, near, far: float32): Mat4
|
|
```
|
|
|
|
## **func** ortho
|
|
|
|
|
|
```nim
|
|
func ortho(left, right, bottom, top, near, far: float32): Mat4
|
|
```
|
|
|
|
## **func** lookAt
|
|
|
|
|
|
```nim
|
|
func lookAt(eye, center, up: Vec3): Mat4
|
|
```
|
|
|
|
## **func** mat3
|
|
|
|
Gets rotation and translation, ignoring z coordinates.
|
|
|
|
```nim
|
|
func mat3(m: Mat4): Mat3
|
|
```
|
|
|
|
## **func** mat3Rotation
|
|
|
|
Gets the rotational part of the 4x4 matrix.
|
|
|
|
```nim
|
|
func mat3Rotation(m: Mat4): Mat3
|
|
```
|
|
|
|
## **func** mat4
|
|
|
|
Takes a 2d Mat3 with position and converts to a 3d matrix.
|
|
|
|
```nim
|
|
func mat4(m: Mat3): Mat4
|
|
```
|
|
|
|
## **func** mat4Rotation
|
|
|
|
Gets the rotational part of the 3x3 matrix into a 4x4 matrix.
|
|
|
|
```nim
|
|
func mat4Rotation(m: Mat3): Mat4
|
|
```
|
|
|
|
## **func** `$`
|
|
|
|
|
|
```nim
|
|
func `$`(a: Mat4): string {.raises: [ValueError].}
|
|
```
|
|
|
|
## **type** Quat
|
|
|
|
|
|
```nim
|
|
Quat = object
|
|
x*: float32
|
|
y*: float32
|
|
z*: float32
|
|
w*: float32
|
|
```
|
|
|
|
## **func** quat
|
|
|
|
|
|
```nim
|
|
func quat(x, y, z, w: float32): Quat
|
|
```
|
|
|
|
## **func** conjugate
|
|
|
|
|
|
```nim
|
|
func conjugate(q: Quat): Quat
|
|
```
|
|
|
|
## **func** length
|
|
|
|
|
|
```nim
|
|
func length(q: Quat): float32
|
|
```
|
|
|
|
## **func** normalize
|
|
|
|
|
|
```nim
|
|
func normalize(q: Quat): Quat
|
|
```
|
|
|
|
## **func** xyz
|
|
|
|
|
|
```nim
|
|
func xyz(q: Quat): Vec3
|
|
```
|
|
|
|
## **func** xyz=
|
|
|
|
|
|
```nim
|
|
func xyz=(q: var Quat; v: Vec3)
|
|
```
|
|
|
|
## **func** `-`
|
|
|
|
|
|
```nim
|
|
func `-`(a: var Quat): Quat
|
|
```
|
|
|
|
## **func** `+`
|
|
|
|
|
|
```nim
|
|
func `+`(a: Quat; b: Quat): Quat
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
Multiply the quaternion by a quaternion.
|
|
|
|
```nim
|
|
func `*`(a, b: Quat): Quat
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
Multiply the quaternion by a float32.
|
|
|
|
```nim
|
|
func `*`(q: Quat; v: float32): Quat
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
Multiply the quaternion by a vector.
|
|
|
|
```nim
|
|
func `*`(q: Quat; v: Vec3): Vec3
|
|
```
|
|
|
|
## **func** `[]=`
|
|
|
|
|
|
```nim
|
|
func `[]=`(a: var Quat; i: int; b: float32)
|
|
```
|
|
|
|
## **func** mat3
|
|
|
|
|
|
```nim
|
|
func mat3(q: Quat): Mat3
|
|
```
|
|
|
|
## **func** mat4
|
|
|
|
|
|
```nim
|
|
func mat4(q: Quat): Mat4
|
|
```
|
|
|
|
## **func** recifuncalSqrt
|
|
|
|
|
|
```nim
|
|
func recifuncalSqrt(x: float32): float32
|
|
```
|
|
|
|
## **proc** quat
|
|
|
|
|
|
```nim
|
|
proc quat(m: Mat4): Quat
|
|
```
|
|
|
|
## **func** fromAxisAngle
|
|
|
|
|
|
```nim
|
|
func fromAxisAngle(axis: Vec3; angle: float32): Quat
|
|
```
|
|
|
|
## **func** toAxisAngle
|
|
|
|
|
|
```nim
|
|
func toAxisAngle(q: Quat; axis: var Vec3; angle: var float32)
|
|
```
|
|
|
|
## **func** quat
|
|
|
|
|
|
```nim
|
|
func quat(heading, pitch, roll: float32): Quat
|
|
```
|
|
|
|
## **func** quat
|
|
|
|
|
|
```nim
|
|
func quat(hpr: Vec3): Quat
|
|
```
|
|
|
|
## **func** hrp
|
|
|
|
|
|
```nim
|
|
func hrp(q: Quat): Vec3
|
|
```
|
|
|
|
## **func** dot
|
|
|
|
|
|
```nim
|
|
func dot(a: Quat; b: Quat): float32
|
|
```
|
|
|
|
## **func** nlerp
|
|
|
|
|
|
```nim
|
|
func nlerp(a: Quat; b: Quat; v: float32): Quat
|
|
```
|
|
|
|
## **func** `$`
|
|
|
|
|
|
```nim
|
|
func `$`(a: Quat): string {.raises: [ValueError].}
|
|
```
|
|
|
|
## **func** rotate
|
|
|
|
|
|
```nim
|
|
func rotate(angle: float32; axis: Vec3): Mat4
|
|
```
|
|
|
|
## **func** rotateX
|
|
|
|
|
|
```nim
|
|
func rotateX(angle: float32): Mat4
|
|
```
|
|
|
|
## **func** rotateY
|
|
|
|
|
|
```nim
|
|
func rotateY(angle: float32): Mat4
|
|
```
|
|
|
|
## **func** rotateZ
|
|
|
|
|
|
```nim
|
|
func rotateZ(angle: float32): Mat4
|
|
```
|
|
|
|
## **func** scaleMat
|
|
|
|
|
|
```nim
|
|
func scaleMat(scale: Vec3): Mat4
|
|
```
|
|
|
|
## **func** scaleMat
|
|
|
|
|
|
```nim
|
|
func scaleMat(scale: float32): Mat4
|
|
```
|
|
|
|
## **type** Rect
|
|
|
|
|
|
```nim
|
|
Rect = object
|
|
x*: float32
|
|
y*: float32
|
|
w*: float32
|
|
h*: float32
|
|
```
|
|
|
|
## **func** rect
|
|
|
|
|
|
```nim
|
|
func rect(x, y, w, h: float32): Rect
|
|
```
|
|
|
|
## **func** rect
|
|
|
|
|
|
```nim
|
|
func rect(pos, size: Vec2): Rect
|
|
```
|
|
|
|
## **func** xy
|
|
|
|
Gets the xy as a Vec2.
|
|
|
|
```nim
|
|
func xy(rect: Rect): Vec2
|
|
```
|
|
|
|
## **func** xy=
|
|
|
|
Sets the xy from Vec2.
|
|
|
|
```nim
|
|
func xy=(rect: var Rect; v: Vec2)
|
|
```
|
|
|
|
## **func** wh
|
|
|
|
Gets the wh as a Vec2.
|
|
|
|
```nim
|
|
func wh(rect: Rect): Vec2
|
|
```
|
|
|
|
## **func** wh=
|
|
|
|
Sets the wh from Vec2.
|
|
|
|
```nim
|
|
func wh=(rect: var Rect; v: Vec2)
|
|
```
|
|
|
|
## **func** `*`
|
|
|
|
* all elements of a Rect.
|
|
|
|
```nim
|
|
func `*`(r: Rect; v: float): Rect
|
|
```
|
|
|
|
## **func** `/`
|
|
|
|
/ all elements of a Rect.
|
|
|
|
```nim
|
|
func `/`(r: Rect; v: float): Rect
|
|
```
|
|
|
|
## **func** `+`
|
|
|
|
Add two boxes together.
|
|
|
|
```nim
|
|
func `+`(a, b: Rect): Rect
|
|
```
|
|
|
|
## **func** `$`
|
|
|
|
|
|
```nim
|
|
func `$`(a: Rect): string {.raises: [ValueError].}
|
|
```
|
|
|
|
## **func** inside
|
|
|
|
Checks if pos is inside rect.
|
|
|
|
```nim
|
|
func inside(pos: Vec2; rect: Rect): bool
|
|
```
|
|
|
|
## **func** overlap
|
|
|
|
Returns true if box a overlaps box b.
|
|
|
|
```nim
|
|
func overlap(a, b: Rect): bool
|
|
```
|
|
|
|
## **proc** `or`
|
|
|
|
Union of two rectangles.
|
|
|
|
```nim
|
|
proc `or`(a, b: Rect): Rect
|
|
```
|
|
|
|
## **proc** `and`
|
|
|
|
Intersection of two rectangles.
|
|
|
|
```nim
|
|
proc `and`(a, b: Rect): Rect
|
|
```
|