Options
All
  • Public
  • Public/Protected
  • All
Menu

External module animation

Index

Enumerations

Classes

Interfaces

Type aliases

Variables

Functions

Type aliases

BezierControlPoints

BezierControlPoints: [number, number, number, number]

BlendFunction

BlendFunction: function

If propertyBlendState.weight equals to zero, the propertyBlendState.value is dirty. You shall handle this situation correctly.

Type declaration

CompressedEasingMethods

CompressedEasingMethods: Record<number, EasingMethod>

ConvertedProps

ConvertedProps: Record<string, IPropertyCurve>

CubicSplineValueConstructor

CubicSplineValueConstructor: object

Type declaration

CurveData

CurveData: Vec3 | Quat | Mat4

CurveTarget

CurveTarget: Record<string, any>

表示曲线的目标对象。

CurveValue

CurveValue: any

表示曲线值，曲线值可以是任意类型，但必须符合插值方式的要求。

EasingMethod

EasingMethod: EasingMethodName | BezierControlPoints

帧时间渐变方式。可能为内置帧时间渐变方式的名称或贝塞尔控制点。

EasingMethodName

EasingMethodName: keyof "E:/workCode/editor-3d/resources/3d/engine/cocos/core/animation/easing"

内置帧时间渐变方式名称。

IRuntimeCurve

IRuntimeCurve: Pick<ICurve, "modifiers" | "valueAdapter" | "commonTarget"> & object

LerpFunction

LerpFunction: function

Type declaration

    • (from: T, to: T, t: number, dt: number): T

    • Parameters

      • from: T
      • to: T
      • t: number
      • dt: number

      Returns T

PropertyBlendState

PropertyBlendState: object

Type declaration

  • name: string
  • refCount: number
  • Optional value?: T
  • weight: number

ScaleAndAddFx

ScaleAndAddFx: function

Type declaration

    • (out: T, v1: T, v2: T, s: number): T

    • Parameters

      • out: T
      • v1: T
      • v2: T
      • s: number

      Returns T

ScaleFx

ScaleFx: function

Type declaration

    • (out: T, v: T, s: number): T

    • Parameters

      • out: T
      • v: T
      • s: number

      Returns T

Variables

Const CubicSplineQuatValue

CubicSplineQuatValue: object = makeCubicSplineValueConstructor('cc.CubicSplineQuatValue', Quat, Quat.multiplyScalar, Quat.scaleAndAdd)

Type declaration

Const CubicSplineVec2Value

CubicSplineVec2Value: object = makeCubicSplineValueConstructor('cc.CubicSplineVec2Value', Vec2, Vec2.multiplyScalar, Vec2.scaleAndAdd)

Type declaration

Const CubicSplineVec3Value

CubicSplineVec3Value: object = makeCubicSplineValueConstructor('cc.CubicSplineVec3Value', Vec3, Vec3.multiplyScalar, Vec3.scaleAndAdd)

Type declaration

Const CubicSplineVec4Value

CubicSplineVec4Value: object = makeCubicSplineValueConstructor('cc.CubicSplineVec4Value', Vec4, Vec4.multiplyScalar, Vec4.scaleAndAdd)

Type declaration

Const InvalidIndex

InvalidIndex: -1 = -1

Const _defaultCurves

_defaultCurves: never[] = []

Const acos

acos: acos = Math.acos

Const backOutIn

backOutIn: (Anonymous function) = _makeOutIn(backIn, backOut)

Const binaryBuffer

binaryBuffer: ArrayBuffer = ArrayBuffer.isView(this._nativeAsset) ? this._nativeAsset.buffer : this._nativeAsset

Const bounceOutIn

bounceOutIn: (Anonymous function) = _makeOutIn(bounceIn, bounceOut)

Const circOutIn

circOutIn: (Anonymous function) = _makeOutIn(circIn, circOut)

Const cos

cos: cos = Math.cos

Const cubicOutIn

cubicOutIn: (Anonymous function) = _makeOutIn(cubicIn, cubicOut)

Const elasticOutIn

elasticOutIn: (Anonymous function) = _makeOutIn(elasticIn, elasticOut)

Const eventGroups

eventGroups: IAnimationEventGroup[] = []

Const events

events: any = this.events.sort((a, b) => a.frame - b.frame)

Const expoOutIn

expoOutIn: (Anonymous function) = _makeOutIn(expoIn, expoOut)

Const m4_1

m4_1: Mat4 = new Mat4()

Const m4_1

m4_1: Mat4 = new Mat4()

Const m4_1

m4_1: Mat4 = new Mat4()

Const m4_2

m4_2: Mat4 = new Mat4()

Const max

max: max = Math.max

Const maybeCompressedKeys

maybeCompressedKeys: (number[] | CompactValueTypeArray)[] = this._keys as AnimationClip._impl.MaybeCompactKeys

off

off: off

on

on: on

Const pi

pi: number = Math.PI

Const quadOutIn

quadOutIn: (Anonymous function) = _makeOutIn(quadIn, quadOut)

