@zephyr3d/scene 0.9.24 → 0.9.26

package/dist/scene/mesh.js

@@ -7,11 +7,14 @@ import '../material/unlit.js';
 import '../material/particle.js';
 import '../material/subsurfaceprofile.js';
 import '../material/skin.js';
+import '../material/eye.js';
 import { PBStructTypeInfo, PBArrayTypeInfo, PBPrimitiveTypeInfo, PBPrimitiveType } from '@zephyr3d/device';
-import { MORPH_WEIGHTS_VECTOR_COUNT, MORPH_ATTRIBUTE_VECTOR_COUNT, QUEUE_OPAQUE } from '../values.js';
+import { QUEUE_OPAQUE, MORPH_WEIGHTS_VECTOR_COUNT, MORPH_ATTRIBUTE_VECTOR_COUNT, getMorphTargetLimit, getActiveMorphTargetLimit } from '../values.js';
 import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
 import { getDevice } from '../app/api.js';
 import '../material/meshmaterial.js';
+import '../material/hair.js';
+import '../material/hairstrand.js';
 import '../material/grassmaterial.js';
 import '../material/terrain-cm.js';
 import '../material/pbrmr.js';
@@ -25,6 +28,40 @@ import { BoundingBox } from '../utility/bounding_volume.js';
 import { mixinDrawable } from '../render/drawable_mixin.js';
 import { calculateMorphBoundingBox } from '../animation/morphtarget.js';
 
+const MORPH_WEIGHT_CAPACITY = MORPH_WEIGHTS_VECTOR_COUNT * 4;
+const MORPH_ATTRIBUTE_CAPACITY = MORPH_ATTRIBUTE_VECTOR_COUNT * 4;
+const MORPH_INFO_DATA_LENGTH = 4 + MORPH_WEIGHT_CAPACITY + MORPH_ATTRIBUTE_CAPACITY;
+const MORPH_RENDER_INDEX_OFFSET = 4 + MORPH_WEIGHT_CAPACITY;
+const MORPH_RENDER_ATTRIBUTE_OFFSET = MORPH_RENDER_INDEX_OFFSET + MORPH_WEIGHT_CAPACITY;
+const MORPH_RENDER_INFO_DATA_LENGTH = MORPH_RENDER_ATTRIBUTE_OFFSET + MORPH_ATTRIBUTE_CAPACITY;
+const ACTIVE_MORPH_WEIGHT_EPSILON = 1e-5;
+function normalizeMorphInfoData(data) {
+    const normalized = new Float32Array(MORPH_INFO_DATA_LENGTH);
+    for(let i = 0; i < MORPH_ATTRIBUTE_CAPACITY; i++){
+        normalized[4 + MORPH_WEIGHT_CAPACITY + i] = -1;
+    }
+    normalized.set(data.subarray(0, Math.min(data.length, normalized.length)));
+    const declaredCount = Math.max(0, Math.floor(Number(normalized[3]) || 0));
+    const supportedCount = Math.min(declaredCount, getMorphTargetLimit(), MORPH_WEIGHT_CAPACITY, Math.max(0, data.length - 4));
+    normalized[3] = supportedCount;
+    return {
+        data: normalized,
+        declaredCount,
+        supportedCount
+    };
+}
+function createMorphInfoBuffer(data) {
+    const bufferData = new Float32Array(data);
+    const bufferType = new PBStructTypeInfo('dummy', 'std140', [
+        {
+            name: ShaderHelper.getMorphInfoUniformName(),
+            type: new PBArrayTypeInfo(new PBPrimitiveTypeInfo(PBPrimitiveType.F32VEC4), 1 + MORPH_WEIGHTS_VECTOR_COUNT * 2 + MORPH_ATTRIBUTE_VECTOR_COUNT)
+        }
+    ]);
+    return getDevice().createStructuredBuffer(bufferType, {
+        usage: 'uniform'
+    }, bufferData);
+}
 const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
 /**
  * Mesh node
@@ -37,9 +74,16 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     /** @internal */ _animatedBoundingBox;
     /** @internal */ _skinBindingName;
     /** @internal */ _boneMatrices;
