gdext/math

Search:
Group by:

Consts

CMP_EPSILON = 0.00001'f32
LN2 = 0.6931471805599453
SQRT2 = 1.4142135623730951
SQRT12 = 0.7071067811865476

Procs

func `*`(left: AABB; right: Transform3D): AABB {....raises: [], tags: [RootEffect],
    forbids: [].}
func `*`(left: Basis; right: Basis): Basis {....raises: [], tags: [RootEffect],
    forbids: [].}
func `*`(left: Basis; right: Float): Basis {....raises: [], tags: [RootEffect],
    forbids: [].}
func `*`(left: Basis; right: Int): Basis {....raises: [], tags: [RootEffect],
    forbids: [].}
func `*`(left: Basis; right: Vector3): Vector3 {....raises: [], tags: [RootEffect],
    forbids: [].}
func `*`(left: Plane; right: Transform3D): Plane {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Projection; right: Projection): Projection {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Projection; right: Vector4): Vector4 {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Quaternion; right: Float): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Quaternion; right: Int): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Quaternion; right: Quaternion): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Quaternion; right: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Rect2; right: Transform2D): Rect2 {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform2D; right: Float): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform2D; right: Int): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform2D; right: PackedVector2Array): PackedVector2Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `*`(left: Transform2D; right: Rect2): Rect2 {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform2D; right: Transform2D): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform2D; right: Vector2): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform3D; right: AABB): AABB {....raises: [], tags: [RootEffect],
    forbids: [].}
func `*`(left: Transform3D; right: Float): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform3D; right: Int): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform3D; right: PackedVector3Array): PackedVector3Array {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func `*`(left: Transform3D; right: Plane): Plane {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform3D; right: Transform3D): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Transform3D; right: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Vector2; right: Transform2D): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Vector3; right: Basis): Vector3 {....raises: [], tags: [RootEffect],
    forbids: [].}
func `*`(left: Vector3; right: Quaternion): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Vector3; right: Transform3D): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
func `*`(left: Vector4; right: Projection): Vector4 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc `*`[N: static int; T, S: SomeNumber](left: T; right: Vector[N, S]): auto {.
    inline.}
proc `*`[N: static int; T, S: SomeNumber](left: Vector[N, T]; right: S): auto {.
    inline.}
func `*`[N: static int; T, S: SomeNumber](left: Vector[N, T];
    right: Vector[N, S]): auto {.inline.}
func `+`(left: Plane): Plane {....raises: [], tags: [RootEffect], forbids: [].}
func `+`(left: Quaternion): Quaternion {....raises: [], tags: [RootEffect],
    forbids: [].}
func `+`(left: Quaternion; right: Quaternion): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
proc `+`[N: static int; T, S: SomeNumber](left: T; right: Vector[N, S]): auto {.
    inline.}
proc `+`[N: static int; T, S: SomeNumber](left: Vector[N, T]; right: S): auto {.
    inline.}
func `+`[N: static int; T, S: SomeNumber](left: Vector[N, T];
    right: Vector[N, S]): auto {.inline.}
func `-`(left: Plane): Plane {....raises: [], tags: [RootEffect], forbids: [].}
func `-`(left: Quaternion): Quaternion {....raises: [], tags: [RootEffect],
    forbids: [].}
func `-`(left: Quaternion; right: Quaternion): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
proc `-`[N: static int; T, S: SomeNumber](left: T; right: Vector[N, S]): auto {.
    inline.}
proc `-`[N: static int; T, S: SomeNumber](left: Vector[N, T]; right: S): auto {.
    inline.}
func `-`[N: static int; T, S: SomeNumber](left: Vector[N, T];
    right: Vector[N, S]): auto {.inline.}
func `-`[N: static int; T: SomeNumber](left: Vector[N, T]): Vector[N, T] {.
    inline.}
func `/`(left: Basis; right: Float): Basis {....raises: [], tags: [RootEffect],
    forbids: [].}
func `/`(left: Basis; right: Int): Basis {....raises: [], tags: [RootEffect],
    forbids: [].}
func `/`(left: Quaternion; right: Float): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
func `/`(left: Quaternion; right: Int): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
func `/`(left: Transform2D; right: Float): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
func `/`(left: Transform2D; right: Int): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
func `/`(left: Transform3D; right: Float): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
func `/`(left: Transform3D; right: Int): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc `/`[N: static int; T, S: SomeNumber](left: T; right: Vector[N, S]): auto {.
    inline.}
proc `/`[N: static int; T, S: SomeNumber](left: Vector[N, T]; right: S): auto {.
    inline.}
func `/`[N: static int; T, S: SomeNumber](left: Vector[N, T];
    right: Vector[N, S]): auto {.inline.}
func `<`[N: static int; T: SomeNumber](left, right: Vector[N, T]): bool {.inline.}
func `<=`[N: static int; T: SomeNumber](left, right: Vector[N, T]): bool {.
    inline.}
proc `[]`(self: Basis; index: int): Vector3 {....raises: [], tags: [], forbids: [].}
proc `[]`(self: Projection; index: int): Vector4 {....raises: [], tags: [],
    forbids: [].}
proc `[]`(self: Quaternion; index: int): real_elem {....raises: [], tags: [],
    forbids: [].}
proc `[]`(self: Transform2D; index: int): Vector2 {....raises: [], tags: [],
    forbids: [].}
proc aABB(position: Vector3; size: Vector3): AABB {....raises: [],
    tags: [RootEffect], forbids: [].}
proc aabb(): AABB {....raises: [], tags: [], forbids: [].}
proc aabb(from: AABB): AABB {....raises: [], tags: [], forbids: [].}
proc abs(self: AABB): AABB {....raises: [], tags: [RootEffect], forbids: [].}
proc abs(self: Rect2): Rect2 {....raises: [], tags: [RootEffect], forbids: [].}
proc abs(self: Rect2i): Rect2i {....raises: [], tags: [RootEffect], forbids: [].}
func abs[N: static int; T: SomeNumber](self: Vector[N, T]): Vector[N, T] {.
    inline.}
