gfxlite 0.1.0

package/dist/types/core/camera/Camera.d.ts

@@ -0,0 +1,13 @@
+import { Matrix4 } from '../../math';
+import { Object3D } from '../object/Object3D';
+export declare class Camera extends Object3D {
+    projectionMatrix: Matrix4;
+    viewMatrix: Matrix4;
+    viewProjectionMatrix: Matrix4;
+    frustumPlanes: Float32Array;
+    updateWorldMatrix(parentWorldMatrix?: Matrix4): void;
+    updateProjectionMatrix(): void;
+    private updateViewProjectionMatrix;
+    private extractFrustumPlanes;
+    private normalizePlane;
+}

package/dist/types/core/camera/OrthographicCamera.d.ts

@@ -0,0 +1,11 @@
+import { Camera } from './Camera';
+export declare class OrthographicCamera extends Camera {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    near: number;
+    far: number;
+    constructor(left?: number, right?: number, top?: number, bottom?: number, near?: number, far?: number);
+    updateProjectionMatrix(): void;
+}

package/dist/types/core/camera/PerspectiveCamera.d.ts

@@ -0,0 +1,9 @@
+import { Camera } from './Camera';
+export declare class PerspectiveCamera extends Camera {
+    fov: number;
+    aspect: number;
+    near: number;
+    far: number;
+    constructor(fov?: number, aspect?: number, near?: number, far?: number);
+    updateProjectionMatrix(): void;
+}

package/dist/types/core/controls/OrbitControls.d.ts

@@ -0,0 +1,84 @@
+import { Vector3 } from '../../math';
+import { Camera } from '../camera/Camera';
+export interface OrbitControlsOptions {
+    /** Enable/disable controls */
+    enabled?: boolean;
+    /** Target point to orbit around */
+    target?: Vector3;
+    /** Minimum distance from target */
+    minDistance?: number;
+    /** Maximum distance from target */
+    maxDistance?: number;
+    /** Minimum polar angle (radians, 0 = top) */
+    minPolarAngle?: number;
+    /** Maximum polar angle (radians, PI = bottom) */
+    maxPolarAngle?: number;
+    /** Enable damping (inertia) */
+    enableDamping?: boolean;
+    /** Damping factor (0-1, lower = more damping) */
+    dampingFactor?: number;
+    /** Rotation speed multiplier */
+    rotateSpeed?: number;
+    /** Pan speed multiplier */
+    panSpeed?: number;
+    /** Zoom speed multiplier */
+    zoomSpeed?: number;
+    /** Enable panning */
+    enablePan?: boolean;
+    /** Enable zooming */
+    enableZoom?: boolean;
+}
+export declare class OrbitControls {
+    enabled: boolean;
+    target: Vector3;
+    minDistance: number;
+    maxDistance: number;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    rotateSpeed: number;
+    panSpeed: number;
+    zoomSpeed: number;
+    enablePan: boolean;
+    enableZoom: boolean;
+    private camera;
+    private domElement;
+    private spherical;
+    private sphericalDelta;
+    private panOffset;
+    private scale;
+    private isPointerDown;
+    private pointerStart;
+    private pointerType;
+    private touches;
+    private lastPinchDistance;
+    private onPointerDownBound;
+    private onPointerMoveBound;
+    private onPointerUpBound;
+    private onWheelBound;
+    private onContextMenuBound;
+    constructor(camera: Camera, domElement: HTMLElement, options?: OrbitControlsOptions);
+    private updateSphericalFromCamera;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onWheel;
+    private pan;
+    /**
+     * Update camera position. Call this every frame.
+     */
+    update(): void;
+    /**
+     * Set the target point to orbit around.
+     */
+    setTarget(x: number, y: number, z: number): void;
+    /**
+     * Reset the camera to look at target from current position.
+     */
+    reset(): void;
+    /**
+     * Remove event listeners and clean up.
+     */
+    dispose(): void;
+}

package/dist/types/core/environment/Environment.d.ts

