@zephyr3d/scene 0.5.0 → 0.6.1

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/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';
@@ -15,7 +16,6 @@ import '../render/renderer.js';
 import { SkyRenderer } from '../render/sky.js';
 import '../render/clipmap.js';
 import { EnvIBL, EnvHemisphericAmbient, EnvConstantAmbient, EnvShIBL } from '../render/envlight.js';
-import '../render/watermesh.js';
 
 /**
  * Wrapper for environmant lighting
@@ -39,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;

package/dist/scene/graph_node.js

@@ -43,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,11 +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;
     /**
@@ -42,10 +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';
@@ -77,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;
@@ -99,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() {
@@ -106,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() {
@@ -146,19 +163,19 @@ 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;
-    }
-    /**
-   * Sets the inverse bind matrix for skeletal animation
-   * @param matrix - The matrix to set
-   */ setInvBindMatrix(matrix) {
-        this._invBindMatrix = matrix;
+        if (this._boneMatrices !== matrices) {
+            this._boneMatrices = matrices;
+            RenderBundleWrapper.drawableChanged(this);
+        }
     }
     /**
    * Sets the texture that contains the morph target data
    * @param data - The texture that contains the morph target data
    */ setMorphData(data) {
-        this._morphData = data;
+        if (this._morphData !== data) {
+            this._morphData = data;
+            RenderBundleWrapper.drawableChanged(this);
+        }
     }
     /**
    * {@inheritDoc Drawable.getMorphData}
@@ -169,7 +186,10 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
    * Sets the buffer that contains the morph target information
    * @param info - The buffer that contains the morph target information
    */ setMorphInfo(info) {
-        this._morphInfo = info;
+        if (this._morphInfo !== info) {
+            this._morphInfo = info;
+            RenderBundleWrapper.drawableChanged(this);
+        }
     }
     /**
    * {@inheritDoc Drawable.getMorphInfo}
@@ -185,6 +205,7 @@ import { mixinDrawable } from '../render/drawable_mixin.js';
         this._primitive = null;
         this._material = null;
         super.dispose();
+        RenderBundleWrapper.drawableChanged(this);
     }
     /**
    * {@inheritDoc Drawable.getQueueType}
@@ -218,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

@@ -89,7 +89,7 @@ import { Environment } from './environment.js';
         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_node.js

@@ -162,17 +162,16 @@ import { XForm } from './xform.js';
     }
     /**
    * Computes the bounding volume of the node
-   * @param bv - The output bounding volume
    * @returns The output bounding volume
-   */ computeBoundingVolume(bv) {
-        return bv;
+   */ computeBoundingVolume() {
+        return null;
     }
     /**
    * Gets the bounding volume of the node
    * @returns The bounding volume of the node
    */ getBoundingVolume() {
         if (this._bvDirty) {
-            this._bv = this.computeBoundingVolume(this._bv) || null;
+            this._bv = this.computeBoundingVolume();
             this._bvDirty = false;
         }
         return this._bv;
@@ -183,7 +182,8 @@ import { XForm } from './xform.js';
    */ setBoundingVolume(bv) {
         if (bv !== this._bv) {
             this._bv = bv;
-            this.invalidateBoundingVolume();
+            this._bvDirty = !this._bv;
+            this.invalidateWorldBoundingVolume(false);
         }
     }
     /**
@@ -213,6 +213,7 @@ import { XForm } from './xform.js';
             } else if (this.isGraphNode()) {
                 this._scene.invalidateNodePlacement(this);
             }
+            this.dispatchEvent(this, 'bvchanged');
         }
     }
     /** Clip mode */ get clipTestEnabled() {
@@ -236,6 +237,9 @@ import { XForm } from './xform.js';
             const prevHidden = this.hidden;
             this._visible = val;
             if (prevHidden !== this.hidden) {
+                if (this.isGraphNode()) {
+                    this._scene.invalidateNodePlacement(this);
+                }
                 this.notifyHiddenChanged();
             }
         }

package/dist/scene/scene_node.js.map

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

package/dist/scene/terrain/grass.js

@@ -37,14 +37,13 @@ class GrassCluster extends applyMixins(GrassClusterBase, mixinDrawable) {
         return this._terrain.getInstanceColor();
     }
     getPickTarget() {
-        return this._terrain;
+        return {
+            node: this._terrain
+        };
     }
     getBoneMatrices() {
         return null;
     }
-    getInvBindMatrix() {
-        return null;
-    }
     getMorphData() {
         return null;
     }

package/dist/scene/terrain/grass.js.map

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