proc affineInverse(self: Transform2D): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc affineInverse(self: Transform3D): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
func angle[T: SomeFloat](self: Vector[2, T]): T {.inline.}
proc angleTo(self: Quaternion; to: Quaternion): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
proc angleTo(self: Vector3; to: Vector3): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
func angleTo[T: SomeFloat](self, to: Vector[2, T]): T {.inline.}
func angleToPoint[T](self, to: Vector[2, T]): T {.inline.}
proc asNormalized[N: static int; T: SomeFloat](vec: Vector[N, T]): NVector[N, T] {.
    inline.}
func aspect[T: SomeFloat](self: Vector[2, T]): T {.inline.}
func aspect[T: SomeInteger](self: Vector[2, T]): float {.inline.}
proc basis(): Basis {....raises: [], tags: [], forbids: [].}
proc basis(axis: Vector3; angle: Float): Basis {....raises: [], tags: [RootEffect],
    forbids: [].}
proc basis(from: Basis): Basis {....raises: [], tags: [], forbids: [].}
proc basis(from: Quaternion): Basis {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc basis(xAxis, yAxis, zAxis: Vector3): Basis {....raises: [], tags: [],
    forbids: [].}
proc basis(xx, xy, xz, yx, yy, yz, zx, zy, zz: real_elem): Basis {....raises: [],
    tags: [], forbids: [].}
proc basisXform(self: Transform2D; v: Vector2): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc basisXformInv(self: Transform2D; v: Vector2): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc bezierDerivative(self: Vector2; control1: Vector2; control2: Vector2;
                      end: Vector2; t: Float): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc bezierDerivative(self: Vector3; control1: Vector3; control2: Vector3;
                      end: Vector3; t: Float): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc bezierInterpolate(self: Vector2; control1: Vector2; control2: Vector2;
                       end: Vector2; t: Float): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc bezierInterpolate(self: Vector3; control1: Vector3; control2: Vector3;
                       end: Vector3; t: Float): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc bounce(self: Vector2; n: Vector2): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc bounce(self: Vector3; n: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
func ceil[N: static int; T: SomeFloat](self: Vector[N, T]): Vector[N, T] {.
    inline.}
func clamp[N: static int; T: SomeNumber](self, min, max: Vector[N, T]): Vector[
    N, T] {.inline.}
func clamp[N: static int; T: SomeNumber](self: Vector[N, T]; min, max: T): Vector[
    N, T] {.inline.}
func clamp01[N: static int; T: SomeNumber](self: Vector[N, T]): Vector[N, T] {.
    inline.}
func clamp01[T: SomeFloat](x: T): T
proc clampf(self: Vector2; min: Float; max: Float): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc clampf(self: Vector3; min: Float; max: Float): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc clampf(self: Vector4; min: Float; max: Float): Vector4 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc clampi(self: Vector2i; min: Int; max: Int): Vector2i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc clampi(self: Vector3i; min: Int; max: Int): Vector3i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc clampi(self: Vector4i; min: Int; max: Int): Vector4i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc createDepthCorrection(_: typedesc[Projection]; flipY: bool): Projection
proc createFitAabb(_: typedesc[Projection]; aabb: AABB): Projection
proc createForHmd(_: typedesc[Projection]; eye: Int; aspect: Float;
                  intraocularDist: Float; displayWidth: Float;
                  displayToLens: Float; oversample: Float; zNear: Float;
                  zFar: Float): Projection
proc createFrustum(_: typedesc[Projection]; left: Float; right: Float;
                   bottom: Float; top: Float; zNear: Float; zFar: Float): Projection
proc createFrustumAspect(_: typedesc[Projection]; size: Float; aspect: Float;
                         offset: Vector2; zNear: Float; zFar: Float;
                         flipFov: bool = false): Projection
proc createLightAtlasRect(_: typedesc[Projection]; rect: Rect2): Projection
proc createOrthogonal(_: typedesc[Projection]; left: Float; right: Float;
                      bottom: Float; top: Float; zNear: Float; zFar: Float): Projection
proc createOrthogonalAspect(_: typedesc[Projection]; size: Float; aspect: Float;
                            zNear: Float; zFar: Float; flipFov: bool = false): Projection
proc createPerspective(_: typedesc[Projection]; fovy: Float; aspect: Float;
                       zNear: Float; zFar: Float; flipFov: bool = false): Projection
proc createPerspectiveHmd(_: typedesc[Projection]; fovy: Float; aspect: Float;
                          zNear: Float; zFar: Float; flipFov: bool; eye: Int;
                          intraocularDist: Float; convergenceDist: Float): Projection
proc cross(self: Vector3; with: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
func cross[T](self: Vector[2, T]; with: Vector[2, T]): T {.inline.}
proc cubicInterpolate(self: Vector2; b: Vector2; preA: Vector2; postB: Vector2;
                      weight: Float): Vector2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc cubicInterpolate(self: Vector3; b: Vector3; preA: Vector3; postB: Vector3;
                      weight: Float): Vector3 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc cubicInterpolate(self: Vector4; b: Vector4; preA: Vector4; postB: Vector4;
                      weight: Float): Vector4 {....raises: [], tags: [RootEffect],
    forbids: [].}
func cubicInterpolate[T: SomeFloat](pFrom, pTo, pPre, pPost, pWeight: T): T {.
    inline.}
func cubicInterpolateAngle[T: SomeFloat](pFrom, pTo, pPre, pPost: T; pWeight: T): T {.
    inline.}
proc cubicInterpolateInTime(self: Vector2; b: Vector2; preA: Vector2;
                            postB: Vector2; weight: Float; bT: Float;
                            preAT: Float; postBT: Float): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc cubicInterpolateInTime(self: Vector3; b: Vector3; preA: Vector3;
                            postB: Vector3; weight: Float; bT: Float;
                            preAT: Float; postBT: Float): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc cubicInterpolateInTime(self: Vector4; b: Vector4; preA: Vector4;
                            postB: Vector4; weight: Float; bT: Float;
                            preAT: Float; postBT: Float): Vector4 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc determinant(self: Basis): Float {....raises: [], tags: [RootEffect],
                                       forbids: [].}
proc determinant(self: Projection): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc determinant(self: Transform2D): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
func directionTo[N: static int; T: SomeFloat](self, to: Vector[N, T]): Vector[N,
    T] {.inline.}
proc distanceSquaredTo(self: Vector2i; to: Vector2i): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc distanceSquaredTo(self: Vector3i; to: Vector3i): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc distanceSquaredTo(self: Vector4i; to: Vector4i): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
func distanceSquaredTo[N: static int; T: SomeFloat](self, to: Vector[N, T]): T {.
    inline.}
proc distanceTo(self: Plane; point: Vector3): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
proc distanceTo(self: Vector2i; to: Vector2i): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
proc distanceTo(self: Vector3i; to: Vector3i): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
proc distanceTo(self: Vector4i; to: Vector4i): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
func distanceTo[N: static int; T: SomeFloat](self, to: Vector[N, T]): T {.inline.}
func `div`[N: static int; T, S: SomeInteger](left: T; right: Vector[N, S]): auto {.
    inline.}
func `div`[N: static int; T, S: SomeInteger](left: Vector[N, T]; right: S): auto {.
    inline.}
func `div`[N: static int; T, S: SomeInteger](left: Vector[N, T];
    right: Vector[N, S]): auto {.inline.}
proc dot(self: Quaternion; with: Quaternion): Float {....raises: [],
    tags: [RootEffect], forbids: [].}
func dot[N: static int; T: SomeNumber](left, right: Vector[N, T]): T {.inline.}
proc encloses(self: AABB; with: AABB): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc encloses(self: Rect2; b: Rect2): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc encloses(self: Rect2i; b: Rect2i): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc exp(self: Quaternion): Quaternion {....raises: [], tags: [RootEffect],
    forbids: [].}
proc expand(self: AABB; toPoint: Vector3): AABB {....raises: [],
    tags: [RootEffect], forbids: [].}
proc expand(self: Rect2; to: Vector2): Rect2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc expand(self: Rect2i; to: Vector2i): Rect2i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc extend[T](value: T; N: static int): array[N, T]
proc flippedY(self: Projection): Projection {....raises: [], tags: [RootEffect],
    forbids: [].}
func floor[N: static int; T: SomeFloat](self: Vector[N, T]): Vector[N, T] {.
    inline.}
func floorLog2[T: SomeOrdinal](x: T): T
func fposmodp[T: SomeFloat](pX, pY: T): T {.inline.}
func fromAngle[T: SomeFloat](_: typedesc[NVector[2, T]]; angle: T): NVector[2, T] {.
    inline.}
proc fromEuler(_: typedesc[Basis]; euler: Vector3; order: Int = 2): Basis
proc fromEuler(_: typedesc[Quaternion]; euler: Vector3): Quaternion
proc fromScale(_: typedesc[Basis]; scale: Vector3): Basis
proc getAngle(self: Quaternion): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getArea(self: Rect2): Float {....raises: [], tags: [RootEffect], forbids: [].}
proc getArea(self: Rect2i): Int {....raises: [], tags: [RootEffect], forbids: [].}
proc getAspect(self: Projection): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getAxis(self: Quaternion): Vector3 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getCenter(self: AABB): Vector3 {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc getCenter(self: Plane): Vector3 {....raises: [], tags: [RootEffect],
                                       forbids: [].}
proc getCenter(self: Rect2): Vector2 {....raises: [], tags: [RootEffect],
                                       forbids: [].}
proc getCenter(self: Rect2i): Vector2i {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getEndpoint(self: AABB; idx: Int): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getEuler(self: Basis; order: Int = 2): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getEuler(self: Quaternion; order: Int = 2): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getFarPlaneHalfExtents(self: Projection): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getFov(self: Projection): Float {....raises: [], tags: [RootEffect],
                                       forbids: [].}
proc getFovy(_: typedesc[Projection]; fovx: Float; aspect: Float): Float
proc getLodMultiplier(self: Projection): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getLongestAxis(self: AABB): Vector3 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getLongestAxisIndex(self: AABB): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getLongestAxisSize(self: AABB): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
func getNumBits[T](x: T): T
proc getOrigin(self: Transform2D): Vector2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getPixelsPerMeter(self: Projection; forPixelWidth: Int): Int {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getProjectionPlane(self: Projection; plane: Int): Plane {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getRotation(self: Transform2D): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getRotationQuaternion(self: Basis): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getScale(self: Basis): Vector3 {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc getScale(self: Transform2D): Vector2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getShortestAxis(self: AABB): Vector3 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getShortestAxisIndex(self: AABB): Int {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getShortestAxisSize(self: AABB): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getSkew(self: Transform2D): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc getSupport(self: AABB; direction: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getSupport(self: Rect2; direction: Vector2): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getViewportHalfExtents(self: Projection): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc getVolume(self: AABB): Float {....raises: [], tags: [RootEffect], forbids: [].}
proc getZFar(self: Projection): Float {....raises: [], tags: [RootEffect],
                                        forbids: [].}
proc getZNear(self: Projection): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc grow(self: AABB; by: Float): AABB {....raises: [], tags: [RootEffect],
    forbids: [].}
proc grow(self: Rect2; amount: Float): Rect2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc grow(self: Rect2i; amount: Int): Rect2i {....raises: [], tags: [RootEffect],
    forbids: [].}
proc growIndividual(self: Rect2; left: Float; top: Float; right: Float;
                    bottom: Float): Rect2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc growIndividual(self: Rect2i; left: Int; top: Int; right: Int; bottom: Int): Rect2i {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc growSide(self: Rect2; side: Int; amount: Float): Rect2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc growSide(self: Rect2i; side: Int; amount: Int): Rect2i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc hasArea(self: Rect2): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc hasArea(self: Rect2i): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc hasPoint(self: AABB; point: Vector3): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc hasPoint(self: Plane; point: Vector3; tolerance: Float = 0.00001): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc hasPoint(self: Rect2; point: Vector2): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc hasPoint(self: Rect2i; point: Vector2i): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc hasSurface(self: AABB): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc hasVolume(self: AABB): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc interpolateWith(self: Transform2D; xform: Transform2D; weight: Float): Transform2D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc interpolateWith(self: Transform3D; xform: Transform3D; weight: Float): Transform3D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc intersect3(self: Plane; b: Plane; c: Plane): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}
proc intersection(self: AABB; with: AABB): AABB {....raises: [],
    tags: [RootEffect], forbids: [].}
proc intersection(self: Rect2; b: Rect2): Rect2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc intersection(self: Rect2i; b: Rect2i): Rect2i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc intersects(self: AABB; with: AABB): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc intersects(self: Rect2; b: Rect2; includeBorders: bool = false): bool {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc intersects(self: Rect2i; b: Rect2i): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc intersectsPlane(self: AABB; plane: Plane): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc intersectsRay(self: AABB; from: Vector3; dir: Vector3): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc intersectsRay(self: Plane; from: Vector3; dir: Vector3): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc intersectsSegment(self: AABB; from: Vector3; to: Vector3): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc intersectsSegment(self: Plane; from: Vector3; to: Vector3): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc inverse(self: Basis): Basis {....raises: [], tags: [RootEffect], forbids: [].}
proc inverse(self: Projection): Projection {....raises: [], tags: [RootEffect],
    forbids: [].}
proc inverse(self: Quaternion): Quaternion {....raises: [], tags: [RootEffect],
    forbids: [].}
proc inverse(self: Transform2D): Transform2D {....raises: [], tags: [RootEffect],
    forbids: [].}
proc inverse(self: Transform3D): Transform3D {....raises: [], tags: [RootEffect],
    forbids: [].}
proc inverse(self: Vector3): Vector3 {....raises: [], tags: [RootEffect],
                                       forbids: [].}
proc inverse(self: Vector4): Vector4 {....raises: [], tags: [RootEffect],
                                       forbids: [].}
proc isConformal(self: Basis): bool {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc isConformal(self: Transform2D): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isEqualApprox(self: AABB; aabb: AABB): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isEqualApprox(self: Basis; b: Basis): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isEqualApprox(self: Plane; toPlane: Plane): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isEqualApprox(self: Quaternion; to: Quaternion): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isEqualApprox(self: Rect2; rect: Rect2): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isEqualApprox(self: Transform2D; xform: Transform2D): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isEqualApprox(self: Transform3D; xform: Transform3D): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isEqualApprox[N: static int; T: SomeFloat](left, right: Vector[N, T]): bool {.
    inline.}
proc isEqualApprox[T: SomeFloat](a, b, tolerance: T): bool {.inline.}
proc isEqualApprox[T: SomeFloat](a, b: T): bool {.inline.}
proc isFinite(self: AABB): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc isFinite(self: Basis): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc isFinite(self: Plane): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc isFinite(self: Quaternion): bool {....raises: [], tags: [RootEffect],
                                        forbids: [].}
proc isFinite(self: Rect2): bool {....raises: [], tags: [RootEffect], forbids: [].}
proc isFinite(self: Transform2D): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isFinite(self: Transform3D): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
func isFinite[N: static int; T: SomeFloat](self: Vector[N, T]): bool {.inline.}
func isFinite[T: SomeFloat](pX: T): bool
proc isNormalized(self: Quaternion): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isOrthogonal(self: Projection): bool {....raises: [], tags: [RootEffect],
    forbids: [].}
proc isPointOver(self: Plane; point: Vector3): bool {....raises: [],
    tags: [RootEffect], forbids: [].}
proc isZeroApprox[N: static int; T: SomeFloat](self: Vector[N, T]): bool {.
    inline.}
proc isZeroApprox[T: SomeFloat](s: T): bool {.inline.}
proc jitterOffseted(self: Projection; offset: Vector2): Projection {....raises: [],
    tags: [RootEffect], forbids: [].}
proc length(self: Quaternion): Float {....raises: [], tags: [RootEffect],
                                       forbids: [].}
func length[N: static int; T: SomeFloat](self: NVector[N, T]): T {.inline.}
func length[N: static int; T: SomeFloat](self: Vector[N, T]): T {.inline.}
func length[N: static int; T: SomeInteger](self: Vector[N, T]): float {.inline.}
proc lengthSquared(self: Quaternion): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
func lengthSquared[N: static int; T: SomeNumber](self: Vector[N, T]): T {.inline.}
proc lerp[N: static int; T: SomeFloat](x, y: Vector[N, T]; ratio: T): Vector[N,
    T] {.inline.}
func lerp[T: SomeFloat](pFrom, pTo: T; t: T): T {.inline.}
func lerpAngle[T: SomeFloat](pFrom, pTo: T; t: T): T {.inline.}
proc limitLength(self: Vector2; length: Float = 1.0): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc limitLength(self: Vector3; length: Float = 1.0): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc log(self: Quaternion): Quaternion {....raises: [], tags: [RootEffect],
    forbids: [].}
proc lookingAt(_: typedesc[Basis]; target: Vector3;
               up: Vector3 = vector3(0, 1, 0); useModelFront: bool = false): Basis
proc lookingAt(self: Transform2D; target: Vector2 = vector2(0, 0)): Transform2D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc lookingAt(self: Transform3D; target: Vector3;
               up: Vector3 = vector3(0, 1, 0); useModelFront: bool = false): Transform3D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc max(self: Vector2; with: Vector2): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc max(self: Vector2i; with: Vector2i): Vector2i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc max(self: Vector3; with: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc max(self: Vector3i; with: Vector3i): Vector3i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc max(self: Vector4; with: Vector4): Vector4 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc max(self: Vector4i; with: Vector4i): Vector4i {....raises: [],
    tags: [RootEffect], forbids: [].}
func max[N: static int; T: SomeNumber](self: Vector[N, T]): T {.inline.}
func max[T](x: T; xs: varargs[T]): T
proc maxf(self: Vector2; with: Float): Vector2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc maxf(self: Vector3; with: Float): Vector3 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc maxf(self: Vector4; with: Float): Vector4 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc maxi(self: Vector2i; with: Int): Vector2i {....raises: [], tags: [RootEffect],
    forbids: [].}
proc maxi(self: Vector3i; with: Int): Vector3i {....raises: [], tags: [RootEffect],
    forbids: [].}
proc maxi(self: Vector4i; with: Int): Vector4i {....raises: [], tags: [RootEffect],
    forbids: [].}
proc maxidx[N: static int; T: SomeNumber](self: Vector[N, T]): int {.inline.}
proc merge(self: AABB; with: AABB): AABB {....raises: [], tags: [RootEffect],
    forbids: [].}
proc merge(self: Rect2; b: Rect2): Rect2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc merge(self: Rect2i; b: Rect2i): Rect2i {....raises: [], tags: [RootEffect],
    forbids: [].}
proc min(self: Vector2; with: Vector2): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc min(self: Vector2i; with: Vector2i): Vector2i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc min(self: Vector3; with: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc min(self: Vector3i; with: Vector3i): Vector3i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc min(self: Vector4; with: Vector4): Vector4 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc min(self: Vector4i; with: Vector4i): Vector4i {....raises: [],
    tags: [RootEffect], forbids: [].}
func min[N: static int; T: SomeNumber](self: Vector[N, T]): T {.inline.}
func min[T](x: T; xs: varargs[T]): T
proc minf(self: Vector2; with: Float): Vector2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc minf(self: Vector3; with: Float): Vector3 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc minf(self: Vector4; with: Float): Vector4 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc mini(self: Vector2i; with: Int): Vector2i {....raises: [], tags: [RootEffect],
    forbids: [].}
proc mini(self: Vector3i; with: Int): Vector3i {....raises: [], tags: [RootEffect],
    forbids: [].}
proc mini(self: Vector4i; with: Int): Vector4i {....raises: [], tags: [RootEffect],
    forbids: [].}
proc minidx[N: static int; T: SomeNumber](self: Vector[N, T]): int {.inline.}
func `mod`[N: static int; T, S: SomeInteger](left: T; right: Vector[N, S]): auto {.
    inline.}
func `mod`[N: static int; T, S: SomeInteger](left: Vector[N, T]; right: S): auto {.
    inline.}
func `mod`[N: static int; T, S: SomeInteger](left: Vector[N, T];
    right: Vector[N, S]): auto {.inline.}
proc moveToward[N: static int; T: SomeFloat](from, to: Vector[N, T]; delta: T): Vector[
    N, T] {.inline.}
proc moveToward[T: SomeFloat](from, to, delta: T): T
proc normalized(self: Plane): Plane {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc normalized(self: Quaternion): Quaternion {....raises: [], tags: [RootEffect],
    forbids: [].}
func normalized[N: static int; T: SomeFloat](self: Vector[N, T]): NVector[N, T] {.
    inline.}
func `not`(left: AABB): bool {....raises: [], tags: [RootEffect], forbids: [].}
func `not`(left: Basis): bool {....raises: [], tags: [RootEffect], forbids: [].}
func `not`(left: Plane): bool {....raises: [], tags: [RootEffect], forbids: [].}
func `not`(left: Projection): bool {....raises: [], tags: [RootEffect], forbids: [].}
func `not`(left: Quaternion): bool {....raises: [], tags: [RootEffect], forbids: [].}
func `not`(left: Rect2): bool {....raises: [], tags: [RootEffect], forbids: [].}
func `not`(left: Rect2i): bool {....raises: [], tags: [RootEffect], forbids: [].}
func `not`(left: Transform2D): bool {....raises: [], tags: [RootEffect],
                                      forbids: [].}
func `not`(left: Transform3D): bool {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc octahedronDecode(_: typedesc[Vector3]; uv: Vector2): Vector3
proc octahedronEncode(self: Vector3): Vector2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc orthogonal(self: Vector2): Vector2 {....raises: [], tags: [RootEffect],
    forbids: [].}
proc orthonormalized(self: Basis): Basis {....raises: [], tags: [RootEffect],
    forbids: [].}
proc orthonormalized(self: Transform2D): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc orthonormalized(self: Transform3D): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc outer(self: Vector3; with: Vector3): Basis {....raises: [],
    tags: [RootEffect], forbids: [].}
proc perspectiveZnearAdjusted(self: Projection; newZnear: Float): Projection {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc plane(): Plane {....raises: [], tags: [], forbids: [].}
proc plane(a, b, c, d: real_elem): Plane {....raises: [], tags: [], forbids: [].}
proc plane(from: Plane): Plane {....raises: [], tags: [], forbids: [].}
proc plane(normal: Vector3): Plane {....raises: [], tags: [RootEffect], forbids: [].}
proc plane(normal: Vector3; d: real_elem): Plane {....raises: [], tags: [],
    forbids: [].}
proc plane(normal: Vector3; point: Vector3): Plane {....raises: [],
    tags: [RootEffect], forbids: [].}
proc plane(point1: Vector3; point2: Vector3; point3: Vector3): Plane {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func posmod[N: static int; T: SomeFloat](x, y: Vector[N, T]): Vector[N, T] {.
    inline.}
func posmod[N: static int; T: SomeFloat](x: Vector[N, T]; y: T): Vector[N, T] {.
    inline.}
func posmod[T: SomeNumber](pX, pY: T): T {.inline.}
proc project(self: Plane; point: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc project(self: Vector2; b: Vector2): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc project(self: Vector3; b: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc projection(): Projection {....raises: [], tags: [], forbids: [].}
proc projection(from: Projection): Projection {....raises: [], tags: [],
    forbids: [].}
proc projection(from: Transform3D): Projection {....raises: [], tags: [RootEffect],
    forbids: [].}
proc projection(xAxis, yAxis, zAxis, wAxis: Vector4): Projection {....raises: [],
    tags: [], forbids: [].}
proc projection(xx, xy, xz, xw, yx, yy, yz, yw, zx, zy, zz, zw, wx, wy, wz, ww: real_elem): Projection {.
    ...raises: [], tags: [], forbids: [].}
proc quaternion(): Quaternion {....raises: [], tags: [], forbids: [].}
proc quaternion(arcFrom: Vector3; arcTo: Vector3): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
proc quaternion(axis: Vector3; angle: Float): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
proc quaternion(from: Basis): Quaternion {....raises: [], tags: [RootEffect],
    forbids: [].}
proc quaternion(from: Quaternion): Quaternion {....raises: [], tags: [],
    forbids: [].}
proc quaternion(x, y, z, w: real_elem): Quaternion {....raises: [], tags: [],
    forbids: [].}
proc rect2(): Rect2 {....raises: [], tags: [], forbids: [].}
proc rect2(from: Rect2): Rect2 {....raises: [], tags: [], forbids: [].}
proc rect2(from: Rect2i): Rect2 {....raises: [], tags: [], forbids: [].}
proc rect2(position, size: Vector2): Rect2 {....raises: [], tags: [], forbids: [].}
proc rect2(x, y, width, height: real_elem): Rect2 {....raises: [], tags: [],
    forbids: [].}
proc rect2i(): Rect2i {....raises: [], tags: [], forbids: [].}
proc rect2i(a: Rect2i): Rect2i {....raises: [], tags: [], forbids: [].}
proc rect2i(from: Rect2): Rect2i {....raises: [], tags: [], forbids: [].}
proc rect2i(position, size: Vector2i): Rect2i {....raises: [], tags: [],
    forbids: [].}
proc rect2i(x, y, width, height: int_elem): Rect2i {....raises: [], tags: [],
    forbids: [].}
proc reflect(self: Vector2; line: Vector2): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc reflect(self: Vector3; n: Vector3): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc rotated(self: Basis; axis: Vector3; angle: Float): Basis {....raises: [],
    tags: [RootEffect], forbids: [].}
proc rotated(self: Transform2D; angle: Float): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc rotated(self: Transform3D; axis: Vector3; angle: Float): Transform3D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc rotated(self: Vector2; angle: Float): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc rotated(self: Vector3; axis: Vector3; angle: Float): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc rotatedLocal(self: Transform2D; angle: Float): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc rotatedLocal(self: Transform3D; axis: Vector3; angle: Float): Transform3D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func round[N: static int; T: SomeFloat](self: Vector[N, T]): Vector[N, T] {.
    inline.}
proc scaled(self: Basis; scale: Vector3): Basis {....raises: [],
    tags: [RootEffect], forbids: [].}
proc scaled(self: Transform2D; scale: Vector2): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc scaled(self: Transform3D; scale: Vector3): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc scaledLocal(self: Transform2D; scale: Vector2): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc scaledLocal(self: Transform3D; scale: Vector3): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
func sgn[N: static int; T: SomeNumber](self: Vector[N, T]): Vector[N, int] {.
    inline.}
proc signedAngleTo(self: Vector3; to: Vector3; axis: Vector3): Float {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func sinc[T: SomeFloat](pX: T): T {.inline.}
func sincn[T: SomeFloat](pX: T): T {.inline.}
proc slerp(self: Basis; to: Basis; weight: Float): Basis {....raises: [],
    tags: [RootEffect], forbids: [].}
proc slerp(self: Quaternion; to: Quaternion; weight: Float): Quaternion {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc slerp(self: Vector2; to: Vector2; weight: Float): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc slerp(self: Vector3; to: Vector3; weight: Float): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc slerpni(self: Quaternion; to: Quaternion; weight: Float): Quaternion {.
    ...raises: [], tags: [RootEffect], forbids: [].}
func slide[N: static int; T: SomeFloat](self: Vector[N, T];
                                        normal: NVector[N, T]): Vector[N, T] {.
    inline.}
func snapped[N: static int; T: SomeNumber](self, step: Vector[N, T]): Vector[N,
    T] {.inline.}
func snapped[N: static int; T: SomeNumber](self: Vector[N, T]; step: T): Vector[
    N, T] {.inline.}
proc snapped[T: SomeFloat; S: SomeNumber](value: T; step: S): S
proc snappedf(self: Vector2; step: Float): Vector2 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc snappedf(self: Vector3; step: Float): Vector3 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc snappedf(self: Vector4; step: Float): Vector4 {....raises: [],
    tags: [RootEffect], forbids: [].}
proc snappedi(self: Vector2i; step: Int): Vector2i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc snappedi(self: Vector3i; step: Int): Vector3i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc snappedi(self: Vector4i; step: Int): Vector4i {....raises: [],
    tags: [RootEffect], forbids: [].}
proc sphericalCubicInterpolate(self: Quaternion; b: Quaternion;
                               preA: Quaternion; postB: Quaternion;
                               weight: Float): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
proc sphericalCubicInterpolateInTime(self: Quaternion; b: Quaternion;
                                     preA: Quaternion; postB: Quaternion;
                                     weight: Float; bT: Float; preAT: Float;
                                     postBT: Float): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}
proc tdotx(self: Basis; with: Vector3): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc tdoty(self: Basis; with: Vector3): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc tdotz(self: Basis; with: Vector3): Float {....raises: [], tags: [RootEffect],
    forbids: [].}
proc transform2D(): Transform2D {....raises: [], tags: [], forbids: [].}
proc transform2D(from: Transform2D): Transform2D {....raises: [], tags: [],
    forbids: [].}
proc transform2D(rotation: Float; position: Vector2): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc transform2D(rotation: Float; scale: Vector2; skew: Float; position: Vector2): Transform2D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc transform2D(xAxis, yAxis, origin: Vector2): Transform2D {....raises: [],
    tags: [], forbids: [].}
proc transform2D(xx, xy, yx, yy, ox, oy: real_elem): Transform2D {....raises: [],
    tags: [], forbids: [].}
proc transform3D(): Transform3D {....raises: [], tags: [], forbids: [].}
proc transform3D(basis: Basis; origin: Vector3): Transform3D {....raises: [],
    tags: [], forbids: [].}
proc transform3D(from: Projection): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc transform3D(from: Transform3D): Transform3D {....raises: [], tags: [],
    forbids: [].}
proc transform3D(xAxis, yAxis, zAxis, origin: Vector3): Transform3D {.
    ...raises: [], tags: [], forbids: [].}
proc transform3D(xx, xy, xz, yx, yy, yz, zx, zy, zz, ox, oy, oz: real_elem): Transform3D {.
    ...raises: [], tags: [], forbids: [].}
proc translated(self: Transform2D; offset: Vector2): Transform2D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc translated(self: Transform3D; offset: Vector3): Transform3D {....raises: [],
    tags: [RootEffect], forbids: [].}
proc translatedLocal(self: Transform2D; offset: Vector2): Transform2D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc translatedLocal(self: Transform3D; offset: Vector3): Transform3D {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc transposed(self: Basis): Basis {....raises: [], tags: [RootEffect],
                                      forbids: [].}
proc vector2(): Vector2 {.inline, ...raises: [], tags: [], forbids: [].}
proc vector2(from: Vector2): Vector2 {.inline, ...raises: [], tags: [], forbids: [].}
proc vector2(from: Vector2i): Vector2 {.inline, ...raises: [], tags: [],
                                        forbids: [].}
proc vector2(x, y: real_elem): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector2i(): Vector2i {.inline, ...raises: [], tags: [], forbids: [].}
proc vector2i(from: Vector2): Vector2i {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector2i(from: Vector2i): Vector2i {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector2i(x, y: int_elem): Vector2i {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector3(): Vector3 {.inline, ...raises: [], tags: [], forbids: [].}
proc vector3(from: Vector3): Vector3 {.inline, ...raises: [], tags: [], forbids: [].}
proc vector3(from: Vector3i): Vector3 {.inline, ...raises: [], tags: [],
                                        forbids: [].}
proc vector3(x, y, z: real_elem): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector3i(): Vector3i {.inline, ...raises: [], tags: [], forbids: [].}
proc vector3i(from: Vector3): Vector3i {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector3i(from: Vector3i): Vector3i {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector3i(x, y, z: int_elem): Vector3i {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector4(): Vector4 {.inline, ...raises: [], tags: [], forbids: [].}
proc vector4(from: Vector4): Vector4 {.inline, ...raises: [], tags: [], forbids: [].}
proc vector4(from: Vector4i): Vector4 {.inline, ...raises: [], tags: [],
                                        forbids: [].}
proc vector4(x, y, z, w: real_elem): Vector4 {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector4i(): Vector4i {.inline, ...raises: [], tags: [], forbids: [].}
proc vector4i(from: Vector4): Vector4i {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector4i(from: Vector4i): Vector4i {.inline, ...raises: [], tags: [],
    forbids: [].}
proc vector4i(x, y, z, w: int_elem): Vector4i {.inline, ...raises: [], tags: [],
    forbids: [].}
proc wrap[T: SomeFloat](value, min, max: T): T
proc wrap[T: SomeInteger](value, min, max: T): T
proc wrap[T](value: T; bounds: Slice[T]): T

Converters

converter unwrapped[N: static int; T: SomeFloat](v: NVector[N, T]): Vector[N, T] {.
    inline.}

Macros

macro fmap[N: static int; T1, T2, T3](pred; v1: array[N, T1] | T1;
                                      v2: array[N, T2] | T2;
                                      v3: array[N, T3] | T3): auto
macro fmap[N: static int; T1, T2](pred; v1: array[N, T1] | T1;
                                  v2: array[N, T2] | T2): auto
macro fmap[N: static int; T](pred; v1: array[N, T]): auto
macro vec(exp: varargs[typed]): Vector
proc gen: auto = vec(1, 2)
vec(1, 2, 3) == [1, 2, 3]
vec(1, 2) == [1, 2]
vec([1, 2], 3) == [1, 2, 3]
(let x = [1, 2]; vec(x, 3)) == [x[0], x[1], 3]
vec(vec(1, 2), 3) == [1, 2, 3]
vec(gen(), 3) == (let arg0 = gen(); [arg0[0], arg0[1], 3])
macro vector(exp: varargs[typed]): VectorR
macro vectori(exp: varargs[typed]): VectorI

Templates

template `*`[F: SomeFloat; I: SomeInteger](f: F; i: I): F
template `*`[F: SomeFloat; I: SomeInteger](i: I; f: F): F
template `+`[F: SomeFloat; I: SomeInteger](f: F; i: I): F
template `+`[F: SomeFloat; I: SomeInteger](i: I; f: F): F
template `+`[N: static int; T: SomeNumber](left: Vector[N, T]): Vector[N, T] {..}
template `-`[F: SomeFloat; I: SomeInteger](f: F; i: I): F
template `-`[F: SomeFloat; I: SomeInteger](i: I; f: F): F
template `/`[F: SomeFloat; I: SomeInteger](f: F; i: I): F
template `/`[F: SomeFloat; I: SomeInteger](i: I; f: F): F
template absf[T: SomeFloat](x: T): T {..}
template absi[T: SomeInteger](x: T): T {..}
template acos[T: SomeFloat](pX: T): T {..}
template acosh[T: SomeFloat](pX: T): T {..}
template all[N: static int; T1, T2](pred; v1: array[N, T1] | T1;
                                    v2: array[N, T2] | T2): bool
template all[N: static int; T](pred; v: array[N, T]): bool
template any[N: static int; T1, T2](pred; v1: array[N, T1] | T1;
                                    v2: array[N, T2] | T2): bool
template any[N: static int; T](pred; v: array[N, T]): bool
template asin[T: SomeFloat](pX: T): T {..}
template asinh[T: SomeFloat](pX: T): T {..}
template atan[T: SomeFloat](pX: T): T {..}
template atan2[T: SomeFloat](pY, pX: T): T {..}
template atanh[T: SomeFloat](pX: T): T {..}
template Back(_: typedesc[Vector3]): Vector3
template Back(_: typedesc[Vector3i]): Vector3i
template Back[T: SomeNumber](_: typedesc[NVector[3, T]]): NVector[3, T] {..}
template ceilf[T: SomeFloat](x: T): T {..}
template ceili[T: SomeFloat](x: T): int {..}
template clampf[T: SomeFloat](value, min, max: T): T {..}
template clampi[T: SomeInteger](value, min, max: T): T {..}
template Down(_: typedesc[Vector2]): Vector2
template Down(_: typedesc[Vector2i]): Vector2i
template Down(_: typedesc[Vector3]): Vector3
template Down(_: typedesc[Vector3i]): Vector3i
template Down[T: SomeNumber](_: typedesc[NVector[2, T]]): NVector[2, T] {..}
template Down[T: SomeNumber](_: typedesc[NVector[3, T]]): NVector[3, T] {..}
template FlipX(_: typedesc[Basis]): Basis
template FlipX(_: typedesc[Transform2D]): Transform2D
template FlipX(_: typedesc[Transform3D]): Transform3D
template FlipY(_: typedesc[Basis]): Basis
template FlipY(_: typedesc[Transform2D]): Transform2D
template FlipY(_: typedesc[Transform3D]): Transform3D
template FlipZ(_: typedesc[Basis]): Basis
template FlipZ(_: typedesc[Transform3D]): Transform3D
template floorf[T: SomeFloat](x: T): T {..}
template floori[T: SomeFloat](x: T): int {..}
template fmod[T: SomeNumber](x, y: T): T {..}
template Forward(_: typedesc[Vector3]): Vector3
template Forward(_: typedesc[Vector3i]): Vector3i
template Forward[T: SomeNumber](_: typedesc[NVector[3, T]]): NVector[3, T] {..}
template fposmod[T: SomeFloat](x, y: T): T {..}
template Identity(_: typedesc[Basis]): Basis
template Identity(_: typedesc[Projection]): Projection
template Identity(_: typedesc[Quaternion]): Quaternion
template Identity(_: typedesc[Transform2D]): Transform2D
template Identity(_: typedesc[Transform3D]): Transform3D
template Inf(_: typedesc[Vector2]): Vector2
template Inf(_: typedesc[Vector3]): Vector3
template Inf(_: typedesc[Vector4]): Vector4
template Inf[N: static int; T: SomeFloat](_: typedesc[Vector[N, T]]): Vector[N,
    T] {..}
template isInf[T: SomeFloat](x: T): bool {..}
template Left(_: typedesc[Vector2]): Vector2
template Left(_: typedesc[Vector2i]): Vector2i
template Left(_: typedesc[Vector3]): Vector3
template Left(_: typedesc[Vector3i]): Vector3i
template Left[T: SomeNumber](_: typedesc[NVector[2, T]]): NVector[2, T] {..}
template Left[T: SomeNumber](_: typedesc[NVector[3, T]]): NVector[3, T] {..}
template lerpf(from: Float; to: Float; weight: Float): Float {..}
template Max(_: typedesc[Vector2i]): Vector2i
template Max(_: typedesc[Vector3i]): Vector3i
template Max(_: typedesc[Vector4i]): Vector4i
template maxf[T: SomeFloat](a, b: T): T {..}
template maxi[T: SomeInteger](a, b: T): T {..}
template Min(_: typedesc[Vector2i]): Vector2i
template Min(_: typedesc[Vector3i]): Vector3i
template Min(_: typedesc[Vector4i]): Vector4i
template minf[T: SomeFloat](a, b: T): T {..}
template mini[T: SomeInteger](a, b: T): T {..}
template ModelBottom(_: typedesc[Vector3]): Vector3
template ModelFront(_: typedesc[Vector3]): Vector3
template ModelLeft(_: typedesc[Vector3]): Vector3
template ModelRear(_: typedesc[Vector3]): Vector3
template ModelRight(_: typedesc[Vector3]): Vector3
template ModelTop(_: typedesc[Vector3]): Vector3
template nearestPo2(value: Int): Int {..}
template One(_: typedesc[Vector2]): Vector2
template One(_: typedesc[Vector2i]): Vector2i
template One(_: typedesc[Vector3]): Vector3
template One(_: typedesc[Vector3i]): Vector3i
template One(_: typedesc[Vector4]): Vector4
template One(_: typedesc[Vector4i]): Vector4i
template One[N: static int; T: SomeNumber](_: typedesc[Vector[N, T]]): Vector[N,
    T] {..}
template PlaneXy(_: typedesc[Plane]): Plane
template PlaneXz(_: typedesc[Plane]): Plane
template PlaneYz(_: typedesc[Plane]): Plane
template Right(_: typedesc[Vector2]): Vector2
template Right(_: typedesc[Vector2i]): Vector2i
template Right(_: typedesc[Vector3]): Vector3
template Right(_: typedesc[Vector3i]): Vector3i
template Right[T: SomeNumber](_: typedesc[NVector[2, T]]): NVector[2, T] {..}
template Right[T: SomeNumber](_: typedesc[NVector[3, T]]): NVector[3, T] {..}
template roundf[T: SomeFloat](x: T): T {..}
template roundi[T: SomeFloat](x: T): int {..}
template sign[T](v: T): auto {..}
template signf[T: SomeFloat](x: T): T {..}
template signi[T: SomeInteger](x: T): T {..}
template snappedf[T: SomeFloat; S: SomeFloat](value: T; step: S): S {..}
template snappedi[T: SomeFloat; S: SomeInteger](value: T; step: S): S {..}
template Up(_: typedesc[Vector2]): Vector2
template Up(_: typedesc[Vector2i]): Vector2i
template Up(_: typedesc[Vector3]): Vector3
template Up(_: typedesc[Vector3i]): Vector3i
template Up[T: SomeNumber](_: typedesc[NVector[2, T]]): NVector[2, T] {..}
template Up[T: SomeNumber](_: typedesc[NVector[3, T]]): NVector[3, T] {..}
template w[T](vector: array[4, T]): T
template w=[T](vector: var array[4, T]; value: T)
template wrapf[T: SomeFloat](value, min, max: T): T {..}
template wrapi[T: SomeInteger](value, min, max: T): T {..}
template x[T](vector: array[2, T]): T
template x[T](vector: array[3, T]): T
template x[T](vector: array[4, T]): T
template x=[T](vector: var array[2, T]; value: T)
template x=[T](vector: var array[3, T]; value: T)
template x=[T](vector: var array[4, T]; value: T)
template y[T](vector: array[2, T]): T
template y[T](vector: array[3, T]): T
template y[T](vector: array[4, T]): T
template y=[T](vector: var array[2, T]; value: T)
template y=[T](vector: var array[3, T]; value: T)
template y=[T](vector: var array[4, T]; value: T)
template z[T](vector: array[3, T]): T
template z[T](vector: array[4, T]): T
template z=[T](vector: var array[3, T]; value: T)
template z=[T](vector: var array[4, T]; value: T)
template Zero(_: typedesc[Projection]): Projection
template Zero(_: typedesc[Vector2]): Vector2
template Zero(_: typedesc[Vector2i]): Vector2i
template Zero(_: typedesc[Vector3]): Vector3
template Zero(_: typedesc[Vector3i]): Vector3i
template Zero(_: typedesc[Vector4]): Vector4
template Zero(_: typedesc[Vector4i]): Vector4i
template Zero[N: static int; T: SomeNumber](_: typedesc[Vector[N, T]]): Vector[
    N, T] {..}
template `~=`(a, b: typed): bool

Made with Nim. Generated: 2025-04-27 02:52:44 UTC