@zephyr3d/scene 0.4.0 → 0.6.0

package/dist/render/watermesh.js.map

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

package/dist/render/wavegenerator.js

@@ -0,0 +1,8 @@
+/**
+ * Abstract class for wave generators.
+ * @public
+ */ class WaveGenerator {
+}
+
+export { WaveGenerator };
+//# sourceMappingURL=wavegenerator.js.map

package/dist/render/wavegenerator.js.map

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

package/dist/render/weightedblended_oit.js

@@ -14,12 +14,10 @@ import { Vector4 } from '@zephyr3d/base';
     static _compositeProgram;
     static _compositeBindGroup;
     static _compositeRenderStates;
-    _accumBuffer;
     /**
    * Creates an instance of WeightedBlendedOIT class.
    */ constructor(){
         super();
-        this._accumBuffer = null;
     }
     /**
    * {@inheritDoc OIT.getType}
@@ -121,32 +119,17 @@ import { Vector4 } from '@zephyr3d/base';
         drawFullscreenQuad(WeightedBlendedOIT._compositeRenderStates);
     }
     /** @internal */ getAccumFramebuffer(ctx, device) {
-        const vp = device.getViewport();
-        const width = device.screenToDevice(vp.width);
-        const height = device.screenToDevice(vp.height);
-        if (this._accumBuffer) {
-            if (this._accumBuffer.getWidth() !== width || this._accumBuffer.getHeight() !== height || this._accumBuffer.getDepthAttachment() !== ctx.depthTexture) {
-                this._accumBuffer.dispose();
-                this._accumBuffer = null;
-            }
-        }
-        if (!this._accumBuffer) {
-            const accumColor = device.createTexture2D('rgba16f', width, height, {
-                samplerOptions: {
-                    mipFilter: 'none'
-                }
-            });
-            const accumAlpha = device.createTexture2D(device.type === 'webgl' ? 'rgba16f' : 'r16f', width, height, {
-                samplerOptions: {
-                    mipFilter: 'none'
-                }
-            });
-            this._accumBuffer = device.createFrameBuffer([
-                accumColor,
-                accumAlpha
-            ], ctx.depthTexture);
-        }
-        return this._accumBuffer;
+        const width = ctx.depthTexture.width;
+        const height = ctx.depthTexture.height;
+        const accumColor = device.pool.fetchTemporalTexture2D(false, 'rgba16f', width, height, false);
+        const accumAlpha = device.pool.fetchTemporalTexture2D(false, device.type === 'webgl' ? 'rgba16f' : 'r16f', width, height, false);
+        const fb = device.pool.createTemporalFramebuffer(true, [
+            accumColor,
+            accumAlpha
+        ], ctx.depthTexture);
+        device.pool.releaseTexture(accumColor);
+        device.pool.releaseTexture(accumAlpha);
+        return fb;
     }
     /** @internal */ static getCompositeProgram(device) {
         if (!this._compositeProgram) {

package/dist/render/weightedblended_oit.js.map

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

package/dist/scene/batchgroup.js

@@ -1,6 +1,7 @@
 import { GraphNode } from './graph_node.js';
-import '@zephyr3d/base';
+import { Matrix4x4 } from '@zephyr3d/base';
 import './octree.js';
+import '../values.js';
 import '../app.js';
 import { InstanceBindGroupAllocator, RenderQueue } from '../render/render_queue.js';
 import '../material/shader/helper.js';
@@ -8,7 +9,6 @@ import '../render/renderer.js';
 import '../render/sky.js';
 import '../render/clipmap.js';
 import '@zephyr3d/device';
-import '../render/watermesh.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
@@ -17,7 +17,9 @@ import '../material/grassmaterial.js';
 import '../material/terrainmaterial.js';
 import '../material/pbrmr.js';
 import '../material/pbrsg.js';
+import { BoundingBox } from '../utility/bounding_volume.js';
 
+const tmpMatrix = new Matrix4x4();
 /**
  * Batch group node
  * @public
@@ -25,32 +27,44 @@ import '../material/pbrsg.js';
     _renderQueueMap;
     _bindGroupAllocator;
     _changeTag;
+    _staticBV;
     /**
    * Creates an instance of mesh node
    * @param scene - The scene to which the mesh node belongs
    */ constructor(scene){
         super(scene);
-        this._renderQueueMap = new WeakMap();
+        this._renderQueueMap = new Map();
         this._changeTag = 0;
         this._bindGroupAllocator = new InstanceBindGroupAllocator();
+        this._staticBV = false;
+        const bvCallback = (function() {
+            if (!this._staticBV) {
+                this.invalidateBoundingVolume();
+            }
+        }).bind(this);
         this.on('nodeattached', (node)=>{
             node.iterate((child)=>{
-                if (child.isGraphNode()) {
-                    if (!child.isMesh()) {
-                        console.error('Only mesh node can be added to batch group');
-                    }
+                if (child.isMesh()) {
                     child.placeToOctree = false;
+                    if (!this._staticBV) {
+                        this.invalidateBoundingVolume();
+                    }
+                    child.on('bvchanged', bvCallback);
+                    this._changeTag++;
                 }
             });
-            this._changeTag++;
         });
         this.on('noderemoved', (node)=>{
             node.iterate((child)=>{
-                if (child.isGraphNode()) {
+                if (child.isMesh()) {
                     child.placeToOctree = true;
+                    if (!this._staticBV) {
+                        this.invalidateBoundingVolume();
+                    }
+                    child.off('bvchanged', bvCallback);
+                    this._changeTag++;
                 }
             });
-            this._changeTag++;
         });
     }
     /**
@@ -63,10 +77,42 @@ import '../material/pbrsg.js';
    */ isBatchGroup() {
         return true;
     }
-    /** @internal */ computeBoundingVolume(bv) {
-        return super.computeBoundingVolume(bv);
+    /**
+   * Force the batch state to be rebuilt
+   */ invalidate() {
+        this._changeTag++;
+    }
+    /** @internal */ _detached() {
+        // Usually the node will be garbage collected after it is detached,
+        // We should reset the render queue to release the render bundles.
+        this._renderQueueMap.forEach((val)=>{
+            val.queue.reset();
+        });
+        this.invalidate();
+    }
+    /** @internal */ _attached() {
+        // Reset the render queue when attached to a new scene.
+        this.invalidate();
+    }
+    /** @internal */ computeBoundingVolume() {
+        const bv = new BoundingBox();
+        const invWorldMatrix = Matrix4x4.invertAffine(this.worldMatrix);
+        bv.beginExtend();
+        this.iterate((node)=>{
+            if (node.isMesh()) {
+                Matrix4x4.multiplyAffine(invWorldMatrix, node.worldMatrix, tmpMatrix);
+                const wb = node.getBoundingVolume().transform(tmpMatrix).toAABB();
+                bv.extend(wb.minPoint);
+                bv.extend(wb.maxPoint);
+            }
+        });
+        return bv.isValid() ? bv : null;
+    }
+    /** @internal */ setBoundingVolume(bv) {
+        this._staticBV = !!bv;
+        super.setBoundingVolume(bv);
     }
-    getRenderQueue(cullVisitor) {
+    /** @internal */ cull(cullVisitor) {
         let queueInfo = this._renderQueueMap.get(cullVisitor.renderPass);
         if (!queueInfo) {
             queueInfo = {
@@ -91,7 +137,7 @@ import '../material/pbrsg.js';
             cullVisitor.frustumCulling = frustumCulling;
             cullVisitor.renderQueue = renderQueue;
         }
-        return queueInfo.queue;
+        cullVisitor.pushRenderQueue(queueInfo.queue);
     }
 }
 

package/dist/scene/batchgroup.js.map

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

package/dist/scene/environment.js

@@ -1,5 +1,6 @@
 import { Vector4 } from '@zephyr3d/base';
 import './octree.js';
+import '../values.js';
 import '../app.js';
 import '@zephyr3d/device';
 import '../material/shader/helper.js';
@@ -14,8 +15,7 @@ import '../material/pbrsg.js';
 import '../render/renderer.js';
 import { SkyRenderer } from '../render/sky.js';
 import '../render/clipmap.js';
-import { EnvIBL, EnvHemisphericAmbient, EnvConstantAmbient } from '../render/envlight.js';
-import '../render/watermesh.js';
+import { EnvIBL, EnvHemisphericAmbient, EnvConstantAmbient, EnvShIBL } from '../render/envlight.js';
 
 /**
  * Wrapper for environmant lighting
@@ -27,6 +27,7 @@ import '../render/watermesh.js';
     _ambientUp;
     _radianceMap;
     _irradianceMap;
+    _irradianceSH;
     _strength;
     /** @internal */ constructor(){
         this._envLight = new EnvIBL();
@@ -38,7 +39,7 @@ import '../render/watermesh.js';
         this._strength = 1;
     }
     /** @internal */ getHash(ctx) {
-        return ctx.drawEnvLight ? `${this.type}:${this._envLight.hasRadiance() ? '1' : '0'}:${this._envLight.hasIrradiance() ? '1' : '0'}` : 'none';
+        return !ctx || ctx.drawEnvLight ? `${this.type}:${this._envLight.hasRadiance() ? '1' : '0'}:${this._envLight.hasIrradiance() ? '1' : '0'}` : 'none';
     }
     /** @internal */ get envLight() {
         return this._envLight;
@@ -83,6 +84,8 @@ import '../render/watermesh.js';
         this._radianceMap = tex ?? null;
         if (this.type === 'ibl') {
             this._envLight.radianceMap = this._radianceMap;
+        } else if (this.type === 'ibl-sh') {
+            this._envLight.radianceMap = this._radianceMap;
         }
     }
     /** Irradiance map for environment light type ibl */ get irradianceMap() {
@@ -94,6 +97,15 @@ import '../render/watermesh.js';
             this._envLight.irradianceMap = this._irradianceMap;
         }
     }
+    /** Irradiance SH for environment light type ibl-sh */ get irradianceSH() {
+        return this._irradianceSH;
+    }
+    set irradianceSH(value) {
+        this._irradianceSH = value ?? null;
+        if (this.type === 'ibl-sh') {
+            this._envLight.irradianceSH = this._irradianceSH;
+        }
+    }
     /** The environment light type */ get type() {
         return this._envLight?.getType() ?? 'none';
     }
@@ -106,6 +118,15 @@ import '../render/watermesh.js';
                 if (this._envLight?.getType() !== val) {
                     this._envLight = new EnvIBL(this._radianceMap, this._irradianceMap);
                 }
+                this._envLight.radianceMap = this.radianceMap;
+                this._envLight.irradianceMap = this.irradianceMap;
+                break;
+            case 'ibl-sh':
+                if (this._envLight?.getType() !== val) {
+                    this._envLight = new EnvShIBL(this._radianceMap, this._irradianceSH);
+                }
+                this._envLight.radianceMap = this.radianceMap;
+                this._envLight.irradianceSH = this.irradianceSH;
                 break;
             case 'constant':
                 if (this._envLight?.getType() !== val) {

package/dist/scene/environment.js.map

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

package/dist/scene/graph_node.js

@@ -15,7 +15,6 @@ import { SceneNode } from './scene_node.js';
    * @param scene - The scene to which the node belongs
    */ constructor(scene){
         super(scene);
-        this._renderOrder = 0;
         this._octreeNode = null;
     }
     /** @internal */ get octreeNode() {
@@ -24,14 +23,6 @@ import { SceneNode } from './scene_node.js';
     set octreeNode(node) {
         this._octreeNode = node;
     }
-    /**
-   * Render order of the node
-   */ get renderOrder() {
-        return this._renderOrder;
-    }
-    set renderOrder(val) {
-        this._renderOrder = val;
-    }
     /** Gets the name */ getName() {
         return this._name;
     }
@@ -52,11 +43,6 @@ import { SceneNode } from './scene_node.js';
         return null;
     }
     /**
-   * {@inheritDoc Drawable.getInvBindMatrix}
-   */ getInvBindMatrix() {
-        return null;
-    }
-    /**
    * {@inheritDoc Drawable.getSortDistance}
    */ getSortDistance(camera) {
         const cameraWorldMatrix = camera.worldMatrix;

package/dist/scene/graph_node.js.map

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

package/dist/scene/light.js

@@ -293,7 +293,7 @@ export class HemiSphericLight extends AmbientLight {
    */ isDirectionLight() {
         return true;
     }
-    /** @internal */ computeBoundingVolume(bv) {
+    /** @internal */ computeBoundingVolume() {
         return null;
     }
     /** @internal */ computeUniforms() {
@@ -342,8 +342,8 @@ export class HemiSphericLight extends AmbientLight {
    */ isPointLight() {
         return true;
     }
-    /** @internal */ computeBoundingVolume(bv) {
-        const bbox = bv ? bv : new BoundingBox();
+    /** @internal */ computeBoundingVolume() {
+        const bbox = new BoundingBox();
         bbox.minPoint = new Vector3(-this._range, -this._range, -this._range);
         bbox.maxPoint = new Vector3(this._range, this._range, this._range);
         return bbox;
@@ -415,8 +415,8 @@ export class HemiSphericLight extends AmbientLight {
    */ isSpotLight() {
         return true;
     }
-    /** @internal */ computeBoundingVolume(bv) {
-        const bbox = bv ? bv : new BoundingBox();
+    /** @internal */ computeBoundingVolume() {
+        const bbox = new BoundingBox();
         const cosCutoff = Math.cos(this._cutoff);
         const r = this._range / cosCutoff * Math.sqrt(1 - cosCutoff * cosCutoff);
         bbox.minPoint = new Vector3(-r, -r, 0);

package/dist/scene/mesh.js

@@ -8,6 +8,7 @@ import { LambertMaterial } from '../material/lambert.js';
 import '../material/blinn.js';
 import '../material/unlit.js';
 import { QUEUE_OPAQUE } from '../values.js';
+import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
 import '../material/meshmaterial.js';
 import '../material/grassmaterial.js';
 import '../material/terrainmaterial.js';
@@ -25,9 +26,11 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
     /** @internal */ _bboxChangeCallback;
     /** @internal */ _animatedBoundingBox;
     /** @internal */ _boneMatrices;
-    /** @internal */ _invBindMatrix;
+    /** @internal */ _morphData;
+    /** @internal */ _morphInfo;
     /** @internal */ _instanceHash;
     /** @internal */ _batchable;
+    /** @internal */ _pickTarget;
     /** @internal */ _boundingBoxNode;
     /** @internal */ _instanceColor;
     /**
@@ -40,8 +43,12 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
         this._castShadow = true;
         this._animatedBoundingBox = null;
         this._boneMatrices = null;
-        this._invBindMatrix = null;
+        this._morphData = null;
+        this._morphInfo = null;
         this._instanceHash = null;
+        this._pickTarget = {
+            node: this
+        };
         this._boundingBoxNode = null;
         this._instanceColor = Vector4.zero();
         this._batchable = Application.instance.deviceType !== 'webgl';
@@ -73,7 +80,13 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
     /**
    * {@inheritDoc Drawable.getPickTarget }
    */ getPickTarget() {
-        return this;
+        return this._pickTarget;
+    }
+    setPickTarget(node, label) {
+        this._pickTarget = {
+            node,
+            label
+        };
     }
     /** Wether the mesh node casts shadows */ get castShadow() {
         return this._castShadow;
@@ -95,6 +108,7 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
             }
             this._instanceHash = this._primitive && this._material ? `${this.constructor.name}:${this._scene.id}:${this._primitive.id}:${this._material.instanceId}` : null;
             this.invalidateBoundingVolume();
+            RenderBundleWrapper.drawableChanged(this);
         }
     }
     /** Material of the mesh */ get material() {
@@ -102,8 +116,15 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
     }
     set material(m) {
         if (this._material !== m) {
+            if (this._material) {
+                RenderBundleWrapper.materialDetached(this._material.coreMaterial, this);
+            }
             this._material = m;
+            if (this._material) {
+                RenderBundleWrapper.materialAttached(this._material.coreMaterial, this);
+            }
             this._instanceHash = this._primitive && this._material ? `${this.constructor.name}:${this._scene.id}:${this._primitive.id}:${this._material.instanceId}` : null;
+            RenderBundleWrapper.drawableChanged(this);
         }
     }
     /** Wether to draw the bounding box of the mesh node */ get drawBoundingBox() {
@@ -142,23 +163,49 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
    * Sets the texture that contains the bone matrices for skeletal animation
    * @param matrices - The texture that contains the bone matrices
    */ setBoneMatrices(matrices) {
-        this._boneMatrices = matrices;
+        if (this._boneMatrices !== matrices) {
+            this._boneMatrices = matrices;
+            RenderBundleWrapper.drawableChanged(this);
+        }
     }
     /**
-   * Sets the inverse bind matrix for skeletal animation
-   * @param matrix - The matrix to set
-   */ setInvBindMatrix(matrix) {
-        this._invBindMatrix = matrix;
+   * Sets the texture that contains the morph target data
+   * @param data - The texture that contains the morph target data
+   */ setMorphData(data) {
+        if (this._morphData !== data) {
+            this._morphData = data;
+            RenderBundleWrapper.drawableChanged(this);
+        }
+    }
+    /**
+   * {@inheritDoc Drawable.getMorphData}
+   */ getMorphData() {
+        return this._morphData;
+    }
+    /**
+   * Sets the buffer that contains the morph target information
+   * @param info - The buffer that contains the morph target information
+   */ setMorphInfo(info) {
+        if (this._morphInfo !== info) {
+            this._morphInfo = info;
+            RenderBundleWrapper.drawableChanged(this);
+        }
+    }
+    /**
+   * {@inheritDoc Drawable.getMorphInfo}
+   */ getMorphInfo() {
+        return this._morphInfo;
     }
     /**
    * {@inheritDoc Drawable.isBatchable}
    */ isBatchable() {
-        return this._batchable && !this._boneMatrices && this._material?.isBatchable();
+        return this._batchable && !this._boneMatrices && !this._morphData && this._material?.isBatchable();
     }
     /** Disposes the mesh node */ dispose() {
         this._primitive = null;
         this._material = null;
         super.dispose();
+        RenderBundleWrapper.drawableChanged(this);
     }
     /**
    * {@inheritDoc Drawable.getQueueType}
@@ -171,6 +218,11 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
         return !this.material?.supportLighting();
     }
     /**
+   * {@inheritDoc Drawable.needSceneColor}
+   */ needSceneColor() {
+        return this.material?.needSceneColor();
+    }
+    /**
    * {@inheritDoc Drawable.draw}
    */ draw(ctx) {
         this.bind(ctx);
@@ -187,17 +239,12 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
         return this._boneMatrices;
     }
     /**
-   * {@inheritDoc Drawable.getInvBindMatrix}
-   */ getInvBindMatrix() {
-        return this._invBindMatrix;
-    }
-    /**
    * {@inheritDoc Drawable.getXForm}
    */ getXForm() {
         // mesh transform should be ignored when skinned
         return this;
     }
-    /** @internal */ computeBoundingVolume(bv) {
+    /** @internal */ computeBoundingVolume() {
         let bbox;
         if (this._animatedBoundingBox) {
             bbox = this._animatedBoundingBox;

package/dist/scene/mesh.js.map

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

package/dist/scene/octree.js

@@ -515,9 +515,12 @@ var OctreePlacement;
    * @returns Head node of the located node chain
    */ locateNodeChain(candidate, center, radius) {
         let level = this._chunks.length - 1;
-        while(level && this._chunks[level].getNodeSize() < 4 * radius){
+        while(level >= 0 && this._chunks[level].getNodeSize() < 4 * radius){
             --level;
         }
+        if (level < 0) {
+            return null;
+        }
         const dim = this._chunks[level].getDimension();
         const inv_node_size = 1 / this._chunks[level].getNodeSize();
         const px = Math.floor((center.x + this._rootSize * 0.5) * inv_node_size);
@@ -595,7 +598,7 @@ var OctreePlacement;
         }
     }
     resize(size) {
-        size = Math.max(nextPowerOf2(size), this._leafSize);
+        size = Math.max(nextPowerOf2(Math.ceil(size)), this._leafSize);
         if (size === this._rootSize) {
             return;
         }

package/dist/scene/octree.js.map

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

package/dist/scene/raycast_visitor.js

@@ -38,7 +38,9 @@ import { OctreeNode } from './octree.js';
             const d = node.rayIntersect(this._rayLocal); // this._rayLocal.bboxIntersectionTestEx(node.getBoundingVolume().toAABB());
             if (d !== null && d < this._intersectedDist) {
                 this._intersectedDist = d;
-                this._intersected = node;
+                this._intersected = {
+                    node
+                };
                 return true;
             }
         }
@@ -50,7 +52,7 @@ import { OctreeNode } from './octree.js';
             const d = node.primitive.raycast(this._rayLocal);
             if (d !== null && d < this._intersectedDist) {
                 this._intersectedDist = d;
-                this._intersected = node.getPickTarget() ?? node;
+                this._intersected = node.getPickTarget();
                 return true;
             }
         }

package/dist/scene/raycast_visitor.js.map

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

package/dist/scene/scene.js

@@ -81,18 +81,15 @@ import { Environment } from './environment.js';
     }
     /**
    * Cast a ray into the scene to get the closest object hit by the ray
-   * @param camera - The camera used to compute the ray
-   * @param screenX - The x position on screen
-   * @param screenY - The y position on screen
+   *
+   * @param ray - The ray in world coordinate space
+   * @param length - Length of the ray
    * @returns The closest object hit by the ray
-   */ raycast(camera, screenX, screenY) {
-        const width = camera.viewport ? camera.viewport[2] : Application.instance.device.getViewport().width;
-        const height = camera.viewport ? camera.viewport[3] : Application.instance.device.getViewport().height;
-        const ray = this.constructRay(camera, width, height, screenX, screenY);
-        const raycastVisitor = new RaycastVisitor(ray, camera.getFarPlane());
+   */ raycast(ray, length = Infinity) {
+        const raycastVisitor = new RaycastVisitor(ray, length);
         this.octree.getRootNode().traverse(raycastVisitor);
         return raycastVisitor.intersected ? {
-            node: raycastVisitor.intersected,
+            target: raycastVisitor.intersected,
             dist: raycastVisitor.intersectedDist,
             point: raycastVisitor.intersectedPoint
         } : null;

package/dist/scene/scene.js.map

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