raymath

Search:
Group by:
Source   Edit  

Types

Float3 = array[3, float32]
Source   Edit  
Float16 = array[16, float32]
Source   Edit  

Procs

func add(left, right: Matrix): Matrix {.inline, ...raises: [], tags: [],
                                        forbids: [].}
Add two matrices Source   Edit  
func add(q1, q2: Quaternion): Quaternion {.inline, ...raises: [], tags: [],
    forbids: [].}
Add two quaternions Source   Edit  
func add(v1, v2: Vector2): Vector2 {.inline, ...raises: [], tags: [], forbids: [].}
Add two vectors (v1 + v2) Source   Edit  
func add(v1, v2: Vector3): Vector3 {.inline, ...raises: [], tags: [], forbids: [].}
Add two vectors Source   Edit  
func add(v1, v2: Vector4): Vector4 {.inline, ...raises: [], tags: [], forbids: [].}
Add two Vector4s Source   Edit  
func addValue(q: Quaternion; add: float32): Quaternion {.inline, ...raises: [],
    tags: [], forbids: [].}
Add quaternion and float value Source   Edit  
func addValue(v: Vector2; add: float32): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
Add vector and float value Source   Edit  
func addValue(v: Vector3; add: float32): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Add vector and float value Source   Edit  
func addValue(v: Vector4; add: float32): Vector4 {.inline, ...raises: [], tags: [],
    forbids: [].}
Add Vector4 and float value Source   Edit  
func angle(v1, v2: Vector3): float32 {.inline, ...raises: [], tags: [], forbids: [].}
Calculate angle between two vectors Source   Edit  
func angle(v1: Vector2; v2: Vector2): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate angle between two vectors NOTE: Angle is calculated from origin point (0, 0) Source   Edit  
func barycenter(p, a, b, c: Vector3): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) NOTE: Assumes P is on the plane of the triangle Source   Edit  
func clamp(v, min, max: Vector2): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
Clamp the components of the vector between min and max values specified by the given vectors Source   Edit  
func clamp(v, min, max: Vector3): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Clamp the components of the vector between min and max values specified by the given vectors Source   Edit  
func clampValue(v: Vector2; min, max: float32): Vector2 {.inline, ...raises: [],
    tags: [], forbids: [].}
Clamp the magnitude of the vector between two min and max values Source   Edit  
func clampValue(v: Vector3; min, max: float32): Vector3 {.inline, ...raises: [],
    tags: [], forbids: [].}
Clamp the magnitude of the vector between two values Source   Edit  
func crossProduct(v1, v2: Vector3): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate two vectors cross product Source   Edit  
func determinant(mat: Matrix): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Compute matrix determinant Source   Edit  
func distance(v1, v2: Vector2): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate distance between two vectors Source   Edit  
func distance(v1, v2: Vector3): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate distance between two vectors Source   Edit  
func distance(v1, v2: Vector4): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate distance between two vectors Source   Edit  
func distanceSqr(v1, v2: Vector2): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate square distance between two vectors Source   Edit  
func distanceSqr(v1, v2: Vector4): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate square distance between two vectors Source   Edit  
func divide(q1, q2: Quaternion): Quaternion {.inline, ...raises: [], tags: [],
    forbids: [].}
Divide two quaternions Source   Edit  
func divide(v1, v2: Vector2): Vector2 {.inline, ...raises: [], tags: [],
                                        forbids: [].}
Divide vector by vector Source   Edit  
func divide(v1, v2: Vector3): Vector3 {.inline, ...raises: [], tags: [],
                                        forbids: [].}
Divide vector by vector Source   Edit  
func divide(v1, v2: Vector4): Vector4 {.inline, ...raises: [], tags: [],
                                        forbids: [].}
Divide vector by vector Source   Edit  
func dotProduct(v1, v2: Vector2): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate two vectors dot product Source   Edit  
func dotProduct(v1, v2: Vector3): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate two vectors dot product Source   Edit  
func dotProduct(v1, v2: Vector4): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate two vectors dot product Source   Edit  
func equals(p, q: Quaternion; tol = 0.000001'f32): bool {.inline, ...raises: [],
    tags: [], forbids: [].}
