@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/components/anim/morphAnim/MorphTargetFrame.d.ts

@@ -0,0 +1,68 @@
+declare class texture {
+    mouthRollLower: number;
+    browOuterUp_L: number;
+    mouthSmile_L: number;
+    jawRight: number;
+    eyeLookOut_L: number;
+    mouthFunnel: number;
+    mouthUpperUp_R: number;
+    browDown_L: number;
+    jawLeft: number;
+    mouthLowerDown_L: number;
+    noseSneer_R: number;
+    jawForward: number;
+    mouthLowerDown_R: number;
+    browInnerUp: number;
+    mouthRollUpper: number;
+    mouthStretch_R: number;
+    mouthPucker: number;
+    eyeBlink_L: number;
+    mouthUpperUp_L: number;
+    mouthShrugUpper: number;
+    eyeLookIn_R: number;
+    noseSneer_L: number;
+    mouthFrown_L: number;
+    cheekSquint_L: number;
+    eyeLookDown_L: number;
+    mouthDimple_L: number;
+    mouthFrown_R: number;
+    eyeLookIn_L: number;
+    eyeLookOut_R: number;
+    mouthLeft: number;
+    mouthStretch_L: number;
+    mouthPress_L: number;
+    mouthDimple_R: number;
+    eyeWide_R: number;
+    browDown_R: number;
+    eyeLookUp_R: number;
+    eyeBlink_R: number;
+    cheekSquint_R: number;
+    mouthRight: number;
+    eyeLookDown_R: number;
+    eyeLookUp_L: number;
+    eyeSquint_L: number;
+    jawOpen: number;
+    browOuterUp_R: number;
+    mouthClose: number;
+    mouthShrugLower: number;
+    eyeWide_L: number;
+    tongueOut: number;
+    eyeSquint_R: number;
+    cheekPuff: number;
+    mouthPress_R: number;
+    mouthSmile_R: number;
+}
+type float3 = [number, number, number];
+type float4 = [number, number, number, number];
+type float4x4 = [float4, float4, float4, float4];
+type transform = {
+    leftEyeTransform: float4x4;
+    lookAtPoint: float3;
+    rightEyeTransform: float4x4;
+    transform: float4x4;
+};
+export declare class MorphTargetFrame {
+    texture: texture;
+    transform: transform;
+}
+export {};

package/dist/src/components/anim/morphAnim/MorphTargetFrame.js

@@ -0,0 +1,4 @@
+class texture {
+}
+export class MorphTargetFrame {
+}

package/dist/src/components/anim/morphAnim/MorphTargetKey.d.ts