+    /** @internal */ _skinInfluenceData;
     /** @internal */ _morphData;
     /** @internal */ _morphInfo;
+    /** @internal */ _renderMorphInfo;
     /** @internal */ _morphBoundingInfo;
+    /** @internal */ _morphSource;
+    /** @internal */ _morphSourceData;
+    /** @internal */ _activeMorphTargetIndices;
+    /** @internal */ _compactMorphData;
+    /** @internal */ _activeMorphCandidates;
     /** @internal */ _morphDirty;
     /** @internal */ _instanceHash;
     /** @internal */ _batchable;
@@ -61,9 +105,16 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         this._skinnedBoundingInfo = null;
         this._animatedBoundingBox = null;
         this._boneMatrices = new DRef();
+        this._skinInfluenceData = null;
         this._morphData = null;
         this._morphInfo = null;
+        this._renderMorphInfo = null;
         this._morphBoundingInfo = null;
+        this._morphSource = null;
+        this._morphSourceData = null;
+        this._activeMorphTargetIndices = new Uint32Array(0);
+        this._compactMorphData = false;
+        this._activeMorphCandidates = [];
         this._morphDirty = false;
         this._instanceHash = null;
         this._pickTarget = {
@@ -154,6 +205,12 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
             this.invalidateBoundingVolume();
             RenderBundleWrapper.drawableChanged(this);
             this._primitiveChangeTag = null;
+            if (this._morphData) {
+                this._ensureWebGLVertexIndexAttribute('morphing');
+            }
+            if (this._skinInfluenceData && this._skinInfluenceData.influenceCount > 4) {
+                this._ensureWebGLVertexIndexAttribute('skinning');
+            }
             this.dispatchEvent('primitive_changed', prim);
         }
     }
