@rings-webgpu/core 1.0.2 → 1.0.3

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

@@ -1,54 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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);
-    }
-}