@@ -0,0 +1,58 @@
+export type MorphTargetMapper = {
+    [key: string]: MorphTargetStandardKey;
+};
+export type MorphTargetStandardKey = "mouthRollLower" | "browOuterUp_L" | "mouthSmile_L" | "jawRight" | "eyeLookOut_L" | "mouthFunnel" | "mouthUpperUp_R" | "browDown_L" | "jawLeft" | "mouthLowerDown_L" | "noseSneer_R" | "jawForward" | "mouthLowerDown_R" | "browInnerUp" | "mouthRollUpper" | "mouthStretch_R" | "mouthPucker" | "eyeBlink_L" | "mouthUpperUp_L" | "mouthShrugUpper" | "eyeLookIn_R" | "noseSneer_L" | "mouthFrown_L" | "cheekSquint_L" | "eyeLookDown_L" | "mouthDimple_L" | "mouthFrown_R" | "eyeLookIn_L" | "eyeLookOut_R" | "mouthLeft" | "mouthStretch_L" | "mouthPress_L" | "mouthDimple_R" | "eyeWide_R" | "browDown_R" | "eyeLookUp_R" | "eyeBlink_R" | "cheekSquint_R" | "mouthRight" | "eyeLookDown_R" | "eyeLookUp_L" | "eyeSquint_L" | "jawOpen" | "browOuterUp_R" | "mouthClose" | "mouthShrugLower" | "eyeWide_L" | "tongueOut" | "eyeSquint_R" | "cheekPuff" | "mouthPress_R" | "mouthSmile_R";
+export declare enum MorphTargetTransformKey {
+    "mouthRollLower" = "mouthRollLower",
+    "browOuterUp_L" = "browOuterUpLeft",
+    "mouthSmile_L" = "mouthSmileLeft",
+    "jawRight" = "jawRight",
+    "eyeLookOut_L" = "eyeLookOutLeft",
+    "mouthFunnel" = "mouthFunnel",
+    "mouthUpperUp_R" = "mouthUpperUpRight",
+    "browDown_L" = "browDownLeft",
+    "jawLeft" = "jawLeft",
+    "mouthLowerDown_L" = "mouthLowerDownLeft",
+    "noseSneer_R" = "noseSneerRight",
+    "jawForward" = "jawForward",
+    "mouthLowerDown_R" = "mouthLowerDownRight",
+    "browInnerUp" = "browInnerUp",
+    "mouthRollUpper" = "mouthRollUpper",
+    "mouthStretch_R" = "mouthStretchRight",
+    "mouthPucker" = "mouthPucker",
+    "eyeBlink_L" = "eyeBlinkLeft",
+    "mouthUpperUp_L" = "mouthUpperUpLeft",
+    "mouthShrugUpper" = "mouthShrugUpper",
+    "eyeLookIn_R" = "eyeLookInRight",
+    "noseSneer_L" = "noseSneerLeft",
+    "mouthFrown_L" = "mouthFrownLeft",
+    "cheekSquint_L" = "cheekSquintLeft",
+    "eyeLookDown_L" = "eyeLookDownLeft",
+    "mouthDimple_L" = "mouthDimpleLeft",
+    "mouthFrown_R" = "mouthFrownRight",
+    "eyeLookIn_L" = "eyeLookInLeft",
+    "eyeLookOut_R" = "eyeLookOutRight",
+    "mouthLeft" = "mouthLeft",
+    "mouthStretch_L" = "mouthStretchLeft",
+    "mouthPress_L" = "mouthPressLeft",
+    "mouthDimple_R" = "mouthDimpleRight",
+    "eyeWide_R" = "eyeWideRight",
+    "browDown_R" = "browDownRight",
+    "eyeLookUp_R" = "eyeLookUpRight",
+    "eyeBlink_R" = "eyeBlinkRight",
+    "cheekSquint_R" = "cheekSquintRight",
+    "mouthRight" = "mouthDimpleRight",
+    "eyeLookDown_R" = "eyeLookDownRight",
+    "eyeLookUp_L" = "eyeLookUpLeft",
+    "eyeSquint_L" = "eyeSquintLeft",
+    "jawOpen" = "jawOpen",
+    "browOuterUp_R" = "browOuterUpRight",
+    "mouthClose" = "mouthClose",
+    "mouthShrugLower" = "mouthShrugLower",
+    "eyeWide_L" = "eyeWideLeft",
+    "tongueOut" = "tongueOut",
+    "eyeSquint_R" = "eyeSquintRight",
+    "cheekPuff" = "cheekPuff",
+    "mouthPress_R" = "mouthPressRight",
+    "mouthSmile_R" = "mouthSmileRight"
+}

package/dist/src/components/anim/morphAnim/MorphTargetKey.js

