@rings-webgpu/core 1.0.25 → 1.0.26

package/dist/rings.es.max.js

@@ -16785,6 +16785,10 @@ class Texture {
   name;
   url;
   gpuTexture;
+  _isDestroyed = false;
+  get isDestroyed() {
+    return this._isDestroyed;
+  }
   pid;
   view;
   // Assigned later
@@ -17013,6 +17017,14 @@ class Texture {
       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();
   }
@@ -20276,9 +20288,13 @@ class Reference {
    * @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);
+      }
     }
   }
   /**
@@ -22507,23 +22523,36 @@ class RenderNode extends ComponentBase {
     }
   }
   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;
   }
 }
@@ -22543,6 +22572,7 @@ class Material {
   enable = true;
   _defaultSubShader;
   _shader;
+  _isDestroyed = false;
   constructor() {
     this.instanceID = UUID();
   }
@@ -22657,10 +22687,17 @@ class Material {
     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);
@@ -23165,8 +23202,15 @@ class Shader {
       }
     }
   }
-  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();
@@ -23658,6 +23702,7 @@ class GeometryBase {
   _vertexBuffer;
   _onChange = true;
   _wireframeLines;
+  _isDestroyed = false;
   constructor() {
     this.instanceID = UUID();
     this._attributeMap = /* @__PURE__ */ new Map();
@@ -23904,18 +23949,40 @@ class GeometryBase {
     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;
   }
 }
 
@@ -25316,10 +25383,22 @@ class Entity extends CEventDispatcher {
         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();
@@ -25591,6 +25670,16 @@ let Object3D = class extends Entity {
       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);
   }
 };
@@ -32905,6 +32994,12 @@ class BitmapTexture2D extends Texture {
     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 () => {
@@ -32972,17 +33067,32 @@ class BitmapTexture2D extends Texture {
     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 {
@@ -36230,6 +36340,7 @@ class GLBParser extends ParserBase {
       this._gltf,
       this._gltf.scene
     );
+    subParser.destroy();
     if (nodes) {
       this.data = nodes.rootNode;
       return nodes.rootNode;
@@ -36267,6 +36378,7 @@ class GLBParser extends ParserBase {
       this._gltf,
       this._gltf.scene
     );
+    subParser.destroy();
     if (nodes) {
       this.data = nodes.rootNode;
       return nodes.rootNode;
@@ -39067,6 +39179,12 @@ class FeatureTable {
       return data;
     }
   }
+  destroy() {
+    this.buffer = null;
+    this.header = null;
+    this.binOffset = null;
+    this.binLength = null;
+  }
 }
 class BatchTable extends FeatureTable {
   batchSize;
@@ -40992,6 +41110,25 @@ class Res {
     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;
@@ -41288,7 +41425,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.24";
+const version = "1.0.25";
 
 class Engine3D {
   /**
@@ -62520,7 +62657,7 @@ class TilesRenderer {
             if (sceneObj.parent) {
               sceneObj.parent.object3D.removeChild(sceneObj);
             }
-            sceneObj.destroy();
+            sceneObj.destroy(true);
             tileItem.cached.scene = null;
           }
           tileItem.loadingState = UNLOADED;
@@ -62834,7 +62971,7 @@ class TilesRenderer {
   /**
    * Clean up resources
    */
-  dispose() {
+  dispose(force) {
     const plugins = [...this.plugins];
     plugins.forEach((plugin) => this.unregisterPlugin(plugin));
     this.lruCache.clear();
@@ -62846,7 +62983,7 @@ class TilesRenderer {
     this.frameCount = 0;
     this.isLoading = false;
     this.resetCacheStats();
-    this.group.destroy();
+    this.group.destroy(force);
   }
   /**
    * Rings-specific: Add camera