@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/assets/shader/post/FXAAShader.d.ts

@@ -0,0 +1 @@
+export declare let FXAAShader: string;

package/dist/types/assets/shader/post/GlobalFog_shader.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare let GlobalFog_shader: string;

package/dist/types/assets/shader/quad/Quad_shader.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @internal
+ */
+export declare let FullQuad_vert_wgsl: string;
+/**
+ * @internal
+ */
+export declare let Quad_vert_wgsl: string;
+/**
+ * @internal
+ */
+export declare let Quad_frag_wgsl: string;
+/**
+ * @internal
+ */
+export declare let Quad_depth2d_frag_wgsl: string;
+/**
+ * @internal
+ */
+export declare let Quad_depthCube_frag_wgsl: string;
+/**
+ * @internal
+ */
+export declare let Quad_depth2dArray_frag_wgsl: string;

package/dist/types/assets/shader/sky/AtmosphericScatteringSky_shader.d.ts

@@ -0,0 +1,3 @@
+export declare class AtmosphericScatteringSky_shader {
+    static cs: string;
+}

package/dist/types/assets/shader/sky/CubeSky_Shader.d.ts

@@ -0,0 +1,4 @@
+export declare class CubeSky_Shader {
+    static sky_vs_frag_wgsl: string;
+    static sky_fs_frag_wgsl: string;
+}

package/dist/types/assets/shader/utils/BitUtil.d.ts

@@ -0,0 +1 @@
+export declare let BitUtil: string;

package/dist/types/assets/shader/utils/ColorUtil.d.ts

@@ -0,0 +1 @@
+export declare let ColorUtil: string;

package/dist/types/assets/shader/utils/GenerayRandomDir.d.ts

@@ -0,0 +1 @@
+export declare let GenerayRandomDir: string;

package/dist/types/components/AtmosphericComponent.d.ts

@@ -0,0 +1,28 @@
+import { Transform } from "./Transform";
+import { SkyRenderer } from "./renderer/SkyRenderer";
+export declare class AtmosphericComponent extends SkyRenderer {
+    private _atmosphericScatteringSky;
+    private _onChange;
+    private _relatedTransform;
+    private _historyData;
+    get sunX(): number;
+    set sunX(value: number);
+    get sunY(): number;
+    set sunY(value: number);
+    get eyePos(): number;
+    set eyePos(value: number);
+    get sunRadius(): number;
+    set sunRadius(value: number);
+    get sunRadiance(): number;
+    set sunRadiance(value: number);
+    get sunBrightness(): number;
+    set sunBrightness(value: number);
+    get displaySun(): boolean;
+    set displaySun(value: boolean);
+    init(): void;
+    start(view?: any): void;
+    get relativeTransform(): Transform;
+    set relativeTransform(value: Transform);
+    onUpdate(view?: any): void;
+    destroy(force?: boolean): void;
+}

package/dist/types/components/BillboardComponent.d.ts

@@ -0,0 +1,13 @@
+import { Camera3D } from "../core/Camera3D";
+import { Object3D } from "../core/entities/Object3D";
+import { ComponentBase } from "./ComponentBase";
+import { BillboardType } from "./gui/GUIConfig";
+export declare class BillboardComponent extends ComponentBase {
+    type: BillboardType;
+    camera: Camera3D;
+    private _cameraPosition;
+    constructor();
+    onUpdate(): void;
+    private updateBillboardMatrix;
+    cloneTo(obj: Object3D): void;
+}

package/dist/types/components/ColliderComponent.d.ts

@@ -0,0 +1,15 @@
+import { View3D } from "..";
+import { Ray } from "../math/Ray";
+import { ComponentBase } from "./ComponentBase";
+import { ColliderShape, HitInfo } from "./shape/ColliderShape";
+export declare class ColliderComponent extends ComponentBase {
+    private _shape;
+    constructor();
+    start(): void;
+    onEnable(view?: View3D): void;
+    onDisable(view?: View3D): void;
+    get shape(): ColliderShape;
+    set shape(value: ColliderShape);
+    rayPick(ray: Ray): HitInfo;
+    beforeDestroy(force?: boolean): void;
+}