@@ -0,0 +1,25 @@
+export interface EnvironmentOptions {
+    resolution?: number;
+    specularMipLevels?: number;
+    intensity?: number;
+}
+export declare class Environment {
+    readonly id: number;
+    needsUpdate: boolean;
+    hdrData: Float32Array | null;
+    hdrWidth: number;
+    hdrHeight: number;
+    resolution: number;
+    specularMipLevels: number;
+    intensity: number;
+    equirectTexture: GPUTexture | null;
+    cubemap: GPUTexture | null;
+    cubemapView: GPUTextureView | null;
+    irradianceMap: GPUTexture | null;
+    irradianceMapView: GPUTextureView | null;
+    prefilteredMap: GPUTexture | null;
+    prefilteredMapView: GPUTextureView | null;
+    constructor(options?: EnvironmentOptions);
+    static loadHDR(url: string, options?: EnvironmentOptions): Promise<Environment>;
+    dispose(): void;
+}

package/dist/types/core/environment/EnvironmentManager.d.ts

@@ -0,0 +1,44 @@
+import { Environment } from './Environment';
+export declare class EnvironmentManager {
+    private device;
+    private equirectToCubemapPipeline;
+    private irradiancePipeline;
+    private prefilterPipeline;
+    private brdfPipeline;
+    private equirectBindGroupLayout;
+    private irradianceBindGroupLayout;
+    private prefilterBindGroupLayout;
+    private brdfBindGroupLayout;
+    private environmentBindGroupLayout;
+    private brdfLUT;
+    brdfLUTView: GPUTextureView | null;
+    private brdfGenerated;
+    dummyCubemapView: GPUTextureView | null;
+    cubemapSampler: GPUSampler | null;
+    brdfSampler: GPUSampler | null;
+    private envParamsBuffer;
+    private environmentBindGroupCache;
+    private dummyEnvironmentBindGroup;
+    constructor(device: GPUDevice);
+    private createPipelines;
+    private createEquirectToCubemapPipeline;
+    private createIrradiancePipeline;
+    private createPrefilterPipeline;
+    private createBRDFPipeline;
+    private createDummyResources;
+    private createEnvironmentBindGroupLayout;
+    private generateBRDFLUT;
+    processEnvironment(environment: Environment): void;
+    private convertEquirectToCubemap;
+    private generateCubemapMipmaps;
+    private generateIrradianceMap;
+    private generatePrefilteredMap;
+    getEnvironmentBindGroupLayout(): GPUBindGroupLayout;
+    getEnvironmentBindGroup(environment: Environment | null): GPUBindGroup;
+    getSkyboxResources(environment: Environment | null): {
+        cubemapView: GPUTextureView;
+        sampler: GPUSampler;
+        intensity: number;
+    };
+    dispose(): void;
+}

package/dist/types/core/geometry/BoxGeometry.d.ts

@@ -0,0 +1,13 @@
+import { Geometry } from '../geometry/Geometry';
+export declare class BoxGeometry extends Geometry {
+    width: number;
+    height: number;
+    depth: number;
+    constructor({ width, height, depth }?: {
+        width?: number | undefined;
+        height?: number | undefined;
+        depth?: number | undefined;
+    });
+    invalidate(): void;
+    private static build;
+}

package/dist/types/core/geometry/CircleGeometry.d.ts

@@ -0,0 +1,11 @@
+import { Geometry } from '../geometry/Geometry';
+export declare class CircleGeometry extends Geometry {
+    radius: number;
+    segments: number;
+    constructor({ radius, segments }?: {
+        radius?: number | undefined;
+        segments?: number | undefined;
+    });
+    invalidate(): void;
+    private static build;
+}

package/dist/types/core/geometry/ConeGeometry.d.ts

@@ -0,0 +1,17 @@
+import { Geometry } from '../geometry/Geometry';
+export declare class ConeGeometry extends Geometry {
+    radius: number;
+    height: number;
+    radialSegments: number;
+    heightSegments: number;
+    openEnded: boolean;
+    constructor({ radius, height, radialSegments, heightSegments, openEnded, }?: {
+        radius?: number | undefined;
+        height?: number | undefined;
+        radialSegments?: number | undefined;
+        heightSegments?: number | undefined;
+        openEnded?: boolean | undefined;
+    });
+    invalidate(): void;
+    private static build;
+}

package/dist/types/core/geometry/CylinderGeometry.d.ts