@@ -0,0 +1,55 @@
+export var MorphTargetTransformKey;
+(function (MorphTargetTransformKey) {
+    MorphTargetTransformKey["mouthRollLower"] = "mouthRollLower";
+    MorphTargetTransformKey["browOuterUp_L"] = "browOuterUpLeft";
+    MorphTargetTransformKey["mouthSmile_L"] = "mouthSmileLeft";
+    MorphTargetTransformKey["jawRight"] = "jawRight";
+    MorphTargetTransformKey["eyeLookOut_L"] = "eyeLookOutLeft";
+    MorphTargetTransformKey["mouthFunnel"] = "mouthFunnel";
+    MorphTargetTransformKey["mouthUpperUp_R"] = "mouthUpperUpRight";
+    MorphTargetTransformKey["browDown_L"] = "browDownLeft";
+    MorphTargetTransformKey["jawLeft"] = "jawLeft";
+    MorphTargetTransformKey["mouthLowerDown_L"] = "mouthLowerDownLeft";
+    MorphTargetTransformKey["noseSneer_R"] = "noseSneerRight";
+    MorphTargetTransformKey["jawForward"] = "jawForward";
+    MorphTargetTransformKey["mouthLowerDown_R"] = "mouthLowerDownRight";
+    MorphTargetTransformKey["browInnerUp"] = "browInnerUp";
+    MorphTargetTransformKey["mouthRollUpper"] = "mouthRollUpper";
+    MorphTargetTransformKey["mouthStretch_R"] = "mouthStretchRight";
+    MorphTargetTransformKey["mouthPucker"] = "mouthPucker";
+    MorphTargetTransformKey["eyeBlink_L"] = "eyeBlinkLeft";
+    MorphTargetTransformKey["mouthUpperUp_L"] = "mouthUpperUpLeft";
+    MorphTargetTransformKey["mouthShrugUpper"] = "mouthShrugUpper";
+    MorphTargetTransformKey["eyeLookIn_R"] = "eyeLookInRight";
+    MorphTargetTransformKey["noseSneer_L"] = "noseSneerLeft";
+    MorphTargetTransformKey["mouthFrown_L"] = "mouthFrownLeft";
+    MorphTargetTransformKey["cheekSquint_L"] = "cheekSquintLeft";
+    MorphTargetTransformKey["eyeLookDown_L"] = "eyeLookDownLeft";
+    MorphTargetTransformKey["mouthDimple_L"] = "mouthDimpleLeft";
+    MorphTargetTransformKey["mouthFrown_R"] = "mouthFrownRight";
+    MorphTargetTransformKey["eyeLookIn_L"] = "eyeLookInLeft";
+    MorphTargetTransformKey["eyeLookOut_R"] = "eyeLookOutRight";
+    MorphTargetTransformKey["mouthLeft"] = "mouthLeft";
+    MorphTargetTransformKey["mouthStretch_L"] = "mouthStretchLeft";
+    MorphTargetTransformKey["mouthPress_L"] = "mouthPressLeft";
+    MorphTargetTransformKey["mouthDimple_R"] = "mouthDimpleRight";
+    MorphTargetTransformKey["eyeWide_R"] = "eyeWideRight";
+    MorphTargetTransformKey["browDown_R"] = "browDownRight";
+    MorphTargetTransformKey["eyeLookUp_R"] = "eyeLookUpRight";
+    MorphTargetTransformKey["eyeBlink_R"] = "eyeBlinkRight";
+    MorphTargetTransformKey["cheekSquint_R"] = "cheekSquintRight";
+    MorphTargetTransformKey["mouthRight"] = "mouthDimpleRight";
+    MorphTargetTransformKey["eyeLookDown_R"] = "eyeLookDownRight";
+    MorphTargetTransformKey["eyeLookUp_L"] = "eyeLookUpLeft";
+    MorphTargetTransformKey["eyeSquint_L"] = "eyeSquintLeft";
+    MorphTargetTransformKey["jawOpen"] = "jawOpen";
+    MorphTargetTransformKey["browOuterUp_R"] = "browOuterUpRight";
+    MorphTargetTransformKey["mouthClose"] = "mouthClose";
+    MorphTargetTransformKey["mouthShrugLower"] = "mouthShrugLower";
+    MorphTargetTransformKey["eyeWide_L"] = "eyeWideLeft";
+    MorphTargetTransformKey["tongueOut"] = "tongueOut";
+    MorphTargetTransformKey["eyeSquint_R"] = "eyeSquintRight";
+    MorphTargetTransformKey["cheekPuff"] = "cheekPuff";
+    MorphTargetTransformKey["mouthPress_R"] = "mouthPressRight";
+    MorphTargetTransformKey["mouthSmile_R"] = "mouthSmileRight";
+})(MorphTargetTransformKey || (MorphTargetTransformKey = {}));

