@nativescript/canvas-three 2.0.0-webgpu.34 → 2.0.0-webgpu.35

package/three/src/nodes/core/constants.d.ts

@@ -1,27 +0,0 @@
-export declare const NodeShaderStage: {
-	readonly VERTEX: 'vertex';
-	readonly FRAGMENT: 'fragment';
-};
-export declare const NodeUpdateType: {
-	readonly NONE: 'none';
-	readonly FRAME: 'frame';
-	readonly RENDER: 'render';
-	readonly OBJECT: 'object';
-};
-export declare const NodeType: {
-	readonly BOOLEAN: 'bool';
-	readonly INTEGER: 'int';
-	readonly FLOAT: 'float';
-	readonly VECTOR2: 'vec2';
-	readonly VECTOR3: 'vec3';
-	readonly VECTOR4: 'vec4';
-	readonly MATRIX2: 'mat2';
-	readonly MATRIX3: 'mat3';
-	readonly MATRIX4: 'mat4';
-};
-export type NodeShaderStage = 'vertex' | 'fragment' | 'compute';
-export type NodeUpdateType = 'none' | 'frame' | 'render' | 'object';
-export declare const defaultShaderStages: NodeShaderStage[];
-export declare const defaultBuildStages: string[];
-export declare const shaderStages: NodeShaderStage[];
-export declare const vectorComponents: string[];

package/three/src/nodes/display/AfterImageNode.d.ts

@@ -1,25 +0,0 @@
-import TextureNode from '../accessors/TextureNode.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import UniformNode from '../core/UniformNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export default class AfterImageNode extends TempNode {
-	textureNode: TextureNode;
-	textureNodeOld: Node;
-	damp: UniformNode<number>;
-
-	constructor(textureNode: Node, damp?: number);
-
-	getTextureNode(): TextureNode;
-
-	setSize(width: number, height: number): void;
-}
-
-export const afterImage: (node: Node, damp?: number) => ShaderNodeObject<AfterImageNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		afterImage: typeof afterImage;
-	}
-}

package/three/src/nodes/display/AnamorphicNode.d.ts

@@ -1,26 +0,0 @@
-import { Vector2 } from '../../math/Vector2.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export default class AnamorphicNode extends TempNode {
-	textureNode: Node;
-	thresholdNode: Node;
-	scaleNode: Node;
-	samples: number;
-	resolution: Vector2;
-
-	constructor(textureNode: Node, thresholdNode: Node, scaleNode: Node, samples: number);
-
-	getTextureNode(): Node;
-
-	setSize(width: number, height: number): void;
-}
-
-export const anamorphic: (node: Node, threshold?: NodeRepresentation, scale?: NodeRepresentation, samples?: NodeRepresentation) => ShaderNodeObject<AnamorphicNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		anamorphic: typeof anamorphic;
-	}
-}

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

@@ -1,43 +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;
-	}
-}

package/three/src/nodes/display/BloomNode.d.ts

@@ -1,30 +0,0 @@
-import TextureNode from '../accessors/TextureNode.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import UniformNode from '../core/UniformNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-declare class BloomNode extends TempNode {
-	inputNode: Node;
-	strength: UniformNode<number>;
-	radius: UniformNode<number>;
-	threshold: UniformNode<number>;
-
-	smoothWidth: UniformNode<number>;
-
-	constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
-
-	getTexture(): ShaderNodeObject<TextureNode>;
-
-	setSize(width: number, height: number): void;
-}
-
-export const bloom: (node: NodeRepresentation, strength?: number, radius?: number, threshold?: number) => ShaderNodeObject<BloomNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		bloom: typeof bloom;
-	}
-}
-
-export default BloomNode;

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

@@ -1,35 +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;
-	}
-}

package/three/src/nodes/display/ColorSpaceNode.d.ts

@@ -1,32 +0,0 @@
-import { ColorSpace } from '../../constants.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export type ColorSpaceNodeMethod = typeof ColorSpaceNode.LINEAR_TO_LINEAR | typeof ColorSpaceNode.LINEAR_TO_sRGB | typeof ColorSpaceNode.sRGB_TO_LINEAR;
-
-export default class ColorSpaceNode extends TempNode {
-	static LINEAR_TO_LINEAR: 'LinearToLinear';
-	static LINEAR_TO_sRGB: 'LinearTosRGB';
-	static sRGB_TO_LINEAR: 'sRGBToLinear';
-
-	method: ColorSpaceNodeMethod;
-	node: Node;
-
-	constructor(method: ColorSpaceNodeMethod | null, node: Node);
-}
-
-export const linearToColorSpace: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
-export const colorSpaceToLinear: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
-
-export const linearTosRGB: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
-export const sRGBToLinear: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		linearTosRGB: typeof linearTosRGB;
-		sRGBToLinear: typeof sRGBToLinear;
-		linearToColorSpace: typeof linearToColorSpace;
-		colorSpaceToLinear: typeof colorSpaceToLinear;
-	}
-}

