@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/components/anim/curveAnim/PropertyAnimClip.js

@@ -0,0 +1,54 @@
+import { AttributeAnimCurve } from "./AttributeAnimCurve";
+export class ObjectAnimClip {
+    constructor() {
+        this.curve = {};
+    }
+}
+export var WrapMode;
+(function (WrapMode) {
+    WrapMode[WrapMode["Default"] = 0] = "Default";
+    WrapMode[WrapMode["Clamp"] = 1] = "Clamp";
+    WrapMode[WrapMode["Once"] = 1] = "Once";
+    WrapMode[WrapMode["Loop"] = 2] = "Loop";
+    WrapMode[WrapMode["PingPong"] = 4] = "PingPong";
+    WrapMode[WrapMode["ClampForever"] = 8] = "ClampForever";
+})(WrapMode || (WrapMode = {}));
+export class PropertyAnimClip {
+    constructor() {
+        this.totalTime = 0;
+        this.time = 0;
+        this._stopTime = 0;
+    }
+    get wrapMode() {
+        if (!this._wrapMode)
+            this._wrapMode = WrapMode.Default;
+        return this._wrapMode;
+    }
+    set wrapMode(value) {
+        this._wrapMode = value;
+    }
+    parse(jsonData) {
+        this.objAnimClip = {};
+        let clip = jsonData["AnimationClip"];
+        let { m_Name, m_AnimationClipSettings, m_WrapMode, m_SampleRate } = clip;
+        this.name = m_Name;
+        this._wrapMode = m_WrapMode;
+        this._sampleRate = m_SampleRate;
+        this._loopTime = m_AnimationClipSettings.m_LoopTime;
+        for (const key in clip.m_EditorCurves) {
+            if (Object.prototype.hasOwnProperty.call(clip.m_EditorCurves, key)) {
+                const curve = clip.m_EditorCurves[key];
+                let attribute = curve.attribute;
+                let attributeAnimCurve = new AttributeAnimCurve();
+                attributeAnimCurve.unSerialized(curve);
+                this.totalTime = Math.max(this.totalTime, attributeAnimCurve.totalTime);
+                let objClip = this.objAnimClip[curve.path];
+                if (!objClip) {
+                    objClip = new ObjectAnimClip();
+                    this.objAnimClip[curve.path] = objClip;
+                }
+                objClip.curve[attribute] = attributeAnimCurve;
+            }
+        }
+    }
+}

package/dist/src/components/anim/curveAnim/PropertyAnimation.d.ts

@@ -0,0 +1,31 @@
+import { Object3D } from "../../../core/entities/Object3D";
+import { ComponentBase } from "../../ComponentBase";
+import { AnimatorEventKeyframe } from "./PropertyAnimationEvent";
+import { PropertyAnimClip } from "./PropertyAnimClip";
+export declare class PropertyAnimation extends ComponentBase {
+    private _animator;
+    private _clips;
+    defaultClip: string;
+    autoPlay: boolean;
+    private _seekEvent;
+    private _completeEvent;
+    private _keyFrameList;
+    constructor();
+    registerEventKeyFrame(frame: AnimatorEventKeyframe): void;
+    init(): void;
+    onUpdate(): void;
+    appendClip(clip: PropertyAnimClip): void;
+    private statusCall;
+    set speed(value: number);
+    get speed(): number;
+    stop(): void;
+    toggle(): void;
+    getClip(name: string): PropertyAnimClip;
+    get currentClip(): PropertyAnimClip;
+    get time(): number;
+    seek(time: number): void;
+    play(name: string, reset?: boolean): PropertyAnimClip;
+    start(): void;
+    copyComponent(from: this): this;
+    cloneTo(obj: Object3D): void;
+}

package/dist/src/components/anim/curveAnim/PropertyAnimation.js

