@types/three 0.167.2 → 0.169.0

three/src/renderers/webgl/WebGLCapabilities.d.ts

@@ -1,8 +1,20 @@
 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 {
@@ -18,6 +30,7 @@ export class WebGLCapabilities {
 
     precision: string;
     logarithmicDepthBuffer: boolean;
+    reverseDepthBuffer: boolean;
 
     maxTextures: number;
     maxVertexTextures: number;

three/src/renderers/webgl/WebGLPrograms.d.ts

@@ -155,6 +155,7 @@ export interface WebGLProgramParameters {
 
     sizeAttenuation: boolean;
     logarithmicDepthBuffer: boolean;
+    reverseDepthBuffer: boolean;
 
     skinning: boolean;
 

three/src/renderers/webgl/WebGLProperties.d.ts

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

three/src/renderers/webgpu/WebGPUBackend.d.ts

@@ -1,11 +1,15 @@
+/// <reference types="@webgpu/types" />
+
 import { CoordinateSystem } from "../../constants.js";
 import Backend, { BackendParameters } from "../common/Backend.js";
 
 export interface WebGPUBackendParameters extends BackendParameters {
     alpha?: boolean | undefined;
-    antialias?: boolean | undefined;
-    sampleCount?: number | undefined;
+    requiredLimits?: Record<string, GPUSize64> | undefined;
     trackTimestamp?: boolean | undefined;
+    device?: GPUDevice | undefined;
+    powerPreference?: GPUPowerPreference | undefined;
+    context?: GPUCanvasContext | undefined;
 }
 
 export default class WebGPUBackend extends Backend {

three/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);
+}

three/src/renderers/webgpu/WebGPURenderer.d.ts

@@ -5,6 +5,10 @@ export interface WebGPURendererParameters extends RendererParameters, WebGPUBack
     forceWebGL?: boolean | undefined;
 }
 
-export default class WebGPURenderer extends Renderer {
+declare class WebGPURenderer extends Renderer {
+    readonly isWebGPURenderer: true;
+
     constructor(parameters?: WebGPURendererParameters);
 }
+
+export default WebGPURenderer;

three/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;

three/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;

three/src/renderers/webgpu/nodes/WGSLNodeBuilder.d.ts

@@ -4,7 +4,7 @@ import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
 import NodeUniform from "../../../nodes/core/NodeUniform.js";
 import NodeVar from "../../../nodes/core/NodeVar.js";
 import StructTypeNode from "../../../nodes/core/StructTypeNode.js";
-import { ShaderNode } from "../../../nodes/shadernode/ShaderNode.js";
+import { ShaderNode } from "../../../nodes/tsl/TSLCore.js";
 import { Texture } from "../../../textures/Texture.js";
 import NodeUniformsGroup from "../../common/nodes/NodeUniformsGroup.js";
 
@@ -19,7 +19,7 @@ export default class WGSLNodeBuilder extends NodeBuilder {
     builtins: { [key in BuiltinStage]: Map<string, BuiltinType> };
     uniformGroups: { [key in NodeShaderStage]: NodeUniformsGroup };
 
-    needsColorSpaceToLinear(texture: Texture): boolean;
+    needsToWorkingColorSpace(texture: Texture): boolean;
     _generateTextureSample(
         texture: Texture,
         textureProperty: string,

three/src/renderers/webxr/WebXRManager.d.ts

@@ -1,5 +1,3 @@
-// https://threejs.org/docs/#api/en/renderers/webxr/WebXRManager
-
 /// <reference types="webxr" />
 
 import { ArrayCamera } from "../../cameras/ArrayCamera.js";

three/examples/jsm/geometries/SDFGeometryGenerator.d.ts

@@ -1,16 +0,0 @@
-import { BufferGeometry, WebGLRenderer, WebGLRenderTarget } from "three";
-
-export class SDFGeometryGenerator {
-    constructor(renderer: WebGLRenderer);
-
-    generate(res?: number, distFunc?: string, bounds?: number): BufferGeometry;
-
-    computeSDF(
-        width: number,
-        height: number,
-        tilesX: number,
-        tilesY: number,
-        bounds: number,
-        shader: string,
-    ): WebGLRenderTarget;
-}

three/examples/jsm/loaders/LogLuvLoader.d.ts

@@ -1,19 +0,0 @@
-import { DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
-
-export interface LogLuv {
-    width: number;
-    height: number;
-    data: Uint16Array | Float32Array;
-    format: PixelFormat;
-    type: TextureDataType;
-    flipY: boolean;
-}
-
-export class LogLuvLoader extends DataTextureLoader {
-    type: TextureDataType;
-    constructor(manager?: LoadingManager);
-
-    parse(buffer: Iterable<number>): LogLuv;
-
-    setDataType(value: TextureDataType): this;
-}

three/examples/jsm/loaders/TiltLoader.d.ts

@@ -1,7 +0,0 @@
-import { Group, Loader, LoadingManager } from "three";
-
-export class TiltLoader extends Loader<Group> {
-    constructor(manager?: LoadingManager);
-
-    parse(data: ArrayBuffer): Group;
-}

three/examples/jsm/utils/GPUStatsPanel.d.ts

@@ -1,12 +0,0 @@
-import Stats from "../libs/stats.module.js";
-
-export class GPUStatsPanel extends Stats.Panel {
-    context: WebGLRenderingContext | WebGL2RenderingContext;
-    extension: unknown;
-    maxTime: number;
-    activeQueries: number;
-    startQuery: () => void;
-    endQuery: () => void;
-
-    constructor(context: WebGLRenderingContext | WebGL2RenderingContext, name?: string);
-}

three/examples/jsm/utils/PackedPhongMaterial.d.ts

@@ -1,10 +0,0 @@
-/**
- * `PackedPhongMaterial` inherited from THREE.MeshPhongMaterial
- *
- * @param {Object} parameters
- */
-import { MeshPhongMaterial, MeshPhongMaterialParameters } from "three";
-
-export class PackedPhongMaterial extends MeshPhongMaterial {
-    constructor(parameters: MeshPhongMaterialParameters);
-}

three/src/nodes/accessors/NormalNode.d.ts

@@ -1,12 +0,0 @@
-import AttributeNode from "../core/AttributeNode.js";
-import PropertyNode from "../core/PropertyNode.js";
-import VarNode from "../core/VarNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export const normalGeometry: ShaderNodeObject<AttributeNode>;
-export const normalLocal: ShaderNodeObject<VarNode>;
-export const normalView: ShaderNodeObject<VarNode>;
-export const normalWorld: ShaderNodeObject<VarNode>;
-export const transformedNormalView: ShaderNodeObject<PropertyNode>;
-export const transformedNormalWorld: ShaderNodeObject<VarNode>;
-export const transformedClearcoatNormalView: ShaderNodeObject<PropertyNode>;

three/src/nodes/accessors/TextureBicubicNode.d.ts

@@ -1,18 +0,0 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export default class TextureBicubicNode extends TempNode {
-    textureNode: Node;
-    blurNode: Node;
-
-    constructor(textureNode: Node, blurNode?: Node);
-}
-
-export const textureBicubic: (textureNode: Node, blurNode?: NodeRepresentation) => ShaderNodeObject<TextureBicubicNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        bicubic: typeof textureBicubic;
-    }
-}

three/src/nodes/accessors/UniformsNode.d.ts

@@ -1,23 +0,0 @@
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import ArrayElementNode from "../utils/ArrayElementNode.js";
-import BufferNode from "./BufferNode.js";
-
-declare class UniformsElementNode extends ArrayElementNode {
-    constructor(arrayBuffer: Node, indexNode: Node);
-}
-
-export default class UniformsNode extends BufferNode {
-    array: unknown[];
-    elementType: string | null;
-
-    readonly isArrayBufferNode: true;
-
-    constructor(value: unknown[], elementType?: string | null);
-
-    getElementLength(): number;
-
-    element(indexNode: number): ShaderNodeObject<UniformsElementNode>;
-}
-
-export const uniforms: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformsNode>;

three/src/nodes/core/NodeKeywords.d.ts

@@ -1,17 +0,0 @@
-import Node from "./Node.js";
-import NodeBuilder from "./NodeBuilder.js";
-declare class NodeKeywords {
-    keywords: string[];
-    nodes: {
-        [name: string]: Node;
-    };
-    keywordsCallback: {
-        [name: string]: (name: string) => Node;
-    };
-    constructor();
-    getNode(name: string): Node;
-    addKeyword(name: string, callback: (name: string) => Node): this;
-    parse(code: string): Node[];
-    include(builder: NodeBuilder, code: string): void;
-}
-export default NodeKeywords;

three/src/nodes/display/BlendModeNode.d.ts

@@ -1,47 +0,0 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { JoinNode } from "../Nodes.js";
-import { NodeRepresentation, ShaderNode, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export const BurnNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
-
-export const DodgeNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
-
-export const ScreenNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
-
-export const OverlayNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
-
-export type BlendMode =
-    | typeof BlendModeNode.BURN
-    | typeof BlendModeNode.DODGE
-    | typeof BlendModeNode.SCREEN
-    | typeof BlendModeNode.OVERLAY;
-
-export default class BlendModeNode extends TempNode {
-    static BURN: "burn";
-    static DODGE: "dodge";
-    static SCREEN: "screen";
-    static OVERLAY: "overlay";
-
-    baseNode: Node;
-    blendMode: BlendMode;
-    blendNode: Node;
-
-    constructor(blendMode: BlendMode, baseNode: Node, blendNode: Node);
-
-    setup(): Node;
-}
-
-export const burn: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
-export const dodge: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
-export const overlay: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
-export const screen: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        burn: typeof burn;
-        dodge: typeof dodge;
-        overlay: typeof overlay;
-        screen: typeof screen;
-    }
-}

three/src/nodes/display/ColorAdjustmentNode.d.ts

@@ -1,47 +0,0 @@
-import TempNode from "../core/TempNode.js";
-import MathNode from "../math/MathNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export type ColorAdjustmentMethod =
-    | typeof ColorAdjustmentNode.SATURATION
-    | typeof ColorAdjustmentNode.VIBRANCE
-    | typeof ColorAdjustmentNode.HUE;
-
-export default class ColorAdjustmentNode extends TempNode {
-    static SATURATION: "saturation";
-    static VIBRANCE: "vibrance";
-    static HUE: "hue";
-
-    method: ColorAdjustmentMethod;
-
-    colorNode: Node;
-    adjustmentNode: Node;
-
-    constructor(method: ColorAdjustmentMethod, colorNode: Node, adjustmentNode?: Node);
-}
-
-export const saturation: (
-    colorNode: NodeRepresentation,
-    adjustmentNode?: NodeRepresentation,
-) => ShaderNodeObject<ColorAdjustmentNode>;
-export const vibrance: (
-    colorNode: NodeRepresentation,
-    adjustmentNode?: NodeRepresentation,
-) => ShaderNodeObject<ColorAdjustmentNode>;
-export const hue: (
-    colorNode: NodeRepresentation,
-    adjustmentNode?: NodeRepresentation,
-) => ShaderNodeObject<ColorAdjustmentNode>;
-
-export const luminance: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
-
-export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        saturation: typeof saturation;
-        vibrance: typeof vibrance;
-        hue: typeof hue;
-        threshold: typeof threshold;
-    }
-}

