@needle-tools/three 0.169.12 → 0.169.13

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

@@ -0,0 +1,240 @@
+import {
+    ColorSpace,
+    Combine,
+    DepthPackingStrategies,
+    GLSLVersion,
+    Mapping,
+    ShadowMapType,
+    ToneMapping,
+} from "../../constants.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Light } from "../../lights/Light.js";
+import { Material } from "../../materials/Material.js";
+import { Scene } from "../../scenes/Scene.js";
+import { IUniform } from "../shaders/UniformsLib.js";
+import { WebGLRenderer } from "../WebGLRenderer.js";
+import { WebGLBindingStates } from "./WebGLBindingStates.js";
+import { WebGLCapabilities } from "./WebGLCapabilities.js";
+import { WebGLClipping } from "./WebGLClipping.js";
+import { WebGLCubeMaps } from "./WebGLCubeMaps.js";
+import { WebGLExtensions } from "./WebGLExtensions.js";
+import { WebGLLightsState } from "./WebGLLights.js";
+import { WebGLProgram } from "./WebGLProgram.js";
+
+export interface WebGLProgramParameters {
+    shaderID: string;
+    shaderType: string;
+    shaderName: string;
+
+    vertexShader: string;
+    fragmentShader: string;
+    defines: { [define: string]: string | number | boolean } | undefined;
+
+    customVertexShaderID: string | undefined;
+    customFragmentShaderID: string | undefined;
+
+    isRawShaderMaterial: boolean;
+    glslVersion: GLSLVersion | null | undefined;
+
+    precision: "lowp" | "mediump" | "highp";
+
+    batching: boolean;
+    batchingColor: boolean;
+    instancing: boolean;
+    instancingColor: boolean;
+    instancingMorph: boolean;
+
+    supportsVertexTextures: boolean;
+    outputColorSpace: ColorSpace;
+    alphaToCoverage: boolean;
+
+    map: boolean;
+    matcap: boolean;
+    envMap: boolean;
+    envMapMode: Mapping | false;
+    envMapCubeUVHeight: number | null;
+    aoMap: boolean;
+    lightMap: boolean;
+    bumpMap: boolean;
+    normalMap: boolean;
+    displacementMap: boolean;
+    emissiveMap: boolean;
+
+    normalMapObjectSpace: boolean;
+    normalMapTangentSpace: boolean;
+
+    metalnessMap: boolean;
+    roughnessMap: boolean;
+
+    anisotropy: boolean;
+    anisotropyMap: boolean;
+
+    clearcoat: boolean;
+    clearcoatMap: boolean;
+    clearcoatNormalMap: boolean;
+    clearcoatRoughnessMap: boolean;
+
+    dispersion: boolean;
+
+    iridescence: boolean;
+    iridescenceMap: boolean;
+    iridescenceThicknessMap: boolean;
+
+    sheen: boolean;
+    sheenColorMap: boolean;
+    sheenRoughnessMap: boolean;
+
+    specularMap: boolean;
+    specularColorMap: boolean;
+    specularIntensityMap: boolean;
+
+    transmission: boolean;
+    transmissionMap: boolean;
+    thicknessMap: boolean;
+
+    gradientMap: boolean;
+
+    opaque: boolean;
+
+    alphaMap: boolean;
+    alphaTest: boolean;
+    alphaHash: boolean;
+
+    combine: Combine | undefined;
+
+    //
+
+    mapUv: string | false;
+    aoMapUv: string | false;
+    lightMapUv: string | false;
+    bumpMapUv: string | false;
+    normalMapUv: string | false;
+    displacementMapUv: string | false;
+    emissiveMapUv: string | false;
+
+    metalnessMapUv: string | false;
+    roughnessMapUv: string | false;
+
+    anisotropyMapUv: string | false;
+
+    clearcoatMapUv: string | false;
+    clearcoatNormalMapUv: string | false;
+    clearcoatRoughnessMapUv: string | false;
+
+    iridescenceMapUv: string | false;
+    iridescenceThicknessMapUv: string | false;
+
+    sheenColorMapUv: string | false;
+    sheenRoughnessMapUv: string | false;
+
+    specularMapUv: string | false;
+    specularColorMapUv: string | false;
+    specularIntensityMapUv: string | false;
+
+    transmissionMapUv: string | false;
+    thicknessMapUv: string | false;
+
+    alphaMapUv: string | false;
+
+    //
+
+    vertexTangents: boolean;
+    vertexColors: boolean;
+    vertexAlphas: boolean;
+    vertexUv1s: boolean;
+    vertexUv2s: boolean;
+    vertexUv3s: boolean;
+
+    pointsUvs: boolean;
+
+    fog: boolean;
+    useFog: boolean;
+    fogExp2: boolean;
+
+    flatShading: boolean;
+
+    sizeAttenuation: boolean;
+    logarithmicDepthBuffer: boolean;
+    reverseDepthBuffer: boolean;
+
+    skinning: boolean;
+
+    morphTargets: boolean;
+    morphNormals: boolean;
+    morphColors: boolean;
+    morphTargetsCount: number;
+    morphTextureStride: number;
+
+    numDirLights: number;
+    numPointLights: number;
+    numSpotLights: number;
+    numSpotLightMaps: number;
+    numRectAreaLights: number;
+    numHemiLights: number;
+
+    numDirLightShadows: number;
+    numPointLightShadows: number;
+    numSpotLightShadows: number;
+    numSpotLightShadowsWithMaps: number;
+
+    numLightProbes: number;
+
+    numClippingPlanes: number;
+    numClipIntersection: number;
+
+    dithering: boolean;
+
+    shadowMapEnabled: boolean;
+    shadowMapType: ShadowMapType;
+
+    toneMapping: ToneMapping;
+
+    decodeVideoTexture: boolean;
+
+    premultipliedAlpha: boolean;
+
+    doubleSided: boolean;
+    flipSided: boolean;
+
+    useDepthPacking: boolean;
+    depthPacking: DepthPackingStrategies | 0;
+
+    index0AttributeName: string | undefined;
+
+    extensionClipCullDistance: boolean;
+    extensionMultiDraw: boolean;
+
+    rendererExtensionParallelShaderCompile: boolean;
+
+    customProgramCacheKey: string;
+}
+
+export interface WebGLProgramParametersWithUniforms extends WebGLProgramParameters {
+    uniforms: { [uniform: string]: IUniform };
+}
+
+export class WebGLPrograms {
+    constructor(
+        renderer: WebGLRenderer,
+        cubemaps: WebGLCubeMaps,
+        extensions: WebGLExtensions,
+        capabilities: WebGLCapabilities,
+        bindingStates: WebGLBindingStates,
+        clipping: WebGLClipping,
+    );
+
+    programs: WebGLProgram[];
+
+    getParameters(
+        material: Material,
+        lights: WebGLLightsState,
+        shadows: Light[],
+        scene: Scene,
+        object: Object3D,
+    ): WebGLProgramParameters;
+
+    getProgramCacheKey(parameters: WebGLProgramParameters): string;
+    getUniforms(material: Material): { [uniform: string]: IUniform };
+    acquireProgram(parameters: WebGLProgramParametersWithUniforms, cacheKey: string): WebGLProgram;
+    releaseProgram(program: WebGLProgram): void;
+}

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