package/dist/types/components/ComponentBase.d.ts

@@ -0,0 +1,43 @@
+import { View3D } from "../core/View3D";
+import { Object3D } from "../core/entities/Object3D";
+import { CEventDispatcher } from "../event/CEventDispatcher";
+import { IComponent } from "./IComponent";
+import { Transform } from "./Transform";
+export declare class ComponentBase implements IComponent {
+    object3D: Object3D;
+    protected _eventDispatcher: CEventDispatcher;
+    get eventDispatcher(): CEventDispatcher;
+    set eventDispatcher(value: CEventDispatcher);
+    protected _enable: boolean;
+    private __isStart;
+    isDestroyed: boolean;
+    get isStart(): boolean;
+    get transform(): Transform;
+    set enable(value: boolean);
+    get enable(): boolean;
+    private __init;
+    private __start;
+    private __stop;
+    init(param?: any): void;
+    start(): void;
+    stop(): void;
+    onEnable?(view?: View3D): any;
+    onDisable?(view?: View3D): any;
+    onUpdate?(view?: View3D): any;
+    onLateUpdate?(view?: View3D): any;
+    onBeforeUpdate?(view?: View3D): any;
+    onCompute?(view?: View3D, command?: GPUCommandEncoder): any;
+    onGraphic?(view?: View3D): any;
+    onParentChange?(lastParent?: Object3D, currentParent?: Object3D): any;
+    onAddChild?(child: Object3D): any;
+    onRemoveChild?(child: Object3D): any;
+    cloneTo(obj: Object3D): void;
+    copyComponent(from: this): this;
+    private _onUpdate;
+    private _onLateUpdate;
+    private _onBeforeUpdate;
+    private _onCompute;
+    private _onGraphic;
+    beforeDestroy(force?: boolean): void;
+    destroy(force?: boolean): void;
+}

package/dist/types/components/IComponent.d.ts

@@ -0,0 +1,27 @@
+import { View3D } from "../core/View3D";
+import { Object3D } from "../core/entities/Object3D";
+import { CEventDispatcher } from "../event/CEventDispatcher";
+import { Transform } from "./Transform";
+export interface IComponent {
+    object3D: Object3D;
+    eventDispatcher: CEventDispatcher;
+    transform: Transform;
+    enable: boolean;
+    isDestroyed?: boolean;
+    init(param?: any): any;
+    start(): any;
+    stop(): any;
+    onEnable?(view?: View3D): any;
+    onDisable?(view?: View3D): any;
+    onUpdate?(view?: View3D): any;
+    onLateUpdate?(view?: View3D): any;
+    onBeforeUpdate?(view?: View3D): any;
+    onCompute?(view?: View3D, command?: GPUCommandEncoder): any;
+    onGraphic?(view?: View3D): any;
+    cloneTo(obj: Object3D): any;
+    destroy(force?: boolean): any;
+    beforeDestroy(force?: boolean): any;
+    onParentChange?(lastParent?: Object3D, currentParent?: Object3D): any;
+    onAddChild?(child: Object3D): any;
+    onRemoveChild?(child: Object3D): any;
+}

package/dist/types/components/SkeletonAnimationComponent.d.ts

