gfxlite 0.1.0

package/dist/types/core/renderer/BatchManager.d.ts

@@ -0,0 +1,82 @@
+import { Mesh } from '../object/Mesh';
+import { Camera } from '../camera/Camera';
+import { Geometry } from '../geometry/Geometry';
+import { Material } from '../material/Material';
+import { DirectionalLight } from '../light/DirectionalLight';
+export interface DrawBatch {
+    key: string;
+    geometry: Geometry;
+    material: Material;
+    meshes: Mesh[];
+    instanceOffset: number;
+    instanceCount: number;
+    boundingSphereRadius: number;
+    culledStridePerCamera: number;
+    batchInfoBuffer: GPUBuffer;
+    indirectBuffer: GPUBuffer;
+    culledInstanceBuffer: GPUBuffer;
+    renderBindGroup: GPUBindGroup | null;
+    cullBindGroup: GPUBindGroup | null;
+}
+export interface BatchStats {
+    totalBatches: number;
+    totalInstances: number;
+    drawCalls: number;
+    instanceBufferSize: number;
+}
+export interface GeometryData {
+    vertexBuffer: GPUBuffer;
+    normalBuffer: GPUBuffer | null;
+    uvBuffer: GPUBuffer | null;
+    tangentBuffer: GPUBuffer | null;
+    indexBuffer: GPUBuffer | null;
+    version: number;
+}
+export declare class BatchManager {
+    private device;
+    private instanceBuffer;
+    private instanceBufferCapacity;
+    private instanceDataArray;
+    private batchCache;
+    private geometryCache;
+    private batches;
+    private totalInstances;
+    private cameraBuffer;
+    private cameraBindGroup;
+    private cameraBindGroupLayout;
+    private cullBindGroupLayout;
+    private renderBindGroupLayout;
+    private _tempMatrix;
+    private _batchInfoBuffer;
+    private _batchInfoU32;
+    private _batchInfoF32;
+    private _cameraUniformData;
+    private activeShadowLightCount;
+    constructor(device: GPUDevice);
+    private initBindGroupLayouts;
+    private initCameraResources;
+    getCameraBindGroupLayout(): GPUBindGroupLayout;
+    getCullBindGroupLayout(): GPUBindGroupLayout;
+    getRenderBindGroupLayout(): GPUBindGroupLayout;
+    getCameraBindGroup(): GPUBindGroup | null;
+    getCameraBuffer(): GPUBuffer | null;
+    getActiveShadowLightCount(): number;
+    getGeometryData(geometry: Geometry): GeometryData;
+    private createGeometryBuffers;
+    private updateGeometryBuffers;
+    private getBatchKey;
+    private computeBoundingSphereRadius;
+    prepareBatches(meshes: Mesh[]): DrawBatch[];
+    private createBatch;
+    private ensureBatchResources;
+    private ensureInstanceBufferCapacity;
+    updateInstanceBuffer(batches: DrawBatch[]): void;
+    updateCameraUniforms(camera: Camera, shadowLights: DirectionalLight[]): void;
+    getCullBindGroup(batch: DrawBatch): GPUBindGroup;
+    getRenderBindGroup(batch: DrawBatch, cameraIndex: number): GPUBindGroup;
+    getIndirectBufferOffset(cameraIndex: number): number;
+    getBatches(): DrawBatch[];
+    getTotalInstances(): number;
+    getStats(): BatchStats;
+    dispose(): void;
+}

package/dist/types/core/renderer/CullingComputePhase.d.ts

@@ -0,0 +1,13 @@
+import { RenderPhase } from './RenderPhase';
+import { BatchManager } from './BatchManager';
+import { Scene } from '../scene/Scene';
+import { Camera } from '../camera/Camera';
+export declare class CullingComputePhase extends RenderPhase {
+    private cullingPipeline;
+    private batchManager;
+    constructor(device: GPUDevice);
+    setBatchManager(batchManager: BatchManager): void;
+    private initPipeline;
+    prepare(_scene: Scene, _camera: Camera): void;
+    execute(commandEncoder: GPUCommandEncoder): void;
+}

package/dist/types/core/renderer/DepthPrePhase.d.ts

