@zephyr3d/scene 0.4.0 → 0.6.0

package/dist/render/render_queue.js

@@ -6,12 +6,12 @@ import { ShaderHelper } from '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
+import { RenderBundleWrapper } from './renderbundle_wrapper.js';
 import '../material/meshmaterial.js';
 import '../material/grassmaterial.js';
 import '../material/terrainmaterial.js';
 import '../material/pbrmr.js';
 import '../material/pbrsg.js';
-import { RenderBundleWrapper } from './renderbundle_wrapper.js';
 
 const maxBufferSizeInFloats = 65536 / 4;
 /** @internal */ class InstanceBindGroupAllocator {
@@ -63,7 +63,7 @@ const defaultInstanceBindGroupAlloator = new InstanceBindGroupAllocator();
  * A queue that contains the items to be rendered
  * @public
  */ class RenderQueue {
-    /** @internal */ _itemLists;
+    /** @internal */ _itemList;
     /** @internal */ _renderPass;
     /** @internal */ _shadowedLightList;
     /** @internal */ _unshadowedLightList;
@@ -71,12 +71,15 @@ const defaultInstanceBindGroupAlloator = new InstanceBindGroupAllocator();
     /** @internal */ _bindGroupAllocator;
     /** @internal */ _ref;
     /** @internal */ _instanceInfo;
+    /** @internal */ _needSceneColor;
+    /** @internal */ _drawTransparent;
+    /** @internal */ _objectColorMaps;
     /**
    * Creates an instance of a render queue
    * @param renderPass - The render pass to which the render queue belongs
    */ constructor(renderPass, bindGroupAllocator){
         this._bindGroupAllocator = bindGroupAllocator ?? defaultInstanceBindGroupAlloator;
-        this._itemLists = {};
+        this._itemList = null;
         this._renderPass = renderPass;
         this._shadowedLightList = [];
         this._unshadowedLightList = [];
@@ -85,6 +88,11 @@ const defaultInstanceBindGroupAlloator = new InstanceBindGroupAllocator();
             ref: this
         };
         this._instanceInfo = new Map();
+        this._needSceneColor = false;
+        this._drawTransparent = false;
+        this._objectColorMaps = [
+            new Map()
+        ];
     }
     /** The sun light */ get sunLight() {
         return this._sunLight;
@@ -92,13 +100,19 @@ const defaultInstanceBindGroupAlloator = new InstanceBindGroupAllocator();
     set sunLight(light) {
         this._sunLight = light;
     }
+    /** Whether this render queue requires scene color pass */ get needSceneColor() {
+        return this._needSceneColor;
+    }
+    /** Whether this render queue has transparent objects to be drawn */ get drawTransparent() {
+        return this._drawTransparent;
+    }
     /** The render pass to which the render queue belongs */ get renderPass() {
         return this._renderPass;
     }
     /**
    * Gets the items of the render queue
-   */ get items() {
-        return this._itemLists;
+   */ get itemList() {
+        return this._itemList;
     }
     /**
    * Gets the shadowed lights
@@ -147,35 +161,45 @@ const defaultInstanceBindGroupAlloator = new InstanceBindGroupAllocator();
    * Push items from another render queue
    * @param queue - The render queue to be pushed
    */ pushRenderQueue(queue) {
-        for(const order in queue._itemLists){
-            let itemLists = this._itemLists[order];
-            if (!itemLists) {
-                itemLists = this.newRenderItemList(true);
-                this._itemLists[order] = itemLists;
-            }
-            const newItemLists = queue._itemLists[order];
-            itemLists.opaque.lit.push(...newItemLists.opaque.lit);
-            itemLists.opaque.unlit.push(...newItemLists.opaque.unlit);
-            itemLists.transparent.lit.push(...newItemLists.transparent.lit);
-            itemLists.transparent.unlit.push(...newItemLists.transparent.unlit);
+        const newItemLists = queue._itemList;
+        if (!newItemLists) {
+            return;
+        }
+        if (!this._itemList) {
+            this._itemList = this.newRenderItemList();
         }
+        this._itemList.opaque.lit.push(...newItemLists.opaque.lit);
+        this._itemList.opaque.unlit.push(...newItemLists.opaque.unlit);
+        this._itemList.transmission.lit.push(...newItemLists.transmission.lit);
+        this._itemList.transmission.unlit.push(...newItemLists.transmission.unlit);
+        this._itemList.transparent.lit.push(...newItemLists.transparent.lit);
+        this._itemList.transparent.unlit.push(...newItemLists.transparent.unlit);
+        this._itemList.transmission_trans.lit.push(...newItemLists.transmission_trans.lit);
+        this._itemList.transmission_trans.unlit.push(...newItemLists.transmission_trans.unlit);
+        this._needSceneColor ||= queue._needSceneColor;
+        this._drawTransparent ||= queue._drawTransparent;
+        this._objectColorMaps.push(...queue._objectColorMaps);
     }
     /**
    * Push an item to the render queue
    * @param camera - The camera for drawing the item
    * @param drawable - The object to be drawn
-   * @param renderOrder - Render order of the object
-   */ push(camera, drawable, renderOrder) {
+   */ push(camera, drawable) {
         if (drawable) {
-            let itemList = this._itemLists[renderOrder];
-            if (!itemList) {
-                itemList = this.newRenderItemList(false);
-                this._itemLists[renderOrder] = itemList;
+            if (!this._itemList) {
+                this._itemList = this.newRenderItemList();
             }
             const trans = drawable.getQueueType() === QUEUE_TRANSPARENT;
             const unlit = drawable.isUnlit();
+            const transmission = drawable.needSceneColor();
+            this._needSceneColor ||= transmission;
+            this._drawTransparent ||= trans;
+            if (camera.enablePicking) {
+                drawable.getMaterial().objectColor = drawable.getObjectColor();
+                this._objectColorMaps[0].set(drawable.getId(), drawable);
+            }
             if (drawable.isBatchable()) {
-                const instanceList = trans ? unlit ? itemList.transparent.unlit[0].instanceList : itemList.transparent.lit[0].instanceList : unlit ? itemList.opaque.unlit[0].instanceList : itemList.opaque.lit[0].instanceList;
+                const instanceList = trans ? transmission ? unlit ? this._itemList.transmission_trans.unlit[0].instanceList : this._itemList.transmission_trans.lit[0].instanceList : unlit ? this._itemList.transparent.unlit[0].instanceList : this._itemList.transparent.lit[0].instanceList : transmission ? unlit ? this._itemList.transmission.unlit[0].instanceList : this._itemList.transmission.lit[0].instanceList : unlit ? this._itemList.opaque.unlit[0].instanceList : this._itemList.opaque.lit[0].instanceList;
                 const hash = drawable.getInstanceId(this._renderPass);
                 let drawableList = instanceList[hash];
                 if (!drawableList) {
@@ -184,8 +208,20 @@ const defaultInstanceBindGroupAlloator = new InstanceBindGroupAllocator();
                 }
                 drawableList.push(drawable);
             } else {
-                const list = trans ? unlit ? itemList.transparent.unlit[0] : itemList.transparent.lit[0] : unlit ? itemList.opaque.unlit[0] : itemList.opaque.lit[0];
-                this.binaryInsert(drawable.getBoneMatrices() ? list.skinItemList : list.itemList, {
+                const list = trans ? transmission ? unlit ? this._itemList.transmission_trans.unlit[0] : this._itemList.transmission_trans.lit[0] : unlit ? this._itemList.transparent.unlit[0] : this._itemList.transparent.lit[0] : transmission ? unlit ? this._itemList.transmission.unlit[0] : this._itemList.transmission.lit[0] : unlit ? this._itemList.opaque.unlit[0] : this._itemList.opaque.lit[0];
+                const skinAnimation = !!drawable.getBoneMatrices();
+                const morphAnimation = !!drawable.getMorphData();
+                let queue;
+                if (skinAnimation && morphAnimation) {
+                    queue = list.skinAndMorphItemList;
+                } else if (skinAnimation) {
+                    queue = list.skinItemList;
+                } else if (morphAnimation) {
+                    queue = list.morphItemList;
+                } else {
+                    queue = list.itemList;
+                }
+                this.binaryInsert(queue, {
                     drawable,
                     sortDistance: drawable.getSortDistance(camera),
                     instanceData: null
@@ -199,13 +235,53 @@ const defaultInstanceBindGroupAlloator = new InstanceBindGroupAllocator();
             drawable.pushRenderQueueRef(this._ref);
         }
     }
+    /** @internal */ getDrawableByColor(c) {
+        const id = (c[0] << 24) + (c[1] << 16) + (c[2] << 8) + c[3];
+        for (const m of this._objectColorMaps){
+            const drawable = m.get(id);
+            if (drawable) {
+                return drawable;
+            }
+        }
+        return null;
+    }
     /**
    * Removes all items in the render queue
    */ reset() {
-        this._itemLists = {};
+        if (this._itemList) {
+            // Release all render bundles
+            for(const k in this._itemList){
+                const itemListBundle = this._itemList[k];
+                for(const l in itemListBundle){
+                    const listInfo = itemListBundle[l];
+                    for (const info of listInfo){
+                        if (info.renderQueue === this) {
+                            if (info.renderBundle) {
+                                info.renderBundle.dispose();
+                            }
+                            if (info.skinRenderBundle) {
+                                info.skinRenderBundle.dispose();
+                            }
+                            if (info.morphRenderBundle) {
+                                info.morphRenderBundle.dispose();
+                            }
+                            if (info.skinAndMorphRenderBundle) {
+                                info.skinAndMorphRenderBundle.dispose();
+                            }
+                            if (info.instanceRenderBundle) {
+                                info.instanceRenderBundle.dispose();
+                            }
+                        }
+                    }
+                }
+            }
+            this._itemList = null;
+        }
         this._shadowedLightList = [];
         this._unshadowedLightList = [];
         this._sunLight = null;
+        this._needSceneColor = false;
+        this._drawTransparent = false;
     }
     /** @internal */ dispose() {
         this._ref.ref = null;
@@ -214,95 +290,86 @@ const defaultInstanceBindGroupAlloator = new InstanceBindGroupAllocator();
     }
     /** @internal */ end(camera, createRenderBundles) {
         const frameCounter = Application.instance.device.frameInfo.frameCounter;
-        for(const k in this._itemLists){
-            const itemList = this._itemLists[k];
-            const lists = [
-                itemList.opaque.lit,
-                itemList.opaque.unlit,
-                itemList.transparent.lit,
-                itemList.transparent.unlit
-            ];
-            for(let i = 0; i < 4; i++){
-                const list = lists[i];
-                for (const info of list){
-                    if (info.renderQueue !== this) {
-                        continue;
-                    }
-                    const instanceList = info.instanceList;
-                    for(const x in instanceList){
-                        const drawables = instanceList[x];
-                        if (drawables.length === 1) {
-                            this.binaryInsert(info.itemList, {
-                                drawable: drawables[0],
-                                sortDistance: drawables[0].getSortDistance(camera),
-                                instanceData: null
-                            });
-                            drawables[0].applyTransformUniforms(this);
-                            const mat = drawables[0].getMaterial();
-                            if (mat) {
-                                info.materialList.add(mat.coreMaterial);
-                            }
-                        } else {
-                            let bindGroup = null;
-                            let item = null;
-                            for(let i = 0; i < drawables.length; i++){
-                                const drawable = drawables[i];
-                                const instanceUniforms = drawable.getInstanceUniforms();
-                                const instanceUniformsSize = instanceUniforms?.length ?? 0;
-                                const stride = 16 + instanceUniformsSize;
-                                if (!bindGroup || bindGroup.offset + stride > maxBufferSizeInFloats) {
-                                    bindGroup = this._bindGroupAllocator.allocateInstanceBindGroup(frameCounter, stride);
-                                    item = {
-                                        drawable,
-                                        sortDistance: drawable.getSortDistance(camera),
-                                        instanceData: {
-                                            bindGroup,
-                                            offset: bindGroup.offset,
-                                            numInstances: 0,
-                                            stride
-                                        }
-                                    };
-                                    this.binaryInsert(info.instanceItemList, item);
-                                    drawable.applyInstanceOffsetAndStride(this, stride, bindGroup.offset);
-                                }
-                                const instanceInfo = {
+        const itemList = this._itemList;
+        if (!this.itemList) {
+            return this;
+        }
+        const lists = [
+            itemList.opaque.lit,
+            itemList.opaque.unlit,
+            itemList.transmission.lit,
+            itemList.transmission.unlit,
+            itemList.transparent.lit,
+            itemList.transparent.unlit,
+            itemList.transmission_trans.lit,
+            itemList.transmission_trans.unlit
+        ];
+        for(let i = 0; i < lists.length; i++){
+            const list = lists[i];
+            for (const info of list){
+                if (info.renderQueue !== this) {
+                    continue;
+                }
+                const instanceList = info.instanceList;
+                for(const x in instanceList){
+                    const drawables = instanceList[x];
+                    let bindGroup = null;
+                    let item = null;
+                    for(let i = 0; i < drawables.length; i++){
+                        const drawable = drawables[i];
+                        const instanceUniforms = drawable.getInstanceUniforms();
+                        const instanceUniformsSize = instanceUniforms?.length ?? 0;
+                        const stride = 16 + instanceUniformsSize;
+                        if (!bindGroup || bindGroup.offset + stride > maxBufferSizeInFloats) {
+                            bindGroup = this._bindGroupAllocator.allocateInstanceBindGroup(frameCounter, stride);
+                            item = {
+                                drawable,
+                                sortDistance: drawable.getSortDistance(camera),
+                                instanceData: {
                                     bindGroup,
-                                    offset: bindGroup.offset
-                                };
-                                this._instanceInfo.set(drawable, instanceInfo);
-                                drawable.applyTransformUniforms(this);
-                                drawable.applyMaterialUniforms(instanceInfo);
-                                bindGroup.offset += stride;
-                                item.instanceData.numInstances++;
-                                const mat = drawable.getMaterial();
-                                if (mat) {
-                                    info.materialList.add(mat.coreMaterial);
+                                    offset: bindGroup.offset,
+                                    numInstances: 0,
+                                    stride
                                 }
-                            }
-                        }
-                    }
-                    info.instanceList = {};
-                    if (createRenderBundles) {
-                        if (info.itemList.length > 0) {
-                            info.renderBundle = new RenderBundleWrapper();
-                        }
-                        if (info.skinItemList.length > 0) {
-                            info.skinRenderBundle = new RenderBundleWrapper();
+                            };
+                            this.binaryInsert(info.instanceItemList, item);
+                            drawable.applyInstanceOffsetAndStride(this, stride, bindGroup.offset);
                         }
-                        if (info.instanceItemList.length > 0) {
-                            info.instanceRenderBundle = new RenderBundleWrapper();
+                        const instanceInfo = {
+                            bindGroup,
+                            offset: bindGroup.offset
+                        };
+                        this._instanceInfo.set(drawable, instanceInfo);
+                        drawable.applyTransformUniforms(this);
+                        drawable.applyMaterialUniforms(instanceInfo);
+                        bindGroup.offset += stride;
+                        item.instanceData.numInstances++;
+                        const mat = drawable.getMaterial();
+                        if (mat) {
+                            info.materialList.add(mat.coreMaterial);
                         }
                     }
                 }
+                info.instanceList = {};
+                if (createRenderBundles) {
+                    if (info.itemList.length > 0) {
+                        info.renderBundle = new RenderBundleWrapper();
+                    }
+                    if (info.skinItemList.length > 0) {
+                        info.skinRenderBundle = new RenderBundleWrapper();
+                    }
+                    if (info.morphItemList.length > 0) {
+                        info.morphRenderBundle = new RenderBundleWrapper();
+                    }
+                    if (info.skinAndMorphItemList.length > 0) {
+                        info.skinAndMorphRenderBundle = new RenderBundleWrapper();
+                    }
+                    if (info.instanceItemList.length > 0) {
+                        info.instanceRenderBundle = new RenderBundleWrapper();
+                    }
+                }
             }
-        /*
-      itemList.opaque.lit.forEach(info => {
-        info.itemList.sort((a, b) => (a.drawable.getMaterial()?.instanceId ?? 0) - (b.drawable.getMaterial()?.instanceId ?? 0))
-      });
-      itemList.opaque.unlit.forEach(info => {
-        info.itemList.sort((a, b) => (a.drawable.getMaterial()?.instanceId ?? 0) - (b.drawable.getMaterial()?.instanceId ?? 0))
-      });
-      */ }
+        }
         return this;
     }
     binaryInsert(itemList, item) {
@@ -326,63 +393,49 @@ const defaultInstanceBindGroupAlloator = new InstanceBindGroupAllocator();
     /**
    * Sorts the items in the render queue for rendering
    */ sortTransparentItems(cameraPos) {
-        for (const list of Object.values(this._itemLists)){
-            list.transparent.lit[0].itemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
-            list.transparent.lit[0].skinItemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
-            list.transparent.unlit[0].itemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
-            list.transparent.unlit[0].skinItemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
+        if (this._itemList) {
+            this._itemList.transparent.lit[0].itemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
+            this._itemList.transparent.lit[0].skinItemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
+            this._itemList.transparent.lit[0].morphItemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
+            this._itemList.transparent.lit[0].skinAndMorphItemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
+            this._itemList.transparent.unlit[0].itemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
+            this._itemList.transparent.unlit[0].skinItemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
+            this._itemList.transparent.unlit[0].morphItemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
+            this._itemList.transparent.unlit[0].skinAndMorphItemList.sort((a, b)=>this.drawableDistanceToCamera(b.drawable, cameraPos) - this.drawableDistanceToCamera(a.drawable, cameraPos));
         }
     }
     drawableDistanceToCamera(drawable, cameraPos) {
         const drawablePos = drawable.getXForm().position;
         return Vector3.distanceSq(drawablePos, cameraPos);
     }
-    newRenderItemList(empty) {
+    newRenderItemListInfo() {
         return {
-            opaque: {
-                lit: empty ? [] : [
-                    {
-                        itemList: [],
-                        skinItemList: [],
-                        instanceItemList: [],
-                        materialList: new Set(),
-                        instanceList: {},
-                        renderQueue: this
-                    }
-                ],
-                unlit: empty ? [] : [
-                    {
-                        itemList: [],
-                        skinItemList: [],
-                        instanceItemList: [],
-                        materialList: new Set(),
-                        instanceList: {},
-                        renderQueue: this
-                    }
-                ]
-            },
-            transparent: {
-                lit: empty ? [] : [
-                    {
-                        itemList: [],
-                        skinItemList: [],
-                        instanceItemList: [],
-                        materialList: new Set(),
-                        instanceList: {},
-                        renderQueue: this
-                    }
-                ],
-                unlit: empty ? [] : [
-                    {
-                        itemList: [],
-                        skinItemList: [],
-                        instanceItemList: [],
-                        materialList: new Set(),
-                        instanceList: {},
-                        renderQueue: this
-                    }
-                ]
-            }
+            itemList: [],
+            skinItemList: [],
+            morphItemList: [],
+            skinAndMorphItemList: [],
+            instanceItemList: [],
+            materialList: new Set(),
+            instanceList: {},
+            renderQueue: this
+        };
+    }
+    newRenderItemListBundle() {
+        return {
+            lit: [
+                this.newRenderItemListInfo()
+            ],
+            unlit: [
+                this.newRenderItemListInfo()
+            ]
+        };
+    }
+    newRenderItemList() {
+        return {
+            opaque: this.newRenderItemListBundle(),
+            transmission: this.newRenderItemListBundle(),
+            transparent: this.newRenderItemListBundle(),
+            transmission_trans: this.newRenderItemListBundle()
         };
     }
 }

package/dist/render/render_queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"render_queue.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"render_queue.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/render/renderbundle_wrapper.js

@@ -2,8 +2,80 @@ import { Application } from '../app.js';
 
 class RenderBundleWrapper {
     _renderBundles;
+    _disposed;
+    static _drawableContainer = new WeakMap();
+    static _materialContainer = new WeakMap();
+    /** @internal */ static addDrawable(drawable, material, wrapper, hash) {
+        let renderBundles = this._drawableContainer.get(drawable);
+        if (!renderBundles) {
+            renderBundles = [];
+            this._drawableContainer.set(drawable, renderBundles);
+        }
+        const index = renderBundles.findIndex((rb)=>rb.wrapper === wrapper);
+        if (index < 0) {
+            renderBundles.push({
+                wrapper: wrapper,
+                hashes: [
+                    hash
+                ]
+            });
+        } else {
+            if (!renderBundles[index].hashes.includes(hash)) {
+                renderBundles[index].hashes.push(hash);
+            }
+        }
+        if (material) {
+            let ownDrawables = this._materialContainer.get(material);
+            if (!ownDrawables) {
+                ownDrawables = new Set();
+                this._materialContainer.set(material, ownDrawables);
+            }
+            ownDrawables.add(drawable);
+        }
+    }
+    /** @internal */ static drawableChanged(drawable) {
+        const renderBundles = this._drawableContainer.get(drawable);
+        if (renderBundles) {
+            for(let i = renderBundles.length - 1; i >= 0; i--){
+                const renderBundle = renderBundles[i].wrapper;
+                if (renderBundle.disposed) {
+                    renderBundles.splice(i, 1);
+                } else {
+                    for (const hash of renderBundles[i].hashes){
+                        renderBundles[i].wrapper.invalidate(hash);
+                    }
+                }
+            }
+        }
+    }
+    /** @internal */ static materialChanged(material) {
+        const ownDrawables = this._materialContainer.get(material);
+        if (ownDrawables) {
+            for (const drawable of ownDrawables){
+                this.drawableChanged(drawable);
+            }
+        }
+    }
+    /** @internal */ static materialAttached(material, drawable) {
+        const ownDrawables = this._materialContainer.get(material);
+        if (ownDrawables && !ownDrawables.has(drawable)) {
+            ownDrawables.add(drawable);
+            this.drawableChanged(drawable);
+        }
+    }
+    /** @internal */ static materialDetached(material, drawable) {
+        const ownDrawables = this._materialContainer.get(material);
+        if (ownDrawables && ownDrawables.has(drawable)) {
+            ownDrawables.delete(drawable);
+            this.drawableChanged(drawable);
+        }
+    }
     constructor(){
         this._renderBundles = {};
+        this._disposed = false;
+    }
+    get disposed() {
+        return this._disposed;
     }
     getRenderBundle(hash) {
         return this._renderBundles[hash] ?? null;
@@ -14,6 +86,13 @@ class RenderBundleWrapper {
     endRenderBundle(hash) {
         this._renderBundles[hash] = Application.instance.device.endCapture();
     }
+    invalidate(hash) {
+        this._renderBundles[hash] = undefined;
+    }
+    dispose() {
+        this._renderBundles = {};
+        this._disposed = true;
+    }
 }
 
 export { RenderBundleWrapper };

package/dist/render/renderbundle_wrapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"renderbundle_wrapper.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"renderbundle_wrapper.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}