@sparkjsdev/spark 0.1.6 → 0.1.8

package/dist/types/PackedSplats.d.ts

@@ -1,8 +1,22 @@
+import { FullScreenQuad } from 'three/addons/postprocessing/Pass.js';
 import { GsplatGenerator } from './SplatGenerator';
 import { SplatFileType } from './SplatLoader';
 import { DynoProgram, DynoProgramTemplate, DynoUniform } from './dyno';
 import { TPackedSplats } from './dyno/splats';
 import * as THREE from "three";
+export type SplatEncoding = {
+    rgbMin?: number;
+    rgbMax?: number;
+    lnScaleMin?: number;
+    lnScaleMax?: number;
+    sh1Min?: number;
+    sh1Max?: number;
+    sh2Min?: number;
+    sh2Max?: number;
+    sh3Min?: number;
+    sh3Max?: number;
+};
+export declare const DEFAULT_SPLAT_ENCODING: SplatEncoding;
 export type PackedSplatsOptions = {
     url?: string;
     fileBytes?: Uint8Array | ArrayBuffer;
@@ -13,18 +27,24 @@ export type PackedSplatsOptions = {
     numSplats?: number;
     construct?: (splats: PackedSplats) => Promise<void> | void;
     extra?: Record<string, unknown>;
+    splatEncoding?: SplatEncoding;
 };
 export declare class PackedSplats {
     maxSplats: number;
     numSplats: number;
     packedArray: Uint32Array | null;
     extra: Record<string, unknown>;
+    splatEncoding?: SplatEncoding;
     initialized: Promise<PackedSplats>;
     isInitialized: boolean;
     target: THREE.WebGLArrayRenderTarget | null;
     source: THREE.DataArrayTexture | null;
     needsUpdate: boolean;
     dyno: DynoUniform<typeof TPackedSplats, "packedSplats">;
+    dynoRgbMinMaxLnScaleMinMax: DynoUniform<"vec4", "rgbMinMaxLnScaleMinMax">;
+    dynoSh1MinMax: DynoUniform<"vec2", "sh1MinMax">;
+    dynoSh2MinMax: DynoUniform<"vec2", "sh2MinMax">;
+    dynoSh3MinMax: DynoUniform<"vec2", "sh3MinMax">;
     constructor(options?: PackedSplatsOptions);
     reinitialize(options: PackedSplatsOptions): void;
     initialize(options: PackedSplatsOptions): void;
@@ -70,15 +90,13 @@ export declare class PackedSplats {
     };
     static programTemplate: DynoProgramTemplate | null;
     static generatorProgram: Map<GsplatGenerator, DynoProgram>;
-    static geometry: THREE.PlaneGeometry;
-    static mesh: THREE.Mesh<THREE.PlaneGeometry, THREE.RawShaderMaterial, THREE.Object3DEventMap>;
-    static scene: THREE.Scene;
-    static camera: THREE.Camera;
+    static fullScreenQuad: FullScreenQuad;
 }
 export declare const dynoPackedSplats: (packedSplats?: PackedSplats) => DynoPackedSplats;
 export declare class DynoPackedSplats extends DynoUniform<typeof TPackedSplats, "packedSplats", {
     texture: THREE.DataArrayTexture;
     numSplats: number;
+    rgbMinMaxLnScaleMinMax: THREE.Vector4;
 }> {
     packedSplats?: PackedSplats;
     constructor({ packedSplats }?: {

package/dist/types/Readback.d.ts

@@ -1,3 +1,4 @@
+import { FullScreenQuad } from 'three/addons/postprocessing/Pass.js';
 import { Dyno } from './dyno';
 import { DynoProgram, DynoProgramTemplate } from './dyno/program';
 import * as THREE from "three";
@@ -43,8 +44,5 @@ export declare class Readback {
     getTexture(): THREE.DataArrayTexture | undefined;
     static programTemplate: DynoProgramTemplate | null;
     static readbackProgram: Map<Rgba8Readback, DynoProgram>;
-    static geometry: THREE.PlaneGeometry;
-    static mesh: THREE.Mesh<THREE.PlaneGeometry, THREE.RawShaderMaterial, THREE.Object3DEventMap>;
-    static scene: THREE.Scene;
-    static camera: THREE.Camera;
+    static fullScreenQuad: FullScreenQuad;
 }

package/dist/types/SparkRenderer.d.ts

@@ -1,33 +1,139 @@
+import { SplatEncoding } from './PackedSplats';
 import { RgbaArray } from './RgbaArray';
 import { SparkViewpoint, SparkViewpointOptions } from './SparkViewpoint';
 import { SplatAccumulator } from './SplatAccumulator';
 import { SplatGenerator } from './SplatGenerator';
 import * as THREE from "three";
 export type SparkRendererOptions = {
+    /**
+     * Pass in your THREE.WebGLRenderer instance so Spark can perform work
+     * outside the usual render loop. Should be created with antialias: false
+     * (default setting) as WebGL anti-aliasing doesn't improve Gaussian Splatting
+     * rendering and significantly reduces performance.
+     */
     renderer: THREE.WebGLRenderer;
+    /**
+     * Whether to use premultiplied alpha when accumulating splat RGB
+     * @default true
+     */
+    premultipliedAlpha?: boolean;
+    /**
+     * Pass in a THREE.Clock to synchronize time-based effects across different
+     * systems. Alternatively, you can set the SparkRenderer properties time and
+     * deltaTime directly. (default: new THREE.Clock)
+     */
     clock?: THREE.Clock;
+    /**
+     * Controls whether to check and automatically update Gsplat collection after
+     * each frame render.
+     * @default true
+     */
     autoUpdate?: boolean;
+    /**
+     * Controls whether to update the Gsplats before or after rendering. For WebXR
+     * this must be false in order to complete rendering as soon as possible.
+     * @default false
+     */
     preUpdate?: boolean;
+    /**
+     * Distance threshold for SparkRenderer movement triggering a Gsplat update at
+     * the new origin.
+     * @default 1.0
+     */
     originDistance?: number;
+    /**
+     * Maximum standard deviations from the center to render Gaussians. Values
+     * Math.sqrt(5)..Math.sqrt(8) produce good results and can be tweaked for
+     * performance.
+     * @default Math.sqrt(8)
+     */
     maxStdDev?: number;
+    /**
+     * Maximum pixel radius for splat rendering.
+     * @default 512.0
+     */
+    maxPixelRadius?: number;
+    /**
+     * Minimum alpha value for splat rendering.
+     * @default 0.5 * (1.0 / 255.0)
+     */
+    minAlpha?: number;
+    /**
+     * Enable 2D Gaussian splatting rendering ability. When this mode is enabled,
+     * any scale x/y/z component that is exactly 0 (minimum quantized value) results
+     * in the other two non-0 axis being interpreted as an oriented 2D Gaussian Splat,
+     * rather instead of the usual projected 3DGS Z-slice. When reading PLY files,
+     * scale values less than e^-30 will be interpreted as 0.
+     * @default false
+     */
     enable2DGS?: boolean;
+    /**
+     * Scalar value to add to 2D splat covariance diagonal, effectively blurring +
+     * enlarging splats. In scenes trained without the Gsplat anti-aliasing tweak
+     * this value was typically 0.3, but with anti-aliasing it is 0.0
+     * @default 0.0
+     */
     preBlurAmount?: number;
+    /**
+     * Scalar value to add to 2D splat covarianve diagonal, with opacity adjustment
+     * to correctly account for "blurring" when anti-aliasing. Typically 0.3
+     * (equivalent to approx 0.5 pixel radius) in scenes trained with anti-aliasing.
+     */
     blurAmount?: number;
+    /**
+     * Depth-of-field distance to focal plane
+     */
     focalDistance?: number;
+    /**
+     * Full-width angle of aperture opening (in radians), 0.0 to disable
+     * @default 0.0
+     */
     apertureAngle?: number;
+    /**
+     * Modulate Gaussian kernel falloff. 0 means "no falloff, flat shading",
+     * while 1 is the normal Gaussian kernel.
+     * @default 1.0
+     */
     falloff?: number;
+    /**
+     * X/Y clipping boundary factor for Gsplat centers against view frustum.
+     * 1.0 clips any centers that are exactly out of bounds, while 1.4 clips
+     * centers that are 40% beyond the bounds.
+     * @default 1.4
+     */
     clipXY?: number;
+    /**
+     * Parameter to adjust projected splat scale calculation to match other renderers,
+     * similar to the same parameter in the MKellogg 3DGS renderer. Higher values will
+     * tend to sharpen the splats. A value 2.0 can be used to match the behavior of
+     * the PlayCanvas renderer.
+     * @default 1.0
+     */
     focalAdjustment?: number;
+    /**
+     * Configures the SparkViewpointOptions for the default SparkViewpoint
+     * associated with this SparkRenderer. Notable option: sortRadial (sort by
+     * radial distance or Z-depth)
+     */
     view?: SparkViewpointOptions;
+    /**
+     * Override the default splat encoding ranges for the PackedSplats.
+     * (default: undefined)
+     */
+    splatEncoding?: SplatEncoding;
 };
 export declare class SparkRenderer extends THREE.Mesh {
     renderer: THREE.WebGLRenderer;
+    premultipliedAlpha: boolean;
     material: THREE.ShaderMaterial;
     uniforms: ReturnType<typeof SparkRenderer.makeUniforms>;
     autoUpdate: boolean;
     preUpdate: boolean;
+    needsUpdate: boolean;
     originDistance: number;
     maxStdDev: number;
+    maxPixelRadius: number;
+    minAlpha: number;
     enable2DGS: boolean;
     preBlurAmount: number;
     blurAmount: number;
@@ -36,6 +142,7 @@ export declare class SparkRenderer extends THREE.Mesh {
     falloff: number;
     clipXY: number;
     focalAdjustment: number;
+    splatEncoding: SplatEncoding;
     splatTexture: null | {
         enable?: boolean;
         texture?: THREE.Data3DTexture;
@@ -59,6 +166,7 @@ export declare class SparkRenderer extends THREE.Mesh {
     private lastFrame;
     private lastUpdateTime;
     private defaultCameras;
+    private lastStochastic;
     viewpoint: SparkViewpoint;
     private pendingUpdate;
     private envViewpoint;
@@ -88,6 +196,15 @@ export declare class SparkRenderer extends THREE.Mesh {
         maxStdDev: {
             value: number;
         };
+        maxPixelRadius: {
+            value: number;
+        };
+        minAlpha: {
+            value: number;
+        };
+        stochastic: {
+            value: boolean;
+        };
         enable2DGS: {
             value: boolean;
         };
@@ -138,6 +255,9 @@ export declare class SparkRenderer extends THREE.Mesh {
             type: string;
             value: THREE.DataArrayTexture;
         };
+        rgbMinMaxLnScaleMinMax: {
+            value: THREE.Vector4;
+        };
         time: {
             value: number;
         };

package/dist/types/SparkViewpoint.d.ts

@@ -3,21 +3,96 @@ import { SplatAccumulator } from './SplatAccumulator';
 import { SplatGeometry } from './SplatGeometry';
 import * as THREE from "three";
 export type SparkViewpointOptions = {
+    /**
+     * Controls whether to auto-update its sort order whenever the SparkRenderer
+     * updates the Gsplats. If you expect to render/display from this viewpoint
+     * most frames, set this to true.
+     * @default false
+     */
     autoUpdate?: boolean;
+    /**
+     * Set a THREE.Camera for this viewpoint to follow.
+     * @default undefined
+     */
     camera?: THREE.Camera;
+    /**
+     * Set an explicit view-to-world transformation matrix for this viewpoint (equivalent
+     * to camera.matrixWorld), overrides any camera setting.
+     * @default undefined
+     */
     viewToWorld?: THREE.Matrix4;
+    /**
+     * Configure viewpoint with an off-screen render target.
+     * @default undefined
+     */
     target?: {
+        /**
+         * Width of the render target in pixels.
+         */
         width: number;
+        /**
+         * Height of the render target in pixels.
+         */
         height: number;
+        /**
+         * If you want to be able to render a scene that depends on this target's
+         * output (for example, a recursive viewport), set this to true to enable
+         * double buffering.
+         * @default false
+         */
         doubleBuffer?: boolean;
+        /**
+         * Super-sampling factor for the render target. Values 1-4 are supported.
+         * Note that re-sampling back down to .width x .height is done on the CPU
+         * with simple averaging only when calling readTarget().
+         * @default 1
+         */
         superXY?: number;
     };
+    /**
+     * Callback function that is called when the render target texture is updated.
+     * Receives the texture as a parameter. Use this to update a viewport with
+     * the latest viewpoint render each frame.
+     * @default undefined
+     */
     onTextureUpdated?: (texture: THREE.Texture) => void;
+    /**
+     * Whether to sort splats radially (geometric distance) from the viewpoint (true)
+     * or by Z-depth (false). Most scenes are trained with the Z-depth sort metric
+     * and will render more accurately at certain viewpoints. However, radial sorting
+     * is more stable under viewpoint rotations.
+     * @default true
+     */
     sortRadial?: boolean;
+    /**
+     * Distance threshold for re-sorting splats. If the viewpoint moves more than
+     * this distance, splats will be re-sorted.
+     * @default 0.01 units
+     */
     sortDistance?: number;
+    /**
+     * View direction dot product threshold for re-sorting splats. For
+     * sortRadial: true we use 0.99 while sortRadial: false uses 0.999 because it is
+     * more sensitive to view direction.
+     * @default 0.99 if sortRadial else 0.999
+     */
     sortCoorient?: boolean;
+    /**
+     * Constant added to Z-depth to bias values into the positive range for
+     * sortRadial: false, but also used for culling Gsplats "well behind"
+     * the viewpoint origin
+     * @default 1.0
+     */
     depthBias?: number;
+    /**
+     * Set this to true if rendering a 360 to disable "behind the viewpoint"
+     * culling during sorting. This is set automatically when rendering 360 envMaps
+     * using the SparkRenderer.renderEnvMap() utility function.
+     * @default false
+     */
     sort360?: boolean;
+    sort32?: boolean;
+    stochastic?: boolean;
 };
 export declare class SparkViewpoint {
     spark: SparkRenderer;
@@ -37,6 +112,8 @@ export declare class SparkViewpoint {
     sortCoorient?: boolean;
     depthBias?: number;
     sort360?: boolean;
+    sort32?: boolean;
+    stochastic: boolean;
     display: {
         accumulator: SplatAccumulator;
         viewToWorld: THREE.Matrix4;
@@ -45,7 +122,8 @@ export declare class SparkViewpoint {
     private sorting;
     private pending;
     private sortingCheck;
-    private readback;
+    private readback16;
+    private readback32;
     private orderingFreelist;
     constructor(options: SparkViewpointOptions & {
         spark: SparkRenderer;

package/dist/types/SplatLoader.d.ts

@@ -1,5 +1,5 @@
 import { FileLoader, Loader, LoadingManager } from 'three';
-import { PackedSplats } from './PackedSplats';
+import { PackedSplats, SplatEncoding } from './PackedSplats';
 import { SplatMesh } from './SplatMesh';
 export declare class SplatLoader extends Loader {
     fileLoader: FileLoader;
@@ -64,11 +64,12 @@ export declare function tryPcSogsZip(input: ArrayBuffer | Uint8Array): {
     name: string;
     json: PcSogsJson;
 } | undefined;
-export declare function unpackSplats({ input, extraFiles, fileType, pathOrUrl, }: {
+export declare function unpackSplats({ input, extraFiles, fileType, pathOrUrl, splatEncoding, }: {
     input: Uint8Array | ArrayBuffer;
     extraFiles?: Record<string, ArrayBuffer>;
     fileType?: SplatFileType;
     pathOrUrl?: string;
+    splatEncoding?: SplatEncoding;
 }): Promise<{
     packedArray: Uint32Array;
     numSplats: number;

package/dist/types/SplatMesh.d.ts

@@ -1,4 +1,4 @@
-import { PackedSplats } from './PackedSplats';
+import { PackedSplats, SplatEncoding } from './PackedSplats';
 import { RgbaArray } from './RgbaArray';
 import { SplatEdit } from './SplatEdit';
 import { GsplatModifier, SplatGenerator, SplatTransformer } from './SplatGenerator';
@@ -23,6 +23,7 @@ export type SplatMeshOptions = {
     }) => void;
     objectModifier?: GsplatModifier;
     worldModifier?: GsplatModifier;
+    splatEncoding?: SplatEncoding;
 };
 export type SplatMeshContext = {
     transform: SplatTransformer;
@@ -65,6 +66,7 @@ export declare class SplatMesh extends SplatGenerator {
     pushSplat(center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color): void;
     forEachSplat(callback: (index: number, center: THREE.Vector3, scales: THREE.Vector3, quaternion: THREE.Quaternion, opacity: number, color: THREE.Color) => void): void;
     dispose(): void;
+    getBoundingBox(centers_only?: boolean): THREE.Box3;
     constructGenerator(context: SplatMeshContext): void;
     updateGenerator(): void;
     update({ time, viewToWorld, deltaTime, globalEdits, }: {

package/dist/types/antisplat.d.ts

@@ -1,5 +1,6 @@
+import { SplatEncoding } from './PackedSplats';
 export declare function decodeAntiSplat(fileBytes: Uint8Array, initNumSplats: (numSplats: number) => void, splatCallback: (index: number, x: number, y: number, z: number, scaleX: number, scaleY: number, scaleZ: number, quatX: number, quatY: number, quatZ: number, quatW: number, opacity: number, r: number, g: number, b: number) => void): void;
-export declare function unpackAntiSplat(fileBytes: Uint8Array): {
+export declare function unpackAntiSplat(fileBytes: Uint8Array, splatEncoding: SplatEncoding): {
     packedArray: Uint32Array;
     numSplats: number;
 };

package/dist/types/defines.d.ts

@@ -1,6 +1,5 @@
 export declare const LN_SCALE_MIN = -12;
 export declare const LN_SCALE_MAX = 9;
-export declare const LN_RESCALE: number;
 export declare const SCALE_MIN: number;
 export declare const SCALE_MAX: number;
 export declare const LN_SCALE_ZERO = -30;

package/dist/types/dyno/output.d.ts

@@ -1,15 +1,17 @@
 import { Dyno } from './base';
 import { Gsplat } from './splats';
 import { DynoVal, DynoValue, HasDynoOut } from './value';
-export declare const outputPackedSplat: (gsplat: DynoVal<typeof Gsplat>) => OutputPackedSplat;
+export declare const outputPackedSplat: (gsplat: DynoVal<typeof Gsplat>, rgbMinMaxLnScaleMinMax: DynoVal<"vec4">) => OutputPackedSplat;
 export declare const outputRgba8: (rgba8: DynoVal<"vec4">) => OutputRgba8;
 export declare class OutputPackedSplat extends Dyno<{
     gsplat: typeof Gsplat;
+    rgbMinMaxLnScaleMinMax: "vec4";
 }, {
     output: "uvec4";
 }> implements HasDynoOut<"uvec4"> {
-    constructor({ gsplat }: {
+    constructor({ gsplat, rgbMinMaxLnScaleMinMax, }: {
         gsplat?: DynoVal<typeof Gsplat>;
+        rgbMinMaxLnScaleMinMax?: DynoVal<"vec4">;
     });
     dynoOut(): DynoValue<"uvec4">;
 }

package/dist/types/index.d.ts

@@ -19,3 +19,5 @@ export { type JointId, JointEnum, JOINT_IDS, NUM_JOINTS, JOINT_INDEX, JOINT_RADI
 export { SparkControls, FpsMovement, PointerControls } from './controls';
 export { isMobile, isAndroid, isOculus, flipPixels, pixelsToPngUrl, toHalf, fromHalf, floatToUint8, floatToSint8, Uint8ToFloat, Sint8ToFloat, setPackedSplat, unpackSplat, } from './utils';
 export * as utils from './utils';
+export { LN_SCALE_MIN, LN_SCALE_MAX } from './defines';
+export * as defines from './defines';

package/dist/types/ksplat.d.ts

@@ -1,5 +1,6 @@
+import { SplatEncoding } from './PackedSplats';
 export declare function decodeKsplat(fileBytes: Uint8Array, initNumSplats: (numSplats: number) => void, splatCallback: (index: number, x: number, y: number, z: number, scaleX: number, scaleY: number, scaleZ: number, quatX: number, quatY: number, quatZ: number, quatW: number, opacity: number, r: number, g: number, b: number) => void, shCallback?: (index: number, sh1: Float32Array, sh2?: Float32Array, sh3?: Float32Array) => void): void;
-export declare function unpackKsplat(fileBytes: Uint8Array): {
+export declare function unpackKsplat(fileBytes: Uint8Array, splatEncoding: SplatEncoding): {
     packedArray: Uint32Array;
     numSplats: number;
     extra: Record<string, unknown>;

package/dist/types/pcsogs.d.ts

@@ -1,10 +1,11 @@
+import { SplatEncoding } from './PackedSplats';
 import { PcSogsJson } from './SplatLoader';
-export declare function unpackPcSogs(json: PcSogsJson, extraFiles: Record<string, ArrayBuffer>): Promise<{
+export declare function unpackPcSogs(json: PcSogsJson, extraFiles: Record<string, ArrayBuffer>, splatEncoding: SplatEncoding): Promise<{
     packedArray: Uint32Array;
     numSplats: number;
     extra: Record<string, unknown>;
 }>;
-export declare function unpackPcSogsZip(fileBytes: Uint8Array): Promise<{
+export declare function unpackPcSogsZip(fileBytes: Uint8Array, splatEncoding: SplatEncoding): Promise<{
     packedArray: Uint32Array;
     numSplats: number;
     extra: Record<string, unknown>;

package/dist/types/utils.d.ts

@@ -39,14 +39,33 @@ export declare class FreeList<T, Args> {
     free(item: T): void;
     disposeAll(): void;
 }
-export declare function setPackedSplat(packedSplats: Uint32Array, index: number, x: number, y: number, z: number, scaleX: number, scaleY: number, scaleZ: number, quatX: number, quatY: number, quatZ: number, quatW: number, opacity: number, r: number, g: number, b: number): void;
+export declare function setPackedSplat(packedSplats: Uint32Array, index: number, x: number, y: number, z: number, scaleX: number, scaleY: number, scaleZ: number, quatX: number, quatY: number, quatZ: number, quatW: number, opacity: number, r: number, g: number, b: number, encoding?: {
+    rgbMin?: number;
+    rgbMax?: number;
+    lnScaleMin?: number;
+    lnScaleMax?: number;
+}): void;
 export declare function setPackedSplatCenter(packedSplats: Uint32Array, index: number, x: number, y: number, z: number): void;
-export declare function setPackedSplatScales(packedSplats: Uint32Array, index: number, scaleX: number, scaleY: number, scaleZ: number): void;
+export declare function setPackedSplatScales(packedSplats: Uint32Array, index: number, scaleX: number, scaleY: number, scaleZ: number, encoding?: {
+    lnScaleMin?: number;
+    lnScaleMax?: number;
+}): void;
 export declare function setPackedSplatQuat(packedSplats: Uint32Array, index: number, quatX: number, quatY: number, quatZ: number, quatW: number): void;
-export declare function setPackedSplatRgba(packedSplats: Uint32Array, index: number, r: number, g: number, b: number, a: number): void;
-export declare function setPackedSplatRgb(packedSplats: Uint32Array, index: number, r: number, g: number, b: number): void;
+export declare function setPackedSplatRgba(packedSplats: Uint32Array, index: number, r: number, g: number, b: number, a: number, encoding?: {
+    rgbMin?: number;
+    rgbMax?: number;
+}): void;
+export declare function setPackedSplatRgb(packedSplats: Uint32Array, index: number, r: number, g: number, b: number, encoding?: {
+    rgbMin?: number;
+    rgbMax?: number;
+}): void;
 export declare function setPackedSplatOpacity(packedSplats: Uint32Array, index: number, opacity: number): void;
-export declare function unpackSplat(packedSplats: Uint32Array, index: number): {
+export declare function unpackSplat(packedSplats: Uint32Array, index: number, encoding?: {
+    rgbMin?: number;
+    rgbMax?: number;
+    lnScaleMin?: number;
+    lnScaleMax?: number;
+}): {
     center: THREE.Vector3;
     scales: THREE.Vector3;
     quaternion: THREE.Quaternion;
@@ -132,9 +151,18 @@ export declare function encodeQuatEulerXyz888(q: THREE.Quaternion): number;
  * and then converting them back to Euler angles in [-π, π] and to a quaternion.
  */
 export declare function decodeQuatEulerXyz888(encoded: number, out: THREE.Quaternion): THREE.Quaternion;
-export declare function encodeSh1Rgb(sh1Array: Uint32Array, index: number, sh1Rgb: Float32Array): void;
-export declare function encodeSh2Rgb(sh2Array: Uint32Array, index: number, sh2Rgb: Float32Array): void;
-export declare function encodeSh3Rgb(sh3Array: Uint32Array, index: number, sh3Rgb: Float32Array): void;
+export declare function encodeSh1Rgb(sh1Array: Uint32Array, index: number, sh1Rgb: Float32Array, encoding?: {
+    sh1Min?: number;
+    sh1Max?: number;
+}): void;
+export declare function encodeSh2Rgb(sh2Array: Uint32Array, index: number, sh2Rgb: Float32Array, encoding?: {
+    sh2Min?: number;
+    sh2Max?: number;
+}): void;
+export declare function encodeSh3Rgb(sh3Array: Uint32Array, index: number, sh3Rgb: Float32Array, encoding?: {
+    sh3Min?: number;
+    sh3Max?: number;
+}): void;
 export declare function decompressPartialGzip(fileBytes: Uint8Array, numBytes: number): Uint8Array;
 export declare class GunzipReader {
     fileBytes: Uint8Array;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparkjsdev/spark",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "An advanced 3D Gaussian Splatting renderer for THREE.js",
   "homepage": "https://sparkjs.dev/",
   "type": "module",