@@ -0,0 +1,52 @@
+import { Object3D } from "../core/entities/Object3D";
+import { StorageGPUBuffer } from "../gfx/graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { ComponentBase } from "./ComponentBase";
+import { Skeleton } from "./anim/skeletonAnim/Skeleton";
+import { SkeletonAnimationClip } from "./anim/skeletonAnim/SkeletonAnimationClip";
+import { SkeletonAnimationClipState } from "./anim/skeletonAnim/SkeletonAnimationClipState";
+import { SkeletonPose } from "./anim/skeletonAnim/SkeletonPose";
+export declare class SkeletonAnimationComponent extends ComponentBase {
+    isPlaying: boolean;
+    timeScale: number;
+    protected _skeleton: Skeleton;
+    protected _clips: SkeletonAnimationClip[];
+    protected _clipStates: Map<string, SkeletonAnimationClipState>;
+    protected _mixSkeletonPose: SkeletonPose;
+    protected _mixTempSkeletonPose: SkeletonPose;
+    protected _currentClipState: SkeletonAnimationClipState;
+    protected _bindList: Array<any>;
+    protected _jointMatrixIndexTableBuffer: StorageGPUBuffer;
+    protected _crossFadeState: SkeletonAnimationCrossFadeState;
+    constructor();
+    start(): void;
+    set skeleton(value: Skeleton);
+    get skeleton(): Skeleton;
+    get finalSkeletonPose(): SkeletonPose;
+    get jointMatrixIndexTableBuffer(): StorageGPUBuffer;
+    getJointIndexTable(skinJointsName: Array<string>): Array<number>;
+    addAnimationClip(clip: SkeletonAnimationClip): void;
+    getAnimationClip(name: string): SkeletonAnimationClip;
+    getAnimationClips(): SkeletonAnimationClip[];
+    getAnimationClipState(name: string): SkeletonAnimationClipState;
+    getAnimationClipStates(): Map<string, SkeletonAnimationClipState>;
+    pause(): void;
+    resume(): void;
+    play(animName: string, speed?: number, reset?: boolean): boolean;
+    crossFade(animName: string, crossTime: number): void;
+    setAnimIsLoop(animName: string, isLoop: boolean): void;
+    addJointBind(jointName: string, obj: Object3D): void;
+    removeJointBind(obj: Object3D): void;
+    onUpdate(): void;
+    cloneTo(obj: Object3D): void;
+    protected setCurrentClipState(clipState: SkeletonAnimationClipState): void;
+}
+declare class SkeletonAnimationCrossFadeState {
+    inClip: SkeletonAnimationClipState;
+    outClip: SkeletonAnimationClipState;
+    currentTime: number;
+    crossFadeTime: number;
+    constructor(inClip: SkeletonAnimationClipState, outClip: SkeletonAnimationClipState, time: number);
+    reset(inClip: SkeletonAnimationClipState, outClip: SkeletonAnimationClipState, time: number): void;
+    update(delta: number): void;
+}
+export {};

package/dist/types/components/Transform.d.ts