@@ -215,12 +272,61 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         }
     }
     /**
+   * Sets additional per-vertex skinning influences packed in a texture.
+   * The first 4 influences remain in the vertex attributes; this payload stores the remainder.
+   * @param data - Extra influence texture payload, or null to clear it
+   */ setSkinInfluenceData(data) {
+        if (!data) {
+            if (this._skinInfluenceData) {
+                this._skinInfluenceData.texture?.get()?.dispose();
+                this._skinInfluenceData = null;
+                this._renderBundle = {};
+                RenderBundleWrapper.drawableChanged(this);
+            }
+            return;
+        }
+        if (!this._skinInfluenceData) {
+            this._skinInfluenceData = {
+                texture: new DRef(),
+                width: 0,
+                height: 0,
+                influenceCount: 4,
+                data: new Float32Array(0)
+            };
+        }
+        this._skinInfluenceData.width = data.width;
+        this._skinInfluenceData.height = data.height;
+        this._skinInfluenceData.influenceCount = data.influenceCount;
+        this._skinInfluenceData.data = data.data.slice();
+        if (data.texture?.get()) {
+            this._skinInfluenceData.texture.set(data.texture.get());
+        } else {
+            let tex = this._skinInfluenceData.texture?.get() ?? null;
+            if (!tex || tex.width !== data.width || tex.height !== data.height) {
+                tex?.dispose();
+                tex = getDevice().createTexture2D('rgba32f', data.width, data.height, {
+                    mipmapping: false,
+                    samplerOptions: {
+                        minFilter: 'nearest',
+                        magFilter: 'nearest',
+                        mipFilter: 'none'
+                    }
+                });
+                this._skinInfluenceData.texture.set(tex);
+            }
+            tex.update(data.data, 0, 0, data.width, data.height);
+        }
+        this._ensureWebGLVertexIndexAttribute('skinning');
+        this._renderBundle = {};
+        RenderBundleWrapper.drawableChanged(this);
+    }
+    /**
    * Sets the texture that contains the morph target data
    * @param data - The texture that contains the morph target data
    */ setMorphData(data) {
         if (!data) {
             if (this._morphData) {
-                this._morphData?.texture?.dispose();
+                this._morphData.texture?.get()?.dispose();
                 this._morphData = null;
                 this._renderBundle = {};
                 RenderBundleWrapper.drawableChanged(this);
@@ -237,19 +343,27 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
             if (data.texture?.get()) {
                 this._morphData.texture.set(data.texture.get());
             } else {
-                const tex = getDevice().createTexture2D('rgba32f', data.width, data.height, {
-                    mipmapping: false,
-                    samplerOptions: {
-                        minFilter: 'nearest',
-                        magFilter: 'nearest',
-                        mipFilter: 'none'
-                    }
-                });
+                let tex = this._morphData.texture?.get() ?? null;
+                if (!tex || tex.width !== data.width || tex.height !== data.height) {
+                    tex?.dispose();
+                    tex = getDevice().createTexture2D('rgba32f', data.width, data.height, {
+                        mipmapping: false,
+                        samplerOptions: {
+                            minFilter: 'nearest',
+                            magFilter: 'nearest',
+                            mipFilter: 'none'
+                        }
+                    });
+                    this._morphData.texture.set(tex);
+                }
                 tex.update(data.data, 0, 0, data.width, data.height);
-                this._morphData.texture.set(tex);
             }
+            this._ensureWebGLVertexIndexAttribute('morphing');
             this._renderBundle = {};
             RenderBundleWrapper.drawableChanged(this);
+            if (this._morphInfo && !this._morphSourceData) {
+                this.updateRenderMorphInfo(this.collectActiveMorphTargetIndices(), false);
+            }
         }
     }
     /**
@@ -264,41 +378,86 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         return this._morphData;
     }
     /**
+   * {@inheritDoc Drawable.getSkinInfluenceData}
+   */ getSkinInfluenceData() {
+        return this._skinInfluenceData;
+    }
+    /**
+   * Gets the external morph source descriptor.
+   */ getMorphSource() {
+        return this._morphSource;
+    }
+    /**
+   * Sets the external morph source descriptor.
+   * @param source - The morph source descriptor
+   */ setMorphSource(source) {
+        this._morphSource = source ? {
+            ...source
+        } : null;
+    }
+    /**
+   * Gets the CPU-side morph source data.
+   */ getMorphSourceData() {
+        return this._morphSourceData;
+    }
+    /**
+   * Sets the CPU-side morph source data used to rebuild GPU morph textures on demand.
+   */ setMorphSourceData(data) {
+        this._morphSourceData = data ?? null;
+        this._activeMorphTargetIndices = new Uint32Array(0);
+        this._compactMorphData = false;
+        this._morphDirty = true;
+        if (!data) {
+            this.setMorphData(null);
+            this.setRenderMorphInfo(null);
+        } else if (this._morphInfo) {
+            this.setMorphData(null);
+            this.setRenderMorphInfo(null);
+            this.rebuildActiveMorphData();
+            this._morphDirty = false;
+        }
+    }
+    /**
    * Sets the buffer that contains the morph target information
    * @param info - The buffer that contains the morph target information
    */ setMorphInfo(info) {
         if (!info) {
             if (this._morphInfo) {
-                this._morphInfo.buffer?.dispose();
                 this._morphInfo = null;
-                this._renderBundle = {};
-                RenderBundleWrapper.drawableChanged(this);
             }
+            this.setMorphData(null);
+            this.setRenderMorphInfo(null);
+            this._activeMorphTargetIndices = new Uint32Array(0);
+            this._compactMorphData = false;
+            this._renderBundle = {};
+            RenderBundleWrapper.drawableChanged(this);
         } else {
             if (!this._morphInfo) {
-                this._morphInfo = {
-                    buffer: new DRef()
-                };
+                this._morphInfo = {};
             }
-            this._morphInfo.data = info.data.slice();
-            this._morphInfo.names = {
-                ...info.names
-            };
-            if (info.buffer?.get()) {
-                this._morphInfo.buffer.set(info.buffer.get());
-            } else {
-                const bufferType = new PBStructTypeInfo('dummy', 'std140', [
-                    {
-                        name: ShaderHelper.getMorphInfoUniformName(),
-                        type: new PBArrayTypeInfo(new PBPrimitiveTypeInfo(PBPrimitiveType.F32VEC4), 1 + MORPH_WEIGHTS_VECTOR_COUNT + MORPH_ATTRIBUTE_VECTOR_COUNT)
-                    }
-                ]);
-                const morphUniformBuffer = getDevice().createStructuredBuffer(bufferType, {
-                    usage: 'uniform'
-                }, info.data);
-                this._morphInfo.buffer.set(morphUniformBuffer);
+            const { data, declaredCount, supportedCount } = normalizeMorphInfoData(info.data);
+            if (declaredCount !== supportedCount) {
+                console.warn(`Morph target count truncated from ${declaredCount} to ${supportedCount} to fit the runtime buffer layout`);
+            }
+            const names = {};
+            for (const [name, index] of Object.entries(info.names ?? {})){
+                if (Number.isInteger(index) && index >= 0 && index < supportedCount) {
+                    names[name] = index;
+                }
+            }
+            this._morphInfo.data = data;
+            this._morphInfo.names = names;
+            this._morphDirty = true;
+            if (this._morphSourceData) {
+                this.setMorphData(null);
+                this.setRenderMorphInfo(null);
+                this.rebuildActiveMorphData();
+                this._morphDirty = false;
+            } else if (this._morphData) {
+                this.setRenderMorphInfo(null);
+                this.updateRenderMorphInfo(this.collectActiveMorphTargetIndices(), false);
+                this._morphDirty = false;
             }
-            this._morphDirty = false;
             this.refreshAnimatedBoundingBox();
             this._renderBundle = {};
             RenderBundleWrapper.drawableChanged(this);
@@ -309,10 +468,228 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
    */ getMorphInfo() {
         return this._morphInfo;
     }
+    /** @internal */ getRenderMorphInfo() {
+        return this._renderMorphInfo;
+    }
+    /** @internal */ setRenderMorphInfo(info) {
+        if (!info) {
+            if (this._renderMorphInfo) {
+                this._renderMorphInfo.buffer?.dispose();
+                this._renderMorphInfo = null;
+            }
+            return;
+        }
+        if (!this._renderMorphInfo) {
+            this._renderMorphInfo = {
+                buffer: new DRef()
+            };
+        }
+        this._renderMorphInfo.data = info.data;
+        this._renderMorphInfo.names = info.names;
+        if (!this._renderMorphInfo.buffer?.get()) {
+            this._renderMorphInfo.buffer.set(createMorphInfoBuffer(info.data));
+        } else {
+            this._renderMorphInfo.buffer.get().bufferSubData(0, info.data);
+        }
+    }
+    /** @internal */ collectActiveMorphTargetIndices() {
+        if (!this._morphInfo) {
+            return new Uint32Array(0);
+        }
+        const count = this.getNumMorphTargets();
+        const activeLimit = Math.min(getActiveMorphTargetLimit(), count);
+        if (activeLimit <= 0) {
+            return new Uint32Array(0);
+        }
+        const weighted = this._activeMorphCandidates;
+        let weightedCount = 0;
+        for(let i = 0; i < count; i++){
+            const weight = this._morphInfo.data[4 + i];
+            if (Math.abs(weight) > ACTIVE_MORPH_WEIGHT_EPSILON) {
+                const candidate = weighted[weightedCount] ?? {
+                    index: i,
+                    weight: 0
+                };
+                candidate.index = i;
+                candidate.weight = Math.abs(weight);
+                weighted[weightedCount] = candidate;
+                weightedCount++;
+            }
+        }
+        weighted.length = weightedCount;
+        let selectedCount = weightedCount;
+        if (weightedCount > activeLimit) {
+            weighted.sort((a, b)=>b.weight - a.weight);
+            selectedCount = activeLimit;
+        }
+        for(let i = 1; i < selectedCount; i++){
+            const candidate = weighted[i];
+            let targetIndex = i;
+            while(targetIndex > 0 && weighted[targetIndex - 1].index > candidate.index){
+                weighted[targetIndex] = weighted[targetIndex - 1];
+                targetIndex--;
+            }
+            weighted[targetIndex] = candidate;
+        }
+        const activeIndices = new Uint32Array(selectedCount);
+        for(let i = 0; i < selectedCount; i++){
+            activeIndices[i] = weighted[i].index;
+        }
+        return activeIndices;
+    }
+    /** @internal */ rebuildActiveMorphData() {
+        if (!this._morphInfo || !this._morphSourceData) {
+            this.setMorphData(null);
+            this.setRenderMorphInfo(null);
+            this._activeMorphTargetIndices = new Uint32Array(0);
+            this._compactMorphData = false;
+            return;
+        }
+        const activeIndices = this.collectActiveMorphTargetIndices();
+        const sameActiveSet = this._activeMorphTargetIndices.length === activeIndices.length && this._activeMorphTargetIndices.every((value, index)=>value === activeIndices[index]);
+        if (this._morphData && (!this._compactMorphData || sameActiveSet)) {
+            this.updateRenderMorphInfo(activeIndices, this._compactMorphData);
+            this._activeMorphTargetIndices = activeIndices;
+            return;
+        }
+        const attributes = Object.keys(this._morphSourceData.targets).map((key)=>Number(key)).filter((value)=>Number.isInteger(value) && value >= 0 && value < MORPH_ATTRIBUTE_CAPACITY).sort((a, b)=>a - b);
+        const numVertices = this._morphSourceData.numVertices;
+        const textureTargetCount = Math.min(this.getNumMorphTargets(), this._morphSourceData.numTargets);
+        if (numVertices <= 0 || attributes.length === 0 || textureTargetCount <= 0) {
+            this.setMorphData(null);
+            this.setRenderMorphInfo(null);
+            this._activeMorphTargetIndices = new Uint32Array(0);
+            this._compactMorphData = false;
+            return;
+        }
+        const maxTextureSize = getDevice().getDeviceCaps().textureCaps.maxTextureSize;
+        const fullTextureSize = Math.ceil(Math.sqrt(numVertices * attributes.length * textureTargetCount));
+        let textureTargetIndices;
+        if (fullTextureSize <= maxTextureSize) {
+            textureTargetIndices = new Uint32Array(textureTargetCount);
+            for(let i = 0; i < textureTargetCount; i++){
+                textureTargetIndices[i] = i;
+            }
+            this._compactMorphData = false;
+        } else if (activeIndices.length > 0) {
+            textureTargetIndices = activeIndices;
+            this._compactMorphData = true;
+        } else {
+            this.setMorphData(null);
+            this.setRenderMorphInfo(null);
+            this._activeMorphTargetIndices = activeIndices;
+            this._compactMorphData = true;
+            return;
+        }
+        const textureSize = Math.ceil(Math.sqrt(numVertices * attributes.length * textureTargetIndices.length));
+        if (textureSize > maxTextureSize) {
+            console.warn(`Active morph target texture too large for mesh "${this.name ?? ''}": ${textureSize} exceeds device limit`);
+            this.setMorphData(null);
+            this.setRenderMorphInfo(null);
+            this._activeMorphTargetIndices = new Uint32Array(0);
+            return;
+        }
+        const textureData = new Float32Array(textureSize * textureSize * 4);
+        const attributeOffsets = new Float32Array(MORPH_ATTRIBUTE_CAPACITY);
+        for(let i = 0; i < MORPH_ATTRIBUTE_CAPACITY; i++){
+            attributeOffsets[i] = -1;
+        }
+        let offset = 0;
+        for (const attrib of attributes){
+            const source = this._morphSourceData.targets[attrib];
+            if (!source) {
+                continue;
+            }
+            attributeOffsets[attrib] = offset >> 2;
+            for(let slot = 0; slot < textureTargetIndices.length; slot++){
+                const targetIndex = textureTargetIndices[slot];
+                const targetData = source.data[targetIndex];
+                const sparseIndices = source.indices?.[targetIndex];
+                const baseOffset = offset + slot * numVertices * 4;
+                if (sparseIndices && targetData) {
+                    for(let i = 0; i < sparseIndices.length; i++){
+                        const vertexOffset = baseOffset + sparseIndices[i] * 4;
+                        for(let j = 0; j < source.numComponents; j++){
+                            textureData[vertexOffset + j] = targetData[i * source.numComponents + j];
+                        }
+                    }
+                } else if (targetData) {
+                    for(let vertex = 0; vertex < numVertices; vertex++){
+                        const vertexOffset = baseOffset + vertex * 4;
+                        for(let j = 0; j < source.numComponents; j++){
+                            textureData[vertexOffset + j] = targetData[vertex * source.numComponents + j];
+                        }
+                    }
+                }
+            }
+            offset += numVertices * 4 * textureTargetIndices.length;
+        }
+        this.setMorphData({
+            width: textureSize,
+            height: textureSize,
+            data: textureData
+        });
+        this.updateRenderMorphInfo(activeIndices, this._compactMorphData, attributeOffsets);
+        this._activeMorphTargetIndices = activeIndices;
+    }
+    /** @internal */ updateRenderMorphInfo(activeIndices, useCompactSlots, attributeOffsets) {
+        if (!this._morphInfo || !this._morphData) {
+            this.setRenderMorphInfo(null);
+            return;
+        }
+        const infoData = this._renderMorphInfo?.data instanceof Float32Array && this._renderMorphInfo.data.length === MORPH_RENDER_INFO_DATA_LENGTH ? this._renderMorphInfo.data : new Float32Array(MORPH_RENDER_INFO_DATA_LENGTH);
+        infoData[0] = this._morphData.width;
+        infoData[1] = this._morphData.height;
+        infoData[2] = this._morphSourceData?.numVertices ?? (Number(this._morphInfo.data[2]) || 0);
+        infoData[3] = activeIndices.length;
+        infoData.fill(0, 4, MORPH_RENDER_ATTRIBUTE_OFFSET);
+        for(let slot = 0; slot < activeIndices.length; slot++){
+            const targetIndex = activeIndices[slot];
+            infoData[4 + slot] = this._morphInfo.data[4 + targetIndex];
+            infoData[MORPH_RENDER_INDEX_OFFSET + slot] = useCompactSlots ? slot : targetIndex;
+        }
+        if (attributeOffsets) {
+            infoData.fill(-1, MORPH_RENDER_ATTRIBUTE_OFFSET);
+            infoData.set(attributeOffsets, MORPH_RENDER_ATTRIBUTE_OFFSET);
+        } else if (!this._renderMorphInfo) {
+            infoData.fill(-1, MORPH_RENDER_ATTRIBUTE_OFFSET);
+            for(let attrib = 0; attrib < MORPH_ATTRIBUTE_CAPACITY; attrib++){
+                infoData[MORPH_RENDER_ATTRIBUTE_OFFSET + attrib] = this._morphInfo.data[4 + MORPH_WEIGHT_CAPACITY + attrib] ?? -1;
+            }
+        }
+        this.setRenderMorphInfo({
+            data: infoData,
+            names: this._renderMorphInfo?.names ?? {}
+        });
+    }
     /** @internal */ resolveAnimatedBoundingBox(morphBoundingBox) {
         const skinnedBoundingBox = this._boneMatrices.get() && this._skinnedBoundingInfo?.boundingBox?.isValid() ? this._skinnedBoundingInfo.boundingBox : null;
         if (skinnedBoundingBox && morphBoundingBox) {
-            return skinnedBoundingBox.clone().union(morphBoundingBox);
+            // Skinning and morphing both active. The two boxes live in different
+            // frames: the skinned box already reflects where the geometry actually
+            // ended up, while the morph box is still expressed around the rest pose.
+            // Unioning them therefore spans the gap between rest and posed positions
+            // and produces a wildly oversized box - which is why that union was
+            // removed. But dropping the morph side entirely loses the displacement,
+            // since the skinned box is built from rest-pose representative vertices
+            // (SkinBinding.computeBoundingBox) and never sees morph offsets - so a
+            // large facial expression could reach outside its own bounds and be
+            // culled.
+            //
+            // Transfer only what is frame-independent: the displacement. Clamped so
+            // it can only grow the box, because a morph that pushes geometry one way
+            // must not be allowed to shrink the opposite side.
+            const box = skinnedBoundingBox.clone();
+            const displacement = this.calculateMorphDisplacement();
+            if (displacement) {
+                const min = box.minPoint;
+                const max = box.maxPoint;
+                const dmin = displacement.minPoint;
+                const dmax = displacement.maxPoint;
+                min.setXYZ(min.x + Math.min(0, dmin.x), min.y + Math.min(0, dmin.y), min.z + Math.min(0, dmin.z));
+                max.setXYZ(max.x + Math.max(0, dmax.x), max.y + Math.max(0, dmax.y), max.z + Math.max(0, dmax.z));
+            }
+            return box;
         }
         return skinnedBoundingBox?.clone() ?? morphBoundingBox ?? null;
     }
@@ -321,7 +698,7 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
    *
    * @returns The number of morph targets
    */ getNumMorphTargets() {
-        return this._morphInfo?.data[3] ?? 0;
+        return this._morphInfo ? Math.min(this._morphInfo.data[3], MORPH_WEIGHT_CAPACITY) : 0;
     }
     /**
    * Get the name of the morph target by index
@@ -329,7 +706,7 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
    * @param index - The index of the morph target
    * @returns The name of the morph target, or null if not found
    */ getMorphTargetName(index) {
-        if (this._morphInfo && index >= 0 && index < this._morphInfo.data[3]) {
+        if (this._morphInfo && index >= 0 && index < this.getNumMorphTargets()) {
             const name = Object.keys(this._morphInfo.names).find((key)=>this._morphInfo.names[key] === index);
             return name ?? null;
         }
@@ -359,9 +736,10 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
    * @param index - The index of the morph target
    * @param weight - The weight of the morph target
    */ setMorphWeightByIndex(index, weight) {
-        if (index >= 0 && index < this._morphInfo.data[3]) {
-            if (this._morphInfo.data[4 + index] !== weight) {
-                this._morphInfo.data[4 + index] = weight;
+        if (index >= 0 && index < this.getNumMorphTargets()) {
+            const normalizedWeight = Math.fround(weight);
+            if (this._morphInfo.data[4 + index] !== normalizedWeight) {
+                this._morphInfo.data[4 + index] = normalizedWeight;
                 this._morphDirty = true;
                 this.refreshAnimatedBoundingBox();
                 this.scene.queueUpdateNode(this);
@@ -377,7 +755,7 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
    * @returns The weight of the morph target, or 0 if not found
    */ getMorphWeight(name) {
         const index = this._morphInfo?.names?.[name];
-        if (index !== undefined && index >= 0 && index < this._morphInfo.data[3]) {
+        if (index !== undefined && index >= 0 && index < this.getNumMorphTargets()) {
             return this._morphInfo.data[4 + index];
         }
         return 0;
@@ -387,8 +765,18 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
    *
    * @param weight - The morph target weights. The length must not exceed the mesh's morph target count.
    */ updateMorphWeights(weight) {
-        if (this._morphInfo && weight && weight.length <= this._morphInfo.data[3]) {
-            this._morphInfo.data.set(weight, 4);
+        if (this._morphInfo && weight && weight.length <= this.getNumMorphTargets()) {
+            let changed = false;
+            for(let i = 0; i < weight.length; i++){
+                const normalizedWeight = Math.fround(weight[i] ?? 0);
+                if (this._morphInfo.data[4 + i] !== normalizedWeight) {
+                    this._morphInfo.data[4 + i] = normalizedWeight;
+                    changed = true;
+                }
+            }
+            if (!changed) {
+                return;
+            }
             this._morphDirty = true;
             this.refreshAnimatedBoundingBox();
             this.scene.queueUpdateNode(this);
@@ -439,17 +827,35 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
    */ needSceneDepth() {
         return this.material?.needSceneDepth() ?? false;
     }
-    /** @internal */ calculateMorphBoundingBox() {
+    /** @internal */ /**
+   * Weighted morph displacement, relative to the rest pose - i.e. how far the
+   * active morph targets push geometry beyond `originBox`, not where that
+   * geometry ends up.
+   *
+   * Kept separate from {@link calculateMorphBoundingBox} because the two are
+   * useful in different frames of reference: the absolute box is meaningful for
+   * an unskinned mesh, while for a skinned one only the displacement transfers -
+   * the rest-space position is superseded by the skinning result.
+   *
+   * @internal
+   */ calculateMorphDisplacement() {
         if (!this._morphInfo || !this._morphBoundingInfo) {
             return null;
         }
-        const numTargets = Math.min(this._morphInfo.data[3], this._morphBoundingInfo.targetBoxes.length);
+        const numTargets = Math.min(this.getNumMorphTargets(), this._morphBoundingInfo.targetBoxes.length);
         if (numTargets <= 0) {
             return null;
         }
         const weights = this._morphInfo.data instanceof Float32Array ? this._morphInfo.data.subarray(4, 4 + numTargets) : new Float32Array(Array.from(this._morphInfo.data.subarray(4, 4 + numTargets)));
         const bbox = new BoundingBox();
         calculateMorphBoundingBox(bbox, this._morphBoundingInfo.targetBoxes, weights, numTargets);
+        return bbox;
+    }
+    /** @internal */ calculateMorphBoundingBox() {
+        const bbox = this.calculateMorphDisplacement();
+        if (!bbox) {
+            return null;
+        }
         bbox.minPoint.addBy(this._morphBoundingInfo.originBox.minPoint);
         bbox.maxPoint.addBy(this._morphBoundingInfo.originBox.maxPoint);
         return bbox;
@@ -459,7 +865,13 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     }
     /** @internal */ updateMorphState() {
         if (this._morphInfo && this._morphDirty) {
-            this._morphInfo.buffer.get().bufferSubData(4 * 4, this._morphInfo.data, 4, this._morphInfo.data[3]);
+            if (this._morphSourceData) {
+                this.rebuildActiveMorphData();
+            } else if (this._morphData) {
+                const activeIndices = this.collectActiveMorphTargetIndices();
+                this.updateRenderMorphInfo(activeIndices, false);
+                this._activeMorphTargetIndices = activeIndices;
+            }
             this.refreshAnimatedBoundingBox();
             this._morphDirty = false;
         }
@@ -546,8 +958,11 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
         this._primitive.dispose();
         this._material.dispose();
         this._boneMatrices.dispose();
+        this.setSkinInfluenceData(null);
         this.setMorphData(null);
+        this.setRenderMorphInfo(null);
         this.setMorphInfo(null);
+        this.setMorphSourceData(null);
         this.setMorphBoundingInfo(null);
         this._renderBundle = null;
         RenderBundleWrapper.drawableChanged(this);
@@ -555,6 +970,25 @@ const MeshBase = castObservable(applyMixins(GraphNode, mixinDrawable))();
     /** @internal */ _onBoundingboxChange() {
         this.invalidateBoundingVolume();
     }
+    /** @internal */ _ensureWebGLVertexIndexAttribute(feature) {
+        const primitive = this._primitive.get();
+        if (!primitive || getDevice().type !== 'webgl') {
+            return;
+        }
+        if (primitive.getVertexBuffer('texCoord7')) {
+            return;
+        }
+        const numVertices = primitive.getNumVertices();
+        if (numVertices <= 0) {
+            return;
+        }
+        const vertexIndices = new Float32Array(numVertices);
+        for(let i = 0; i < numVertices; i++){
+            vertexIndices[i] = i;
+        }
+        primitive.createAndSetVertexBuffer('tex7_f32', vertexIndices);
+        console.info(`Injected texCoord7 vertex indices for WebGL ${feature} on mesh "${this.name ?? ''}"`);
+    }
     /** @internal */ static _defaultMaterial = null;
     /** @internal */ static _getDefaultMaterial() {
         if (!this._defaultMaterial) {