@nativescript/canvas-three 2.0.0-webgpu.25 → 2.0.0-webgpu.27

package/three/src/renderers/common/RenderObjects.d.ts

@@ -0,0 +1,62 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
+import { Scene } from "../../scenes/Scene.js";
+import Bindings from "./Bindings.js";
+import ChainMap from "./ChainMap.js";
+import Geometries from "./Geometries.js";
+import Info from "./Info.js";
+import Nodes from "./nodes/Nodes.js";
+import Pipelines from "./Pipelines.js";
+import RenderContext from "./RenderContext.js";
+import Renderer from "./Renderer.js";
+import RenderObject from "./RenderObject.js";
+declare class RenderObjects {
+    renderer: Renderer;
+    nodes: Nodes;
+    geometries: Geometries;
+    pipelines: Pipelines;
+    bindings: Bindings;
+    info: Info;
+    chainMaps: {
+        [passId: string]: ChainMap<readonly [Object3D, Material, RenderContext, LightsNode], RenderObject>;
+    };
+    constructor(
+        renderer: Renderer,
+        nodes: Nodes,
+        geometries: Geometries,
+        pipelines: Pipelines,
+        bindings: Bindings,
+        info: Info,
+    );
+    get(
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        renderContext: RenderContext,
+        passId: string | undefined,
+    ): RenderObject;
+    getChainMap(
+        passId?: string,
+    ): ChainMap<
+        readonly [Object3D<import("../../core/Object3D.js").Object3DEventMap>, Material, RenderContext, LightsNode],
+        RenderObject
+    >;
+    dispose(): void;
+    createRenderObject(
+        nodes: Nodes,
+        geometries: Geometries,
+        renderer: Renderer,
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        renderContext: RenderContext,
+        passId: string | undefined,
+    ): RenderObject;
+}
+export default RenderObjects;

package/three/src/renderers/common/RenderPipeline.d.ts

@@ -0,0 +1,8 @@
+import Pipeline from "./Pipeline.js";
+import ProgrammableStage from "./ProgrammableStage.js";
+declare class RenderPipeline extends Pipeline {
+    vertexProgram: ProgrammableStage;
+    fragmentProgram: ProgrammableStage;
+    constructor(cacheKey: string, vertexProgram: ProgrammableStage, fragmentProgram: ProgrammableStage);
+}
+export default RenderPipeline;

package/three/src/renderers/common/Renderer.d.ts

