References

summary
public	C AbstractViewer
public	C AnimatedVec3
public	C BimserverGeometryLoader GeometryLoader loads data from a BIMserver
public	C BimSurfer Entry point for the public BimSurfer API.
public	C BufferManager BufferManager keeps track of (CPU side) buffers, these buffers are eventually flushed to the GPU.
public	C BufferManagerPerColor Buffer manager that keeps track of one buffer per color.
public	C BufferManagerTransparencyOnly A buffer manager that keeps track of only 2 buffers, one opaque and one with transparent data.
public	C BufferSetPool Keeps track of a collections of buffersets that can be reused.
public	C BufferTransformer This class transforms buffers.
public	C Camera A Camera defines viewing and projection transforms for its Viewer.
public	C CameraControl Controls the camera with user input.
public	C DataInputStream This class keeps track of the position of reading, supplies get methods for most types and provides alignment methods.
public	C DefaultRenderLayer This is the default renderer for what we called the base layer.
public	C Executor Executor allows to submit jobs for execution.
public	C FatLineRenderer As you many know, line rendering with thickness is not well-supported in WebGL implementations (mostly due to WebGL implementations on Windows defaulting to emulating OpenGL calls via ANGLE on DirectX 9).
public	C FreezableSet The default ES6 Set() class is rather useless, as it doesn't do proper equality comparison, no use of keys in a Map(), etc. This class is a wrapper around such a Set() but with a `frozen' getter to convert to String for equality testing.
public	C Frustum Frustum for fast World-space frustum-AABB collision testing
public	C GeometryCache Keeps track of GeometryData that is potentially reused.
public	C GeometryLoader This class is supposed to be and stay BIMserver-free.
public	C GLTFLoader
public	C GpuBufferManager
public	C Lighting Configures the viewer's light sources.
public	C LineBoxGeometry Simple (reusable) class to draw a linebox
public	C Octree
public	C Orthographic Configures orthographic projection mode for the camera.
public	C Perspective Configures perspective projection mode for the camera.
public	C ProgramManager Keeps track of shader programs, glsl, uniform positions and vertex attributes
public	C Projection
public	C ProjectTreeModel A quick and dirty tree model, this is used in both the dev.js and interactive.js apps
public	C RenderLayer Abstract base class for managing and rendering buffers pertaining to a render layer, ie.
public	C ReuseLoader When loading Tiles, there is sometimes geometry (GeometryData) that is reused in other Tiles as well, in that case it is omitted in the stream, to be loaded later.
public	C SectionPlane
public	C SectionPlaneSet
public	C Settings This class builds a quick UI for changing basic settings and stores the settings in localStorage.
public	C SSQuad A Screen-space quadrangle used for deferred rendering.
public	C Stats Keeps track of statistics.
public	C SvgOverlay A SVG overlay that is synced with the WebGL viewport for efficiently rendering two-dimensional elements such as text, that are not easily rendered using WebGL.
public	C TileLoader Loads tiles.
public	C TilingRenderLayer A specific type of RenderLayer, which uses Tiling to achieve better render performance, but also minimizes the amount of data that needs to be loaded of the line.
public	C TreeModel
public	C TreeView A basic tree view.
public	C Utils Generic utils
public	C VertexQuantization This class is responsible for keeping track of the various matrices used for quantization/unquantization
public	C Viewer The idea is that this class doesn't know anything about BIMserver, and can possibly be reused in classes other than BimServerViewer Main viewer class, too many responsibilities: Keep track of width/height of viewport Keeps track of dirty scene Contains the basic render loop (and delegates to the render layers)
public	C WSQuad A World-space quadrangle used for rendering a capping polygon for the sectionplane.
public	V CLICK_MEASURE_DIST: number
public	V CLICK_MEASURE_PATH: number
public	V CLICK_SELECT: number
public	V DRAG_ORBIT: number
public	V DRAG_PAN: number
public	V DRAG_SECTION: number
public	V DefaultColors: {"IFCSPACE": , "IFCROOF": , "IFCSLAB": , "IFCWALL": , "IFCWALLSTANDARDCASE": , "IFCDOOR": , "IFCWINDOW": , "IFCOPENINGELEMENT": , "IFCRAILING": , "IFCCOLUMN": , "IFCBEAM": , "IFCBEAMSTANDARDCASE": , "IFCFURNISHINGELEMENT": , "IFCCURTAINWALL": , "IFCSTAIR": , "IFCSTAIRFLIGHT": , "IFCBUILDINGELEMENTPROXY": , "IFCFLOWSEGMENT": , "IFCFLOWITTING": , "IFCFLOWTERMINAL": , "IFCPROXY": , "IFCSITE": , "IFCLIGHTFIXTURE": , "IFCDUCTSEGMENT": , "IFCDISTRIBUTIONFLOWELEMENT": , "IFCDUCTFITTING": , "IFCPLATE": , "IFCPILE": , "IFCAIRTERMINAL": , "IFCMEMBER": , "IFCCOVERING": , "IFCTRANSPORTELEMENT": , "IFCFLOWCONTROLLER": , "IFCFLOWFITTING": , "IFCRAMP": , "IFCFURNITURE": , "IFCFOOTING": , "IFCSYSTEMFURNITUREELEMENT": , "IFCBUILDINGELEMENTPART": , "IFCDISTRIBUTIONELEMENT": , "DEFAULT": *} Default colors, only used by the BimserverGeometryLoader when no default color is given by the serializer
public	V COLOR_QUANTIZATION: number
public	V LINES: number
public	V LINE_PRIMITIVES: number
public	V NORMAL_OCT_ENCODE: number
public	V NORMAL_QUANTIZATION: number
public	V OBJECT_COLORS: number
public	V PICKING: number
public	V QUANTIZE_COLOR_BUFFER: number
public	V REUSE: number
public	V VERTEX_QUANTIZATION: number
public	V COLOR_ALPHA_DEPTH: number
public	V COLOR_FLOAT_DEPTH_NORMAL: number
public	V ALLOW_FLOAT_RENDER_TARGET: boolean