Check whether two given quaternions are almost equal Source   Edit  
func equals(p, q: Vector2; tol = 0.000001'f32): bool {.inline, ...raises: [],
    tags: [], forbids: [].}
Check whether two given vectors are almost equal Source   Edit  
func equals(p, q: Vector3; tol = 0.000001'f32): bool {.inline, ...raises: [],
    tags: [], forbids: [].}
Check whether two given vectors are almost equal Source   Edit  
func equals(p, q: Vector4; tol = 0.000001'f32): bool {.inline, ...raises: [],
    tags: [], forbids: [].}
Check whether two given quaternions are almost equal Source   Edit  
func equals(x, y: float32; tol = 0.000001'f32): bool {.inline, ...raises: [],
    tags: [], forbids: [].}
Check whether two given floats are almost equal Source   Edit  
func fromAxisAngle(axis: Vector3; angle: float32): Quaternion {.inline,
    ...raises: [], tags: [], forbids: [].}
Get rotation quaternion for an angle and axis NOTE: Angle must be provided in radians Source   Edit  
func fromEuler(pitch, yaw, roll: float32): Quaternion {.inline, ...raises: [],
    tags: [], forbids: [].}
Get the quaternion equivalent to Euler angles NOTE: Rotation order is ZYX Source   Edit  
func fromMatrix(mat: Matrix): Quaternion {.inline, ...raises: [], tags: [],
    forbids: [].}
Get a quaternion for a given rotation matrix Source   Edit  
func fromVector3ToVector3(from, to: Vector3): Quaternion {.inline, ...raises: [],
    tags: [], forbids: [].}
Calculate quaternion based on the rotation from one vector to another Source   Edit  
func frustum(left, right, bottom, top, near, far: float): Matrix {.inline,
    ...raises: [], tags: [], forbids: [].}
Source   Edit  
func identity(_: typedesc[Matrix]): Matrix {.inline.}
Get identity matrix Source   Edit  
func identity(_: typedesc[Quaternion]): Quaternion {.inline.}
Get identity quaternion Source   Edit  
func invert(mat: Matrix): Matrix {.inline, ...raises: [], tags: [], forbids: [].}
Invert provided matrix Source   Edit  
func invert(q: Quaternion): Quaternion {.inline, ...raises: [], tags: [],
    forbids: [].}
Invert provided quaternion Source   Edit  
func invert(v: Vector2): Vector2 {.inline, ...raises: [], tags: [], forbids: [].}
Invert the given vector Source   Edit  
func invert(v: Vector3): Vector3 {.inline, ...raises: [], tags: [], forbids: [].}
Invert the given vector Source   Edit  
func invert(v: Vector4): Vector4 {.inline, ...raises: [], tags: [], forbids: [].}
Invert the given vector Source   Edit  
func length(q: Quaternion): float32 {.inline, ...raises: [], tags: [], forbids: [].}
Computes the length of a quaternion Source   Edit  
func length(v: Vector2): float32 {.inline, ...raises: [], tags: [], forbids: [].}
Calculate vector length Source   Edit  
func length(v: Vector3): float32 {.inline, ...raises: [], tags: [], forbids: [].}
Calculate vector length Source   Edit  
func length(v: Vector4): float32 {.inline, ...raises: [], tags: [], forbids: [].}
Computes the length of a Vector4 Source   Edit  
func lengthSqr(v: Vector2): float32 {.inline, ...raises: [], tags: [], forbids: [].}
Calculate vector square length Source   Edit  
func lengthSqr(v: Vector3): float32 {.inline, ...raises: [], tags: [], forbids: [].}
Calculate vector square length Source   Edit  
func lengthSqr(v: Vector4): float32 {.inline, ...raises: [], tags: [], forbids: [].}
Computes the square length of a Vector4 Source   Edit  
func lerp(q1, q2: Quaternion; amount: float32): Quaternion {.inline, ...raises: [],
    tags: [], forbids: [].}