package/dist/src/components/anim/morphAnim/MorphTarget_shader.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 面部表情、形状变形着色器
+ */
+export declare class MorphTarget_shader {
+    static getMorphTargetShaderBinding(group: number, beginBinding: number): string;
+    static getMorphTargetCalcVertex(): string;
+    static CsMain: string;
+}

package/dist/src/components/anim/morphAnim/MorphTarget_shader.js

@@ -0,0 +1,101 @@
+/**
+ * 面部表情、形状变形着色器
+ */
+export class MorphTarget_shader {
+    static getMorphTargetShaderBinding(group, beginBinding) {
+        return `
+            fn blendMorphTargetPosition(vertexID:i32, posIn:vec3<f32>) -> vec3<f32>{
+                let offset:i32 = vertexID * 3;
+                var pos = posIn * morphTargetConfig:morphBaseInfluence;
+                pos += vec3<f32>(morphTargetOpPositions[offset], morphTargetOpPositions[offset + 1], morphTargetOpPositions[offset + 2]);
+                return pos;
+            }
+
+            #if USE_MORPHNORMALS
+                fn blendMorphTargetNormal(vertexID:i32, normalIn:vec3<f32>) -> vec3<f32> {
+                    let offset:i32 = vertexID * 3;
+                    var normal = normalIn * morphTargetConfig.morphBaseInfluence;
+                    normal += vec3<f32>(morphTargetOpNormals[offset], morphTargetOpNormals[offset + 1], morphTargetOpNormals[offset + 2]);
+                    return normal;
+                }
+            #endif
+
+            struct MorphTargetConfigData {
+                morphBaseInfluence:f32, // 基础形变权重
+                morphTargetCount:f32, // 变形目标数量
+                totalVertexCount:f32, // 总顶点数
+                computeWorkGroupXY:f32, // 计算工作组的XY维度
+            };
+
+            @group(${group}) @binding(${beginBinding})
+            var<uniform> morphTargetConfig: MorphTargetConfigData;
+
+            @group(${group}) @binding(${beginBinding + 1})
+            var<storage,read> morphTargetOpPosition: array<f32>;
+
+            #if USE_MORPHNORMALS
+                @group(${group}) @binding(${beginBinding + 2})
+                var<storage,read> morphTargetOpNormals: array<f32>;
+            #endif
+        `;
+    }
+    static getMorphTargetCalcVertex() {
+        return `
+            vertexPosition = blendMorphTargetPosition(i32(vertex.vIndex), vertexPosition);
+
+            #if USE_MORPHNORMALS
+                vertexNormal = blendMorphTargetNormal(i32(vertex.vIndex), vertexNormal);
+            #endif
+        `;
+    }
+    static { this.CsMain = `
+        struct MorphTargetConfigData {
+            morphBaseInfluence:f32,
+            morphTargetCount:f32,
+            totalVertexCount:f32,
+            computeWorkGroupXY:f32,
+        };
+
+        @group(0) @binding(0) var<uniform> morphTargetConfig: MorphTargetConfigData;
+        @group(0) @binding(1) var<storage, read> morphTargetInfluence : array<f32>;
+        @group(0) @binding(2) var<storage, read> morphTargetPositions : array<f32>;
+        @group(0) @binding(3) var<storage, read_write> morphTargetOpPositions : array<f32>;
+
+        #if USE_MORPHNORMALS
+            @group(0) @binding(4) var<storage, read> morphTargetNormals : array<f32>;
+            @group(0) @binding(5) var<storage, read_write> morphTargetOpNormals : array<f32>;
+        #endif
+
+        @compute @workgroup_size( 8 , 8 , 1 )
+        fn CsMain(@builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
+            let vertexIndex:i32 = i32(globalInvocation_id.y) * i32(morphTargetConfig.computeWorkGroupXY) + i32(globalInvocation_id.x);
+            let morphTargetCount:i32 = i32(morphTargetConfig.morphTargetCount);
+            let totalVertexCount:i32 = i32(morphTargetConfig.totalVertexCount);
+            var vertexPosition:vec3<f32> = vec3<f32>(0.0);
+            var vertexNormal:vec3<f32> = vec3<f32>(0.0);
+            if(vertexIndex < totalVertexCount){
+                for(var i:i32 = 0; i < morphTargetCount; i ++){
+                    let offset:i32 = (i * totalVertexCount + vertexIndex) * 3;
+                    let morphPosition = vec3<f32>(morphTargetPositions[offset], morphTargetPositions[offset + 1], morphTargetPositions[offset + 2]);
+                    vertexPosition += morphTargetInfluence[i] * morphPosition;
+                }
+                var writeOffset = vertexIndex * 3;
+                morphTargetOpPositions[writeOffset] = vertexPosition.x;
+                morphTargetOpPositions[writeOffset + 1] = vertexPosition.y;
+                morphTargetOpPositions[writeOffset + 2] = vertexPosition.z;
+
+                #if USE_MORPHNORMALS
+                    for(var i:i32 = 0; i < morphTargetCount; i ++){
+                        let offset:i32 = (i * totalVertexCount + vertexIndex) * 3;
+                        let morphNormal = vec3<f32>(morphTargetNormals[offset], morphTargetNormals[offset + 1], morphTargetNormals[offset + 2]);
+                        vertexNormal += morphTargetInfluence[i] * morphNormal;
+                    }
+
+                    morphTargetOpNormals[writeOffset] = vertexNormal.x;
+                    morphTargetOpNormals[writeOffset + 1] = vertexNormal.y;
+                    morphTargetOpNormals[writeOffset + 2] = vertexNormal.z;
+                #endif
+            }
+        }
+    `; }
+}