@@ -0,0 +1,9 @@
+export class WebGLProperties {
+    constructor();
+
+    has: (object: unknown) => boolean;
+    get: (object: unknown) => unknown;
+    remove: (object: unknown) => void;
+    update: (object: unknown, key: unknown, value: unknown) => unknown;
+    dispose: () => void;
+}

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

@@ -0,0 +1,66 @@
+import { Camera } from "../../cameras/Camera.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import { Group } from "../../objects/Group.js";
+import { Scene } from "../../scenes/Scene.js";
+import { WebGLProgram } from "./WebGLProgram.js";
+import { WebGLProperties } from "./WebGLProperties.js";
+
+export interface RenderItem {
+    id: number;
+    object: Object3D;
+    geometry: BufferGeometry | null;
+    material: Material;
+    program: WebGLProgram;
+    groupOrder: number;
+    renderOrder: number;
+    z: number;
+    group: Group | null;
+}
+
+export class WebGLRenderList {
+    constructor(properties: WebGLProperties);
+
+    /**
+     * @default []
+     */
+    opaque: RenderItem[];
+
+    /**
+     * @default []
+     */
+    transparent: RenderItem[];
+
+    /**
+     * @default []
+     */
+    transmissive: RenderItem[];
+
+    init(): void;
+    push(
+        object: Object3D,
+        geometry: BufferGeometry | null,
+        material: Material,
+        groupOrder: number,
+        z: number,
+        group: Group | null,
+    ): void;
+    unshift(
+        object: Object3D,
+        geometry: BufferGeometry | null,
+        material: Material,
+        groupOrder: number,
+        z: number,
+        group: Group | null,
+    ): void;
+    sort(opaqueSort: (a: any, b: any) => number, transparentSort: (a: any, b: any) => number): void;
+    finish(): void;
+}
+
+export class WebGLRenderLists {
+    constructor(properties: WebGLProperties);
+
+    dispose(): void;
+    get(scene: Scene, renderCallDepth: number): WebGLRenderList;
+}

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