collections

summary
public	C AvlTree
public	C BinarySearchTree

glmatrix

summary
public	F equals(a: Number, b: Number): Boolean Tests whether or not the arguments have approximately the same value, within an absolute or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less than or equal to 1.0, and a relative tolerance is used for larger values)
public	F setMatrixArrayType(type: Float32ArrayConstructor \| ArrayConstructor) Sets the type of array used when creating new vectors and matrices
public	F toRadian(a: Number): * Convert Degree To Radian
public	F LDU(L: ReadonlyMat2, D: ReadonlyMat2, U: ReadonlyMat2, a: ReadonlyMat2): undefined[] Returns L, D and U matrices (Lower triangular, Diagonal and Upper triangular) by factorizing the input matrix
public	F add(out: mat2, a: ReadonlyMat2, b: ReadonlyMat2): mat2 Adds two mat2's
public	F adjoint(out: mat2, a: ReadonlyMat2): mat2 Calculates the adjugate of a mat2
public	F clone(a: ReadonlyMat2): mat2 Creates a new mat2 initialized with values from an existing matrix
public	F copy(out: mat2, a: ReadonlyMat2): mat2 Copy the values from one mat2 to another
public	F create(): mat2 Creates a new identity mat2
public	F determinant(a: ReadonlyMat2): Number Calculates the determinant of a mat2
public	F equals(a: ReadonlyMat2, b: ReadonlyMat2): Boolean Returns whether or not the matrices have approximately the same elements in the same position.
public	F exactEquals(a: ReadonlyMat2, b: ReadonlyMat2): Boolean Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
public	F frob(a: ReadonlyMat2): Number Returns Frobenius norm of a mat2
public	F fromRotation(out: mat2, rad: Number): mat2 Creates a matrix from a given angle This is equivalent to (but much faster than):
public	F fromScaling(out: mat2, v: ReadonlyVec2): mat2 Creates a matrix from a vector scaling This is equivalent to (but much faster than):
public	F fromValues(m00: Number, m01: Number, m10: Number, m11: Number): mat2 Create a new mat2 with the given values
public	F identity(out: mat2): mat2 Set a mat2 to the identity matrix
public	F invert(out: mat2, a: ReadonlyMat2): mat2 Inverts a mat2
public	F multiply(out: mat2, a: ReadonlyMat2, b: ReadonlyMat2): mat2 Multiplies two mat2's
public	F multiplyScalar(out: mat2, a: ReadonlyMat2, b: Number): mat2 Multiply each element of the matrix by a scalar.
public	F multiplyScalarAndAdd(out: mat2, a: ReadonlyMat2, b: ReadonlyMat2, scale: Number): mat2 Adds two mat2's after multiplying each element of the second operand by a scalar value.
public	F rotate(out: mat2, a: ReadonlyMat2, rad: Number): mat2 Rotates a mat2 by the given angle
public	F scale(out: mat2, a: ReadonlyMat2, v: ReadonlyVec2): mat2 Scales the mat2 by the dimensions in the given vec2
public	F set(out: mat2, m00: Number, m01: Number, m10: Number, m11: Number): mat2 Set the components of a mat2 to the given values
public	F str(a: ReadonlyMat2): String Returns a string representation of a mat2
public	F subtract(out: mat2, a: ReadonlyMat2, b: ReadonlyMat2): mat2 Subtracts matrix b from matrix a
public	F transpose(out: mat2, a: ReadonlyMat2): mat2 Transpose the values of a mat2
public	F add(out: mat2d, a: ReadonlyMat2d, b: ReadonlyMat2d): mat2d Adds two mat2d's
public	F clone(a: ReadonlyMat2d): mat2d Creates a new mat2d initialized with values from an existing matrix
public	F copy(out: mat2d, a: ReadonlyMat2d): mat2d Copy the values from one mat2d to another
public	F create(): mat2d Creates a new identity mat2d
public	F determinant(a: ReadonlyMat2d): Number Calculates the determinant of a mat2d
public	F equals(a: ReadonlyMat2d, b: ReadonlyMat2d): Boolean Returns whether or not the matrices have approximately the same elements in the same position.
public	F exactEquals(a: ReadonlyMat2d, b: ReadonlyMat2d): Boolean Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
public	F frob(a: ReadonlyMat2d): Number Returns Frobenius norm of a mat2d
public	F fromRotation(out: mat2d, rad: Number): mat2d Creates a matrix from a given angle This is equivalent to (but much faster than):
public	F fromScaling(out: mat2d, v: ReadonlyVec2): mat2d Creates a matrix from a vector scaling This is equivalent to (but much faster than):
public	F fromTranslation(out: mat2d, v: ReadonlyVec2): mat2d Creates a matrix from a vector translation This is equivalent to (but much faster than):
public	F fromValues(a: Number, b: Number, c: Number, d: Number, tx: Number, ty: Number): mat2d Create a new mat2d with the given values
public	F identity(out: mat2d): mat2d Set a mat2d to the identity matrix
public	F invert(out: mat2d, a: ReadonlyMat2d): mat2d Inverts a mat2d
public	F multiply(out: mat2d, a: ReadonlyMat2d, b: ReadonlyMat2d): mat2d Multiplies two mat2d's
public	F multiplyScalar(out: mat2d, a: ReadonlyMat2d, b: Number): mat2d Multiply each element of the matrix by a scalar.
public	F multiplyScalarAndAdd(out: mat2d, a: ReadonlyMat2d, b: ReadonlyMat2d, scale: Number): mat2d Adds two mat2d's after multiplying each element of the second operand by a scalar value.
public	F rotate(out: mat2d, a: ReadonlyMat2d, rad: Number): mat2d Rotates a mat2d by the given angle
public	F scale(out: mat2d, a: ReadonlyMat2d, v: ReadonlyVec2): mat2d Scales the mat2d by the dimensions in the given vec2
public	F set(out: mat2d, a: Number, b: Number, c: Number, d: Number, tx: Number, ty: Number): mat2d Set the components of a mat2d to the given values
public	F str(a: ReadonlyMat2d): String Returns a string representation of a mat2d
public	F subtract(out: mat2d, a: ReadonlyMat2d, b: ReadonlyMat2d): mat2d Subtracts matrix b from matrix a
public	F translate(out: mat2d, a: ReadonlyMat2d, v: ReadonlyVec2): mat2d Translates the mat2d by the dimensions in the given vec2
public	F add(out: mat3, a: ReadonlyMat3, b: ReadonlyMat3): mat3 Adds two mat3's
public	F adjoint(out: mat3, a: ReadonlyMat3): mat3 Calculates the adjugate of a mat3
public	F clone(a: ReadonlyMat3): mat3 Creates a new mat3 initialized with values from an existing matrix
public	F copy(out: mat3, a: ReadonlyMat3): mat3 Copy the values from one mat3 to another
public	F create(): mat3 Creates a new identity mat3
public	F determinant(a: ReadonlyMat3): Number Calculates the determinant of a mat3
public	F equals(a: ReadonlyMat3, b: ReadonlyMat3): Boolean Returns whether or not the matrices have approximately the same elements in the same position.
public	F exactEquals(a: ReadonlyMat3, b: ReadonlyMat3): Boolean Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
public	F frob(a: ReadonlyMat3): Number Returns Frobenius norm of a mat3
public	F fromMat2d(out: mat3, a: ReadonlyMat2d): mat3 Copies the values from a mat2d into a mat3
public	F fromMat4(out: mat3, a: ReadonlyMat4): mat3 Copies the upper-left 3x3 values into the given mat3.
public	F fromQuat(out: mat3, q: ReadonlyQuat): mat3 Calculates a 3x3 matrix from the given quaternion
public	F fromRotation(out: mat3, rad: Number): mat3 Creates a matrix from a given angle This is equivalent to (but much faster than):
public	F fromScaling(out: mat3, v: ReadonlyVec2): mat3 Creates a matrix from a vector scaling This is equivalent to (but much faster than):
public	F fromTranslation(out: mat3, v: ReadonlyVec2): mat3 Creates a matrix from a vector translation This is equivalent to (but much faster than):
public	F fromValues(m00: Number, m01: Number, m02: Number, m10: Number, m11: Number, m12: Number, m20: Number, m21: Number, m22: Number): mat3 Create a new mat3 with the given values
public	F identity(out: mat3): mat3 Set a mat3 to the identity matrix
public	F invert(out: mat3, a: ReadonlyMat3): mat3 Inverts a mat3
public	F multiply(out: mat3, a: ReadonlyMat3, b: ReadonlyMat3): mat3 Multiplies two mat3's
public	F multiplyScalar(out: mat3, a: ReadonlyMat3, b: Number): mat3 Multiply each element of the matrix by a scalar.
public	F multiplyScalarAndAdd(out: mat3, a: ReadonlyMat3, b: ReadonlyMat3, scale: Number): mat3 Adds two mat3's after multiplying each element of the second operand by a scalar value.
public	F normalFromMat4(out: mat3, a: ReadonlyMat4): mat3 Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix
public	F projection(out: mat3, width: number, height: number): mat3 Generates a 2D projection matrix with the given bounds
public	F rotate(out: mat3, a: ReadonlyMat3, rad: Number): mat3 Rotates a mat3 by the given angle
public	F scale(out: mat3, a: ReadonlyMat3, v: ReadonlyVec2): mat3 Scales the mat3 by the dimensions in the given vec2
public	F set(out: mat3, m00: Number, m01: Number, m02: Number, m10: Number, m11: Number, m12: Number, m20: Number, m21: Number, m22: Number): mat3 Set the components of a mat3 to the given values
public	F str(a: ReadonlyMat3): String Returns a string representation of a mat3
public	F subtract(out: mat3, a: ReadonlyMat3, b: ReadonlyMat3): mat3 Subtracts matrix b from matrix a
public	F translate(out: mat3, a: ReadonlyMat3, v: ReadonlyVec2): mat3 Translate a mat3 by the given vector
public	F transpose(out: mat3, a: ReadonlyMat3): mat3 Transpose the values of a mat3
public	F add(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4): mat4 Adds two mat4's
public	F adjoint(out: mat4, a: ReadonlyMat4): mat4 Calculates the adjugate of a mat4
public	F clone(a: ReadonlyMat4): mat4 Creates a new mat4 initialized with values from an existing matrix
public	F copy(out: mat4, a: ReadonlyMat4): mat4 Copy the values from one mat4 to another
public	F create(): mat4 Creates a new identity mat4
public	F determinant(a: ReadonlyMat4): Number Calculates the determinant of a mat4
public	F equals(a: ReadonlyMat4, b: ReadonlyMat4): Boolean Returns whether or not the matrices have approximately the same elements in the same position.
public	F exactEquals(a: ReadonlyMat4, b: ReadonlyMat4): Boolean Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
public	F frob(a: ReadonlyMat4): Number Returns Frobenius norm of a mat4
public	F fromQuat(out: mat4, q: ReadonlyQuat): mat4 Calculates a 4x4 matrix from the given quaternion
public	F fromQuat2(out: mat4, a: ReadonlyQuat2): mat4 Creates a new mat4 from a dual quat.
public	F fromRotation(out: mat4, rad: Number, axis: ReadonlyVec3): mat4 Creates a matrix from a given angle around a given axis This is equivalent to (but much faster than):
public	F fromRotationTranslation(out: mat4, q: quat4, v: ReadonlyVec3): mat4 Creates a matrix from a quaternion rotation and vector translation This is equivalent to (but much faster than):
public	F fromRotationTranslationScale(out: mat4, q: quat4, v: ReadonlyVec3, s: ReadonlyVec3): mat4 Creates a matrix from a quaternion rotation, vector translation and vector scale This is equivalent to (but much faster than):
public	F fromRotationTranslationScaleOrigin(out: mat4, q: quat4, v: ReadonlyVec3, s: ReadonlyVec3, o: ReadonlyVec3): mat4 Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin This is equivalent to (but much faster than):
public	F fromScaling(out: mat4, v: ReadonlyVec3): mat4 Creates a matrix from a vector scaling This is equivalent to (but much faster than):
public	F fromTranslation(out: mat4, v: ReadonlyVec3): mat4 Creates a matrix from a vector translation This is equivalent to (but much faster than):
public	F fromValues(m00: Number, m01: Number, m02: Number, m03: Number, m10: Number, m11: Number, m12: Number, m13: Number, m20: Number, m21: Number, m22: Number, m23: Number, m30: Number, m31: Number, m32: Number, m33: Number): mat4 Create a new mat4 with the given values
public	F fromXRotation(out: mat4, rad: Number): mat4 Creates a matrix from the given angle around the X axis This is equivalent to (but much faster than):
public	F fromYRotation(out: mat4, rad: Number): mat4 Creates a matrix from the given angle around the Y axis This is equivalent to (but much faster than):
public	F fromZRotation(out: mat4, rad: Number): mat4 Creates a matrix from the given angle around the Z axis This is equivalent to (but much faster than):
public	F frustum(out: mat4, left: Number, right: Number, bottom: Number, top: Number, near: Number, far: Number): mat4 Generates a frustum matrix with the given bounds
public	F getRotation(out: quat, mat: ReadonlyMat4): quat Returns a quaternion representing the rotational component of a transformation matrix.
public	F getScaling(out: vec3, mat: ReadonlyMat4): vec3 Returns the scaling factor component of a transformation matrix.
public	F getTranslation(out: vec3, mat: ReadonlyMat4): vec3 Returns the translation vector component of a transformation matrix.
public	F identity(out: mat4): mat4 Set a mat4 to the identity matrix
public	F invert(out: mat4, a: ReadonlyMat4): mat4 Inverts a mat4
public	F lookAt(out: mat4, eye: ReadonlyVec3, center: ReadonlyVec3, up: ReadonlyVec3): mat4 Generates a look-at matrix with the given eye position, focal point, and up axis.
public	F multiply(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4): mat4 Multiplies two mat4s
public	F multiplyScalar(out: mat4, a: ReadonlyMat4, b: Number): mat4 Multiply each element of the matrix by a scalar.
public	F multiplyScalarAndAdd(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4, scale: Number): mat4 Adds two mat4's after multiplying each element of the second operand by a scalar value.
public	F ortho(out: mat4, left: number, right: number, bottom: number, top: number, near: number, far: number): mat4 Generates a orthogonal projection matrix with the given bounds
public	F perspective(out: mat4, fovy: number, aspect: number, near: number, far: number): mat4 Generates a perspective projection matrix with the given bounds.
public	F perspectiveFromFieldOfView(out: mat4, fov: Object, near: number, far: number): mat4 Generates a perspective projection matrix with the given field of view.
public	F rotate(out: mat4, a: ReadonlyMat4, rad: Number, axis: ReadonlyVec3): mat4 Rotates a mat4 by the given angle around the given axis
public	F rotateX(out: mat4, a: ReadonlyMat4, rad: Number): mat4 Rotates a matrix by the given angle around the X axis
public	F rotateY(out: mat4, a: ReadonlyMat4, rad: Number): mat4 Rotates a matrix by the given angle around the Y axis
public	F rotateZ(out: mat4, a: ReadonlyMat4, rad: Number): mat4 Rotates a matrix by the given angle around the Z axis
public	F scale(out: mat4, a: ReadonlyMat4, v: ReadonlyVec3): mat4 Scales the mat4 by the dimensions in the given vec3 not using vectorization
public	F set(out: mat4, m00: Number, m01: Number, m02: Number, m03: Number, m10: Number, m11: Number, m12: Number, m13: Number, m20: Number, m21: Number, m22: Number, m23: Number, m30: Number, m31: Number, m32: Number, m33: Number): mat4 Set the components of a mat4 to the given values
public	F str(a: ReadonlyMat4): String Returns a string representation of a mat4
public	F subtract(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4): mat4 Subtracts matrix b from matrix a
public	F targetTo(out: mat4, eye: ReadonlyVec3, center: ReadonlyVec3, up: ReadonlyVec3): mat4 Generates a matrix that makes something look at something else.
public	F translate(out: mat4, a: ReadonlyMat4, v: ReadonlyVec3): mat4 Translate a mat4 by the given vector
public	F transpose(out: mat4, a: ReadonlyMat4): mat4 Transpose the values of a mat4
public	F calculateW(out: quat, a: ReadonlyQuat): quat Calculates the W component of a quat from the X, Y, and Z components.
public	F conjugate(out: quat, a: ReadonlyQuat): quat Calculates the conjugate of a quat If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.
public	F create(): quat Creates a new identity quat
public	F exp(out: quat, a: ReadonlyQuat): quat Calculate the exponential of a unit quaternion.
public	F fromEuler(out: quat, Angle: x, Angle: y, Angle: z): quat Creates a quaternion from the given euler angle x, y, z.
public	F fromMat3(out: quat, m: ReadonlyMat3): quat Creates a quaternion from the given 3x3 rotation matrix.
public	F getAngle(a: ReadonlyQuat, b: ReadonlyQuat): Number Gets the angular distance between two unit quaternions
public	F getAxisAngle(out_axis: vec3, q: ReadonlyQuat): Number Gets the rotation axis and angle for a given quaternion.
public	F identity(out: quat): quat Set a quat to the identity quaternion
public	F invert(out: quat, a: ReadonlyQuat): quat Calculates the inverse of a quat
public	F ln(out: quat, a: ReadonlyQuat): quat Calculate the natural logarithm of a unit quaternion.
public	F multiply(out: quat, a: ReadonlyQuat, b: ReadonlyQuat): quat Multiplies two quat's
public	F pow(out: quat, a: ReadonlyQuat, b: Number): quat Calculate the scalar power of a unit quaternion.
public	F random(out: quat): quat Generates a random unit quaternion
public	F rotateX(out: quat, a: ReadonlyQuat, rad: number): quat Rotates a quaternion by the given angle about the X axis
public	F rotateY(out: quat, a: ReadonlyQuat, rad: number): quat Rotates a quaternion by the given angle about the Y axis
public	F rotateZ(out: quat, a: ReadonlyQuat, rad: number): quat Rotates a quaternion by the given angle about the Z axis
public	F setAxisAngle(out: quat, axis: ReadonlyVec3, rad: Number): quat Sets a quat from the given angle and rotation axis, then returns it.
public	F slerp(out: quat, a: ReadonlyQuat, b: ReadonlyQuat, t: Number): quat Performs a spherical linear interpolation between two quat
public	F str(a: ReadonlyQuat): String Returns a string representation of a quatenion
public	F add(out: quat2, a: ReadonlyQuat2, b: ReadonlyQuat2): quat2 Adds two dual quat's
public	F clone(a: ReadonlyQuat2): quat2 Creates a new quat initialized with values from an existing quaternion
public	F conjugate(out: quat2, a: ReadonlyQuat2): quat2 Calculates the conjugate of a dual quat If the dual quaternion is normalized, this function is faster than quat2.inverse and produces the same result.
public	F copy(out: quat2, a: ReadonlyQuat2): quat2 Copy the values from one dual quat to another
public	F create(): quat2 Creates a new identity dual quat
public	F equals(a: ReadonlyQuat2, b: ReadonlyQuat2): Boolean Returns whether or not the dual quaternions have approximately the same elements in the same position.
public	F exactEquals(a: ReadonlyQuat2, b: ReadonlyQuat2): Boolean Returns whether or not the dual quaternions have exactly the same elements in the same position (when compared with ===)
public	F fromMat4(out: quat2, a: ReadonlyMat4): quat2 Creates a new dual quat from a matrix (4x4)
public	F fromRotation(dual: ReadonlyQuat2, q: ReadonlyQuat): quat2 Creates a dual quat from a quaternion
public	F fromRotationTranslation(dual: ReadonlyQuat2, q: ReadonlyQuat, t: ReadonlyVec3): quat2 Creates a dual quat from a quaternion and a translation
public	F fromRotationTranslationValues(x1: Number, y1: Number, z1: Number, w1: Number, x2: Number, y2: Number, z2: Number): quat2 Creates a new dual quat from the given values (quat and translation)
public	F fromTranslation(dual: ReadonlyQuat2, t: ReadonlyVec3): quat2 Creates a dual quat from a translation
public	F fromValues(x1: Number, y1: Number, z1: Number, w1: Number, x2: Number, y2: Number, z2: Number, w2: Number): quat2 Creates a new dual quat initialized with the given values
public	F getDual(out: quat, a: ReadonlyQuat2): quat Gets the dual part of a dual quat
public	F getTranslation(out: vec3, a: ReadonlyQuat2): vec3 Gets the translation of a normalized dual quat
public	F identity(out: quat2): quat2 Set a dual quat to the identity dual quaternion
public	F invert(out: quat2, a: ReadonlyQuat2): quat2 Calculates the inverse of a dual quat.
public	F lerp(out: quat2, a: ReadonlyQuat2, b: ReadonlyQuat2, t: Number): quat2 Performs a linear interpolation between two dual quats's NOTE: The resulting dual quaternions won't always be normalized (The error is most noticeable when t = 0.5)
public	F multiply(out: quat2, a: ReadonlyQuat2, b: ReadonlyQuat2): quat2 Multiplies two dual quat's
public	F normalize(out: quat2, a: ReadonlyQuat2): quat2 Normalize a dual quat
public	F rotateAroundAxis(out: quat2, a: ReadonlyQuat2, axis: ReadonlyVec3, rad: Number): quat2 Rotates a dual quat around a given axis.
public	F rotateByQuatAppend(out: quat2, a: ReadonlyQuat2, q: ReadonlyQuat): quat2 Rotates a dual quat by a given quaternion (a * q)
public	F rotateByQuatPrepend(out: quat2, q: ReadonlyQuat, a: ReadonlyQuat2): quat2 Rotates a dual quat by a given quaternion (q * a)
public	F rotateX(out: quat2, a: ReadonlyQuat2, rad: number): quat2 Rotates a dual quat around the X axis
public	F rotateY(out: quat2, a: ReadonlyQuat2, rad: number): quat2 Rotates a dual quat around the Y axis
public	F rotateZ(out: quat2, a: ReadonlyQuat2, rad: number): quat2 Rotates a dual quat around the Z axis
public	F scale(out: quat2, a: ReadonlyQuat2, b: Number): quat2 Scales a dual quat by a scalar number
public	F set(out: quat2, x1: Number, y1: Number, z1: Number, w1: Number, x2: Number, y2: Number, z2: Number, w2: Number): quat2 Set the components of a dual quat to the given values
public	F setDual(out: quat2, q: ReadonlyQuat): quat2 Set the dual component of a dual quat to the given quaternion
public	F str(a: ReadonlyQuat2): String Returns a string representation of a dual quatenion
public	F translate(out: quat2, a: ReadonlyQuat2, v: ReadonlyVec3): quat2 Translates a dual quat by the given vector
public	F add(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2 Adds two vec2's
public	F angle(a: ReadonlyVec2, b: ReadonlyVec2): Number Get the angle between two 2D vectors
public	F ceil(out: vec2, a: ReadonlyVec2): vec2 Math.ceil the components of a vec2
public	F clone(a: ReadonlyVec2): vec2 Creates a new vec2 initialized with values from an existing vector
public	F copy(out: vec2, a: ReadonlyVec2): vec2 Copy the values from one vec2 to another
public	F create(): vec2 Creates a new, empty vec2
public	F cross(out: vec3, a: ReadonlyVec2, b: ReadonlyVec2): vec3 Computes the cross product of two vec2's Note that the cross product must by definition produce a 3D vector
public	F distance(a: ReadonlyVec2, b: ReadonlyVec2): Number Calculates the euclidian distance between two vec2's
public	F divide(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2 Divides two vec2's
public	F dot(a: ReadonlyVec2, b: ReadonlyVec2): Number Calculates the dot product of two vec2's
public	F equals(a: ReadonlyVec2, b: ReadonlyVec2): Boolean Returns whether or not the vectors have approximately the same elements in the same position.
public	F exactEquals(a: ReadonlyVec2, b: ReadonlyVec2): Boolean Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
public	F floor(out: vec2, a: ReadonlyVec2): vec2 Math.floor the components of a vec2
public	F fromValues(x: Number, y: Number): vec2 Creates a new vec2 initialized with the given values
public	F inverse(out: vec2, a: ReadonlyVec2): vec2 Returns the inverse of the components of a vec2
public	F length(a: ReadonlyVec2): Number Calculates the length of a vec2
public	F lerp(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2, t: Number): vec2 Performs a linear interpolation between two vec2's
public	F max(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2 Returns the maximum of two vec2's
public	F min(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2 Returns the minimum of two vec2's
public	F multiply(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2 Multiplies two vec2's
public	F negate(out: vec2, a: ReadonlyVec2): vec2 Negates the components of a vec2
public	F normalize(out: vec2, a: ReadonlyVec2): vec2 Normalize a vec2
public	F random(out: vec2, scale: Number): vec2 Generates a random vector with the given scale
public	F rotate(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2, rad: Number): vec2 Rotate a 2D vector
public	F round(out: vec2, a: ReadonlyVec2): vec2 Math.round the components of a vec2
public	F scale(out: vec2, a: ReadonlyVec2, b: Number): vec2 Scales a vec2 by a scalar number
public	F scaleAndAdd(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2, scale: Number): vec2 Adds two vec2's after scaling the second operand by a scalar value
public	F set(out: vec2, x: Number, y: Number): vec2 Set the components of a vec2 to the given values
public	F squaredDistance(a: ReadonlyVec2, b: ReadonlyVec2): Number Calculates the squared euclidian distance between two vec2's
public	F squaredLength(a: ReadonlyVec2): Number Calculates the squared length of a vec2
public	F str(a: ReadonlyVec2): String Returns a string representation of a vector
public	F subtract(out: vec2, a: ReadonlyVec2, b: ReadonlyVec2): vec2 Subtracts vector b from vector a
public	F transformMat2(out: vec2, a: ReadonlyVec2, m: ReadonlyMat2): vec2 Transforms the vec2 with a mat2
public	F transformMat2d(out: vec2, a: ReadonlyVec2, m: ReadonlyMat2d): vec2 Transforms the vec2 with a mat2d
public	F transformMat3(out: vec2, a: ReadonlyVec2, m: ReadonlyMat3): vec2 Transforms the vec2 with a mat3 3rd vector component is implicitly '1'
public	F transformMat4(out: vec2, a: ReadonlyVec2, m: ReadonlyMat4): vec2 Transforms the vec2 with a mat4 3rd vector component is implicitly '0' 4th vector component is implicitly '1'
public	F zero(out: vec2): vec2 Set the components of a vec2 to zero
public	F add(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3): vec3 Adds two vec3's
public	F angle(a: ReadonlyVec3, b: ReadonlyVec3): Number Get the angle between two 3D vectors
public	F bezier(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3, c: ReadonlyVec3, d: ReadonlyVec3, t: Number): vec3 Performs a bezier interpolation with two control points
public	F ceil(out: vec3, a: ReadonlyVec3): vec3 Math.ceil the components of a vec3
public	F clone(a: ReadonlyVec3): vec3 Creates a new vec3 initialized with values from an existing vector
public	F copy(out: vec3, a: ReadonlyVec3): vec3 Copy the values from one vec3 to another
public	F create(): vec3 Creates a new, empty vec3
public	F cross(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3): vec3 Computes the cross product of two vec3's
public	F distance(a: ReadonlyVec3, b: ReadonlyVec3): Number Calculates the euclidian distance between two vec3's
public	F divide(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3): vec3 Divides two vec3's
public	F dot(a: ReadonlyVec3, b: ReadonlyVec3): Number Calculates the dot product of two vec3's
public	F equals(a: ReadonlyVec3, b: ReadonlyVec3): Boolean Returns whether or not the vectors have approximately the same elements in the same position.
public	F exactEquals(a: ReadonlyVec3, b: ReadonlyVec3): Boolean Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
public	F floor(out: vec3, a: ReadonlyVec3): vec3 Math.floor the components of a vec3
public	F fromValues(x: Number, y: Number, z: Number): vec3 Creates a new vec3 initialized with the given values
public	F hermite(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3, c: ReadonlyVec3, d: ReadonlyVec3, t: Number): vec3 Performs a hermite interpolation with two control points
public	F inverse(out: vec3, a: ReadonlyVec3): vec3 Returns the inverse of the components of a vec3
public	F length(a: ReadonlyVec3): Number Calculates the length of a vec3
public	F lerp(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3, t: Number): vec3 Performs a linear interpolation between two vec3's
public	F max(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3): vec3 Returns the maximum of two vec3's
public	F min(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3): vec3 Returns the minimum of two vec3's
public	F multiply(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3): vec3 Multiplies two vec3's
public	F negate(out: vec3, a: ReadonlyVec3): vec3 Negates the components of a vec3
public	F normalize(out: vec3, a: ReadonlyVec3): vec3 Normalize a vec3
public	F random(out: vec3, scale: Number): vec3 Generates a random vector with the given scale
public	F rotateX(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3, rad: Number): vec3 Rotate a 3D vector around the x-axis
public	F rotateY(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3, rad: Number): vec3 Rotate a 3D vector around the y-axis
public	F rotateZ(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3, rad: Number): vec3 Rotate a 3D vector around the z-axis
public	F round(out: vec3, a: ReadonlyVec3): vec3 Math.round the components of a vec3
public	F scale(out: vec3, a: ReadonlyVec3, b: Number): vec3 Scales a vec3 by a scalar number
public	F scaleAndAdd(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3, scale: Number): vec3 Adds two vec3's after scaling the second operand by a scalar value
public	F set(out: vec3, x: Number, y: Number, z: Number): vec3 Set the components of a vec3 to the given values
public	F squaredDistance(a: ReadonlyVec3, b: ReadonlyVec3): Number Calculates the squared euclidian distance between two vec3's
public	F squaredLength(a: ReadonlyVec3): Number Calculates the squared length of a vec3
public	F str(a: ReadonlyVec3): String Returns a string representation of a vector
public	F subtract(out: vec3, a: ReadonlyVec3, b: ReadonlyVec3): vec3 Subtracts vector b from vector a
public	F transformMat3(out: vec3, a: ReadonlyVec3, m: ReadonlyMat3): vec3 Transforms the vec3 with a mat3.
public	F transformMat4(out: vec3, a: ReadonlyVec3, m: ReadonlyMat4): vec3 Transforms the vec3 with a mat4.
public	F transformQuat(out: vec3, a: ReadonlyVec3, q: ReadonlyQuat): vec3 Transforms the vec3 with a quat Can also be used for dual quaternions.
public	F zero(out: vec3): vec3 Set the components of a vec3 to zero
public	F add(out: vec4, a: ReadonlyVec4, b: ReadonlyVec4): vec4 Adds two vec4's
public	F ceil(out: vec4, a: ReadonlyVec4): vec4 Math.ceil the components of a vec4
public	F clone(a: ReadonlyVec4): vec4 Creates a new vec4 initialized with values from an existing vector
public	F copy(out: vec4, a: ReadonlyVec4): vec4 Copy the values from one vec4 to another
public	F create(): vec4 Creates a new, empty vec4
public	F cross(result: ReadonlyVec4, U: ReadonlyVec4, V: ReadonlyVec4, W: ReadonlyVec4): vec4 Returns the cross-product of three vectors in a 4-dimensional space
public	F distance(a: ReadonlyVec4, b: ReadonlyVec4): Number Calculates the euclidian distance between two vec4's
public	F divide(out: vec4, a: ReadonlyVec4, b: ReadonlyVec4): vec4 Divides two vec4's
public	F dot(a: ReadonlyVec4, b: ReadonlyVec4): Number Calculates the dot product of two vec4's
public	F equals(a: ReadonlyVec4, b: ReadonlyVec4): Boolean Returns whether or not the vectors have approximately the same elements in the same position.
public	F exactEquals(a: ReadonlyVec4, b: ReadonlyVec4): Boolean Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
public	F floor(out: vec4, a: ReadonlyVec4): vec4 Math.floor the components of a vec4
public	F fromValues(x: Number, y: Number, z: Number, w: Number): vec4 Creates a new vec4 initialized with the given values
public	F inverse(out: vec4, a: ReadonlyVec4): vec4 Returns the inverse of the components of a vec4
public	F length(a: ReadonlyVec4): Number Calculates the length of a vec4
public	F lerp(out: vec4, a: ReadonlyVec4, b: ReadonlyVec4, t: Number): vec4 Performs a linear interpolation between two vec4's
public	F max(out: vec4, a: ReadonlyVec4, b: ReadonlyVec4): vec4 Returns the maximum of two vec4's
public	F min(out: vec4, a: ReadonlyVec4, b: ReadonlyVec4): vec4 Returns the minimum of two vec4's
public	F multiply(out: vec4, a: ReadonlyVec4, b: ReadonlyVec4): vec4 Multiplies two vec4's
public	F negate(out: vec4, a: ReadonlyVec4): vec4 Negates the components of a vec4
public	F normalize(out: vec4, a: ReadonlyVec4): vec4 Normalize a vec4
public	F random(out: vec4, scale: Number): vec4 Generates a random vector with the given scale
public	F round(out: vec4, a: ReadonlyVec4): vec4 Math.round the components of a vec4
public	F scale(out: vec4, a: ReadonlyVec4, b: Number): vec4 Scales a vec4 by a scalar number
public	F scaleAndAdd(out: vec4, a: ReadonlyVec4, b: ReadonlyVec4, scale: Number): vec4 Adds two vec4's after scaling the second operand by a scalar value
public	F set(out: vec4, x: Number, y: Number, z: Number, w: Number): vec4 Set the components of a vec4 to the given values
public	F squaredDistance(a: ReadonlyVec4, b: ReadonlyVec4): Number Calculates the squared euclidian distance between two vec4's
public	F squaredLength(a: ReadonlyVec4): Number Calculates the squared length of a vec4
public	F str(a: ReadonlyVec4): String Returns a string representation of a vector
public	F subtract(out: vec4, a: ReadonlyVec4, b: ReadonlyVec4): vec4 Subtracts vector b from vector a
public	F transformMat4(out: vec4, a: ReadonlyVec4, m: ReadonlyMat4): vec4 Transforms the vec4 with a mat4.
public	F transformQuat(out: vec4, a: ReadonlyVec4, q: ReadonlyQuat): vec4 Transforms the vec4 with a quat
public	F zero(out: vec4): vec4 Set the components of a vec4 to zero
public	V ARRAY_TYPE: *
public	V EPSILON: number Common utilities
public	V RANDOM: *
public	V mul: * Alias for mat2.multiply
public	V sub: * Alias for mat2.subtract
public	V mul: * Alias for mat2d.multiply
public	V sub: * Alias for mat2d.subtract
public	V mul: * Alias for mat3.multiply
public	V sub: * Alias for mat3.subtract
public	V mul: * Alias for mat4.multiply
public	V sub: * Alias for mat4.subtract
public	V add(out: quat, a: ReadonlyQuat, b: ReadonlyQuat): quat: * Adds two quat's
public	V clone(a: ReadonlyQuat): quat: * Creates a new quat initialized with values from an existing quaternion
public	V copy(out: quat, a: ReadonlyQuat): quat: * Copy the values from one quat to another
public	V dot(a: ReadonlyQuat, b: ReadonlyQuat): Number: * Calculates the dot product of two quat's
public	V equals(a: ReadonlyQuat, b: ReadonlyQuat): Boolean: * Returns whether or not the quaternions have approximately the same elements in the same position.
public	V exactEquals(a: ReadonlyQuat, b: ReadonlyQuat): Boolean: * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
public	V fromValues(x: Number, y: Number, z: Number, w: Number): quat: * Creates a new quat initialized with the given values
public	V len: * Alias for quat.length
public	V length(a: ReadonlyQuat): Number: * Calculates the length of a quat
public	V lerp(out: quat, a: ReadonlyQuat, b: ReadonlyQuat, t: Number): quat: * Performs a linear interpolation between two quat's
public	V mul: * Alias for quat.multiply
public	V normalize(out: quat, a: ReadonlyQuat): quat: * Normalize a quat
public	V rotationTo(out: quat, a: ReadonlyVec3, b: ReadonlyVec3): quat: * Sets a quaternion to represent the shortest rotation from one vector to another.
public	V scale(out: quat, a: ReadonlyQuat, b: Number): quat: * Scales a quat by a scalar number
public	V set(out: quat, x: Number, y: Number, z: Number, w: Number): quat: * Set the components of a quat to the given values
public	V setAxes(view: ReadonlyVec3, right: ReadonlyVec3, up: ReadonlyVec3): quat: * Sets the specified quaternion with values corresponding to the given axes.
public	V sqlerp(out: quat, a: ReadonlyQuat, b: ReadonlyQuat, c: ReadonlyQuat, d: ReadonlyQuat, t: Number): quat: * Performs a spherical linear interpolation with two control points
public	V sqrLen: * Alias for quat.squaredLength
public	V squaredLength(a: ReadonlyQuat): Number: * Calculates the squared length of a quat
public	V dot(a: ReadonlyQuat2, b: ReadonlyQuat2): Number: * Calculates the dot product of two dual quat's (The dot product of the real parts)
public	V getReal(out: quat, a: ReadonlyQuat2): quat: * Gets the real part of a dual quat
public	V len: * Alias for quat2.length
public	V length(a: ReadonlyQuat2): Number: * Calculates the length of a dual quat
public	V mul: * Alias for quat2.multiply
public	V setReal(out: quat2, q: ReadonlyQuat): quat2: * Set the real component of a dual quat to the given quaternion
public	V sqrLen: * Alias for quat2.squaredLength
public	V squaredLength(a: ReadonlyQuat2): Number: * Calculates the squared length of a dual quat
public	V dist: * Alias for vec2.distance
public	V div: * Alias for vec2.divide
public	V forEach(a: Array, stride: Number, offset: Number, count: Number, fn: Function, arg: Object): Array: * Perform some operation over an array of vec2s.
public	V len: * Alias for vec2.length
public	V mul: * Alias for vec2.multiply
public	V sqrDist: * Alias for vec2.squaredDistance
public	V sqrLen: * Alias for vec2.squaredLength
public	V sub: * Alias for vec2.subtract
public	V dist: * Alias for vec3.distance
public	V div: * Alias for vec3.divide
public	V forEach(a: Array, stride: Number, offset: Number, count: Number, fn: Function, arg: Object): Array: * Perform some operation over an array of vec3s.
public	V len: * Alias for vec3.length
public	V mul: * Alias for vec3.multiply
public	V sqrDist: * Alias for vec3.squaredDistance
public	V sqrLen: * Alias for vec3.squaredLength
public	V sub: * Alias for vec3.subtract
public	V dist: * Alias for vec4.distance
public	V div: * Alias for vec4.divide
public	V forEach(a: Array, stride: Number, offset: Number, count: Number, fn: Function, arg: Object): Array: * Perform some operation over an array of vec4s.
public	V len: * Alias for vec4.length
public	V mul: * Alias for vec4.multiply
public	V sqrDist: * Alias for vec4.squaredDistance
public	V sqrLen: * Alias for vec4.squaredLength
public	V sub: * Alias for vec4.subtract

shaders

summary
public	V FRAGMENT_SHADER_SOURCE: string
public	V VERTEX_SHADER_SOURCE: string

Directories

collections

glmatrix

shaders