package/dist/src/components/anim/skeletonAnim/Joint.d.ts

@@ -0,0 +1,12 @@
+import { Quaternion } from "../../../math/Quaternion";
+import { Vector3 } from "../../../math/Vector3";
+export declare class Joint {
+    name: string;
+    index: number;
+    instanceID: string;
+    parent: Joint;
+    scale: Vector3;
+    rotation: Quaternion;
+    translation: Vector3;
+    constructor(name?: string);
+}

package/dist/src/components/anim/skeletonAnim/Joint.js

@@ -0,0 +1,14 @@
+import { Quaternion } from "../../../math/Quaternion";
+import { Vector3 } from "../../../math/Vector3";
+export class Joint {
+    constructor(name = "") {
+        this.name = "";
+        this.index = 0;
+        this.instanceID = "";
+        this.parent = null;
+        this.scale = new Vector3();
+        this.rotation = new Quaternion();
+        this.translation = new Vector3();
+        this.name = name;
+    }
+}

package/dist/src/components/anim/skeletonAnim/JointPose.d.ts

@@ -0,0 +1,6 @@
+import { Matrix4 } from "../../../math/Matrix4";
+export declare class JointPose {
+    index: number;
+    worldMatrix: Matrix4;
+    constructor(index: number, useGlobalMatrix?: boolean);
+}

package/dist/src/components/anim/skeletonAnim/JointPose.js

@@ -0,0 +1,7 @@
+import { Matrix4 } from "../../../math/Matrix4";
+export class JointPose {
+    constructor(index, useGlobalMatrix = false) {
+        this.index = index;
+        this.worldMatrix = new Matrix4(!useGlobalMatrix);
+    }
+}

package/dist/src/components/anim/skeletonAnim/Skeleton.d.ts

@@ -0,0 +1,10 @@
+import { Joint } from "./Joint";
+export declare class Skeleton {
+    joints: Array<Joint>;
+    constructor(joints?: Array<Joint>);
+    get numJoint(): number;
+    addJoint(joint: Joint): void;
+    getJointName(jointIndex: number): string;
+    getJointParentIndex(jointIndex: number): number;
+    getJointByName(name: string): Joint;
+}

