@needle-tools/three 0.169.12 → 0.169.13

package/types/src/renderers/shaders/UniformsLib.d.ts

@@ -0,0 +1,189 @@
+import { Color } from "../../math/Color.js";
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Vector2 } from "../../math/Vector2.js";
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export interface IUniform<TValue = any> {
+    value: TValue;
+}
+
+export const UniformsLib: {
+    common: {
+        diffuse: IUniform<Color>;
+        opacity: IUniform<number>;
+        map: IUniform<unknown>;
+        mapTransform: IUniform<Matrix3>;
+        alphaMap: IUniform<unknown>;
+        alphaMapTransform: IUniform<Matrix3>;
+        alphaTest: IUniform<number>;
+    };
+    specularmap: {
+        specularMap: IUniform<unknown>;
+        specularMapTransform: IUniform<Matrix3>;
+    };
+    envmap: {
+        envMap: IUniform<unknown>;
+        envMapRotation: IUniform<Matrix3>;
+        flipEnvMap: IUniform<number>;
+        reflectivity: IUniform<number>;
+        ior: IUniform<number>;
+        refractRatio: IUniform<number>;
+    };
+    aomap: {
+        aoMap: IUniform<unknown>;
+        aoMapIntensity: IUniform<number>;
+        aoMapTransform: IUniform<Matrix3>;
+    };
+    lightmap: {
+        lightMap: IUniform<number>;
+        lightMapIntensity: IUniform<number>;
+        lightMapTransform: IUniform<Matrix3>;
+    };
+    bumpmap: {
+        bumpMap: IUniform<unknown>;
+        bumpMapTransform: IUniform<Matrix3>;
+        bumpScale: IUniform<number>;
+    };
+    normalmap: {
+        normalMap: IUniform<unknown>;
+        normalMapTransform: IUniform<Matrix3>;
+        normalScale: IUniform<Vector2>;
+    };
+    displacementmap: {
+        displacementMap: IUniform<unknown>;
+        displacementMapTransform: IUniform<Matrix3>;
+        displacementScale: IUniform<number>;
+        displacementBias: IUniform<number>;
+    };
+    emissivemap: {
+        emissiveMap: IUniform<unknown>;
+        emissiveMapTransform: IUniform<Matrix3>;
+    };
+    metalnessmap: {
+        metalnessMap: IUniform<unknown>;
+        metalnessMapTransform: IUniform<Matrix3>;
+    };
+    roughnessmap: {
+        roughnessMap: IUniform<unknown>;
+        roughnessMapTransform: IUniform<Matrix3>;
+    };
+    gradientmap: {
+        gradientMap: IUniform<unknown>;
+    };
+    fog: {
+        fogDensity: IUniform<number>;
+        fogNear: IUniform<number>;
+        fogFar: IUniform<number>;
+        fogColor: IUniform<Color>;
+    };
+    lights: {
+        ambientLightColor: IUniform<unknown[]>;
+        lightProbe: IUniform<unknown[]>;
+        directionalLights: {
+            value: unknown[];
+            properties: {
+                direction: {};
+                color: {};
+            };
+        };
+        directionalLightShadows: {
+            value: unknown[];
+            properties: {
+                shadowIntensity: number;
+                shadowBias: {};
+                shadowNormalBias: {};
+                shadowRadius: {};
+                shadowMapSize: {};
+            };
+        };
+        directionalShadowMap: IUniform<unknown[]>;
+        directionalShadowMatrix: IUniform<unknown[]>;
+        spotLights: {
+            value: unknown[];
+            properties: {
+                color: {};
+                position: {};
+                direction: {};
+                distance: {};
+                coneCos: {};
+                penumbraCos: {};
+                decay: {};
+            };
+        };
+        spotLightShadows: {
+            value: unknown[];
+            properties: {
+                shadowIntensity: number;
+                shadowBias: {};
+                shadowNormalBias: {};
+                shadowRadius: {};
+                shadowMapSize: {};
+            };
+        };
+        spotLightMap: IUniform<unknown[]>;
+        spotShadowMap: IUniform<unknown[]>;
+        spotLightMatrix: IUniform<unknown[]>;
+        pointLights: {
+            value: unknown[];
+            properties: {
+                color: {};
+                position: {};
+                decay: {};
+                distance: {};
+            };
+        };
+        pointLightShadows: {
+            value: unknown[];
+            properties: {
+                shadowIntensity: number;
+                shadowBias: {};
+                shadowNormalBias: {};
+                shadowRadius: {};
+                shadowMapSize: {};
+                shadowCameraNear: {};
+                shadowCameraFar: {};
+            };
+        };
+        pointShadowMap: IUniform<unknown[]>;
+        pointShadowMatrix: IUniform<unknown[]>;
+        hemisphereLights: {
+            value: unknown[];
+            properties: {
+                direction: {};
+                skycolor: {};
+                groundColor: {};
+            };
+        };
+        rectAreaLights: {
+            value: unknown[];
+            properties: {
+                color: {};
+                position: {};
+                width: {};
+                height: {};
+            };
+        };
+        ltc_1: IUniform<unknown>;
+        ltc_2: IUniform<unknown>;
+    };
+    points: {
+        diffuse: IUniform<Color>;
+        opacity: IUniform<number>;
+        size: IUniform<number>;
+        scale: IUniform<number>;
+        map: IUniform<unknown>;
+        alphaMap: IUniform<unknown>;
+        alphaTest: IUniform<number>;
+        uvTransform: IUniform<Matrix3>;
+    };
+    sprite: {
+        diffuse: IUniform<Color>;
+        opacity: IUniform<number>;
+        center: IUniform<Vector2>;
+        rotation: IUniform<number>;
+        map: IUniform<unknown>;
+        mapTransform: IUniform<Matrix3>;
+        alphaMap: IUniform<unknown>;
+        alphaTest: IUniform<number>;
+    };
+};