Const quartOutIn

quartOutIn: (Anonymous function) = _makeOutIn(quartIn, quartOut)

Const quintOutIn

quintOutIn: (Anonymous function) = _makeOutIn(quintIn, quintOut)

Const ratios

ratios: number[] = []

Const result

result: number = binarySearchEpsilon(this._runtimeEvents!.ratios, ratio)

Const selectLerpFx

selectLerpFx: (Anonymous function) = (() => {function makeValueTypeLerpFx<T extends ValueType> (constructor: Constructor<T>) {const tempValue = new constructor();return (from: T, to: T, ratio: number) => {// @ts-ignoreconstructor.lerp(tempValue, from, to, ratio);return tempValue;};}function callLerpable (from: ILerpable, to: ILerpable, t: number, dt: number): any {return from.lerp(to, t, dt);}function makeQuatSlerpFx () {const tempValue = new Quat();return (from: Quat, to: Quat, t: number, dt: number) => {return Quat.slerp(tempValue, from, to, t);};}return (value: any): LerpFunction<any> | undefined => {if (value === null) {return undefined;}if (typeof value === 'number') {return lerp;} else if (typeof value === 'object' && value.constructor) {if (value instanceof Quat) {return makeQuatSlerpFx();} else if (value instanceof ValueType) {return makeValueTypeLerpFx(value.constructor as typeof ValueType);} else if (value.constructor === Number) {return lerp;} else if (isLerpable(value)) {return callLerpable;}}return undefined;};})()

Const sineOutIn

sineOutIn: (Anonymous function) = _makeOutIn(sineIn, sineOut)

Const sqrt

sqrt: sqrt = Math.sqrt

Const tau

tau: number = 2 * pi

Functions

makeOutIn

  • makeOutIn(fnIn: function, fnOut: function): (Anonymous function)

  • Parameters

    • fnIn: function
        • (k: number): number

        • Parameters

          • k: number

          Returns number

    • fnOut: function
        • (k: number): number

        • Parameters

          • k: number

          Returns number

    Returns (Anonymous function)

additive1D

  • additive1D(value: number, weight: number, propertyBlendState: PropertyBlendState<number>): number

additive3D

additiveQuat

backIn

  • backIn(k: number): number

backInOut

  • backInOut(k: number): number

backOut

  • backOut(k: number): number

bezier

  • bezier(C1: number, C2: number, C3: number, C4: number, t: number): number

bezierByTime

bounceIn

  • bounceIn(k: number): number

bounceInOut

  • bounceInOut(k: number): number

bounceOut

  • bounceOut(k: number): number

cardano

circIn

  • circIn(k: number): number

circInOut

  • circInOut(k: number): number

circOut

  • circOut(k: number): number

collectRecursively

  • collectRecursively(node: Node, prefix?: string, out?: string[]): string[]

computeRatioByType

  • computeRatioByType(ratio: number, type: EasingMethod): number

  • Compute a new ratio by curve type.

    Parameters

    • ratio: number

      The origin ratio

    • type: EasingMethod

      If it's Array, then ratio will be computed with bezierByTime. If it's string, then ratio will be computed with cc.easing function

    Returns number

constant

  • constant(): number

convertToSkeletalCurves

convertToUniformSample

convertToWorldSpace

crt

  • crt(v: number): number

cubicIn

  • cubicIn(k: number): number

cubicInOut

  • cubicInOut(k: number): number

cubicOut

  • cubicOut(k: number): number

elasticIn

  • elasticIn(k: number): number

elasticInOut

  • elasticInOut(k: number): number

elasticOut

  • elasticOut(k: number): number

equalClips

expoIn

  • expoIn(k: number): number

expoInOut

  • expoInOut(k: number): number

expoOut

  • expoOut(k: number): number

fade

  • fade(k: number): number

getPathFromRoot

  • getPathFromRoot(target: Node | null, root: Node): string

getWorldTransformUntilRoot

  • getWorldTransformUntilRoot(target: Node, root: Node, outMatrix: Mat4): void

isLerpable

  • isLerpable(object: any): boolean

linear

  • linear(k: number): number

makeCubicSplineValueConstructor

makeSamplerSharedGroup

quadIn

  • quadIn(k: number): number

quadInOut

  • quadInOut(k: number): number

quadOut

  • quadOut(k: number): number

quartIn

  • quartIn(k: number): number

quartInOut

  • quartInOut(k: number): number

quartOut

  • quartOut(k: number): number

quickFindIndex

  • quickFindIndex(ratios: number[], ratio: number): number

quintIn

  • quintIn(k: number): number

quintInOut

  • quintInOut(k: number): number

quintOut

  • quintOut(k: number): number

sampleAnimationCurve

sineIn

  • sineIn(k: number): number

sineInOut

  • sineInOut(k: number): number

sineOut

  • sineOut(k: number): number

smooth

  • smooth(k: number): number

wrapIterations

  • wrapIterations(iterations: number): number

Generated using TypeDoc