interface Jitter3dUtilsInterface

Utilities for Jitter 3D manipulations

It is not possible to instantiate this interface directly; it is available globally as a Jitter3DUtils object and methods can be called like Jitter3DUtils.vadd().

Index

Methods

• add_quats(q1, q2, q3)
• axis_to_quat(axis, quat)
• build_rotmatrix(m, q)
• closest_line_sphere(lineA, lineB, center, r, p1)
• intersect_line_quad(lineA, lineB, pos, rot, scale, p1, p2)
• intersect_line_sphere(lineA, lineB, center, r, p1)
• normalize_quat(quat)
• quat_to_axis(quat, axis)
• transform_point(point, matrix)
• vadd(src1, src2, dst)
• vcopy(v1, v2)
• vcross(v1, v2, cross)
• vdiv(src1, src2, dst)
• vdot(v1, v2)
• vlength(v)
• vlength2(v)
• vmul(src1, src2, dst)
• vnormal(v)
• vscale(v, scale)
• vset(v, x, y, z)
• vsub(src1, src2, dst)
• vzero(v)
• xyz_to_axis(v, axis)

add_quats(q1, q2, q3)

Add three 4D vectors (quaternions)

add_quats(
  q1: Jitter3dUtilsVec4,
  q2: Jitter3dUtilsVec4,
  q3: Jitter3dUtilsVec4,
): void;

axis_to_quat(axis, quat)

Convert an angle/axis rotation to a quaternion

axis_to_quat(axis: Jitter3dUtilsVec3, quat: Jitter3dUtilsVec4): void;

build_rotmatrix(m, q)

Build a rotation matrix for a given quaternion

build_rotmatrix(m: Jitter3dUtilsVec4, q: Jitter3dUtilsVec4): void;

closest_line_sphere(lineA, lineB, center, r, p1)

Set p1 to the point on a sphere closest to a line segment

(x3 - x1)(x2 - x1) + (y3 - y1)(y2 - y1) + (z3 - z1)(z2 - z1)
-----------------------------------------------------------
(x2 - x1)(x2 - x1) + (y2 - y1)(y2 - y1) + (z2 - z1)(z2 - z1)

closest_line_sphere(
  lineA: Jitter3dUtilsVec3,
  lineB: Jitter3dUtilsVec3,
  center: Jitter3dUtilsVec3,
  r: number,
  p1: Jitter3dUtilsVec3,
): void;

intersect_line_quad(lineA, lineB, pos, rot, scale, p1, p2)

Returns whether the ray defined by the line's two points intersect the quad defined by a position, rotation, and scale. Sets p2 to the point of intersection with the quad plane in unit coordinates and sets p1 to the same point in world coordinates.

intersect_line_quad(
  lineA: Jitter3dUtilsVec3,
  lineB: Jitter3dUtilsVec3,
  pos: Jitter3dUtilsVec3,
  rot: Jitter3dUtilsVec3,
  scale: Jitter3dUtilsVec3,
  p1: Jitter3dUtilsVec3,
  p2: Jitter3dUtilsVec3,
): boolean;

intersect_line_sphere(lineA, lineB, center, r, p1)

Returns whether the ray defined by the line's two points intersect with the sphere of given center and radius. Sets p1 to the closest point of intersection.

intersect_line_sphere(
  lineA: Jitter3dUtilsVec3,
  lineB: Jitter3dUtilsVec3,
  center: Jitter3dUtilsVec3,
  r: number,
  p1: Jitter3dUtilsVec3,
): boolean;

normalize_quat(quat)

Normalize a quaternion

normalize_quat(quat: Jitter3dUtilsVec4): void;

quat_to_axis(quat, axis)

Convert a quaternion to an angle/axis rotation

quat_to_axis(quat: Jitter3dUtilsVec4, axis: Jitter3dUtilsVec3): void;

transform_point(point, matrix)

transform_point(point: Jitter3dUtilsVec4, matrix: Jitter3dUtilsMat16): void;

vadd(src1, src2, dst)

Add two 3D vectors

vadd(
  src1: Jitter3dUtilsVec3,
  src2: Jitter3dUtilsVec3,
  dst: Jitter3dUtilsVec3,
): void;

vcopy(v1, v2)

Copy one vector to another

vcopy(v1: Jitter3dUtilsVec3, v2: Jitter3dUtilsVec3): void;

vcross(v1, v2, cross)

Calculate the cross product of two 3D vectors

vcross(
  v1: Jitter3dUtilsVec3,
  v2: Jitter3dUtilsVec3,
  cross: Jitter3dUtilsVec3,
): void;

vdiv(src1, src2, dst)

Divide src1 and src2 (element-wise) and store the result in dst

vdiv(
  src1: Jitter3dUtilsVec3,
  src2: Jitter3dUtilsVec3,
  dst: Jitter3dUtilsVec3,
): void;

vdot(v1, v2)

Calculate the dot product of two 3D vectors

vdot(v1: Jitter3dUtilsVec3, v2: Jitter3dUtilsVec3): number;

vlength(v)

Compute the squared distance of a 3D vector

vlength(v: Jitter3dUtilsVec3): number;

vlength2(v)

A cheaper distance-squared calculation

vlength2(v: Jitter3dUtilsVec3): number;

vmul(src1, src2, dst)

Multiply src1 and src2 (element-wise) and store the result in dst

vmul(
  src1: Jitter3dUtilsVec3,
  src2: Jitter3dUtilsVec3,
  dst: Jitter3dUtilsVec3,
): void;

vnormal(v)

Normalize a 3D vector

vnormal(v: Jitter3dUtilsVec3): void;

vscale(v, scale)

Scale a vector

vscale(v: Jitter3dUtilsVec3, scale: number): void;

vset(v, x, y, z)

Set the values of a vector

vset(v: Jitter3dUtilsVec3, x: number, y: number, z: number): void;

vsub(src1, src2, dst)

Subtract src2 from src1 and store the result in dst

vsub(
  src1: Jitter3dUtilsVec3,
  src2: Jitter3dUtilsVec3,
  dst: Jitter3dUtilsVec3,
): void;

vzero(v)

Set all elements of a vector to zero

vzero(v: Jitter3dUtilsVec3): void;

xyz_to_axis(v, axis)

Convert rotation in Euler angles (xyz) to angle/axis rotation

xyz_to_axis(v: Jitter3dUtilsVec3, axis: Jitter3dUtilsVec3): void;