mirror of
https://github.com/4ian/GDevelop.git
synced 2026-10-12 10:09:53 +00:00
2258 lines
65 KiB
TypeScript
2258 lines
65 KiB
TypeScript
/*
|
|
GDevelop - Tween Behavior Extension
|
|
Copyright (c) 2010-2023 Florian Rival ([email protected])
|
|
*/
|
|
namespace gdjs {
|
|
const logger = new gdjs.Logger('Tween');
|
|
|
|
interface TweenBehaviorNetworkSyncDataType {
|
|
tweenManager: TweenManagerNetworkSyncData;
|
|
}
|
|
/**
|
|
* @category Behaviors > Tween
|
|
*/
|
|
export interface TweenBehaviorNetworkSyncData
|
|
extends BehaviorNetworkSyncData {
|
|
props: TweenBehaviorNetworkSyncDataType;
|
|
}
|
|
|
|
interface IColorable extends gdjs.RuntimeObject {
|
|
setColor(color: string): void;
|
|
getColor(): string;
|
|
}
|
|
|
|
interface ICharacterScalable extends gdjs.RuntimeObject {
|
|
setCharacterSize(characterSize: number): void;
|
|
getCharacterSize(): number;
|
|
}
|
|
|
|
function isScalable(
|
|
object: gdjs.RuntimeObject
|
|
): object is gdjs.RuntimeObject & gdjs.Scalable {
|
|
return (
|
|
//@ts-ignore We are checking if the methods are present.
|
|
object.setScaleX &&
|
|
//@ts-ignore
|
|
object.setScaleY &&
|
|
//@ts-ignore
|
|
object.getScaleX &&
|
|
//@ts-ignore
|
|
object.getScaleY
|
|
);
|
|
}
|
|
|
|
function isOpaque(
|
|
object: gdjs.RuntimeObject
|
|
): object is gdjs.RuntimeObject & gdjs.OpacityHandler {
|
|
//@ts-ignore We are checking if the methods are present.
|
|
return object.setOpacity && object.getOpacity;
|
|
}
|
|
|
|
function is3D(
|
|
object: gdjs.RuntimeObject
|
|
): object is gdjs.RuntimeObject & gdjs.Base3DHandler {
|
|
//@ts-ignore We are checking if the methods are present.
|
|
return object.getZ && object.setZ;
|
|
}
|
|
|
|
function isColorable(object: gdjs.RuntimeObject): object is IColorable {
|
|
//@ts-ignore We are checking if the methods are present.
|
|
return object.setColor && object.getColor;
|
|
}
|
|
|
|
function isCharacterScalable(
|
|
object: gdjs.RuntimeObject
|
|
): object is ICharacterScalable {
|
|
//@ts-ignore We are checking if the methods are present.
|
|
return object.setCharacterSize && object.getCharacterSize;
|
|
}
|
|
|
|
const linearInterpolation = gdjs.evtTools.common.lerp;
|
|
const exponentialInterpolation =
|
|
gdjs.evtTools.common.exponentialInterpolation;
|
|
|
|
const tweenObjectValueSetter = () => {};
|
|
const getTweenVariableSetter = (variable: gdjs.Variable) => {
|
|
return (value: float) => variable.setNumber(value);
|
|
};
|
|
const getTweenObjectPositionXSetter = (object: gdjs.RuntimeObject) => {
|
|
return (value: float) => object.setX(value);
|
|
};
|
|
const getTweenObjectPositionYSetter = (object: gdjs.RuntimeObject) => {
|
|
return (value: float) => object.setY(value);
|
|
};
|
|
const getTweenObjectPositionZSetter = (object: gdjs.RuntimeObject) => {
|
|
if (!is3D(object)) return () => {};
|
|
return (value: float) => object.setZ(value);
|
|
};
|
|
const getTweenObjectPositionSetter = (object: gdjs.RuntimeObject) => {
|
|
return ([x, y]: float[]) => object.setPosition(x, y);
|
|
};
|
|
const getTweenObjectAngleSetter = (object: gdjs.RuntimeObject) => {
|
|
return (value: float) => object.setAngle(value);
|
|
};
|
|
const getTweenObjectWidthSetter = (object: gdjs.RuntimeObject) => {
|
|
return (value: float) => object.setWidth(value);
|
|
};
|
|
const getTweenObjectHeightSetter = (object: gdjs.RuntimeObject) => {
|
|
return (value: float) => object.setHeight(value);
|
|
};
|
|
const getTweenObjectRotationXSetter = (
|
|
object: gdjs.RuntimeObject & gdjs.Base3DHandler
|
|
) => {
|
|
return (value: float) => object.setRotationX(value);
|
|
};
|
|
const getTweenObjectRotationYSetter = (
|
|
object: gdjs.RuntimeObject & gdjs.Base3DHandler
|
|
) => {
|
|
return (value: float) => object.setRotationY(value);
|
|
};
|
|
const getTweenObjectDepthSetter = (
|
|
object: gdjs.RuntimeObject & gdjs.Base3DHandler
|
|
) => {
|
|
return (value: float) => object.setDepth(value);
|
|
};
|
|
const getTweenObjectScaleXYSetter = (
|
|
object: gdjs.RuntimeObject & gdjs.Scalable,
|
|
scaleFromCenterOfObject: boolean
|
|
) => {
|
|
return scaleFromCenterOfObject
|
|
? ([scaleX, scaleY]: float[]) => {
|
|
const oldX = object.getCenterXInScene();
|
|
const oldY = object.getCenterYInScene();
|
|
object.setScaleX(scaleX);
|
|
object.setScaleY(scaleY);
|
|
object.setCenterPositionInScene(oldX, oldY);
|
|
}
|
|
: ([scaleX, scaleY]: float[]) => {
|
|
object.setScaleX(scaleX);
|
|
object.setScaleY(scaleY);
|
|
};
|
|
};
|
|
const getTweenObjectScaleSetter = (
|
|
object: gdjs.RuntimeObject & gdjs.Scalable,
|
|
object3d: (gdjs.RuntimeObject & gdjs.Base3DHandler) | null,
|
|
scaleFromCenterOfObject: boolean
|
|
) => {
|
|
return scaleFromCenterOfObject
|
|
? (scale: float) => {
|
|
const oldX = object.getCenterXInScene();
|
|
const oldY = object.getCenterYInScene();
|
|
const oldZ = object3d ? object3d.getCenterZInScene() : 0;
|
|
object.setScale(scale);
|
|
object.setCenterXInScene(oldX);
|
|
object.setCenterYInScene(oldY);
|
|
if (object3d) {
|
|
object3d.setCenterZInScene(oldZ);
|
|
}
|
|
}
|
|
: (scale: float) => object.setScale(scale);
|
|
};
|
|
const getTweenObjectScaleXSetter = (
|
|
object: gdjs.RuntimeObject & gdjs.Scalable,
|
|
scaleFromCenterOfObject: boolean
|
|
) => {
|
|
return scaleFromCenterOfObject
|
|
? (scaleX: float) => {
|
|
const oldX = object.getCenterXInScene();
|
|
object.setScaleX(scaleX);
|
|
object.setCenterXInScene(oldX);
|
|
}
|
|
: (scaleX: float) => object.setScaleX(scaleX);
|
|
};
|
|
const getTweenObjectScaleYSetter = (
|
|
object: gdjs.RuntimeObject & gdjs.Scalable,
|
|
scaleFromCenterOfObject: boolean
|
|
) => {
|
|
return scaleFromCenterOfObject
|
|
? (scaleY: float) => {
|
|
const oldY = object.getCenterYInScene();
|
|
object.setScaleY(scaleY);
|
|
object.setCenterYInScene(oldY);
|
|
}
|
|
: (scaleY: float) => object.setScaleY(scaleY);
|
|
};
|
|
const getTweenObjectOpacitySetter = (
|
|
object: gdjs.RuntimeObject & gdjs.OpacityHandler
|
|
) => {
|
|
return (value: float) => object.setOpacity(value);
|
|
};
|
|
const getTweenObjectCharacterSizeSetter = (object: ICharacterScalable) => {
|
|
return (value: float) => object.setCharacterSize(value);
|
|
};
|
|
const getTweenObjectNumberEffectPropertySetter = (
|
|
effect: PixiFiltersTools.Filter,
|
|
propertyName: string
|
|
) => {
|
|
return (value: float) => {
|
|
effect.updateDoubleParameter(propertyName, value);
|
|
};
|
|
};
|
|
const getTweenObjectColorEffectPropertySetter = (
|
|
effect: PixiFiltersTools.Filter,
|
|
propertyName: string
|
|
) => {
|
|
return ([hue, saturation, lightness]: number[]) => {
|
|
const rgbFromHslColor = gdjs.evtTools.tween.hslToRgb(
|
|
hue,
|
|
saturation,
|
|
lightness
|
|
);
|
|
effect.updateColorParameter(
|
|
propertyName,
|
|
gdjs.rgbToHexNumber(
|
|
rgbFromHslColor[0],
|
|
rgbFromHslColor[1],
|
|
rgbFromHslColor[2]
|
|
)
|
|
);
|
|
};
|
|
};
|
|
const getTweenObjectColorSetter = (
|
|
object: IColorable,
|
|
useHSLColorTransition: boolean
|
|
) => {
|
|
if (useHSLColorTransition) {
|
|
return ([hue, saturation, lightness]: number[]) => {
|
|
const rgbFromHslColor = gdjs.evtTools.tween.hslToRgb(
|
|
hue,
|
|
saturation,
|
|
lightness
|
|
);
|
|
object.setColor(
|
|
Math.floor(rgbFromHslColor[0]) +
|
|
';' +
|
|
Math.floor(rgbFromHslColor[1]) +
|
|
';' +
|
|
Math.floor(rgbFromHslColor[2])
|
|
);
|
|
};
|
|
} else {
|
|
return ([red, green, blue]: number[]) => {
|
|
object.setColor(
|
|
Math.floor(red) + ';' + Math.floor(green) + ';' + Math.floor(blue)
|
|
);
|
|
};
|
|
}
|
|
};
|
|
const getTweenObjectColorHSLSetter = (object: IColorable) => {
|
|
return ([hue, saturation, lightness]: number[]) => {
|
|
const rgbFromHslColor = gdjs.evtTools.tween.hslToRgb(
|
|
hue,
|
|
saturation,
|
|
lightness
|
|
);
|
|
|
|
object.setColor(
|
|
Math.floor(rgbFromHslColor[0]) +
|
|
';' +
|
|
Math.floor(rgbFromHslColor[1]) +
|
|
';' +
|
|
Math.floor(rgbFromHslColor[2])
|
|
);
|
|
};
|
|
};
|
|
|
|
const tweenSetterFactory =
|
|
(object: RuntimeObject) =>
|
|
(tweenInformation: TweenInformationNetworkSyncData) => {
|
|
const type = tweenInformation.type;
|
|
const variablePath = tweenInformation.variablePath;
|
|
const effectName = tweenInformation.effectName;
|
|
const propertyName = tweenInformation.propertyName;
|
|
const scaleFromCenterOfObject =
|
|
!!tweenInformation.scaleFromCenterOfObject;
|
|
const useHSLColorTransition = !!tweenInformation.useHSLColorTransition;
|
|
if (type === 'objectValue') {
|
|
return tweenObjectValueSetter;
|
|
}
|
|
if (type === 'variable' && variablePath) {
|
|
const variable = object
|
|
.getVariables()
|
|
.getVariableFromPath(variablePath);
|
|
if (!variable) return () => {};
|
|
return getTweenVariableSetter(variable);
|
|
}
|
|
if (type === 'positionX') {
|
|
return getTweenObjectPositionXSetter(object);
|
|
}
|
|
if (type === 'positionY') {
|
|
return getTweenObjectPositionYSetter(object);
|
|
}
|
|
if (type === 'position') {
|
|
return getTweenObjectPositionSetter(object);
|
|
}
|
|
if (type === 'positionZ') {
|
|
return getTweenObjectPositionZSetter(object);
|
|
}
|
|
if (type === 'width') {
|
|
return getTweenObjectWidthSetter(object);
|
|
}
|
|
if (type === 'height') {
|
|
return getTweenObjectHeightSetter(object);
|
|
}
|
|
if (type === 'depth') {
|
|
if (!is3D(object)) return () => {};
|
|
return getTweenObjectDepthSetter(object);
|
|
}
|
|
if (type === 'angle') {
|
|
return getTweenObjectAngleSetter(object);
|
|
}
|
|
if (type === 'rotationX') {
|
|
if (!is3D(object)) return () => {};
|
|
return getTweenObjectRotationXSetter(object);
|
|
}
|
|
if (type === 'rotationY') {
|
|
if (!is3D(object)) return () => {};
|
|
return getTweenObjectRotationYSetter(object);
|
|
}
|
|
if (type === 'scale') {
|
|
if (!isScalable(object)) return () => {};
|
|
|
|
const object3d = is3D(object) ? object : null;
|
|
return getTweenObjectScaleSetter(
|
|
object,
|
|
object3d,
|
|
scaleFromCenterOfObject
|
|
);
|
|
}
|
|
if (type === 'scaleXY') {
|
|
if (!isScalable(object)) return () => {};
|
|
return getTweenObjectScaleXYSetter(object, scaleFromCenterOfObject);
|
|
}
|
|
if (type === 'scaleX') {
|
|
if (!isScalable(object)) return () => {};
|
|
return getTweenObjectScaleXSetter(object, scaleFromCenterOfObject);
|
|
}
|
|
if (type === 'scaleY') {
|
|
if (!isScalable(object)) return () => {};
|
|
return getTweenObjectScaleYSetter(object, scaleFromCenterOfObject);
|
|
}
|
|
if (type === 'opacity') {
|
|
if (!isOpaque(object)) return () => {};
|
|
return getTweenObjectOpacitySetter(object);
|
|
}
|
|
if (type === 'characterSize') {
|
|
if (!isCharacterScalable(object)) return () => {};
|
|
return getTweenObjectCharacterSizeSetter(object);
|
|
}
|
|
if (type === 'numberEffectProperty' && effectName && propertyName) {
|
|
const effect = object.getRendererEffects()[effectName];
|
|
if (!effect) {
|
|
logger.error(
|
|
`The object "${object.name}" doesn't have any effect called "${effectName}"`
|
|
);
|
|
}
|
|
return getTweenObjectNumberEffectPropertySetter(effect, propertyName);
|
|
}
|
|
if (type === 'colorEffectProperty' && effectName && propertyName) {
|
|
const effect = object.getRendererEffects()[effectName];
|
|
if (!effect) {
|
|
logger.error(
|
|
`The object "${object.name}" doesn't have any effect called "${effectName}"`
|
|
);
|
|
}
|
|
|
|
return getTweenObjectColorEffectPropertySetter(effect, propertyName);
|
|
}
|
|
|
|
if (type === 'objectColor') {
|
|
if (!isColorable(object)) return () => {};
|
|
|
|
return getTweenObjectColorSetter(object, useHSLColorTransition);
|
|
}
|
|
if (type === 'objectColorHSL') {
|
|
if (!isColorable(object)) return () => {};
|
|
|
|
return getTweenObjectColorHSLSetter(object);
|
|
}
|
|
|
|
return () => {};
|
|
};
|
|
|
|
/**
|
|
* @category Behaviors > Tween
|
|
*/
|
|
export class TweenRuntimeBehavior extends gdjs.RuntimeBehavior {
|
|
private _tweens = new gdjs.evtTools.tween.TweenManager();
|
|
private _isActive: boolean = true;
|
|
|
|
/**
|
|
* @param instanceContainer The instance container the behavior belongs to.
|
|
* @param behaviorData The data to initialize the behavior
|
|
* @param owner The runtime object the behavior belongs to.
|
|
*/
|
|
constructor(
|
|
instanceContainer: gdjs.RuntimeInstanceContainer,
|
|
behaviorData: BehaviorData,
|
|
owner: gdjs.RuntimeObject
|
|
) {
|
|
super(instanceContainer, behaviorData, owner);
|
|
}
|
|
|
|
override applyBehaviorOverriding(behaviorData: BehaviorData): boolean {
|
|
// Nothing to update.
|
|
return true;
|
|
}
|
|
|
|
getNetworkSyncData(
|
|
syncOptions: GetNetworkSyncDataOptions
|
|
): TweenBehaviorNetworkSyncData {
|
|
return {
|
|
...super.getNetworkSyncData(syncOptions),
|
|
props: {
|
|
tweenManager: this._tweens.getNetworkSyncData(),
|
|
},
|
|
};
|
|
}
|
|
|
|
updateFromNetworkSyncData(
|
|
networkSyncData: TweenBehaviorNetworkSyncData,
|
|
options: UpdateFromNetworkSyncDataOptions
|
|
): void {
|
|
super.updateFromNetworkSyncData(networkSyncData, options);
|
|
|
|
if (networkSyncData.props.tweenManager) {
|
|
this._tweens.updateFromNetworkSyncData(
|
|
networkSyncData.props.tweenManager,
|
|
(tweenInformationNetworkSyncData) => {
|
|
return this.owner;
|
|
},
|
|
(tweenInformationNetworkSyncData) => {
|
|
return tweenSetterFactory(this.owner)(
|
|
tweenInformationNetworkSyncData
|
|
);
|
|
},
|
|
(tweenInformationNetworkSyncData) => {
|
|
return tweenInformationNetworkSyncData.destroyObjectWhenFinished
|
|
? () => this._deleteFromScene()
|
|
: null;
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer): void {
|
|
this._tweens.step();
|
|
}
|
|
|
|
private _deleteFromScene() {
|
|
this.owner.deleteFromScene();
|
|
}
|
|
|
|
/**
|
|
* Add an object variable tween.
|
|
* @deprecated Use addVariableTween3 instead.
|
|
* This function is misleading since one could think that the tween starts
|
|
* right at the moment this function is called whereas the value of the variable
|
|
* will change at the next frame only. Moreover, the variable will not start from
|
|
* the start value exactly since time will have passed at the moment the next
|
|
* frame is rendered.
|
|
* See https://github.com/4ian/GDevelop/issues/4270
|
|
* @param identifier Unique id to identify the tween
|
|
* @param variable The object variable to store the tweened value
|
|
* @param fromValue Start value
|
|
* @param toValue End value
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addVariableTween(
|
|
identifier: string,
|
|
variable: gdjs.Variable,
|
|
fromValue: float,
|
|
toValue: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
this.owner.getRuntimeScene(),
|
|
duration / 1000,
|
|
easing,
|
|
linearInterpolation,
|
|
fromValue,
|
|
toValue,
|
|
getTweenVariableSetter(variable),
|
|
{
|
|
type: 'variable',
|
|
variable,
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object variable.
|
|
* @deprecated Use addVariableTween3 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param variable The object variable to store the tweened value
|
|
* @param toValue End value
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addVariableTween2(
|
|
identifier: string,
|
|
variable: gdjs.Variable,
|
|
toValue: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addVariableTween(
|
|
identifier,
|
|
variable,
|
|
toValue,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object variable.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param variable The object variable to store the tweened value
|
|
* @param toValue End value
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addVariableTween3(
|
|
identifier: string,
|
|
variable: gdjs.Variable,
|
|
toValue: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addVariableTween(
|
|
identifier,
|
|
variable,
|
|
toValue,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addVariableTween(
|
|
identifier: string,
|
|
variable: gdjs.Variable,
|
|
toValue: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
if (variable.getType() !== 'number') {
|
|
return;
|
|
}
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
variable.getValue() as number,
|
|
toValue,
|
|
getTweenVariableSetter(variable),
|
|
{
|
|
type: 'variable',
|
|
variable,
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Add an object value tween.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param fromValue Start value
|
|
* @param toValue End value
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param useExponentialInterpolation Set it to true to use a exponential
|
|
* It's useful for values that are factors like a scale or a zoom.
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addValueTween(
|
|
identifier: string,
|
|
fromValue: float,
|
|
toValue: float,
|
|
easing: string,
|
|
duration: float,
|
|
useExponentialInterpolation: boolean,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
this.owner,
|
|
duration,
|
|
easing,
|
|
useExponentialInterpolation
|
|
? exponentialInterpolation
|
|
: linearInterpolation,
|
|
fromValue,
|
|
toValue,
|
|
tweenObjectValueSetter,
|
|
{
|
|
type: 'objectValue',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object position.
|
|
* @deprecated Use addObjectPositionTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toX The target X position
|
|
* @param toY The target Y position
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectPositionTween(
|
|
identifier: string,
|
|
toX: number,
|
|
toY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectPositionTween(
|
|
identifier,
|
|
toX,
|
|
toY,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object position.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toX The target X position
|
|
* @param toY The target Y position
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectPositionTween2(
|
|
identifier: string,
|
|
toX: number,
|
|
toY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectPositionTween(
|
|
identifier,
|
|
toX,
|
|
toY,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectPositionTween(
|
|
identifier: string,
|
|
toX: number,
|
|
toY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
this._tweens.addMultiTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
[this.owner.getX(), this.owner.getY()],
|
|
[toX, toY],
|
|
getTweenObjectPositionSetter(this.owner),
|
|
{
|
|
type: 'position',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object X position.
|
|
* @deprecated Use addObjectPositionXTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toX The target X position
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectPositionXTween(
|
|
identifier: string,
|
|
toX: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectPositionXTween(
|
|
identifier,
|
|
toX,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object X position.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toX The target X position
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectPositionXTween2(
|
|
identifier: string,
|
|
toX: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectPositionXTween(
|
|
identifier,
|
|
toX,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectPositionXTween(
|
|
identifier: string,
|
|
toX: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
this.owner.getX(),
|
|
toX,
|
|
getTweenObjectPositionXSetter(this.owner),
|
|
{
|
|
type: 'positionX',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object Y position.
|
|
* @deprecated Use addObjectPositionYTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toY The target Y position
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectPositionYTween(
|
|
identifier: string,
|
|
toY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectPositionYTween(
|
|
identifier,
|
|
toY,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object Y position.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toY The target Y position
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectPositionYTween2(
|
|
identifier: string,
|
|
toY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectPositionYTween(
|
|
identifier,
|
|
toY,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectPositionYTween(
|
|
identifier: string,
|
|
toY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
this.owner.getY(),
|
|
toY,
|
|
getTweenObjectPositionYSetter(this.owner),
|
|
{
|
|
type: 'positionY',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object Z position.
|
|
* @deprecated Use addObjectPositionZTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toZ The target Z position
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectPositionZTween(
|
|
identifier: string,
|
|
toZ: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectPositionZTween(
|
|
identifier,
|
|
toZ,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object Z position.
|
|
* @param object3DBehavior Only used by events can be set to null
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toZ The target Z position
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectPositionZTween2(
|
|
object3DBehavior: any,
|
|
identifier: string,
|
|
toZ: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectPositionZTween(
|
|
identifier,
|
|
toZ,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectPositionZTween(
|
|
identifier: string,
|
|
toZ: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
const { owner } = this;
|
|
if (!is3D(owner)) return;
|
|
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
owner.getZ(),
|
|
toZ,
|
|
getTweenObjectPositionZSetter(owner),
|
|
{
|
|
type: 'positionZ',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object angle.
|
|
* @deprecated Use addObjectAngleTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toAngle The target angle
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectAngleTween(
|
|
identifier: string,
|
|
toAngle: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectAngleTween(
|
|
identifier,
|
|
toAngle,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object angle.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toAngle The target angle
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectAngleTween2(
|
|
identifier: string,
|
|
toAngle: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectAngleTween(
|
|
identifier,
|
|
toAngle,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectAngleTween(
|
|
identifier: string,
|
|
toAngle: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
this.owner.getAngle(),
|
|
toAngle,
|
|
getTweenObjectAngleSetter(this.owner),
|
|
{
|
|
type: 'angle',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween a 3D object rotation X.
|
|
* @param object3DBehavior Only used by events can be set to null
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toAngle The target angle
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectRotationXTween(
|
|
object3DBehavior: any,
|
|
identifier: string,
|
|
toAngle: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
const { owner } = this;
|
|
if (!is3D(owner)) return;
|
|
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
this.owner,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
owner.getRotationX(),
|
|
toAngle,
|
|
getTweenObjectRotationXSetter(owner),
|
|
{
|
|
type: 'rotationX',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween a 3D object rotation Y.
|
|
* @param object3DBehavior Only used by events can be set to null
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toAngle The target angle
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectRotationYTween(
|
|
object3DBehavior: any,
|
|
identifier: string,
|
|
toAngle: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
const { owner } = this;
|
|
if (!is3D(owner)) return;
|
|
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
this.owner,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
owner.getRotationY(),
|
|
toAngle,
|
|
getTweenObjectRotationYSetter(owner),
|
|
{
|
|
type: 'rotationY',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object scale.
|
|
* @deprecated Use addObjectScaleTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toScaleX The target X-scale
|
|
* @param toScaleY The target Y-scale
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
* @param scaleFromCenterOfObject Scale the transform from the center of the object (or point that is called center), not the top-left origin
|
|
*/
|
|
addObjectScaleTween(
|
|
identifier: string,
|
|
toScaleX: number,
|
|
toScaleY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean
|
|
) {
|
|
this._addObjectScaleTween(
|
|
identifier,
|
|
toScaleX,
|
|
toScaleY,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
scaleFromCenterOfObject,
|
|
this.owner.getRuntimeScene(),
|
|
linearInterpolation
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object scale.
|
|
* @deprecated Use addObjectScaleXTween2 and addObjectScaleYTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toScaleX The target X-scale
|
|
* @param toScaleY The target Y-scale
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
* @param scaleFromCenterOfObject Scale the transform from the center of the object (or point that is called center), not the top-left origin
|
|
*/
|
|
addObjectScaleTween2(
|
|
identifier: string,
|
|
toScaleX: number,
|
|
toScaleY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean
|
|
) {
|
|
this._addObjectScaleTween(
|
|
identifier,
|
|
toScaleX,
|
|
toScaleY,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
scaleFromCenterOfObject,
|
|
this.owner,
|
|
exponentialInterpolation
|
|
);
|
|
}
|
|
|
|
private _addObjectScaleTween(
|
|
identifier: string,
|
|
toScaleX: number,
|
|
toScaleY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource,
|
|
interpolation: gdjs.evtTools.tween.Interpolation
|
|
) {
|
|
const owner = this.owner;
|
|
if (!isScalable(owner)) return;
|
|
|
|
if (toScaleX < 0) toScaleX = 0;
|
|
if (toScaleY < 0) toScaleY = 0;
|
|
|
|
this._tweens.addMultiTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
interpolation,
|
|
[owner.getScaleX(), owner.getScaleY()],
|
|
[toScaleX, toScaleY],
|
|
getTweenObjectScaleXYSetter(owner, scaleFromCenterOfObject),
|
|
{
|
|
type: 'scaleXY',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object scale.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toScale The target scale
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
* @param scaleFromCenterOfObject Scale the transform from the center of the object (or point that is called center), not the top-left origin
|
|
*/
|
|
addObjectScaleTween3(
|
|
identifier: string,
|
|
toScale: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean
|
|
) {
|
|
this._addObjectScaleXTween(
|
|
identifier,
|
|
toScale,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
scaleFromCenterOfObject,
|
|
this.owner,
|
|
exponentialInterpolation
|
|
);
|
|
const owner = this.owner;
|
|
if (!isScalable(owner)) return;
|
|
|
|
// This action doesn't require 3D capabilities.
|
|
// So, gdjs.RuntimeObject3D may not exist
|
|
// when the 3D extension is not used.
|
|
const owner3d = is3D(owner) ? owner : null;
|
|
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
this.owner,
|
|
duration,
|
|
easing,
|
|
exponentialInterpolation,
|
|
owner.getScale(),
|
|
toScale,
|
|
getTweenObjectScaleSetter(owner, owner3d, scaleFromCenterOfObject),
|
|
{
|
|
type: 'scale',
|
|
scaleFromCenterOfObject,
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object X-scale.
|
|
* @deprecated Use addObjectScaleXTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toScaleX The target X-scale
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
* @param scaleFromCenterOfObject Scale the transform from the center of the object (or point that is called center), not the top-left origin
|
|
*/
|
|
addObjectScaleXTween(
|
|
identifier: string,
|
|
toScaleX: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean
|
|
) {
|
|
this._addObjectScaleXTween(
|
|
identifier,
|
|
toScaleX,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
scaleFromCenterOfObject,
|
|
this.owner.getRuntimeScene(),
|
|
linearInterpolation
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object X-scale.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toScaleX The target X-scale
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
* @param scaleFromCenterOfObject Scale the transform from the center of the object (or point that is called center), not the top-left origin
|
|
*/
|
|
addObjectScaleXTween2(
|
|
identifier: string,
|
|
toScaleX: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean
|
|
) {
|
|
this._addObjectScaleXTween(
|
|
identifier,
|
|
toScaleX,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
scaleFromCenterOfObject,
|
|
this.owner,
|
|
exponentialInterpolation
|
|
);
|
|
}
|
|
|
|
private _addObjectScaleXTween(
|
|
identifier: string,
|
|
toScaleX: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource,
|
|
interpolation: gdjs.evtTools.tween.Interpolation
|
|
) {
|
|
const owner = this.owner;
|
|
if (!isScalable(owner)) return;
|
|
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
interpolation,
|
|
owner.getScaleX(),
|
|
toScaleX,
|
|
getTweenObjectScaleXSetter(owner, scaleFromCenterOfObject),
|
|
{
|
|
type: 'scaleX',
|
|
scaleFromCenterOfObject,
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object Y-scale.
|
|
* @deprecated Use addObjectScaleYTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toScaleY The target Y-scale
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
* @param scaleFromCenterOfObject Scale the transform from the center of the object (or point that is called center), not the top-left origin
|
|
*/
|
|
addObjectScaleYTween(
|
|
identifier: string,
|
|
toScaleY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean
|
|
) {
|
|
this._addObjectScaleYTween(
|
|
identifier,
|
|
toScaleY,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
scaleFromCenterOfObject,
|
|
this.owner.getRuntimeScene(),
|
|
linearInterpolation
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object Y-scale.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toScaleY The target Y-scale
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
* @param scaleFromCenterOfObject Scale the transform from the center of the object (or point that is called center), not the top-left origin
|
|
*/
|
|
addObjectScaleYTween2(
|
|
identifier: string,
|
|
toScaleY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean
|
|
) {
|
|
this._addObjectScaleYTween(
|
|
identifier,
|
|
toScaleY,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
scaleFromCenterOfObject,
|
|
this.owner,
|
|
exponentialInterpolation
|
|
);
|
|
}
|
|
|
|
private _addObjectScaleYTween(
|
|
identifier: string,
|
|
toScaleY: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
scaleFromCenterOfObject: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource,
|
|
interpolation: gdjs.evtTools.tween.Interpolation
|
|
) {
|
|
const owner = this.owner;
|
|
if (!isScalable(owner)) return;
|
|
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
interpolation,
|
|
owner.getScaleY(),
|
|
toScaleY,
|
|
getTweenObjectScaleYSetter(owner, scaleFromCenterOfObject),
|
|
{
|
|
type: 'scaleY',
|
|
scaleFromCenterOfObject,
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object opacity.
|
|
* @deprecated Use addObjectOpacityTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toOpacity The target opacity
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectOpacityTween(
|
|
identifier: string,
|
|
toOpacity: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectOpacityTween(
|
|
identifier,
|
|
toOpacity,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object opacity.
|
|
* @deprecated Use addObjectOpacityTween3 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toOpacity The target opacity
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in second
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectOpacityTween2(
|
|
identifier: string,
|
|
toOpacity: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectOpacityTween(
|
|
identifier,
|
|
toOpacity,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object opacity.
|
|
* @param opacityBehavior Only used by events can be set to null
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toOpacity The target opacity
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in second
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectOpacityTween3(
|
|
opacityBehavior: any,
|
|
identifier: string,
|
|
toOpacity: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectOpacityTween(
|
|
identifier,
|
|
toOpacity,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectOpacityTween(
|
|
identifier: string,
|
|
toOpacity: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
const owner = this.owner;
|
|
if (!isOpaque(owner)) return;
|
|
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
owner.getOpacity(),
|
|
toOpacity,
|
|
getTweenObjectOpacitySetter(owner),
|
|
{
|
|
type: 'opacity',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween a numeric object effect property.
|
|
* @param effectBehavior Only used by events can be set to null
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toValue The targeted value
|
|
* @param effectName Effect name
|
|
* @param propertyName Property name
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addNumberEffectPropertyTween(
|
|
effectBehavior: any,
|
|
identifier: string,
|
|
toValue: float,
|
|
effectName: string,
|
|
propertyName: string,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
const effect = this.owner.getRendererEffects()[effectName];
|
|
if (!effect) {
|
|
logger.error(
|
|
`The object "${this.owner.name}" doesn't have any effect called "${effectName}"`
|
|
);
|
|
}
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
this.owner,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
effect ? effect.getDoubleParameter(propertyName) : 0,
|
|
toValue,
|
|
getTweenObjectNumberEffectPropertySetter(effect, propertyName),
|
|
{
|
|
type: 'numberEffectProperty',
|
|
effectName,
|
|
propertyName,
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween a color object effect property.
|
|
* @param effectBehavior Only used by events can be set to null
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toColorStr The target RGB color (format "128;200;255" with values between 0 and 255 for red, green and blue)
|
|
* @param effectName Effect name
|
|
* @param propertyName Property name
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addColorEffectPropertyTween(
|
|
effectBehavior: any,
|
|
identifier: string,
|
|
toColorStr: string,
|
|
effectName: string,
|
|
propertyName: string,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
const effect = this.owner.getRendererEffects()[effectName];
|
|
if (!effect) {
|
|
logger.error(
|
|
`The object "${this.owner.name}" doesn't have any effect called "${effectName}"`
|
|
);
|
|
}
|
|
const rgbFromColor = gdjs.hexNumberToRGB(
|
|
effect ? effect.getColorParameter(propertyName) : 0
|
|
);
|
|
const rgbToColor: float[] = gdjs.rgbOrHexToRGBColor(toColorStr);
|
|
|
|
this._tweens.addMultiTween(
|
|
identifier,
|
|
this.owner,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
gdjs.evtTools.tween.rgbToHsl(
|
|
rgbFromColor.r,
|
|
rgbFromColor.g,
|
|
rgbFromColor.b
|
|
),
|
|
gdjs.evtTools.tween.rgbToHsl(
|
|
rgbToColor[0],
|
|
rgbToColor[1],
|
|
rgbToColor[2]
|
|
),
|
|
getTweenObjectColorEffectPropertySetter(effect, propertyName),
|
|
{
|
|
type: 'colorEffectProperty',
|
|
effectName,
|
|
propertyName,
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object color.
|
|
* @deprecated Use addObjectColorTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toColorStr The target RGB color (format "128;200;255" with values between 0 and 255 for red, green and blue)
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
* @param useHSLColorTransition Tween using HSL color mappings, rather than direct RGB line
|
|
*/
|
|
addObjectColorTween(
|
|
identifier: string,
|
|
toColorStr: string,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
useHSLColorTransition: boolean
|
|
) {
|
|
this._addObjectColorTween(
|
|
identifier,
|
|
toColorStr,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
useHSLColorTransition,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object color.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toColorStr The target RGB color (format "128;200;255" with values between 0 and 255 for red, green and blue)
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
* @param useHSLColorTransition Tween using HSL color mappings, rather than direct RGB line
|
|
*/
|
|
addObjectColorTween2(
|
|
identifier: string,
|
|
toColorStr: string,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
useHSLColorTransition: boolean = true
|
|
) {
|
|
this._addObjectColorTween(
|
|
identifier,
|
|
toColorStr,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
useHSLColorTransition,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectColorTween(
|
|
identifier: string,
|
|
toColorStr: string,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
useHSLColorTransition: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
const owner = this.owner;
|
|
if (!isColorable(owner)) {
|
|
return;
|
|
}
|
|
|
|
const rgbFromColor: float[] = gdjs.rgbOrHexToRGBColor(owner.getColor());
|
|
const rgbToColor: float[] = gdjs.rgbOrHexToRGBColor(toColorStr);
|
|
|
|
const initialValue = useHSLColorTransition
|
|
? gdjs.evtTools.tween.rgbToHsl(
|
|
rgbFromColor[0],
|
|
rgbFromColor[1],
|
|
rgbFromColor[2]
|
|
)
|
|
: rgbFromColor;
|
|
const targetedValue = useHSLColorTransition
|
|
? gdjs.evtTools.tween.rgbToHsl(
|
|
rgbToColor[0],
|
|
rgbToColor[1],
|
|
rgbToColor[2]
|
|
)
|
|
: rgbToColor;
|
|
|
|
this._tweens.addMultiTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
initialValue,
|
|
targetedValue,
|
|
getTweenObjectColorSetter(owner, useHSLColorTransition),
|
|
{
|
|
type: 'objectColor',
|
|
useHSLColorTransition,
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object HSL color, with the "to" color given using HSL (H: any number, S and L: 0-100).
|
|
* @deprecated Use addObjectColorHSLTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toHue The target hue, or the same as the from color's hue if blank
|
|
* @param animateHue include hue in calculations, as can't set this to -1 as default to ignore
|
|
* @param toSaturation The target saturation, or the same as the from color's saturation if blank
|
|
* @param toLightness The target lightness, or the same as the from color's lightness if blank
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectColorHSLTween(
|
|
identifier: string,
|
|
toHue: number,
|
|
animateHue: boolean,
|
|
toSaturation: number,
|
|
toLightness: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectColorHSLTween(
|
|
identifier,
|
|
toHue,
|
|
animateHue,
|
|
toSaturation,
|
|
toLightness,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object HSL color, with the "to" color given using HSL (H: any number, S and L: 0-100).
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toHue The target hue, or the same as the from color's hue if blank
|
|
* @param animateHue include hue in calculations, as can't set this to -1 as default to ignore
|
|
* @param toSaturation The target saturation, or the same as the from color's saturation if blank
|
|
* @param toLightness The target lightness, or the same as the from color's lightness if blank
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectColorHSLTween2(
|
|
identifier: string,
|
|
toHue: number,
|
|
animateHue: boolean,
|
|
toSaturation: number,
|
|
toLightness: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectColorHSLTween(
|
|
identifier,
|
|
toHue,
|
|
animateHue,
|
|
toSaturation,
|
|
toLightness,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectColorHSLTween(
|
|
identifier: string,
|
|
toHue: number,
|
|
animateHue: boolean,
|
|
toSaturation: number,
|
|
toLightness: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
if (!isColorable(this.owner)) return;
|
|
const owner = this.owner;
|
|
|
|
const rgbFromColor = gdjs.rgbOrHexToRGBColor(owner.getColor());
|
|
const hslFromColor = gdjs.evtTools.tween.rgbToHsl(
|
|
rgbFromColor[0],
|
|
rgbFromColor[1],
|
|
rgbFromColor[2]
|
|
);
|
|
|
|
const toH = animateHue ? toHue : hslFromColor[0];
|
|
const toS =
|
|
-1 === toSaturation
|
|
? hslFromColor[1]
|
|
: Math.min(Math.max(toSaturation, 0), 100);
|
|
const toL =
|
|
-1 === toLightness
|
|
? hslFromColor[2]
|
|
: Math.min(Math.max(toLightness, 0), 100);
|
|
|
|
this._tweens.addMultiTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
hslFromColor,
|
|
[toH, toS, toL],
|
|
getTweenObjectColorHSLSetter(owner),
|
|
{
|
|
type: 'objectColorHSL',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween a text object character size.
|
|
* @deprecated Use addTextObjectCharacterSizeTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toSize The target character size
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addTextObjectCharacterSizeTween(
|
|
identifier: string,
|
|
toSize: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addTextObjectCharacterSizeTween(
|
|
identifier,
|
|
toSize,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene(),
|
|
linearInterpolation
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween a text object character size.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toSize The target character size
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addTextObjectCharacterSizeTween2(
|
|
identifier: string,
|
|
toSize: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addTextObjectCharacterSizeTween(
|
|
identifier,
|
|
toSize,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner,
|
|
exponentialInterpolation
|
|
);
|
|
}
|
|
|
|
private _addTextObjectCharacterSizeTween(
|
|
identifier: string,
|
|
toSize: number,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource,
|
|
interpolation: gdjs.evtTools.tween.Interpolation
|
|
) {
|
|
const owner = this.owner;
|
|
if (!isCharacterScalable(owner)) return;
|
|
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
interpolation,
|
|
owner.getCharacterSize(),
|
|
toSize,
|
|
getTweenObjectCharacterSizeSetter(owner),
|
|
{
|
|
type: 'characterSize',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object width.
|
|
* @deprecated Use addObjectWidthTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toWidth The target width
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectWidthTween(
|
|
identifier: string,
|
|
toWidth: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectWidthTween(
|
|
identifier,
|
|
toWidth,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object width.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toWidth The target width
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectWidthTween2(
|
|
identifier: string,
|
|
toWidth: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectWidthTween(
|
|
identifier,
|
|
toWidth,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectWidthTween(
|
|
identifier: string,
|
|
toWidth: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
this.owner.getWidth(),
|
|
toWidth,
|
|
getTweenObjectWidthSetter(this.owner),
|
|
{
|
|
type: 'width',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object height.
|
|
* @deprecated Use addObjectHeightTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toHeight The target height
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectHeightTween(
|
|
identifier: string,
|
|
toHeight: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectHeightTween(
|
|
identifier,
|
|
toHeight,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object height.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toHeight The target height
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectHeightTween2(
|
|
identifier: string,
|
|
toHeight: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectHeightTween(
|
|
identifier,
|
|
toHeight,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectHeightTween(
|
|
identifier: string,
|
|
toHeight: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
this.owner.getHeight(),
|
|
toHeight,
|
|
getTweenObjectHeightSetter(this.owner),
|
|
{
|
|
type: 'height',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object depth.
|
|
* @deprecated Use addObjectDepthTween2 instead.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toDepth The target depth
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in milliseconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectDepthTween(
|
|
identifier: string,
|
|
toDepth: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectDepthTween(
|
|
identifier,
|
|
toDepth,
|
|
easing,
|
|
duration / 1000,
|
|
destroyObjectWhenFinished,
|
|
this.owner.getRuntimeScene()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween an object depth.
|
|
* @param object3DBehavior Only used by events can be set to null
|
|
* @param identifier Unique id to identify the tween
|
|
* @param toDepth The target depth
|
|
* @param easing Easing function identifier
|
|
* @param duration Duration in seconds
|
|
* @param destroyObjectWhenFinished Destroy this object when the tween ends
|
|
*/
|
|
addObjectDepthTween2(
|
|
object3DBehavior: any,
|
|
identifier: string,
|
|
toDepth: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean
|
|
) {
|
|
this._addObjectDepthTween(
|
|
identifier,
|
|
toDepth,
|
|
easing,
|
|
duration,
|
|
destroyObjectWhenFinished,
|
|
this.owner
|
|
);
|
|
}
|
|
|
|
private _addObjectDepthTween(
|
|
identifier: string,
|
|
toDepth: float,
|
|
easing: string,
|
|
duration: float,
|
|
destroyObjectWhenFinished: boolean,
|
|
timeSource: gdjs.evtTools.tween.TimeSource
|
|
) {
|
|
const { owner } = this;
|
|
if (!is3D(owner)) return;
|
|
|
|
this._tweens.addSimpleTween(
|
|
identifier,
|
|
timeSource,
|
|
duration,
|
|
easing,
|
|
linearInterpolation,
|
|
owner.getDepth(),
|
|
toDepth,
|
|
getTweenObjectDepthSetter(owner),
|
|
{
|
|
type: 'depth',
|
|
destroyObjectWhenFinished,
|
|
},
|
|
destroyObjectWhenFinished ? () => this._deleteFromScene() : null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Tween is playing.
|
|
* @param identifier Unique id to identify the tween
|
|
*/
|
|
isPlaying(identifier: string): boolean {
|
|
return this._tweens.isPlaying(identifier);
|
|
}
|
|
|
|
/**
|
|
* Tween exists.
|
|
* @param identifier Unique id to identify the tween
|
|
* @returns The tween exists
|
|
*/
|
|
exists(identifier: string): boolean {
|
|
return this._tweens.exists(identifier);
|
|
}
|
|
|
|
/**
|
|
* Tween has finished.
|
|
* @param identifier Unique id to identify the tween
|
|
*/
|
|
hasFinished(identifier: string): boolean {
|
|
return this._tweens.hasFinished(identifier);
|
|
}
|
|
|
|
/**
|
|
* Pause a tween.
|
|
* @param identifier Unique id to identify the tween
|
|
*/
|
|
pauseTween(identifier: string) {
|
|
if (this._isActive) {
|
|
this._tweens.pauseTween(identifier);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stop a tween.
|
|
* @param identifier Unique id to identify the tween
|
|
* @param jumpToDest Move to destination
|
|
*/
|
|
stopTween(identifier: string, jumpToDest: boolean) {
|
|
if (this._isActive) {
|
|
this._tweens.stopTween(identifier, jumpToDest);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resume a tween.
|
|
* @param identifier Unique id to identify the tween
|
|
*/
|
|
resumeTween(identifier: string) {
|
|
if (this._isActive) {
|
|
this._tweens.resumeTween(identifier);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove a tween.
|
|
* @param identifier Unique id to identify the tween
|
|
*/
|
|
removeTween(identifier: string) {
|
|
this._tweens.removeTween(identifier);
|
|
}
|
|
|
|
/**
|
|
* Get tween progress.
|
|
* @param identifier Unique id to identify the tween
|
|
* @returns Progress of playing tween animation (between 0.0 and 1.0)
|
|
*/
|
|
getProgress(identifier: string): float {
|
|
return this._tweens.getProgress(identifier);
|
|
}
|
|
|
|
/**
|
|
* Get tween value.
|
|
*
|
|
* It returns 0 for tweens with several values.
|
|
*
|
|
* @param identifier Unique id to identify the tween
|
|
* @returns Value of playing tween animation
|
|
*/
|
|
getValue(identifier: string): float {
|
|
return this._tweens.getValue(identifier);
|
|
}
|
|
|
|
onDeActivate() {
|
|
this._isActive = false;
|
|
}
|
|
|
|
onActivate() {
|
|
this._isActive = true;
|
|
}
|
|
}
|
|
gdjs.registerBehavior('Tween::TweenBehavior', gdjs.TweenRuntimeBehavior);
|
|
}
|