@@ -0,0 +1,277 @@
+import { Camera } from "../../cameras/Camera.js";
+import { ColorSpace, ShadowMapType, ToneMapping } from "../../constants.js";
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { BufferGeometry, GeometryGroup } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Material } from "../../materials/Material.js";
+import { Box2 } from "../../math/Box2.js";
+import { Color } from "../../math/Color.js";
+import { Plane } from "../../math/Plane.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector4 } from "../../math/Vector4.js";
+import { ComputeNode, LightsNode, MRTNode } from "../../nodes/Nodes.js";
+import { Scene } from "../../scenes/Scene.js";
+import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
+import { Texture } from "../../textures/Texture.js";
+import Animation from "./Animation.js";
+import Attributes from "./Attributes.js";
+import Backend from "./Backend.js";
+import Background from "./Background.js";
+import Bindings from "./Bindings.js";
+import Color4 from "./Color4.js";
+import Geometries from "./Geometries.js";
+import Info from "./Info.js";
+import Nodes from "./nodes/Nodes.js";
+import Pipelines from "./Pipelines.js";
+import QuadMesh from "./QuadMesh.js";
+import RenderBundle from "./RenderBundle.js";
+import RenderBundles from "./RenderBundles.js";
+import RenderContext from "./RenderContext.js";
+import RenderContexts from "./RenderContexts.js";
+import RenderList, { Bundle, RenderItem } from "./RenderList.js";
+import RenderLists from "./RenderLists.js";
+import RenderObjects from "./RenderObjects.js";
+import Textures from "./Textures.js";
+export interface RendererParameters {
+    logarithmicDepthBuffer?: boolean | undefined;
+    alpha?: boolean | undefined;
+    antialias?: boolean | undefined;
+    samples?: number | undefined;
+}
+declare class Renderer {
+    readonly isRenderer: true;
+    domElement: HTMLCanvasElement;
+    backend: Backend;
+    samples: number;
+    autoClear: boolean;
+    autoClearColor: boolean;
+    autoClearDepth: boolean;
+    autoClearStencil: boolean;
+    alpha: boolean;
+    logarithmicDepthBuffer: boolean;
+    outputColorSpace: ColorSpace;
+    toneMapping: ToneMapping;
+    toneMappingExposure: number;
+    sortObjects: boolean;
+    depth: boolean;
+    stencil: boolean;
+    clippingPlanes: readonly Plane[];
+    info: Info;
+    _pixelRatio: number;
+    _width: number;
+    _height: number;
+    _viewport: Vector4;
+    _scissor: Vector4;
+    _scissorTest: boolean;
+    _attributes: Attributes | null;
+    _geometries: Geometries | null;
+    _nodes: Nodes | null;
+    _animation: Animation | null;
+    _bindings: Bindings | null;
+    _objects: RenderObjects | null;
+    _pipelines: Pipelines | null;
+    _bundles: RenderBundles | null;
+    _renderLists: RenderLists | null;
+    _renderContexts: RenderContexts | null;
+    _textures: Textures | null;
+    _background: Background | null;
+    _quad: QuadMesh;
+    _currentRenderContext: RenderContext | null;
+    _opaqueSort: ((a: RenderItem, b: RenderItem) => number) | null;
+    _transparentSort: ((a: RenderItem, b: RenderItem) => number) | null;
+    _frameBufferTarget: RenderTarget | null;
+    _clearColor: Color4;
+    _clearDepth: number;
+    _clearStencil: number;
+    _renderTarget: RenderTarget | null;
+    _activeCubeFace: number;
+    _activeMipmapLevel: number;
+    _mrt: MRTNode | null;
+    _renderObjectFunction:
+        | ((
+            object: Object3D,
+            scene: Scene,
+            camera: Camera,
+            geometry: BufferGeometry,
+            material: Material,
+            group: GeometryGroup,
+            lightsNode: LightsNode,
+        ) => void)
+        | null;
+    _currentRenderObjectFunction:
+        | ((
+            object: Object3D,
+            scene: Scene,
+            camera: Camera,
+            geometry: BufferGeometry,
+            material: Material,
+            group: GeometryGroup,
+            lightsNode: LightsNode,
+        ) => void)
+        | null;
+    _currentRenderBundle: RenderBundle | null;
+    _handleObjectFunction: (
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        group: GeometryGroup,
+        passId?: string,
+    ) => void;
+    _initialized: boolean;
+    _initPromise: Promise<void> | null;
+    _compilationPromises: Promise<void>[] | null;
+    transparent: boolean;
+    opaque: boolean;
+    shadowMap: {
+        enabled: boolean;
+        type: ShadowMapType | null;
+    };
+    xr: {
+        enabled: boolean;
+    };
+    debug: {
+        checkShaderErrors: boolean;
+        onShaderError:
+            | ((
+                gl: WebGL2RenderingContext,
+                programGPU: WebGLProgram,
+                glVertexShader: WebGLShader,
+                glFragmentShader: WebGLShader,
+            ) => void)
+            | null;
+    };
+    localClippingEnabled?: boolean | undefined;
+    constructor(backend: Backend, parameters?: RendererParameters);
+    init(): Promise<void>;
+    get coordinateSystem(): import("../../constants.js").CoordinateSystem;
+    compileAsync(scene: Scene, camera: Camera, targetScene?: Scene | null): Promise<void>;
+    renderAsync(scene: Scene, camera: Camera): Promise<void>;
+    setMRT(mrt: MRTNode | null): this;
+    getMRT(): MRTNode | null;
+    _renderBundle(bundle: Bundle, sceneRef: Scene, lightsNode: LightsNode): void;
+    render(scene: Scene, camera: Camera): Promise<void> | undefined;
+    _getFrameBufferTarget(): RenderTarget<Texture> | null;
+    _renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext;
+    getMaxAnisotropy(): number;
+    getActiveCubeFace(): number;
+    getActiveMipmapLevel(): number;
+    setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): Promise<void>;
+    getArrayBufferAsync(attribute: BufferAttribute): Promise<ArrayBuffer>;
+    getContext(): void;
+    getPixelRatio(): number;
+    getDrawingBufferSize(target: Vector2): Vector2;
+    getSize(target: Vector2): Vector2;
+    setPixelRatio(value?: number): void;
+    setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
+    setSize(width: number, height: number, updateStyle?: boolean): void;
+    setOpaqueSort(method: ((a: RenderItem, b: RenderItem) => number) | null): void;
+    setTransparentSort(method: ((a: RenderItem, b: RenderItem) => number) | null): void;
+    getScissor(target: Vector4): Vector4;
+    setScissor(x: Vector4): void;
+    setScissor(x: number, y: number, width: number, height: number): void;
+    getScissorTest(): boolean;
+    setScissorTest(boolean: boolean): void;
+    getViewport(target: Vector4): Vector4;
+    setViewport(x: Vector4): void;
+    setViewport(x: number, y: number, width: number, height: number, minDepth?: number, maxDepth?: number): void;
+    getClearColor(target: Color4): Color4;
+    setClearColor(color: Color, alpha?: number): void;
+    getClearAlpha(): number;
+    setClearAlpha(alpha: number): void;
+    getClearDepth(): number;
+    setClearDepth(depth: number): void;
+    getClearStencil(): number;
+    setClearStencil(stencil: number): void;
+    isOccluded(object: Object3D): boolean | null;
+    clear(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void> | undefined;
+    clearColor(): Promise<void> | undefined;
+    clearDepth(): Promise<void> | undefined;
+    clearStencil(): Promise<void> | undefined;
+    clearAsync(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void>;
+    clearColorAsync(): Promise<void>;
+    clearDepthAsync(): Promise<void>;
+    clearStencilAsync(): Promise<void>;
+    get currentColorSpace(): ColorSpace;
+    dispose(): void;
+    setRenderTarget(renderTarget: RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
+    getRenderTarget(): RenderTarget<Texture> | null;
+    setRenderObjectFunction(
+        renderObjectFunction:
+            | ((
+                object: Object3D,
+                scene: Scene,
+                camera: Camera,
+                geometry: BufferGeometry,
+                material: Material,
+                group: GeometryGroup,
+                lightsNode: LightsNode,
+            ) => void)
+            | null,
+    ): void;
+    getRenderObjectFunction():
+        | ((
+            object: Object3D,
+            scene: Scene,
+            camera: Camera,
+            geometry: BufferGeometry,
+            material: Material,
+            group: GeometryGroup,
+            lightsNode: LightsNode,
+        ) => void)
+        | null;
+    computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
+    hasFeatureAsync(name: string): Promise<void>;
+    hasFeature(name: string): false | void;
+    copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
+    copyTextureToTexture(
+        srcTexture: Texture,
+        dstTexture: Texture,
+        srcRegion?: Box2 | null,
+        dstPosition?: Vector2 | null,
+        level?: number,
+    ): void;
+    readRenderTargetPixelsAsync(
+        renderTarget: RenderTarget,
+        x: number,
+        y: number,
+        width: number,
+        height: number,
+        index?: number,
+    ): Promise<import("../../core/BufferAttribute.js").TypedArray>;
+    _projectObject(object: Object3D, camera: Camera, groupOrder: number, renderList: RenderList): void;
+    _renderBundles(bundles: Bundle[], sceneRef: Scene, lightsNode: LightsNode): void;
+    _renderObjects(renderList: RenderItem[], camera: Camera, scene: Scene, lightsNode: LightsNode): void;
+    renderObject(
+        object: Object3D,
+        scene: Scene,
+        camera: Camera,
+        geometry: BufferGeometry,
+        material: Material,
+        group: GeometryGroup,
+        lightsNode: LightsNode,
+    ): void;
+    _renderObjectDirect(
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        group: GeometryGroup,
+        passId?: string,
+    ): void;
+    _createObjectPipeline(
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        group: GeometryGroup,
+        passId?: string,
+    ): void;
+    get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
+    get compile(): (scene: Scene, camera: Camera, targetScene?: Scene | null) => Promise<void>;
+}
+export default Renderer;

package/three/src/renderers/common/SampledTexture.d.ts

@@ -0,0 +1,27 @@
+import { Texture } from "../../textures/Texture.js";
+import Binding from "./Binding.js";
+
+declare class SampledTexture extends Binding {
+    id: number;
+    texture: Texture | null;
+    version: number;
+    store: boolean;
+    readonly isSampledTexture: true;
+    constructor(name: string, texture: Texture | null);
+    get needsBindingsUpdate(): boolean;
+    update(): boolean;
+}
+
+declare class SampledArrayTexture extends SampledTexture {
+    readonly isSampledArrayTexture: true;
+}
+
+declare class Sampled3DTexture extends SampledTexture {
+    readonly isSampled3DTexture: true;
+}
+
+declare class SampledCubeTexture extends SampledTexture {
+    readonly isSampledCubeTexture: true;
+}
+
+export { Sampled3DTexture, SampledArrayTexture, SampledCubeTexture, SampledTexture };

package/three/src/renderers/common/Sampler.d.ts

@@ -0,0 +1,11 @@
+import TextureNode from "../../nodes/accessors/TextureNode.js";
+import Binding from "./Binding.js";
+
+declare class Sampler extends Binding {
+    texture: TextureNode | null;
+    version: number;
+    readonly isSampler: true;
+    constructor(name: string, texture: TextureNode | null);
+}
+
+export default Sampler;

package/three/src/renderers/common/StorageBufferAttribute.d.ts

@@ -0,0 +1,7 @@
+import { BufferAttribute, TypedArray } from "../../core/BufferAttribute.js";
+
+export default class StorageBufferAttribute extends BufferAttribute {
+    readonly isStorageBufferAttribute: true;
+
+    constructor(array: TypedArray, itemSize: number);
+}

package/three/src/renderers/common/StorageInstancedBufferAttribute.d.ts

@@ -0,0 +1,8 @@
+import { TypedArray } from "../../core/BufferAttribute.js";
+import { InstancedBufferAttribute } from "../../core/InstancedBufferAttribute.js";
+
+export default class StorageInstancedBufferAttribute extends InstancedBufferAttribute {
+    readonly isStorageInstancedBufferAttribute: true;
+
+    constructor(array: TypedArray | number, itemSize: number);
+}

package/three/src/renderers/common/StorageTexture.d.ts

@@ -0,0 +1,5 @@
+import { Texture } from "../../textures/Texture.js";
+
+export default class StorageTexture extends Texture {
+    constructor(width?: number, height?: number);
+}

package/three/src/renderers/common/Textures.d.ts

@@ -0,0 +1,67 @@
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { DepthTexture } from "../../textures/DepthTexture.js";
+import { Texture } from "../../textures/Texture.js";
+import Backend from "./Backend.js";
+import DataMap from "./DataMap.js";
+import Info from "./Info.js";
+import Renderer from "./Renderer.js";
+type SizeVector3Unitialized = Vector3 & {
+    width?: number;
+    height?: number;
+    depth?: number;
+};
+type SizeVector3 = Vector3 & {
+    width: number;
+    height: number;
+    depth: number;
+};
+interface RenderTargetData {
+    depthTextureMips?: {
+        [activeMipmapLevel: number]: DepthTexture;
+    };
+    width?: number;
+    height?: number;
+    textures?: Texture[];
+    depthTexture?: DepthTexture;
+    depth?: boolean;
+    stencil?: boolean;
+    renderTarget?: RenderTarget;
+    sampleCount?: number;
+    initialized?: boolean;
+}
+interface TextureData {
+    initialized?: boolean;
+    version?: number;
+    isDefaultTexture?: boolean;
+}
+interface TextureOptions {
+    width?: number;
+    height?: number;
+    depth?: number;
+    needsMipmaps?: boolean;
+    levels?: number;
+}
+declare class Textures extends DataMap<{
+    renderTarget: {
+        key: RenderTarget;
+        value: RenderTargetData;
+    };
+    texture: {
+        key: Texture;
+        value: TextureData;
+    };
+}> {
+    renderer: Renderer;
+    backend: Backend;
+    info: Info;
+    constructor(renderer: Renderer, backend: Backend, info: Info);
+    updateRenderTarget(renderTarget: RenderTarget, activeMipmapLevel?: number): void;
+    updateTexture(texture: Texture, options?: TextureOptions): void;
+    getSize(texture: Texture, target?: SizeVector3Unitialized): SizeVector3;
+    getMipLevels(texture: Texture, width: number, height: number): number;
+    needsMipmaps(texture: Texture): boolean;
+    isEnvironmentTexture(texture: Texture): boolean;
+    _destroyTexture(texture: Texture): void;
+}
+export default Textures;

package/three/src/renderers/common/Uniform.d.ts

@@ -0,0 +1,45 @@
+import { Color } from "../../math/Color.js";
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Vector4 } from "../../math/Vector4.js";
+declare class Uniform<TValue> {
+    name: string;
+    value: TValue;
+    boundary: number;
+    itemSize: number;
+    offset: number;
+    constructor(name: string, value: TValue);
+    setValue(value: TValue): void;
+    getValue(): TValue;
+}
+declare class NumberUniform extends Uniform<number> {
+    readonly isNumberUniform: true;
+    constructor(name: string, value?: number);
+}
+declare class Vector2Uniform extends Uniform<Vector2> {
+    readonly isVector2Uniform: true;
+    constructor(name: string, value?: Vector2);
+}
+declare class Vector3Uniform extends Uniform<Vector3> {
+    readonly isVector3Uniform: true;
+    constructor(name: string, value?: Vector3);
+}
+declare class Vector4Uniform extends Uniform<Vector4> {
+    readonly isVector4Uniform: true;
+    constructor(name: string, value?: Vector4);
+}
+declare class ColorUniform extends Uniform<Color> {
+    readonly isColorUniform: true;
+    constructor(name: string, value?: Color);
+}
+declare class Matrix3Uniform extends Uniform<Matrix3> {
+    readonly isMatrix3Uniform: true;
+    constructor(name: string, value?: Matrix3);
+}
+declare class Matrix4Uniform extends Uniform<Matrix4> {
+    readonly isMatrix4Uniform: true;
+    constructor(name: string, value?: Matrix4);
+}
+export { ColorUniform, Matrix3Uniform, Matrix4Uniform, NumberUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform };

package/three/src/renderers/common/UniformBuffer.d.ts

@@ -0,0 +1,6 @@
+import Buffer from "./Buffer.js";
+declare class UniformBuffer extends Buffer {
+    readonly isUniformBuffer: true;
+    constructor(name?: string, buffer?: null);
+}
+export default UniformBuffer;

package/three/src/renderers/common/UniformsGroup.d.ts

@@ -0,0 +1,32 @@
+import {
+    ColorNodeUniform,
+    Matrix3NodeUniform,
+    Matrix4NodeUniform,
+    NodeUniformGPU,
+    NumberNodeUniform,
+    Vector2NodeUniform,
+    Vector3NodeUniform,
+    Vector4NodeUniform,
+} from "./nodes/NodeUniform.js";
+import UniformBuffer from "./UniformBuffer.js";
+declare class UniformsGroup extends UniformBuffer {
+    readonly isUniformsGroup: true;
+    _values: number[] | null;
+    uniforms: NodeUniformGPU[];
+    constructor(name?: string);
+    addUniform(uniform: NodeUniformGPU): this;
+    removeUniform(uniform: NodeUniformGPU): this;
+    get values(): number[];
+    get buffer(): Float32Array;
+    get byteLength(): number;
+    update(): boolean;
+    updateByType(uniform: NodeUniformGPU): boolean | undefined;
+    updateNumber(uniform: NumberNodeUniform): boolean;
+    updateVector2(uniform: Vector2NodeUniform): boolean;
+    updateVector3(uniform: Vector3NodeUniform): boolean;
+    updateVector4(uniform: Vector4NodeUniform): boolean;
+    updateColor(uniform: ColorNodeUniform): boolean;
+    updateMatrix3(uniform: Matrix3NodeUniform): boolean;
+    updateMatrix4(uniform: Matrix4NodeUniform): boolean;
+}
+export default UniformsGroup;

package/three/src/renderers/common/extras/PMREMGenerator.d.ts

@@ -0,0 +1,9 @@
+import { RenderTarget } from "../../../core/RenderTarget.js";
+import { Scene } from "../../../scenes/Scene.js";
+import Renderer from "../Renderer.js";
+
+export default class PMREMGenerator {
+    constructor(renderer: Renderer);
+
+    fromScene(scene: Scene, sigma?: number, near?: number, far?: number): RenderTarget;
+}

package/three/src/renderers/common/nodes/NodeBuilderState.d.ts

@@ -0,0 +1,30 @@
+import Node from "../../../nodes/core/Node.js";
+import NodeAttribute from "../../../nodes/core/NodeAttribute.js";
+import BindGroup from "../BindGroup.js";
+declare class NodeBuilderState {
+    vertexShader: string | null;
+    fragmentShader: string | null;
+    computeShader: string | null;
+    transforms: never[];
+    nodeAttributes: NodeAttribute[];
+    bindings: BindGroup[];
+    updateNodes: Node[];
+    updateBeforeNodes: Node[];
+    updateAfterNodes: Node[];
+    instanceBindGroups: boolean;
+    usedTimes: number;
+    constructor(
+        vertexShader: string | null,
+        fragmentShader: string | null,
+        computeShader: string | null,
+        nodeAttributes: NodeAttribute[],
+        bindings: BindGroup[],
+        updateNodes: Node[],
+        updateBeforeNodes: Node[],
+        updateAfterNodes: Node[],
+        instanceBindGroups?: boolean,
+        transforms?: never[],
+    );
+    createBindings(): BindGroup[];
+}
+export default NodeBuilderState;

package/three/src/renderers/common/nodes/NodeSampledTexture.d.ts

@@ -0,0 +1,29 @@
+import TextureNode from "../../../nodes/accessors/TextureNode.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import { SampledTexture } from "../SampledTexture.js";
+
+type GPUStorageTextureAccess = "read-only" | "read-write" | "write-only";
+
+declare class NodeSampledTexture extends SampledTexture {
+    textureNode: TextureNode | undefined;
+    groupNode: UniformGroupNode;
+    access: "read-write" | "read-only" | "write-only";
+    constructor(
+        name: string,
+        textureNode: TextureNode | undefined,
+        groupNode: UniformGroupNode,
+        access: GPUStorageTextureAccess | null,
+    );
+    get needsBindingsUpdate(): boolean;
+    update(): boolean;
+}
+
+declare class NodeSampledCubeTexture extends NodeSampledTexture {
+    readonly isSampledCubeTexture: true;
+}
+
+declare class NodeSampledTexture3D extends NodeSampledTexture {
+    readonly isSampledTexture3D = true;
+}
+
+export { NodeSampledCubeTexture, NodeSampledTexture, NodeSampledTexture3D };

package/three/src/renderers/common/nodes/NodeSampler.d.ts

@@ -0,0 +1,12 @@
+import TextureNode from "../../../nodes/accessors/TextureNode.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import Sampler from "../Sampler.js";
+
+declare class NodeSampler extends Sampler {
+    textureNode: TextureNode | undefined;
+    groupNode: UniformGroupNode;
+    constructor(name: string, textureNode: TextureNode | undefined, groupNode: UniformGroupNode);
+    update(): void;
+}
+
+export default NodeSampler;