Calculate linear interpolation between two quaternions Source   Edit  
func lerp(start, end, amount: float32): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate linear interpolation between two floats Source   Edit  
func lerp(v1, v2: Vector2; amount: float32): Vector2 {.inline, ...raises: [],
    tags: [], forbids: [].}
Calculate linear interpolation between two vectors Source   Edit  
func lerp(v1, v2: Vector3; amount: float32): Vector3 {.inline, ...raises: [],
    tags: [], forbids: [].}
Calculate linear interpolation between two vectors Source   Edit  
func lerp(v1, v2: Vector4; amount: float32): Vector4 {.inline, ...raises: [],
    tags: [], forbids: [].}
Calculate linear interpolation between two vectors Source   Edit  
func lineAngle(start, end: Vector2): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate angle defined by a two vectors line NOTE: Parameters need to be normalized Source   Edit  
func lookAt(eye, target, up: Vector3): Matrix {.inline, ...raises: [], tags: [],
    forbids: [].}
Get camera look-at matrix (view matrix) Source   Edit  
func max(v1, v2: Vector2): Vector2 {.inline, ...raises: [], tags: [], forbids: [].}
Get max value for each pair of components Source   Edit  
func max(v1, v2: Vector3): Vector3 {.inline, ...raises: [], tags: [], forbids: [].}
Get max value for each pair of components Source   Edit  
func max(v1, v2: Vector4): Vector4 {.inline, ...raises: [], tags: [], forbids: [].}
Get max value for each pair of components Source   Edit  
func min(v1, v2: Vector2): Vector2 {.inline, ...raises: [], tags: [], forbids: [].}
Get min value for each pair of components Source   Edit  
func min(v1, v2: Vector3): Vector3 {.inline, ...raises: [], tags: [], forbids: [].}
Get min value for each pair of components Source   Edit  
func min(v1, v2: Vector4): Vector4 {.inline, ...raises: [], tags: [], forbids: [].}
Get min value for each pair of components Source   Edit  
func moveTowards(v, target: Vector2; maxDistance: float32): Vector2 {.inline,
    ...raises: [], tags: [], forbids: [].}
Move Vector towards target Source   Edit  
func moveTowards(v, target: Vector3; maxDistance: float32): Vector3 {.inline,
    ...raises: [], tags: [], forbids: [].}
Move Vector towards target Source   Edit  
func moveTowards(v, target: Vector4; maxDistance: float32): Vector4 {.inline,
    ...raises: [], tags: [], forbids: [].}
Move Vector towards target Source   Edit  
func multiply(left, right: Matrix): Matrix {.inline, ...raises: [], tags: [],
    forbids: [].}
