@rings-webgpu/core 1.0.25 → 1.0.26

package/dist/rings.umd.max.js

@@ -16792,6 +16792,10 @@ struct InstanceData {
     name;
     url;
     gpuTexture;
+    _isDestroyed = false;
+    get isDestroyed() {
+      return this._isDestroyed;
+    }
     pid;
     view;
     // Assigned later
@@ -17020,6 +17024,14 @@ struct InstanceData {
         this.textureDescriptor = null;
         this.gpuTexture.destroy();
         this.gpuTexture = null;
+        this._isDestroyed = true;
+      }
+      if (this._sourceImageData && this._sourceImageData instanceof ImageBitmap) {
+        try {
+          this._sourceImageData.close();
+        } catch (e) {
+        }
+        this._sourceImageData = null;
       }
       this._stateChangeRef.clear();
     }
@@ -20283,9 +20295,13 @@ struct InstanceData {
      * @param target reference parent
      */
     detached(ref, target) {
+      if (!this.reference) return;
       let refMap = this.reference.get(ref);
       if (refMap) {
         refMap.delete(target);
+        if (refMap.size === 0) {
+          this.reference.delete(ref);
+        }
       }
     }
     /**
@@ -22514,23 +22530,36 @@ struct InstanceData {
       }
     }
     beforeDestroy(force) {
-      Reference.getInstance().detached(this._geometry, this);
-      if (!Reference.getInstance().hasReference(this._geometry)) {
-        this._geometry.destroy(force);
+      if (this._geometry) {
+        Reference.getInstance().detached(this._geometry, this);
+        if (!Reference.getInstance().hasReference(this._geometry)) {
+          this._geometry.destroy(force);
+        }
       }
       for (let i = 0; i < this._materials.length; i++) {
         const mat = this._materials[i];
-        Reference.getInstance().detached(mat, this);
-        if (!Reference.getInstance().hasReference(mat)) {
-          mat.destroy(force);
+        if (mat) {
+          Reference.getInstance().detached(mat, this);
+          if (!Reference.getInstance().hasReference(mat)) {
+            mat.destroy(force);
+          }
         }
       }
+      if (this._computes) {
+        this._computes.length = 0;
+      }
+      this.detachSceneOctree();
       super.beforeDestroy(force);
     }
     destroy(force) {
       super.destroy(force);
       this._geometry = void 0;
       this._materials.length = 0;
+      this._computes = null;
+      if (this._passInit) {
+        this._passInit.clear();
+        this._passInit = null;
+      }
       this._combineShaderRefection = void 0;
     }
   }
@@ -22550,6 +22579,7 @@ struct InstanceData {
     enable = true;
     _defaultSubShader;
     _shader;
+    _isDestroyed = false;
     constructor() {
       this.instanceID = UUID();
     }
@@ -22664,10 +22694,17 @@ struct InstanceData {
       return newMat;
     }
     destroy(force) {
+      if (this._isDestroyed) {
+        return;
+      }
       this.name = null;
       this.instanceID = null;
-      this._shader.destroy();
-      this._shader = null;
+      if (this._shader) {
+        this._shader.destroy(force);
+        this._shader = null;
+      }
+      this._defaultSubShader = null;
+      this._isDestroyed = true;
     }
     setDefine(define, value) {
       this.shader.setDefine(define, value);
@@ -23172,8 +23209,15 @@ struct InstanceData {
         }
       }
     }
-    destroy() {
-      this.getDefaultColorShader().destroy();
+    destroy(force) {
+      for (const pass of this.passShader) {
+        for (const rd of pass[1]) {
+          rd.destroy(force);
+        }
+      }
+      this.passShader.clear();
+      this.passShader = null;
+      this.computes = null;
     }
     clone() {
       let newShader = new Shader();
@@ -23665,6 +23709,7 @@ struct InstanceData {
     _vertexBuffer;
     _onChange = true;
     _wireframeLines;
+    _isDestroyed = false;
     constructor() {
       this.instanceID = UUID();
       this._attributeMap = /* @__PURE__ */ new Map();
@@ -23911,18 +23956,40 @@ struct InstanceData {
       return false;
     }
     destroy(force) {
+      if (this._isDestroyed) {
+        return;
+      }
       this.instanceID = null;
       this.name = null;
       this.subGeometries = null;
       this.morphTargetDictionary = null;
-      this._bounds.destroy();
-      this._bounds = null;
-      this._attributeMap = null;
+      this.skinNames = null;
+      this.bindPose = null;
+      this.blendShapeData = null;
+      this._wireframeLines = null;
+      if (this._bounds) {
+        this._bounds.destroy();
+        this._bounds = null;
+      }
+      if (this._attributeMap) {
+        this._attributeMap.forEach((vertexInfo) => {
+          if (vertexInfo && vertexInfo.data) {
+            vertexInfo.data = null;
+          }
+        });
+        this._attributeMap.clear();
+        this._attributeMap = null;
+      }
       this._attributes = null;
-      this._indicesBuffer.destroy();
-      this._vertexBuffer.destroy();
-      this._indicesBuffer = null;
-      this._vertexBuffer = null;
+      if (this._indicesBuffer) {
+        this._indicesBuffer.destroy();
+        this._indicesBuffer = null;
+      }
+      if (this._vertexBuffer) {
+        this._vertexBuffer.destroy();
+        this._vertexBuffer = null;
+      }
+      this._isDestroyed = true;
     }
   }
 