package/types/src/renderers/shaders/UniformsUtils.d.ts

@@ -0,0 +1,14 @@
+import { UniformsGroup } from "../../core/UniformsGroup.js";
+import { IUniform } from "./UniformsLib.js";
+
+export function cloneUniforms<T extends { [uniform: string]: IUniform }>(uniformsSrc: T): T;
+export function mergeUniforms(uniforms: Array<{ [uniform: string]: IUniform }>): { [uniform: string]: IUniform };
+
+export function cloneUniformsGroups(src: UniformsGroup[]): UniformsGroup[];
+
+declare const UniformsUtils: {
+    clone: typeof cloneUniforms;
+    merge: typeof mergeUniforms;
+};
+
+export { UniformsUtils };

package/types/src/renderers/webgl/WebGLAttributes.d.ts

@@ -0,0 +1,21 @@
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { GLBufferAttribute } from "../../core/GLBufferAttribute.js";
+import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
+
+export class WebGLAttributes {
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
+
+    get(attribute: BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute):
+        | {
+            buffer: WebGLBuffer;
+            type: number;
+            bytesPerElement: number;
+            version: number;
+            size: number;
+        }
+        | undefined;
+
+    remove(attribute: BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute): void;
+
+    update(attribute: BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute, bufferType: number): void;
+}

package/types/src/renderers/webgl/WebGLBindingStates.d.ts

@@ -0,0 +1,26 @@
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import { WebGLAttributes } from "./WebGLAttributes.js";
+import { WebGLProgram } from "./WebGLProgram.js";
+
+export class WebGLBindingStates {
+    constructor(gl: WebGLRenderingContext, attributes: WebGLAttributes);
+
+    setup(
+        object: Object3D,
+        material: Material,
+        program: WebGLProgram,
+        geometry: BufferGeometry,
+        index: BufferAttribute,
+    ): void;
+    reset(): void;
+    resetDefaultState(): void;
+    dispose(): void;
+    releaseStatesOfGeometry(): void;
+    releaseStatesOfProgram(): void;
+    initAttributes(): void;
+    enableAttribute(attribute: number): void;
+    disableUnusedAttributes(): void;
+}

package/types/src/renderers/webgl/WebGLBufferRenderer.d.ts

@@ -0,0 +1,21 @@
+import { WebGLExtensions } from "./WebGLExtensions.js";
+import { WebGLInfo } from "./WebGLInfo.js";
+
+export class WebGLBufferRenderer {
+    constructor(
+        gl: WebGLRenderingContext,
+        extensions: WebGLExtensions,
+        info: WebGLInfo,
+    );
+
+    setMode: (value: any) => void;
+    render: (start: any, count: number) => void;
+    renderInstances: (start: any, count: number, primcount: number) => void;
+    renderMultiDraw: (starts: Int32Array, counts: Int32Array, drawCount: number) => void;
+    renderMultiDrawInstances: (
+        starts: Int32Array,
+        counts: Int32Array,
+        drawCount: number,
+        primcount: Int32Array,
+    ) => void;
+}

