@zephyr3d/scene 0.8.2 → 0.9.0

package/dist/utility/serialization/scene/cloth_script.js

@@ -0,0 +1,834 @@
+import { createGPUClothWrapBindingData } from '../../../animation/cloth/gpu_cloth_system.js';
+import { defineProps } from '../types.js';
+
+const clothConfigHostMap = new WeakMap();
+const clothTargetHostMap = new WeakMap();
+const clothTargetOwnerMap = new WeakMap();
+function clamp01(value) {
+    return Math.min(Math.max(value, 0), 1);
+}
+function normalizePlaneDirection(value) {
+    return value < 0 ? -1 : 1;
+}
+function resolveClothHostScope(host) {
+    return typeof host?.getPrefabNode === 'function' && host.getPrefabNode() || host.scene?.rootNode || host;
+}
+function resolveClothMeshById(host, meshId) {
+    const id = String(meshId ?? '').trim();
+    if (!host || !id) {
+        return null;
+    }
+    const scope = resolveClothHostScope(host);
+    const candidate = scope?.findNodeById?.(id);
+    return candidate?.isMesh?.() && candidate.primitive ? candidate : null;
+}
+function resolveClothMeshLabel(host, meshId) {
+    const id = String(meshId ?? '').trim();
+    if (!id) {
+        return '';
+    }
+    const mesh = resolveClothMeshById(host, id);
+    if (mesh) {
+        const name = String(mesh.name ?? '').trim();
+        return name || mesh.persistentId || id;
+    }
+    return `[Missing] ${id}`;
+}
+function getClothConfigHost(config) {
+    return clothConfigHostMap.get(config) ?? null;
+}
+function getClothTargetHost(target) {
+    const owner = clothTargetOwnerMap.get(target);
+    return clothTargetHostMap.get(target) ?? (owner ? clothConfigHostMap.get(owner) : null) ?? null;
+}
+function setClothTargetOwner(target, owner, host) {
+    clothTargetOwnerMap.set(target, owner);
+    if (host) {
+        clothTargetHostMap.set(target, host);
+    }
+}
+function clearClothTargetBinding(target) {
+    target.bindingData = '';
+    target.bindingSignature = '';
+}
+function clearClothBindings(config) {
+    for (const target of config.targetMeshes){
+        clearClothTargetBinding(target);
+    }
+}
+function setClothBindingStatus(config, status) {
+    config.bindingStatus = status;
+}
+function ensureDefaultTargetMeshEntry(config) {
+    if (config.targetMeshes.length === 0) {
+        const target = new ClothTargetMeshConfig();
+        config.targetMeshes.push(target);
+        setClothTargetOwner(target, config, getClothConfigHost(config));
+    }
+}
+function invalidateClothBindings(config, status = 'Binding cache needs rebuild') {
+    clearClothBindings(config);
+    setClothBindingStatus(config, status);
+}
+async function bindClothTargetMeshes(config) {
+    const host = getClothConfigHost(config);
+    if (config.bindingInProgress) {
+        return;
+    }
+    const simulationMesh = resolveClothMeshById(host, config.simulationMeshId) || (host?.isMesh?.() && host.primitive ? host : null);
+    if (!simulationMesh) {
+        setClothBindingStatus(config, 'Set Simulation Mesh before binding.');
+        return;
+    }
+    const targetEntries = config.targetMeshes.filter((entry)=>String(entry.meshId ?? '').trim().length > 0);
+    if (targetEntries.length === 0) {
+        setClothBindingStatus(config, 'Add at least one Target Mesh before binding.');
+        return;
+    }
+    config.bindingInProgress = true;
+    setClothBindingStatus(config, 'Binding target meshes...');
+    let successCount = 0;
+    const failedTargets = [];
+    try {
+        for (const entry of targetEntries){
+            const targetMesh = resolveClothMeshById(getClothTargetHost(entry), entry.meshId);
+            if (!targetMesh) {
+                clearClothTargetBinding(entry);
+                failedTargets.push(resolveClothMeshLabel(host, entry.meshId));
+                continue;
+            }
+            if (targetMesh === simulationMesh) {
+                clearClothTargetBinding(entry);
+                failedTargets.push(resolveClothMeshLabel(host, entry.meshId));
+                continue;
+            }
+            try {
+                const data = await createGPUClothWrapBindingData(simulationMesh, targetMesh);
+                entry.bindingData = JSON.stringify(data);
+                entry.bindingSignature = `${data.version}:${data.vertexCount}:${data.sourceVertexCount}:${data.influenceCount}`;
+                successCount++;
+            } catch (err) {
+                clearClothTargetBinding(entry);
+                failedTargets.push(`${resolveClothMeshLabel(host, entry.meshId)}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    } finally{
+        config.bindingInProgress = false;
+    }
+    if (successCount > 0 && failedTargets.length === 0) {
+        setClothBindingStatus(config, `Bound ${successCount} target mesh(es).`);
+    } else if (successCount > 0) {
+        setClothBindingStatus(config, `Bound ${successCount} target mesh(es), ${failedTargets.length} failed: ${failedTargets.join('; ')}`);
+    } else {
+        setClothBindingStatus(config, failedTargets[0] || 'Binding failed.');
+    }
+}
+function bindClothScriptConfigHost(config, host) {
+    clothConfigHostMap.set(config, host);
+    ensureDefaultTargetMeshEntry(config);
+    for (const target of config.targetMeshes){
+        setClothTargetOwner(target, config, host);
+    }
+}
+class ClothColliderConfig {
+    type;
+    enabled;
+    bone;
+    offsetX;
+    offsetY;
+    offsetZ;
+    endOffsetX;
+    endOffsetY;
+    endOffsetZ;
+    normalX;
+    normalY;
+    normalZ;
+    radius;
+    constructor(type = 'sphere'){
+        this.type = type;
+        this.enabled = true;
+        this.bone = '';
+        this.offsetX = 0;
+        this.offsetY = 0;
+        this.offsetZ = 0;
+        this.endOffsetX = 0;
+        this.endOffsetY = 0.2;
+        this.endOffsetZ = 0;
+        this.normalX = 0;
+        this.normalY = 1;
+        this.normalZ = 0;
+        this.radius = 0.15;
+    }
+}
+class ClothTargetMeshConfig {
+    meshId;
+    bindingData;
+    bindingSignature;
+    constructor(){
+        this.meshId = '';
+        this.bindingData = '';
+        this.bindingSignature = '';
+    }
+}
+class ClothScriptConfig {
+    enabled;
+    autoUpdate;
+    simulationMeshId;
+    targetMeshes;
+    bindingStatus;
+    bindingInProgress;
+    damping;
+    dynamicFriction;
+    staticFriction;
+    stiffness;
+    poseFollow;
+    substeps;
+    gravityX;
+    gravityY;
+    gravityZ;
+    solverIterations;
+    vertexPinWeightsByTarget;
+    pinnedVertexIndicesByTarget;
+    maxNeighbors;
+    maxTrianglesPerVertex;
+    workgroupSize;
+    rebuildNormals;
+    colliders;
+    constructor(){
+        this.enabled = true;
+        this.autoUpdate = true;
+        this.simulationMeshId = '';
+        this.targetMeshes = [
+            new ClothTargetMeshConfig()
+        ];
+        this.bindingStatus = 'Binding cache needs rebuild';
+        this.bindingInProgress = false;
+        this.damping = 0.02;
+        this.dynamicFriction = 0.15;
+        this.staticFriction = 0.3;
+        this.stiffness = 0.3;
+        this.poseFollow = 0;
+        this.substeps = 2;
+        this.gravityX = 0;
+        this.gravityY = -9.8;
+        this.gravityZ = 0;
+        this.solverIterations = 5;
+        this.vertexPinWeightsByTarget = '';
+        this.pinnedVertexIndicesByTarget = '';
+        this.maxNeighbors = 8;
+        this.maxTrianglesPerVertex = 16;
+        this.workgroupSize = 64;
+        this.rebuildNormals = true;
+        this.colliders = [];
+    }
+}
+function getClothColliderConfigClass() {
+    return {
+        ctor: ClothColliderConfig,
+        name: 'ClothColliderConfig',
+        noTitle: true,
+        createFunc () {
+            return {
+                obj: new ClothColliderConfig()
+            };
+        },
+        getProps () {
+            return defineProps([
+                {
+                    name: 'Type',
+                    type: 'string',
+                    options: {
+                        group: 'Shape',
+                        enum: {
+                            labels: [
+                                'Sphere',
+                                'Capsule',
+                                'Plane'
+                            ],
+                            values: [
+                                'sphere',
+                                'capsule',
+                                'plane'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.type;
+                    },
+                    set (value) {
+                        this.type = value.str[0] ?? 'sphere';
+                    }
+                },
+                {
+                    name: 'Enabled',
+                    type: 'bool',
+                    options: {
+                        group: 'General'
+                    },
+                    get (value) {
+                        value.bool[0] = this.enabled;
+                    },
+                    set (value) {
+                        this.enabled = !!value.bool[0];
+                    }
+                },
+                {
+                    name: 'Bone',
+                    type: 'string',
+                    options: {
+                        group: 'General'
+                    },
+                    get (value) {
+                        value.str[0] = this.bone;
+                    },
+                    set (value) {
+                        this.bone = value.str[0] ?? '';
+                    }
+                },
+                {
+                    name: 'Offset',
+                    type: 'vec3',
+                    options: {
+                        group: 'Shape'
+                    },
+                    isValid () {
+                        return this.type !== 'plane';
+                    },
+                    get (value) {
+                        value.num[0] = this.offsetX;
+                        value.num[1] = this.offsetY;
+                        value.num[2] = this.offsetZ;
+                    },
+                    set (value) {
+                        this.offsetX = value.num[0];
+                        this.offsetY = value.num[1];
+                        this.offsetZ = value.num[2];
+                    }
+                },
+                {
+                    name: 'EndOffset',
+                    type: 'vec3',
+                    options: {
+                        group: 'Shape'
+                    },
+                    isValid () {
+                        return this.type === 'capsule';
+                    },
+                    get (value) {
+                        value.num[0] = this.endOffsetX;
+                        value.num[1] = this.endOffsetY;
+                        value.num[2] = this.endOffsetZ;
+                    },
+                    set (value) {
+                        this.endOffsetX = value.num[0];
+                        this.endOffsetY = value.num[1];
+                        this.endOffsetZ = value.num[2];
+                    }
+                },
+                {
+                    name: 'Radius',
+                    type: 'float',
+                    options: {
+                        group: 'Shape',
+                        minValue: 0
+                    },
+                    isValid () {
+                        return this.type !== 'plane';
+                    },
+                    get (value) {
+                        value.num[0] = this.radius;
+                    },
+                    set (value) {
+                        this.radius = value.num[0];
+                    }
+                },
+                {
+                    name: 'Normal',
+                    type: 'float',
+                    options: {
+                        group: 'Shape',
+                        minValue: -1,
+                        maxValue: 1
+                    },
+                    isValid () {
+                        return this.type === 'plane';
+                    },
+                    get (value) {
+                        value.num[0] = this.normalY;
+                    },
+                    set (value) {
+                        this.normalX = 0;
+                        this.normalY = normalizePlaneDirection(value.num[0]);
+                        this.normalZ = 0;
+                    }
+                }
+            ]);
+        }
+    };
+}
+function getClothTargetMeshConfigClass() {
+    return {
+        ctor: ClothTargetMeshConfig,
+        name: 'ClothTargetMeshConfig',
+        noTitle: true,
+        createFunc () {
+            return {
+                obj: new ClothTargetMeshConfig()
+            };
+        },
+        getProps () {
+            return defineProps([
+                {
+                    name: 'TargetMesh',
+                    type: 'string',
+                    options: {
+                        sceneNode: {
+                            kind: 'mesh'
+                        }
+                    },
+                    isPersistent () {
+                        return false;
+                    },
+                    get (value) {
+                        value.str[0] = resolveClothMeshLabel(getClothTargetHost(this), this.meshId);
+                    },
+                    set (value) {
+                        const nextId = String(value.str[0] ?? '').trim();
+                        if (this.meshId !== nextId) {
+                            this.meshId = nextId;
+                            clearClothTargetBinding(this);
+                            const owner = clothTargetOwnerMap.get(this);
+                            if (owner) {
+                                setClothBindingStatus(owner, 'Binding cache needs rebuild');
+                            }
+                        }
+                    }
+                },
+                {
+                    name: 'MeshId',
+                    type: 'string',
+                    isHidden () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = this.meshId;
+                    },
+                    set (value) {
+                        this.meshId = value.str[0] ?? '';
+                    }
+                },
+                {
+                    name: 'BindingData',
+                    type: 'string',
+                    isHidden () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = this.bindingData;
+                    },
+                    set (value) {
+                        this.bindingData = value.str[0] ?? '';
+                    }
+                },
+                {
+                    name: 'BindingSignature',
+                    type: 'string',
+                    isHidden () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = this.bindingSignature;
+                    },
+                    set (value) {
+                        this.bindingSignature = value.str[0] ?? '';
+                    }
+                }
+            ]);
+        }
+    };
+}
+function getClothScriptConfigClass() {
+    return {
+        ctor: ClothScriptConfig,
+        name: 'ClothScriptConfig',
+        noTitle: true,
+        createFunc () {
+            return {
+                obj: new ClothScriptConfig()
+            };
+        },
+        getProps () {
+            return defineProps([
+                {
+                    name: 'Enabled',
+                    type: 'bool',
+                    options: {
+                        group: 'General'
+                    },
+                    get (value) {
+                        value.bool[0] = this.enabled;
+                    },
+                    set (value) {
+                        this.enabled = !!value.bool[0];
+                    }
+                },
+                {
+                    name: 'AutoUpdate',
+                    type: 'bool',
+                    options: {
+                        group: 'General'
+                    },
+                    get (value) {
+                        value.bool[0] = this.autoUpdate;
+                    },
+                    set (value) {
+                        this.autoUpdate = !!value.bool[0];
+                    }
+                },
+                {
+                    name: 'SimulationMesh',
+                    type: 'string',
+                    options: {
+                        group: 'General',
+                        sceneNode: {
+                            kind: 'mesh'
+                        }
+                    },
+                    isPersistent () {
+                        return false;
+                    },
+                    get (value) {
+                        value.str[0] = resolveClothMeshLabel(getClothConfigHost(this), this.simulationMeshId);
+                    },
+                    set (value) {
+                        const nextId = String(value.str[0] ?? '').trim();
+                        if (this.simulationMeshId !== nextId) {
+                            this.simulationMeshId = nextId;
+                            invalidateClothBindings(this);
+                        }
+                    }
+                },
+                {
+                    name: 'SimulationMeshId',
+                    type: 'string',
+                    isHidden () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = this.simulationMeshId;
+                    },
+                    set (value) {
+                        this.simulationMeshId = value.str[0] ?? '';
+                    }
+                },
+                {
+                    name: 'TargetMesh',
+                    type: 'object_array',
+                    options: {
+                        group: 'Binding',
+                        objectTypes: [
+                            ClothTargetMeshConfig
+                        ],
+                        inlineObjectArray: true
+                    },
+                    get (value) {
+                        ensureDefaultTargetMeshEntry(this);
+                        value.object = this.targetMeshes;
+                    },
+                    set (value) {
+                        this.targetMeshes = (value.object ?? []).filter((entry)=>entry instanceof ClothTargetMeshConfig);
+                        ensureDefaultTargetMeshEntry(this);
+                        const host = getClothConfigHost(this);
+                        for (const entry of this.targetMeshes){
+                            setClothTargetOwner(entry, this, host);
+                        }
+                    },
+                    add (value, index) {
+                        const target = value.object?.[0] ?? new ClothTargetMeshConfig();
+                        setClothTargetOwner(target, this, getClothConfigHost(this));
+                        this.targetMeshes.splice(index ?? this.targetMeshes.length, 0, target);
+                        setClothBindingStatus(this, 'Binding cache needs rebuild');
+                    },
+                    delete (index) {
+                        this.targetMeshes.splice(index, 1);
+                        ensureDefaultTargetMeshEntry(this);
+                        setClothBindingStatus(this, 'Binding cache needs rebuild');
+                    },
+                    create () {
+                        return new ClothTargetMeshConfig();
+                    }
+                },
+                {
+                    name: 'BindingStatus',
+                    type: 'string',
+                    readonly: true,
+                    options: {
+                        group: 'Binding'
+                    },
+                    isPersistent () {
+                        return false;
+                    },
+                    get (value) {
+                        value.str[0] = this.bindingStatus;
+                    }
+                },
+                {
+                    name: 'Binding',
+                    type: 'command',
+                    options: {
+                        group: 'Binding'
+                    },
+                    get (value) {
+                        value.str[0] = this.bindingInProgress ? 'Binding...' : 'Bind';
+                        value.str[1] = 'Clear';
+                    },
+                    command (index) {
+                        if (index === 0) {
+                            if (!this.bindingInProgress) {
+                                void bindClothTargetMeshes(this);
+                            }
+                        } else {
+                            clearClothBindings(this);
+                            setClothBindingStatus(this, 'Binding cache cleared.');
+                        }
+                        return true;
+                    }
+                },
+                {
+                    name: 'VertexPinWeightsByTarget',
+                    type: 'string',
+                    isHidden () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = this.vertexPinWeightsByTarget;
+                    },
+                    set (value) {
+                        this.vertexPinWeightsByTarget = value.str[0] ?? '';
+                    }
+                },
+                {
+                    name: 'PinnedVertexIndicesByTarget',
+                    type: 'string',
+                    isHidden () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = this.pinnedVertexIndicesByTarget;
+                    },
+                    set (value) {
+                        this.pinnedVertexIndicesByTarget = value.str[0] ?? '';
+                    }
+                },
+                {
+                    name: 'Gravity',
+                    type: 'vec3',
+                    options: {
+                        group: 'Simulation'
+                    },
+                    get (value) {
+                        value.num[0] = this.gravityX;
+                        value.num[1] = this.gravityY;
+                        value.num[2] = this.gravityZ;
+                    },
+                    set (value) {
+                        this.gravityX = value.num[0];
+                        this.gravityY = value.num[1];
+                        this.gravityZ = value.num[2];
+                    }
+                },
+                {
+                    name: 'Damping',
+                    type: 'float',
+                    options: {
+                        group: 'Simulation',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.damping;
+                    },
+                    set (value) {
+                        this.damping = clamp01(value.num[0]);
+                    }
+                },
+                {
+                    name: 'Stiffness',
+                    type: 'float',
+                    options: {
+                        group: 'Simulation',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.stiffness;
+                    },
+                    set (value) {
+                        this.stiffness = clamp01(value.num[0]);
+                    }
+                },
+                {
+                    name: 'DynamicFriction',
+                    type: 'float',
+                    options: {
+                        group: 'Simulation',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.dynamicFriction;
+                    },
+                    set (value) {
+                        this.dynamicFriction = clamp01(value.num[0]);
+                    }
+                },
+                {
+                    name: 'PoseFollow',
+                    type: 'float',
+                    options: {
+                        group: 'PoseFollow',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.poseFollow;
+                    },
+                    set (value) {
+                        this.poseFollow = clamp01(value.num[0]);
+                    }
+                },
+                {
+                    name: 'StaticFriction',
+                    type: 'float',
+                    options: {
+                        group: 'Simulation',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.staticFriction;
+                    },
+                    set (value) {
+                        this.staticFriction = clamp01(value.num[0]);
+                    }
+                },
+                {
+                    name: 'SolverIterations',
+                    type: 'int',
+                    options: {
+                        group: 'Simulation',
+                        minValue: 1,
+                        maxValue: 32
+                    },
+                    get (value) {
+                        value.num[0] = this.solverIterations;
+                    },
+                    set (value) {
+                        this.solverIterations = value.num[0];
+                    }
+                },
+                {
+                    name: 'Substeps',
+                    type: 'int',
+                    options: {
+                        group: 'Simulation',
+                        minValue: 1,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.substeps;
+                    },
+                    set (value) {
+                        this.substeps = Math.max(1, Math.min(8, value.num[0] | 0));
+                    }
+                },
+                {
+                    name: 'MaxNeighbors',
+                    type: 'int',
+                    options: {
+                        group: 'Advanced',
+                        minValue: 1,
+                        maxValue: 64
+                    },
+                    get (value) {
+                        value.num[0] = this.maxNeighbors;
+                    },
+                    set (value) {
+                        this.maxNeighbors = value.num[0];
+                    }
+                },
+                {
+                    name: 'MaxTrianglesPerVertex',
+                    type: 'int',
+                    options: {
+                        group: 'Advanced',
+                        minValue: 1,
+                        maxValue: 64
+                    },
+                    get (value) {
+                        value.num[0] = this.maxTrianglesPerVertex;
+                    },
+                    set (value) {
+                        this.maxTrianglesPerVertex = value.num[0];
+                    }
+                },
+                {
+                    name: 'WorkgroupSize',
+                    type: 'int',
+                    options: {
+                        group: 'Advanced',
+                        minValue: 1,
+                        maxValue: 256
+                    },
+                    get (value) {
+                        value.num[0] = this.workgroupSize;
+                    },
+                    set (value) {
+                        this.workgroupSize = value.num[0];
+                    }
+                },
+                {
+                    name: 'RebuildNormals',
+                    type: 'bool',
+                    options: {
+                        group: 'Advanced'
+                    },
+                    get (value) {
+                        value.bool[0] = this.rebuildNormals;
+                    },
+                    set (value) {
+                        this.rebuildNormals = !!value.bool[0];
+                    }
+                },
+                {
+                    name: 'Colliders',
+                    type: 'object_array',
+                    options: {
+                        group: 'Collider',
+                        objectTypes: [
+                            ClothColliderConfig
+                        ]
+                    },
+                    get (value) {
+                        value.object = this.colliders;
+                    },
+                    set (value) {
+                        this.colliders = value.object ?? [];
+                    },
+                    add (value, index) {
+                        this.colliders.splice(index ?? this.colliders.length, 0, value.object[0]);
+                    },
+                    delete (index) {
+                        this.colliders.splice(index, 1);
+                    },
+                    create () {
+                        return new ClothColliderConfig();
+                    }
+                }
+            ]);
+        }
+    };
+}
+
+export { ClothColliderConfig, ClothScriptConfig, ClothTargetMeshConfig, bindClothScriptConfigHost, getClothColliderConfigClass, getClothScriptConfigClass, getClothTargetMeshConfigClass };
+//# sourceMappingURL=cloth_script.js.map