package/three/src/nodes/display/DenoiseNode.d.ts

@@ -1,32 +0,0 @@
-import { Camera } from '../../cameras/Camera.js';
-import { Matrix4 } from '../../math/Matrix4.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import UniformNode from '../core/UniformNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-declare class DenoiseNode extends TempNode {
-	textureNode: Node;
-	depthNode: Node;
-	normalNode: Node;
-	noiseNode: Node;
-
-	cameraProjectionMatrixInversion: UniformNode<Matrix4>;
-	lumaPhi: UniformNode<number>;
-	depthPhi: UniformNode<number>;
-	normalPhi: UniformNode<number>;
-	radius: UniformNode<number>;
-	index: UniformNode<number>;
-
-	constructor(textureNode: Node, depthNode: Node, normalNode: Node, noiseNode: Node, camera: Camera);
-}
-
-export const denoise: (node: NodeRepresentation, depthNode: NodeRepresentation, normalNode: NodeRepresentation, noiseNode: NodeRepresentation, camera: Camera) => ShaderNodeObject<DenoiseNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		denoise: typeof denoise;
-	}
-}
-
-export default DenoiseNode;

package/three/src/nodes/display/DepthOfFieldNode.d.ts

@@ -1,24 +0,0 @@
-import TextureNode from '../accessors/TextureNode.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import UniformNode from '../core/UniformNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export default class DepthOfFieldNode extends TempNode {
-	textureNode: TextureNode;
-	viewZNode: Node;
-
-	focus: UniformNode<number>;
-	aperture: UniformNode<number>;
-	maxblur: UniformNode<number>;
-
-	constructor(textureNode: TextureNode, viewZNode: Node, focusNode: Node, apertureNode: Node, maxblurNode: Node);
-}
-
-export const dof: (node: NodeRepresentation, viewZNode: NodeRepresentation, focus?: NodeRepresentation, aperture?: NodeRepresentation, maxblur?: NodeRepresentation) => ShaderNodeObject<DepthOfFieldNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		dof: typeof dof;
-	}
-}

package/three/src/nodes/display/DotScreenNode.d.ts

@@ -1,22 +0,0 @@
-import { Vector2 } from '../../math/Vector2.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import UniformNode from '../core/UniformNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export default class DotScreenNode extends TempNode {
-	inputNode: Node;
-	center: UniformNode<Vector2>;
-	angle: UniformNode<number>;
-	scale: UniformNode<number>;
-
-	constructor(inputNode: Node, center?: Vector2, angle?: number, scale?: number);
-}
-
-export const dotScreen: (node: NodeRepresentation, center?: Vector2, angle?: number, scale?: number) => ShaderNodeObject<DotScreenNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		dotScreen: typeof dotScreen;
-	}
-}

package/three/src/nodes/display/FXAANode.d.ts

@@ -1,19 +0,0 @@
-import TextureNode from '../accessors/TextureNode.js';
-import TempNode from '../core/TempNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-declare class FXAANode extends TempNode {
-	textureNode: TextureNode;
-
-	constructor(textureNode: TextureNode);
-}
-
-export const fxaa: (node: NodeRepresentation) => ShaderNodeObject<FXAANode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		fxaa: typeof fxaa;
-	}
-}
-
-export default FXAANode;

package/three/src/nodes/display/FilmNode.d.ts

@@ -1,21 +0,0 @@
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-declare class FilmNode extends TempNode {
-	inputNode: Node;
-	intensityNode: Node | null;
-	uvNode: Node | null;
-
-	constructor(inputNode: Node, intensityNode?: Node | null, uvNode?: Node | null);
-}
-
-export const film: (inputNode: NodeRepresentation, intensityNode?: NodeRepresentation | null, uvNode?: NodeRepresentation | null) => ShaderNodeObject<FilmNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		film: typeof film;
-	}
-}
-
-export default FilmNode;

package/three/src/nodes/display/FrontFacingNode.d.ts

@@ -1,10 +0,0 @@
-import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export default class FrontFacingNode extends Node {
-	isFrontFacingNode: true;
-	constructor();
-}
-
-export const frontFacing: ShaderNodeObject<FrontFacingNode>;
-export const faceDirection: ShaderNodeObject<Node>;