three/src/nodes/display/ViewportNode.d.ts

@@ -1,31 +0,0 @@
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export type ViewportNodeScope =
-    | typeof ViewportNode.COORDINATE
-    | typeof ViewportNode.RESOLUTION
-    | typeof ViewportNode.TOP_LEFT
-    | typeof ViewportNode.BOTTOM_LEFT
-    | typeof ViewportNode.TOP_RIGHT
-    | typeof ViewportNode.BOTTOM_RIGHT;
-
-export default class ViewportNode extends Node {
-    static COORDINATE: "coordinate";
-    static RESOLUTION: "resolution";
-    static TOP_LEFT: "topLeft";
-    static BOTTOM_LEFT: "bottomLeft";
-    static TOP_RIGHT: "topRight";
-    static BOTTOM_RIGHT: "bottomRight";
-
-    scope: ViewportNodeScope;
-    isViewportNode: true;
-
-    constructor(scope: ViewportNodeScope);
-}
-
-export const viewportCoordinate: ShaderNodeObject<ViewportNode>;
-export const viewportResolution: ShaderNodeObject<ViewportNode>;
-export const viewportTopLeft: ShaderNodeObject<ViewportNode>;
-export const viewportBottomLeft: ShaderNodeObject<ViewportNode>;
-export const viewportTopRight: ShaderNodeObject<ViewportNode>;
-export const viewportBottomRight: ShaderNodeObject<ViewportNode>;

