soonspacejs 3.0.0-alpha.5 → 3.0.0-alpha.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soonspacejs",
-  "version": "3.0.0-alpha.5",
+  "version": "3.0.0-alpha.8",
   "homepage": "https://www.xwbuilders.com/soonspacejs/",
   "description": "SoonSpace.js 3.0 alpha",
   "module": "./dist/index.esm.js",

package/types/Cache/ModelBufferCache.d.ts

@@ -0,0 +1,15 @@
+/** Raw HTTP model bytes only. Runtime leases / GPU graphs are never persisted. */
+export declare class ModelBufferCache {
+    private readonly store;
+    private readonly enabled;
+    constructor(store?: LocalForage, enabled?: () => boolean);
+    load(url: string, init: {
+        headers: Headers;
+        credentials: RequestCredentials;
+        signal?: AbortSignal;
+        redirect?: RequestRedirect;
+    }): Promise<ArrayBuffer>;
+    private key;
+    private mutate;
+    clear(): Promise<void>;
+}

package/types/Entity/ModelResources.d.ts

@@ -1,5 +1,6 @@
 import { BufferGeometry, Material, Matrix4, Texture } from 'three';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { ModelBufferCache } from '../Cache/ModelBufferCache';
 export interface ModelPart {
     /** Omitted for triangle meshes. Basic line segments share the Entity lifecycle. */
     kind?: 'mesh' | 'line-segments';
@@ -63,8 +64,9 @@ export declare class ModelResources {
     private pending;
     private urls;
     private gltfLoader;
+    private bufferCache;
     /** Borrow a host-configured loader; its decoder workers remain host-owned. */
-    setGLTFLoader(loader: GLTFLoader): void;
+    setGLTFLoader(loader: GLTFLoader, bufferCache?: ModelBufferCache): void;
     readonly materials: {
         register: (material: Material, options: {
             ownership: "transfer";

package/types/Loader/TexturePreloader.d.ts

@@ -0,0 +1,44 @@
+import { Object3D, Texture } from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+interface TextureRenderer {
+    initTexture(texture: Texture): void;
+    domElement?: EventTarget;
+    getContext?: () => {
+        isContextLost(): boolean;
+    };
+}
+export declare const texturePreloaderFor: (loader: GLTFLoader) => TexturePreloader | undefined;
+export declare const bindTexturePreloader: (loader: GLTFLoader, queue: TexturePreloader) => void;
+/** Renderer-owned, frame-budgeted preparation for newly decoded GLTF roots. */
+export declare class TexturePreloader {
+    private readonly renderer;
+    private readonly budgetMs;
+    private entries;
+    private jobs;
+    private owners;
+    private frame;
+    private fallback;
+    private frameGeneration;
+    private contextLost;
+    private disposed;
+    readonly stats: {
+        uploads: number;
+        reused: number;
+        cancelled: number;
+        failed: number;
+        frames: number;
+        totalMs: number;
+        maxUploadMs: number;
+        maxFrameMs: number;
+    };
+    constructor(renderer: TextureRenderer, budgetMs?: number);
+    private onContextLost;
+    private onContextRestored;
+    private cancelFrame;
+    prepare(root: Object3D, signal?: AbortSignal, managerSignal?: AbortSignal): Promise<void>;
+    private schedule;
+    private pump;
+    private cancel;
+    dispose(): void;
+}
+export {};

package/types/Loader/scoped-gltf.d.ts

@@ -1,12 +1,15 @@
 import { GLTF, GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { ModelBufferCache } from '../Cache/ModelBufferCache';
 interface RequestScope {
     rootURL: string;
     headers: HeadersInit;
     signal?: AbortSignal;
+    bufferCache?: ModelBufferCache;
 }
 /** Each standard GLTFLoader parse constructs its parser synchronously, before any await. */
 export declare function parseScopedGLTF(loader: GLTFLoader, data: ArrayBuffer, path: string, scope: RequestScope): Promise<{
     gltf: GLTF;
     dependencyError?: unknown;
+    prepareTextures: () => Promise<void>;
 }>;
 export {};

package/types/Manager/ModelManage.d.ts

@@ -9,6 +9,7 @@ import { Group, GroupInfo, Model, ModelInfo } from '../Library';
 import { CloneModelInfo } from '../Interface';
 import { ObjectsCache } from '../Cache';
 import { default as DefaultManage } from './DefaultManage';
+import { ModelBufferCache } from '../Cache/ModelBufferCache';
 declare class ModelManage extends DefaultManage {
     readonly viewport: Viewport;
     readonly cache: ObjectsCache;
@@ -24,6 +25,8 @@ declare class ModelManage extends DefaultManage {
      */
     store: typeof localforage;
     cacheStore: typeof localforage;
+    readonly bufferCache: ModelBufferCache;
+    private texturePreloader?;
     loadingManager: LoadingManager;
     gltfLoader: GLTFLoader;
     fbxLoader: FBXLoader;

package/types/index.d.ts

@@ -3487,6 +3487,22 @@ export declare interface ModelAnimationFindFunc {
     (animation: AnimationClip, index: number, animations: AnimationClip[]): boolean;
 }
 
+/** Raw HTTP model bytes only. Runtime leases / GPU graphs are never persisted. */
+declare class ModelBufferCache {
+    private readonly store;
+    private readonly enabled;
+    constructor(store?: LocalForage, enabled?: () => boolean);
+    load(url: string, init: {
+        headers: Headers;
+        credentials: RequestCredentials;
+        signal?: AbortSignal;
+        redirect?: RequestRedirect;
+    }): Promise<ArrayBuffer>;
+    private key;
+    private mutate;
+    clear(): Promise<void>;
+}
+
 export declare interface ModelEventParams {
     target: Model;
     currentTarget: Mesh;
@@ -3544,6 +3560,8 @@ declare class ModelManage extends DefaultManage {
      */
     store: typeof default_2;
     cacheStore: typeof default_2;
+    readonly bufferCache: ModelBufferCache;
+    private texturePreloader?;
     loadingManager: LoadingManager;
     gltfLoader: GLTFLoader;
     fbxLoader: FBXLoader;
@@ -3653,8 +3671,9 @@ export declare class ModelResources {
     private pending;
     private urls;
     private gltfLoader;
+    private bufferCache;
     /** Borrow a host-configured loader; its decoder workers remain host-owned. */
-    setGLTFLoader(loader: GLTFLoader): void;
+    setGLTFLoader(loader: GLTFLoader, bufferCache?: ModelBufferCache): void;
     readonly materials: {
         register: (material: Material, options: {
             ownership: "transfer";