@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/animation/cloth/gpu_cloth_system.js

@@ -1,9 +1,22 @@
-import { PBPrimitiveType } from '@zephyr3d/device';
 import { Vector3, retainObject, releaseObject, Matrix4x4, uint8ArrayToBase64, base64ToUint8Array } from '@zephyr3d/base';
 import { getDevice } from '../../app/api.js';
+import { readPrimitiveAttribute, readPrimitiveIndices } from '../../render/primitive_readback.js';
 import { BoundingBox } from '../../utility/bounding_volume.js';
 import { updateColliderFromNode } from '../spring/spring_collider.js';
+import { warnUnsupported } from '../../utility/unsupported.js';
 
+function normalizeTargetWrapWeights(source, vertexCount) {
+    const result = new Float32Array(vertexCount);
+    result.fill(1);
+    if (!source) {
+        return result;
+    }
+    const count = Math.min(vertexCount, source.length);
+    for(let i = 0; i < count; i++){
+        result[i] = clamp(Number(source[i]) || 0, 0, 1);
+    }
+    return result;
+}
 function encodeTypedArrayBase64(view) {
     return uint8ArrayToBase64(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
 }
@@ -67,68 +80,6 @@ function getInitialColliderBufferFloatCount(colliders, type, stride) {
     const count = (colliders ?? []).reduce((total, collider)=>total + (collider?.type === type ? 1 : 0), 0);
     return Math.max(1, count) * stride;
 }
-function getPrimitiveScalarByteSize(type) {
-    switch(type){
-        case PBPrimitiveType.I16:
-        case PBPrimitiveType.I16_NORM:
-        case PBPrimitiveType.U16:
-        case PBPrimitiveType.U16_NORM:
-        case PBPrimitiveType.F16:
-            return 2;
-        case PBPrimitiveType.I32:
-        case PBPrimitiveType.I32_NORM:
-        case PBPrimitiveType.U32:
-        case PBPrimitiveType.U32_NORM:
-        case PBPrimitiveType.F32:
-            return 4;
-        default:
-            return 1;
-    }
-}
-function readPrimitiveScalar(view, byteOffset, scalarType, normalized) {
-    switch(scalarType){
-        case PBPrimitiveType.I8:
-        case PBPrimitiveType.I8_NORM:
-            {
-                const value = view.getInt8(byteOffset);
-                return normalized ? Math.max(-1, value / 127) : value;
-            }
-        case PBPrimitiveType.U8:
-        case PBPrimitiveType.U8_NORM:
-            {
-                const value = view.getUint8(byteOffset);
-                return normalized ? value / 255 : value;
-            }
-        case PBPrimitiveType.I16:
-        case PBPrimitiveType.I16_NORM:
-            {
-                const value = view.getInt16(byteOffset, true);
-                return normalized ? Math.max(-1, value / 32767) : value;
-            }
-        case PBPrimitiveType.U16:
-        case PBPrimitiveType.U16_NORM:
-            {
-                const value = view.getUint16(byteOffset, true);
-                return normalized ? value / 65535 : value;
-            }
-        case PBPrimitiveType.I32:
-        case PBPrimitiveType.I32_NORM:
-            {
-                const value = view.getInt32(byteOffset, true);
-                return normalized ? Math.max(-1, value / 2147483647) : value;
-            }
-        case PBPrimitiveType.U32:
-        case PBPrimitiveType.U32_NORM:
-            {
-                const value = view.getUint32(byteOffset, true);
-                return normalized ? value / 4294967295 : value;
-            }
-        case PBPrimitiveType.F32:
-            return view.getFloat32(byteOffset, true);
-        default:
-            throw new Error(`Unsupported vertex scalar type: ${scalarType}`);
-    }
-}
 function distance3(positions, a, b) {
     const a0 = a * 3;
     const b0 = b * 3;
@@ -486,6 +437,7 @@ function createIntegrateProgram(device, workgroupSize) {
             this.sphereData = pb.float[0]().storageBufferReadonly(0);
             this.capsuleData = pb.float[0]().storageBufferReadonly(0);
             this.planeData = pb.float[0]().storageBufferReadonly(0);
+            this.boxData = pb.float[0]().storageBufferReadonly(0);
             this.vertexCount = pb.uint().uniform(0);
             this.deltaTime = pb.float().uniform(0);
             this.damping = pb.float().uniform(0);
@@ -493,6 +445,7 @@ function createIntegrateProgram(device, workgroupSize) {
             this.sphereCount = pb.uint().uniform(0);
             this.capsuleCount = pb.uint().uniform(0);
             this.planeCount = pb.uint().uniform(0);
+            this.boxCount = pb.uint().uniform(0);
             this.dynamicFriction = pb.float().uniform(0);
             this.staticFriction = pb.float().uniform(0);
             this.minDistance = pb.float().uniform(0);
@@ -633,6 +586,34 @@ function createIntegrateProgram(device, workgroupSize) {
                             });
                         });
                     });
+                    this.$for(pb.uint('b'), 0, this.boxCount, function() {
+                        this.$l.boxBase = pb.mul(this.b, 16);
+                        this.$l.boxCenter = pb.vec3(this.boxData.at(this.boxBase), this.boxData.at(pb.add(this.boxBase, 1)), this.boxData.at(pb.add(this.boxBase, 2)));
+                        this.$l.boxHalf = pb.vec3(this.boxData.at(pb.add(this.boxBase, 3)), this.boxData.at(pb.add(this.boxBase, 4)), this.boxData.at(pb.add(this.boxBase, 5)));
+                        this.$l.boxAxisX = pb.vec3(this.boxData.at(pb.add(this.boxBase, 6)), this.boxData.at(pb.add(this.boxBase, 7)), this.boxData.at(pb.add(this.boxBase, 8)));
+                        this.$l.boxAxisY = pb.vec3(this.boxData.at(pb.add(this.boxBase, 9)), this.boxData.at(pb.add(this.boxBase, 10)), this.boxData.at(pb.add(this.boxBase, 11)));
+                        this.$l.boxAxisZ = pb.vec3(this.boxData.at(pb.add(this.boxBase, 12)), this.boxData.at(pb.add(this.boxBase, 13)), this.boxData.at(pb.add(this.boxBase, 14)));
+                        this.$l.boxRel = pb.sub(this.next, this.boxCenter);
+                        this.$l.boxLocal = pb.vec3(pb.dot(this.boxRel, this.boxAxisX), pb.dot(this.boxRel, this.boxAxisY), pb.dot(this.boxRel, this.boxAxisZ));
+                        this.$l.boxPen = pb.sub(this.boxHalf, pb.abs(this.boxLocal));
+                        this.$if(pb.and(pb.and(pb.greaterThan(this.boxPen.x, 0), pb.greaterThan(this.boxPen.y, 0)), pb.greaterThan(this.boxPen.z, 0)), function() {
+                            this.$l.boxAxis = this.boxAxisX;
+                            this.$l.boxDepth = this.boxPen.x;
+                            this.$l.boxSign = pb.select(pb.float(1), pb.float(-1), pb.greaterThanEqual(this.boxLocal.x, 0));
+                            this.$if(pb.lessThan(this.boxPen.y, this.boxDepth), function() {
+                                this.boxAxis = this.boxAxisY;
+                                this.boxDepth = this.boxPen.y;
+                                this.boxSign = pb.select(pb.float(1), pb.float(-1), pb.greaterThanEqual(this.boxLocal.y, 0));
+                            });
+                            this.$if(pb.lessThan(this.boxPen.z, this.boxDepth), function() {
+                                this.boxAxis = this.boxAxisZ;
+                                this.boxDepth = this.boxPen.z;
+                                this.boxSign = pb.select(pb.float(1), pb.float(-1), pb.greaterThanEqual(this.boxLocal.z, 0));
+                            });
+                            this.$l.boxSign = this.boxSign;
+                            this.next = pb.add(this.next, pb.mul(this.boxAxis, pb.mul(this.boxSign, this.boxDepth)));
+                        });
+                    });
                     this.next = pb.add(pb.mul(this.next, this.freeWeight), pb.mul(this.rest, this.pinWeight));
                     this.$l.prevOut = pb.add(pb.mul(this.current, this.freeWeight), pb.mul(this.rest, this.pinWeight));
                     this.prevPositions.setAt(this.base, this.prevOut.x);
