@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/components/anim/AnimatorComponent.js

@@ -1,411 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var AnimatorComponent_1;
-import { Engine3D, Matrix4, MeshRenderer, Object3D, Quaternion, RendererMask, RendererMaskUtil, SkinnedMeshRenderer2, StorageGPUBuffer, Time, Vector3, } from "../..";
-import { RegisterComponent } from "../../util/SerializeDecoration";
-import { ComponentBase } from "../ComponentBase";
-/* eslint-disable */
-let AnimatorComponent = AnimatorComponent_1 = class AnimatorComponent extends ComponentBase {
-    constructor() {
-        super(...arguments);
-        this.timeScale = 1.0;
-        this.playBlendShapeLoop = false;
-        this._skeletonTime = 0;
-        this._blendShapeTime = 0;
-        this._skeletonSpeed = 1;
-        this._blendShapeSpeed = 1;
-        this._skeletonStart = true;
-        this._blendShapeStart = true;
-        this._bonePos = new Vector3();
-        this._boneScale = new Vector3();
-        this._boneRot = new Quaternion();
-        this.skeltonPoseObject3D = {};
-        this.skeltonTPoseObject3D = {};
-    }
-    init(param) {
-        this.propertyCache = new Map();
-        this._clipsMap = new Map();
-        this._clips = [];
-        this._clipsState = [];
-        this._rendererList =
-            this.object3D.getComponentsInChild(SkinnedMeshRenderer2);
-        let mrs = this.object3D.getComponentsInChild(MeshRenderer);
-        for (let mr of mrs) {
-            let o = mr;
-            o.blendShape = mr.morphData;
-            this._rendererList.push(o);
-        }
-        for (const renderer of this._rendererList) {
-            let hasMorphTarget = RendererMaskUtil.hasMask(renderer.rendererMask, RendererMask.MorphTarget);
-            if (hasMorphTarget) {
-                renderer.selfCloneMaterials("MORPH_TARGET_UUID");
-            }
-        }
-    }
-    start() { }
-    debug() { }
-    playAnim(anim, time = 0, speed = 1) {
-        let clipState = this.getAnimationClipState(anim);
-        if (clipState) {
-            if (this._currentSkeletonClip) {
-                this._currentSkeletonClip.weight = 0;
-            }
-            this._currentSkeletonClip = clipState;
-            this._currentSkeletonClip.weight = 1.0;
-            this._skeletonTime = time;
-            this._skeletonSpeed = speed;
-            this._skeletonStart = true;
-        }
-        else {
-            console.warn(`not has anim ${anim}`);
-        }
-    }
-    crossFade(anim, crossTime) {
-        let clipState = this.getAnimationClipState(anim);
-        if (!clipState) {
-            console.warn(`not has anim ${anim}`);
-            return;
-        }
-        if (crossTime < 0.01 || !this._currentSkeletonClip) {
-            this.playAnim(anim);
-            return;
-        }
-        if (this._currentSkeletonClip &&
-            this._currentSkeletonClip.clip.clipName === anim) {
-            return;
-        }
-        let inClip = clipState;
-        let outClip = this._currentSkeletonClip;
-        if (this._crossFadeState) {
-            if (this._crossFadeState.inClip) {
-                this._crossFadeState.inClip.weight = 0;
-            }
-            if (this._crossFadeState.outClip) {
-                this._crossFadeState.outClip.weight = 0;
-            }
-            this._crossFadeState.reset(inClip, outClip, crossTime);
-        }
-        else {
-            this._crossFadeState = new SkeletonAnimCrossFadeState(inClip, outClip, crossTime);
-        }
-        this._currentSkeletonClip = inClip;
-    }
-    playBlendShape(shapeName, time = 0, speed = 1) {
-        if (this._clipsMap.has(shapeName)) {
-            this._currentBlendAnimClip = this._clipsMap.get(shapeName);
-            this._blendShapeTime = time;
-            this._blendShapeSpeed = speed;
-            this._blendShapeStart = true;
-        }
-        else {
-            console.warn(`not has blendShape ${shapeName}`);
-        }
-    }
-    set avatar(name) {
-        this._avatarName = name;
-        this.inverseBindMatrices = [];
-        this._avatar = Engine3D.res.getObj(name);
-        let jointMapping = this.buildSkeletonPose();
-        const jointMatrixIndexTable = new Float32Array(jointMapping);
-        this.jointMatrixIndexTableBuffer = new StorageGPUBuffer(this._avatar.count, 0, jointMatrixIndexTable);
-    }
-    get numJoint() {
-        return this._avatar.count;
-    }
-    getJointIndexTable(skinJointsName) {
-        let result = new Array();
-        for (let i = 0; i < skinJointsName.length; i++) {
-            let joint = this._avatar.boneMap.get(skinJointsName[i]);
-            result[i] = joint ? joint.boneID : -1;
-        }
-        return result;
-    }
-    buildSkeletonPose() {
-        let list = [];
-        for (const joint of this._avatar.boneData) {
-            let obj = new Object3D();
-            Matrix4.getEuler(Vector3.HELP_6, joint.q, true, "ZYX");
-            obj.localPosition = joint.t.clone();
-            obj.localRotation = Vector3.HELP_6.clone();
-            obj.localScale = Vector3.ONE;
-            joint.s.clone();
-            this.skeltonPoseObject3D[joint.boneName] = obj;
-            this.skeltonTPoseObject3D[joint.bonePath] = obj.clone();
-            if (joint.parentBoneName && joint.parentBoneName != "") {
-                this.skeltonPoseObject3D[joint.parentBoneName].addChild(obj);
-            }
-            else {
-                if (this.object3D.transform.scene3D) {
-                    this.object3D.transform.scene3D.addChild(obj);
-                }
-                this.root = obj;
-            }
-            list.push(obj.transform.worldMatrix.index);
-            let local = new Matrix4();
-            local.copyFrom(obj.transform.worldMatrix);
-            local.invert();
-            this.inverseBindMatrices.push(local.rawData);
-        }
-        return list;
-    }
-    set clips(clips) {
-        this._clips = clips;
-        for (const clip of clips) {
-            this._clipsMap.set(clip.clipName, clip);
-        }
-        this._clipsState = [];
-        for (const clip of clips) {
-            this._clipsState.push(new PropertyAnimationClipState(clip));
-        }
-        if (!this._currentSkeletonClip) {
-            this.playAnim(clips[0].clipName);
-        }
-    }
-    get clips() {
-        return this._clips;
-    }
-    get clipsState() {
-        return this._clipsState;
-    }
-    cloneTo(obj) {
-        let animatorComponent = obj.addComponent(AnimatorComponent_1);
-        animatorComponent.avatar = this._avatarName;
-        animatorComponent.clips = this._clips;
-    }
-    updateTime() {
-        const delta = Time.delta * 0.001;
-        if (this._skeletonStart) {
-            this._skeletonTime += delta * this._skeletonSpeed * this.timeScale;
-            if (this._currentSkeletonClip &&
-                this._currentSkeletonClip.clip.loopTime) {
-                this._skeletonTime =
-                    this._skeletonTime % this._currentSkeletonClip.clip.stopTime;
-            }
-        }
-        if (this._blendShapeStart) {
-            this._blendShapeTime += delta * this._blendShapeSpeed;
-            if (this._currentBlendAnimClip) {
-                if (this._currentBlendAnimClip.loopTime && this.playBlendShapeLoop) {
-                    this._blendShapeTime =
-                        this._blendShapeTime % this._currentBlendAnimClip.stopTime;
-                }
-                else {
-                    this._blendShapeTime =
-                        Math.min(this._blendShapeTime, this._currentBlendAnimClip.stopTime) - 0.0001;
-                }
-            }
-        }
-        if (this._crossFadeState) {
-            this._crossFadeState.update(delta);
-        }
-    }
-    onUpdate(view) {
-        this.updateTime();
-        let mixClip = [];
-        for (let clipState of this._clipsState) {
-            if (clipState.weight > 0) {
-                mixClip.push(clipState);
-            }
-        }
-        if (mixClip.length > 0) {
-            this.updateSkeletonAnimMix(mixClip);
-        }
-        else {
-            this.updateSkeletonAnim();
-        }
-        this.updateMorphAnim();
-    }
-    updateSkeletonAnim() {
-        if (this._currentSkeletonClip) {
-            let joints = this._avatar.boneData;
-            let i = 0;
-            let len = joints.length;
-            for (i = 0; i < len; i++) {
-                const joint = joints[i];
-                let obj = this.skeltonPoseObject3D[joint.boneName];
-                if (this._currentSkeletonClip.clip.useSkeletonPos) {
-                    let pos = this.getPosition(joint.bonePath, this._skeletonTime);
-                    obj.transform.localPosition = pos;
-                }
-                let rot = this.getRotation(joint.bonePath, this._skeletonTime);
-                obj.transform.localRotQuat = rot;
-                if (this._currentSkeletonClip.clip.useSkeletonScale) {
-                    let scale = this.getScale(joint.bonePath, this._skeletonTime);
-                    obj.transform.localScale = scale;
-                }
-            }
-        }
-    }
-    updateMorphAnim() {
-        if (this._currentBlendAnimClip && this._currentBlendAnimClip.floatCurves) {
-            if (this._currentBlendAnimClip.floatCurves.size > 0 &&
-                this._rendererList) {
-                for (const iterator of this._currentBlendAnimClip.floatCurves) {
-                    let key = iterator[0];
-                    let curve = iterator[1];
-                    let attributes = curve.propertys;
-                    let x = this._currentBlendAnimClip.floatCurves
-                        .get(key)
-                        .getValue(this._blendShapeTime);
-                    let value = x / 100;
-                    this.updateBlendShape(attributes, key, value);
-                }
-            }
-        }
-    }
-    updateBlendShape(attributes, key, value) {
-        for (const renderer of this._rendererList) {
-            if (renderer.blendShape) {
-                let property = this.propertyCache.get(renderer);
-                if (property && key in property) {
-                    property[key](value);
-                }
-                else {
-                    property = renderer;
-                    for (const att of attributes) {
-                        if (!property[att]) {
-                            property = null;
-                            break;
-                        }
-                        property = property[att];
-                    }
-                    if (!property || property == renderer)
-                        continue;
-                    if (!this.propertyCache.get(renderer))
-                        this.propertyCache.set(renderer, {});
-                    this.propertyCache.get(renderer)[key] = property;
-                    property(value);
-                }
-            }
-        }
-    }
-    updateSkeletonAnimMix(mixClip) {
-        let totalWeight = 0;
-        for (let clip of mixClip) {
-            totalWeight += clip.weight;
-        }
-        if (mixClip.length > 0) {
-            let joints = this._avatar.boneData;
-            let len = joints.length;
-            for (let i = 0; i < len; i++) {
-                const joint = joints[i];
-                let obj = this.skeltonPoseObject3D[joint.boneName];
-                if (mixClip[0].clip.useSkeletonPos) {
-                    this._bonePos.copyFrom(this.getPosition(joint.bonePath, this._skeletonTime, mixClip[0].clip));
-                    for (let i = 1; i < mixClip.length; i++) {
-                        const clipState = mixClip[i];
-                        if (clipState.clip.useSkeletonPos) {
-                            let pos = this.getPosition(joint.bonePath, this._skeletonTime, clipState.clip);
-                            Vector3.HELP_0.lerp(this._bonePos, pos, clipState.weight / totalWeight);
-                            this._bonePos.copyFrom(Vector3.HELP_0);
-                        }
-                    }
-                    obj.transform.localPosition = this._bonePos;
-                }
-                this._boneRot.copyFrom(this.getRotation(joint.bonePath, this._skeletonTime, mixClip[0].clip));
-                for (let i = 1; i < mixClip.length; i++) {
-                    const clipState = mixClip[i];
-                    let rot = this.getRotation(joint.bonePath, this._skeletonTime, clipState.clip);
-                    Quaternion.HELP_2.slerp(this._boneRot, rot, clipState.weight / totalWeight);
-                    this._boneRot.copyFrom(Quaternion.HELP_2);
-                }
-                obj.transform.localRotQuat = this._boneRot;
-                if (mixClip[0].clip.useSkeletonScale) {
-                    this._boneScale.copyFrom(this.getScale(joint.bonePath, this._skeletonTime, mixClip[0].clip));
-                    for (let i = 1; i < mixClip.length; i++) {
-                        const clipState = mixClip[i];
-                        if (clipState.clip.useSkeletonScale) {
-                            let scale = this.getScale(joint.bonePath, this._skeletonTime, clipState.clip);
-                            Vector3.HELP_0.lerp(this._boneScale, scale, clipState.weight / totalWeight);
-                            this._boneScale.copyFrom(Vector3.HELP_0);
-                        }
-                    }
-                    obj.transform.localScale = this._boneScale;
-                }
-            }
-        }
-    }
-    getPosition(boneName, time, clip = this._currentSkeletonClip.clip) {
-        if (clip.positionCurves.has(boneName)) {
-            let t = clip.positionCurves.get(boneName).getValue(time);
-            return t;
-        }
-        return this.skeltonTPoseObject3D[boneName].localPosition;
-    }
-    getRotation(boneName, time, clip = this._currentSkeletonClip.clip) {
-        if (clip.rotationCurves.has(boneName)) {
-            let v4 = clip.rotationCurves.get(boneName).getValue(time);
-            Quaternion.HELP_0.set(v4.x, v4.y, v4.z, v4.w);
-            return Quaternion.HELP_0;
-        }
-        return this.skeltonTPoseObject3D[boneName].localQuaternion;
-    }
-    getScale(boneName, time, clip = this._currentSkeletonClip.clip) {
-        if (clip.scaleCurves.has(boneName)) {
-            let x = clip.scaleCurves.get(boneName).getValue(time);
-            return x;
-        }
-        return this.skeltonTPoseObject3D[boneName].localScale;
-    }
-    getAnimationClipState(name) {
-        for (let clipState of this._clipsState) {
-            if (clipState.clip.clipName === name) {
-                return clipState;
-            }
-        }
-        return null;
-    }
-    cloneMorphRenderers() {
-        let dst = {};
-        for (const renderer of this._rendererList) {
-            for (const key in renderer.geometry.morphTargetDictionary) {
-                let renderList = dst[key] || [];
-                renderList.push(renderer);
-                dst[key] = renderList;
-            }
-        }
-        return dst;
-    }
-};
-AnimatorComponent = AnimatorComponent_1 = __decorate([
-    RegisterComponent(AnimatorComponent, "AnimatorComponent")
-], AnimatorComponent);
-export { AnimatorComponent };
-export class PropertyAnimationClipState {
-    get totalTime() {
-        return this.clip.stopTime - this.clip.startTime;
-    }
-    constructor(clip) {
-        this.weight = 0.0;
-        this.clip = clip;
-    }
-}
-class SkeletonAnimCrossFadeState {
-    constructor(inClip, outClip, time) {
-        this.reset(inClip, outClip, time);
-    }
-    reset(inClip, outClip, time) {
-        this.inClip = inClip;
-        this.outClip = outClip;
-        this.currentTime = 0;
-        this.crossFadeTime = time;
-    }
-    update(delta) {
-        if (!this.inClip || !this.outClip) {
-            return;
-        }
-        this.currentTime += delta;
-        this.inClip.weight = Math.min(Math.abs(this.currentTime % this.crossFadeTime) / this.crossFadeTime, 1.0);
-        this.outClip.weight = 1.0 - this.inClip.weight;
-        if (Math.abs(this.currentTime) >= this.crossFadeTime) {
-            this.inClip.weight = 1.0;
-            this.outClip.weight = 0.0;
-            this.inClip = null;
-            this.outClip = null;
-        }
-    }
-}

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

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