@@ -25323,10 +25390,22 @@ struct InstanceData {
           c.destroy(force);
         });
         this.components.clear();
-        this.entityChildren.forEach((c) => {
-          c.destroy(force);
-        });
-        this.removeAllChild();
+        this.components.clear();
+        if (this.entityChildren) {
+          this.entityChildren.forEach((c) => {
+            c.destroy(force);
+          });
+          this.removeAllChild();
+          this.entityChildren = [];
+        }
+        if (this._bound && this._bound.destroy) {
+          this._bound.destroy();
+          this._bound = null;
+        }
+        if (this._boundWorld && this._boundWorld.destroy) {
+          this._boundWorld.destroy();
+          this._boundWorld = null;
+        }
         this.transform.parent = null;
         this._dispose = true;
         super.destroy();
@@ -25598,6 +25677,16 @@ struct InstanceData {
         this.onTransformLocalChange,
         this
       );
+      const batchTable = this.batchTable;
+      if (batchTable && typeof batchTable.destroy === "function") {
+        batchTable.destroy();
+        this.batchTable = null;
+      }
+      const featureTable = this.featureTable;
+      if (featureTable && typeof featureTable.destroy === "function") {
+        featureTable.destroy();
+        this.featureTable = null;
+      }
       super.destroy(force);
     }
   };
@@ -32912,6 +33001,12 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
       return this._source;
     }
     set source(value) {
+      if (this._source && this._source instanceof ImageBitmap) {
+        try {
+          this._source.close();
+        } catch (e) {
+        }
+      }
       this._source = value;
       if (this._source instanceof HTMLImageElement) {
         this._source.decode().then(async () => {
@@ -32979,17 +33074,32 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
       if (imageBitmap.width < 32 || imageBitmap.height < 32) {
         let width = Math.max(imageBitmap.width, 32);
         let height = Math.max(imageBitmap.height, 32);
+        const oldImageBitmap = imageBitmap;
         imageBitmap = await createImageBitmap(imageBitmap, {
           resizeWidth: width,
           resizeHeight: height,
           imageOrientation: this.flipY ? "flipY" : "from-image",
           premultiplyAlpha: "none"
         });
+        try {
+          oldImageBitmap.close();
+        } catch (e) {
+        }
       }
       this.format = GPUTextureFormat.rgba8unorm;
       this.generate(imageBitmap);
       return true;
     }
+    destroy(force) {
+      if (this._source && this._source instanceof ImageBitmap) {
+        try {
+          this._source.close();
+        } catch (e) {
+        }
+        this._source = null;
+      }
+      super.destroy(force);
+    }
   }
 
   class LoaderBase {
@@ -36237,6 +36347,7 @@ else if (typeof exports === 'object')
         this._gltf,
         this._gltf.scene
       );
+      subParser.destroy();
       if (nodes) {
         this.data = nodes.rootNode;
         return nodes.rootNode;
@@ -36274,6 +36385,7 @@ else if (typeof exports === 'object')
         this._gltf,
         this._gltf.scene
       );
+      subParser.destroy();
       if (nodes) {
         this.data = nodes.rootNode;
         return nodes.rootNode;
@@ -39074,6 +39186,12 @@ else if (typeof exports === 'object')
         return data;
       }
     }
+    destroy() {
+      this.buffer = null;
+      this.header = null;
+      this.binOffset = null;
+      this.binLength = null;
+    }
   }
   class BatchTable extends FeatureTable {
     batchSize;
@@ -40999,6 +41117,25 @@ else if (typeof exports === 'object')
       this._texturePool.set(url, texture);
       return texture;
     }