@@ -0,0 +1,17 @@
+import { RenderPhase } from './RenderPhase';
+import { Scene } from '../scene/Scene';
+import { Camera } from '../camera/Camera';
+import { BatchManager } from './BatchManager';
+export declare class DepthPrePhase extends RenderPhase {
+    private batchManager;
+    private depthTextureView;
+    private sampleCount;
+    private depthPipeline;
+    private opaqueBatches;
+    constructor(device: GPUDevice, batchManager: BatchManager, sampleCount?: number);
+    private initDepthPipeline;
+    setDepthTextureView(depthTextureView: GPUTextureView): void;
+    prepare(_scene: Scene, _camera: Camera): void;
+    execute(commandEncoder: GPUCommandEncoder): void;
+    dispose(): void;
+}

package/dist/types/core/renderer/LightingManager.d.ts

@@ -0,0 +1,20 @@
+import { Scene } from '../scene/Scene';
+import { Light } from '../light/Light';
+export declare class LightingManager {
+    private device;
+    private lightingBuffer;
+    shadowMapArray: GPUTexture | null;
+    shadowMapArrayView: GPUTextureView | null;
+    private dummyShadowMap;
+    private dummyShadowSampler;
+    private _lightingData;
+    private _tempMatrix;
+    constructor(device: GPUDevice, dummyShadowMap: GPUTextureView, dummyShadowSampler: GPUSampler);
+    collectLights(scene: Scene): Light[];
+    updateLightingBuffer(scene: Scene, lights: Light[], shadowType: number, shadowsEnabled?: boolean): GPUBuffer;
+    private createShadowMapArray;
+    getLightingBuffer(): GPUBuffer | null;
+    getDummyShadowMap(): GPUTextureView;
+    getShadowSampler(): GPUSampler;
+    dispose(): void;
+}

package/dist/types/core/renderer/MainRenderPhase.d.ts

@@ -0,0 +1,62 @@
+import { RenderPhase } from './RenderPhase';
+import { Scene } from '../scene/Scene';
+import { Camera } from '../camera/Camera';
+import { LightingManager } from './LightingManager';
+import { BatchManager } from './BatchManager';
+import { TextureManager } from '../material/TextureManager';
+import { EnvironmentManager } from '../environment/EnvironmentManager';
+import { Environment } from '../environment/Environment';
+export declare class MainRenderPhase extends RenderPhase {
+    private lightingManager;
+    private batchManager;
+    private textureManager;
+    private environmentManager;
+    private context;
+    private depthTextureView;
+    private msaaTextureView;
+    private sampleCount;
+    private renderList;
+    private batches;
+    private currentEnvironment;
+    private skyboxRendered;
+    private clearColor;
+    private cameraPosition;
+    private indirectPipelineCache;
+    private materialBindGroupLayout;
+    private lightingBindGroupLayout;
+    private textureBindGroupLayout;
+    private simpleTextureBindGroupLayout;
+    private textureBindGroupCache;
+    private simpleTextureBindGroupCache;
+    private envParamsBufferCache;
+    private sceneEnvironmentId;
+    private materialEnvKeyCache;
+    debugInfo: {
+        calls: number;
+        triangles: number;
+        batches: number;
+    };
+    constructor(device: GPUDevice, lightingManager: LightingManager, batchManager: BatchManager, textureManager: TextureManager, context: GPUCanvasContext, depthTextureView: GPUTextureView, msaaTextureView: GPUTextureView | null, sampleCount: number);
+    setEnvironmentManager(environmentManager: EnvironmentManager): void;
+    setEnvironment(environment: Environment | null): void;
+    /** Called by Renderer to inform whether skybox was rendered this frame */
+    setSkyboxRendered(rendered: boolean): void;
+    /** Set the clear color for the background */
+    setClearColor(r: number, g: number, b: number, a?: number): void;
+    private initBindGroupLayouts;
+    private getIndirectPipeline;
+    private createLightingBindGroup;
+    invalidateLightingBindGroups(): void;
+    prepare(scene: Scene, camera: Camera): void;
+    execute(commandEncoder: GPUCommandEncoder): void;
+    private sortTransparentBatches;
+    private getBatchCentroidDistance;
+    private renderBatches;
+    private updateMaterial;
+    private getTextureBindGroup;
+    private getSimpleTextureBindGroup;
+    private materialBindGroupCache;
+    private materialBufferCache;
+    private getMaterialBindGroup;
+    dispose(): void;
+}

package/dist/types/core/renderer/Program.d.ts