@@ -0,0 +1,19 @@
+import { Geometry } from '../geometry/Geometry';
+export declare class CylinderGeometry extends Geometry {
+    radiusTop: number;
+    radiusBottom: number;
+    height: number;
+    radialSegments: number;
+    heightSegments: number;
+    openEnded: boolean;
+    constructor({ radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, }?: {
+        radiusTop?: number | undefined;
+        radiusBottom?: number | undefined;
+        height?: number | undefined;
+        radialSegments?: number | undefined;
+        heightSegments?: number | undefined;
+        openEnded?: boolean | undefined;
+    });
+    invalidate(): void;
+    private static build;
+}

package/dist/types/core/geometry/Geometry.d.ts

@@ -0,0 +1,27 @@
+import { Box3 } from '../../math/Box3';
+export declare class Geometry {
+    readonly id: number;
+    vertices: Float32Array;
+    normals: Float32Array | null;
+    uvs: Float32Array | null;
+    tangents: Float32Array | null;
+    indices: Uint32Array | null;
+    indexCount: number;
+    boundingBox: Box3 | null;
+    /**
+     * Version counter that increments when the geometry is invalidated.
+     * Used by BatchManager to detect when GPU buffers need re-uploading.
+     */
+    version: number;
+    constructor(vertices: Float32Array, indices?: Uint32Array, normals?: Float32Array, uvs?: Float32Array, tangents?: Float32Array);
+    computeBoundingBox(): void;
+    /**
+     * Called after modifying geometry parameters. Subclasses should override
+     * this to rebuild vertex data, then call super.invalidate().
+     */
+    invalidate(): void;
+    /**
+     * Helper for subclasses to update geometry data and trigger invalidation.
+     */
+    protected setBuffers(vertices: Float32Array, indices: Uint32Array, normals: Float32Array, uvs: Float32Array): void;
+}

package/dist/types/core/geometry/PlaneGeometry.d.ts

@@ -0,0 +1,15 @@
+import { Geometry } from '../geometry/Geometry';
+export declare class PlaneGeometry extends Geometry {
+    width: number;
+    height: number;
+    widthSegments: number;
+    heightSegments: number;
+    constructor({ width, height, widthSegments, heightSegments, }?: {
+        width?: number | undefined;
+        height?: number | undefined;
+        widthSegments?: number | undefined;
+        heightSegments?: number | undefined;
+    });
+    invalidate(): void;
+    private static build;
+}

package/dist/types/core/geometry/SphereGeometry.d.ts

@@ -0,0 +1,13 @@
+import { Geometry } from '../geometry/Geometry';
+export declare class SphereGeometry extends Geometry {
+    radius: number;
+    widthSegments: number;
+    heightSegments: number;
+    constructor({ radius, widthSegments, heightSegments }?: {
+        radius?: number | undefined;
+        widthSegments?: number | undefined;
+        heightSegments?: number | undefined;
+    });
+    invalidate(): void;
+    private static build;
+}

package/dist/types/core/geometry/TorusGeometry.d.ts

@@ -0,0 +1,15 @@
+import { Geometry } from '../geometry/Geometry';
+export declare class TorusGeometry extends Geometry {
+    radius: number;
+    tube: number;
+    radialSegments: number;
+    tubularSegments: number;
+    constructor({ radius, tube, radialSegments, tubularSegments, }?: {
+        radius?: number | undefined;
+        tube?: number | undefined;
+        radialSegments?: number | undefined;
+        tubularSegments?: number | undefined;
+    });
+    invalidate(): void;
+    private static build;
+}

package/dist/types/core/light/DirectionalLight.d.ts

@@ -0,0 +1,19 @@
+import { Light } from './Light';
+import { Vector3 } from '../../math';
+import { OrthographicCamera } from '../camera/OrthographicCamera';
+export declare class DirectionalLight extends Light {
+    constructor(color?: Vector3, intensity?: number);
+    get direction(): Vector3;
+    shadow: {
+        camera: OrthographicCamera;
+        mapSize: {
+            width: number;
+            height: number;
+        };
+        bias: number;
+        map: GPUTexture | undefined;
+        view: GPUTextureView | undefined;
+        sampler: GPUSampler | undefined;
+        autoUpdate: boolean;
+    };
+}

package/dist/types/core/light/Light.d.ts

@@ -0,0 +1,7 @@
+import { Object3D } from '../object/Object3D';
+import { Vector3 } from '../../math';
+export declare class Light extends Object3D {
+    color: Vector3;
+    intensity: number;
+    constructor(color?: Vector3, intensity?: number);
+}

package/dist/types/core/material/BasicMaterial.d.ts