@@ -666,6 +647,7 @@ function createConstraintProgram(device, workgroupSize) {
             this.sphereData = pb.float[0]().storageBufferReadonly(0);
             this.capsuleData = pb.float[0]().storageBufferReadonly(0);
             this.planeData = pb.float[0]().storageBufferReadonly(0);
+            this.boxData = pb.float[0]().storageBufferReadonly(0);
             this.vertexCount = pb.uint().uniform(0);
             this.maxNeighbors = pb.uint().uniform(0);
             this.stiffness = pb.float().uniform(0);
@@ -673,6 +655,7 @@ function createConstraintProgram(device, workgroupSize) {
             this.sphereCount = pb.uint().uniform(0);
             this.capsuleCount = pb.uint().uniform(0);
             this.planeCount = pb.uint().uniform(0);
+            this.boxCount = pb.uint().uniform(0);
             this.dynamicFriction = pb.float().uniform(0);
             this.staticFriction = pb.float().uniform(0);
             this.minDistance = pb.float().uniform(0);
@@ -760,6 +743,34 @@ function createConstraintProgram(device, workgroupSize) {
                                 this.corrected = pb.sub(this.corrected, pb.mul(this.planeNormal, this.planeDistance));
                             });
                         });
+                        this.$for(pb.uint('b'), 0, this.boxCount, function() {
+                            this.$l.boxBase = pb.mul(this.b, 16);
+                            this.$l.boxCenter = pb.vec3(this.boxData.at(this.boxBase), this.boxData.at(pb.add(this.boxBase, 1)), this.boxData.at(pb.add(this.boxBase, 2)));
+                            this.$l.boxHalf = pb.vec3(this.boxData.at(pb.add(this.boxBase, 3)), this.boxData.at(pb.add(this.boxBase, 4)), this.boxData.at(pb.add(this.boxBase, 5)));
+                            this.$l.boxAxisX = pb.vec3(this.boxData.at(pb.add(this.boxBase, 6)), this.boxData.at(pb.add(this.boxBase, 7)), this.boxData.at(pb.add(this.boxBase, 8)));
+                            this.$l.boxAxisY = pb.vec3(this.boxData.at(pb.add(this.boxBase, 9)), this.boxData.at(pb.add(this.boxBase, 10)), this.boxData.at(pb.add(this.boxBase, 11)));
+                            this.$l.boxAxisZ = pb.vec3(this.boxData.at(pb.add(this.boxBase, 12)), this.boxData.at(pb.add(this.boxBase, 13)), this.boxData.at(pb.add(this.boxBase, 14)));
+                            this.$l.boxRel = pb.sub(this.corrected, this.boxCenter);
+                            this.$l.boxLocal = pb.vec3(pb.dot(this.boxRel, this.boxAxisX), pb.dot(this.boxRel, this.boxAxisY), pb.dot(this.boxRel, this.boxAxisZ));
+                            this.$l.boxPen = pb.sub(this.boxHalf, pb.abs(this.boxLocal));
+                            this.$if(pb.and(pb.and(pb.greaterThan(this.boxPen.x, 0), pb.greaterThan(this.boxPen.y, 0)), pb.greaterThan(this.boxPen.z, 0)), function() {
+                                this.$l.boxAxis = this.boxAxisX;
+                                this.$l.boxDepth = this.boxPen.x;
+                                this.$l.boxSign = pb.select(pb.float(1), pb.float(-1), pb.greaterThanEqual(this.boxLocal.x, 0));
+                                this.$if(pb.lessThan(this.boxPen.y, this.boxDepth), function() {
+                                    this.boxAxis = this.boxAxisY;
+                                    this.boxDepth = this.boxPen.y;
+                                    this.boxSign = pb.select(pb.float(1), pb.float(-1), pb.greaterThanEqual(this.boxLocal.y, 0));
+                                });
+                                this.$if(pb.lessThan(this.boxPen.z, this.boxDepth), function() {
+                                    this.boxAxis = this.boxAxisZ;
+                                    this.boxDepth = this.boxPen.z;
+                                    this.boxSign = pb.select(pb.float(1), pb.float(-1), pb.greaterThanEqual(this.boxLocal.z, 0));
+                                });
+                                this.$l.boxSign = this.boxSign;
+                                this.corrected = pb.add(this.corrected, pb.mul(this.boxAxis, pb.mul(this.boxSign, this.boxDepth)));
+                            });
+                        });
                         this.positions.setAt(this.base, this.corrected.x);
                         this.positions.setAt(pb.add(this.base, 1), this.corrected.y);
                         this.positions.setAt(pb.add(this.base, 2), this.corrected.z);