@@ -0,0 +1,25 @@
+export interface ProgramOptions {
+    vertex: {
+        code: string;
+        entryPoint?: string;
+    };
+    fragment: {
+        code: string;
+        entryPoint?: string;
+    };
+    multisample?: GPUMultisampleState;
+    bindGroupLayouts?: GPUBindGroupLayout[];
+    positionOnly?: boolean;
+    hasNormals?: boolean;
+    hasUVs?: boolean;
+    hasTangents?: boolean;
+    blend?: GPUBlendState;
+    depthWrite?: boolean;
+    depthCompare?: GPUCompareFunction;
+    cullMode?: GPUCullMode;
+}
+export declare class Program {
+    pipeline: GPURenderPipeline;
+    bindGroupLayouts: GPUBindGroupLayout[] | null;
+    constructor(device: GPUDevice, options: ProgramOptions);
+}

package/dist/types/core/renderer/RenderPhase.d.ts

@@ -0,0 +1,10 @@
+import { Scene } from '../scene/Scene';
+import { Camera } from '../camera/Camera';
+export declare abstract class RenderPhase {
+    protected device: GPUDevice;
+    protected label: string;
+    constructor(device: GPUDevice, label: string);
+    abstract prepare(scene: Scene, camera: Camera): void;
+    abstract execute(commandEncoder: GPUCommandEncoder): void;
+    dispose?(): void;
+}

package/dist/types/core/renderer/Renderer.d.ts

@@ -0,0 +1,61 @@
+import { Camera } from '../camera/Camera';
+import { Scene } from '../scene/Scene';
+export declare const ShadowType: {
+    readonly Basic: 0;
+    readonly PCF: 1;
+    readonly PCFSoft: 2;
+};
+export type ShadowType = (typeof ShadowType)[keyof typeof ShadowType];
+export interface RendererOptions {
+    antialias?: boolean;
+    shadowType?: ShadowType;
+    shadows?: boolean;
+}
+export declare class Renderer {
+    canvas: HTMLCanvasElement;
+    device: GPUDevice;
+    context: GPUCanvasContext;
+    presentationFormat: GPUTextureFormat;
+    private pixelRatio;
+    debug: boolean;
+    private isInitialized;
+    private initializationPromise;
+    private lightingManager;
+    private batchManager;
+    private textureManager;
+    private environmentManager;
+    private mainPhase;
+    private shadowPhase;
+    private depthPrePhase;
+    private skyboxPhase;
+    private cullingPhase;
+    private depthTexture;
+    private depthTextureView;
+    private msaaTexture;
+    private msaaTextureView;
+    private dummyShadowMap;
+    private dummyShadowSampler;
+    shadowType: ShadowType;
+    shadowsEnabled: boolean;
+    private sampleCount;
+    private lastBackgroundType;
+    private lastClearColor;
+    debugInfo: {
+        render: {
+            calls: number;
+            triangles: number;
+        };
+        memory: {
+            geometries: number;
+            programs: number;
+        };
+    };
+    constructor(canvas: HTMLCanvasElement, options?: RendererOptions);
+    private init;
+    getPixelRatio(): number;
+    setPixelRatio(value: number): void;
+    resize(): void;
+    private createFrameResources;
+    render(scene: Scene, camera: Camera): Promise<void>;
+    dispose(): void;
+}

package/dist/types/core/renderer/ShadowRenderPhase.d.ts

@@ -0,0 +1,32 @@
+import { RenderPhase } from './RenderPhase';
+import { LightingManager } from './LightingManager';
+import { Scene } from '../scene/Scene';
+import { Camera } from '../camera/Camera';
+import { Light } from '../light/Light';
+import { BatchManager } from './BatchManager';
+export declare class ShadowRenderPhase extends RenderPhase {
+    private lightingManager;
+    private batchManager;
+    private shadowPipeline;
+    private shadowsEnabled;
+    private lights;
+    private scene;
+    private batches;
+    private shadowRenderBindGroupLayout;
+    private lightIndexBuffer;
+    private lightIndexBindGroupLayout;
+    private lightIndexBindGroups;
+    private shadowMapLayerViews;
+    private cachedShadowMapArray;
+    private _sceneBox;
+    private _tempBox;
+    constructor(device: GPUDevice, lightingManager: LightingManager, batchManager: BatchManager);
+    private initShadowRenderPipeline;
+    setEnabled(enabled: boolean): void;
+    setLights(lights: Light[]): void;
+    prepare(scene: Scene, _camera: Camera): void;
+    execute(commandEncoder: GPUCommandEncoder): void;
+    private renderShadowForLight;
+    private updateShadowCameraBounds;
+    dispose(): void;
+}