@@ -0,0 +1,20 @@
+import { Vector3 } from '../../math';
+import { Material } from './Material';
+import { Texture } from './Texture';
+export interface BasicMaterialOptions {
+    color?: Vector3;
+    opacity?: number;
+    transparent?: boolean;
+    map?: Texture;
+}
+export declare class BasicMaterial extends Material {
+    readonly materialType: 0;
+    readonly needsLighting = false;
+    readonly needsNormals = false;
+    map: Texture | null;
+    constructor({ color, opacity, transparent, map, }?: BasicMaterialOptions);
+    hasTextures(): boolean;
+    getUniformBufferData(): Float32Array;
+    getVertexShader(): string;
+    getFragmentShader(): string;
+}

package/dist/types/core/material/LambertMaterial.d.ts

@@ -0,0 +1,20 @@
+import { Vector3 } from '../../math';
+import { Material } from './Material';
+import { Texture } from './Texture';
+export interface LambertMaterialOptions {
+    color?: Vector3;
+    opacity?: number;
+    transparent?: boolean;
+    map?: Texture;
+}
+export declare class LambertMaterial extends Material {
+    readonly materialType: 1;
+    readonly needsLighting = true;
+    readonly needsNormals = true;
+    map: Texture | null;
+    constructor({ color, opacity, transparent, map, }?: LambertMaterialOptions);
+    hasTextures(): boolean;
+    getUniformBufferData(): Float32Array;
+    getVertexShader(): string;
+    getFragmentShader(): string;
+}

package/dist/types/core/material/Material.d.ts

@@ -0,0 +1,34 @@
+export declare const BlendMode: {
+    readonly Opaque: 0;
+    readonly AlphaBlend: 1;
+    readonly AlphaCutoff: 2;
+};
+export type BlendMode = (typeof BlendMode)[keyof typeof BlendMode];
+export declare const MaterialType: {
+    readonly Basic: 0;
+    readonly Lambert: 1;
+    readonly Phong: 2;
+    readonly Standard: 3;
+};
+export type MaterialType = (typeof MaterialType)[keyof typeof MaterialType];
+export declare abstract class Material {
+    readonly id: number;
+    needsUpdate: boolean;
+    uniforms: {
+        [key: string]: unknown;
+    };
+    transparent: boolean;
+    opacity: number;
+    blendMode: BlendMode;
+    alphaCutoff: number;
+    depthWrite: boolean;
+    doubleSided: boolean;
+    abstract readonly materialType: MaterialType;
+    abstract readonly needsLighting: boolean;
+    abstract readonly needsNormals: boolean;
+    abstract getUniformBufferData(): Float32Array;
+    abstract getVertexShader(): string;
+    abstract getFragmentShader(): string;
+    hasTextures(): boolean;
+    getPipelineKey(): string;
+}

package/dist/types/core/material/PhongMaterial.d.ts

@@ -0,0 +1,22 @@
+import { Vector3 } from '../../math';
+import { Material } from './Material';
+import { Texture } from './Texture';
+export interface PhongMaterialOptions {
+    color?: Vector3;
+    specular?: Vector3;
+    shininess?: number;
+    opacity?: number;
+    transparent?: boolean;
+    map?: Texture;
+}
+export declare class PhongMaterial extends Material {
+    readonly materialType: 2;
+    readonly needsLighting = true;
+    readonly needsNormals = true;
+    map: Texture | null;
+    constructor({ color, specular, shininess, opacity, transparent, map, }?: PhongMaterialOptions);
+    hasTextures(): boolean;
+    getUniformBufferData(): Float32Array;
+    getVertexShader(): string;
+    getFragmentShader(): string;
+}

package/dist/types/core/material/StandardMaterial.d.ts