package/types/src/renderers/webgl/WebGLCapabilities.d.ts

@@ -0,0 +1,48 @@
+import { PixelFormat, TextureDataType } from "../../constants.js";
+
+export interface WebGLCapabilitiesParameters {
+    /**
+     * shader precision. Can be "highp", "mediump" or "lowp".
+     */
+    precision?: string | undefined;
+
+    /**
+     * default is false.
+     */
+    logarithmicDepthBuffer?: boolean | undefined;
+
+    /**
+     * default is false.
+     */
+    reverseDepthBuffer?: boolean | undefined;
+}
+
+export class WebGLCapabilities {
+    constructor(gl: WebGLRenderingContext, extensions: any, parameters: WebGLCapabilitiesParameters);
+
+    readonly isWebGL2: boolean;
+
+    getMaxAnisotropy: () => number;
+    getMaxPrecision: (precision: string) => string;
+
+    textureFormatReadable: (textureFormat: PixelFormat) => boolean;
+    textureTypeReadable: (textureType: TextureDataType) => boolean;
+
+    precision: string;
+    logarithmicDepthBuffer: boolean;
+    reverseDepthBuffer: boolean;
+
+    maxTextures: number;
+    maxVertexTextures: number;
+    maxTextureSize: number;
+    maxCubemapSize: number;
+
+    maxAttributes: number;
+    maxVertexUniforms: number;
+    maxVaryings: number;
+    maxFragmentUniforms: number;
+
+    vertexTextures: boolean;
+
+    maxSamples: number;
+}

package/types/src/renderers/webgl/WebGLClipping.d.ts

@@ -0,0 +1,26 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Material } from "../../materials/Material.js";
+import { Plane } from "../../math/Plane.js";
+import { WebGLProperties } from "./WebGLProperties.js";
+
+export class WebGLClipping {
+    constructor(properties: WebGLProperties);
+
+    uniform: { value: any; needsUpdate: boolean };
+
+    /**
+     * @default 0
+     */
+    numPlanes: number;
+
+    /**
+     * @default 0
+     */
+    numIntersection: number;
+
+    init(planes: any[], enableLocalClipping: boolean): boolean;
+    beginShadows(): void;
+    endShadows(): void;
+    setGlobalState(planes: Plane[], camera: Camera): void;
+    setState(material: Material, camera: Camera, useCache: boolean): void;
+}

package/types/src/renderers/webgl/WebGLCubeMaps.d.ts

@@ -0,0 +1,8 @@
+import { WebGLRenderer } from "../WebGLRenderer.js";
+
+export class WebGLCubeMaps {
+    constructor(renderer: WebGLRenderer);
+
+    get(texture: any): any;
+    dispose(): void;
+}

package/types/src/renderers/webgl/WebGLCubeUVMaps.d.ts

@@ -0,0 +1,9 @@
+import { Texture } from "../../textures/Texture.js";
+import { WebGLRenderer } from "../WebGLRenderer.js";
+
+export class WebGLCubeUVMaps {
+    constructor(renderer: WebGLRenderer);
+
+    get<T>(texture: T): T extends Texture ? Texture : T;
+    dispose(): void;
+}

package/types/src/renderers/webgl/WebGLExtensions.d.ts

@@ -0,0 +1,7 @@
+export class WebGLExtensions {
+    constructor(gl: WebGLRenderingContext);
+
+    has(name: string): boolean;
+    init(): void;
+    get(name: string): any;
+}

package/types/src/renderers/webgl/WebGLGeometries.d.ts

@@ -0,0 +1,13 @@
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { WebGLAttributes } from "./WebGLAttributes.js";
+import { WebGLInfo } from "./WebGLInfo.js";
+
+export class WebGLGeometries {
+    constructor(gl: WebGLRenderingContext, attributes: WebGLAttributes, info: WebGLInfo);
+
+    get(object: Object3D, geometry: BufferGeometry): BufferGeometry;
+    update(geometry: BufferGeometry): void;
+    getWireframeAttribute(geometry: BufferGeometry): BufferAttribute;
+}

package/types/src/renderers/webgl/WebGLIndexedBufferRenderer.d.ts