@@ -0,0 +1 @@
+export function WebGLShader(gl: WebGLRenderingContext, type: string, string: string): WebGLShader;

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

@@ -0,0 +1,38 @@
+import { Camera } from "../../cameras/Camera.js";
+import { ShadowMapType } from "../../constants.js";
+import { Light } from "../../lights/Light.js";
+import { Scene } from "../../scenes/Scene.js";
+import { WebGLRenderer } from "../WebGLRenderer.js";
+import { WebGLCapabilities } from "./WebGLCapabilities.js";
+import { WebGLObjects } from "./WebGLObjects.js";
+
+export class WebGLShadowMap {
+    constructor(_renderer: WebGLRenderer, _objects: WebGLObjects, _capabilities: WebGLCapabilities);
+
+    /**
+     * @default false
+     */
+    enabled: boolean;
+
+    /**
+     * @default true
+     */
+    autoUpdate: boolean;
+
+    /**
+     * @default false
+     */
+    needsUpdate: boolean;
+
+    /**
+     * @default THREE.PCFShadowMap
+     */
+    type: ShadowMapType;
+
+    render(shadowsArray: Light[], scene: Scene, camera: Camera): void;
+
+    /**
+     * @deprecated Use {@link Material#shadowSide} instead.
+     */
+    cullFace: any;
+}

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

@@ -0,0 +1,116 @@
+import {
+    Blending,
+    BlendingDstFactor,
+    BlendingEquation,
+    BlendingSrcFactor,
+    CullFace,
+    DepthModes,
+} from "../../constants.js";
+import { Material } from "../../materials/Material.js";
+import { Vector4 } from "../../math/Vector4.js";
+import { WebGLRenderTarget } from "../WebGLRenderTarget.js";
+
+export class WebGLColorBuffer {
+    constructor();
+
+    setMask(colorMask: boolean): void;
+    setLocked(lock: boolean): void;
+    setClear(r: number, g: number, b: number, a: number, premultipliedAlpha: boolean): void;
+    reset(): void;
+}
+
+export class WebGLDepthBuffer {
+    constructor();
+
+    setTest(depthTest: boolean): void;
+    setMask(depthMask: boolean): void;
+    setFunc(depthFunc: DepthModes): void;
+    setLocked(lock: boolean): void;
+    setClear(depth: number): void;
+    reset(): void;
+}
+
+export class WebGLStencilBuffer {
+    constructor();
+
+    setTest(stencilTest: boolean): void;
+    setMask(stencilMask: number): void;
+    setFunc(stencilFunc: number, stencilRef: number, stencilMask: number): void;
+    setOp(stencilFail: number, stencilZFail: number, stencilZPass: number): void;
+    setLocked(lock: boolean): void;
+    setClear(stencil: number): void;
+    reset(): void;
+}
+
+export class WebGLState {
+    constructor(gl: WebGLRenderingContext);
+
+    buffers: {
+        color: WebGLColorBuffer;
+        depth: WebGLDepthBuffer;
+        stencil: WebGLStencilBuffer;
+    };
+
+    enable(id: number): void;
+    disable(id: number): void;
+    bindFramebuffer(target: number, framebuffer: WebGLFramebuffer | null): void;
+    drawBuffers(renderTarget: WebGLRenderTarget | null, framebuffer: WebGLFramebuffer | null): void;
+    useProgram(program: any): boolean;
+    setBlending(
+        blending: Blending,
+        blendEquation?: BlendingEquation,
+        blendSrc?: BlendingSrcFactor,
+        blendDst?: BlendingDstFactor,
+        blendEquationAlpha?: BlendingEquation,
+        blendSrcAlpha?: BlendingSrcFactor,
+        blendDstAlpha?: BlendingDstFactor,
+        premultiplyAlpha?: boolean,
+    ): void;
+    setMaterial(material: Material, frontFaceCW: boolean): void;
+    setFlipSided(flipSided: boolean): void;
+    setCullFace(cullFace: CullFace): void;
+    setLineWidth(width: number): void;
+    setPolygonOffset(polygonoffset: boolean, factor?: number, units?: number): void;
+    setScissorTest(scissorTest: boolean): void;
+    activeTexture(webglSlot: number): void;
+    bindTexture(webglType: number, webglTexture: any): void;
+    unbindTexture(): void;
+    // Same interface as https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/compressedTexImage2D
+    compressedTexImage2D(
+        target: number,
+        level: number,
+        internalformat: number,
+        width: number,
+        height: number,
+        border: number,
+        data: ArrayBufferView,
+    ): void;
+    // Same interface as https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/texImage2D
+    texImage2D(
+        target: number,
+        level: number,
+        internalformat: number,
+        width: number,
+        height: number,
+        border: number,
+        format: number,
+        type: number,
+        pixels: ArrayBufferView | null,
+    ): void;
+    texImage2D(target: number, level: number, internalformat: number, format: number, type: number, source: any): void;
+    texImage3D(
+        target: number,
+        level: number,
+        internalformat: number,
+        width: number,
+        height: number,
+        depth: number,
+        border: number,
+        format: number,
+        type: number,
+        pixels: any,
+    ): void;
+    scissor(scissor: Vector4): void;
+    viewport(viewport: Vector4): void;
+    reset(): void;
+}

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

