@needle-tools/three 0.169.12 → 0.169.13

package/types/examples/jsm/shaders/SSRShader.d.ts

@@ -0,0 +1,62 @@
+import { IUniform, Matrix4, Texture, Vector2 } from "three";
+/**
+ * References:
+ * https://lettier.github.io/3d-game-shaders-for-beginners/screen-space-reflection.html
+ */
+
+export const SSRShader: SSRShader;
+export interface SSRShader {
+    name: string;
+    defines: {
+        MAX_STEP: number;
+        isPerspectiveCamera: boolean;
+        isDistanceAttenuation: boolean;
+        isFresnel: boolean;
+        isInfiniteThick: boolean;
+        isSelective: boolean;
+    };
+    uniforms: {
+        tDiffuse: IUniform<Texture | null>;
+        tNormal: IUniform<Texture | null>;
+        tMetalness: IUniform<Texture | null>;
+        tDepth: IUniform<Texture | null>;
+        cameraNear: IUniform<number>;
+        cameraFar: IUniform<number>;
+        resolution: IUniform<Vector2>;
+        cameraProjectionMatrix: IUniform<Matrix4>;
+        cameraInverseProjectionMatrix: IUniform<Matrix4>;
+        opacity: IUniform<number>;
+        maxDistance: IUniform<number>;
+        cameraRange: IUniform<number>;
+        thickness: IUniform<number>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+}
+
+export const SSRDepthShader: SSRDepthShader;
+export interface SSRDepthShader {
+    name: string;
+    defines: {
+        PERSPECTIVE_CAMERA: number;
+    };
+    uniforms: {
+        tDepth: IUniform<Texture | null>;
+        cameraNear: IUniform<number>;
+        cameraFar: IUniform<number>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+}
+
+export const SSRBlurShader: SSRBlurShader;
+export interface SSRBlurShader {
+    name: string;
+    uniforms: {
+        tDiffuse: IUniform<Texture | null>;
+        resolution: IUniform<Vector2>;
+        opacity: IUniform<number>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+}

package/types/examples/jsm/shaders/SepiaShader.d.ts

@@ -0,0 +1,10 @@
+import { IUniform } from "three";
+
+export const SepiaShader: {
+    uniforms: {
+        tDiffuse: IUniform;
+        amount: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/SobelOperatorShader.d.ts

@@ -0,0 +1,11 @@
+import { IUniform } from "three";
+
+export const SobelOperatorShader: {
+    name: string;
+    uniforms: {
+        tDiffuse: IUniform;
+        resolution: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/SubsurfaceScatteringShader.d.ts

@@ -0,0 +1,38 @@
+import { IUniform } from "three";
+
+export const SubsurfaceScatteringShader: {
+    name: string;
+    uniforms: {
+        alphaMap: IUniform;
+        ambientLightColor: IUniform;
+        color: IUniform;
+        diffuse: IUniform;
+        directionalLights: IUniform;
+        directionalShadowMap: IUniform;
+        directionalShadowMatrix: IUniform;
+        emissive: IUniform;
+        hemisphereLights: IUniform;
+        lightProbe: IUniform;
+        map: IUniform;
+        opacity: IUniform;
+        pointLights: IUniform;
+        pointShadowMap: IUniform;
+        pointShadowMatrix: IUniform;
+        rectAreaLights: IUniform;
+        shininess: IUniform;
+        specular: IUniform;
+        spotLights: IUniform;
+        spotShadowMap: IUniform;
+        spotShadowMatrix: IUniform;
+        thicknessAmbient: IUniform;
+        thicknessAttenuation: IUniform;
+        thicknessColor: IUniform;
+        thicknessDistortion: IUniform;
+        thicknessMap: IUniform;
+        thicknessPower: IUniform;
+        thicknessScale: IUniform;
+        uvTransform: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/TechnicolorShader.d.ts

@@ -0,0 +1,10 @@
+import { IUniform } from "three";
+
+export const TechnicolorShader: {
+    name: string;
+    uniforms: {
+        tDiffuse: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/ToonShader.d.ts

@@ -0,0 +1,54 @@
+import { IUniform } from "three";
+
+export const ToonShader1: {
+    uniforms: {
+        uDirLightPos: IUniform;
+        uDirLightColor: IUniform;
+        uAmbientLightColor: IUniform;
+        uBaseColor: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export const ToonShader2: {
+    uniforms: {
+        uDirLightPos: IUniform;
+        uDirLightColor: IUniform;
+        uAmbientLightColor: IUniform;
+        uBaseColor: IUniform;
+        uLineColor1: IUniform;
+        uLineColor2: IUniform;
+        uLineColor3: IUniform;
+        uLineColor4: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export const ToonShaderHatching: {
+    uniforms: {
+        uDirLightPos: IUniform;
+        uDirLightColor: IUniform;
+        uAmbientLightColor: IUniform;
+        uBaseColor: IUniform;
+        uLineColor1: IUniform;
+        uLineColor2: IUniform;
+        uLineColor3: IUniform;
+        uLineColor4: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export const ToonShaderDotted: {
+    uniforms: {
+        uDirLightPos: IUniform;
+        uDirLightColor: IUniform;
+        uAmbientLightColor: IUniform;
+        uBaseColor: IUniform;
+        uLineColor1: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/TriangleBlurShader.d.ts

@@ -0,0 +1,11 @@
+import { IUniform } from "three";
+
+export const TriangleBlurShader: {
+    name: string;
+    uniforms: {
+        texture: IUniform;
+        delta: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/UnpackDepthRGBAShader.d.ts

@@ -0,0 +1,11 @@
+import { IUniform } from "three";
+
+export const UnpackDepthRGBAShader: {
+    name: string;
+    uniforms: {
+        tDiffuse: IUniform;
+        opacity: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/VelocityShader.d.ts

@@ -0,0 +1,16 @@
+import { IUniform, UniformsLib } from "three";
+
+export const VelocityShader: {
+    name: string;
+    uniforms:
+        & (typeof UniformsLib)["common"]
+        & (typeof UniformsLib)["displacementmap"]
+        & {
+            modelMatrixPrev: IUniform;
+            currentProjectionViewMatrix: IUniform;
+            previousProjectionViewMatrix: IUniform;
+        };
+
+    fragmentShader: string;
+    vertexShader: string;
+};

package/types/examples/jsm/shaders/VerticalBlurShader.d.ts

@@ -0,0 +1,10 @@
+import { IUniform } from "three";
+
+export const VerticalBlurShader: {
+    uniforms: {
+        tDiffuse: IUniform;
+        v: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/VerticalTiltShiftShader.d.ts

@@ -0,0 +1,12 @@
+import { IUniform } from "three";
+
+export const VerticalTiltShiftShader: {
+    name: string;
+    uniforms: {
+        tDiffuse: IUniform;
+        v: IUniform;
+        r: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/VignetteShader.d.ts

@@ -0,0 +1,11 @@
+import { IUniform } from "three";
+
+export const VignetteShader: {
+    uniforms: {
+        tDiffuse: IUniform;
+        offset: IUniform;
+        darkness: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/VolumeShader.d.ts

@@ -0,0 +1,14 @@
+import { IUniform } from "three";
+
+export const VolumeRenderShader1: {
+    uniforms: {
+        u_size: IUniform;
+        u_renderstyle: IUniform;
+        u_renderthreshold: IUniform;
+        u_clim: IUniform;
+        u_data: IUniform;
+        u_cmdata: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/shaders/WaterRefractionShader.d.ts

@@ -0,0 +1,14 @@
+import { IUniform } from "three";
+
+export const WaterRefractionShader: {
+    name: string;
+    uniforms: {
+        color: IUniform;
+        time: IUniform;
+        tDiffuse: IUniform;
+        tDudv: IUniform;
+        textureMatrix: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/types/examples/jsm/textures/FlakesTexture.d.ts

@@ -0,0 +1,3 @@
+export class FlakesTexture extends HTMLCanvasElement {
+    constructor(width?: number, height?: number);
+}

package/types/examples/jsm/transpiler/AST.d.ts

@@ -0,0 +1,7 @@
+export class Program {
+    body: unknown[];
+
+    isProgram: true;
+
+    constructor();
+}

package/types/examples/jsm/transpiler/GLSLDecoder.d.ts

@@ -0,0 +1,7 @@
+import { Program } from "./AST.js";
+
+export default class GLSLDecoder {
+    constructor();
+
+    parse(source: string): Program;
+}

package/types/examples/jsm/transpiler/ShaderToyDecoder.d.ts

@@ -0,0 +1,3 @@
+import GLSLDecoder from "./GLSLDecoder.js";
+
+export default class ShaderToyDecoder extends GLSLDecoder {}

package/types/examples/jsm/transpiler/TSLEncoder.d.ts

@@ -0,0 +1,7 @@
+import { Program } from "./AST.js";
+
+export default class TSLEncoder {
+    constructor();
+
+    emit(ast: Program): string;
+}

package/types/examples/jsm/transpiler/Transpiler.d.ts

@@ -0,0 +1,5 @@
+export default class Transpiler<U, V> {
+    constructor(decoder: { parse(source: string): U }, encoder: { emit(decoded: U): V });
+
+    parse(source: string): V;
+}

package/types/examples/jsm/utils/BufferGeometryUtils.d.ts

@@ -0,0 +1,37 @@
+// https://threejs.org/docs/?q=buffergeome#examples/en/utils/BufferGeometryUtils
+
+import {
+    BufferAttribute,
+    BufferGeometry,
+    InterleavedBufferAttribute,
+    Line,
+    Mesh,
+    Points,
+    TrianglesDrawModes,
+} from "three";
+
+export function deepCloneAttribute(attribute: BufferAttribute): BufferAttribute;
+export function mergeGeometries(geometries: BufferGeometry[], useGroups?: boolean): BufferGeometry;
+export function mergeAttributes(attributes: BufferAttribute[]): BufferAttribute;
+export function interleaveAttributes(attributes: BufferAttribute[]): InterleavedBufferAttribute;
+export function estimateBytesUsed(geometry: BufferGeometry): number;
+export function mergeVertices(geometry: BufferGeometry, tolerance?: number): BufferGeometry;
+export function toTrianglesDrawMode(geometry: BufferGeometry, drawMode: TrianglesDrawModes): BufferGeometry;
+export function computeMorphedAttributes(object: Mesh | Line | Points): object;
+export function computeMikkTSpaceTangents(
+    geometry: BufferGeometry,
+    MikkTSpace: unknown,
+    negateSign?: boolean,
+): BufferGeometry;
+export function mergeGroups(geometry: BufferGeometry): BufferGeometry;
+export function deinterleaveAttribute(geometry: BufferGeometry): void;
+export function deinterleaveGeometry(geometry: BufferGeometry): void;
+
+/**
+ * Modifies the supplied geometry if it is non-indexed, otherwise creates a new, non-indexed geometry. Returns the
+ * geometry with smooth normals everywhere except faces that meet at an angle greater than the crease angle.
+ *
+ * @param geometry The input geometry.
+ * @param creaseAngle The crease angle in radians.
+ */
+export function toCreasedNormals(geometry: BufferGeometry, creaseAngle?: number): BufferGeometry;

package/types/examples/jsm/utils/CameraUtils.d.ts

@@ -0,0 +1,9 @@
+import { PerspectiveCamera, Vector3 } from "three";
+
+export function frameCorners(
+    camera: PerspectiveCamera,
+    bottomLeftCorner: Vector3,
+    bottomRightCorner: Vector3,
+    topLeftCorner: Vector3,
+    estimateViewFrustum?: boolean,
+): void;

package/types/examples/jsm/utils/GeometryCompressionUtils.d.ts

@@ -0,0 +1,21 @@
+import { BufferGeometry, Mesh } from "three";
+
+/**
+ * Make the input geometry's normal attribute encoded and compressed by 3 different methods.
+ */
+declare function compressNormals(
+    geometry: BufferGeometry,
+    encodeMethod: "DEFAULT" | "OCT1Byte" | "OCT2Byte" | "ANGLES",
+): void;
+
+/**
+ * Make the input geometry's position attribute encoded and compressed.
+ */
+declare function compressPositions(geometry: BufferGeometry): void;
+
+/**
+ * Make the input geometry's uv attribute encoded and compressed.
+ */
+declare function compressUvs(geometry: BufferGeometry): void;
+
+export { compressNormals, compressPositions, compressUvs };

package/types/examples/jsm/utils/GeometryUtils.d.ts

@@ -0,0 +1,25 @@
+import { Vector3 } from "three";
+
+export function hilbert2D(
+    center?: Vector3,
+    size?: number,
+    iterations?: number,
+    v0?: number,
+    v1?: number,
+    v2?: number,
+    v3?: number,
+): Vector3[];
+export function hilbert3D(
+    center?: Vector3,
+    size?: number,
+    iterations?: number,
+    v0?: number,
+    v1?: number,
+    v2?: number,
+    v3?: number,
+    v4?: number,
+    v5?: number,
+    v6?: number,
+    v7?: number,
+): Vector3[];
+export function gosper(size?: number): number[];

package/types/examples/jsm/utils/LDrawUtils.d.ts

@@ -0,0 +1,5 @@
+import { Group, Object3D } from "three";
+
+export namespace LDrawUtils {
+    function mergeObject(object: Object3D): Group;
+}

package/types/examples/jsm/utils/SceneUtils.d.ts

@@ -0,0 +1,57 @@
+import { BufferGeometry, Group, InstancedMesh, Material, Mesh, Object3D, Scene, Vector3 } from "three";
+
+export function createMeshesFromInstancedMesh(instancedMesh: InstancedMesh): Group;
+export function createMultiMaterialObject(geometry: BufferGeometry, materials: Material[]): Group;
+/**
+ * @deprecated Use scene.attach( child ) instead.
+ */
+export function detach(child: Object3D, parent: Object3D, scene: Scene): void;
+/**
+ * @deprecated Use parent.attach( child ) instead.
+ */
+export function attach(child: Object3D, scene: Scene, parent: Object3D): void;
+
+export function createMeshesFromMultiMaterialMesh(mesh: Mesh): Group;
+
+export function sortInstancedMesh(mesh: InstancedMesh, compareFn: (a: number, b: number) => number): void;
+
+/**
+ * Akin to Array.prototype.reduce(), but operating on the vertices of all the visible descendant objects, in world space.
+ * Additionally, it can operate as a transform-reduce, returning a different type T than the Vector3 input.
+ * This can be useful for e.g. fitting a viewing frustum to the scene.
+ *
+ * @param object - The object to traverse (uses traverseVisible internally).
+ * @param func - The binary function applied for the reduction.
+ * Must have the signature: (value: T, vertex: Vector3): T.
+ * @param initialValue - The value to initialize the reduction with.
+ * This is required as it also sets the reduction type, which is not required to be Vector3.
+ */
+export function reduceVertices<TValue>(
+    object: Object3D,
+    func: (value: TValue, vertex: Vector3) => TValue,
+    initialValue: TValue,
+): TValue;
+
+/**
+ * A generator based version of {@link Object3D.traverse}.
+ *
+ * @param object The 3D object to traverse.
+ * @yields Objects that passed the filter condition.
+ */
+export function traverseGenerator(object: Object3D): Generator<Object3D, void, unknown>;
+
+/**
+ * A generator based version of {@link Object3D.traverseVisible}.
+ *
+ * @param object The 3D object to traverse.
+ * @yields Objects that passed the filter condition.
+ */
+export function traverseVisibleGenerator(object: Object3D): Generator<Object3D, void, unknown>;
+
+/**
+ * A generator based version of {@link Object3D.traverseAncestors}.
+ *
+ * @param object The 3D object to traverse.
+ * @yields Objects that passed the filter condition.
+ */
+export function traverseAncestorsGenerator(object: Object3D): Generator<Object3D, void, unknown>;

package/types/examples/jsm/utils/ShadowMapViewer.d.ts

@@ -0,0 +1,26 @@
+import { Light, Renderer } from "three";
+
+export interface Size {
+    width: number;
+    height: number;
+    set: (width: number, height: number) => void;
+}
+
+export interface Position {
+    x: number;
+    y: number;
+    set: (x: number, y: number) => void;
+}
+
+declare class ShadowMapViewer {
+    enabled: boolean;
+    size: Size;
+    position: Position;
+    render: (renderer: Renderer) => void;
+    updateForWindowResize: () => void;
+    update: () => void;
+
+    constructor(light: Light);
+}
+
+export { ShadowMapViewer };

package/types/examples/jsm/utils/ShadowMapViewerGPU.d.ts

@@ -0,0 +1,26 @@
+import { Light, WebGPURenderer } from "three/webgpu";
+
+export interface Size {
+    width: number;
+    height: number;
+    set: (width: number, height: number) => void;
+}
+
+export interface Position {
+    x: number;
+    y: number;
+    set: (x: number, y: number) => void;
+}
+
+declare class ShadowMapViewer {
+    enabled: boolean;
+    size: Size;
+    position: Position;
+    render: (renderer: WebGPURenderer) => void;
+    updateForWindowResize: () => void;
+    update: () => void;
+
+    constructor(light: Light);
+}
+
+export { ShadowMapViewer };

package/types/examples/jsm/utils/SkeletonUtils.d.ts

@@ -0,0 +1,32 @@
+import { AnimationClip, Bone, Object3D, Skeleton, Vector3 } from "three";
+
+export interface RetargetOptions {
+    preserveBoneMatrix?: boolean | undefined;
+    preserveHipPosition?: boolean | undefined;
+    useTargetMatrix?: boolean | undefined;
+    hip?: string | undefined;
+    hipInfluence?: Vector3 | undefined;
+    scale?: number | undefined;
+    names?: { [boneName: string]: string } | undefined;
+    getBoneName?: ((bone: Bone) => string) | undefined;
+    hipPosition?: Vector3 | undefined;
+}
+
+declare function retarget(target: Object3D | Skeleton, source: Object3D | Skeleton, options?: RetargetOptions): void;
+
+export interface RetargetClipOptions extends RetargetOptions {
+    useFirstFramePosition?: boolean | undefined;
+    fps?: number | undefined;
+    trim?: [number, number] | undefined;
+}
+
+declare function retargetClip(
+    target: Skeleton | Object3D,
+    source: Skeleton | Object3D,
+    clip: AnimationClip,
+    options?: RetargetClipOptions,
+): AnimationClip;
+
+declare function clone(source: Object3D): Object3D;
+
+export { clone, retarget, retargetClip };

package/types/examples/jsm/utils/SortUtils.d.ts

@@ -0,0 +1,7 @@
+export interface RadixSortOptions<T> {
+    aux?: T[] | undefined;
+    get?: ((el: T) => number) | undefined;
+    reversed?: boolean | undefined;
+}
+
+export const radixSort: <T = number>(arr: T[], opt?: RadixSortOptions<T>) => void;

package/types/examples/jsm/utils/TextureUtils.d.ts

@@ -0,0 +1,3 @@
+import { Texture, WebGLRenderer } from "three";
+
+export function decompress(texture: Texture, maxTextureSize?: number, renderer?: WebGLRenderer): Texture;

package/types/examples/jsm/utils/TextureUtilsGPU.d.ts

@@ -0,0 +1,3 @@
+import { Texture, WebGPURenderer } from "three/webgpu";
+
+export function decompress(blitTexture: Texture, maxTextureSize?: number, renderer?: WebGPURenderer): Promise<Texture>;

package/types/examples/jsm/utils/UVsDebug.d.ts

@@ -0,0 +1,3 @@
+import { BufferGeometry } from "three";
+
+export function UVsDebug(geometry: BufferGeometry, size?: number): HTMLCanvasElement;

package/types/examples/jsm/utils/WorkerPool.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @author Deepkolos / https://github.com/deepkolos
+ */
+
+export class WorkerPool {
+    pool: number;
+    quene: Array<{
+        resolve: (e: any) => void;
+        msg: any;
+        transfer: Array<Transferable>;
+    }>;
+    workers: Array<Worker>;
+    workersResolve: Array<(e: any) => void>;
+    workerStatus: number;
+
+    constructor(pool?: number);
+
+    _initWorker(workerId: number): void;
+    workerCreator(): Worker;
+    _getIdleWorker(): void;
+    _onMessage(workerId: number, msg: any): void;
+    setWorkerCreator(workerCreator: () => Worker): void;
+    setWorkerLimit(pool: number): void;
+    postMessage(msg: any, transfer?: Array<Transferable>): Promise<MessageEvent>;
+    dispose(): void;
+}

package/types/examples/jsm/webxr/ARButton.d.ts

@@ -0,0 +1,9 @@
+import { WebGLRenderer } from "three";
+
+export interface ARButtonSessionInit extends XRSessionInit {
+    domOverlay: { root: HTMLElement };
+}
+
+export namespace ARButton {
+    function createButton(renderer: WebGLRenderer, sessionInit?: Partial<ARButtonSessionInit>): HTMLElement;
+}