package/dist/src/components/anim/skeletonAnim/Skeleton.js

@@ -0,0 +1,26 @@
+export class Skeleton {
+    constructor(joints = []) {
+        this.joints = joints;
+    }
+    get numJoint() {
+        return this.joints.length;
+    }
+    addJoint(joint) {
+        joint.index = this.joints.push(joint) - 1;
+    }
+    getJointName(jointIndex) {
+        return this.joints[jointIndex].name;
+    }
+    getJointParentIndex(jointIndex) {
+        let joint = this.joints[jointIndex];
+        return joint.parent ? joint.parent.index : -1;
+    }
+    getJointByName(name) {
+        for (let joint of this.joints) {
+            if (joint.name == name) {
+                return joint;
+            }
+        }
+        return null;
+    }
+}

package/dist/src/components/anim/skeletonAnim/SkeletonAnimationClip.d.ts

@@ -0,0 +1,22 @@
+import { Skeleton } from "./Skeleton";
+import { SkeletonPose } from "./SkeletonPose";
+import { OAnimationEvent } from "../OAnimationEvent";
+export declare class SkeletonAnimationClip {
+    name: string;
+    protected _skeleton: Skeleton;
+    protected _skeletonPoses: Array<SkeletonPose>;
+    protected _animationClipData: Float32Array;
+    protected _events: Array<OAnimationEvent>;
+    constructor(name: string, skeleton: Skeleton, numFrame: number, bufferData: Float32Array);
+    get totalTime(): number;
+    get frameRate(): number;
+    get skeleton(): Skeleton;
+    get numFrame(): number;
+    get animationClipData(): Float32Array;
+    getSkeletonPose(frame: number): SkeletonPose;
+    getLerpSkeletonPose(currFrame: number, nextFrame: number, weight: number, dst: SkeletonPose): SkeletonPose;
+    createSubClip(name: string, startTime: number, endTime: number): SkeletonAnimationClip;
+    addEvent(eventName: string, triggerTime: number): void;
+    removeEvent(eventName: string): void;
+    getEvents(): Array<OAnimationEvent>;
+}

package/dist/src/components/anim/skeletonAnim/SkeletonAnimationClip.js

@@ -0,0 +1,70 @@
+import { SkeletonPose } from "./SkeletonPose";
+import { OAnimationEvent } from "../OAnimationEvent";
+export class SkeletonAnimationClip {
+    constructor(name, skeleton, numFrame, bufferData) {
+        this.name = "";
+        this.name = name;
+        this._skeleton = skeleton;
+        this._animationClipData = bufferData;
+        if (numFrame > 0 && bufferData) {
+            this._skeletonPoses = new Array(numFrame);
+            let skeletonPoseLength = 12 * skeleton.numJoint;
+            for (let nFrame = 0; nFrame < numFrame; nFrame++) {
+                let byteOffset = skeletonPoseLength * nFrame * 4;
+                const buffer = bufferData.buffer instanceof ArrayBuffer ? bufferData.buffer : new Uint8Array(bufferData.buffer).buffer;
+                let poseData = new Float32Array(buffer, byteOffset, skeletonPoseLength);
+                let skeletonPose = new SkeletonPose(skeleton);
+                skeletonPose.buildSkeletonPose(poseData);
+                this._skeletonPoses[nFrame] = skeletonPose;
+            }
+        }
+    }
+    get totalTime() {
+        return this._skeletonPoses[this._skeletonPoses.length - 1].time;
+    }
+    get frameRate() {
+        return this.totalTime / this._skeletonPoses.length;
+    }
+    get skeleton() {
+        return this._skeleton;
+    }
+    get numFrame() {
+        return this._skeletonPoses.length - 1;
+    }
+    get animationClipData() {
+        return this._animationClipData;
+    }
+    getSkeletonPose(frame) {
+        return this._skeletonPoses[frame];
+    }
+    getLerpSkeletonPose(currFrame, nextFrame, weight, dst) {
+        let skeletonPoseA = this.getSkeletonPose(currFrame);
+        let skeletonPoseB = this.getSkeletonPose(nextFrame);
+        dst.lerp(skeletonPoseA, skeletonPoseB, weight);
+        return dst;
+    }
+    createSubClip(name, startTime, endTime) {
+        var result = new SkeletonAnimationClip(name, this._skeleton, 0, null);
+        const startFrame = Math.max(Math.floor(startTime / this.frameRate), 0);
+        const endFrame = Math.min(Math.floor(endTime / this.frameRate), this._skeletonPoses.length - 1);
+        result._skeletonPoses = this._skeletonPoses.slice(startFrame, endFrame);
+        const skeletonPoseByteLength = 12 * this._skeleton.numJoint * 4;
+        const buffer = this._animationClipData.buffer instanceof ArrayBuffer ? this._animationClipData.buffer : new Uint8Array(this._animationClipData.buffer).buffer;
+        this._animationClipData = new Float32Array(buffer, startFrame * skeletonPoseByteLength, (endFrame - startFrame) * skeletonPoseByteLength);
+        return result;
+    }
+    addEvent(eventName, triggerTime) {
+        if (!this._events) {
+            this._events = new Array();
+        }
+        this._events.push(new OAnimationEvent(eventName, triggerTime));
+    }
+    removeEvent(eventName) {
+        if (this._events) {
+            this._events = this._events.filter((items) => items.type != eventName);
+        }
+    }
+    getEvents() {
+        return this._events;
+    }
+}