package/dist/src/components/anim/OAnimationEvent.js

@@ -1,8 +0,0 @@
-import { CEvent } from "../../event/CEvent";
-export class OAnimationEvent extends CEvent {
-    constructor(name, time) {
-        super();
-        this.type = name;
-        this.time = time;
-    }
-}

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

@@ -1,29 +0,0 @@
-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/src/components/anim/curveAnim/AnimationMonitor.js

@@ -1,159 +0,0 @@
-import { repeat, clamp } from "../../../math/MathUtil";
-import { Matrix4 } from "../../../math/Matrix4";
-import { WrapMode } from "./PropertyAnimClip";
-import { PropertyAnimTag, PropertyHelp } from "./PropertyHelp";
-export class AnimationMonitor {
-    static { this.Complete = 0; }
-    static { this.Seek = 1; }
-    constructor(animation) {
-        this._frame = 0;
-        this._time = 0;
-        this._isPlaying = true;
-        this.speed = 1;
-        this._rootObject3D = animation.object3D;
-        this._animation = animation;
-        this._propertyTagDic = new Map();
-        this.reset();
-    }
-    reset() {
-        this._propertyCache = {};
-        this._propertyTagDic.clear();
-    }
-    get time() {
-        return this._time;
-    }
-    get currentClip() {
-        return this._currentClip;
-    }
-    play(clip, reset = true) {
-        this._isPlaying = true;
-        if (reset) {
-            this._time = 0;
-        }
-        if (clip != this._currentClip) {
-            if (clip) {
-                this.parseAnimClip(clip);
-            }
-        }
-        this._currentClip = clip;
-        this.validProperty();
-    }
-    parseAnimClip(clip) {
-        this.reset();
-        for (const objPath in clip.objAnimClip) {
-            let objClip = clip.objAnimClip[objPath];
-            let bindObject3D = this._rootObject3D;
-            let attsCache = {};
-            if (objPath == "") {
-                bindObject3D = this._rootObject3D;
-            }
-            else {
-                bindObject3D = this._rootObject3D.getObjectByName(objPath);
-            }
-            if (!bindObject3D)
-                continue;
-            let tag = new PropertyAnimTag();
-            this._propertyTagDic.set(bindObject3D, tag);
-            let curve = objClip.curve;
-            for (const attribute in curve) {
-                PropertyHelp.updatePropertyTag(tag, attribute);
-                let binder = (this._propertyCache[objPath] ||= {});
-                let atts = PropertyHelp.Property[attribute].split(".");
-                let atts_0 = atts[0];
-                if (atts.length > 1) {
-                    let value = attsCache[atts_0];
-                    if (!value) {
-                        value = attsCache[atts_0] = bindObject3D[atts_0];
-                    }
-                    binder[attribute] = { value: value, property: atts[1] };
-                }
-                else {
-                    binder[attribute] = { value: bindObject3D, property: atts[0] };
-                }
-            }
-        }
-        return this;
-    }
-    stop() {
-        this._isPlaying = false;
-        return this;
-    }
-    toggle() {
-        this._isPlaying = !this._isPlaying;
-        return this;
-    }
-    get isPlaying() {
-        return this._isPlaying;
-    }
-    update(time, delta) {
-        time = time * 0.001;
-        delta = delta * 0.001;
-        if (!this._currentClip || this._frame == time)
-            return;
-        if (!this._isPlaying)
-            return;
-        this._frame = time;
-        let lastTime = this._time;
-        this._time = this.calcTime(lastTime + delta * this.speed);
-        this.validProperty();
-        if (this._currentClip.wrapMode != WrapMode.Loop &&
-            this._currentClip.wrapMode != WrapMode.Default) {
-            let complete = this.speed > 0
-                ? this._time >= this._currentClip.totalTime
-                : this._time <= 0;
-            if (complete) {
-                this._isPlaying = false;
-                this._animation["statusCall"](AnimationMonitor.Complete, lastTime, this._time);
-            }
-        }
-        this._animation["statusCall"](AnimationMonitor.Seek, lastTime, this._time);
-    }
-    seek(time) {
-        this._time = this.calcTime(time);
-        this._rootObject3D && this.validProperty();
-        return this;
-    }
-    calcTime(time) {
-        if (this._currentClip.wrapMode == WrapMode.Loop ||
-            this._currentClip.wrapMode == WrapMode.Default) {
-            time = repeat(time, this._currentClip.totalTime);
-        }
-        else {
-            time = clamp(time, 0, this._currentClip.totalTime);
-        }
-        return time;
-    }
-    validProperty() {
-        for (const objName in this._currentClip.objAnimClip) {
-            let objClip = this._currentClip.objAnimClip[objName];
-            let curve = objClip.curve;
-            for (const attribute in curve) {
-                const attributeAnim = curve[attribute];
-                let target = this._propertyCache[objName][attribute];
-                let ret = attributeAnim.getValue(this._time);
-                if (attribute in PropertyHelp.Scale) {
-                    ret *= PropertyHelp.Scale[attribute];
-                }
-                target.value[target.property] = ret;
-            }
-        }
-        //
-        this._propertyTagDic.forEach((v, k) => {
-            this.applyProperty(v, k);
-        });
-    }
-    applyProperty(tag, obj3d) {
-        if (tag.quaternion) {
-            Matrix4.getEuler(obj3d.transform.localRotation, obj3d.transform.localRotQuat, true, "ZYX");
-        }
-        if (tag.transform) {
-            obj3d.transform.localPosition = obj3d.transform.localPosition;
-            obj3d.transform.localRotation = obj3d.transform.localRotation;
-            obj3d.transform.localScale = obj3d.transform.localScale;
-        }
-        let animObj = obj3d;
-        if (tag.materialColor) {
-            animObj.notifyMaterialColorChange(0, "baseColor");
-        }
-    }
-}

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

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

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

@@ -1,15 +0,0 @@
-import { AnimationCurve } from "../../../math/AnimationCurve";
-export class AttributeAnimCurve extends AnimationCurve {
-    constructor() {
-        super();
-        this.attribute = "";
-    }
-    unSerialized(data) {
-        let { attribute, path } = data;
-        this.attribute = attribute;
-        this.path = path;
-        this.propertyList = attribute.split(".");
-        super.unSerialized(data.curve);
-        return this;
-    }
-}

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

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