@@ -883,45 +894,11 @@ async function readPositionDataFromPrimitive(primitive) {
     return positions;
 }
 async function readVertexAttributeDataFromPrimitive(primitive, semantic, componentCount) {
-    const info = primitive.getVertexBufferInfo(semantic);
-    if (!info || !info.type.isPrimitiveType() || info.type.cols < componentCount) {
-        return null;
-    }
-    const vertexCount = primitive.getNumVertices();
-    if (vertexCount <= 0) {
-        return null;
-    }
-    const bytes = await info.buffer.getBufferSubData();
-    const result = new Float32Array(vertexCount * componentCount);
-    const scalarType = info.type.scalarType;
-    const normalized = info.type.normalized;
-    const componentByteSize = getPrimitiveScalarByteSize(scalarType);
-    const baseByteOffset = info.drawOffset + info.offset;
-    if (scalarType === PBPrimitiveType.F32 && !normalized && baseByteOffset % 4 === 0 && info.stride % 4 === 0) {
-        const raw = new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 2);
-        const stride = info.stride >> 2;
-        const srcOffset = baseByteOffset >> 2;
-        for(let i = 0; i < vertexCount; i++){
-            const src = srcOffset + i * stride;
-            const dst = i * componentCount;
-            for(let c = 0; c < componentCount; c++){
-                result[dst + c] = raw[src + c];
-            }
-        }
-        return result;
-    }
-    if (scalarType === PBPrimitiveType.F16) {
-        throw new Error(`GPU cloth initialization failed: unsupported ${semantic} attribute format.`);
-    }
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    for(let i = 0; i < vertexCount; i++){
-        const src = baseByteOffset + i * info.stride;
-        const dst = i * componentCount;
-        for(let c = 0; c < componentCount; c++){
-            result[dst + c] = readPrimitiveScalar(view, src + c * componentByteSize, scalarType, normalized);
-        }
+    try {
+        return await readPrimitiveAttribute(primitive, semantic, componentCount);
+    } catch (err) {
+        throw new Error(`GPU cloth initialization failed: ${err instanceof Error ? err.message : err}`);
     }
-    return result;
 }
 async function readSkinningDataFromPrimitive(primitive) {
     try {
@@ -934,42 +911,60 @@ async function readSkinningDataFromPrimitive(primitive) {
         }
         return {
             blendIndices,
-            blendWeights
+            blendWeights,
+            influenceCount: 4
         };
     } catch  {
         return null;
     }
 }