@@ -0,0 +1,119 @@
+import { Scene3D } from "../core/Scene3D";
+import { View3D } from "../core/View3D";
+import { Object3D } from "../core/entities/Object3D";
+import { CEvent } from "../event/CEvent";
+import { Matrix4 } from "../math/Matrix4";
+import { Quaternion } from "../math/Quaternion";
+import { Vector3 } from "../math/Vector3";
+import { ComponentBase } from "./ComponentBase";
+export declare class Transform extends ComponentBase {
+    static LIMIT: number;
+    static COMPONENT_NAME: string;
+    static COMPONENT_TYPE: string;
+    static POSITION_ONCHANGE: string;
+    static ROTATION_ONCHANGE: string;
+    static SCALE_ONCHANGE: string;
+    static PARENT_ONCHANGE: string;
+    static CHILDREN_ONCHANGE: string;
+    static ADD_ONCHANGE: string;
+    static LOCAL_ONCHANGE: string;
+    eventPositionChange: CEvent;
+    eventRotationChange: CEvent;
+    eventScaleChange: CEvent;
+    eventLocalChange: CEvent;
+    onPositionChange: Function;
+    onRotationChange: Function;
+    onScaleChange: Function;
+    private _scene3d;
+    private _parent;
+    private _localPos;
+    _localRot: Vector3;
+    private _localRotQuat;
+    private _localScale;
+    private _localDetailPos;
+    private _localDetailRot;
+    private _localDetailScale;
+    index: number;
+    index2: number;
+    private _forward;
+    private _back;
+    private _right;
+    private _left;
+    private _up;
+    private _down;
+    readonly _worldMatrix: Matrix4;
+    private _targetPos;
+    static: boolean;
+    depthOrder: number;
+    get localChange(): boolean;
+    set localChange(value: boolean);
+    get targetPos(): Vector3;
+    set targetPos(value: Vector3);
+    get parent(): Transform;
+    set parent(value: Transform);
+    set enable(value: boolean);
+    get enable(): boolean;
+    get scene3D(): Scene3D;
+    set scene3D(value: Scene3D);
+    get view3D(): View3D;
+    constructor();
+    awake(): void;
+    start(): void;
+    stop(): void;
+    notifyLocalChange(): void;
+    get up(): Vector3;
+    set up(value: Vector3);
+    get down(): Vector3;
+    set down(value: Vector3);
+    get forward(): Vector3;
+    set forward(value: Vector3);
+    get back(): Vector3;
+    set back(value: Vector3);
+    get left(): Vector3;
+    set left(value: Vector3);
+    get right(): Vector3;
+    set right(value: Vector3);
+    get localRotQuat(): Quaternion;
+    set localRotQuat(value: Quaternion);
+    notifyChange(): void;
+    get worldMatrix(): Matrix4;
+    updateWorldMatrix(force?: boolean): void;
+    updateChildTransform(): void;
+    lookTarget(target: Vector3, up?: Vector3): void;
+    lookAt(pos: Vector3, target: Vector3, up?: Vector3): void;
+    decomposeFromMatrix(matrix: Matrix4, orientationStyle?: string): this;
+    cloneTo(obj: Object3D): void;
+    set x(value: number);
+    get x(): number;
+    set y(value: number);
+    get y(): number;
+    set z(value: number);
+    get z(): number;
+    set scaleX(value: number);
+    get scaleX(): number;
+    set scaleY(value: number);
+    get scaleY(): number;
+    set scaleZ(value: number);
+    get scaleZ(): number;
+    set rotationX(value: number);
+    get rotationX(): number;
+    set rotationY(value: number);
+    get rotationY(): number;
+    set rotationZ(value: number);
+    get rotationZ(): number;
+    get worldPosition(): Vector3;
+    set localPosition(v: Vector3);
+    get localPosition(): Vector3;
+    set localRotation(v: Vector3);
+    get localRotation(): Vector3;
+    set localScale(v: Vector3);
+    get localScale(): Vector3;
+    get localDetailScale(): Vector3;
+    set localDetailScale(value: Vector3);
+    get localDetailRot(): Vector3;
+    set localDetailRot(value: Vector3);
+    get localDetailPos(): Vector3;
+    set localDetailPos(value: Vector3);
+    beforeDestroy(force?: boolean): void;
+    destroy(): void;
+}

package/dist/types/components/anim/AnimatorComponent.d.ts

@@ -0,0 +1,67 @@
+import { FloatArray } from "@rings/wasm-matrix/WasmMatrix";
+import { Object3D, PrefabAvatarData, RenderNode, SkinnedMeshRenderer2, StorageGPUBuffer, View3D } from "../..";
+import { PropertyAnimationClip } from "../../math/AnimationCurveClip";
+import { ComponentBase } from "../ComponentBase";
+export declare class AnimatorComponent extends ComponentBase {
+    timeScale: number;
+    jointMatrixIndexTableBuffer: StorageGPUBuffer;
+    playBlendShapeLoop: boolean;
+    protected inverseBindMatrices: FloatArray[];
+    protected _avatar: PrefabAvatarData;
+    protected _rendererList: SkinnedMeshRenderer2[];
+    protected propertyCache: Map<RenderNode, {
+        [name: string]: any;
+    }>;
+    protected _clips: PropertyAnimationClip[];
+    protected _clipsState: PropertyAnimationClipState[];
+    protected _clipsMap: Map<string, PropertyAnimationClip>;
+    protected _currentSkeletonClip: PropertyAnimationClipState;
+    protected _currentBlendAnimClip: PropertyAnimationClip;
+    private _skeletonTime;
+    private _blendShapeTime;
+    private _skeletonSpeed;
+    private _blendShapeSpeed;
+    private _skeletonStart;
+    private _blendShapeStart;
+    root: Object3D;
+    private _avatarName;
+    private _bonePos;
+    private _boneScale;
+    private _boneRot;
+    private _crossFadeState;
+    init(param?: any): void;
+    start(): void;
+    private debug;
+    playAnim(anim: string, time?: number, speed?: number): void;
+    crossFade(anim: string, crossTime: number): void;
+    playBlendShape(shapeName: string, time?: number, speed?: number): void;
+    set avatar(name: string);
+    get numJoint(): number;
+    getJointIndexTable(skinJointsName: Array<string>): number[];
+    private skeltonPoseObject3D;
+    private skeltonTPoseObject3D;
+    private buildSkeletonPose;
+    set clips(clips: PropertyAnimationClip[]);
+    get clips(): PropertyAnimationClip[];
+    get clipsState(): PropertyAnimationClipState[];
+    cloneTo(obj: Object3D): void;
+    private updateTime;
+    onUpdate(view?: View3D): void;
+    private updateSkeletonAnim;
+    private updateMorphAnim;
+    updateBlendShape(attributes: string[], key: string, value: number): void;
+    private updateSkeletonAnimMix;
+    private getPosition;
+    private getRotation;
+    private getScale;
+    getAnimationClipState(name: string): PropertyAnimationClipState;
+    cloneMorphRenderers(): {
+        [key: string]: SkinnedMeshRenderer2[];
+    };
+}
+export declare class PropertyAnimationClipState {
+    clip: PropertyAnimationClip;
+    weight: number;
+    get totalTime(): number;
+    constructor(clip: PropertyAnimationClip);
+}