+    destroyTexture(url) {
+      const texture = this._texturePool.get(url);
+      if (texture) {
+        if (!Reference.getInstance().hasReference(texture)) {
+          if (!texture.isDestroyed) {
+            texture.destroy();
+          }
+          this._texturePool.delete(url);
+          return true;
+        }
+        return false;
+      }
+      return false;
+    }
+    destroyTextureAllUnUsed() {
+      for (const [url, texture] of this._texturePool.entries()) {
+        this.destroyTexture(url);
+      }
+    }
     async loadTextureCount(urls, count, loaderFunctions, flipY) {
       return new Promise(async (suc, fail) => {
         let total = 0;
@@ -41295,7 +41432,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.24";
+  const version = "1.0.25";
 
   class Engine3D {
     /**
@@ -62527,7 +62664,7 @@ fn frag(){
               if (sceneObj.parent) {
                 sceneObj.parent.object3D.removeChild(sceneObj);
               }
-              sceneObj.destroy();
+              sceneObj.destroy(true);
               tileItem.cached.scene = null;
             }
             tileItem.loadingState = UNLOADED;
@@ -62841,7 +62978,7 @@ fn frag(){
     /**
      * Clean up resources
      */
-    dispose() {
+    dispose(force) {
       const plugins = [...this.plugins];
       plugins.forEach((plugin) => this.unregisterPlugin(plugin));
       this.lruCache.clear();
@@ -62853,7 +62990,7 @@ fn frag(){
       this.frameCount = 0;
       this.isLoading = false;
       this.resetCacheStats();
-      this.group.destroy();
+      this.group.destroy(force);
     }
     /**
      * Rings-specific: Add camera

package/dist/types/assets/Res.d.ts

@@ -44,6 +44,8 @@ export declare class Res {
     loadB3DM(url: string, loaderFunctions?: LoaderFunctions, userData?: any): Promise<Object3D>;
     loadI3DM(url: string, loaderFunctions?: LoaderFunctions, userData?: any): Promise<Object3D>;
     loadTexture(url: string, loaderFunctions?: LoaderFunctions, flipY?: boolean): Promise<Texture>;
+    destroyTexture(url: string): boolean;
+    destroyTextureAllUnUsed(): void;
     private loadTextureCount;
     loadBitmapTextures(urls: string[], count?: number, loaderFunctions?: LoaderFunctions, flipY?: boolean): Promise<BitmapTexture2D[]>;
     loadHDRTexture(url: string, loaderFunctions?: LoaderFunctions): Promise<Texture>;

package/dist/types/core/geometry/GeometryBase.d.ts

@@ -41,6 +41,7 @@ export declare class GeometryBase {
     private _vertexBuffer;
     private _onChange;
     private _wireframeLines;
+    private _isDestroyed;
     constructor();
     get indicesBuffer(): GeometryIndicesBuffer;
     get vertexBuffer(): GeometryVertexBuffer;

package/dist/types/gfx/graphics/webGpu/core/texture/Texture.d.ts

@@ -2,6 +2,8 @@ export declare class Texture implements GPUSamplerDescriptor {
     name: string;
     url: string;
     protected gpuTexture: GPUTexture;
+    private _isDestroyed;
+    get isDestroyed(): boolean;
     pid: number;
     view: GPUTextureView | GPUExternalTexture;
     gpuSampler: GPUSampler;

package/dist/types/gfx/graphics/webGpu/shader/Shader.d.ts

@@ -47,7 +47,7 @@ export declare class Shader {
     setStructStorageBuffer<T extends Struct>(arg0: string, arg1: StructStorageGPUBuffer<T>): void;
     getStructStorageBuffer(arg0: string): GPUBufferBase;
     noticeValueChange(): void;
-    destroy(): void;
+    destroy(force?: boolean): void;
     clone(): Shader;
     applyUniform(): void;
 }

package/dist/types/loader/parser/b3dm/FeatureTable.d.ts

@@ -6,6 +6,7 @@ export declare class FeatureTable {
     constructor(buffer: any, start: any, headerLength: any, binLength: any);
     getKeys(): string[];
     getData(key: any, count?: any, defaultComponentType?: any, defaultType?: any): any;
+    destroy(): void;
 }
 export declare class BatchTable extends FeatureTable {
     private batchSize;

package/dist/types/loader/parser/tileRenderer/TilesRenderer.d.ts

@@ -290,7 +290,7 @@ export declare class TilesRenderer {
     /**
      * Clean up resources
      */
-    dispose(): void;
+    dispose(force?: boolean): void;
     /**
      * Rings-specific: Add camera
      */

package/dist/types/materials/Material.d.ts

@@ -15,6 +15,7 @@ export declare class Material {
     enable: boolean;
     private _defaultSubShader;
     protected _shader: Shader;
+    private _isDestroyed;
     constructor();
     set shader(shader: Shader);
     get shader(): Shader;

package/dist/types/textures/BitmapTexture2D.d.ts

@@ -9,4 +9,5 @@ export declare class BitmapTexture2D extends Texture {
     load(url: string, loaderFunctions?: LoaderFunctions): Promise<unknown>;
     private imageData;
     loadFromBlob(imgData: Blob): Promise<boolean>;
+    destroy(force?: boolean): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rings-webgpu/core",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "Rings webgpu Engine",
   "main": "index.js",
   "exports": {