-function buildNonIndexedTriangles(primitive, vertexCount) {
-    if (primitive.primitiveType !== 'triangle-list') {
-        throw new Error('GPU cloth initialization failed: only triangle-list primitive is supported.');
+async function readSkinningDataFromMesh(mesh) {
+    if (!mesh.primitive) {
+        return null;
     }
-    const start = primitive.indexStart;
-    const count = primitive.indexCount;
-    if (count <= 0 || count % 3 !== 0 || start < 0 || start + count > vertexCount) {
-        throw new Error('GPU cloth initialization failed: invalid non-indexed triangle range.');
+    const base = await readSkinningDataFromPrimitive(mesh.primitive);
+    if (!base) {
+        return null;
     }
-    const indices = new Uint32Array(count);
-    for(let i = 0; i < count; i++){
-        indices[i] = start + i;
+    const extra = mesh.getSkinInfluenceData?.() ?? null;
+    const influenceCount = Math.max(4, Math.floor(Number(extra?.influenceCount) || 4));
+    if (!extra || influenceCount <= 4) {
+        return base;
+    }
+    const vertexCount = mesh.primitive.getNumVertices();
+    const pairCount = Math.ceil((influenceCount - 4) / 2);
+    if (extra.data.length < vertexCount * pairCount * 4) {
+        return base;
+    }
+    const blendIndices = new Float32Array(vertexCount * influenceCount);
+    const blendWeights = new Float32Array(vertexCount * influenceCount);
+    for(let vertex = 0; vertex < vertexCount; vertex++){
+        const baseSource = vertex * 4;
+        const target = vertex * influenceCount;
+        blendIndices.set(base.blendIndices.subarray(baseSource, baseSource + 4), target);
+        blendWeights.set(base.blendWeights.subarray(baseSource, baseSource + 4), target);
+        for(let influence = 4; influence < influenceCount; influence++){
+            const extraInfluence = influence - 4;
+            const source = (vertex * pairCount + (extraInfluence >> 1)) * 4 + (extraInfluence & 1) * 2;
+            blendIndices[target + influence] = Number(extra.data[source]) || 0;
+            blendWeights[target + influence] = Number(extra.data[source + 1]) || 0;
+        }
     }
-    return indices;
+    return {
+        blendIndices,
+        blendWeights,
+        influenceCount
+    };
 }
-async function readIndexDataFromPrimitive(primitive, vertexCount) {
-    const indexBuffer = primitive.getIndexBuffer();
-    if (!indexBuffer) {
-        return buildNonIndexedTriangles(primitive, vertexCount);
-    }
-    if (primitive.primitiveType !== 'triangle-list') {
-        throw new Error('GPU cloth initialization failed: only triangle-list primitive is supported.');
-    }
-    const bytes = await indexBuffer.getBufferSubData();
-    if (indexBuffer.indexType.primitiveType === PBPrimitiveType.U16) {
-        const src = new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 1);
-        return new Uint16Array(src);
+/**
+ * The primitive's full-detail triangles. With mesh LODs the index buffer holds
+ * every level in its own range; reading all of it would stack them together.
+ */ async function readIndexDataFromPrimitive(primitive) {
+    try {
+        return await readPrimitiveIndices(primitive);
+    } catch (err) {
+        throw new Error(`GPU cloth initialization failed: ${err instanceof Error ? err.message : err}`);
     }
-    const src = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 2);
-    return new Uint32Array(src);
 }
 function createWrapDeformerProgram(device, workgroupSize) {
     const program = device.buildComputeProgram({
@@ -983,11 +978,15 @@ function createWrapDeformerProgram(device, workgroupSize) {
             this.sourceTriangleIndices = pb.uint[0]().storageBufferReadonly(0);
             this.sourceBarycentrics = pb.float[0]().storageBufferReadonly(0);
             this.targetLocalOffsets = pb.float[0]().storageBufferReadonly(0);
+            this.targetSkinPositions = pb.float[0]().storageBufferReadonly(0);
+            this.targetSkinNormals = pb.float[0]().storageBufferReadonly(0);
+            this.targetWrapWeights = pb.float[0]().storageBufferReadonly(0);
             this.targetPositions = pb.float[0]().storageBuffer(0);
             this.targetNormals = pb.float[0]().storageBuffer(0);
             this.vertexCount = pb.uint().uniform(0);
             this.sourceToTargetMatrix = pb.mat4().uniform(0);
             this.minDistance = pb.float().uniform(0);
+            this.hasTargetNormals = pb.float().uniform(0);
             pb.main(function() {
                 this.$l.vertex = this.$builtins.globalInvocationId.x;
                 this.$if(pb.lessThan(this.vertex, this.vertexCount), function() {
@@ -1052,6 +1051,18 @@ function createWrapDeformerProgram(device, workgroupSize) {
                     });
                     this.$l.localOffset = pb.vec3(this.targetLocalOffsets.at(this.targetBase), this.targetLocalOffsets.at(pb.add(this.targetBase, 1)), this.targetLocalOffsets.at(pb.add(this.targetBase, 2)));
                     this.$l.deformedPosition = pb.add(this.basePoint, pb.add(pb.mul(this.tangent, this.localOffset.x), pb.mul(this.bitangent, this.localOffset.y), pb.mul(this.normal, this.localOffset.z)));
+                    this.$l.wrapWeight = this.targetWrapWeights.at(this.vertex);
+                    this.$l.skinPosition = pb.vec3(this.targetSkinPositions.at(this.targetBase), this.targetSkinPositions.at(pb.add(this.targetBase, 1)), this.targetSkinPositions.at(pb.add(this.targetBase, 2)));
+                    this.deformedPosition = pb.add(pb.mul(this.skinPosition, pb.sub(1, this.wrapWeight)), pb.mul(this.deformedPosition, this.wrapWeight));
+                    this.$l.skinNormal = pb.vec3(this.targetSkinNormals.at(this.targetBase), this.targetSkinNormals.at(pb.add(this.targetBase, 1)), this.targetSkinNormals.at(pb.add(this.targetBase, 2)));
+                    this.$l.normalWeight = pb.max(this.wrapWeight, pb.sub(1, this.hasTargetNormals));
+                    this.normal = pb.add(pb.mul(this.skinNormal, pb.sub(1, this.normalWeight)), pb.mul(this.normal, this.normalWeight));
+                    this.normalLen = pb.length(this.normal);
+                    this.$if(pb.greaterThan(this.normalLen, this.minDistance), function() {
+                        this.normal = pb.div(this.normal, this.normalLen);
+                    }).$else(function() {
+                        this.normal = pb.vec3(0, 1, 0);
+                    });
                     this.targetPositions.setAt(this.targetBase, this.deformedPosition.x);
                     this.targetPositions.setAt(pb.add(this.targetBase, 1), this.deformedPosition.y);
                     this.targetPositions.setAt(pb.add(this.targetBase, 2), this.deformedPosition.z);
@@ -1085,6 +1096,28 @@ function getWrapSourceToTargetMatrix(source, target, out) {
     }
     return Matrix4x4.multiplyAffine(target.invWorldMatrix, source.worldMatrix, out);
 }
+/** @internal Conservative bounds for the blend of wrapped and skinned target vertices. */ function calculateGPUClothWrapBoundingBox(sourceBBox, sourceToTargetMatrix, skinPositions, offsetDistances, wrapWeights) {
+    const wrappedBox = sourceBBox.transform(sourceToTargetMatrix);
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for(let vertex = 0; vertex < wrapWeights.length; vertex++){
+        const base = vertex * 3;
+        const weight = wrapWeights[vertex];
+        const skinWeight = 1 - weight;
+        const radius = weight * offsetDistances[vertex] + 0.001;
+        minX = Math.min(minX, skinWeight * skinPositions[base] + weight * wrappedBox.minPoint.x - radius);
+        minY = Math.min(minY, skinWeight * skinPositions[base + 1] + weight * wrappedBox.minPoint.y - radius);
+        minZ = Math.min(minZ, skinWeight * skinPositions[base + 2] + weight * wrappedBox.minPoint.z - radius);
+        maxX = Math.max(maxX, skinWeight * skinPositions[base] + weight * wrappedBox.maxPoint.x + radius);
+        maxY = Math.max(maxY, skinWeight * skinPositions[base + 1] + weight * wrappedBox.maxPoint.y + radius);
+        maxZ = Math.max(maxZ, skinWeight * skinPositions[base + 2] + weight * wrappedBox.maxPoint.z + radius);
+    }
+    return new BoundingBox(new Vector3(minX, minY, minZ), new Vector3(maxX, maxY, maxZ));
+}
 class GPUClothWrapBinding {
     _device;
     _source;
@@ -1093,17 +1126,28 @@ class GPUClothWrapBinding {
     _wrapTriangleIndexBuffer;
     _wrapBarycentricBuffer;
     _wrapLocalOffsetBuffer;
+    _targetSkinPositionBuffer;
+    _targetSkinNormalBuffer;
+    _targetWrapWeightBuffer;
     _program;
     _bindGroup;
     _workgroupCount;
-    _maxOffsetDistance;
+    _targetOffsetDistances;
+    _targetWrapWeights;
     _sourceToTargetMatrix;
     _positionBuffer;
     _normalBuffer;
     _originalPositionBuffer;
     _originalNormalBuffer;
     _restoreSkinning;
-    constructor(device, source, target, targetPrimitive, wrapTriangleIndexBuffer, wrapBarycentricBuffer, wrapLocalOffsetBuffer, program, bindGroup, positionBuffer, normalBuffer, originalPositionBuffer, originalNormalBuffer, workgroupCount, maxOffsetDistance, restoreSkinning){
+    _targetBasePositions;
+    _targetBaseNormals;
+    _targetBlendIndices;
+    _targetBlendWeights;
+    _targetSkinnedPositions;
+    _targetSkinnedNormals;
+    _hasPartialWrap;
+    constructor(device, source, target, targetPrimitive, wrapTriangleIndexBuffer, wrapBarycentricBuffer, wrapLocalOffsetBuffer, targetSkinPositionBuffer, targetSkinNormalBuffer, targetWrapWeightBuffer, program, bindGroup, positionBuffer, normalBuffer, originalPositionBuffer, originalNormalBuffer, workgroupCount, targetOffsetDistances, restoreSkinning, targetBasePositions, targetBaseNormals, targetBlendIndices, targetBlendWeights, targetWrapWeights){
         this._device = device;
         this._source = source;
         this._target = target;
@@ -1111,20 +1155,31 @@ class GPUClothWrapBinding {
         this._wrapTriangleIndexBuffer = wrapTriangleIndexBuffer;
         this._wrapBarycentricBuffer = wrapBarycentricBuffer;
         this._wrapLocalOffsetBuffer = wrapLocalOffsetBuffer;
+        this._targetSkinPositionBuffer = targetSkinPositionBuffer;
+        this._targetSkinNormalBuffer = targetSkinNormalBuffer;
+        this._targetWrapWeightBuffer = targetWrapWeightBuffer;
         this._program = program;
         this._bindGroup = bindGroup;
         this._workgroupCount = workgroupCount;
-        this._maxOffsetDistance = maxOffsetDistance;
+        this._targetOffsetDistances = targetOffsetDistances;
+        this._targetWrapWeights = targetWrapWeights;
         this._sourceToTargetMatrix = new Matrix4x4();
         this._positionBuffer = positionBuffer;
         this._normalBuffer = normalBuffer;
         this._originalPositionBuffer = originalPositionBuffer;
         this._originalNormalBuffer = originalNormalBuffer;
         this._restoreSkinning = restoreSkinning;
-    }
-    static async create(device, source, sourcePositionBuffer, sourceRestPositions, sourceIndexData, target, workgroupSize) {
+        this._targetBasePositions = targetBasePositions;
+        this._targetBaseNormals = targetBaseNormals;
+        this._targetBlendIndices = targetBlendIndices;
+        this._targetBlendWeights = targetBlendWeights;
+        this._targetSkinnedPositions = new Float32Array(targetBasePositions);
+        this._targetSkinnedNormals = new Float32Array(targetBaseNormals);
+        this._hasPartialWrap = targetWrapWeights.some((weight)=>weight < 1 - 1e-6);
+    }
+    static async create(device, source, sourcePositionBuffer, sourceRestPositions, sourceIndexData, target, workgroupSize, targetWrapWeights) {
         const data = await GPUClothWrapBinding.createBindingData(source, sourceRestPositions, sourceIndexData, target);
-        return GPUClothWrapBinding.createFromData(device, source, sourcePositionBuffer, sourceRestPositions, sourceIndexData, target, workgroupSize, data);
+        return GPUClothWrapBinding.createFromData(device, source, sourcePositionBuffer, sourceRestPositions, sourceIndexData, target, workgroupSize, data, targetWrapWeights);
     }
     static async createBindingData(source, sourceRestPositions, sourceIndexData, target) {
         if (!target?.primitive) {
@@ -1227,7 +1282,7 @@ class GPUClothWrapBinding {
             targetLocalOffsets: encodeTypedArrayBase64(targetLocalOffsets)
         };
     }
-    static createFromData(device, source, sourcePositionBuffer, sourceRestPositions, _sourceIndexData, target, workgroupSize, data) {
+    static async createFromData(device, source, sourcePositionBuffer, sourceRestPositions, _sourceIndexData, target, workgroupSize, data, targetWrapWeightSource) {
         if (!target?.primitive) {
             throw new Error('GPU cloth wrap failed: target mesh has no primitive.');
         }
@@ -1236,11 +1291,24 @@ class GPUClothWrapBinding {
         if (!isWrapBindingDataCompatible(data, sourceRestPositions, vertexCount)) {
             throw new Error('GPU cloth wrap failed: binding cache is incompatible with current meshes.');
         }
+        const [targetBasePositions, targetBaseNormalsSource, targetSkinningData] = await Promise.all([
+            readPositionDataFromPrimitive(targetPrimitive),
+            readVertexAttributeDataFromPrimitive(targetPrimitive, 'normal', 3),
+            readSkinningDataFromMesh(target)
+        ]);
         const expectedElementCount = vertexCount * 3;
+        const hasTargetNormals = !!targetBaseNormalsSource;
+        const targetBaseNormals = targetBaseNormalsSource ?? new Float32Array(expectedElementCount);
+        const targetWrapWeights = normalizeTargetWrapWeights(targetWrapWeightSource, vertexCount);
         const influenceElementCount = vertexCount * data.influenceCount;
         const wrapSourceTriangleIndices = decodeTypedArrayFromBase64(Uint32Array, data.sourceTriangleIndices, influenceElementCount);
         const wrapSourceBarycentrics = decodeTypedArrayFromBase64(Float32Array, data.sourceBarycentrics, influenceElementCount);
         const wrapTargetLocalOffsets = decodeTypedArrayFromBase64(Float32Array, data.targetLocalOffsets, expectedElementCount);
+        const targetOffsetDistances = new Float32Array(vertexCount);
+        for(let vertex = 0; vertex < vertexCount; vertex++){
+            const base = vertex * 3;
+            targetOffsetDistances[vertex] = Math.hypot(wrapTargetLocalOffsets[base], wrapTargetLocalOffsets[base + 1], wrapTargetLocalOffsets[base + 2]);
+        }
         const positionBuffer = device.createVertexBuffer('position_f32x3', new Float32Array(expectedElementCount), {
             storage: true,
             managed: false
@@ -1276,6 +1344,27 @@ class GPUClothWrapBinding {
             managed: false
         });
         wrapLocalOffsetBuffer.bufferSubData(0, wrapTargetLocalOffsets);
+        const targetSkinPositionBuffer = device.createBuffer(targetBasePositions.byteLength, {
+            usage: 'uniform',
+            storage: true,
+            dynamic: false,
+            managed: false
+        });
+        targetSkinPositionBuffer.bufferSubData(0, targetBasePositions);
+        const targetSkinNormalBuffer = device.createBuffer(targetBaseNormals.byteLength, {
+            usage: 'uniform',
+            storage: true,
+            dynamic: false,
+            managed: false
+        });
+        targetSkinNormalBuffer.bufferSubData(0, targetBaseNormals);
+        const targetWrapWeightBuffer = device.createBuffer(targetWrapWeights.byteLength, {
+            usage: 'uniform',
+            storage: true,
+            dynamic: false,
+            managed: false
+        });
+        targetWrapWeightBuffer.bufferSubData(0, targetWrapWeights);
         const program = createWrapDeformerProgram(device, workgroupSize);
         if (!program) {
             throw new Error('GPU cloth wrap failed: could not create compute program.');
@@ -1285,12 +1374,16 @@ class GPUClothWrapBinding {
         bindGroup.setBuffer('sourceTriangleIndices', wrapTriangleIndexBuffer);
         bindGroup.setBuffer('sourceBarycentrics', wrapBarycentricBuffer);
         bindGroup.setBuffer('targetLocalOffsets', wrapLocalOffsetBuffer);
+        bindGroup.setBuffer('targetSkinPositions', targetSkinPositionBuffer);
+        bindGroup.setBuffer('targetSkinNormals', targetSkinNormalBuffer);
+        bindGroup.setBuffer('targetWrapWeights', targetWrapWeightBuffer);
         bindGroup.setBuffer('targetPositions', positionBuffer);
         bindGroup.setBuffer('targetNormals', normalBuffer);
         const sourceToTargetBindMatrix = getWrapSourceToTargetMatrix(source, target);
         bindGroup.setValue('vertexCount', vertexCount);
         bindGroup.setValue('sourceToTargetMatrix', sourceToTargetBindMatrix);
         bindGroup.setValue('minDistance', 1e-5);
+        bindGroup.setValue('hasTargetNormals', hasTargetNormals ? 1 : 0);
         const originalPositionBuffer = targetPrimitive.getVertexBuffer('position');
         const originalNormalBuffer = targetPrimitive.getVertexBuffer('normal');
         retainObject(originalPositionBuffer);
@@ -1306,11 +1399,12 @@ class GPUClothWrapBinding {
             target.setBoneMatrices?.(null);
             target.setAnimatedBoundingBox?.(null);
         }
-        const binding = new GPUClothWrapBinding(device, source, target, targetPrimitive, wrapTriangleIndexBuffer, wrapBarycentricBuffer, wrapLocalOffsetBuffer, program, bindGroup, positionBuffer, normalBuffer, originalPositionBuffer, originalNormalBuffer, Math.max(1, Math.ceil(vertexCount / workgroupSize)), Math.max(0, Number(data.maxOffsetDistance) || 0), restoreSkinning);
+        const binding = new GPUClothWrapBinding(device, source, target, targetPrimitive, wrapTriangleIndexBuffer, wrapBarycentricBuffer, wrapLocalOffsetBuffer, targetSkinPositionBuffer, targetSkinNormalBuffer, targetWrapWeightBuffer, program, bindGroup, positionBuffer, normalBuffer, originalPositionBuffer, originalNormalBuffer, Math.max(1, Math.ceil(vertexCount / workgroupSize)), targetOffsetDistances, restoreSkinning, targetBasePositions, targetBaseNormals, targetSkinningData?.blendIndices ?? null, targetSkinningData?.blendWeights ?? null, targetWrapWeights);
         binding.update();
         return binding;
     }
     update() {
+        this.updateTargetSkinning();
         getWrapSourceToTargetMatrix(this._source, this._target, this._sourceToTargetMatrix);
         this._bindGroup.setValue('sourceToTargetMatrix', this._sourceToTargetMatrix);
         this._device.setProgram(this._program);
@@ -1324,6 +1418,9 @@ class GPUClothWrapBinding {
         this._wrapTriangleIndexBuffer.dispose();
         this._wrapBarycentricBuffer.dispose();
         this._wrapLocalOffsetBuffer.dispose();
+        this._targetSkinPositionBuffer.dispose();
+        this._targetSkinNormalBuffer.dispose();
+        this._targetWrapWeightBuffer.dispose();
         if (this._targetPrimitive) {
             this._targetPrimitive.removeVertexBuffer('position');
             if (this._originalPositionBuffer) {
@@ -1343,73 +1440,31 @@ class GPUClothWrapBinding {
             this._target.suspendSkinning = this._restoreSkinning;
         }
     }
+    updateTargetSkinning() {
+        if (!this._hasPartialWrap) {
+            return;
+        }
+        const skeletonId = String(this._target?.skeletonName ?? '');
+        const skeleton = skeletonId && typeof this._target?.findSkeletonById === 'function' ? this._target.findSkeletonById(skeletonId) : null;
+        if (skeleton?.skinPositionsToLocal && this._targetBlendIndices && this._targetBlendWeights && this._target?.invWorldMatrix) {
+            skeleton.skinPositionsToLocal(this._targetBasePositions, this._targetBlendIndices, this._targetBlendWeights, this._target.invWorldMatrix, this._targetSkinnedPositions);
+            if (skeleton.skinDirectionsToLocal && this._targetBaseNormals.length > 0) {
+                skeleton.skinDirectionsToLocal(this._targetBaseNormals, this._targetBlendIndices, this._targetBlendWeights, this._target.invWorldMatrix, this._targetSkinnedNormals);
+            }
+        } else {
+            this._targetSkinnedPositions.set(this._targetBasePositions);
+            this._targetSkinnedNormals.set(this._targetBaseNormals);
+        }
+        this._targetSkinPositionBuffer.bufferSubData(0, this._targetSkinnedPositions);
+        this._targetSkinNormalBuffer.bufferSubData(0, this._targetSkinnedNormals);
+    }
     updateBoundingBox() {
         const sourceBBox = this._source?.getAnimatedBoundingBox?.() ?? this._source?.primitive?.getBoundingVolume?.()?.toAABB?.() ?? null;
         if (!sourceBBox) {
             return;
         }
-        let minX = Number.POSITIVE_INFINITY;
-        let minY = Number.POSITIVE_INFINITY;
-        let minZ = Number.POSITIVE_INFINITY;
-        let maxX = Number.NEGATIVE_INFINITY;
-        let maxY = Number.NEGATIVE_INFINITY;
-        let maxZ = Number.NEGATIVE_INFINITY;
         getWrapSourceToTargetMatrix(this._source, this._target, this._sourceToTargetMatrix);
-        const corners = [
-            [
-                sourceBBox.minPoint.x,
-                sourceBBox.minPoint.y,
-                sourceBBox.minPoint.z
-            ],
-            [
-                sourceBBox.minPoint.x,
-                sourceBBox.minPoint.y,
-                sourceBBox.maxPoint.z
-            ],
-            [
-                sourceBBox.minPoint.x,
-                sourceBBox.maxPoint.y,
-                sourceBBox.minPoint.z
-            ],
-            [
-                sourceBBox.minPoint.x,
-                sourceBBox.maxPoint.y,
-                sourceBBox.maxPoint.z
-            ],
-            [
-                sourceBBox.maxPoint.x,
-                sourceBBox.minPoint.y,
-                sourceBBox.minPoint.z
-            ],
-            [
-                sourceBBox.maxPoint.x,
-                sourceBBox.minPoint.y,
-                sourceBBox.maxPoint.z
-            ],
-            [
-                sourceBBox.maxPoint.x,
-                sourceBBox.maxPoint.y,
-                sourceBBox.minPoint.z
-            ],
-            [
-                sourceBBox.maxPoint.x,
-                sourceBBox.maxPoint.y,
-                sourceBBox.maxPoint.z
-            ]
-        ];
-        for (const corner of corners){
-            const x = this._sourceToTargetMatrix[0] * corner[0] + this._sourceToTargetMatrix[4] * corner[1] + this._sourceToTargetMatrix[8] * corner[2] + this._sourceToTargetMatrix[12];
-            const y = this._sourceToTargetMatrix[1] * corner[0] + this._sourceToTargetMatrix[5] * corner[1] + this._sourceToTargetMatrix[9] * corner[2] + this._sourceToTargetMatrix[13];
-            const z = this._sourceToTargetMatrix[2] * corner[0] + this._sourceToTargetMatrix[6] * corner[1] + this._sourceToTargetMatrix[10] * corner[2] + this._sourceToTargetMatrix[14];
-            minX = Math.min(minX, x);
-            minY = Math.min(minY, y);
-            minZ = Math.min(minZ, z);
-            maxX = Math.max(maxX, x);
-            maxY = Math.max(maxY, y);
-            maxZ = Math.max(maxZ, z);
-        }
-        const padding = Math.max(0.001, this._maxOffsetDistance);
-        this._target?.setAnimatedBoundingBox?.(new BoundingBox(new Vector3(minX - padding, minY - padding, minZ - padding), new Vector3(maxX + padding, maxY + padding, maxZ + padding)));
+        this._target?.setAnimatedBoundingBox?.(calculateGPUClothWrapBoundingBox(sourceBBox, this._sourceToTargetMatrix, this._targetSkinnedPositions, this._targetOffsetDistances, this._targetWrapWeights));
     }
 }
 /**
@@ -1422,7 +1477,7 @@ class GPUClothWrapBinding {
     }
     const sourcePrimitive = source.primitive;
     const sourcePositions = await readPositionDataFromPrimitive(sourcePrimitive);
-    const sourceIndices = toUInt32Indices(await readIndexDataFromPrimitive(sourcePrimitive, sourcePositions.length / 3 >> 0));
+    const sourceIndices = toUInt32Indices(await readIndexDataFromPrimitive(sourcePrimitive));
     return GPUClothWrapBinding.createBindingData(source, sourcePositions, sourceIndices, target);
 }
 /**
@@ -1472,9 +1527,11 @@ class GPUClothWrapBinding {
     _sphereColliderBuffer;
     _capsuleColliderBuffer;
     _planeColliderBuffer;
+    _boxColliderBuffer;
     _sphereColliderData;
     _capsuleColliderData;
     _planeColliderData;
+    _boxColliderData;
     _triangleIndexBuffer;
     _triangleNormalBuffer;
     _vertexTriangleAdjacencyBuffer;
@@ -1545,9 +1602,11 @@ class GPUClothWrapBinding {
         this._sphereColliderBuffer = null;
         this._capsuleColliderBuffer = null;
         this._planeColliderBuffer = null;
+        this._boxColliderBuffer = null;
         this._sphereColliderData = new Float32Array(getInitialColliderBufferFloatCount(this._colliders, 'sphere', 4));
         this._capsuleColliderData = new Float32Array(getInitialColliderBufferFloatCount(this._colliders, 'capsule', 8));
         this._planeColliderData = new Float32Array(getInitialColliderBufferFloatCount(this._colliders, 'plane', 8));
+        this._boxColliderData = new Float32Array(getInitialColliderBufferFloatCount(this._colliders, 'box', 16));
         this._triangleIndexBuffer = null;
         this._triangleNormalBuffer = null;
         this._vertexTriangleAdjacencyBuffer = null;
@@ -1581,6 +1640,9 @@ class GPUClothWrapBinding {
         };
         if (!supported) {
             this._disabledReason = 'GPU cloth is disabled: current backend is not WebGPU.';
+            if (wantEnabled) {
+                warnUnsupported('GPU cloth (GPUClothComponent)', 'WebGPU', 'the cloth does not move');
+            }
             return;
         }
         if (!this._device) {
@@ -1711,6 +1773,13 @@ class GPUClothWrapBinding {
                 managed: false
             });
             this._planeColliderBuffer.bufferSubData(0, this._planeColliderData);
+            this._boxColliderBuffer = this._device.createBuffer(this._boxColliderData.byteLength, {
+                usage: 'uniform',
+                storage: true,
+                dynamic: false,
+                managed: false
+            });
+            this._boxColliderBuffer.bufferSubData(0, this._boxColliderData);
             this._integrateProgram = createIntegrateProgram(this._device, workgroupSize);
             this._constraintProgram = createConstraintProgram(this._device, workgroupSize);
             if (!this._integrateProgram || !this._constraintProgram) {
@@ -1726,12 +1795,14 @@ class GPUClothWrapBinding {
             this._integrateBindGroup.setBuffer('sphereData', this._sphereColliderBuffer);
             this._integrateBindGroup.setBuffer('capsuleData', this._capsuleColliderBuffer);
             this._integrateBindGroup.setBuffer('planeData', this._planeColliderBuffer);
+            this._integrateBindGroup.setBuffer('boxData', this._boxColliderBuffer);
             this._integrateBindGroup.setValue('vertexCount', vertexCount);
             this._integrateBindGroup.setValue('damping', this._damping);
             this._integrateBindGroup.setValue('gravity', this._gravity);
             this._integrateBindGroup.setValue('sphereCount', 0);
             this._integrateBindGroup.setValue('capsuleCount', 0);
             this._integrateBindGroup.setValue('planeCount', 0);
+            this._integrateBindGroup.setValue('boxCount', 0);
             this._integrateBindGroup.setValue('dynamicFriction', this._dynamicFriction);
             this._integrateBindGroup.setValue('staticFriction', this._staticFriction);
             this._integrateBindGroup.setValue('minDistance', 1e-5);
@@ -1744,6 +1815,7 @@ class GPUClothWrapBinding {
             this._constraintBindGroup.setBuffer('sphereData', this._sphereColliderBuffer);
             this._constraintBindGroup.setBuffer('capsuleData', this._capsuleColliderBuffer);
             this._constraintBindGroup.setBuffer('planeData', this._planeColliderBuffer);
+            this._constraintBindGroup.setBuffer('boxData', this._boxColliderBuffer);
             this._constraintBindGroup.setValue('vertexCount', vertexCount);
             this._constraintBindGroup.setValue('maxNeighbors', this._maxNeighbors);
             this._constraintBindGroup.setValue('stiffness', this._stiffness);
@@ -1751,6 +1823,7 @@ class GPUClothWrapBinding {
             this._constraintBindGroup.setValue('sphereCount', 0);
             this._constraintBindGroup.setValue('capsuleCount', 0);
             this._constraintBindGroup.setValue('planeCount', 0);
+            this._constraintBindGroup.setValue('boxCount', 0);
             this._constraintBindGroup.setValue('dynamicFriction', this._dynamicFriction);
             this._constraintBindGroup.setValue('staticFriction', this._staticFriction);
             this._constraintBindGroup.setValue('minDistance', 1e-5);
@@ -1811,7 +1884,7 @@ class GPUClothWrapBinding {
     static async createFromPrimitive(primitive, options) {
         const positionData = await readPositionDataFromPrimitive(primitive);
         const skinningData = await readSkinningDataFromPrimitive(primitive);
-        const indexData = await readIndexDataFromPrimitive(primitive, positionData.length / 3 >> 0);
+        const indexData = await readIndexDataFromPrimitive(primitive);
         return new GPUClothSystem({
             ...options,
             primitive,
@@ -1825,8 +1898,16 @@ class GPUClothWrapBinding {
         if (!mesh.primitive) {
             throw new Error('GPU cloth initialization failed: mesh has no primitive.');
         }
-        return GPUClothSystem.createFromPrimitive(mesh.primitive, {
+        const positionData = await readPositionDataFromPrimitive(mesh.primitive);
+        const skinningData = await readSkinningDataFromMesh(mesh);
+        const indexData = await readIndexDataFromPrimitive(mesh.primitive);
+        return new GPUClothSystem({
             ...options,
+            primitive: mesh.primitive,
+            positionData,
+            indexData,
+            skinningBlendIndices: skinningData?.blendIndices ?? undefined,
+            skinningBlendWeights: skinningData?.blendWeights ?? undefined,
             collisionSpaceNode: mesh,
             scene: mesh.scene ?? null
         });
@@ -1848,7 +1929,7 @@ class GPUClothWrapBinding {
             }
         }
     }
-    setWrapTargetsFromBindingData(targets) {
+    async setWrapTargetsFromBindingData(targets) {
         this.clearWrapTargets();
         if (!this.supported || !this._device || !this._positionBuffer || !this._sourcePositionData || !this._sourceIndexData) {
             return;
@@ -1861,7 +1942,7 @@ class GPUClothWrapBinding {
             }
             seen.add(target);
             try {
-                const binding = GPUClothWrapBinding.createFromData(this._device, this._collisionSpaceNode, this._positionBuffer, this._sourcePositionData, this._sourceIndexData, target, this._workgroupSize, entry.data);
+                const binding = await GPUClothWrapBinding.createFromData(this._device, this._collisionSpaceNode, this._positionBuffer, this._sourcePositionData, this._sourceIndexData, target, this._workgroupSize, entry.data, entry.targetWrapWeights);
                 this._wrapBindings.push(binding);
             } catch (err) {
                 console.error('GPU cloth wrap target binding cache initialization failed:', err);
@@ -2077,6 +2158,8 @@ class GPUClothWrapBinding {
         this._capsuleColliderBuffer = null;
         this._planeColliderBuffer?.dispose();
         this._planeColliderBuffer = null;
+        this._boxColliderBuffer?.dispose();
+        this._boxColliderBuffer = null;
         releaseObject(this._originalPositionBuffer);
         this._originalPositionBuffer = null;
         releaseObject(this._originalNormalBuffer);
@@ -2145,6 +2228,7 @@ class GPUClothWrapBinding {
         const spheres = [];
         const capsules = [];
         const planes = [];
+        const boxes = [];
         const blend = this.getTemporalBlendFactor(deltaTime, DEFAULT_COLLIDER_SMOOTHING_TIME);
         for (const collider of this._colliders){
             if (!collider?.enabled) {
@@ -2175,6 +2259,10 @@ class GPUClothWrapBinding {
                     point: smoothed.point,
                     normal: smoothed.normal
                 });
+            } else if (collider.type === 'box') {
+                boxes.push({
+                    collider: collider
+                });
             }
         }
         const sphereData = new Float32Array(Math.max(1, spheres.length) * 4);
@@ -2220,6 +2308,31 @@ class GPUClothWrapBinding {
             planeData[base + 6] = normal.z;
             planeData[base + 7] = 0;
         }
+        const boxData = new Float32Array(Math.max(1, boxes.length) * 16);
+        for(let i = 0; i < boxes.length; i++){
+            const base = i * 16;
+            const box = boxes[i].collider;
+            const center = this.toCollisionSpacePoint(box.center);
+            const axisX = this.toCollisionSpaceVector(box.axes[0]);
+            const axisY = this.toCollisionSpaceVector(box.axes[1]);
+            const axisZ = this.toCollisionSpaceVector(box.axes[2]);
+            boxData[base] = center.x;
+            boxData[base + 1] = center.y;
+            boxData[base + 2] = center.z;
+            boxData[base + 3] = this.toCollisionSpaceRadius(box.halfExtents.x);
+            boxData[base + 4] = this.toCollisionSpaceRadius(box.halfExtents.y);
+            boxData[base + 5] = this.toCollisionSpaceRadius(box.halfExtents.z);
+            boxData[base + 6] = axisX.x;
+            boxData[base + 7] = axisX.y;
+            boxData[base + 8] = axisX.z;
+            boxData[base + 9] = axisY.x;
+            boxData[base + 10] = axisY.y;
+            boxData[base + 11] = axisY.z;
+            boxData[base + 12] = axisZ.x;
+            boxData[base + 13] = axisZ.y;
+            boxData[base + 14] = axisZ.z;
+            boxData[base + 15] = 0;
+        }
         if (!this._sphereColliderBuffer || this._sphereColliderBuffer.byteLength < sphereData.byteLength) {
             if (this._sphereColliderBuffer) {
                 // Drain queued uploads for the old buffer before replacing it.
@@ -2268,12 +2381,29 @@ class GPUClothWrapBinding {
             this._constraintBindGroup?.setBuffer('planeData', this._planeColliderBuffer);
         }
         this._planeColliderBuffer.bufferSubData(0, planeData);
+        if (!this._boxColliderBuffer || this._boxColliderBuffer.byteLength < boxData.byteLength) {
+            if (this._boxColliderBuffer) {
+                this._device.flush();
+                this._boxColliderBuffer.dispose();
+            }
+            this._boxColliderBuffer = this._device.createBuffer(boxData.byteLength, {
+                usage: 'uniform',
+                storage: true,
+                dynamic: false,
+                managed: false
+            });
+            this._integrateBindGroup.setBuffer('boxData', this._boxColliderBuffer);
+            this._constraintBindGroup?.setBuffer('boxData', this._boxColliderBuffer);
+        }
+        this._boxColliderBuffer.bufferSubData(0, boxData);
         this._integrateBindGroup.setValue('sphereCount', spheres.length);
         this._integrateBindGroup.setValue('capsuleCount', capsules.length);
         this._integrateBindGroup.setValue('planeCount', planes.length);
+        this._integrateBindGroup.setValue('boxCount', boxes.length);
         this._constraintBindGroup?.setValue('sphereCount', spheres.length);
         this._constraintBindGroup?.setValue('capsuleCount', capsules.length);
         this._constraintBindGroup?.setValue('planeCount', planes.length);
+        this._constraintBindGroup?.setValue('boxCount', boxes.length);
     }
     getSubstepPoseFollow() {
         const effectivePoseFollow = this.getEffectivePoseFollow();
@@ -2520,5 +2650,5 @@ class GPUClothWrapBinding {
     }
 }
 
-export { GPUClothSystem, createGPUClothWrapBindingData, isGPUClothSupported };
+export { GPUClothSystem, calculateGPUClothWrapBoundingBox, createGPUClothWrapBindingData, isGPUClothSupported };
 //# sourceMappingURL=gpu_cloth_system.js.map