package/dist/types/core/renderer/SkyboxRenderPhase.d.ts

@@ -0,0 +1,26 @@
+import { RenderPhase } from './RenderPhase';
+import { Scene } from '../scene/Scene';
+import { Camera } from '../camera/Camera';
+import { EnvironmentManager } from '../environment/EnvironmentManager';
+import { Environment } from '../environment/Environment';
+export declare class SkyboxRenderPhase extends RenderPhase {
+    private environmentManager;
+    private presentationFormat;
+    private sampleCount;
+    private pipeline;
+    private bindGroupLayout;
+    private cameraBuffer;
+    private paramsBuffer;
+    private bindGroup;
+    private colorTextureView;
+    private depthTextureView;
+    private environment;
+    constructor(device: GPUDevice, environmentManager: EnvironmentManager, presentationFormat: GPUTextureFormat, sampleCount?: number);
+    private createResources;
+    private createPipeline;
+    setEnvironment(environment: Environment | null): void;
+    setRenderTargets(colorTextureView: GPUTextureView, depthTextureView: GPUTextureView): void;
+    prepare(_scene: Scene, camera: Camera): void;
+    execute(commandEncoder: GPUCommandEncoder): void;
+    dispose(): void;
+}

package/dist/types/core/scene/Scene.d.ts