@@ -0,0 +1,30 @@
+import { WebGLCapabilities } from "./WebGLCapabilities.js";
+import { WebGLExtensions } from "./WebGLExtensions.js";
+import { WebGLInfo } from "./WebGLInfo.js";
+import { WebGLProperties } from "./WebGLProperties.js";
+import { WebGLState } from "./WebGLState.js";
+import { WebGLUtils } from "./WebGLUtils.js";
+
+export class WebGLTextures {
+    constructor(
+        gl: WebGLRenderingContext,
+        extensions: WebGLExtensions,
+        state: WebGLState,
+        properties: WebGLProperties,
+        capabilities: WebGLCapabilities,
+        utils: WebGLUtils,
+        info: WebGLInfo,
+    );
+
+    allocateTextureUnit(): void;
+    resetTextureUnits(): void;
+    setTexture2D(texture: any, slot: number): void;
+    setTexture2DArray(texture: any, slot: number): void;
+    setTexture3D(texture: any, slot: number): void;
+    setTextureCube(texture: any, slot: number): void;
+    setupRenderTarget(renderTarget: any): void;
+    updateRenderTargetMipmap(renderTarget: any): void;
+    updateMultisampleRenderTarget(renderTarget: any): void;
+    safeSetTexture2D(texture: any, slot: number): void;
+    safeSetTextureCube(texture: any, slot: number): void;
+}

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

@@ -0,0 +1,12 @@
+import { WebGLProgram } from "./WebGLProgram.js";
+import { WebGLTextures } from "./WebGLTextures.js";
+
+export class WebGLUniforms {
+    constructor(gl: WebGLRenderingContext, program: WebGLProgram);
+
+    setValue(gl: WebGLRenderingContext, name: string, value: any, textures: WebGLTextures): void;
+    setOptional(gl: WebGLRenderingContext, object: any, name: string): void;
+
+    static upload(gl: WebGLRenderingContext, seq: any, values: any[], textures: WebGLTextures): void;
+    static seqWithValue(seq: any, values: any[]): any[];
+}

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