package/dist/src/components/anim/skeletonAnim/SkeletonAnimationClipState.d.ts

@@ -0,0 +1,21 @@
+import { SkeletonAnimationClip } from "./SkeletonAnimationClip";
+import { SkeletonPose } from "./SkeletonPose";
+export declare class SkeletonAnimationClipState {
+    loop: boolean;
+    speed: number;
+    t: number;
+    time: number;
+    weight: number;
+    currFrame: number;
+    lastFrame: number;
+    nextFrame: number;
+    clip: SkeletonAnimationClip;
+    animation: any;
+    protected _isEnd: boolean;
+    protected _currSkeletonPose: SkeletonPose;
+    constructor(clip: SkeletonAnimationClip);
+    reset(): void;
+    get name(): string;
+    get currSkeletonPose(): SkeletonPose;
+    update(delta: number): void;
+}

package/dist/src/components/anim/skeletonAnim/SkeletonAnimationClipState.js

@@ -0,0 +1,80 @@
+import { SkeletonPose } from "./SkeletonPose";
+export class SkeletonAnimationClipState {
+    constructor(clip) {
+        this.loop = true;
+        this.speed = 1.0;
+        this.t = 0.0;
+        this.time = 0.0;
+        this.weight = 0;
+        this.currFrame = 0;
+        this.lastFrame = -1;
+        this.nextFrame = 0;
+        this._isEnd = false;
+        this.clip = clip;
+        this._currSkeletonPose = new SkeletonPose(this.clip.skeleton);
+    }
+    reset() {
+        this.time = 0;
+        this.weight = 0;
+        this._isEnd = false;
+    }
+    get name() {
+        return this.clip.name;
+    }
+    get currSkeletonPose() {
+        return this._currSkeletonPose;
+    }
+    update(delta) {
+        this.time = (this.time + delta * this.speed) % this.clip.totalTime;
+        let frameTime = this.time / this.clip.frameRate;
+        this.currFrame = Math.trunc(frameTime);
+        this.t = frameTime - this.currFrame;
+        if (this.currFrame < 0) {
+            this.currFrame = this.clip.numFrame + this.currFrame;
+        }
+        if (this.time >= 0) {
+            this.nextFrame = (this.currFrame + 1) % this.clip.numFrame;
+        }
+        else {
+            this.nextFrame = this.currFrame - 1;
+            if (this.nextFrame < 0) {
+                this.nextFrame = this.clip.numFrame + this.nextFrame;
+            }
+            this.t = 1 - this.t;
+        }
+        if (this._isEnd) {
+            this.currFrame = this.nextFrame =
+                this.speed < 0 ? 0 : this.clip.numFrame - 1;
+        }
+        else if (this.currFrame != this.lastFrame) {
+            let endFrame = this.speed < 0 ? 0 : this.clip.numFrame;
+            if (this.currFrame == endFrame) {
+                if (this.loop) {
+                    this.currFrame = 0;
+                    this.nextFrame = 1;
+                    this.time = this.t = 0;
+                }
+                else {
+                    this.currFrame = this.nextFrame =
+                        this.speed < 0 ? 0 : this.clip.numFrame - 1;
+                    this._isEnd = true;
+                }
+            }
+            var events = this.clip.getEvents();
+            if (events) {
+                for (let event of events) {
+                    var triggerFrame = Math.floor(event.time / this.clip.frameRate);
+                    triggerFrame = Math.min(triggerFrame, this.clip.numFrame);
+                    triggerFrame = Math.max(triggerFrame, 0);
+                    if (triggerFrame == this.currFrame) {
+                        event.skeletonAnimation = this.animation;
+                        this.animation.eventDispatcher.dispatchEvent(event);
+                        break;
+                    }
+                }
+            }
+            this.lastFrame = this.currFrame;
+        }
+        this.clip.getLerpSkeletonPose(this.currFrame, this.nextFrame, this.t, this._currSkeletonPose);
+    }
+}

