@miris-inc/core 0.0.8-655ef21 → 0.0.8-65fc419

package/package.json

@@ -1,16 +1,66 @@
 {
   "name": "@miris-inc/core",
+  "version": "0.0.8-65fc419",
+  "description": "Core scene-graph runtime for the Miris 3D streaming SDK. WASM-backed Engine, Client, Scene, Stream, and LOD primitives shared by all higher-level packages.",
+  "keywords": [
+    "3d",
+    "3dgs",
+    "4dgs",
+    "gaussian-splatting",
+    "miris",
+    "splats",
+    "streaming",
+    "wasm"
+  ],
+  "homepage": "https://miris.com",
   "license": "Apache-2.0",
-  "exports": "./core.js",
+  "author": "Miris, Inc.",
+  "files": [
+    "banner.svg",
+    "webshark.d.ts",
+    "webshark.js",
+    "webshark.wasm",
+    "dist/*.js",
+    "dist/*.d.ts",
+    "dist/*.wasm",
+    "!dist/**/*.map"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/core.prod.js",
+  "module": "./dist/core.prod.js",
+  "types": "./dist/core.d.ts",
+  "unpkg": "./dist/core.standalone.prod.js",
+  "jsdelivr": "./dist/core.standalone.prod.js",
+  "exports": {
+    ".": {
+      "source": "./index.ts",
+      "types": "./dist/core.d.ts",
+      "development": "./dist/core.js",
+      "import": "./dist/core.prod.js",
+      "default": "./dist/core.prod.js"
+    },
+    "./webshark": {
+      "types": "./webshark.d.ts",
+      "default": "./webshark.js"
+    },
+    "./standalone": {
+      "types": "./dist/core.d.ts",
+      "development": "./dist/core.standalone.js",
+      "import": "./dist/core.standalone.prod.js",
+      "default": "./dist/core.standalone.prod.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "d": "bun dev",
     "dev": "vite",
     "b": "cd ../.. && vite build --mode packages/core",
     "build": "cd ../.. && vite build --mode packages/core"
   },
-  "devDependencies": {
-    "@types/emscripten": "^1.41.5",
-    "core-js": "^3.47.0"
-  },
-  "version": "0.0.8-655ef21"
+  "engines": {
+    "node": ">=18"
+  }
 }

package/webshark.d.ts

@@ -0,0 +1,201 @@
+export interface Camera {
+  dir: vec4;
+  U: vec4;
+  V: vec4;
+  eye: vec4;
+  l: number;
+  fov: number;
+}
+
+export interface SortTypeValue {
+  value: number;
+}
+
+export interface TextureFormatValue {
+  value: number;
+}
+
+export interface SharkRenderInfo {
+  triangles: number;
+}
+
+export interface SharkInfo {
+  renderCalls: number;
+  render: SharkRenderInfo;
+  reset(): void;
+}
+
+export interface RendererWGPU {
+  getProgramCount(): number;
+  getTextureCount(): number;
+  getEstimatedTextureSize(): number;
+  getTotalBufferSize(): number;
+  info: SharkInfo;
+}
+
+export interface RenderState {
+  initRenderState(
+    renderer: RendererWGPU,
+    width: number,
+    height: number,
+    vertices: number,
+    splats: number,
+    cubes: number,
+    sortThreads: number,
+    sortGroupSize: number,
+    sortKeySize: number,
+  ): void;
+  initGraphicsState(
+    width: number,
+    height: number,
+    renderTextureFormat: TextureFormatValue,
+    depthTextureFormat: TextureFormatValue,
+  ): void;
+  updateRenderDetails(
+    width: number,
+    height: number,
+    splatTriangles: number,
+  ): void;
+}
+
+export interface vec4 {
+  x: number;
+  y: number;
+  z: number;
+  w: number;
+  delete(): void;
+}
+
+export interface SplatSet {
+  splatCount: number;
+  // Number of splats actually drawn: ordering[0, activeSplats) holds the unmasked splat indices.
+  // Set alongside orderingView() to restrict the draw to unmasked octant ranges.
+  activeSplats: number;
+  // Selects which ellipsoid layout to allocate and what ellipsoidsView() exposes:
+  // packed (16 bytes/splat) or uncompressed (48). Must be set before the first resize.
+  usePackedEllipsoids: boolean;
+  // direct-write upload: resize -> write into the views -> finalize.
+  // views are valid only until the next resize.
+  resize(splatCount: number): void;
+  ellipsoidsView(): Uint32Array;
+  colorsView(): Uint32Array;
+  sh1View(): Uint32Array;
+  sh2View(): Uint32Array;
+  sh3aView(): Uint32Array;
+  sh3bView(): Uint32Array;
+  // Per-chunk fade (opacity multiplier), one float per chunk, defaults to 1.0.
+  // Also sizes the chunk slot to model root slot map below, since both are indexed by chunk slot
+  resizeChunkFades(chunkCount: number): void;
+  chunkFadesView(): Float32Array;
+  // Per-splat chunk index, defaults to slot 0. Write before finalize()
+  chunkIndicesView(): Int32Array;
+  // Model transforms, resolved per splat as
+  //   modelRootTransforms[chunkModelRoots[chunkIndices[splat]]]
+  // Slot 0 of both tables is reserved as identity, so real slots start at 1 and a set that
+  // never writes them renders untransformed.
+  resizeModelRootSlots(modelRootCount: number): void;
+  // 16 floats per model root, COLUMN-major - i.e. write THREE's Matrix4.toArray() straight in
+  modelRootTransformsView(): Float32Array;
+  // The inverses, same slots and layout. The true-perspective projection (Project.glsl) transforms
+  // a quadratic form and needs them; writing a transform without its inverse leaves that path
+  // projecting the splat as if untransformed. Use Matrix4.invert() on a copy
+  modelRootInverseTransformsView(): Float32Array;
+  // Sized by resizeChunkFades. Defaults to slot 0 (identity) for every chunk
+  chunkModelRootsView(): Int32Array;
+  // int32 render-order buffer (sized 2*splatCount after finalize). Valid only until the next resize.
+  orderingView(): Int32Array;
+  finalize(): void;
+  // like finalize() but keeps splats in their delivered (octant-sorted) order — no kd-tree reorder —
+  // so sparse-octant range masking can index child-octant ranges directly. RADIX_SORT only.
+  finalizeBounds(): void;
+}
+
+export interface WebGPUInterface {
+  importJsAdapter(adapter: GPUAdapter, parentPtr?: number): number;
+  importJsDevice(device: GPUDevice, parentPtr?: number): number;
+  importJsTexture(obj: GPUTexture, parentPtr?: number): number;
+}
+
+export interface MainModule {
+  Camera: new () => Camera;
+  RenderState: new () => RenderState;
+  SplatSet: new () => SplatSet;
+  vec4: new (x: number, y: number, z: number, w: number) => vec4;
+
+  SortType: {
+    RADIX_SORT: SortTypeValue;
+    OCTREE_SORT: SortTypeValue;
+    KDTREE_SORT: SortTypeValue;
+    STD_SORT: SortTypeValue;
+  };
+
+  TextureFormat: {
+    RGBA32_Float: TextureFormatValue;
+    RGBA16_Float: TextureFormatValue;
+    RG16_Float: TextureFormatValue;
+    RGBA32_UInt: TextureFormatValue;
+    RGBA32_SInt: TextureFormatValue;
+    RGBA16_UInt: TextureFormatValue;
+    RGBA16_SInt: TextureFormatValue;
+    RGBA8_UInt: TextureFormatValue;
+    RGBA8_SInt: TextureFormatValue;
+    RGBA8_UNorm: TextureFormatValue;
+    RGBA8_SNorm: TextureFormatValue;
+    RGBA16_UNorm: TextureFormatValue;
+    RGBA16_SNorm: TextureFormatValue;
+    BGRA8_UNorm: TextureFormatValue;
+    BC6HRGB_UFloat: TextureFormatValue;
+    BC6HRGB_Float: TextureFormatValue;
+    BC7RGBA_UNorm: TextureFormatValue;
+    BC7RGBA_UNormSrgb: TextureFormatValue;
+    BC3RGBA_UNorm: TextureFormatValue;
+    BC3RGBA_UNormSrgb: TextureFormatValue;
+    Depth16Unorm: TextureFormatValue;
+    Depth24Plus: TextureFormatValue;
+    Depth32Float: TextureFormatValue;
+  };
+
+  WebGPU: WebGPUInterface;
+
+  uploadSplatSetData(
+    set: SplatSet,
+    renderState: RenderState,
+    start: number,
+  ): void;
+  uploadChunkFades(set: SplatSet, renderState: RenderState): void;
+  // One mat4 per model root, so cheap enough to call every frame while an asset is moving
+  uploadModelRootTransforms(set: SplatSet, renderState: RenderState): void;
+  processSplatSet(
+    camera: Camera,
+    set: SplatSet,
+    renderState: RenderState,
+    width: number,
+    height: number,
+    triangles: number,
+    projectOnGPU: boolean,
+    cullEllipsoid: boolean,
+    useAffineApprox: boolean,
+    depthSortOnGPU: boolean,
+    useInvZ: boolean,
+    rasterizeWithCompute: boolean,
+    useSOGS: boolean,
+    sortType: SortTypeValue,
+    skipSort: boolean,
+  ): number;
+  createRendererWGPUWithoutSurface(
+    colorTargetFormat: TextureFormatValue,
+  ): RendererWGPU;
+  renderSplatSetToSceneTextures(
+    splatSet: SplatSet,
+    renderState: RenderState,
+    colorTarget: number,
+    depthTarget: number,
+    renderGES: boolean,
+  ): void;
+}
+
+declare function WebShark(
+  moduleArg?: Record<string, unknown>,
+): Promise<MainModule>;
+
+export default WebShark;