@@ -0,0 +1,17 @@
+import { UniformsGroup } from "../../core/UniformsGroup.js";
+
+import { WebGLCapabilities } from "./WebGLCapabilities.js";
+import { WebGLInfo } from "./WebGLInfo.js";
+import { WebGLProgram } from "./WebGLProgram.js";
+import { WebGLState } from "./WebGLState.js";
+
+export function WebGLUniformsGroups(
+    gl: WebGLRenderingContext,
+    info: WebGLInfo,
+    capabilities: WebGLCapabilities,
+    state: WebGLState,
+): {
+    dispose: () => void;
+    update: (uniformsGroup: UniformsGroup, program: WebGLProgram) => void;
+    bind: (uniformsGroup: UniformsGroup, program: WebGLProgram) => void;
+};

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

@@ -0,0 +1,11 @@
+import { ColorSpace, CompressedPixelFormat, PixelFormat, TextureDataType } from "../../constants.js";
+import { WebGLExtensions } from "./WebGLExtensions.js";
+
+export class WebGLUtils {
+    constructor(
+        gl: WebGLRenderingContext | WebGL2RenderingContext,
+        extensions: WebGLExtensions,
+    );
+
+    convert(p: PixelFormat | CompressedPixelFormat | TextureDataType, colorSpace?: ColorSpace): number | null;
+}

package/types/src/renderers/webgl-fallback/WebGLBackend.d.ts

@@ -0,0 +1,14 @@
+import { CoordinateSystem } from "../../constants.js";
+import Backend, { BackendParameters } from "../common/Backend.js";
+
+export interface WebGLBackendParameters extends BackendParameters {
+    trackTimestamp?: boolean | undefined;
+}
+
+export default class WebGLBackend extends Backend {
+    constructor(parameters?: BackendParameters);
+
+    get coordinateSystem(): CoordinateSystem;
+
+    getMaxAnisotropy(): number;
+}

package/types/src/renderers/webgpu/WebGPUBackend.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="@webgpu/types" />
+
+import { CoordinateSystem } from "../../constants.js";
+import Backend, { BackendParameters } from "../common/Backend.js";
+
+export interface WebGPUBackendParameters extends BackendParameters {
+    alpha?: boolean | undefined;
+    requiredLimits?: Record<string, GPUSize64> | undefined;
+    trackTimestamp?: boolean | undefined;
+    device?: GPUDevice | undefined;
+    powerPreference?: GPUPowerPreference | undefined;
+    context?: GPUCanvasContext | undefined;
+}
+
+export default class WebGPUBackend extends Backend {
+    readonly isWebGPUBackend: true;
+
+    constructor(parameters?: WebGPUBackendParameters);
+
+    get coordinateSystem(): CoordinateSystem;
+
+    // utils public
+
+    getMaxAnisotropy(): number;
+}

package/types/src/renderers/webgpu/WebGPURenderer.Nodes.d.ts

@@ -0,0 +1,12 @@
+import Renderer, { RendererParameters } from "../common/Renderer.js";
+import { WebGPUBackendParameters } from "./WebGPUBackend.js";
+
+export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
+    forceWebGL?: boolean | undefined;
+}
+
+export default class WebGPURenderer extends Renderer {
+    readonly isWebGPURenderer: true;
+
+    constructor(parameters?: WebGPURendererParameters);
+}

package/types/src/renderers/webgpu/WebGPURenderer.d.ts

@@ -0,0 +1,14 @@
+import Renderer, { RendererParameters } from "../common/Renderer.js";
+import { WebGPUBackendParameters } from "./WebGPUBackend.js";
+
+export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
+    forceWebGL?: boolean | undefined;
+}
+
+declare class WebGPURenderer extends Renderer {
+    readonly isWebGPURenderer: true;
+
+    constructor(parameters?: WebGPURendererParameters);
+}
+
+export default WebGPURenderer;

package/types/src/renderers/webgpu/nodes/BasicNodeLibrary.d.ts

@@ -0,0 +1,5 @@
+import NodeLibrary from "../../common/nodes/NodeLibrary.js";
+declare class BasicNodeLibrary extends NodeLibrary {
+    constructor();
+}
+export default BasicNodeLibrary;

package/types/src/renderers/webgpu/nodes/StandardNodeLibrary.d.ts

@@ -0,0 +1,5 @@
+import NodeLibrary from "../../common/nodes/NodeLibrary.js";
+declare class StandardNodeLibrary extends NodeLibrary {
+    constructor();
+}
+export default StandardNodeLibrary;