package/dist/src/components/anim/skeletonAnim/SkeletonAnimationCompute.d.ts

@@ -0,0 +1,6 @@
+export declare class SkeletonAnimationCompute {
+    private _computePipeline;
+    private _computeBindGroup;
+    constructor(computeShader: string, entries: GPUBindGroupEntry[]);
+    compute(command: GPUCommandEncoder, workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): this;
+}

package/dist/src/components/anim/skeletonAnim/SkeletonAnimationCompute.js

@@ -0,0 +1,27 @@
+import { webGPUContext } from "../../../gfx/graphics/webGpu/Context3D";
+export class SkeletonAnimationCompute {
+    constructor(computeShader, entries) {
+        let device = webGPUContext.device;
+        this._computePipeline = device.createComputePipeline({
+            layout: `auto`,
+            compute: {
+                module: device.createShaderModule({
+                    code: computeShader,
+                }),
+                entryPoint: "CsMain",
+            },
+        });
+        this._computeBindGroup = device.createBindGroup({
+            layout: this._computePipeline.getBindGroupLayout(0),
+            entries: entries,
+        });
+    }
+    compute(command, workgroupCountX, workgroupCountY, workgroupCountZ) {
+        let computePass = command.beginComputePass();
+        computePass.setPipeline(this._computePipeline);
+        computePass.setBindGroup(0, this._computeBindGroup);
+        computePass.dispatchWorkgroups(workgroupCountX, workgroupCountY, workgroupCountZ);
+        computePass.end();
+        return this;
+    }
+}

package/dist/src/components/anim/skeletonAnim/SkeletonPose.d.ts

@@ -0,0 +1,16 @@
+import { JointPose } from "./JointPose";
+import { Skeleton } from "./Skeleton";
+export declare class SkeletonPose {
+    time: number;
+    protected _skeleton: Skeleton;
+    protected _jointsPose: Array<JointPose>;
+    protected mJointMatrixIndexTable: Array<number>;
+    constructor(skeleton: Skeleton, useGlobalMatrix?: boolean);
+    buildSkeletonPose(poseData: Float32Array): void;
+    get numJoint(): number;
+    get joints(): Array<JointPose>;
+    get jointMatrixIndexTable(): Array<number>;
+    lerp(a: SkeletonPose, b: SkeletonPose, weight: number): void;
+    copyFrom(other: SkeletonPose): void;
+    reset(): void;
+}