three/src/nodes/loaders/NodeMaterialLoader.d.ts

@@ -1,8 +0,0 @@
-import { MaterialLoader } from "../../loaders/MaterialLoader.js";
-import { NodeLoaderResult } from "./NodeLoader.js";
-
-export default class NodeMaterialLoader extends MaterialLoader {
-    nodes: NodeLoaderResult;
-
-    setNodes(value: NodeLoaderResult): this;
-}

three/src/nodes/loaders/NodeObjectLoader.d.ts

@@ -1,10 +0,0 @@
-import { ObjectLoader } from "../../loaders/ObjectLoader.js";
-import { Material } from "../../materials/Material.js";
-import { Texture } from "../../textures/Texture.js";
-import { NodeLoaderResult } from "./NodeLoader.js";
-
-export default class NodeObjectLoader extends ObjectLoader {
-    parseNodes(json: unknown, textures: { [key: string]: Texture }): NodeLoaderResult;
-
-    parseMaterials(json: unknown, textures: { [key: string]: Texture }): { [key: string]: Material };
-}

three/src/nodes/materials/NodeMaterial.d.ts

@@ -1,124 +0,0 @@
-import { LineBasicMaterial } from "../../materials/LineBasicMaterial.js";
-import { Material, MaterialParameters } from "../../materials/Material.js";
-import { MeshBasicMaterial } from "../../materials/MeshBasicMaterial.js";
-import { MeshMatcapMaterial } from "../../materials/MeshMatcapMaterial.js";
-import { MeshNormalMaterial } from "../../materials/MeshNormalMaterial.js";
-import { MeshPhongMaterial } from "../../materials/MeshPhongMaterial.js";
-import { MeshPhysicalMaterial } from "../../materials/MeshPhysicalMaterial.js";
-import { MeshStandardMaterial } from "../../materials/MeshStandardMaterial.js";
-import { MeshToonMaterial } from "../../materials/MeshToonMaterial.js";
-import { PointsMaterial } from "../../materials/PointsMaterial.js";
-import { ShadowMaterial } from "../../materials/ShadowMaterial.js";
-import { SpriteMaterial } from "../../materials/SpriteMaterial.js";
-import ClippingNode from "../accessors/ClippingNode.js";
-import LightingModel from "../core/LightingModel.js";
-import MRTNode from "../core/MRTNode.js";
-import Node from "../core/Node.js";
-import NodeBuilder from "../core/NodeBuilder.js";
-import LightsNode from "../lighting/LightsNode.js";
-import LineBasicNodeMaterial from "./LineBasicNodeMaterial.js";
-import MeshBasicNodeMaterial from "./MeshBasicNodeMaterial.js";
-import MeshMatcapNodeMaterial from "./MeshMatcapNodeMaterial.js";
-import MeshNormalNodeMaterial from "./MeshNormalNodeMaterial.js";
-import MeshPhongNodeMaterial from "./MeshPhongNodeMaterial.js";
-import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
-import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
-import MeshToonNodeMaterial from "./MeshToonNodeMaterial.js";
-import PointsNodeMaterial from "./PointsNodeMaterial.js";
-import ShadowNodeMaterial from "./ShadowNodeMaterial.js";
-import SpriteNodeMaterial from "./SpriteNodeMaterial.js";
-
-export interface NodeMaterialParameters extends MaterialParameters {
-    normals?: boolean | undefined;
-
-    colorSpaced?: boolean | undefined;
-
-    lightsNode?: LightsNode | null | undefined;
-    envNode?: Node | null | undefined;
-    aoNode?: Node | null | undefined;
-
-    colorNode?: Node | null | undefined;
-    normalNode?: Node | null | undefined;
-    opacityNode?: Node | null | undefined;
-    backdropNode?: Node | null | undefined;
-    backdropAlphaNode?: Node | null | undefined;
-    alphaTestNode?: Node | null | undefined;
-
-    positionNode?: Node | null | undefined;
-
-    depthNode?: Node | null | undefined;
-    shadowNode?: Node | null | undefined;
-
-    outputNode?: Node | null | undefined;
-
-    fragmentNode?: Node | null | undefined;
-    vertexNode?: Node | null | undefined;
-}
-
-export default class NodeMaterial extends Material {
-    readonly isNodeMaterial: true;
-
-    fog: boolean;
-    lights: boolean;
-    normals: boolean;
-
-    lightsNode: LightsNode | null;
-    envNode: Node | null;
-    aoNode: Node | null;
-
-    colorNode: Node | null;
-    normalNode: Node | null;
-    opacityNode: Node | null;
-    backdropNode: Node | null;
-    backdropAlphaNode: Node | null;
-    alphaTestNode: Node | null;
-
-    positionNode: Node | null;
-
-    depthNode: Node | null;
-    shadowNode: Node | null;
-    shadowPositionNode: Node | null;
-
-    outputNode: Node | null;
-    mrtNode: MRTNode | null;
-
-    fragmentNode: Node | null;
-    vertexNode: Node | null;
-
-    constructor();
-
-    build(builder: NodeBuilder): void;
-    setup(builder: NodeBuilder): void;
-    setupClipping(builder: NodeBuilder): ClippingNode | null;
-    setupDepth(builder: NodeBuilder): void;
-    setupPosition(builder: NodeBuilder): Node;
-    setupDiffuseColor(builder: NodeBuilder): void;
-    setupVariants(builder: NodeBuilder): void;
-    setupNormal(builder: NodeBuilder): void;
-    setupEnvironment(builder: NodeBuilder): Node | null;
-    setupLightMap(builder: NodeBuilder): Node | null;
-    setupLights(builder: NodeBuilder): LightsNode;
-    setupOutgoingLight(): Node;
-    setupLightingModel(builder: NodeBuilder): LightingModel;
-    setupLighting(builder: NodeBuilder): Node;
-    setupOutput(builder: NodeBuilder, outputNode: Node): Node;
-
-    setDefaultValues(material: Material): void;
-
-    static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
-    static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
-    static fromMaterial(material: MeshMatcapMaterial): MeshMatcapNodeMaterial;
-    static fromMaterial(material: MeshNormalMaterial): MeshNormalNodeMaterial;
-    static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
-    static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
-    static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
-    static fromMaterial(material: MeshToonMaterial): MeshToonNodeMaterial;
-    static fromMaterial(material: PointsMaterial): PointsNodeMaterial;
-    static fromMaterial(material: ShadowMaterial): ShadowNodeMaterial;
-    static fromMaterial(material: SpriteMaterial): SpriteNodeMaterial;
-    static fromMaterial(material: NodeMaterial): NodeMaterial;
-    static fromMaterial(material: Material): NodeMaterial;
-}
-
-export function addNodeMaterial(type: string, nodeMaterial: typeof NodeMaterial): void;
-export function createNodeMaterialFromType(type: string): NodeMaterial;