@@ -0,0 +1,107 @@
+import { Time } from "../../../util/Time";
+import { ComponentBase } from "../../ComponentBase";
+import { AnimationMonitor } from "./AnimationMonitor";
+import { PropertyAnimationEvent, } from "./PropertyAnimationEvent";
+export class PropertyAnimation extends ComponentBase {
+    constructor() {
+        super();
+        this._clips = [];
+        this._seekEvent = new PropertyAnimationEvent(this, PropertyAnimationEvent.SEEK);
+        this._completeEvent = new PropertyAnimationEvent(this, PropertyAnimationEvent.COMPLETE);
+        this._keyFrameList = {};
+    }
+    registerEventKeyFrame(frame) {
+        let list = this._keyFrameList[frame.clipName];
+        if (list == null) {
+            this._keyFrameList[frame.clipName] = list = [];
+        }
+        list.push(frame);
+    }
+    init() {
+        this._animator = new AnimationMonitor(this);
+    }
+    onUpdate() {
+        if (this.enable) {
+            this._animator.update(Time.time, Time.delta);
+        }
+    }
+    appendClip(clip) {
+        this._clips.push(clip);
+        this.play(clip.name);
+    }
+    statusCall(tag, last, now) {
+        if (tag == AnimationMonitor.Complete) {
+            this.eventDispatcher.dispatchEvent(this._completeEvent);
+        }
+        else if (tag == AnimationMonitor.Seek) {
+            if (last != now) {
+                let frames = this._keyFrameList[this.currentClip.name];
+                if (frames) {
+                    for (let frame of frames) {
+                        if (frame.time > last && frame.time <= now) {
+                            this._seekEvent.data = this._seekEvent.frame = frame;
+                            this.eventDispatcher.dispatchEvent(this._seekEvent);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    set speed(value) {
+        this._animator.speed = value;
+    }
+    get speed() {
+        return this._animator.speed;
+    }
+    stop() {
+        this._animator.stop();
+    }
+    toggle() {
+        this._animator.toggle();
+    }
+    getClip(name) {
+        let clip;
+        for (let item of this._clips) {
+            if (item.name == name) {
+                clip = item;
+                break;
+            }
+        }
+        return clip;
+    }
+    get currentClip() {
+        return this._animator.currentClip;
+    }
+    get time() {
+        return this._animator.time;
+    }
+    seek(time) {
+        this._animator.seek(time);
+    }
+    play(name, reset = true) {
+        let clip = this.getClip(name);
+        if (clip) {
+            this._animator.play(clip, reset);
+            return clip;
+        }
+        return null;
+    }
+    start() {
+        if (this.autoPlay) {
+            this.play(this.defaultClip);
+        }
+    }
+    copyComponent(from) {
+        this.autoPlay = from.autoPlay;
+        this.defaultClip = from.defaultClip;
+        let clips = from._clips;
+        for (let i = 0, count = clips.length; i < count; i++) {
+            this.appendClip(clips[i]);
+        }
+        return this;
+    }
+    cloneTo(obj) {
+        let animator = obj.addComponent(PropertyAnimation);
+        animator.copyComponent(this);
+    }
+}

package/dist/src/components/anim/curveAnim/PropertyAnimationEvent.d.ts

@@ -0,0 +1,14 @@
+import { CEvent } from "../../../event/CEvent";
+import { PropertyAnimation } from "./PropertyAnimation";
+export declare class AnimatorEventKeyframe {
+    clipName: string;
+    data: any;
+    time: number;
+}
+export declare class PropertyAnimationEvent extends CEvent {
+    static SEEK: string;
+    static COMPLETE: string;
+    animation: PropertyAnimation;
+    frame: AnimatorEventKeyframe;
+    constructor(animation: PropertyAnimation, name: string);
+}

package/dist/src/components/anim/curveAnim/PropertyAnimationEvent.js

@@ -0,0 +1,11 @@
+import { CEvent } from "../../../event/CEvent";
+export class AnimatorEventKeyframe {
+}
+export class PropertyAnimationEvent extends CEvent {
+    static { this.SEEK = "SEEK"; }
+    static { this.COMPLETE = "COMPLETE"; }
+    constructor(animation, name) {
+        super(name);
+        this.animation = animation;
+    }
+}

package/dist/src/components/anim/curveAnim/PropertyHelp.d.ts

@@ -0,0 +1,13 @@
+export declare class PropertyAnimTag {
+    transform?: boolean;
+    quaternion?: boolean;
+    materialColor?: boolean;
+}
+export declare class PropertyHelp {
+    static Property: any;
+    static Scale: any;
+    static updatePropertyTag(tag: PropertyAnimTag, attribute: string): void;
+    private static tag_quaternion;
+    private static tag_materialColor;
+    private static tag_transform;
+}

package/dist/src/components/anim/curveAnim/PropertyHelp.js

@@ -0,0 +1,96 @@
+export class PropertyAnimTag {
+}
+export class PropertyHelp {
+    static { this.Property = {
+        "m_LocalPosition.x": "localPosition.x",
+        "m_LocalPosition.y": "localPosition.y",
+        "m_LocalPosition.z": "localPosition.z",
+        "m_LocalRotation.x": "localQuaternion.x",
+        "m_LocalRotation.y": "localQuaternion.y",
+        "m_LocalRotation.z": "localQuaternion.z",
+        "m_LocalRotation.w": "localQuaternion.w",
+        "localEulerAnglesRaw.x": "localRotation.x",
+        "localEulerAnglesRaw.y": "localRotation.y",
+        "localEulerAnglesRaw.z": "localRotation.z",
+        "m_LocalEulerAngles.x": "localRotation.x",
+        "m_LocalEulerAngles.y": "localRotation.y",
+        "m_LocalEulerAngles.z": "localRotation.z",
+        "m_LocalScale.x": "localScale.x",
+        "m_LocalScale.y": "localScale.y",
+        "m_LocalScale.z": "localScale.z",
+        "m_Color.r": "materialColor.r",
+        "m_Color.g": "materialColor.g",
+        "m_Color.b": "materialColor.b",
+        "m_Color.a": "materialColor.a",
+        "material._Color.r": "materialColor.r",
+        "material._Color.g": "materialColor.g",
+        "material._Color.b": "materialColor.b",
+        "material._Color.a": "materialColor.a",
+        "material._UnlitColor.r": "materialColor.r",
+        "material._UnlitColor.g": "materialColor.g",
+        "material._UnlitColor.b": "materialColor.b",
+        "material._UnlitColor.a": "materialColor.a",
+        "field of view": "camera3D.fov",
+        m_IsActive: "active",
+        m_Sprite: "sprite",
+        m_FlipX: "flipX",
+        m_FlipY: "flipY",
+    }; }
+    static { this.Scale = {
+        "m_LocalPosition.x": 1,
+        "m_LocalPosition.y": 1,
+        "m_LocalPosition.z": -1,
+        "localEulerAnglesRaw.x": -1, //Deg2Rad(1),
+        "localEulerAnglesRaw.y": 1, //Deg2Rad(1),
+        "localEulerAnglesRaw.z": 1, //Deg2Rad(1),
+        "m_LocalEulerAngles.x": -1, //Deg2Rad(1),
+        "m_LocalEulerAngles.y": 1, //Deg2Rad(1),
+        "m_LocalEulerAngles.z": 1, //Deg2Rad(1),
+        "m_LocalRotation.x": 1, //Rad2Deg(1),
+        "m_LocalRotation.y": 1, //Rad2Deg(1),
+        "m_LocalRotation.z": -1, //Rad2Deg(1),
+        "m_LocalRotation.w": -1, //Rad2Deg(1),
+        "field of view": 1,
+        m_IsActive: 1,
+        m_Sprite: 1,
+    }; }
+    static updatePropertyTag(tag, attribute) {
+        tag.quaternion ||= this.tag_quaternion[attribute];
+        tag.transform ||= this.tag_transform[attribute];
+        tag.materialColor ||= this.tag_materialColor[attribute];
+    }
+    static { this.tag_quaternion = {
+        "m_LocalRotation.x": true,
+        "m_LocalRotation.y": true,
+        "m_LocalRotation.z": true,
+        "m_LocalRotation.w": true,
+    }; }
+    static { this.tag_materialColor = {
+        "material._Color.r": true,
+        "material._Color.g": true,
+        "material._Color.b": true,
+        "material._Color.a": true,
+        "material._UnlitColor.r": true,
+        "material._UnlitColor.g": true,
+        "material._UnlitColor.b": true,
+        "material._UnlitColor.a": true,
+    }; }
+    static { this.tag_transform = {
+        "m_LocalPosition.x": true,
+        "m_LocalPosition.y": true,
+        "m_LocalPosition.z": true,
+        "m_LocalRotation.x": true,
+        "m_LocalRotation.y": true,
+        "m_LocalRotation.z": true,
+        "m_LocalRotation.w": true,
+        "localEulerAnglesRaw.x": true,
+        "localEulerAnglesRaw.y": true,
+        "localEulerAnglesRaw.z": true,
+        "m_LocalEulerAngles.x": true,
+        "m_LocalEulerAngles.y": true,
+        "m_LocalEulerAngles.z": true,
+        "m_LocalScale.x": true,
+        "m_LocalScale.y": true,
+        "m_LocalScale.z": true,
+    }; }
+}

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

@@ -0,0 +1,18 @@
+import { MorphTargetMapper } from "./MorphTargetKey";
+import { ComponentBase } from "../../ComponentBase";
+import { MorphTargetFrame } from "./MorphTargetFrame";
+import { SkinnedMeshRenderer2 } from "../../renderer/SkinnedMeshRenderer2";
+export declare class MorphTargetBlender extends ComponentBase {
+    private _targetRenderers;
+    private _vec3;
+    private _matrix4;
+    private _quaternion;
+    init(param?: any): void;
+    getMorphRenderersByKey(key: string): SkinnedMeshRenderer2[];
+    cloneMorphRenderers(): {
+        [key: string]: SkinnedMeshRenderer2[];
+    };
+    applyBlendShape(frame: MorphTargetFrame, keyMapper: MorphTargetMapper, multiplier?: number): void;
+    private applyMorphTargetInfluence;
+    private fetchMorphRenderers;
+}

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

@@ -0,0 +1,81 @@
+import { Matrix4 } from "../../../math/Matrix4";
+import { Quaternion } from "../../../math/Quaternion";
+import { Vector3 } from "../../../math/Vector3";
+import { ComponentBase } from "../../ComponentBase";
+import { SkinnedMeshRenderer2 } from "../../renderer/SkinnedMeshRenderer2";
+import { RendererMask, RendererMaskUtil, } from "../../../gfx/renderJob/passRenderer/state/RendererMask";
+import { MeshRenderer } from "../../renderer/MeshRenderer";
+export class MorphTargetBlender extends ComponentBase {
+    constructor() {
+        super(...arguments);
+        this._targetRenderers = {};
+        this._vec3 = new Vector3();
+        this._matrix4 = new Matrix4();
+        this._quaternion = new Quaternion();
+    }
+    init(param) {
+        let meshRenders = this.fetchMorphRenderers(this.object3D, SkinnedMeshRenderer2);
+        let meshRenders2 = this.fetchMorphRenderers(this.object3D, MeshRenderer);
+        meshRenders.push(...meshRenders2);
+        for (const renderer of meshRenders) {
+            let hasMorphTarget = RendererMaskUtil.hasMask(renderer.rendererMask, RendererMask.MorphTarget);
+            if (hasMorphTarget) {
+                renderer.selfCloneMaterials("MORPH_TARGET_UUID");
+            }
+            for (const key in renderer.geometry.morphTargetDictionary) {
+                let renderList = this._targetRenderers[key] || [];
+                renderList.push(renderer);
+                this._targetRenderers[key] = renderList;
+            }
+        }
+    }
+    getMorphRenderersByKey(key) {
+        return this._targetRenderers[key];
+    }
+    cloneMorphRenderers() {
+        let dst = {};
+        for (let key in this._targetRenderers) {
+            dst[key] = this._targetRenderers[key];
+        }
+        return dst;
+    }
+    applyBlendShape(frame, keyMapper, multiplier = 1) {
+        if (!frame) {
+            console.warn("blendShape is null");
+            return;
+        }
+        this._vec3.setFromArray(frame.transform.transform[3]);
+        this._vec3.multiplyScalar(multiplier);
+        this.object3D.transform.localPosition = this._vec3;
+        this._vec3.setFromArray(frame.transform.transform[2]);
+        this._matrix4.copyColFrom(2, this._vec3);
+        this._vec3.setFromArray(frame.transform.transform[1]);
+        this._matrix4.copyColFrom(1, this._vec3);
+        this._vec3.setFromArray(frame.transform.transform[0]);
+        this._matrix4.copyColFrom(0, this._vec3);
+        this._matrix4.transpose();
+        this._quaternion.fromMatrix(this._matrix4);
+        this.object3D.localQuaternion = this._quaternion;
+        for (let keyInModel in keyMapper) {
+            let renderList = this._targetRenderers[keyInModel];
+            let stdKey = keyMapper[keyInModel];
+            let influence = frame.texture[stdKey];
+            this.applyMorphTargetInfluence(keyInModel, influence, renderList);
+        }
+    }
+    applyMorphTargetInfluence(key, influence, rendererList) {
+        for (let renderer of rendererList) {
+            renderer.setMorphInfluence(key, influence);
+        }
+    }
+    fetchMorphRenderers(obj, c) {
+        let sourceRenders = obj.getComponentsInChild(c);
+        let result = [];
+        for (let renderer of sourceRenders) {
+            if (renderer.hasMask(RendererMask.MorphTarget)) {
+                result.push(renderer);
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,52 @@
+import { StorageGPUBuffer } from "../../../gfx/graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { UniformGPUBuffer } from "../../../gfx/graphics/webGpu/core/buffer/UniformGPUBuffer";
+import { ComputeShader } from "../../../gfx/graphics/webGpu/shader/ComputeShader";
+import { RenderShaderPass } from "../../../gfx/graphics/webGpu/shader/RenderShaderPass";
+import { GeometryBase } from "../../../core/geometry/GeometryBase";
+type MorphTargetCollectData = {
+    mtCount: number;
+    vCount: number;
+    mergedPos: Float32Array;
+    mergedNormal: Float32Array;
+};
+declare class MorphAttrDataGroup {
+    source: Float32Array;
+    input: StorageGPUBuffer;
+    output: StorageGPUBuffer;
+    reset(value: Float32Array): void;
+    apply(vertexCount: number): void;
+}
+export declare class MorphTargetData {
+    enable: boolean;
+    morphTargetsRelative: boolean;
+    readonly MaxMorphTargetCount: number;
+    protected _computeConfigArray: Float32Array;
+    protected _computeConfigBuffer: UniformGPUBuffer;
+    protected _morphInfluenceArray: Float32Array;
+    protected _morphInfluenceBuffer: StorageGPUBuffer;
+    protected _positionAttrDataGroup: MorphAttrDataGroup;
+    protected _normalAttrDataGroup: MorphAttrDataGroup;
+    private _isInfluenceDirty;
+    protected _morphTargetCount: number;
+    protected _totalVertexCount: number;
+    protected _computeShader: ComputeShader;
+    protected _computeShaders: ComputeShader[];
+    protected _computeWorkGroupXY: number;
+    protected _collectMorphTargetData: MorphTargetCollectData;
+    private _blendTarget;
+    constructor();
+    initMorphTarget(geometry: GeometryBase): void;
+    applyRenderShader(renderShader: RenderShaderPass): void;
+    computeMorphTarget(command: GPUCommandEncoder): void;
+    updateInfluence(index: number, value: number): void;
+    get blendShape(): {
+        [key: string]: any;
+    };
+    private collectMorphTargetList;
+    private collectAttribute;
+    private uploadConfigGBuffer;
+    private calcWorkGroup;
+    protected uploadMorphTargetBuffer(): void;
+    protected generateGPUBuffer(): void;
+}
+export {};

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

@@ -0,0 +1,183 @@
+import { StorageGPUBuffer } from "../../../gfx/graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { UniformGPUBuffer } from "../../../gfx/graphics/webGpu/core/buffer/UniformGPUBuffer";
+import { MorphTarget_shader } from "../../../components/anim/morphAnim/MorphTarget_shader";
+import { ComputeShader } from "../../../gfx/graphics/webGpu/shader/ComputeShader";
+import { GPUContext } from "../../../gfx/renderJob/GPUContext";
+class MorphAttrDataGroup {
+    reset(value) {
+        this.input && this.input.destroy();
+        this.output && this.output.destroy();
+        this.input = this.output = null;
+        this.source = value;
+    }
+    apply(vertexCount) {
+        if (this.source) {
+            if (!this.input) {
+                let usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST;
+                this.input = new StorageGPUBuffer(this.source.length, usage, this.source);
+                this.input.apply();
+            }
+            if (!this.output) {
+                let usage = GPUBufferUsage.STORAGE |
+                    GPUBufferUsage.COPY_DST |
+                    GPUBufferUsage.COPY_SRC;
+                this.output = new StorageGPUBuffer(vertexCount * 3, usage);
+                this.output.apply();
+            }
+        }
+    }
+}
+export class MorphTargetData {
+    constructor() {
+        this.MaxMorphTargetCount = 64;
+        this._computeWorkGroupXY = 1;
+        this._isInfluenceDirty = true;
+        this.generateGPUBuffer();
+        this._positionAttrDataGroup = new MorphAttrDataGroup();
+        this._normalAttrDataGroup = new MorphAttrDataGroup();
+    }
+    initMorphTarget(geometry) {
+        this._collectMorphTargetData = this.collectMorphTargetList(geometry);
+        this._computeShader && this._computeShader.destroy();
+        let code = MorphTarget_shader.CsMain;
+        this._computeShader = new ComputeShader(code);
+        if (this._collectMorphTargetData.mergedNormal) {
+            this._computeShader.setDefine("USE_MORPHNORMALS", true);
+        }
+        else {
+            this._computeShader.deleteDefine("USE_MORPHNORMALS");
+        }
+        this._computeShaders = [this._computeShader];
+        this._isInfluenceDirty = true;
+        this._morphTargetCount = this._collectMorphTargetData.mtCount;
+        this._totalVertexCount = this._collectMorphTargetData.vCount;
+        this._morphInfluenceArray.fill(0);
+        this._computeWorkGroupXY = this.calcWorkGroup(this._totalVertexCount);
+        this._positionAttrDataGroup.reset(this._collectMorphTargetData.mergedPos);
+        this._normalAttrDataGroup.reset(this._collectMorphTargetData.mergedNormal);
+    }
+    applyRenderShader(renderShader) {
+        this.uploadMorphTargetBuffer();
+        this.uploadConfigGBuffer();
+        renderShader.setUniformBuffer("morphTargetConfig", this._computeConfigBuffer);
+        renderShader.setStorageBuffer("morphTargetOpPositions", this._positionAttrDataGroup.output);
+        if (this._collectMorphTargetData.mergedNormal) {
+            renderShader.setStorageBuffer("morphTargetOpNormals", this._normalAttrDataGroup.output);
+        }
+    }
+    computeMorphTarget(command) {
+        this.uploadConfigGBuffer();
+        this.uploadMorphTargetBuffer();
+        this._computeShader.setUniformBuffer("morphTargetConfig", this._computeConfigBuffer);
+        this._computeShader.setStorageBuffer("morphTargetInfluence", this._morphInfluenceBuffer);
+        this._computeShader.setStorageBuffer("morphTargetPositions", this._positionAttrDataGroup.input);
+        this._computeShader.setStorageBuffer("morphTargetOpPositions", this._positionAttrDataGroup.output);
+        if (this._collectMorphTargetData.mergedNormal) {
+            this._computeShader.setStorageBuffer("morphTargetNormals", this._normalAttrDataGroup.input);
+            this._computeShader.setStorageBuffer("morphTargetOpNormals", this._normalAttrDataGroup.output);
+        }
+        this._computeShader.workerSizeX = this._computeWorkGroupXY;
+        this._computeShader.workerSizeY = this._computeWorkGroupXY;
+        this._computeShader.workerSizeZ = 1;
+        GPUContext.computeCommand(command, this._computeShaders);
+    }
+    updateInfluence(index, value) {
+        this._isInfluenceDirty = true;
+        this._morphInfluenceArray[index] = value;
+    }
+    get blendShape() {
+        return this._blendTarget;
+    }
+    collectMorphTargetList(geometry) {
+        let posAttrList = this.collectAttribute("a_morphPositions_", geometry);
+        let morphTargetCount = posAttrList.length;
+        let vertexCount = posAttrList[0].data.length / 3;
+        this._blendTarget = {};
+        if (geometry.blendShapeData) {
+            for (let i = 0; i < geometry.blendShapeData.shapeIndexs.length; i++) {
+                let index = geometry.blendShapeData.shapeIndexs[i];
+                let shapeNames = geometry.blendShapeData.shapeNames[i].split(".");
+                let shapeName = shapeNames[shapeNames.length - 1];
+                this._blendTarget[shapeName] = (value) => this.updateInfluence(index, value);
+            }
+        }
+        let posArray = new Float32Array(vertexCount * morphTargetCount * 3);
+        {
+            let offset = 0;
+            for (let i = 0; i < morphTargetCount; i++) {
+                let item = posAttrList[i];
+                posArray.set(item.data, offset);
+                offset += item.data.length;
+            }
+        }
+        let normalAttrList = this.collectAttribute("a_morphNormals_", geometry);
+        let normalArray;
+        if (normalAttrList && normalAttrList.length > 0) {
+            let offset = 0;
+            normalArray = new Float32Array(vertexCount * morphTargetCount * 3);
+            for (let i = 0; i < morphTargetCount; i++) {
+                let item = normalAttrList[i];
+                normalArray.set(item.data, offset);
+                offset += item.data.length;
+            }
+        }
+        return {
+            mtCount: morphTargetCount,
+            vCount: vertexCount,
+            mergedPos: posArray,
+            mergedNormal: normalArray,
+        };
+    }
+    collectAttribute(attrKey, geometry) {
+        let list = [];
+        for (let i = 0; i < this.MaxMorphTargetCount; i++) {
+            let morphKey = attrKey + i;
+            let item = geometry.getAttribute(morphKey);
+            if (!item)
+                break;
+            else
+                list[i] = item;
+        }
+        return list;
+    }
+    uploadConfigGBuffer() {
+        if (this._isInfluenceDirty) {
+            let sumInfluence = 0;
+            for (let i = 0; i < this._morphTargetCount; i++) {
+                sumInfluence += this._morphInfluenceArray[i];
+            }
+            this._morphInfluenceBuffer.setFloat32Array("data", this._morphInfluenceArray);
+            this._morphInfluenceBuffer.apply();
+            this._computeConfigArray[0] = this.morphTargetsRelative
+                ? 1
+                : 1 - sumInfluence;
+            this._computeConfigArray[1] = this._morphTargetCount;
+            this._computeConfigArray[2] = this._totalVertexCount;
+            this._computeConfigArray[3] = this._computeWorkGroupXY;
+            this._computeConfigBuffer.setFloat32Array("data", this._computeConfigArray);
+            this._computeConfigBuffer.apply();
+            this._isInfluenceDirty = false;
+        }
+    }
+    calcWorkGroup(count) {
+        let groupXY = Math.ceil(Math.sqrt(count));
+        let log2 = Math.ceil(Math.log2(groupXY));
+        groupXY = Math.pow(2, log2);
+        return groupXY;
+    }
+    uploadMorphTargetBuffer() {
+        if (!this._positionAttrDataGroup.output) {
+            this._positionAttrDataGroup.apply(this._totalVertexCount);
+        }
+        if (!this._normalAttrDataGroup.output) {
+            this._normalAttrDataGroup.apply(this._totalVertexCount);
+        }
+    }
+    generateGPUBuffer() {
+        this._computeConfigArray = new Float32Array(4);
+        this._computeConfigBuffer = new UniformGPUBuffer(4);
+        this._morphInfluenceArray = new Float32Array(this.MaxMorphTargetCount);
+        let usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST;
+        this._morphInfluenceBuffer = new StorageGPUBuffer(this.MaxMorphTargetCount, usage);
+    }
+}