package/three/src/nodes/display/GTAONode.d.ts

@@ -1,42 +0,0 @@
-import { Camera } from '../../cameras/Camera.js';
-import { Matrix4 } from '../../math/Matrix4.js';
-import { Vector2 } from '../../math/Vector2.js';
-import TextureNode from '../accessors/TextureNode.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import UniformNode from '../core/UniformNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-declare class GTAONode extends TempNode {
-	depthNode: Node;
-	normalNode: Node;
-
-	radius: ShaderNodeObject<UniformNode<number>>;
-	resolution: ShaderNodeObject<UniformNode<Vector2>>;
-	thickness: ShaderNodeObject<UniformNode<number>>;
-	distanceExponent: ShaderNodeObject<UniformNode<number>>;
-	distanceFallOff: ShaderNodeObject<UniformNode<number>>;
-	scale: ShaderNodeObject<UniformNode<number>>;
-	noiseNode: ShaderNodeObject<TextureNode>;
-
-	cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
-	cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
-
-	SAMPLES: ShaderNodeObject<UniformNode<number>>;
-
-	constructor(depthNode: Node, normalNode: Node, camera: Camera);
-
-	getTextureNode(): ShaderNodeObject<TextureNode>;
-
-	setSize(width: number, height: number): void;
-}
-
-export const ao: (depthNode: NodeRepresentation, normalNode: NodeRepresentation, camera: Camera) => ShaderNodeObject<GTAONode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		ao: typeof ao;
-	}
-}
-
-export default GTAONode;

package/three/src/nodes/display/GaussianBlurNode.d.ts

@@ -1,27 +0,0 @@
-import { Vector2 } from '../../math/Vector2.js';
-import TextureNode from '../accessors/TextureNode.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export default class GaussianBlurNode extends TempNode {
-	textureNode: TextureNode;
-	directionNode: Node | null;
-	sigma: number;
-
-	resolution: Vector2;
-
-	constructor(textureNode: TextureNode, directionNode?: Node | null, sigma?: number);
-
-	setSize(width: number, height: number): void;
-
-	getTextureNode(): TextureNode;
-}
-
-export const gaussianBlur: (node: NodeRepresentation, directionNode?: NodeRepresentation | null, sigma?: number) => ShaderNodeObject<GaussianBlurNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		gaussianBlur: typeof gaussianBlur;
-	}
-}

package/three/src/nodes/display/Lut3DNode.d.ts

@@ -1,25 +0,0 @@
-import { Data3DTexture } from '../../textures/Data3DTexture.js';
-import Texture3DNode from '../accessors/Texture3DNode.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import UniformNode from '../core/UniformNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-declare class Lut3DNode extends TempNode {
-	inputNode: Node;
-	lutNode: Texture3DNode;
-	size: ShaderNodeObject<UniformNode<number>>;
-	intensityNode: UniformNode<number>;
-
-	constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
-}
-
-export const lut3D: (node: NodeRepresentation, lut: NodeRepresentation, size: number, intensity: NodeRepresentation) => ShaderNodeObject<Lut3DNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		lut3D: typeof lut3D;
-	}
-}
-
-export default Lut3DNode;

package/three/src/nodes/display/NormalMapNode.d.ts

@@ -1,21 +0,0 @@
-import { NormalMapTypes } from '../../constants.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export default class NormalMapNode extends TempNode {
-	node: Node;
-	scaleNode: Node | null;
-
-	normalMapType: NormalMapTypes;
-
-	constructor(node: Node, scaleNode?: Node | null);
-}
-
-export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		normalMap: typeof normalMap;
-	}
-}

package/three/src/nodes/display/PassNode.d.ts

@@ -1,62 +0,0 @@
-import { Camera } from '../../cameras/Camera.js';
-import { RenderTarget, RenderTargetOptions } from '../../core/RenderTarget.js';
-import { Scene } from '../../scenes/Scene.js';
-import { Texture } from '../../textures/Texture.js';
-import TextureNode from '../accessors/TextureNode.js';
-import MRTNode from '../core/MRTNode.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-declare class PassTextureNode extends TextureNode {
-	passNode: PassNode;
-
-	constructor(passNode: PassNode, texture: Texture);
-}
-
-declare class PassMultipleTextureNode extends PassTextureNode {
-	textureName: string;
-
-	constructor(passNode: PassNode, textureName: string);
-}
-
-declare class PassNode extends TempNode {
-	scope: PassNodeScope;
-	scene: Scene;
-	camera: Camera;
-
-	renderTarget: RenderTarget;
-
-	readonly isPassNode: true;
-
-	constructor(scope: PassNodeScope, scene: Scene, camera: Camera, options?: RenderTargetOptions);
-
-	setMRT(mrt: MRTNode | null): this;
-
-	getMRT(): MRTNode | null;
-
-	getTexture(name: string): Texture;
-
-	getTextureNode(name?: string): ShaderNodeObject<Node>;
-
-	getViewZNode(name?: string): ShaderNodeObject<Node>;
-
-	getLinearDepthNode(name?: string): ShaderNodeObject<Node>;
-
-	setSize(width: number, height: number): void;
-
-	setPixelRatio(pixelRatio: number): void;
-
-	dispose(): void;
-
-	static COLOR: 'color';
-	static DEPTH: 'depth';
-}
-
-export type PassNodeScope = typeof PassNode.COLOR | typeof PassNode.DEPTH;
-
-export default PassNode;
-
-export const pass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;
-export const passTexture: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
-export const depthPass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;