@@ -0,0 +1,15 @@
+export class WebGLIndexedBufferRenderer {
+    constructor(gl: WebGLRenderingContext, extensions: any, info: any);
+
+    setMode: (value: any) => void;
+    setIndex: (index: any) => void;
+    render: (start: any, count: number) => void;
+    renderInstances: (start: any, count: number, primcount: number) => void;
+    renderMultiDraw: (starts: Int32Array, counts: Int32Array, drawCount: number) => void;
+    renderMultiDrawInstances: (
+        starts: Int32Array,
+        counts: Int32Array,
+        drawCount: number,
+        primcount: Int32Array,
+    ) => void;
+}

package/types/src/renderers/webgl/WebGLInfo.d.ts

@@ -0,0 +1,39 @@
+import { WebGLProgram } from "./WebGLProgram.js";
+
+/**
+ * An object with a series of statistical information about the graphics board memory and the rendering process.
+ */
+export class WebGLInfo {
+    constructor(gl: WebGLRenderingContext);
+
+    /**
+     * @default true
+     */
+    autoReset: boolean;
+
+    /**
+     * @default { geometries: 0, textures: 0 }
+     */
+    memory: {
+        geometries: number;
+        textures: number;
+    };
+
+    /**
+     * @default null
+     */
+    programs: WebGLProgram[] | null;
+
+    /**
+     * @default { frame: 0, calls: 0, triangles: 0, points: 0, lines: 0 }
+     */
+    render: {
+        calls: number;
+        frame: number;
+        lines: number;
+        points: number;
+        triangles: number;
+    };
+    update(count: number, mode: number, instanceCount: number): void;
+    reset(): void;
+}

package/types/src/renderers/webgl/WebGLLights.d.ts

@@ -0,0 +1,49 @@
+import { WebGLExtensions } from "./WebGLExtensions.js";
+
+export interface WebGLLightsState {
+    version: number;
+
+    hash: {
+        directionalLength: number;
+        pointLength: number;
+        spotLength: number;
+        rectAreaLength: number;
+        hemiLength: number;
+
+        numDirectionalShadows: number;
+        numPointShadows: number;
+        numSpotShadows: number;
+        numSpotMaps: number;
+
+        numLightProbes: number;
+    };
+
+    ambient: number[];
+    probe: any[];
+    directional: any[];
+    directionalShadow: any[];
+    directionalShadowMap: any[];
+    directionalShadowMatrix: any[];
+    spot: any[];
+    spotShadow: any[];
+    spotShadowMap: any[];
+    spotShadowMatrix: any[];
+    rectArea: any[];
+    point: any[];
+    pointShadow: any[];
+    pointShadowMap: any[];
+    pointShadowMatrix: any[];
+    hemi: any[];
+    numSpotLightShadowsWithMaps: number;
+    numLightProbes: number;
+}
+
+export class WebGLLights {
+    constructor(extensions: WebGLExtensions);
+
+    state: WebGLLightsState;
+
+    get(light: any): any;
+    setup(lights: any): void;
+    setupView(lights: any, camera: any): void;
+}

package/types/src/renderers/webgl/WebGLObjects.d.ts

@@ -0,0 +1,6 @@
+export class WebGLObjects {
+    constructor(gl: WebGLRenderingContext, geometries: any, attributes: any, info: any);
+
+    update(object: any): any;
+    dispose(): void;
+}

package/types/src/renderers/webgl/WebGLProgram.d.ts

@@ -0,0 +1,30 @@
+import { WebGLRenderer } from "../WebGLRenderer.js";
+import { WebGLUniforms } from "./WebGLUniforms.js";
+
+export class WebGLProgram {
+    constructor(renderer: WebGLRenderer, cacheKey: string, parameters: object);
+
+    name: string;
+    id: number;
+    cacheKey: string; // unique identifier for this program, used for looking up compiled programs from cache.
+
+    /**
+     * @default 1
+     */
+    usedTimes: number;
+    program: any;
+    vertexShader: WebGLShader;
+    fragmentShader: WebGLShader;
+    /**
+     * @deprecated Use {@link WebGLProgram#getUniforms getUniforms()} instead.
+     */
+    uniforms: any;
+    /**
+     * @deprecated Use {@link WebGLProgram#getAttributes getAttributes()} instead.
+     */
+    attributes: any;
+
+    getUniforms(): WebGLUniforms;
+    getAttributes(): any;
+    destroy(): void;
+}