@1pizzateam/roostr 0.0.0-stage → 0.8.0

package/dist/roostr.d.ts

@@ -0,0 +1,941 @@
+/*
+MIT License
+
+Copyright (c) 2015 Ludovic CLUBER
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+https://github.com/1pizzateam/RoostR.js
+*/
+
+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;
+    private blendKey;
+    private blendEnabled;
+    private depthWrite;
+    constructor(context: WebGLRenderingContext);
+    invalidateState(): void;
+    reset(): void;
+    defaultSettings(): void;
+    enable(capability: string): void;
+    disable(capability: string): void;
+    setDepthFunc(mode: string): void;
+    setBlendFunction(sourceFactor: string, destinationFactor: string): void;
+    setBlendEquation(mode: string): void;
+    enableDepthTest(): void;
+    disableDepthTest(): void;
+    enableBlendMode(equation: string, source: string, destination: string): void;
+    disableBlendMode(): void;
+    setDepthWrite(enabled: boolean): void;
+    getParameter(parameterName: GLenum): GLenum | Float32Array | GLint | WebGLBuffer | GLboolean | Array<GLboolean> | GLfloat | WebGLFramebuffer | Int32Array | GLuint | WebGLTexture;
+}
+
+declare class SceneGraph {
+    model: Array<Mat4x3>;
+    nbModel: number;
+    modelStackTop: number;
+    constructor();
+    pushModelMatrix(modelMatrix: Mat4x3): void;
+    popModelMatrix(): void;
+    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;
+    wrapT?: number;
+    minFilter?: number;
+    magFilter?: number;
+    flipY?: boolean;
+    generateMipmaps?: boolean;
+    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, offset?: Vec2, size?: Vec2, flipY?: boolean): void;
+};
+
+type UniformValue = number | number[] | Float32Array | Int32Array | Vec2 | Vec3 | Quat | Mat3 | Mat4 | Mat4x3;
+declare class Uniform {
+    type: string;
+    value: UniformValue;
+    constructor(type: string, value: UniformValue);
+}
+
+declare class SubMesh {
+    start: number;
+    count: number;
+    constructor(start: number, count: number);
+}
+
+declare class GLState {
+    program: WebGLProgram | null;
+    arrayBuffer: WebGLBuffer | null;
+    elementBuffer: WebGLBuffer | null;
+    attributeMask: number | null;
+    maxAttributes: number;
+    frameOfProgram: WeakMap<object, number>;
+    materialOfProgram: WeakMap<object, object>;
+    materialVersionOfProgram: WeakMap<object, number>;
+    invalidate(): void;
+    reset(): 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 {
+    vertices: number[] | Float32Array | null;
+    indices: number[] | Int32Array | Uint16Array | null;
+    normals: number[] | Float32Array | null;
+    subMeshes: SubMesh[];
+    itemSize: number | null;
+    primitive: string | null;
+    uvs?: number[] | Float32Array | null;
+    nbSubMeshes?: number;
+    quad?: {
+        vertices: number[] | null;
+        indices: number[] | null;
+        uvs?: number[] | null;
+    };
+}
+interface IMesh extends IGeometry {
+    customUniforms?: ICustomUniforms;
+    context?: WebGLRenderingContext;
+    renderer?: MeshRenderer;
+    WebGLTexture?: WebGLTexture | null;
+    vertexBuffer?: WebGLBuffer | null;
+    indexBuffer?: WebGLBuffer | null;
+    normalBuffer?: WebGLBuffer | null;
+    texCoordBuffer?: WebGLBuffer | null;
+    position?: Vec3;
+    rotation?: Vec3;
+    scale?: Vec3;
+    quaternion?: Quat;
+    modelMatrix?: Mat4x3;
+    worldMatrix?: Mat4x3;
+    normalMatrix?: Mat3;
+    active?: boolean;
+    drawMethod?: eDrawMethod;
+    programs?: IProgram[];
+    nbPrograms?: number;
+    materials?: Material[];
+    children?: IMesh[];
+    blendMode?: boolean;
+    zOrder?: number;
+}
+interface IFrameInfo {
+    id: number;
+    resolution?: Vec2;
+}
+interface IBlendOptions {
+    equation: string;
+    source: string;
+    destination: string;
+}
+interface ICustomUniforms {
+    [key: string]: Uniform;
+}
+interface IMaterialUniforms {
+    materialAmbient: Uniform;
+    materialDiffuse: Uniform;
+    materialSpecular: Uniform;
+    materialShininess: Uniform;
+}
+interface IProgram extends WebGLProgram {
+    vertexNormal: GLint;
+    vertexPosition: GLint;
+    textureCoord: GLint;
+    sampler: WebGLUniformLocation | null;
+    modelMatrix: WebGLUniformLocation | null;
+    normalMatrix?: WebGLUniformLocation | null;
+    projectionMatrix: WebGLUniformLocation | null;
+    viewMatrix: WebGLUniformLocation | null;
+    time: WebGLUniformLocation | null;
+    screenResolution: WebGLUniformLocation | null;
+    lightPosition?: WebGLUniformLocation | null;
+    lightDiffuse?: WebGLUniformLocation | null;
+    lightSpecular?: WebGLUniformLocation | null;
+    lightDirection?: WebGLUniformLocation | null;
+    lightAttenuation?: WebGLUniformLocation | null;
+    lightCutoff?: WebGLUniformLocation | null;
+    lightExponent?: WebGLUniformLocation | null;
+    lightType?: WebGLUniformLocation | null;
+    lightPositionType?: WebGLUniformLocation | null;
+    lightDiffuseCutoff?: WebGLUniformLocation | null;
+    lightSpecularExponent?: WebGLUniformLocation | null;
+    nbLights?: WebGLUniformLocation | null;
+    ambientLight?: WebGLUniformLocation | null;
+    ambientColor?: WebGLUniformLocation | null;
+    fogColor?: WebGLUniformLocation | null;
+    fogNear?: WebGLUniformLocation | null;
+    fogFar?: WebGLUniformLocation | null;
+    [key: string]: any;
+}
+interface IFlatLights {
+    position: number[];
+    diffuse: number[];
+    specular: number[];
+    constantAttenuation: number[];
+    linearAttenuation: number[];
+    quadraticAttenuation: number[];
+    cutoff: number[];
+    exponent: number[];
+    direction: number[];
+    type: (string | number)[];
+    ambient?: number[];
+    floatPosition?: Float32Array;
+    floatDiffuse?: Float32Array;
+    floatSpecular?: Float32Array;
+    floatDirection?: Float32Array;
+    floatAttenuation?: Float32Array;
+    floatCutoff?: Float32Array;
+    floatExponent?: Float32Array;
+    floatType?: Float32Array;
+    floatAmbient?: Float32Array;
+    packedPosition?: Float32Array;
+    packedDiffuse?: Float32Array;
+    packedSpecular?: Float32Array;
+    [key: string]: any;
+}
+
+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 extends Node<Mesh> implements IMesh {
+    vertices: number[] | Float32Array | null;
+    indices: number[] | Int32Array | Uint16Array | null;
+    normals: number[] | Float32Array | null;
+    uvs: number[] | Float32Array | null;
+    itemSize: number | null;
+    subMeshes: SubMesh[];
+    nbSubMeshes: number;
+    primitive: string | null;
+    customUniforms: ICustomUniforms;
+    context: WebGLRenderingContext;
+    renderer: MeshRenderer;
+    WebGLTexture: WebGLTexture | null;
+    vertexBuffer: WebGLBuffer | null;
+    indexBuffer: WebGLBuffer | null;
+    normalBuffer: WebGLBuffer | null;
+    texCoordBuffer: WebGLBuffer | null;
+    sortKey: number;
+    private ownsTexture;
+    private textureSource;
+    private textureOptions;
+    indexType: number;
+    private static readonly scratchHit;
+    active: boolean;
+    drawMethod: eDrawMethod;
+    programs: IProgram[];
+    nbPrograms: number;
+    materials: Material[];
+    blendMode: boolean;
+    blendOptions: IBlendOptions;
+    depthWrite: boolean;
+    zOrder: number;
+    constructor(meshOrContext: IMesh | WebGLRenderingContext, contextOrMesh: WebGLRenderingContext | IMesh);
+    setActive(): void;
+    setInactive(): void;
+    toggleActive(): boolean;
+    isActive(): boolean;
+    addProgram(vertexShaderOrProgram: string | WebGLProgram, fragmentShaderOrMaterial?: string | Material, material?: Material): boolean;
+    clearPrograms(): void;
+    addMaterial(material: Material): boolean;
+    raycast(ray: Ray3, precise?: boolean): {
+        distance: number;
+        point: Vec3;
+    } | null;
+    useBasicMaterial(options?: IMaterialShortcutOptions): this;
+    usePhongMaterial(options?: IPhongShortcutOptions): this;
+    useNormalMaterial(): this;
+    private applyTextureOption;
+    private releaseTexture;
+    setTexture(img: TextureSource, options?: ITextureOptions): void;
+    addCustomUniform(name: string, type: string, value: UniformValue): void;
+    setCustomUniform(name: string, value: UniformValue): void;
+    private createIndexData;
+    private createBuffers;
+    restore(): void;
+    private createProgram;
+    activateBlendMode(): void;
+    deactivateBlendMode(): void;
+    setBlend(source?: string, destination?: string, equation?: string): this;
+    setDepthWrite(enabled: boolean): this;
+    render(projectionMatrix: Float32Array, viewMatrix: Float32Array, lights: IFlatLights, time: number, blendMode: boolean, cameraPosition?: Vec3, fog?: {
+        color: Vec3;
+        near: number;
+        far: number;
+    } | null, frame?: IFrameInfo): void;
+    renderSelf(projectionMatrix: Float32Array, viewMatrix: Float32Array, lights: IFlatLights, time: number, blendMode: boolean, cameraPosition?: Vec3, fog?: {
+        color: Vec3;
+        near: number;
+        far: number;
+    } | null, frame?: IFrameInfo): void;
+    destroy(): void;
+}
+interface IMaterialShortcutOptions {
+    color?: Vec3;
+    texture?: HTMLImageElement | HTMLCanvasElement | WebGLTexture;
+}
+interface IPhongShortcutOptions {
+    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 | 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 | 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 | ISpotLightOptions);
+    setCutoff(value: number): void;
+    setExponent(value: number): void;
+    setDirection(direction: Vec3): void;
+}
+
+declare class AmbientLight {
+    diffuse: Vec3;
+    intensity: number;
+    type: Light;
+    constructor(diffuse?: Vec3, intensity?: number);
+    setColor(diffuse: Vec3): this;
+    setIntensity(intensity: number): this;
+    getColor(target?: Vec3): Vec3;
+    get color(): Vec3;
+    set color(c: Vec3);
+}
+
+type AnyLight = DirectionalLight | PointLight | SpotLight | AmbientLight;
+declare const MAX_LIGHTS = 8;
+declare class Lights {
+    private warnedOverflow;
+    directionals: DirectionalLight[];
+    points: PointLight[];
+    spots: SpotLight[];
+    ambients: AmbientLight[];
+    nbDirectionals: number;
+    nbPoints: number;
+    nbSpots: number;
+    nbAmbients: number;
+    flatArrays: IFlatLights;
+    constructor();
+    addLight(light: AnyLight): void;
+    removeLight(light: AnyLight): boolean;
+    flatten(extraAmbient?: Vec3): IFlatLights;
+    clear(): void;
+    getFlatArray(property: string): (number | string)[] | undefined;
+}
+
+declare class Camera {
+    viewMatrix: Mat4x3;
+    projectionMatrix: Mat4;
+    position: Vec3;
+    target: Vec3;
+    up: Vec3;
+    protected cachedViewMatrix: Float32Array;
+    protected cachedProjectionMatrix: Float32Array;
+    private projectionViewMatrix;
+    private inverseProjectionViewMatrix;
+    private isProjectionViewDirty;
+    private isInverseDirty;
+    private static _scratchNear;
+    private static _scratchFar;
+    private static _scratchDir;
+    private static _scratchNdc;
+    constructor(position: Vec3, target: Vec3, up: Vec3);
+    setViewMatrix(): void;
+    setProjectionMatrix(): void;
+    private invalidateProjectionView;
+    getProjectionViewMatrix(): Float32Array;
+    getInverseProjectionViewMatrix(): Mat4;
+    setPosition(position: Vec3): void;
+    setTarget(target: Vec3): void;
+    setUp(up: Vec3): void;
+    lookAt(target: Vec3): void;
+    getViewDirection(target?: Vec3): Vec3;
+    getDistance(): number;
+    dolly(amount: number): void;
+    getViewMatrix(): Float32Array;
+    getProjectionMatrix(): Float32Array;
+    getViewMatrixObject(): Mat4x3;
+    getProjectionMatrixObject(): Mat4;
+    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?: {
+        position?: Vec2;
+        size: Vec2;
+    } | Vec2;
+    clearColor?: Vec3;
+    cullFace?: 'BACK' | 'FRONT' | 'NONE';
+    frontFace?: 'CCW' | 'CW';
+    depthTest?: boolean;
+    ambientColor?: Vec3;
+    fog?: {
+        color: Vec3;
+        near: number;
+        far: number;
+    } | null;
+    enableFrustumCulling?: boolean;
+}
+declare class Scene {
+    meshes: Mesh[];
+    nbMeshes: number;
+    lights: Lights;
+    ambientColor: Vec3;
+    fog: {
+        color: Vec3;
+        near: number;
+        far: number;
+    } | null;
+    enableFrustumCulling: boolean;
+    context: WebGLRenderingContext;
+    renderer: SceneRenderer;
+    graph: SceneGraph;
+    collector: SceneCollector;
+    resolution: Vec2;
+    private frame;
+    private frameCounter;
+    private traversalStamp;
+    constructor(contextOrOptions: WebGLRenderingContext | ISceneOptions);
+    private static contextFromCanvas;
+    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(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;
+    disableBlendMode(): void;
+    getRendererBlendMode(): GLenum | Float32Array | GLint | WebGLBuffer | GLboolean | GLboolean[] | GLfloat | WebGLFramebuffer | Int32Array | GLuint | WebGLTexture;
+    raycast(ray: Ray3, precise?: boolean): {
+        mesh: Mesh;
+        distance: number;
+        point: Vec3;
+    }[];
+    render(camera: Camera, time?: number): number;
+    private markDescendants;
+    private computeWorldMatrices;
+    private beginFrame;
+    renderBlended(camera: Camera, time?: number, flatLights?: IFlatLights, frustum?: Frustum | null): number;
+}
+
+interface IRendererOptions {
+    size?: Vec2;
+    contextAttributes?: WebGLContextAttributes;
+    onContextLost?: () => void;
+    onContextRestored?: () => void;
+}
+declare class Renderer {
+    canvas: HTMLCanvasElement | null;
+    context: WebGLRenderingContext | null;
+    isContextLost: boolean;
+    private options;
+    private onContextLostBound;
+    private onContextRestoredBound;
+    constructor(canvasID: string | HTMLCanvasElement, options?: IRendererOptions);
+    dispose(): void;
+    defaultSettings(): void;
+    setFrontFace(mode: string): void;
+    enable(capability: string): void;
+    disable(capability: string): void;
+    setCullFace(mode: string): void;
+    setViewport(size: Vec2): void;
+    setClearColor(color: Vec3, alpha?: number): void;
+    clearFrame(): void;
+    getContext(): WebGLRenderingContext | null;
+    getCanvas(): HTMLCanvasElement | null;
+    setSize(size: Vec2): void;
+    getSize(target?: Vec2): Vec2;
+    private findById;
+}
+
+declare class RenderTarget {
+    width: number;
+    height: number;
+    context: WebGLRenderingContext;
+    framebuffer: WebGLFramebuffer | null;
+    texture: WebGLTexture | null;
+    depthBuffer: WebGLRenderbuffer | null;
+    constructor(size: Vec2, context: WebGLRenderingContext);
+    restore(): void;
+    private init;
+    bind(): void;
+    unbind(viewportSize?: Vec2): void;
+    getSize(target?: Vec2): Vec2;
+    setSize(size: Vec2): void;
+    dispose(): void;
+}
+
+declare class PerspectiveCamera extends Camera {
+    fov: number;
+    ratio: number;
+    zNear: number;
+    zFar: number;
+    constructor(fov: number, nearFar?: Vec2, context?: WebGLRenderingContext | null);
+    setProjectionMatrix(viewport?: Vec2 | null): void;
+    setFov(fov: number): void;
+    setNearFar(nearFar: Vec2): void;
+    getNearFar(target?: Vec2): Vec2;
+}
+
+declare class OrthographicCamera extends Camera {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    near: number;
+    far: number;
+    constructor(bounds: Rect, nearFar?: Vec2);
+    setProjectionMatrix(): void;
+    setBounds(bounds: Rect, nearFar?: Vec2): void;
+    getNearFar(target?: Vec2): Vec2;
+}
+
+declare class OrbitControls {
+    camera: Camera;
+    domElement: HTMLElement;
+    distance: number;
+    targetDistance: number;
+    azimuth: number;
+    targetAzimuth: number;
+    elevation: number;
+    targetElevation: number;
+    minDistance: number;
+    maxDistance: number;
+    minElevation: number;
+    maxElevation: number;
+    rotateSpeed: number;
+    zoomSpeed: number;
+    panSpeed: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    private isDragging;
+    private dragMode;
+    private previousMouseX;
+    private previousMouseY;
+    private touchStartDistance;
+    private activePointerId;
+    private appliedPose;
+    private appliedTarget;
+    private onPointerDownBound;
+    private onPointerMoveBound;
+    private onPointerUpBound;
+    private onWheelBound;
+    private onContextMenuBound;
+    private onTouchStartBound;
+    private onTouchMoveBound;
+    private onTouchEndBound;
+    constructor(camera: Camera, domElement: HTMLElement);
+    private attach;
+    dispose(): void;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onWheel;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    private static _touchA;
+    private static _touchB;
+    private static touchDistance;
+    private static _scratchForward;
+    private static _scratchRight;
+    private static _scratchUp;
+    private static _scratchPan;
+    private static _scratchSpherical;
+    private pan;
+    update(deltaTime?: number): void;
+}
+
+declare class BasicMesh implements IGeometry {
+    vertices: number[] | Float32Array | null;
+    indices: number[] | Int32Array | Uint16Array | null;
+    normals: number[] | Float32Array | null;
+    uvs: number[] | Float32Array | null;
+    subMeshes: SubMesh[];
+    itemSize: number;
+    primitive: string;
+    constructor();
+}
+
+declare class Line extends BasicMesh {
+    vertices: number[];
+    thickness: number;
+    subMeshes: SubMesh[];
+    itemSize: number;
+    primitive: string;
+    constructor(vertices?: Vec3[], thickness?: number);
+    setPoints(vertices: Vec3[]): this;
+}
+
+declare class FullscreenQuad extends BasicMesh {
+    uvs: number[];
+    constructor();
+}
+
+declare class Quad extends BasicMesh {
+    vertices: number[];
+    uvs: number[];
+    subMeshes: SubMesh[];
+    itemSize: number;
+    primitive: string;
+    constructor(size?: Vec2 | Rect);
+}
+
+interface IQuad {
+    vertices: Float32Array;
+    indices: Int32Array;
+    uvs: Float32Array;
+}
+declare class MultiQuad extends BasicMesh {
+    vertices: number[];
+    indices: number[];
+    uvs: number[];
+    quad: IQuad;
+    constructor(size?: Vec2 | Rect);
+    createQuads(length: number): void;
+    private createIndices;
+}
+
+declare class Cube extends BasicMesh {
+    constructor(size?: Vec3, flat?: boolean);
+}
+
+declare class Sphere extends BasicMesh {
+    constructor(scale?: Vec3);
+}
+
+declare class Hemisphere extends BasicMesh {
+    constructor();
+}
+
+declare class Plane extends BasicMesh {
+    constructor(size?: Vec2, segments?: Vec2, orientation?: 'xy' | 'xz');
+}
+
+declare class Cylinder extends BasicMesh {
+    constructor(radii?: Vec2, height?: number, radialSegments?: number, heightSegments?: number, openEnded?: boolean);
+}
+
+declare class VWing extends BasicMesh {
+    constructor();
+}
+
+declare class Cannon extends BasicMesh {
+    constructor();
+}
+
+declare class CustomMesh implements IGeometry {
+    vertices: Float32Array | null;
+    indices: Int32Array | null;
+    normals: Float32Array | null;
+    uvs: Float32Array | null;
+    subMeshes: SubMesh[];
+    itemSize: number;
+    primitive: string;
+    primitives: string[];
+    constructor();
+    private static toFloat32;
+    setVertices(array: Vec3[]): void;
+    setIndices(array: Int32Array | number[]): void;
+    setNormals(array: Vec3[]): void;
+    setUvs(array: Float32Array | number[]): void;
+    addSubMeshes(array: Float32Array | Int32Array | number[]): void;
+    addSubMesh(start: number, count: number): void;
+    setItemSize(itemSize: number): void;
+    setPrimitive(primitive: string): boolean;
+    private static _vA;
+    private static _vB;
+    private static _vC;
+    private static _e1;
+    private static _e2;
+    private static _n;
+    private static _sum;
+    private static readonly UP;
+    private static accumulate;
+    computeVertexNormals(): Float32Array | null;
+}
+
+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;
+};
+
+declare const BasicShader: {
+    vertex: string;
+    fragment: string;
+    create(context: WebGLRenderingContext): WebGLProgram | null;
+};
+
+declare const PhongShader: {
+    vertex: string;
+    fragment: string;
+    create(context: WebGLRenderingContext): WebGLProgram | null;
+};
+
+declare const NormalShader: {
+    vertex: string;
+    fragment: string;
+    create(context: WebGLRenderingContext): WebGLProgram | null;
+};
+
+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 };