package/three/src/nodes/display/PixelationPassNode.d.ts

@@ -1,41 +0,0 @@
-import { Camera } from '../../cameras/Camera.js';
-import { Scene } from '../../scenes/Scene.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import UniformNode from '../core/UniformNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-import PassNode from './PassNode.js';
-
-declare class PixelationNode extends TempNode {
-	textureNode: Node;
-	depthNode: Node;
-	normalNode: Node;
-
-	pixelSize: Node;
-	normalEdgeStrength: Node;
-	depthEdgeStrength: Node;
-
-	constructor(textureNode: Node, depthNode: Node, normalNode: Node, pixelSize: Node, normalEdgeStrength: Node, depthEdgeStrength: Node);
-}
-
-declare const pixelation: (node: NodeRepresentation, depthNode: NodeRepresentation, normalNode: NodeRepresentation, pixelSize?: number, normalEdgeStrength?: number, depthEdgeStrength?: number) => ShaderNodeObject<PixelationNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		pixelation: typeof pixelation;
-	}
-}
-
-declare class PixelationPassNode extends PassNode {
-	pixelSize: UniformNode<number>;
-	normalEdgeStrength: UniformNode<number>;
-	depthEdgeStrength: UniformNode<number>;
-
-	readonly isPixelationPassNode: true;
-
-	constructor(scene: Scene, camera: Camera, pixelSize: number, normalEdgeStrength: number, depthEdgeStrength: number);
-}
-
-export const pixelationPass: (scene: Scene, camera: Camera, pixelSize: UniformNode<number>, normalEdgeStrength: UniformNode<number>, depthEdgeStrength: UniformNode<number>) => ShaderNodeObject<PixelationPassNode>;
-
-export default PixelationPassNode;

package/three/src/nodes/display/PosterizeNode.d.ts

@@ -1,17 +0,0 @@
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export default class PosterizeNode extends Node {
-	sourceNode: Node;
-	stepsNode: Node;
-
-	constructor(sourceNode: Node, stepsNode: Node);
-}
-
-export const posterize: (sourceNode: NodeRepresentation, stepsNode: NodeRepresentation) => ShaderNodeObject<PosterizeNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		posterize: typeof posterize;
-	}
-}

package/three/src/nodes/display/RGBShiftNode.d.ts

@@ -1,24 +0,0 @@
-import TextureNode from '../accessors/TextureNode.js';
-import TempNode from '../core/TempNode.js';
-import UniformNode from '../core/UniformNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-export default class RGBShiftNode extends TempNode {
-	textureNode: TextureNode;
-	amount: UniformNode<number>;
-	angle: UniformNode<number>;
-
-	constructor(textureNode: TextureNode, amount?: number, angle?: number);
-
-	getTextureNode(): TextureNode;
-
-	setSize(width: number, height: number): void;
-}
-
-export const rgbShift: (node: NodeRepresentation, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		rgbShift: typeof rgbShift;
-	}
-}

package/three/src/nodes/display/RenderOutputNode.d.ts

@@ -1,24 +0,0 @@
-import { ColorSpace, ToneMapping } from '../../constants.js';
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
-
-declare class RenderOutputNode extends TempNode {
-	colorNode: Node;
-	toneMapping: ToneMapping | null;
-	outputColorSpace: ColorSpace | null;
-
-	readonly isRenderOutput: true;
-
-	constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null);
-}
-
-export default RenderOutputNode;
-
-export const renderOutput: (color: NodeRepresentation, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null) => ShaderNodeObject<RenderOutputNode>;
-
-declare module '../shadernode/ShaderNode.js' {
-	interface NodeElements {
-		renderOutput: typeof renderOutput;
-	}
-}