three/src/nodes/math/CondNode.d.ts

@@ -1,22 +0,0 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export default class CondNode extends Node {
-    condNode: Node;
-    ifNode: Node;
-    elseNode: Node;
-
-    constructor(condNode: Node, ifNode: Node, elseNode: Node);
-}
-
-export function cond(
-    condNode: NodeRepresentation,
-    ifNode: NodeRepresentation,
-    elseNode: NodeRepresentation,
-): ShaderNodeObject<Node>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        cond: typeof cond;
-    }
-}

three/src/nodes/math/HashNode.d.ts

@@ -1,16 +0,0 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export default class HashNode extends Node {
-    seedNode: Node;
-
-    constructor(seedNode: Node);
-}
-
-export const hash: (seedNode: NodeRepresentation) => ShaderNodeObject<HashNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        hash: typeof hash;
-    }
-}

three/src/nodes/procedural/CheckerNode.d.ts

@@ -1,15 +0,0 @@
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export default class CheckerNode extends TempNode {
-    uvNode: Node;
-    constructor(uvNode?: Node);
-}
-
-export const checker: (uvNode?: NodeRepresentation) => ShaderNodeObject<CheckerNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        checker: typeof checker;
-    }
-}

three/src/nodes/utils/DiscardNode.d.ts

@@ -1,17 +0,0 @@
-import Node from "../core/Node.js";
-import CondNode from "../math/CondNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export default class DiscardNode extends CondNode {
-    constructor(condNode: Node);
-}
-
-export const inlineDiscard: (condNode: NodeRepresentation) => ShaderNodeObject<DiscardNode>;
-export const discard: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
-export const Return: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        discard: typeof discard;
-    }
-}

three/src/nodes/utils/PackingNode.d.ts

@@ -1,24 +0,0 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export type PackingNodeScope = typeof PackingNode.DIRECTION_TO_COLOR | typeof PackingNode.COLOR_TO_DIRECTION;
-
-declare class PackingNode extends TempNode {
-    constructor(scope: PackingNodeScope, node: Node);
-
-    static DIRECTION_TO_COLOR: "directionToColor";
-    static COLOR_TO_DIRECTION: "colorToDirection";
-}
-
-export default PackingNode;
-
-export const directionToColor: (node: NodeRepresentation) => ShaderNodeObject<PackingNode>;
-export const colorToDirection: (node: NodeRepresentation) => ShaderNodeObject<PackingNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        directionToColor: typeof directionToColor;
-        colorToDirection: typeof colorToDirection;
-    }
-}