@@ -0,0 +1,42 @@
+import { Vector3 } from '../../math';
+import { Material, BlendMode } from './Material';
+import { Texture } from './Texture';
+import { Environment } from '../environment/Environment';
+export interface StandardMaterialOptions {
+    baseColor?: Vector3;
+    opacity?: number;
+    metallic?: number;
+    roughness?: number;
+    emissive?: Vector3;
+    emissiveFactor?: number;
+    normalScale?: number;
+    occlusionStrength?: number;
+    baseColorMap?: Texture;
+    normalMap?: Texture;
+    metallicRoughnessMap?: Texture;
+    emissiveMap?: Texture;
+    aoMap?: Texture;
+    transparent?: boolean;
+    blendMode?: BlendMode;
+    alphaCutoff?: number;
+    doubleSided?: boolean;
+    envMap?: Environment;
+    envMapIntensity?: number;
+}
+export declare class StandardMaterial extends Material {
+    readonly materialType: 3;
+    readonly needsLighting = true;
+    readonly needsNormals = true;
+    baseColorMap: Texture | null;
+    normalMap: Texture | null;
+    metallicRoughnessMap: Texture | null;
+    emissiveMap: Texture | null;
+    aoMap: Texture | null;
+    envMap: Environment | null;
+    envMapIntensity: number;
+    constructor(options?: StandardMaterialOptions);
+    hasTextures(): boolean;
+    getUniformBufferData(): Float32Array;
+    getVertexShader(): string;
+    getFragmentShader(): string;
+}

package/dist/types/core/material/Texture.d.ts

@@ -0,0 +1,24 @@
+export interface TextureOptions {
+    wrapS?: GPUAddressMode;
+    wrapT?: GPUAddressMode;
+    minFilter?: GPUFilterMode;
+    magFilter?: GPUFilterMode;
+    mipmaps?: boolean;
+    flipY?: boolean;
+}
+export declare class Texture {
+    readonly id: number;
+    source: ImageBitmap | null;
+    needsUpdate: boolean;
+    wrapS: GPUAddressMode;
+    wrapT: GPUAddressMode;
+    minFilter: GPUFilterMode;
+    magFilter: GPUFilterMode;
+    mipmaps: boolean;
+    flipY: boolean;
+    gpuTexture: GPUTexture | null;
+    gpuTextureView: GPUTextureView | null;
+    constructor(source?: ImageBitmap, options?: TextureOptions);
+    static load(url: string, options?: TextureOptions): Promise<Texture>;
+    dispose(): void;
+}

package/dist/types/core/material/TextureManager.d.ts

@@ -0,0 +1,18 @@
+import { Texture } from './Texture';
+export declare class TextureManager {
+    private device;
+    private samplerCache;
+    dummyWhiteTexture: GPUTextureView;
+    dummyNormalTexture: GPUTextureView;
+    dummyBlackTexture: GPUTextureView;
+    defaultSampler: GPUSampler;
+    private mipmapPipeline;
+    private mipmapBindGroupLayout;
+    constructor(device: GPUDevice);
+    private createDummyTextures;
+    private createMipmapPipeline;
+    uploadTexture(texture: Texture): GPUTextureView;
+    private generateMipmaps;
+    getSampler(texture: Texture): GPUSampler;
+    dispose(): void;
+}

package/dist/types/core/object/Mesh.d.ts

@@ -0,0 +1,8 @@
+import { Geometry } from '../geometry/Geometry';
+import { Material } from '../material/Material';
+import { Object3D } from '../object/Object3D';
+export declare class Mesh extends Object3D {
+    geometry: Geometry;
+    material: Material;
+    constructor(geometry: Geometry, material: Material);
+}

package/dist/types/core/object/Object3D.d.ts

@@ -0,0 +1,35 @@
+import { Matrix4, Quaternion, Vector3 } from '../../math';
+export declare class Object3D {
+    readonly id: number;
+    name: string;
+    parent: Object3D | null;
+    children: Object3D[];
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+    castShadow: boolean;
+    receiveShadow: boolean;
+    localMatrix: Matrix4;
+    worldMatrix: Matrix4;
+    lookAt(target: Vector3): void;
+    add(child: Object3D): void;
+    remove(child: Object3D): void;
+    rotateOnAxis(axis: Vector3, angle: number): this;
+    rotateX(angle: number): this;
+    rotateY(angle: number): this;
+    rotateZ(angle: number): this;
+    /**
+     * Updates the object's local matrix from its position, rotation, and scale.
+     */
+    updateLocalMatrix(): void;
+    /**
+     * Updates the object's world matrix, and recursively updates all children.
+     * @param parentWorldMatrix The world matrix of the parent object.
+     */
+    updateWorldMatrix(parentWorldMatrix?: Matrix4): void;
+    /**
+     * Traverses the object and its descendants.
+     * @param callback The function to call for each object.
+     */
+    traverse(callback: (object: Object3D) => void): void;
+}