gaussian-splat-lite 1.2.2 → 1.3.0

package/dist/types/rendering/MaterialState.d.cts

@@ -0,0 +1,9 @@
+import type * as THREE from "three";
+/** Keeps public material state and explicit shader updates across variants. */
+export declare class MaterialState {
+  private versions;
+  constructor(material: THREE.Material);
+  sync(target: THREE.Material, source: THREE.Material): void;
+  /** Records updates made by the renderer itself. */
+  record(material: THREE.Material): void;
+}

package/dist/types/rendering/MaterialState.d.ts

@@ -0,0 +1,9 @@
+import type * as THREE from "three";
+/** Keeps public material state and explicit shader updates across variants. */
+export declare class MaterialState {
+  private versions;
+  constructor(material: THREE.Material);
+  sync(target: THREE.Material, source: THREE.Material): void;
+  /** Records updates made by the renderer itself. */
+  record(material: THREE.Material): void;
+}

package/dist/types/rendering/SortCenterCache.d.cts

@@ -1,21 +1,21 @@
-import { SplatAccumulator } from './SplatAccumulator.cjs';
+import type { SplatAccumulator } from "./SplatAccumulator.cjs";
 /** Tracks raw-center and matrix revisions cached by the sort worker. */
 export declare class SortCenterCache {
-    private entries;
-    private freeMeshIds;
-    private nextMeshId;
-    private allocateMeshId;
-    dispose(): void;
-    prepare(current: SplatAccumulator): {
-        payload: {
-            centerUpdateRangeIndices: Uint32Array<ArrayBuffer>;
-            updateCenters: Float32Array<ArrayBuffer>;
-            matrixUpdateRangeIndices: Uint32Array<ArrayBuffer>;
-            updateMatrices: Float64Array<ArrayBuffer>;
-            rangeMeshIds: Uint32Array<ArrayBuffer>;
-            rangeBases: Uint32Array<ArrayBuffer>;
-            rangeCounts: Uint32Array<ArrayBuffer>;
-        };
-        commit: () => void;
+  private entries;
+  private freeMeshIds;
+  private nextMeshId;
+  private allocateMeshId;
+  dispose(): void;
+  prepare(current: SplatAccumulator): {
+    payload: {
+      centerUpdateRangeIndices: Uint32Array<ArrayBuffer>;
+      updateCenters: Float32Array<ArrayBuffer>;
+      matrixUpdateRangeIndices: Uint32Array<ArrayBuffer>;
+      updateMatrices: Float64Array<ArrayBuffer>;
+      rangeMeshIds: Uint32Array<ArrayBuffer>;
+      rangeBases: Uint32Array<ArrayBuffer>;
+      rangeCounts: Uint32Array<ArrayBuffer>;
     };
+    commit: () => void;
+  };
 }

package/dist/types/rendering/SortCenterCache.d.ts

@@ -1,21 +1,21 @@
-import { SplatAccumulator } from './SplatAccumulator';
+import type { SplatAccumulator } from "./SplatAccumulator.js";
 /** Tracks raw-center and matrix revisions cached by the sort worker. */
 export declare class SortCenterCache {
-    private entries;
-    private freeMeshIds;
-    private nextMeshId;
-    private allocateMeshId;
-    dispose(): void;
-    prepare(current: SplatAccumulator): {
-        payload: {
-            centerUpdateRangeIndices: Uint32Array<ArrayBuffer>;
-            updateCenters: Float32Array<ArrayBuffer>;
-            matrixUpdateRangeIndices: Uint32Array<ArrayBuffer>;
-            updateMatrices: Float64Array<ArrayBuffer>;
-            rangeMeshIds: Uint32Array<ArrayBuffer>;
-            rangeBases: Uint32Array<ArrayBuffer>;
-            rangeCounts: Uint32Array<ArrayBuffer>;
-        };
-        commit: () => void;
+  private entries;
+  private freeMeshIds;
+  private nextMeshId;
+  private allocateMeshId;
+  dispose(): void;
+  prepare(current: SplatAccumulator): {
+    payload: {
+      centerUpdateRangeIndices: Uint32Array<ArrayBuffer>;
+      updateCenters: Float32Array<ArrayBuffer>;
+      matrixUpdateRangeIndices: Uint32Array<ArrayBuffer>;
+      updateMatrices: Float64Array<ArrayBuffer>;
+      rangeMeshIds: Uint32Array<ArrayBuffer>;
+      rangeBases: Uint32Array<ArrayBuffer>;
+      rangeCounts: Uint32Array<ArrayBuffer>;
     };
+    commit: () => void;
+  };
 }

package/dist/types/rendering/SplatAccumulator.d.cts

@@ -1,86 +1,102 @@
-import { SplatMesh } from '../scene/SplatMesh.cjs';
-import { GaussianSplatCompatibleRenderer } from './rendererUtils.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { SplatMesh } from "../scene/SplatMesh.cjs";
+import type { GaussianSplatCompatibleRenderer } from "./rendererUtils.cjs";
 export type SplatMapping = {
-    node: SplatMesh;
-    matrixWorld: THREE.Matrix4;
-    source: SplatMesh["splats"];
-    version: number;
-    sortVersion: number;
-    centerVersion: number;
-    mappingVersion: number;
-    base: number;
-    count: number;
+  node: SplatMesh;
+  matrixWorld: THREE.Matrix4;
+  source: SplatMesh["splats"];
+  version: number;
+  sortVersion: number;
+  centerVersion: number;
+  mappingVersion: number;
+  base: number;
+  count: number;
 };
 type GenerateUniforms = Record<string, THREE.IUniform>;
 type SplatDataTextures = readonly [THREE.Texture, THREE.Texture];
 export declare class SplatAccumulator {
-    time: number;
-    deltaTime: number;
-    viewOrigin: THREE.Vector3;
-    private readonly previousOrigin;
-    viewDirection: THREE.Vector3;
+  time: number;
+  deltaTime: number;
+  viewOrigin: THREE.Vector3;
+  private readonly previousOrigin;
+  viewDirection: THREE.Vector3;
+  maxSplats: number;
+  numSplats: number;
+  target: THREE.WebGLArrayRenderTarget | null;
+  mapping: SplatMapping[];
+  version: number;
+  mappingVersion: number;
+  private transformScale;
+  private transformQuaternion;
+  private fallbackGenerator;
+  private readonly sceneNodes;
+  private readonly frameContext;
+  constructor();
+  dispose(): void;
+  private disposeStorage;
+  getTextures(): SplatDataTextures;
+  getStochasticSeeds(): THREE.Texture;
+  /** Whether this accumulator was generated for stochastic rendering. */
+  get hasStochasticSeeds(): boolean;
+  /**
+   * Regenerate moved meshes in place, without changing the source ranges used
+   * by an in-flight sort. WebGL backends only.
+   */
+  refreshTransforms(renderer: GaussianSplatCompatibleRenderer): void;
+  ensureGenerate({
+    maxSplats,
+    renderer,
+    shrinkResources,
+    stochasticSeeds,
+  }: {
     maxSplats: number;
-    numSplats: number;
-    target: THREE.WebGLArrayRenderTarget | null;
-    mapping: SplatMapping[];
+    renderer?: GaussianSplatCompatibleRenderer;
+    shrinkResources?: boolean;
+    stochasticSeeds?: boolean;
+  }): boolean;
+  prepareUniforms(
+    mesh: SplatMesh,
+    uniforms: GenerateUniforms,
+    matrixWorld?: THREE.Matrix4,
+  ): void;
+  generate({
+    mesh,
+    base,
+    count,
+    renderer,
+  }: {
+    mesh: SplatMesh;
+    base: number;
+    count: number;
+    renderer: GaussianSplatCompatibleRenderer;
+  }): void;
+  prepareGenerate({
+    renderer,
+    scene,
+    timer,
+    camera,
+    layerCamera,
+    previous,
+    frameCallbacks,
+    shrinkResources,
+    excludedObjects,
+  }: {
+    renderer: GaussianSplatCompatibleRenderer;
+    scene: THREE.Scene;
+    timer: THREE.Timer;
+    camera: THREE.Camera;
+    layerCamera?: THREE.Camera;
+    previous: SplatAccumulator;
+    frameCallbacks?: boolean;
+    shrinkResources?: boolean;
+    excludedObjects?: ReadonlySet<THREE.Object3D>;
+  }): {
     version: number;
-    mappingVersion: number;
-    private transformScale;
-    private transformQuaternion;
-    private fallbackGenerator;
-    constructor();
-    dispose(): void;
-    private disposeStorage;
-    getTextures(): SplatDataTextures;
-    getStochasticSeeds(): THREE.Texture;
-    /** Whether this accumulator was generated for stochastic rendering. */
-    get hasStochasticSeeds(): boolean;
-    /**
-     * Regenerate moved meshes in place, without changing the source ranges used
-     * by an in-flight sort. WebGL backends only.
-     */
-    refreshTransforms(renderer: GaussianSplatCompatibleRenderer): void;
-    generateMapping(splatCounts: number[], compact?: boolean): {
-        maxSplats: number;
-        mapping: {
-            base: number;
-            count: number;
-        }[];
-    };
-    ensureGenerate({ maxSplats, renderer, shrinkResources, stochasticSeeds, }: {
-        maxSplats: number;
-        renderer?: GaussianSplatCompatibleRenderer;
-        shrinkResources?: boolean;
-        stochasticSeeds?: boolean;
-    }): boolean;
-    prepareUniforms(mesh: SplatMesh, uniforms: GenerateUniforms, matrixWorld?: THREE.Matrix4): void;
-    generate({ mesh, base, count, renderer, }: {
-        mesh: SplatMesh;
-        base: number;
-        count: number;
-        renderer: GaussianSplatCompatibleRenderer;
-    }): void;
-    prepareGenerate({ renderer, scene, timer, camera, layerCamera, previous, frameCallbacks, }: {
-        renderer: GaussianSplatCompatibleRenderer;
-        scene: THREE.Scene;
-        timer: THREE.Timer;
-        camera: THREE.Camera;
-        layerCamera?: THREE.Camera;
-        previous: SplatAccumulator;
-        frameCallbacks?: boolean;
-    }): {
-        version: number;
-        sortUpdated: boolean;
-        requiredMaxSplats: number;
-        generate: (shrinkResources?: boolean, stochasticSeeds?: boolean) => void;
-    };
-    checkVersions(other: SplatMapping[]): {
-        splatsUpdated: boolean;
-        mappingUpdated: boolean;
-        sortUpdated: boolean;
-    };
-    static emptyTexture: THREE.DataArrayTexture;
-    static emptyTextures: SplatDataTextures;
+    sortUpdated: boolean;
+    requiredMaxSplats: number;
+    generate: (shrinkResources?: boolean, stochasticSeeds?: boolean) => void;
+  };
+  static emptyTexture: THREE.DataArrayTexture;
+  static emptyTextures: SplatDataTextures;
 }
 export {};

package/dist/types/rendering/SplatAccumulator.d.ts

@@ -1,86 +1,102 @@
-import { SplatMesh } from '../scene/SplatMesh';
-import { GaussianSplatCompatibleRenderer } from './rendererUtils';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { SplatMesh } from "../scene/SplatMesh.js";
+import type { GaussianSplatCompatibleRenderer } from "./rendererUtils.js";
 export type SplatMapping = {
-    node: SplatMesh;
-    matrixWorld: THREE.Matrix4;
-    source: SplatMesh["splats"];
-    version: number;
-    sortVersion: number;
-    centerVersion: number;
-    mappingVersion: number;
-    base: number;
-    count: number;
+  node: SplatMesh;
+  matrixWorld: THREE.Matrix4;
+  source: SplatMesh["splats"];
+  version: number;
+  sortVersion: number;
+  centerVersion: number;
+  mappingVersion: number;
+  base: number;
+  count: number;
 };
 type GenerateUniforms = Record<string, THREE.IUniform>;
 type SplatDataTextures = readonly [THREE.Texture, THREE.Texture];
 export declare class SplatAccumulator {
-    time: number;
-    deltaTime: number;
-    viewOrigin: THREE.Vector3;
-    private readonly previousOrigin;
-    viewDirection: THREE.Vector3;
+  time: number;
+  deltaTime: number;
+  viewOrigin: THREE.Vector3;
+  private readonly previousOrigin;
+  viewDirection: THREE.Vector3;
+  maxSplats: number;
+  numSplats: number;
+  target: THREE.WebGLArrayRenderTarget | null;
+  mapping: SplatMapping[];
+  version: number;
+  mappingVersion: number;
+  private transformScale;
+  private transformQuaternion;
+  private fallbackGenerator;
+  private readonly sceneNodes;
+  private readonly frameContext;
+  constructor();
+  dispose(): void;
+  private disposeStorage;
+  getTextures(): SplatDataTextures;
+  getStochasticSeeds(): THREE.Texture;
+  /** Whether this accumulator was generated for stochastic rendering. */
+  get hasStochasticSeeds(): boolean;
+  /**
+   * Regenerate moved meshes in place, without changing the source ranges used
+   * by an in-flight sort. WebGL backends only.
+   */
+  refreshTransforms(renderer: GaussianSplatCompatibleRenderer): void;
+  ensureGenerate({
+    maxSplats,
+    renderer,
+    shrinkResources,
+    stochasticSeeds,
+  }: {
     maxSplats: number;
-    numSplats: number;
-    target: THREE.WebGLArrayRenderTarget | null;
-    mapping: SplatMapping[];
+    renderer?: GaussianSplatCompatibleRenderer;
+    shrinkResources?: boolean;
+    stochasticSeeds?: boolean;
+  }): boolean;
+  prepareUniforms(
+    mesh: SplatMesh,
+    uniforms: GenerateUniforms,
+    matrixWorld?: THREE.Matrix4,
+  ): void;
+  generate({
+    mesh,
+    base,
+    count,
+    renderer,
+  }: {
+    mesh: SplatMesh;
+    base: number;
+    count: number;
+    renderer: GaussianSplatCompatibleRenderer;
+  }): void;
+  prepareGenerate({
+    renderer,
+    scene,
+    timer,
+    camera,
+    layerCamera,
+    previous,
+    frameCallbacks,
+    shrinkResources,
+    excludedObjects,
+  }: {
+    renderer: GaussianSplatCompatibleRenderer;
+    scene: THREE.Scene;
+    timer: THREE.Timer;
+    camera: THREE.Camera;
+    layerCamera?: THREE.Camera;
+    previous: SplatAccumulator;
+    frameCallbacks?: boolean;
+    shrinkResources?: boolean;
+    excludedObjects?: ReadonlySet<THREE.Object3D>;
+  }): {
     version: number;
-    mappingVersion: number;
-    private transformScale;
-    private transformQuaternion;
-    private fallbackGenerator;
-    constructor();
-    dispose(): void;
-    private disposeStorage;
-    getTextures(): SplatDataTextures;
-    getStochasticSeeds(): THREE.Texture;
-    /** Whether this accumulator was generated for stochastic rendering. */
-    get hasStochasticSeeds(): boolean;
-    /**
-     * Regenerate moved meshes in place, without changing the source ranges used
-     * by an in-flight sort. WebGL backends only.
-     */
-    refreshTransforms(renderer: GaussianSplatCompatibleRenderer): void;
-    generateMapping(splatCounts: number[], compact?: boolean): {
-        maxSplats: number;
-        mapping: {
-            base: number;
-            count: number;
-        }[];
-    };
-    ensureGenerate({ maxSplats, renderer, shrinkResources, stochasticSeeds, }: {
-        maxSplats: number;
-        renderer?: GaussianSplatCompatibleRenderer;
-        shrinkResources?: boolean;
-        stochasticSeeds?: boolean;
-    }): boolean;
-    prepareUniforms(mesh: SplatMesh, uniforms: GenerateUniforms, matrixWorld?: THREE.Matrix4): void;
-    generate({ mesh, base, count, renderer, }: {
-        mesh: SplatMesh;
-        base: number;
-        count: number;
-        renderer: GaussianSplatCompatibleRenderer;
-    }): void;
-    prepareGenerate({ renderer, scene, timer, camera, layerCamera, previous, frameCallbacks, }: {
-        renderer: GaussianSplatCompatibleRenderer;
-        scene: THREE.Scene;
-        timer: THREE.Timer;
-        camera: THREE.Camera;
-        layerCamera?: THREE.Camera;
-        previous: SplatAccumulator;
-        frameCallbacks?: boolean;
-    }): {
-        version: number;
-        sortUpdated: boolean;
-        requiredMaxSplats: number;
-        generate: (shrinkResources?: boolean, stochasticSeeds?: boolean) => void;
-    };
-    checkVersions(other: SplatMapping[]): {
-        splatsUpdated: boolean;
-        mappingUpdated: boolean;
-        sortUpdated: boolean;
-    };
-    static emptyTexture: THREE.DataArrayTexture;
-    static emptyTextures: SplatDataTextures;
+    sortUpdated: boolean;
+    requiredMaxSplats: number;
+    generate: (shrinkResources?: boolean, stochasticSeeds?: boolean) => void;
+  };
+  static emptyTexture: THREE.DataArrayTexture;
+  static emptyTextures: SplatDataTextures;
 }
 export {};

package/dist/types/rendering/SplatGeometry.d.cts

@@ -2,6 +2,6 @@ import * as THREE from "three";
 export declare const SPLATS_PER_INSTANCE = 128;
 /** Repeated quads; position.z identifies the Splat within each instance. */
 export declare class SplatGeometry extends THREE.InstancedBufferGeometry {
-    constructor();
-    setSplatCount(count: number): void;
+  constructor();
+  setSplatCount(count: number): void;
 }

package/dist/types/rendering/SplatGeometry.d.ts

@@ -2,6 +2,6 @@ import * as THREE from "three";
 export declare const SPLATS_PER_INSTANCE = 128;
 /** Repeated quads; position.z identifies the Splat within each instance. */
 export declare class SplatGeometry extends THREE.InstancedBufferGeometry {
-    constructor();
-    setSplatCount(count: number): void;
+  constructor();
+  setSplatCount(count: number): void;
 }

package/dist/types/rendering/StochasticSplatMaterial.d.cts

@@ -0,0 +1,14 @@
+import type { Material } from "three";
+import type { GaussianSplatCompatibleRenderer } from "./rendererUtils.cjs";
+
+/** Registers a stochastic material's four-sample variant factory. */
+export declare function registerStochasticSplatMaterial(
+  material: Material,
+  createVariant: (renderer: GaussianSplatCompatibleRenderer) => Material,
+): void;
+
+/** Shares the Splat shader and uniforms, adding four-sample coverage. */
+export declare function createStochasticSplatVariant(
+  material: Material,
+  renderer: GaussianSplatCompatibleRenderer,
+): Material | null;

package/dist/types/rendering/StochasticSplatMaterial.d.ts

@@ -0,0 +1,14 @@
+import type { Material } from "three";
+import type { GaussianSplatCompatibleRenderer } from "./rendererUtils.js";
+
+/** Registers a stochastic material's four-sample variant factory. */
+export declare function registerStochasticSplatMaterial(
+  material: Material,
+  createVariant: (renderer: GaussianSplatCompatibleRenderer) => Material,
+): void;
+
+/** Shares the Splat shader and uniforms, adding four-sample coverage. */
+export declare function createStochasticSplatVariant(
+  material: Material,
+  renderer: GaussianSplatCompatibleRenderer,
+): Material | null;

package/dist/types/rendering/backend.d.cts

@@ -1,23 +1,35 @@
-import { GaussianSplatCompatibleRenderer } from './rendererUtils.cjs';
-import { SplatNodeMaterial } from './tsl/SplatMaterial.cjs';
-import { Uniforms } from './uniforms.cjs';
-import { WebGLFallbackSplatBackend } from './webgl-fallback/SplatBackend.cjs';
-import { WebGLSplatBackend } from './webgl/SplatBackend.cjs';
-import { WebGPUSplatBackend } from './webgpu/SplatBackend.cjs';
-import * as THREE from "three";
-export type SplatBackend = WebGLSplatBackend | WebGPUSplatBackend | WebGLFallbackSplatBackend;
-export declare function createSplatBackend(renderer: GaussianSplatCompatibleRenderer, uniforms: Uniforms, options: SplatMaterialOptions): SplatBackend;
-export declare function configureSplatOutput(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget | null, uniforms: Uniforms, encodeLinear?: boolean): void;
+import type * as THREE from "three";
+import type { GaussianSplatCompatibleRenderer } from "./rendererUtils.cjs";
+import type { SplatNodeMaterial } from "./tsl/SplatMaterial.cjs";
+import type { Uniforms } from "./uniforms.cjs";
+import type { WebGLFallbackSplatBackend } from "./webgl-fallback/SplatBackend.cjs";
+import type { WebGLSplatBackend } from "./webgl/SplatBackend.cjs";
+import type { WebGPUSplatBackend } from "./webgpu/SplatBackend.cjs";
+export type SplatBackend =
+  | WebGLSplatBackend
+  | WebGPUSplatBackend
+  | WebGLFallbackSplatBackend;
+export declare function createSplatBackend(
+  renderer: GaussianSplatCompatibleRenderer,
+  uniforms: Uniforms,
+  options: SplatMaterialOptions,
+): SplatBackend;
+export declare function configureSplatOutput(
+  renderer: GaussianSplatCompatibleRenderer,
+  target: THREE.RenderTarget | null,
+  uniforms: Uniforms,
+  encodeLinear?: boolean,
+): void;
 export type CPUOrderingUpdate = {
-    ordering: Uint32Array;
-    activeSplats: number;
-    requiredCapacity: number;
-    shrink: boolean;
+  ordering: Uint32Array;
+  activeSplats: number;
+  requiredCapacity: number;
+  shrink: boolean;
 };
 export type SplatMaterial = THREE.ShaderMaterial | SplatNodeMaterial;
 export type SplatMaterialOptions = {
-    premultipliedAlpha: boolean;
-    transparent: boolean;
-    depthTest: boolean;
-    depthWrite: boolean;
+  premultipliedAlpha: boolean;
+  transparent: boolean;
+  depthTest: boolean;
+  depthWrite: boolean;
 };

package/dist/types/rendering/backend.d.ts

@@ -1,23 +1,35 @@
-import { GaussianSplatCompatibleRenderer } from './rendererUtils';
-import { SplatNodeMaterial } from './tsl/SplatMaterial';
-import { Uniforms } from './uniforms';
-import { WebGLFallbackSplatBackend } from './webgl-fallback/SplatBackend';
-import { WebGLSplatBackend } from './webgl/SplatBackend';
-import { WebGPUSplatBackend } from './webgpu/SplatBackend';
-import * as THREE from "three";
-export type SplatBackend = WebGLSplatBackend | WebGPUSplatBackend | WebGLFallbackSplatBackend;
-export declare function createSplatBackend(renderer: GaussianSplatCompatibleRenderer, uniforms: Uniforms, options: SplatMaterialOptions): SplatBackend;
-export declare function configureSplatOutput(renderer: GaussianSplatCompatibleRenderer, target: THREE.RenderTarget | null, uniforms: Uniforms, encodeLinear?: boolean): void;
+import type * as THREE from "three";
+import type { GaussianSplatCompatibleRenderer } from "./rendererUtils.js";
+import type { SplatNodeMaterial } from "./tsl/SplatMaterial.js";
+import type { Uniforms } from "./uniforms.js";
+import type { WebGLFallbackSplatBackend } from "./webgl-fallback/SplatBackend.js";
+import type { WebGLSplatBackend } from "./webgl/SplatBackend.js";
+import type { WebGPUSplatBackend } from "./webgpu/SplatBackend.js";
+export type SplatBackend =
+  | WebGLSplatBackend
+  | WebGPUSplatBackend
+  | WebGLFallbackSplatBackend;
+export declare function createSplatBackend(
+  renderer: GaussianSplatCompatibleRenderer,
+  uniforms: Uniforms,
+  options: SplatMaterialOptions,
+): SplatBackend;
+export declare function configureSplatOutput(
+  renderer: GaussianSplatCompatibleRenderer,
+  target: THREE.RenderTarget | null,
+  uniforms: Uniforms,
+  encodeLinear?: boolean,
+): void;
 export type CPUOrderingUpdate = {
-    ordering: Uint32Array;
-    activeSplats: number;
-    requiredCapacity: number;
-    shrink: boolean;
+  ordering: Uint32Array;
+  activeSplats: number;
+  requiredCapacity: number;
+  shrink: boolean;
 };
 export type SplatMaterial = THREE.ShaderMaterial | SplatNodeMaterial;
 export type SplatMaterialOptions = {
-    premultipliedAlpha: boolean;
-    transparent: boolean;
-    depthTest: boolean;
-    depthWrite: boolean;
+  premultipliedAlpha: boolean;
+  transparent: boolean;
+  depthTest: boolean;
+  depthWrite: boolean;
 };

package/dist/types/rendering/blueNoise.d.cts

@@ -1,3 +1,3 @@
-import * as THREE from "three";
+import type * as THREE from "three";
 /** Tileable 32-frame STBN atlas generated by scripts/generate-blue-noise.js. */
 export declare function createBlueNoiseTexture(): THREE.DataTexture;

package/dist/types/rendering/blueNoise.d.ts

@@ -1,3 +1,3 @@
-import * as THREE from "three";
+import type * as THREE from "three";
 /** Tileable 32-frame STBN atlas generated by scripts/generate-blue-noise.js. */
 export declare function createBlueNoiseTexture(): THREE.DataTexture;