@sparkjsdev/spark 0.1.3 → 0.1.5

package/dist/types/SparkRenderer.d.ts

@@ -13,6 +13,8 @@ export type SparkRendererOptions = {
     enable2DGS?: boolean;
     preBlurAmount?: number;
     blurAmount?: number;
+    focalDistance?: number;
+    apertureAngle?: number;
     falloff?: number;
     clipXY?: number;
     view?: SparkViewpointOptions;
@@ -28,8 +30,20 @@ export declare class SparkRenderer extends THREE.Mesh {
     enable2DGS: boolean;
     preBlurAmount: number;
     blurAmount: number;
+    focalDistance: number;
+    apertureAngle: number;
     falloff: number;
     clipXY: number;
+    renderScale: number;
+    splatTexture: null | {
+        enable?: boolean;
+        texture?: THREE.Data3DTexture;
+        multiply?: THREE.Matrix2;
+        add?: THREE.Vector2;
+        near?: number;
+        far?: number;
+        mid?: number;
+    };
     time?: number;
     deltaTime?: number;
     clock: THREE.Clock;
@@ -49,11 +63,18 @@ export declare class SparkRenderer extends THREE.Mesh {
     private envViewpoint;
     private static cubeRender;
     private static pmrem;
+    static EMPTY_SPLAT_TEXTURE: THREE.Data3DTexture;
     constructor(options: SparkRendererOptions);
     static makeUniforms(): {
         renderSize: {
             value: THREE.Vector2;
         };
+        near: {
+            value: number;
+        };
+        far: {
+            value: number;
+        };
         numSplats: {
             value: number;
         };
@@ -75,12 +96,43 @@ export declare class SparkRenderer extends THREE.Mesh {
         blurAmount: {
             value: number;
         };
+        focalDistance: {
+            value: number;
+        };
+        apertureAngle: {
+            value: number;
+        };
         falloff: {
             value: number;
         };
         clipXY: {
             value: number;
         };
+        renderScale: {
+            value: number;
+        };
+        splatTexEnable: {
+            value: boolean;
+        };
+        splatTexture: {
+            type: string;
+            value: THREE.Data3DTexture;
+        };
+        splatTexMul: {
+            value: THREE.Matrix2;
+        };
+        splatTexAdd: {
+            value: THREE.Vector2;
+        };
+        splatTexNear: {
+            value: number;
+        };
+        splatTexFar: {
+            value: number;
+        };
+        splatTexMid: {
+            value: number;
+        };
         packedSplats: {
             type: string;
             value: THREE.DataArrayTexture;

package/dist/types/SplatLoader.d.ts

@@ -4,22 +4,65 @@ import { SplatMesh } from './SplatMesh';
 export declare class SplatLoader extends Loader {
     fileLoader: FileLoader;
     fileType?: SplatFileType;
+    packedSplats?: PackedSplats;
     constructor(manager?: LoadingManager);
     load(url: string, onLoad?: (decoded: PackedSplats) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
     loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<PackedSplats>;
+    loadExtra(url: string): Promise<ArrayBuffer>;
     parse(packedSplats: PackedSplats): SplatMesh;
 }
 export declare enum SplatFileType {
     PLY = "ply",
     SPZ = "spz",
     SPLAT = "splat",
-    KSPLAT = "ksplat"
+    KSPLAT = "ksplat",
+    PCSOGS = "pcsogs"
 }
 export declare function getSplatFileType(fileBytes: Uint8Array): SplatFileType | undefined;
 export declare function getFileExtension(pathOrUrl: string): string;
 export declare function getSplatFileTypeFromPath(pathOrUrl: string): SplatFileType | undefined;
-export declare function unpackSplats({ input, fileType, pathOrUrl, }: {
+export type PcSogsJson = {
+    means: {
+        shape: number[];
+        dtype: string;
+        mins: number[];
+        maxs: number[];
+        files: string[];
+    };
+    scales: {
+        shape: number[];
+        dtype: string;
+        mins: number[];
+        maxs: number[];
+        files: string[];
+    };
+    quats: {
+        shape: number[];
+        dtype: string;
+        encoding?: string;
+        files: string[];
+    };
+    sh0: {
+        shape: number[];
+        dtype: string;
+        mins: number[];
+        maxs: number[];
+        files: string[];
+    };
+    shN: {
+        shape: number[];
+        dtype: string;
+        mins: number;
+        maxs: number;
+        quantization: number;
+        files: string[];
+    };
+};
+export declare function isPcSogs(input: ArrayBuffer | Uint8Array | string): boolean;
+export declare function tryPcSogs(input: ArrayBuffer | Uint8Array | string): PcSogsJson | undefined;
+export declare function unpackSplats({ input, extraFiles, fileType, pathOrUrl, }: {
     input: Uint8Array | ArrayBuffer;
+    extraFiles?: Record<string, ArrayBuffer>;
     fileType?: SplatFileType;
     pathOrUrl?: string;
 }): Promise<{

package/dist/types/controls.d.ts

@@ -74,6 +74,7 @@ export declare class PointerControls {
     reverseScroll: boolean;
     moveInertia: number;
     rotateInertia: number;
+    pointerRollScale: number;
     enable: boolean;
     doublePress: ({ position, intervalMs, }: {
         position: THREE.Vector2;
@@ -91,7 +92,7 @@ export declare class PointerControls {
     scroll: THREE.Vector3;
     rotateVelocity: THREE.Vector3;
     moveVelocity: THREE.Vector3;
-    constructor({ canvas, rotateSpeed, slideSpeed, scrollSpeed, swapRotateSlide, reverseRotate, reverseSlide, reverseSwipe, reverseScroll, moveInertia, rotateInertia, doublePress, }: {
+    constructor({ canvas, rotateSpeed, slideSpeed, scrollSpeed, swapRotateSlide, reverseRotate, reverseSlide, reverseSwipe, reverseScroll, moveInertia, rotateInertia, pointerRollScale, doublePress, }: {
         canvas: HTMLCanvasElement;
         rotateSpeed?: number;
         slideSpeed?: number;
@@ -103,6 +104,7 @@ export declare class PointerControls {
         reverseScroll?: boolean;
         moveInertia?: number;
         rotateInertia?: number;
+        pointerRollScale?: number;
         doublePress?: ({ position, intervalMs, }: {
             position: THREE.Vector2;
             intervalMs: number;

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

@@ -13,6 +13,7 @@ export declare const hashFloat: <T extends ValueTypes>(value: DynoVal<T>) => Dyn
 export declare const hashVec2: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"vec2">;
 export declare const hashVec3: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"vec3">;
 export declare const hashVec4: <T extends ValueTypes>(value: DynoVal<T>) => DynoVal<"vec4">;
+export declare const normalizedDepth: (z: DynoVal<"float">, zNear: DynoVal<"float">, zFar: DynoVal<"float">) => DynoVal<"float">;
 export declare class DynoRemapIndex extends Dyno<{
     from: "int";
     to: "int";
@@ -137,3 +138,17 @@ export declare class HashVec4<T extends ValueTypes> extends DynoBlock<{
     });
     dynoOut(): DynoValue<"vec4">;
 }
+export declare class NormalizedDepth extends Dyno<{
+    z: "float";
+    zNear: "float";
+    zFar: "float";
+}, {
+    depth: "float";
+}> implements HasDynoOut<"float"> {
+    constructor({ z, zNear, zFar, }: {
+        z: DynoVal<"float">;
+        zNear: DynoVal<"float">;
+        zFar: DynoVal<"float">;
+    });
+    dynoOut(): DynoValue<"float">;
+}

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 export { SparkRenderer, type SparkRendererOptions } from './SparkRenderer';
 export { SparkViewpoint, type SparkViewpointOptions } from './SparkViewpoint';
 export * as dyno from './dyno';
-export { SplatLoader, unpackSplats, SplatFileType, getSplatFileType, } from './SplatLoader';
+export { SplatLoader, unpackSplats, SplatFileType, getSplatFileType, isPcSogs, } from './SplatLoader';
 export { PlyReader } from './ply';
 export { SpzReader, SpzWriter, transcodeSpz } from './spz';
 export { PackedSplats, type PackedSplatsOptions } from './PackedSplats';
@@ -13,6 +13,7 @@ export { SplatSkinning, type SplatSkinningOptions } from './SplatSkinning';
 export { SplatEdit, type SplatEditOptions, SplatEditSdf, type SplatEditSdfOptions, SplatEditSdfType, SplatEditRgbaBlendMode, SplatEdits, } from './SplatEdit';
 export { constructGrid, constructAxes, constructSpherePoints, imageSplats, textSplats, } from './splatConstructors';
 export * as generators from './generators';
+export * as modifiers from './modifiers';
 export { VRButton } from './vrButton';
 export { type JointId, JointEnum, JOINT_IDS, NUM_JOINTS, JOINT_INDEX, JOINT_RADIUS, JOINT_SEGMENTS, JOINT_SEGMENT_STEPS, JOINT_TIPS, FINGER_TIPS, Hand, HANDS, type Joint, type HandJoints, type HandsJoints, XrHands, HandMovement, } from './hands';
 export { SparkControls, FpsMovement, PointerControls } from './controls';

package/dist/types/modifiers/depthColor.d.ts

@@ -0,0 +1,17 @@
+import { SplatTransformer } from '../SplatGenerator';
+import { SplatMesh } from '../SplatMesh';
+import { DynoVal } from '../dyno';
+export declare function makeDepthColorModifier(splatToView: SplatTransformer, minDepth: DynoVal<"float">, maxDepth: DynoVal<"float">, reverse: DynoVal<"bool">): import('../dyno').DynoBlock<{
+    gsplat: {
+        type: "Gsplat";
+    };
+}, {
+    gsplat: {
+        type: "Gsplat";
+    };
+}>;
+export declare function setDepthColor(splats: SplatMesh, minDepth: number, maxDepth: number, reverse?: boolean): {
+    minDepth: import('../dyno').DynoConst<"float">;
+    maxDepth: import('../dyno').DynoConst<"float">;
+    reverse: import('../dyno').DynoConst<"bool">;
+};

package/dist/types/modifiers/normalColor.d.ts

@@ -0,0 +1,12 @@
+import { SplatTransformer } from '../SplatGenerator';
+import { SplatMesh } from '../SplatMesh';
+export declare function makeNormalColorModifier(splatToView: SplatTransformer): import('../dyno').DynoBlock<{
+    gsplat: {
+        type: "Gsplat";
+    };
+}, {
+    gsplat: {
+        type: "Gsplat";
+    };
+}>;
+export declare function setWorldNormalColor(splats: SplatMesh): void;

package/dist/types/modifiers.d.ts

@@ -0,0 +1,2 @@
+export * from './modifiers/normalColor';
+export * from './modifiers/depthColor';

package/dist/types/pcsogs.d.ts

@@ -0,0 +1,5 @@
+export declare function unpackPcSogs(fileBytes: Uint8Array, extraFiles: Record<string, ArrayBuffer>): Promise<{
+    packedArray: Uint32Array;
+    numSplats: number;
+    extra: Record<string, unknown>;
+}>;

package/dist/types/utils.d.ts

@@ -43,6 +43,7 @@ export declare function setPackedSplat(packedSplats: Uint32Array, index: number,
 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 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 setPackedSplatOpacity(packedSplats: Uint32Array, index: number, opacity: number): void;
 export declare function unpackSplat(packedSplats: Uint32Array, index: number): {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparkjsdev/spark",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "An advanced 3D Gaussian Splatting renderer for THREE.js",
   "homepage": "https://sparkjs.dev/",
   "type": "module",
@@ -32,9 +32,9 @@
     "lint:fix": "biome check . --fix",
     "lint:summary": "biome check --reporter=summary",
     "prepare": "npm run build:wasm && lefthook install",
-    "site:build": "npm run build && npm run site:clean && node scripts/copy-site-files.js && mkdocs build",
+    "site:build": "npm run build && npm run site:clean && node scripts/copy-site-files.js && mkdocs build && node scripts/rename-assets-to-static.js",
     "site:clean": "node scripts/clean-site-files.js && node scripts/clean-site.js",
-    "site:deploy": "node scripts/deploy-site.js",
+    "site:deploy": "npm run site:build && node scripts/deploy-site.js",
     "site:serve": "node scripts/serve-site.js site",
     "start": "npm run dev",
     "test": "node --no-warnings --loader ts-node/esm --test test/**/*.test.ts"
@@ -58,6 +58,7 @@
     "spark-internal-rs": "file:rust/spark-internal-rs/pkg"
   },
   "dependencies": {
+    "@jsquash/webp": "^1.5.0",
     "fflate": "^0.8.2"
   },
   "keywords": ["3d", "three.js", "gsplats", "3dgs", "gaussian", "splats"]