Get two matrix multiplication NOTE: When multiplying matrices... the order matters! Source   Edit  
func multiply(q1, q2: Quaternion): Quaternion {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate two quaternion multiplication Source   Edit  
func multiply(v1, v2: Vector2): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
Multiply vector by vector Source   Edit  
func multiply(v1, v2: Vector3): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Multiply vector by vector Source   Edit  
func multiply(v1, v2: Vector4): Vector4 {.inline, ...raises: [], tags: [],
    forbids: [].}
Multiply vector by vector Source   Edit  
func negate(v: Vector2): Vector2 {.inline, ...raises: [], tags: [], forbids: [].}
Negate vector Source   Edit  
func negate(v: Vector3): Vector3 {.inline, ...raises: [], tags: [], forbids: [].}
Negate provided vector (invert direction) Source   Edit  
func negate(v: Vector4): Vector4 {.inline, ...raises: [], tags: [], forbids: [].}
Negate provided vector (invert direction) Source   Edit  
func nlerp(q1, q2: Quaternion; amount: float32): Quaternion {.inline,
    ...raises: [], tags: [], forbids: [].}
Calculate slerp-optimized interpolation between two quaternions Source   Edit  
func normalize(q: Quaternion): Quaternion {.inline, ...raises: [], tags: [],
    forbids: [].}
Normalize provided quaternion Source   Edit  
func normalize(v: Vector2): Vector2 {.inline, ...raises: [], tags: [], forbids: [].}
Normalize provided vector Source   Edit  
func normalize(v: Vector3): Vector3 {.inline, ...raises: [], tags: [], forbids: [].}
Normalize provided vector Source   Edit  
func normalize(v: Vector4): Vector4 {.inline, ...raises: [], tags: [], forbids: [].}
Normalize provided vector Source   Edit  
func normalize(value, start, end: float32): float32 {.inline, ...raises: [],
    tags: [], forbids: [].}
Normalize input value within input range Source   Edit  
func one(_: typedesc[Vector2]): Vector2 {.inline.}
Vector with components value 1'f32 Source   Edit  
func one(_: typedesc[Vector3]): Vector3 {.inline.}
Vector with components value 1'f32 Source   Edit  
func one(_: typedesc[Vector4]): Vector4 {.inline.}
Vector with components value 1'f32 Source   Edit  
func ortho(left, right, bottom, top, near, far: float): Matrix {.inline,
    ...raises: [], tags: [], forbids: [].}
Source   Edit  
func orthoNormalize(v1: var Vector3; v2: var Vector3) {.inline, ...raises: [],
    tags: [], forbids: [].}
Orthonormalize provided vectors Makes vectors normalized and orthogonal to each other Gram-Schmidt function implementation Source   Edit  
func perpendicular(v: Vector3): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate one vector perpendicular vector Source   Edit  
func perspective(fovy, aspect, near, far: float): Matrix {.inline, ...raises: [],
    tags: [], forbids: [].}
Get perspective projection matrix NOTE: Fovy angle must be provided in radians Source   Edit  
func project(v1, v2: Vector3): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate the projection of the vector v1 on to v2 Source   Edit  
func reflect(v, normal: Vector2): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate reflected vector to normal Source   Edit  
func reflect(v, normal: Vector3): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Calculate reflected vector to normal Source   Edit  
func refract(v, n: Vector2; r: float32): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
Compute the direction of a refracted ray v: normalized direction of the incoming ray n: normalized normal vector of the interface of two optical media r: ratio of the refractive index of the medium from where the ray comes to the refractive index of the medium on the other side of the surface Source   Edit  
func reject(v1, v2: Vector3): Vector3 {.inline, ...raises: [], tags: [],
                                        forbids: [].}
Calculate the rejection of the vector v1 on to v2 Source   Edit  
func remap(value, inputStart, inputEnd, outputStart, outputEnd: float32): float32 {.
    inline, ...raises: [], tags: [], forbids: [].}
Remap input value within input range to output range Source   Edit  
func rotate(axis: Vector3; angle: float32): Matrix {.inline, ...raises: [],
    tags: [], forbids: [].}
Create rotation matrix from axis and angle NOTE: Angle should be provided in radians Source   Edit  
func rotate(v: Vector2; angle: float32): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
Rotate vector by angle Source   Edit  
func rotateByAxisAngle(v, axis: Vector3; angle: float32): Vector3 {.inline,
    ...raises: [], tags: [], forbids: [].}
Rotates a vector around an axis Source   Edit  
func rotateByQuaternion(v: Vector3; q: Quaternion): Vector3 {.inline,
    ...raises: [], tags: [], forbids: [].}
Transform a vector by quaternion rotation Source   Edit  
func rotateX(angle: float32): Matrix {.inline, ...raises: [], tags: [], forbids: [].}
Get x-rotation matrix NOTE: Angle must be provided in radians Source   Edit  
func rotateXYZ(angle: Vector3): Matrix {.inline, ...raises: [], tags: [],
    forbids: [].}
Get xyz-rotation matrix NOTE: Angle must be provided in radians Source   Edit  
func rotateY(angle: float32): Matrix {.inline, ...raises: [], tags: [], forbids: [].}
Get y-rotation matrix NOTE: Angle must be provided in radians Source   Edit  
func rotateZ(angle: float32): Matrix {.inline, ...raises: [], tags: [], forbids: [].}
Get z-rotation matrix NOTE: Angle must be provided in radians Source   Edit  
func rotateZYX(angle: Vector3): Matrix {.inline, ...raises: [], tags: [],
    forbids: [].}
Get zyx-rotation matrix NOTE: Angle must be provided in radians Source   Edit  
func scale(q: Quaternion; mul: float32): Quaternion {.inline, ...raises: [],
    tags: [], forbids: [].}
Scale quaternion by float value Source   Edit  
func scale(v: Vector2; scale: float32): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
Scale vector (multiply by value) Source   Edit  
func scale(v: Vector3; scalar: float32): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Multiply vector by scalar Source   Edit  
func scale(v: Vector4; scalar: float32): Vector4 {.inline, ...raises: [], tags: [],
    forbids: [].}
Multiply vector by scalar Source   Edit  
func scale(x, y, z: float32): Matrix {.inline, ...raises: [], tags: [], forbids: [].}
Get scaling matrix Source   Edit  
func slerp(q1, q2: Quaternion; amount: float32): Quaternion {.inline,
    ...raises: [], tags: [], forbids: [].}
Calculates spherical linear interpolation between two quaternions Source   Edit  
func subtract(left, right: Matrix): Matrix {.inline, ...raises: [], tags: [],
    forbids: [].}
Subtract two matrices (left - right) Source   Edit  
func subtract(q1, q2: Quaternion): Quaternion {.inline, ...raises: [], tags: [],
    forbids: [].}
Subtract two quaternions Source   Edit  
func subtract(v1, v2: Vector2): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
Subtract two vectors (v1 - v2) Source   Edit  
func subtract(v1, v2: Vector3): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Subtract two vectors Source   Edit  
func subtract(v1, v2: Vector4): Vector4 {.inline, ...raises: [], tags: [],
    forbids: [].}
Subtract two Vector4s Source   Edit  
func subtractValue(q: Quaternion; sub: float32): Quaternion {.inline,
    ...raises: [], tags: [], forbids: [].}
Subtract quaternion and float value Source   Edit  
func subtractValue(v: Vector2; sub: float32): Vector2 {.inline, ...raises: [],
    tags: [], forbids: [].}
Subtract vector by float value Source   Edit  
func subtractValue(v: Vector3; sub: float32): Vector3 {.inline, ...raises: [],
    tags: [], forbids: [].}
Subtract vector by float value Source   Edit  
func subtractValue(v: Vector4; sub: float32): Vector4 {.inline, ...raises: [],
    tags: [], forbids: [].}
Subtract Vector4 and float value Source   Edit  
func toAxisAngle(q: Quaternion; outAxis: var Vector3; outAngle: var float32) {.
    inline, ...raises: [], tags: [], forbids: [].}
Get the rotation angle and axis for a given quaternion Source   Edit  
func toEuler(q: Quaternion): Vector3 {.inline, ...raises: [], tags: [], forbids: [].}
Get the Euler angles equivalent to quaternion (roll, pitch, yaw) NOTE: Angles are returned in a Vector3 struct in radians Source   Edit  
func toFloatV(mat: Matrix): Float16 {.inline, noinit, ...raises: [], tags: [],
                                      forbids: [].}
Get float array of matrix data Source   Edit  
func toFloatV(v: Vector3): Float3 {.inline, noinit, ...raises: [], tags: [],
                                    forbids: [].}
Get Vector3 as float array Source   Edit  
func toMatrix(q: Quaternion): Matrix {.inline, ...raises: [], tags: [], forbids: [].}
Get a matrix for a given quaternion Source   Edit  
func trace(mat: Matrix): float32 {.inline, ...raises: [], tags: [], forbids: [].}
Get the trace of the matrix (sum of the values along the diagonal) Source   Edit  
func transform(q: Quaternion; mat: Matrix): Quaternion {.inline, ...raises: [],
    tags: [], forbids: [].}
Transform a quaternion given a transformation matrix Source   Edit  
func transform(v: Vector2; mat: Matrix): Vector2 {.inline, ...raises: [], tags: [],
    forbids: [].}
Transforms a Vector2 by a given Matrix Source   Edit  
func transform(v: Vector3; mat: Matrix): Vector3 {.inline, ...raises: [], tags: [],
    forbids: [].}
Transforms a Vector3 by a given Matrix Source   Edit  
func translate(x, y, z: float32): Matrix {.inline, ...raises: [], tags: [],
    forbids: [].}
Get translation matrix Source   Edit  
func transpose(mat: Matrix): Matrix {.inline, ...raises: [], tags: [], forbids: [].}
Transposes provided matrix Source   Edit  
func unproject(source: Vector3; projection, view: Matrix): Vector3 {.inline,
    ...raises: [], tags: [], forbids: [].}
Projects a Vector3 from screen space into object space NOTE: We are avoiding calling other raymath functions despite available Source   Edit  
func wrap(value, min, max: float32): float32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Wrap input value from min to max Source   Edit  
func zero(_: typedesc[Vector2]): Vector2 {.inline.}
Vector with components value 0'f32 Source   Edit  
func zero(_: typedesc[Vector3]): Vector3 {.inline.}
Vector with components value 0'f32 Source   Edit  
func zero(_: typedesc[Vector4]): Vector4 {.inline.}
Vector with components value 0'f32 Source   Edit  

Templates

template `*`[T: Vector2 | Vector3 | Vector4 | Quaternion | Matrix](v1, v2: T): T
Source   Edit  
template `*`[T: Vector2 | Vector3 | Vector4 | Quaternion](v1: T; value: float32): T
Source   Edit  
template `*=`[T: Vector2 | Vector3 | Vector4 | Quaternion | Matrix](v1: var T;
    v2: T)
Source   Edit  
template `*=`[T: Vector2 | Vector3 | Vector4 | Quaternion](v1: var T;
    value: float32)
Source   Edit  
template `+`[T: Vector2 | Vector3 | Vector4 | Quaternion | Matrix](v1, v2: T): T
Source   Edit  
template `+`[T: Vector2 | Vector3 | Vector4 | Quaternion](v1: T; value: float32): T
Source   Edit  
template `+=`[T: Vector2 | Vector3 | Vector4 | Quaternion | Matrix](v1: var T;
    v2: T)
Source   Edit  
template `+=`[T: Vector2 | Vector3 | Vector4 | Quaternion](v1: var T;
    value: float32)
Source   Edit  
template `-`[T: Vector2 | Vector3 | Vector4 | Quaternion | Matrix](v1, v2: T): T
Source   Edit  
template `-`[T: Vector2 | Vector3 | Vector4 | Quaternion](v1: T; value: float32): T
Source   Edit  
template `-`[T: Vector2 | Vector3 | Vector4](v1: T): T
Source   Edit  
template `-=`[T: Vector2 | Vector3 | Vector4 | Quaternion | Matrix](v1: var T;
    v2: T)
Source   Edit  
template `-=`[T: Vector2 | Vector3 | Vector4 | Quaternion](v1: var T;
    value: float32)
Source   Edit  
template `/`[T: Vector2 | Vector3 | Vector4 | Quaternion | Matrix](v1, v2: T): T
Source   Edit  
template `/`[T: Vector2 | Vector3 | Vector4 | Quaternion](v1: T; value: float32): T
Source   Edit  
template `/=`[T: Vector2 | Vector3 | Vector4 | Quaternion | Matrix](v1: var T;
    v2: T)
Source   Edit  
template `/=`[T: Vector2 | Vector3 | Vector4 | Quaternion](v1: var T;
    value: float32)
Source   Edit