package/dist/types/components/anim/OAnimationEvent.d.ts

@@ -0,0 +1,6 @@
+import { CEvent } from "../../event/CEvent";
+import { SkeletonAnimationComponent } from "../SkeletonAnimationComponent";
+export declare class OAnimationEvent extends CEvent {
+    skeletonAnimation: SkeletonAnimationComponent;
+    constructor(name: string, time: number);
+}

package/dist/types/components/anim/curveAnim/AnimationMonitor.d.ts

@@ -0,0 +1,29 @@
+import { PropertyAnimClip } from "./PropertyAnimClip";
+import { PropertyAnimation } from "./PropertyAnimation";
+export declare class AnimationMonitor {
+    static readonly Complete: number;
+    static readonly Seek: number;
+    private _rootObject3D;
+    private _animation;
+    private _propertyCache;
+    private _currentClip;
+    private _frame;
+    private _time;
+    private _isPlaying;
+    speed: number;
+    private _propertyTagDic;
+    constructor(animation: PropertyAnimation);
+    private reset;
+    get time(): number;
+    get currentClip(): PropertyAnimClip;
+    play(clip: PropertyAnimClip, reset?: boolean): void;
+    private parseAnimClip;
+    stop(): this;
+    toggle(): this;
+    get isPlaying(): boolean;
+    update(time: number, delta: number): void;
+    seek(time: number): this;
+    private calcTime;
+    private validProperty;
+    private applyProperty;
+}

package/dist/types/components/anim/curveAnim/AttributeAnimCurve.d.ts

@@ -0,0 +1,8 @@
+import { AnimationCurve } from "../../../math/AnimationCurve";
+export declare class AttributeAnimCurve extends AnimationCurve {
+    attribute: string;
+    propertyList: string[];
+    path: string;
+    constructor();
+    unSerialized(data: any): this;
+}

package/dist/types/components/anim/curveAnim/PropertyAnimClip.d.ts

@@ -0,0 +1,29 @@
+import { AttributeAnimCurve } from "./AttributeAnimCurve";
+export declare class ObjectAnimClip {
+    curve: {
+        [attribute: string]: AttributeAnimCurve;
+    };
+}
+export declare enum WrapMode {
+    Default = 0,
+    Clamp = 1,
+    Once = 1,
+    Loop = 2,
+    PingPong = 4,
+    ClampForever = 8
+}
+export declare class PropertyAnimClip {
+    name: string;
+    objAnimClip: {
+        [path: string]: ObjectAnimClip;
+    };
+    totalTime: number;
+    time: number;
+    private _stopTime;
+    private _loopTime;
+    private _wrapMode;
+    private _sampleRate;
+    get wrapMode(): WrapMode;
+    set wrapMode(value: WrapMode);
+    parse(jsonData: any): void;
+}

package/dist/types/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/types/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/types/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/types/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/types/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 {};