@needle-tools/three 0.169.12 → 0.169.13

package/types/src/renderers/common/RenderObject.d.ts

@@ -0,0 +1,94 @@
+import { Camera } from "../../cameras/Camera.js";
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
+import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import NodeMaterialObserver from "../../materials/nodes/manager/NodeMaterialObserver.js";
+import { LightsNode } from "../../nodes/Nodes.js";
+import { Scene } from "../../scenes/Scene.js";
+import BindGroup from "./BindGroup.js";
+import BundleGroup from "./BundleGroup.js";
+import ClippingContext from "./ClippingContext.js";
+import Geometries from "./Geometries.js";
+import NodeBuilderState from "./nodes/NodeBuilderState.js";
+import Nodes from "./nodes/Nodes.js";
+import RenderContext from "./RenderContext.js";
+import Renderer from "./Renderer.js";
+import RenderPipeline from "./RenderPipeline.js";
+export default class RenderObject {
+    _nodes: Nodes;
+    _geometries: Geometries;
+    id: number;
+    renderer: Renderer;
+    object: Object3D;
+    material: Material;
+    scene: Scene;
+    camera: Camera;
+    lightsNode: LightsNode;
+    context: RenderContext;
+    geometry: BufferGeometry;
+    version: number;
+    drawRange: {
+        start: number;
+        count: number;
+    } | null;
+    attributes: Array<BufferAttribute | InterleavedBufferAttribute> | null;
+    pipeline: RenderPipeline | null;
+    vertexBuffers: Array<BufferAttribute | InterleavedBuffer> | null;
+    drawParams: {
+        vertexCount: number;
+        firstVertex: number;
+        instanceCount: number;
+        firstInstance: number;
+    } | null;
+    bundle: BundleGroup | null;
+    clippingContext: ClippingContext;
+    clippingContextVersion: number;
+    initialNodesCacheKey: string;
+    initialCacheKey: string;
+    _nodeBuilderState: NodeBuilderState | null;
+    _bindings: BindGroup[] | null;
+    _monitor: NodeMaterialObserver | null;
+    onDispose: (() => void) | null;
+    readonly isRenderObject: true;
+    onMaterialDispose: () => void;
+    constructor(
+        nodes: Nodes,
+        geometries: Geometries,
+        renderer: Renderer,
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        renderContext: RenderContext,
+    );
+    updateClipping(parent: ClippingContext): void;
+    get clippingNeedsUpdate(): boolean;
+    getNodeBuilderState(): NodeBuilderState;
+    getMonitor(): NodeMaterialObserver;
+    getBindings(): BindGroup[];
+    getIndex(): BufferAttribute | null;
+    getChainArray(): readonly [
+        Object3D<import("../../core/Object3D.js").Object3DEventMap>,
+        Material,
+        RenderContext,
+        LightsNode,
+    ];
+    getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];
+    getVertexBuffers(): (InterleavedBuffer | BufferAttribute)[] | null;
+    getDrawParameters(): {
+        vertexCount: number;
+        firstVertex: number;
+        instanceCount: number;
+        firstInstance: number;
+    } | null;
+    getGeometryCacheKey(): string;
+    getMaterialCacheKey(): number;
+    get needsUpdate(): boolean;
+    getDynamicCacheKey(): string;
+    getCacheKey(): string;
+    dispose(): void;
+}

package/types/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/types/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/types/src/renderers/common/Renderer.d.ts

@@ -0,0 +1,296 @@
+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 MRTNode from "../../nodes/core/MRTNode.js";
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import LightsNode from "../../nodes/lighting/LightsNode.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 NodeLibrary from "./nodes/NodeLibrary.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";
+interface Rectangle {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface RendererParameters {
+    logarithmicDepthBuffer?: boolean | undefined;
+    alpha?: boolean | undefined;
+    antialias?: boolean | undefined;
+    samples?: number | undefined;
+    getFallback?: ((error: unknown) => Backend) | null | 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;
+    nodes: {
+        library: NodeLibrary;
+    };
+    _getFallback: ((error: unknown) => Backend) | null;
+    _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;
+        getShaderAsync: (scene: Scene, camera: Camera, object: Object3D) => Promise<{
+            fragmentShader: string | null;
+            vertexShader: string | null;
+        }>;
+    };
+    localClippingEnabled?: boolean | undefined;
+    constructor(backend: Backend, parameters?: RendererParameters);
+    init(): Promise<void>;
+    get coordinateSystem(): import("../../constants.js").CoordinateSystem;
+    compileAsync(scene: Object3D, camera: Camera, targetScene?: Object3D | 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 currentToneMapping(): ToneMapping;
+    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, rectangle?: Rectangle | null): 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,
+        faceIndex?: 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,
+        passId?: string,
+    ): void;
+    get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
+    get compile(): (scene: Object3D, camera: Camera, targetScene?: Object3D | null) => Promise<void>;
+}
+export default Renderer;

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

@@ -0,0 +1,33 @@
+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;
+    generation: number | null;
+
+    readonly isSampledTexture: true;
+
+    constructor(name: string, texture: Texture | null);
+
+    needsBindingsUpdate(generation: number): 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/types/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/types/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/types/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/types/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/types/src/renderers/common/Textures.d.ts

@@ -0,0 +1,68 @@
+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;
+    generation?: number;
+}
+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/types/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/types/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/types/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;