@1pizzateam/roostr 0.7.0 → 0.8.1

package/dist/roostr.d.ts

@@ -24,8 +24,8 @@ SOFTWARE.
 https://github.com/1pizzateam/RoostR.js
 */
 
-import { Mat4x3, Vec2, Vec3, Quat, Mat3, Mat4, Box, Sphere as Sphere$1, Ray3, Frustum, Rect } from '@1pizzateam/spock';
-export { Accumulator, Bezier, Box as BoundingBox, Sphere as BoundingSphere, Circ, Frustum, Grid, Mat3, Mat4, Mat4x3, NumArray, Quat, Rand, Ray3 as Ray, Rect, RollingAverage, Plane as SpatialPlane, Time, Trigo, Utils, Vec2, Vec3 } from '@1pizzateam/spock';
+import { Mat4x3, Vec3, Quat, Mat3, Box, Sphere as Sphere$1, Vec2, Mat4, Ray3, Frustum, Rect } from '@1pizzateam/spock';
+export { Accumulator, Bezier, Box as BoundingBox, Sphere as BoundingSphere, Circ, Frustum, Grid, Mat3, Mat4, Mat4x3, NumArray, Quat, Rand, Ray3 as Ray, Ray2, Rect, RollingAverage, Plane as SpatialPlane, Time, Trigo, Utils, Vec2, Vec3 } from '@1pizzateam/spock';
 
 declare class SceneRenderer {
     context: WebGLRenderingContext;
@@ -34,6 +34,7 @@ declare class SceneRenderer {
     private depthWrite;
     constructor(context: WebGLRenderingContext);
     invalidateState(): void;
+    reset(): void;
     defaultSettings(): void;
     enable(capability: string): void;
     disable(capability: string): void;
@@ -58,6 +59,62 @@ declare class SceneGraph {
     getWorldMatrix(): Mat4x3;
 }
 
+declare class Node<T extends Node<T> = any> {
+    position: Vec3;
+    scale: Vec3;
+    quaternion: Quat;
+    modelMatrix: Mat4x3;
+    worldMatrix: Mat4x3;
+    normalMatrix: Mat3;
+    boundingBox: Box;
+    boundingSphere: Sphere$1;
+    localBoundingBox: Box;
+    localBoundingSphere: Sphere$1;
+    parent: T | null;
+    children: T[];
+    traversalStamp: number;
+    isBoundsDirty: boolean;
+    isNormalMatrixDirty: boolean;
+    isWorldDirty: boolean;
+    private _rotation;
+    private isRotationStale;
+    private isTransformDirty;
+    private static readonly UP;
+    private static readonly scratchQuat;
+    private static readonly scratchVec;
+    constructor();
+    addChild(node: T): void;
+    removeChild(node: T): boolean;
+    markDirty(): void;
+    get rotation(): Vec3;
+    set rotation(euler: Vec3);
+    private rotationChanged;
+    setPosition(position: Vec3): this;
+    setRotation(rotation: Vec3): this;
+    setScale(scale: Vec3): this;
+    scaleBy(factor: Vec3): this;
+    setQuaternion(q: Quat): this;
+    slerp(targetQuat: Quat, t: number): this;
+    rotateX(angle: number): this;
+    rotateY(angle: number): this;
+    rotateZ(angle: number): this;
+    rotateOnAxis(axis: Vec3, angle: number): this;
+    translate(translation: Vec3): this;
+    lookAt(target: Vec3, up?: Vec3): this;
+    updateModelMatrix(): boolean;
+    computeNormalMatrix(): Mat3;
+    getWorldPosition(target?: Vec3): Vec3;
+    getWorldDirection(target?: Vec3): Vec3;
+    distanceTo(target: Node | Vec3): number;
+    isInsideBounds(box: Box): boolean;
+    setLocalBounds(box: Box): this;
+    computeBounds(): void;
+    computeBoundingBox(): Box;
+    computeBoundingSphere(): Sphere$1;
+    setWorldMatrix(worldMatrix: Mat4x3): void;
+    computeWorldMatrix(graph: SceneGraph): void;
+}
+
 type TextureSource = HTMLImageElement | HTMLCanvasElement | ImageData | ImageBitmap | Uint8Array;
 interface ITextureOptions {
     wrapS?: number;
@@ -66,13 +123,12 @@ interface ITextureOptions {
     magFilter?: number;
     flipY?: boolean;
     generateMipmaps?: boolean;
-    width?: number;
-    height?: number;
+    size?: Vec2;
 }
 declare const Texture: {
     create(source: TextureSource, context: WebGLRenderingContext, options?: ITextureOptions): WebGLTexture | null;
     load(url: string, context: WebGLRenderingContext, options?: ITextureOptions): Promise<WebGLTexture | null>;
-    update(texture: WebGLTexture, source: TextureSource, context: WebGLRenderingContext, xOffset?: number, yOffset?: number, width?: number, height?: number, flipY?: boolean): void;
+    update(texture: WebGLTexture, source: TextureSource, context: WebGLRenderingContext, offset?: Vec2, size?: Vec2, flipY?: boolean): void;
 };
 
 type UniformValue = number | number[] | Float32Array | Int32Array | Vec2 | Vec3 | Quat | Mat3 | Mat4 | Mat4x3;
@@ -82,8 +138,6 @@ declare class Uniform {
     constructor(type: string, value: UniformValue);
 }
 
-type Vec3Like = Vec3 | ArrayLike<number>;
-
 declare class SubMesh {
     start: number;
     count: number;
@@ -96,25 +150,33 @@ declare class GLState {
     elementBuffer: WebGLBuffer | null;
     attributeMask: number | null;
     maxAttributes: number;
-    readonly frameOfProgram: WeakMap<object, number>;
-    readonly materialOfProgram: WeakMap<object, object>;
-    readonly materialVersionOfProgram: WeakMap<object, number>;
+    frameOfProgram: WeakMap<object, number>;
+    materialOfProgram: WeakMap<object, object>;
+    materialVersionOfProgram: WeakMap<object, number>;
     invalidate(): void;
+    reset(): void;
 }
 
-declare class MeshRenderer {
-    context: WebGLRenderingContext;
-    state: GLState;
-    constructor(context: WebGLRenderingContext);
-    defaultSettings(): void;
-    createBuffer(target: string, size: ArrayBuffer | ArrayBufferView | null, drawMethod: string): WebGLBuffer | null;
-    useProgram(program: WebGLProgram): void;
-    bindBuffer(target: string, buffer: WebGLBuffer | null): void;
-    deleteBuffer(buffer: WebGLBuffer): void;
-    setAttributeMask(mask: number): void;
-    vertexAttribPointer(index: number, size: number, type: string, normalized: boolean, stride: number, offset: number): void;
-    drawElements(primitive: string | number, subMesh: SubMesh, indexType?: number): void;
-    drawArrays(primitive: string | number, subMesh: SubMesh): void;
+interface IMaterialOptions {
+    ambient?: Vec3;
+    diffuse?: Vec3;
+    specular?: Vec3;
+    shininess?: number;
+}
+declare class Material {
+    ambient: Vec3;
+    diffuse: Vec3;
+    specular: Vec3;
+    shininess: number;
+    uniforms: IMaterialUniforms;
+    version: number;
+    constructor(options?: IMaterialOptions);
+    setAmbient(ambient: Vec3): void;
+    setDiffuse(diffuse: Vec3): void;
+    setSpecular(specular: Vec3): void;
+    setShininess(shininess: number): void;
+    updateUniforms(): boolean;
+    private sync;
 }
 
 interface IGeometry {
@@ -232,35 +294,31 @@ interface IFlatLights {
     [key: string]: any;
 }
 
-interface IMaterialOptions {
-    ambient?: Vec3Like;
-    diffuse?: Vec3Like;
-    specular?: Vec3Like;
-    shininess?: number;
-}
-declare class Material {
-    ambient: Vec3;
-    diffuse: Vec3;
-    specular: Vec3;
-    shininess: number;
-    uniforms: IMaterialUniforms;
-    version: number;
-    constructor(options?: IMaterialOptions);
-    setAmbient(xOrVec: Vec3Like | number, y?: number, z?: number): void;
-    setDiffuse(xOrVec: Vec3Like | number, y?: number, z?: number): void;
-    setSpecular(xOrVec: Vec3Like | number, y?: number, z?: number): void;
-    setShininess(shininess: number): void;
-    updateUniforms(): boolean;
-    private sync;
+declare class MeshRenderer {
+    context: WebGLRenderingContext;
+    state: GLState;
+    constructor(context: WebGLRenderingContext);
+    defaultSettings(): void;
+    createBuffer(target: string, size: ArrayBuffer | ArrayBufferView | null, drawMethod: string): WebGLBuffer | null;
+    useProgram(program: WebGLProgram): void;
+    bindBuffer(target: string, buffer: WebGLBuffer | null): void;
+    deleteBuffer(buffer: WebGLBuffer): void;
+    setAttributeMask(mask: number): void;
+    vertexAttribPointer(index: number, size: number, type: string, normalized: boolean, stride: number, offset: number): void;
+    drawElements(primitive: string | number, subMesh: SubMesh, indexType?: number): void;
+    drawArrays(primitive: string | number, subMesh: SubMesh): void;
+    drawMesh(mesh: Mesh, projectionMatrix: Float32Array, viewMatrix: Float32Array, lights: IFlatLights, time: number, cameraPosition?: Vec3, fog?: {
+        color: Vec3;
+        near: number;
+        far: number;
+    } | null, frame?: IFrameInfo): void;
 }
 
 declare enum eDrawMethod {
     drawElements = "drawElements",
     drawArrays = "drawArrays"
 }
-declare class Mesh implements IMesh {
-    boundingBox: Box;
-    boundingSphere: Sphere$1;
+declare class Mesh extends Node<Mesh> implements IMesh {
     vertices: number[] | Float32Array | null;
     indices: number[] | Int32Array | Uint16Array | null;
     normals: number[] | Float32Array | null;
@@ -277,44 +335,17 @@ declare class Mesh implements IMesh {
     indexBuffer: WebGLBuffer | null;
     normalBuffer: WebGLBuffer | null;
     texCoordBuffer: WebGLBuffer | null;
-    position: Vec3;
-    scale: Vec3;
-    quaternion: Quat;
-    modelMatrix: Mat4x3;
-    worldMatrix: Mat4x3;
-    normalMatrix: Mat3;
-    parent: Mesh | null;
-    traversalStamp: number;
     sortKey: number;
-    private _rotation;
-    private isRotationStale;
-    private isTransformDirty;
-    private isWorldDirty;
     private ownsTexture;
-    private indexType;
-    private static readonly UP;
-    private static readonly scratchQuat;
-    private static readonly scratchView;
-    private static readonly scratchVec;
-    private static readonly scratchCamera;
-    private static readonly scratchDir;
-    private static readonly scratchA;
-    private static readonly scratchB;
-    private static readonly scratchC;
+    private textureSource;
+    private textureOptions;
+    indexType: number;
     private static readonly scratchHit;
-    private static readonly scratchWorldHit;
-    private static readonly scratchInverse;
-    private static readonly scratchRay;
-    isBoundsDirty: boolean;
-    isNormalMatrixDirty: boolean;
-    localBoundingBox: Box;
-    localBoundingSphere: Sphere$1;
     active: boolean;
     drawMethod: eDrawMethod;
     programs: IProgram[];
     nbPrograms: number;
     materials: Material[];
-    children: Mesh[];
     blendMode: boolean;
     blendOptions: IBlendOptions;
     depthWrite: boolean;
@@ -324,61 +355,29 @@ declare class Mesh implements IMesh {
     setInactive(): void;
     toggleActive(): boolean;
     isActive(): boolean;
-    addChild(mesh: Mesh): void;
-    removeChild(mesh: Mesh): boolean;
     addProgram(vertexShaderOrProgram: string | WebGLProgram, fragmentShaderOrMaterial?: string | Material, material?: Material): boolean;
     clearPrograms(): void;
     addMaterial(material: Material): boolean;
-    markDirty(): void;
-    get rotation(): Vec3;
-    set rotation(euler: Vec3);
-    private rotationChanged;
-    setPosition(xOrVec: Vec3Like | number, y?: number, z?: number): this;
-    setRotation(xOrVec: Vec3Like | number, y?: number, z?: number): this;
-    setScale(xOrVec: Vec3Like | number, y?: number, z?: number): this;
-    scaleBy(factorOrVec: Vec3 | number): this;
-    setQuaternion(q: Quat): this;
-    slerp(targetQuat: Quat, t: number): this;
-    rotateX(angle: number): this;
-    rotateY(angle: number): this;
-    rotateZ(angle: number): this;
-    rotateOnAxis(axis: Vec3, angle: number): this;
-    translate(xOrVec: Vec3Like | number, y?: number, z?: number): this;
-    lookAt(target: Vec3, up?: Vec3): this;
-    updateModelMatrix(): boolean;
-    computeNormalMatrix(): Mat3;
-    getWorldPosition(target?: Vec3): Vec3;
-    getWorldDirection(target?: Vec3): Vec3;
-    distanceTo(target: Mesh | Vec3): number;
-    isInsideBounds(min: Vec3, max: Vec3): boolean;
-    computeBounds(): void;
-    computeBoundingBox(): Box;
-    computeBoundingSphere(): Sphere$1;
     raycast(ray: Ray3, precise?: boolean): {
         distance: number;
         point: Vec3;
     } | null;
-    private raycastTriangles;
-    private getVertex;
     useBasicMaterial(options?: IMaterialShortcutOptions): this;
     usePhongMaterial(options?: IPhongShortcutOptions): this;
     useNormalMaterial(): this;
     private applyTextureOption;
     private releaseTexture;
-    setWorldMatrix(worldMatrix: Mat4x3): void;
     setTexture(img: TextureSource, options?: ITextureOptions): void;
     addCustomUniform(name: string, type: string, value: UniformValue): void;
     setCustomUniform(name: string, value: UniformValue): void;
     private createIndexData;
-    private static initializedPrograms;
+    private createBuffers;
+    restore(): void;
     private createProgram;
-    private addProgramAttribute;
-    private addProgramUniform;
     activateBlendMode(): void;
     deactivateBlendMode(): void;
     setBlend(source?: string, destination?: string, equation?: string): this;
     setDepthWrite(enabled: boolean): this;
-    computeWorldMatrix(graph: SceneGraph): void;
     render(projectionMatrix: Float32Array, viewMatrix: Float32Array, lights: IFlatLights, time: number, blendMode: boolean, cameraPosition?: Vec3, fog?: {
         color: Vec3;
         near: number;
@@ -389,89 +388,82 @@ declare class Mesh implements IMesh {
         near: number;
         far: number;
     } | null, frame?: IFrameInfo): void;
-    private static lightTypeValue;
-    private static packVec4;
-    private uploadFrameUniforms;
     destroy(): void;
-    private ucfirst;
 }
 interface IMaterialShortcutOptions {
-    color?: Vec3Like;
+    color?: Vec3;
     texture?: HTMLImageElement | HTMLCanvasElement | WebGLTexture;
 }
 interface IPhongShortcutOptions {
-    ambient?: Vec3Like;
-    diffuse?: Vec3Like;
-    specular?: Vec3Like;
+    ambient?: Vec3;
+    diffuse?: Vec3;
+    specular?: Vec3;
     shininess?: number;
     texture?: HTMLImageElement | HTMLCanvasElement | WebGLTexture;
 }
 
 type Light = 'directional' | 'point' | 'spot' | 'ambient';
 
+interface IDirectionalLightOptions {
+    direction?: Vec3;
+    diffuse?: Vec3;
+    specular?: Vec3;
+    position?: Vec3;
+}
 declare class DirectionalLight {
     position: Vec3;
     diffuse: Vec3;
     specular: Vec3;
     direction: Vec3;
     type: Light;
-    constructor(directionOrOptions?: Vec3 | number[] | {
-        direction?: Vec3 | number[];
-        diffuse?: Vec3 | number[];
-        specular?: Vec3 | number[];
-        position?: Vec3 | number[];
-    });
-    setPosition(xOrVec: Vec3Like | number, y?: number, z?: number): void;
-    setDirection(xOrVec: Vec3Like | number, y?: number, z?: number): void;
-    setDiffuse(xOrVec: Vec3Like | number, y?: number, z?: number): void;
-    setSpecular(xOrVec: Vec3Like | number, y?: number, z?: number): void;
+    constructor(directionOrOptions?: Vec3 | IDirectionalLightOptions);
+    setPosition(position: Vec3): void;
+    setDirection(direction: Vec3): void;
+    setDiffuse(diffuse: Vec3): void;
+    setSpecular(specular: Vec3): void;
 }
 
+interface IPointLightOptions {
+    position?: Vec3;
+    diffuse?: Vec3;
+    specular?: Vec3;
+    constantAttenuation?: number;
+    linearAttenuation?: number;
+    quadraticAttenuation?: number;
+}
 declare class PointLight extends DirectionalLight {
     constantAttenuation: number;
     linearAttenuation: number;
     quadraticAttenuation: number;
-    constructor(positionOrOptions?: Vec3 | number[] | {
-        position?: Vec3 | number[];
-        diffuse?: Vec3 | number[];
-        specular?: Vec3 | number[];
-        constantAttenuation?: number;
-        linearAttenuation?: number;
-        quadraticAttenuation?: number;
-    });
+    constructor(positionOrOptions?: Vec3 | IPointLightOptions);
     setConstantAttenuation(value: number): void;
     setLinearAttenuation(value: number): void;
     setQuadraticAttenuation(value: number): void;
 }
 
+interface ISpotLightOptions extends IPointLightOptions {
+    direction?: Vec3;
+    cutoff?: number;
+    exponent?: number;
+}
 declare class SpotLight extends PointLight {
     cutoff: number;
     exponent: number;
     direction: Vec3;
-    constructor(positionOrOptions?: Vec3 | number[] | {
-        position?: Vec3 | number[];
-        direction?: Vec3 | number[];
-        diffuse?: Vec3 | number[];
-        specular?: Vec3 | number[];
-        cutoff?: number;
-        exponent?: number;
-        constantAttenuation?: number;
-        linearAttenuation?: number;
-        quadraticAttenuation?: number;
-    });
+    constructor(positionOrOptions?: Vec3 | ISpotLightOptions);
     setCutoff(value: number): void;
     setExponent(value: number): void;
-    setDirection(xOrVec: Vec3Like | number, y?: number, z?: number): void;
+    setDirection(direction: Vec3): void;
 }
 
 declare class AmbientLight {
     diffuse: Vec3;
     intensity: number;
     type: Light;
-    constructor(rOrVec?: Vec3 | number, g?: number, b?: number, intensity?: number);
-    setColor(xOrVec: Vec3Like | number, y?: number, z?: number): this;
+    constructor(diffuse?: Vec3, intensity?: number);
+    setColor(diffuse: Vec3): this;
     setIntensity(intensity: number): this;
-    getColor(): Vec3;
+    getColor(target?: Vec3): Vec3;
     get color(): Vec3;
     set color(c: Vec3);
 }
@@ -479,7 +471,6 @@ declare class AmbientLight {
 type AnyLight = DirectionalLight | PointLight | SpotLight | AmbientLight;
 declare const MAX_LIGHTS = 8;
 declare class Lights {
-    private static _ambient;
     private warnedOverflow;
     directionals: DirectionalLight[];
     points: PointLight[];
@@ -493,9 +484,6 @@ declare class Lights {
     constructor();
     addLight(light: AnyLight): void;
     removeLight(light: AnyLight): boolean;
-    private ClearFlatArrays;
-    private ensureBuffers;
-    private push;
     flatten(extraAmbient?: Vec3): IFlatLights;
     clear(): void;
     getFlatArray(property: string): (number | string)[] | undefined;
@@ -521,11 +509,11 @@ declare class Camera {
     setViewMatrix(): void;
     setProjectionMatrix(): void;
     private invalidateProjectionView;
-    getProjectionViewMatrix(): Float32Array;
+    getProjectionViewMatrix(): Mat4;
     getInverseProjectionViewMatrix(): Mat4;
-    setPosition(xOrVec: Vec3 | number, y?: number, z?: number): void;
-    setTarget(xOrVec: Vec3 | number, y?: number, z?: number): void;
-    setUp(xOrVec: Vec3 | number, y?: number, z?: number): void;
+    setPosition(position: Vec3): void;
+    setTarget(target: Vec3): void;
+    setUp(up: Vec3): void;
     lookAt(target: Vec3): void;
     getViewDirection(target?: Vec3): Vec3;
     getDistance(): number;
@@ -534,23 +522,30 @@ declare class Camera {
     getProjectionMatrix(): Float32Array;
     getViewMatrixObject(): Mat4x3;
     getProjectionMatrixObject(): Mat4;
-    getRay(ndcOrX: Vec2 | number, ndcYOrTarget?: number | Ray3, targetRay?: Ray3): Ray3;
+    getRay(ndc: Vec2, targetRay?: Ray3): Ray3;
+}
+
+declare class SceneCollector {
+    opaqueList: Mesh[];
+    blendedList: Mesh[];
+    scratchFrustum: Frustum;
+    private scratchVec;
+    collect(meshes: Mesh[], camera: Camera, frustum: Frustum | null, opaque: boolean, blended: boolean, stamp: number): void;
+    drawBlended(scene: Scene, camera: Camera, time: number, flatLights: IFlatLights, frame: IFrameInfo): number;
 }
 
 interface ISceneOptions {
     canvasId?: string | HTMLCanvasElement;
     context?: WebGLRenderingContext;
     viewport?: {
-        x?: number;
-        y?: number;
-        width: number;
-        height: number;
-    };
-    clearColor?: Vec3 | number[];
+        position?: Vec2;
+        size: Vec2;
+    } | Vec2;
+    clearColor?: Vec3;
     cullFace?: 'BACK' | 'FRONT' | 'NONE';
     frontFace?: 'CCW' | 'CW';
     depthTest?: boolean;
-    ambientColor?: Vec3Like;
+    ambientColor?: Vec3;
     fog?: {
         color: Vec3;
         near: number;
@@ -572,29 +567,28 @@ declare class Scene {
     context: WebGLRenderingContext;
     renderer: SceneRenderer;
     graph: SceneGraph;
+    collector: SceneCollector;
     resolution: Vec2;
-    private scratchFrustum;
-    private scratchVec;
     private frame;
     private frameCounter;
     private traversalStamp;
-    private opaqueList;
-    private blendedList;
     constructor(contextOrOptions: WebGLRenderingContext | ISceneOptions);
     private static contextFromCanvas;
-    setViewport(x: number, y: number, width: number, height: number): void;
-    setSize(sizeOrWidth: Vec2 | number, height?: number): void;
+    setViewport(size: Vec2, position?: Vec2): void;
+    getSize(target?: Vec2): Vec2;
+    setClearColor(color: Vec3, alpha?: number): void;
+    setSize(size: Vec2): void;
     clear(color?: boolean, depth?: boolean): void;
     addMesh(mesh: Mesh): void;
     removeMesh(mesh: Mesh): boolean;
     addLight(light: AnyLight): void;
     removeLight(light: AnyLight): boolean;
-    setAmbientColor(rOrVec: Vec3Like | number, g?: number, b?: number): this;
-    setFog(color: Vec3Like, near: number, far?: number): this;
-    setFog(r: number, g: number, b: number, near?: number, far?: number): this;
+    setAmbientColor(color: Vec3): this;
+    setFog(color: Vec3, near: number, far?: number): this;
     clearFog(): this;
     clearMeshes(): void;
     clearLights(): void;
+    restore(): void;
     destroy(destroyMeshes?: boolean): void;
     getLightsProperty(property: string): (number | string)[] | undefined;
     enableBlendMode(equation: string, source: string, destination: string): void;
@@ -609,14 +603,11 @@ declare class Scene {
     private markDescendants;
     private computeWorldMatrices;
     private beginFrame;
-    private collect;
-    private drawBlended;
     renderBlended(camera: Camera, time?: number, flatLights?: IFlatLights, frustum?: Frustum | null): number;
 }
 
 interface IRendererOptions {
-    width?: number;
-    height?: number;
+    size?: Vec2;
     contextAttributes?: WebGLContextAttributes;
     onContextLost?: () => void;
     onContextRestored?: () => void;
@@ -635,12 +626,13 @@ declare class Renderer {
     enable(capability: string): void;
     disable(capability: string): void;
     setCullFace(mode: string): void;
-    setViewport(width: number, height: number): void;
-    setClearColor(rOrVec: Vec3 | number, g?: number, b?: number, a?: number): void;
+    setViewport(size: Vec2): void;
+    setClearColor(color: Vec3, alpha?: number): void;
     clearFrame(): void;
     getContext(): WebGLRenderingContext | null;
     getCanvas(): HTMLCanvasElement | null;
-    setSize(sizeOrWidth: Vec2 | number, height?: number): void;
+    setSize(size: Vec2): void;
+    getSize(target?: Vec2): Vec2;
     private findById;
 }
 
@@ -651,12 +643,13 @@ declare class RenderTarget {
     framebuffer: WebGLFramebuffer | null;
     texture: WebGLTexture | null;
     depthBuffer: WebGLRenderbuffer | null;
-    constructor(sizeOrWidth: Vec2 | number, heightOrContext: number | WebGLRenderingContext, context?: WebGLRenderingContext);
+    constructor(size: Vec2, context: WebGLRenderingContext);
+    restore(): void;
     private init;
     bind(): void;
-    unbind(viewportWidthOrSize?: Vec2 | number, viewportHeight?: number): void;
+    unbind(viewportSize?: Vec2): void;
     getSize(target?: Vec2): Vec2;
-    setSize(sizeOrWidth: Vec2 | number, height?: number): void;
+    setSize(size: Vec2): void;
     dispose(): void;
 }
 
@@ -665,10 +658,11 @@ declare class PerspectiveCamera extends Camera {
     ratio: number;
     zNear: number;
     zFar: number;
-    constructor(fov: number, zNearOrContext?: number | WebGLRenderingContext | null, zFarOrNear?: number, contextOrFar?: WebGLRenderingContext | number | null);
-    setProjectionMatrix(viewport?: Vec2 | Int32Array | number[] | null): void;
+    constructor(fov: number, nearFar?: Vec2, context?: WebGLRenderingContext | null);
+    setProjectionMatrix(viewport?: Vec2 | null): void;
     setFov(fov: number): void;
-    setNearFar(zNear: number, zFar: number): void;
+    setNearFar(nearFar: Vec2): void;
+    getNearFar(target?: Vec2): Vec2;
 }
 
 declare class OrthographicCamera extends Camera {
@@ -678,9 +672,10 @@ declare class OrthographicCamera extends Camera {
     bottom: number;
     near: number;
     far: number;
-    constructor(boundsOrLeft: Rect | number, rightOrNear?: number, topOrFar?: number, bottom?: number, near?: number, far?: number);
+    constructor(bounds: Rect, nearFar?: Vec2);
     setProjectionMatrix(): void;
-    setBounds(boundsOrLeft: Rect | number, rightOrNear?: number, topOrFar?: number, bottom?: number, near?: number, far?: number): void;
+    setBounds(bounds: Rect, nearFar?: Vec2): void;
+    getNearFar(target?: Vec2): Vec2;
 }
 
 declare class OrbitControls {
@@ -740,10 +735,10 @@ declare class OrbitControls {
 }
 
 declare class BasicMesh implements IGeometry {
-    vertices: number[] | null;
-    indices: number[] | null;
-    normals: number[] | null;
-    uvs: number[] | null;
+    vertices: number[] | Float32Array | null;
+    indices: number[] | Int32Array | Uint16Array | null;
+    normals: number[] | Float32Array | null;
+    uvs: number[] | Float32Array | null;
     subMeshes: SubMesh[];
     itemSize: number;
     primitive: string;
@@ -756,7 +751,8 @@ declare class Line extends BasicMesh {
     subMeshes: SubMesh[];
     itemSize: number;
     primitive: string;
-    constructor(vertices: Vec3[] | number[], thickness?: number);
+    constructor(vertices?: Vec3[], thickness?: number);
+    setPoints(vertices: Vec3[]): this;
 }
 
 declare class FullscreenQuad extends BasicMesh {
@@ -770,7 +766,7 @@ declare class Quad extends BasicMesh {
     subMeshes: SubMesh[];
     itemSize: number;
     primitive: string;
-    constructor(sizeOrWidth?: Vec2 | Rect | number, height?: number);
+    constructor(size?: Vec2 | Rect);
 }
 
 interface IQuad {
@@ -783,17 +779,17 @@ declare class MultiQuad extends BasicMesh {
     indices: number[];
     uvs: number[];
     quad: IQuad;
-    constructor(sizeOrWidth?: Vec2 | Rect | number, height?: number);
+    constructor(size?: Vec2 | Rect);
     createQuads(length: number): void;
     private createIndices;
 }
 
 declare class Cube extends BasicMesh {
-    constructor(sizeOrDimensions?: Vec3 | number, flat?: boolean);
+    constructor(size?: Vec3, flat?: boolean);
 }
 
 declare class Sphere extends BasicMesh {
-    constructor();
+    constructor(scale?: Vec3);
 }
 
 declare class Hemisphere extends BasicMesh {
@@ -801,11 +797,11 @@ declare class Hemisphere extends BasicMesh {
 }
 
 declare class Plane extends BasicMesh {
-    constructor(sizeOrWidth?: Vec2 | number, heightOrWidthSegments?: number, widthOrHeightSegments?: number, heightSegmentsOrOrientation?: number | ('xy' | 'xz'), orientation?: 'xy' | 'xz');
+    constructor(size?: Vec2, segments?: Vec2, orientation?: 'xy' | 'xz');
 }
 
 declare class Cylinder extends BasicMesh {
-    constructor(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, openEnded?: boolean);
+    constructor(radii?: Vec2, height?: number, radialSegments?: number, heightSegments?: number, openEnded?: boolean);
 }
 
 declare class VWing extends BasicMesh {
@@ -827,9 +823,9 @@ declare class CustomMesh implements IGeometry {
     primitives: string[];
     constructor();
     private static toFloat32;
-    setVertices(array: Vec3[] | Float32Array | number[]): void;
+    setVertices(array: Vec3[]): void;
     setIndices(array: Int32Array | number[]): void;
-    setNormals(array: Vec3[] | Float32Array | number[]): void;
+    setNormals(array: Vec3[]): void;
     setUvs(array: Float32Array | number[]): void;
     addSubMeshes(array: Float32Array | Int32Array | number[]): void;
     addSubMesh(start: number, count: number): void;
@@ -847,12 +843,72 @@ declare class CustomMesh implements IGeometry {
     computeVertexNormals(): Float32Array | null;
 }
 
-declare class Program {
-    static create(context: WebGLRenderingContext, vertexShader: string, fragmentShader: string): WebGLProgram | null;
-    static acquire(context: WebGLRenderingContext, vertexShader: string, fragmentShader: string): WebGLProgram | null;
-    static release(context: WebGLRenderingContext, program: WebGLProgram): void;
+declare const SpriteShader: {
+    vertex: string;
+    fragment: string;
+    create(context: WebGLRenderingContext): WebGLProgram | null;
+};
+
+type SpriteBillboard = 'none' | 'spherical' | 'cylindrical';
+type SpriteAnchor = 'center' | 'bottom';
+interface ISpriteOptions {
+    size?: Vec2;
+    texture?: TextureSource;
+    textureOptions?: ITextureOptions;
+    frames?: number;
+    anchor?: SpriteAnchor;
+    billboard?: SpriteBillboard;
+    alphaCutoff?: number;
+    material?: Material;
+    depthBias?: number;
+    fragment?: string;
+}
+declare class Sprite extends Mesh {
+    readonly width: number;
+    readonly height: number;
+    frames: number;
+    readonly anchor: SpriteAnchor;
+    billboard: SpriteBillboard;
+    private currentFrame;
+    private alphaCutoff;
+    private depthBias;
+    private static readonly scratchSpriteMin;
+    private static readonly scratchSpriteMax;
+    private static readonly scratchSpriteBox;
+    private static readonly scratchSpriteHit;
+    constructor(context: WebGLRenderingContext, options: ISpriteOptions);
+    private updateLocalBounds;
+    setFrame(frame: number): this;
+    getFrame(): number;
+    setFrames(frames: number): this;
+    getFrames(): number;
+    setBillboard(billboard: SpriteBillboard): this;
+    getBillboard(): SpriteBillboard;
+    setAlphaCutoff(cutoff: number): this;
+    getAlphaCutoff(): number;
+    setDepthBias(depthBias: number): this;
+    getDepthBias(): number;
+    getWidth(): number;
+    getHeight(): number;
+    getSize(target?: Vec2): Vec2;
+    getAnchor(): SpriteAnchor;
+    raycast(ray: Ray3, precise?: boolean): {
+        distance: number;
+        point: Vec3;
+    } | null;
 }
 
+declare const Program: {
+    create(context: WebGLRenderingContext, vertexShader: string, fragmentShader: string): WebGLProgram | null;
+    acquire(context: WebGLRenderingContext, vertexShader: string, fragmentShader: string): WebGLProgram | null;
+    release(context: WebGLRenderingContext, program: WebGLProgram): void;
+    sources(program: WebGLProgram): {
+        vertex: string;
+        fragment: string;
+    } | null;
+    reset(context: WebGLRenderingContext): void;
+};
+
 type ShaderType = 'VERTEX_SHADER' | 'FRAGMENT_SHADER';
 declare const Shader: {
     create(context: WebGLRenderingContext, str: string, type: ShaderType): WebGLShader | null;
@@ -863,16 +919,23 @@ declare const BasicShader: {
     fragment: string;
     create(context: WebGLRenderingContext): WebGLProgram | null;
 };
-declare const NormalShader: {
+
+declare const PhongShader: {
     vertex: string;
     fragment: string;
     create(context: WebGLRenderingContext): WebGLProgram | null;
 };
-declare const PhongShader: {
+
+declare const NormalShader: {
     vertex: string;
     fragment: string;
     create(context: WebGLRenderingContext): WebGLProgram | null;
 };
 
-export { AmbientLight, BasicMesh, BasicShader, Camera, Cannon, Cube, CustomMesh, Cylinder, DirectionalLight, FullscreenQuad, Hemisphere, Lights, Line, MAX_LIGHTS, Material, Mesh, MultiQuad, NormalShader, OrbitControls, OrthographicCamera, PerspectiveCamera, PhongShader, Plane, PointLight, Program, Quad, RenderTarget, Renderer, Scene, Shader, Sphere, SpotLight, SubMesh, Texture, Uniform, VWing, eDrawMethod };
-export type { AnyLight, ICustomUniforms, IFlatLights, IFrameInfo, IGeometry, IMaterialOptions, IMaterialUniforms, IMesh, IProgram, IRendererOptions, ISceneOptions, ITextureOptions, TextureSource, UniformValue, Vec3Like };
+type Vec3Like = Vec3 | ArrayLike<number>;
+type Vec2Like = Vec2 | ArrayLike<number>;
+declare function assignVec3(target: Vec3, xOrVec: Vec3Like | number, y?: number, z?: number): Vec3;
+declare function assignVec2(target: Vec2, xOrVec: Vec2Like | number, y?: number): Vec2;
+
+export { AmbientLight, BasicMesh, BasicShader, Camera, Cannon, Cube, CustomMesh, Cylinder, DirectionalLight, FullscreenQuad, Hemisphere, Lights, Line, MAX_LIGHTS, Material, Mesh, MultiQuad, Node, NormalShader, OrbitControls, OrthographicCamera, PerspectiveCamera, PhongShader, Plane, PointLight, Program, Quad, RenderTarget, Renderer, Scene, Shader, Sphere, SpotLight, Sprite, SpriteShader, SubMesh, Texture, Uniform, VWing, assignVec2, assignVec3, eDrawMethod };
+export type { AnyLight, ICustomUniforms, IFlatLights, IFrameInfo, IGeometry, IMaterialOptions, IMaterialUniforms, IMesh, IProgram, IRendererOptions, ISceneOptions, ISpriteOptions, ITextureOptions, SpriteAnchor, SpriteBillboard, TextureSource, UniformValue, Vec2Like, Vec3Like };