@@ -0,0 +1,16 @@
+import { Object3D } from '../object/Object3D';
+import { Vector3 } from '../../math';
+import { Environment } from '../environment/Environment';
+export type SceneBackground = {
+    type: "none";
+} | {
+    type: "color";
+    color: Vector3;
+} | {
+    type: "environment";
+};
+export declare class Scene extends Object3D {
+    ambientLight: Vector3;
+    environment: Environment | null;
+    background: SceneBackground;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,28 @@
+export { Renderer } from './core/renderer/Renderer';
+export { ShadowType } from './core/renderer/Renderer';
+export { Scene } from './core/scene/Scene';
+export type { SceneBackground } from './core/scene/Scene';
+export { Object3D } from './core/object/Object3D';
+export { Camera } from './core/camera/Camera';
+export { PerspectiveCamera } from './core/camera/PerspectiveCamera';
+export { OrthographicCamera } from './core/camera/OrthographicCamera';
+export { BasicMaterial } from './core/material/BasicMaterial';
+export { BoxGeometry } from './core/geometry/BoxGeometry';
+export { SphereGeometry } from './core/geometry/SphereGeometry';
+export { PlaneGeometry } from './core/geometry/PlaneGeometry';
+export { CylinderGeometry } from './core/geometry/CylinderGeometry';
+export { TorusGeometry } from './core/geometry/TorusGeometry';
+export { CircleGeometry } from './core/geometry/CircleGeometry';
+export { ConeGeometry } from './core/geometry/ConeGeometry';
+export { Mesh } from './core/object/Mesh';
+export { PhongMaterial } from './core/material/PhongMaterial';
+export { LambertMaterial } from './core/material/LambertMaterial';
+export { StandardMaterial } from './core/material/StandardMaterial';
+export { Texture } from './core/material/Texture';
+export { BlendMode } from './core/material/Material';
+export { Light } from './core/light/Light';
+export { DirectionalLight } from './core/light/DirectionalLight';
+export { Environment } from './core/environment/Environment';
+export { GLTFLoader } from './loaders/GLTFLoader';
+export { OrbitControls } from './core/controls/OrbitControls';
+export { Vector2, Vector3, Box3, Euler, Quaternion, Matrix3, Matrix4, clamp, degToRad, radToDeg, } from './math';

package/dist/types/loaders/GLTFInterfaces.d.ts

@@ -0,0 +1,144 @@
+export interface GLTF {
+    asset: GLTFAsset;
+    scene?: number;
+    scenes?: GLTFScene[];
+    nodes?: GLTFNode[];
+    meshes?: GLTFMesh[];
+    materials?: GLTFMaterial[];
+    textures?: GLTFTexture[];
+    images?: GLTFImage[];
+    samplers?: GLTFSampler[];
+    accessors?: GLTFAccessor[];
+    bufferViews?: GLTFBufferView[];
+    buffers?: GLTFBuffer[];
+}
+export interface GLTFAsset {
+    version: string;
+    generator?: string;
+    minVersion?: string;
+}
+export interface GLTFScene {
+    nodes?: number[];
+    name?: string;
+}
+export interface GLTFNode {
+    camera?: number;
+    children?: number[];
+    skin?: number;
+    matrix?: number[];
+    mesh?: number;
+    rotation?: number[];
+    scale?: number[];
+    translation?: number[];
+    weights?: number[];
+    name?: string;
+}
+export interface GLTFMesh {
+    primitives: GLTFPrimitive[];
+    weights?: number[];
+    name?: string;
+}
+export interface GLTFPrimitive {
+    attributes: {
+        [key: string]: number;
+    };
+    indices?: number;
+    material?: number;
+    mode?: number;
+    targets?: {
+        [key: string]: number;
+    }[];
+}
+export interface GLTFMaterial {
+    name?: string;
+    pbrMetallicRoughness?: GLTFPbrMetallicRoughness;
+    normalTexture?: GLTFTextureInfo;
+    occlusionTexture?: GLTFTextureInfo;
+    emissiveTexture?: GLTFTextureInfo;
+    emissiveFactor?: number[];
+    alphaMode?: "OPAQUE" | "MASK" | "BLEND";
+    alphaCutoff?: number;
+    doubleSided?: boolean;
+}
+export interface GLTFPbrMetallicRoughness {
+    baseColorFactor?: number[];
+    baseColorTexture?: GLTFTextureInfo;
+    metallicFactor?: number;
+    roughnessFactor?: number;
+    metallicRoughnessTexture?: GLTFTextureInfo;
+}
+export interface GLTFTextureInfo {
+    index: number;
+    texCoord?: number;
+    scale?: number;
+    strength?: number;
+}
+export interface GLTFTexture {
+    sampler?: number;
+    source?: number;
+    name?: string;
+}
+export interface GLTFImage {
+    uri?: string;
+    mimeType?: string;
+    bufferView?: number;
+    name?: string;
+}
+export interface GLTFSampler {
+    magFilter?: number;
+    minFilter?: number;
+    wrapS?: number;
+    wrapT?: number;
+    name?: string;
+}
+export interface GLTFAccessor {
+    bufferView?: number;
+    byteOffset?: number;
+    componentType: number;
+    normalized?: boolean;
+    count: number;
+    type: "SCALAR" | "VEC2" | "VEC3" | "VEC4" | "MAT2" | "MAT3" | "MAT4";
+    max?: number[];
+    min?: number[];
+    sparse?: object;
+    name?: string;
+}
+export interface GLTFBufferView {
+    buffer: number;
+    byteOffset?: number;
+    byteLength: number;
+    byteStride?: number;
+    target?: number;
+    name?: string;
+}
+export interface GLTFBuffer {
+    uri?: string;
+    byteLength: number;
+    name?: string;
+}
+export declare const GLTFConstants: {
+    POINTS: number;
+    LINES: number;
+    LINE_LOOP: number;
+    LINE_STRIP: number;
+    TRIANGLES: number;
+    TRIANGLE_STRIP: number;
+    TRIANGLE_FAN: number;
+    BYTE: number;
+    UNSIGNED_BYTE: number;
+    SHORT: number;
+    UNSIGNED_SHORT: number;
+    UNSIGNED_INT: number;
+    FLOAT: number;
+    ARRAY_BUFFER: number;
+    ELEMENT_ARRAY_BUFFER: number;
+    NEAREST: number;
+    LINEAR: number;
+    NEAREST_MIPMAP_NEAREST: number;
+    LINEAR_MIPMAP_NEAREST: number;
+    NEAREST_MIPMAP_LINEAR: number;
+    LINEAR_MIPMAP_LINEAR: number;
+    CLAMP_TO_EDGE: number;
+    MIRRORED_REPEAT: number;
+    REPEAT: number;
+};

package/dist/types/loaders/GLTFLoader.d.ts

@@ -0,0 +1,30 @@
+import { GLTF } from './GLTFInterfaces';
+import { Object3D } from '../core/object/Object3D';
+export declare class GLTFLoader {
+    private json;
+    private bufferData;
+    private textures;
+    private materials;
+    private meshes;
+    private geometries;
+    private baseURL;
+    load(url: string): Promise<Object3D>;
+    private parseGLB;
+    parse(json: GLTF, isGLB?: boolean): Promise<Object3D>;
+    private loadBuffers;
+    private resolveURL;
+    private loadTextures;
+    private convertWrapMode;
+    private convertMinFilter;
+    private convertMagFilter;
+    private loadMaterials;
+    private loadMeshes;
+    private getAccessor;
+    private getAccessorData;
+    private getNumComponents;
+    private getComponentSize;
+    private createTypedArray;
+    private buildScene;
+    private parseNode;
+    private createMeshNode;
+}

package/dist/types/math/Box3.d.ts

@@ -0,0 +1,21 @@
+import { Vector3 } from './Vector3';
+import { Matrix4 } from './Matrix4';
+export declare class Box3 {
+    min: Vector3;
+    max: Vector3;
+    constructor(min?: Vector3, max?: Vector3);
+    set(min: Vector3, max: Vector3): this;
+    setFromPoints(points: Vector3[]): this;
+    setFromBufferAttribute(attribute: Float32Array): this;
+    clone(): Box3;
+    copy(box: Box3): this;
+    makeEmpty(): this;
+    isEmpty(): boolean;
+    expandByPoint(point: Vector3): this;
+    expandByScalar(scalar: number): this;
+    expandByObject(_object: any): this;
+    union(box: Box3): this;
+    applyMatrix4(matrix: Matrix4): this;
+    getCenter(target: Vector3): Vector3;
+    getSize(target: Vector3): Vector3;
+}

package/dist/types/math/Euler.d.ts

@@ -0,0 +1,12 @@
+import { Matrix3 } from './Matrix3';
+import { Quaternion } from './Quaternion';
+export declare class Euler {
+    x: number;
+    y: number;
+    z: number;
+    order: string;
+    constructor(x?: number, y?: number, z?: number, order?: string);
+    setFromQuaternion(q: Quaternion, order: string): this;
+    setFromRotationMatrix(m: Matrix3, order: string): this;
+    clone(): Euler;
+}

package/dist/types/math/Matrix3.d.ts

@@ -0,0 +1,20 @@
+import { Euler } from './Euler';
+import { Quaternion } from './Quaternion';
+export declare class Matrix3 {
+    elements: number[];
+    constructor();
+    set(m11: number, m12: number, m13: number, m21: number, m22: number, m23: number, m31: number, m32: number, m33: number): this;
+    identity(): this;
+    multiply(m: Matrix3): this;
+    premultiply(m: Matrix3): this;
+    multiplyMatrices(a: Matrix3, b: Matrix3): this;
+    multiplyScalar(s: number): this;
+    determinant(): number;
+    invert(): this;
+    transpose(): this;
+    makeRotationFromEuler(euler: Euler): this;
+    makeRotationFromQuaternion(quaternion: Quaternion): this;
+    fromArray(array: number[]): this;
+    toArray(): number[];
+    clone(): Matrix3;
+}

package/dist/types/math/Matrix4.d.ts

@@ -0,0 +1,31 @@
+import { Vector3 } from './Vector3';
+import { Matrix3 } from './Matrix3';
+import { Quaternion } from './Quaternion';
+export declare class Matrix4 {
+    elements: number[];
+    constructor();
+    set(m11: number, m12: number, m13: number, m14: number, m21: number, m22: number, m23: number, m24: number, m31: number, m32: number, m33: number, m34: number, m41: number, m42: number, m43: number, m44: number): this;
+    identity(): this;
+    copy(m: Matrix4): this;
+    multiply(m: Matrix4): this;
+    premultiply(m: Matrix4): this;
+    multiplyMatrices(a: Matrix4, b: Matrix4): this;
+    multiplyScalar(s: number): this;
+    determinant(): number;
+    invert(): this;
+    transpose(): this;
+    setPosition(position: Vector3): this;
+    scalePosition(scale: Vector3): this;
+    setRotation(rotation: Matrix3): this;
+    extractPosition(): Vector3;
+    extractRotation(): Matrix3;
+    lookAt(eye: Vector3, target: Vector3, up: Vector3): this;
+    fromArray(array: number[]): this;
+    toArray(): number[];
+    clone(): Matrix4;
+    lerp(other: Matrix4, coef: number): Matrix4;
+    compose(position: Vector3, quaternion: Quaternion, scale: Vector3): this;
+    decompose(position: Vector3, quaternion: Quaternion, scale: Vector3): this;
+    perspective(fov: number, aspect: number, near: number, far: number): this;
+    orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): this;
+}