@dcl/ecs 7.10.5 → 7.10.6-18360040798.commit-8d5d559

package/dist/components/extended/Tween.d.ts

@@ -1,5 +1,6 @@
-import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
-import { PBTween, Move, Rotate, Scale, TextureMove } from '../generated/index.gen';
+import { Entity, IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
+import { Quaternion, Vector2, Vector3 } from '../generated/pb/decentraland/common/vectors.gen';
+import { EasingFunction, Move, MoveContinuous, PBTween, Rotate, RotateContinuous, Scale, TextureMove, TextureMoveContinuous, TextureMovementType } from '../generated/index.gen';
 /**
  * @public
  */
@@ -9,17 +10,29 @@ export interface TweenHelper {
      */
     Move: (move: Move) => PBTween['mode'];
     /**
-     * @returns a move mode tween
+     * @returns a move-continuous mode tween
+     */
+    MoveContinuous: (move: MoveContinuous) => PBTween['mode'];
+    /**
+     * @returns a rotate mode tween
      */
     Rotate: (rotate: Rotate) => PBTween['mode'];
     /**
-     * @returns a move mode tween
+     * @returns a rotate-continuous mode tween
+     */
+    RotateContinuous: (rotate: RotateContinuous) => PBTween['mode'];
+    /**
+     * @returns a scale mode tween
      */
     Scale: (scale: Scale) => PBTween['mode'];
     /**
-     * @returns a texture move mode tween
+     * @returns a texture-move mode tween
      */
     TextureMove: (textureMove: TextureMove) => PBTween['mode'];
+    /**
+     * @returns a texture-move-continuous mode tween
+     */
+    TextureMoveContinuous: (textureMove: TextureMoveContinuous) => PBTween['mode'];
 }
 /**
  * @public
@@ -29,5 +42,81 @@ export interface TweenComponentDefinitionExtended extends LastWriteWinElementSet
      * Texture helpers with constructor
      */
     Mode: TweenHelper;
+    /**
+     * @public
+     *
+     * Creates or replaces a move tween component that animates an entity's position from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting position vector
+     * @param end - ending position vector
+     * @param duration - duration of the tween in seconds
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setMove(entity: Entity, start: Vector3, end: Vector3, duration: number, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a scale tween component that animates an entity's scale from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting scale vector
+     * @param end - ending scale vector
+     * @param duration - duration of the tween in seconds
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setScale(entity: Entity, start: Vector3, end: Vector3, duration: number, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a rotation tween component that animates an entity's rotation from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting rotation quaternion
+     * @param end - ending rotation quaternion
+     * @param duration - duration of the tween in seconds
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setRotate(entity: Entity, start: Quaternion, end: Quaternion, duration: number, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a texture move tween component that animates texture UV coordinates from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting UV coordinates
+     * @param end - ending UV coordinates
+     * @param duration - duration of the tween in seconds
+     * @param movementType - type of texture movement (defaults to TMT_OFFSET)
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setTextureMove(entity: Entity, start: Vector2, end: Vector2, duration: number, movementType?: TextureMovementType, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a continuous move tween component that moves an entity continuously in a direction
+     * @param entity - entity to apply the tween to
+     * @param direction - direction vector to move towards
+     * @param speed - speed of movement per second
+     * @param duration - duration of the tween in seconds (defaults to 0 for infinite)
+     */
+    setMoveContinuous(entity: Entity, direction: Vector3, speed: number, duration?: number): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a continuous rotation tween component that rotates an entity continuously
+     * @param entity - entity to apply the tween to
+     * @param direction - rotation direction quaternion
+     * @param speed - speed of rotation per second
+     * @param duration - duration of the tween in seconds (defaults to 0 for infinite)
+     */
+    setRotateContinuous(entity: Entity, direction: Quaternion, speed: number, duration?: number): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a continuous texture move tween component that moves texture UV coordinates continuously
+     * @param entity - entity to apply the tween to
+     * @param direction - direction vector for UV movement
+     * @param speed - speed of UV movement per second
+     * @param movementType - type of texture movement (defaults to TMT_OFFSET)
+     * @param duration - duration of the tween in seconds (defaults to 0 for infinite)
+     */
+    setTextureMoveContinuous(entity: Entity, direction: Vector2, speed: number, movementType?: TextureMovementType, duration?: number): void;
 }
 export declare function defineTweenComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): TweenComponentDefinitionExtended;

package/dist/components/extended/Tween.js

@@ -6,12 +6,24 @@ const TweenHelper = {
             move
         };
     },
+    MoveContinuous(moveContinuous) {
+        return {
+            $case: 'moveContinuous',
+            moveContinuous
+        };
+    },
     Rotate(rotate) {
         return {
             $case: 'rotate',
             rotate
         };
     },
+    RotateContinuous(rotateContinuous) {
+        return {
+            $case: 'rotateContinuous',
+            rotateContinuous
+        };
+    },
     Scale(scale) {
         return {
             $case: 'scale',
@@ -23,12 +35,118 @@ const TweenHelper = {
             $case: 'textureMove',
             textureMove
         };
+    },
+    TextureMoveContinuous(textureMoveContinuous) {
+        return {
+            $case: 'textureMoveContinuous',
+            textureMoveContinuous
+        };
     }
 };
 export function defineTweenComponent(engine) {
     const theComponent = Tween(engine);
     return {
         ...theComponent,
-        Mode: TweenHelper
+        Mode: TweenHelper,
+        setMove(entity, start, end, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'move',
+                    move: {
+                        start,
+                        end
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setScale(entity, start, end, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'scale',
+                    scale: {
+                        start,
+                        end
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setRotate(entity, start, end, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'rotate',
+                    rotate: {
+                        start,
+                        end
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setTextureMove(entity, start, end, duration, movementType = 0 /* TextureMovementType.TMT_OFFSET */, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'textureMove',
+                    textureMove: {
+                        start,
+                        end,
+                        movementType
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setMoveContinuous(entity, direction, speed, duration = 0) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'moveContinuous',
+                    moveContinuous: {
+                        direction,
+                        speed
+                    }
+                },
+                duration,
+                easingFunction: 0 /* EasingFunction.EF_LINEAR */,
+                playing: true
+            });
+        },
+        setRotateContinuous(entity, direction, speed, duration = 0) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'rotateContinuous',
+                    rotateContinuous: {
+                        direction,
+                        speed
+                    }
+                },
+                duration,
+                easingFunction: 0 /* EasingFunction.EF_LINEAR */,
+                playing: true
+            });
+        },
+        setTextureMoveContinuous(entity, direction, speed, movementType = 0 /* TextureMovementType.TMT_OFFSET */, duration = 0) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'textureMoveContinuous',
+                    textureMoveContinuous: {
+                        direction,
+                        speed,
+                        movementType
+                    }
+                },
+                duration,
+                easingFunction: 0 /* EasingFunction.EF_LINEAR */,
+                playing: true
+            });
+        }
     };
 }

package/dist/components/generated/pb/decentraland/sdk/components/tween.gen.d.ts

@@ -68,6 +68,15 @@ export interface PBTween {
     } | {
         $case: "textureMove";
         textureMove: TextureMove;
+    } | {
+        $case: "rotateContinuous";
+        rotateContinuous: RotateContinuous;
+    } | {
+        $case: "moveContinuous";
+        moveContinuous: MoveContinuous;
+    } | {
+        $case: "textureMoveContinuous";
+        textureMoveContinuous: TextureMoveContinuous;
     } | undefined;
     /** default true (pause or running) */
     playing?: boolean | undefined;
@@ -109,6 +118,29 @@ export interface TextureMove {
     /** default = TextureMovementType.TMT_OFFSET */
     movementType?: TextureMovementType | undefined;
 }
+/**
+ * @public
+ */
+export interface RotateContinuous {
+    direction: Quaternion | undefined;
+    speed: number;
+}
+/**
+ * @public
+ */
+export interface MoveContinuous {
+    direction: Vector3 | undefined;
+    speed: number;
+}
+/**
+ * @public
+ */
+export interface TextureMoveContinuous {
+    direction: Vector2 | undefined;
+    speed: number;
+    /** default = TextureMovementType.TMT_OFFSET */
+    movementType?: TextureMovementType | undefined;
+}
 /**
  * @public
  */
@@ -144,3 +176,24 @@ export declare namespace TextureMove {
     function encode(message: TextureMove, writer?: _m0.Writer): _m0.Writer;
     function decode(input: _m0.Reader | Uint8Array, length?: number): TextureMove;
 }
+/**
+ * @public
+ */
+export declare namespace RotateContinuous {
+    function encode(message: RotateContinuous, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): RotateContinuous;
+}
+/**
+ * @public
+ */
+export declare namespace MoveContinuous {
+    function encode(message: MoveContinuous, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): MoveContinuous;
+}
+/**
+ * @public
+ */
+export declare namespace TextureMoveContinuous {
+    function encode(message: TextureMoveContinuous, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): TextureMoveContinuous;
+}

package/dist/components/generated/pb/decentraland/sdk/components/tween.gen.js

@@ -81,6 +81,15 @@ export var PBTween;
             case "textureMove":
                 TextureMove.encode(message.mode.textureMove, writer.uint32(66).fork()).ldelim();
                 break;
+            case "rotateContinuous":
+                RotateContinuous.encode(message.mode.rotateContinuous, writer.uint32(74).fork()).ldelim();
+                break;
+            case "moveContinuous":
+                MoveContinuous.encode(message.mode.moveContinuous, writer.uint32(82).fork()).ldelim();
+                break;
+            case "textureMoveContinuous":
+                TextureMoveContinuous.encode(message.mode.textureMoveContinuous, writer.uint32(90).fork()).ldelim();
+                break;
         }
         if (message.playing !== undefined) {
             writer.uint32(48).bool(message.playing);
@@ -134,6 +143,30 @@ export var PBTween;
                     }
                     message.mode = { $case: "textureMove", textureMove: TextureMove.decode(reader, reader.uint32()) };
                     continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.mode = {
+                        $case: "rotateContinuous",
+                        rotateContinuous: RotateContinuous.decode(reader, reader.uint32()),
+                    };
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.mode = { $case: "moveContinuous", moveContinuous: MoveContinuous.decode(reader, reader.uint32()) };
+                    continue;
+                case 11:
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.mode = {
+                        $case: "textureMoveContinuous",
+                        textureMoveContinuous: TextureMoveContinuous.decode(reader, reader.uint32()),
+                    };
+                    continue;
                 case 6:
                     if (tag !== 48) {
                         break;
@@ -362,3 +395,153 @@ export var TextureMove;
     }
     TextureMove.decode = decode;
 })(TextureMove || (TextureMove = {}));
+function createBaseRotateContinuous() {
+    return { direction: undefined, speed: 0 };
+}
+/**
+ * @public
+ */
+export var RotateContinuous;
+(function (RotateContinuous) {
+    function encode(message, writer = _m0.Writer.create()) {
+        if (message.direction !== undefined) {
+            Quaternion.encode(message.direction, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.speed !== 0) {
+            writer.uint32(21).float(message.speed);
+        }
+        return writer;
+    }
+    RotateContinuous.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRotateContinuous();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.direction = Quaternion.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.speed = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    RotateContinuous.decode = decode;
+})(RotateContinuous || (RotateContinuous = {}));
+function createBaseMoveContinuous() {
+    return { direction: undefined, speed: 0 };
+}
+/**
+ * @public
+ */
+export var MoveContinuous;
+(function (MoveContinuous) {
+    function encode(message, writer = _m0.Writer.create()) {
+        if (message.direction !== undefined) {
+            Vector3.encode(message.direction, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.speed !== 0) {
+            writer.uint32(21).float(message.speed);
+        }
+        return writer;
+    }
+    MoveContinuous.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMoveContinuous();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.direction = Vector3.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.speed = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    MoveContinuous.decode = decode;
+})(MoveContinuous || (MoveContinuous = {}));
+function createBaseTextureMoveContinuous() {
+    return { direction: undefined, speed: 0, movementType: undefined };
+}
+/**
+ * @public
+ */
+export var TextureMoveContinuous;
+(function (TextureMoveContinuous) {
+    function encode(message, writer = _m0.Writer.create()) {
+        if (message.direction !== undefined) {
+            Vector2.encode(message.direction, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.speed !== 0) {
+            writer.uint32(21).float(message.speed);
+        }
+        if (message.movementType !== undefined) {
+            writer.uint32(24).int32(message.movementType);
+        }
+        return writer;
+    }
+    TextureMoveContinuous.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTextureMoveContinuous();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.direction = Vector2.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.speed = reader.float();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.movementType = reader.int32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    TextureMoveContinuous.decode = decode;
+})(TextureMoveContinuous || (TextureMoveContinuous = {}));

package/dist-cjs/components/extended/Tween.d.ts

@@ -1,5 +1,6 @@
-import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
-import { PBTween, Move, Rotate, Scale, TextureMove } from '../generated/index.gen';
+import { Entity, IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
+import { Quaternion, Vector2, Vector3 } from '../generated/pb/decentraland/common/vectors.gen';
+import { EasingFunction, Move, MoveContinuous, PBTween, Rotate, RotateContinuous, Scale, TextureMove, TextureMoveContinuous, TextureMovementType } from '../generated/index.gen';
 /**
  * @public
  */
@@ -9,17 +10,29 @@ export interface TweenHelper {
      */
     Move: (move: Move) => PBTween['mode'];
     /**
-     * @returns a move mode tween
+     * @returns a move-continuous mode tween
+     */
+    MoveContinuous: (move: MoveContinuous) => PBTween['mode'];
+    /**
+     * @returns a rotate mode tween
      */
     Rotate: (rotate: Rotate) => PBTween['mode'];
     /**
-     * @returns a move mode tween
+     * @returns a rotate-continuous mode tween
+     */
+    RotateContinuous: (rotate: RotateContinuous) => PBTween['mode'];
+    /**
+     * @returns a scale mode tween
      */
     Scale: (scale: Scale) => PBTween['mode'];
     /**
-     * @returns a texture move mode tween
+     * @returns a texture-move mode tween
      */
     TextureMove: (textureMove: TextureMove) => PBTween['mode'];
+    /**
+     * @returns a texture-move-continuous mode tween
+     */
+    TextureMoveContinuous: (textureMove: TextureMoveContinuous) => PBTween['mode'];
 }
 /**
  * @public
@@ -29,5 +42,81 @@ export interface TweenComponentDefinitionExtended extends LastWriteWinElementSet
      * Texture helpers with constructor
      */
     Mode: TweenHelper;
+    /**
+     * @public
+     *
+     * Creates or replaces a move tween component that animates an entity's position from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting position vector
+     * @param end - ending position vector
+     * @param duration - duration of the tween in seconds
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setMove(entity: Entity, start: Vector3, end: Vector3, duration: number, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a scale tween component that animates an entity's scale from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting scale vector
+     * @param end - ending scale vector
+     * @param duration - duration of the tween in seconds
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setScale(entity: Entity, start: Vector3, end: Vector3, duration: number, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a rotation tween component that animates an entity's rotation from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting rotation quaternion
+     * @param end - ending rotation quaternion
+     * @param duration - duration of the tween in seconds
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setRotate(entity: Entity, start: Quaternion, end: Quaternion, duration: number, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a texture move tween component that animates texture UV coordinates from start to end
+     * @param entity - entity to apply the tween to
+     * @param start - starting UV coordinates
+     * @param end - ending UV coordinates
+     * @param duration - duration of the tween in seconds
+     * @param movementType - type of texture movement (defaults to TMT_OFFSET)
+     * @param easingFunction - easing function to use (defaults to EF_LINEAR)
+     */
+    setTextureMove(entity: Entity, start: Vector2, end: Vector2, duration: number, movementType?: TextureMovementType, easingFunction?: EasingFunction): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a continuous move tween component that moves an entity continuously in a direction
+     * @param entity - entity to apply the tween to
+     * @param direction - direction vector to move towards
+     * @param speed - speed of movement per second
+     * @param duration - duration of the tween in seconds (defaults to 0 for infinite)
+     */
+    setMoveContinuous(entity: Entity, direction: Vector3, speed: number, duration?: number): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a continuous rotation tween component that rotates an entity continuously
+     * @param entity - entity to apply the tween to
+     * @param direction - rotation direction quaternion
+     * @param speed - speed of rotation per second
+     * @param duration - duration of the tween in seconds (defaults to 0 for infinite)
+     */
+    setRotateContinuous(entity: Entity, direction: Quaternion, speed: number, duration?: number): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a continuous texture move tween component that moves texture UV coordinates continuously
+     * @param entity - entity to apply the tween to
+     * @param direction - direction vector for UV movement
+     * @param speed - speed of UV movement per second
+     * @param movementType - type of texture movement (defaults to TMT_OFFSET)
+     * @param duration - duration of the tween in seconds (defaults to 0 for infinite)
+     */
+    setTextureMoveContinuous(entity: Entity, direction: Vector2, speed: number, movementType?: TextureMovementType, duration?: number): void;
 }
 export declare function defineTweenComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): TweenComponentDefinitionExtended;

package/dist-cjs/components/extended/Tween.js

@@ -9,12 +9,24 @@ const TweenHelper = {
             move
         };
     },
+    MoveContinuous(moveContinuous) {
+        return {
+            $case: 'moveContinuous',
+            moveContinuous
+        };
+    },
     Rotate(rotate) {
         return {
             $case: 'rotate',
             rotate
         };
     },
+    RotateContinuous(rotateContinuous) {
+        return {
+            $case: 'rotateContinuous',
+            rotateContinuous
+        };
+    },
     Scale(scale) {
         return {
             $case: 'scale',
@@ -26,13 +38,119 @@ const TweenHelper = {
             $case: 'textureMove',
             textureMove
         };
+    },
+    TextureMoveContinuous(textureMoveContinuous) {
+        return {
+            $case: 'textureMoveContinuous',
+            textureMoveContinuous
+        };
     }
 };
 function defineTweenComponent(engine) {
     const theComponent = (0, index_gen_1.Tween)(engine);
     return {
         ...theComponent,
-        Mode: TweenHelper
+        Mode: TweenHelper,
+        setMove(entity, start, end, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'move',
+                    move: {
+                        start,
+                        end
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setScale(entity, start, end, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'scale',
+                    scale: {
+                        start,
+                        end
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setRotate(entity, start, end, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'rotate',
+                    rotate: {
+                        start,
+                        end
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setTextureMove(entity, start, end, duration, movementType = 0 /* TextureMovementType.TMT_OFFSET */, easingFunction = 0 /* EasingFunction.EF_LINEAR */) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'textureMove',
+                    textureMove: {
+                        start,
+                        end,
+                        movementType
+                    }
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
+        },
+        setMoveContinuous(entity, direction, speed, duration = 0) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'moveContinuous',
+                    moveContinuous: {
+                        direction,
+                        speed
+                    }
+                },
+                duration,
+                easingFunction: 0 /* EasingFunction.EF_LINEAR */,
+                playing: true
+            });
+        },
+        setRotateContinuous(entity, direction, speed, duration = 0) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'rotateContinuous',
+                    rotateContinuous: {
+                        direction,
+                        speed
+                    }
+                },
+                duration,
+                easingFunction: 0 /* EasingFunction.EF_LINEAR */,
+                playing: true
+            });
+        },
+        setTextureMoveContinuous(entity, direction, speed, movementType = 0 /* TextureMovementType.TMT_OFFSET */, duration = 0) {
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'textureMoveContinuous',
+                    textureMoveContinuous: {
+                        direction,
+                        speed,
+                        movementType
+                    }
+                },
+                duration,
+                easingFunction: 0 /* EasingFunction.EF_LINEAR */,
+                playing: true
+            });
+        }
     };
 }
 exports.defineTweenComponent = defineTweenComponent;

package/dist-cjs/components/generated/pb/decentraland/sdk/components/tween.gen.d.ts

@@ -68,6 +68,15 @@ export interface PBTween {
     } | {
         $case: "textureMove";
         textureMove: TextureMove;
+    } | {
+        $case: "rotateContinuous";
+        rotateContinuous: RotateContinuous;
+    } | {
+        $case: "moveContinuous";
+        moveContinuous: MoveContinuous;
+    } | {
+        $case: "textureMoveContinuous";
+        textureMoveContinuous: TextureMoveContinuous;
     } | undefined;
     /** default true (pause or running) */
     playing?: boolean | undefined;
@@ -109,6 +118,29 @@ export interface TextureMove {
     /** default = TextureMovementType.TMT_OFFSET */
     movementType?: TextureMovementType | undefined;
 }
+/**
+ * @public
+ */
+export interface RotateContinuous {
+    direction: Quaternion | undefined;
+    speed: number;
+}
+/**
+ * @public
+ */
+export interface MoveContinuous {
+    direction: Vector3 | undefined;
+    speed: number;
+}
+/**
+ * @public
+ */
+export interface TextureMoveContinuous {
+    direction: Vector2 | undefined;
+    speed: number;
+    /** default = TextureMovementType.TMT_OFFSET */
+    movementType?: TextureMovementType | undefined;
+}
 /**
  * @public
  */
@@ -144,3 +176,24 @@ export declare namespace TextureMove {
     function encode(message: TextureMove, writer?: _m0.Writer): _m0.Writer;
     function decode(input: _m0.Reader | Uint8Array, length?: number): TextureMove;
 }
+/**
+ * @public
+ */
+export declare namespace RotateContinuous {
+    function encode(message: RotateContinuous, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): RotateContinuous;
+}
+/**
+ * @public
+ */
+export declare namespace MoveContinuous {
+    function encode(message: MoveContinuous, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): MoveContinuous;
+}
+/**
+ * @public
+ */
+export declare namespace TextureMoveContinuous {
+    function encode(message: TextureMoveContinuous, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): TextureMoveContinuous;
+}

package/dist-cjs/components/generated/pb/decentraland/sdk/components/tween.gen.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextureMove = exports.Scale = exports.Rotate = exports.Move = exports.PBTween = exports.EasingFunction = exports.TextureMovementType = void 0;
+exports.TextureMoveContinuous = exports.MoveContinuous = exports.RotateContinuous = exports.TextureMove = exports.Scale = exports.Rotate = exports.Move = exports.PBTween = exports.EasingFunction = exports.TextureMovementType = void 0;
 /* eslint-disable */
 const minimal_1 = __importDefault(require("protobufjs/minimal"));
 const vectors_gen_1 = require("../../common/vectors.gen");
@@ -87,6 +87,15 @@ var PBTween;
             case "textureMove":
                 TextureMove.encode(message.mode.textureMove, writer.uint32(66).fork()).ldelim();
                 break;
+            case "rotateContinuous":
+                RotateContinuous.encode(message.mode.rotateContinuous, writer.uint32(74).fork()).ldelim();
+                break;
+            case "moveContinuous":
+                MoveContinuous.encode(message.mode.moveContinuous, writer.uint32(82).fork()).ldelim();
+                break;
+            case "textureMoveContinuous":
+                TextureMoveContinuous.encode(message.mode.textureMoveContinuous, writer.uint32(90).fork()).ldelim();
+                break;
         }
         if (message.playing !== undefined) {
             writer.uint32(48).bool(message.playing);
@@ -140,6 +149,30 @@ var PBTween;
                     }
                     message.mode = { $case: "textureMove", textureMove: TextureMove.decode(reader, reader.uint32()) };
                     continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.mode = {
+                        $case: "rotateContinuous",
+                        rotateContinuous: RotateContinuous.decode(reader, reader.uint32()),
+                    };
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.mode = { $case: "moveContinuous", moveContinuous: MoveContinuous.decode(reader, reader.uint32()) };
+                    continue;
+                case 11:
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.mode = {
+                        $case: "textureMoveContinuous",
+                        textureMoveContinuous: TextureMoveContinuous.decode(reader, reader.uint32()),
+                    };
+                    continue;
                 case 6:
                     if (tag !== 48) {
                         break;
@@ -368,3 +401,153 @@ var TextureMove;
     }
     TextureMove.decode = decode;
 })(TextureMove = exports.TextureMove || (exports.TextureMove = {}));
+function createBaseRotateContinuous() {
+    return { direction: undefined, speed: 0 };
+}
+/**
+ * @public
+ */
+var RotateContinuous;
+(function (RotateContinuous) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.direction !== undefined) {
+            vectors_gen_1.Quaternion.encode(message.direction, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.speed !== 0) {
+            writer.uint32(21).float(message.speed);
+        }
+        return writer;
+    }
+    RotateContinuous.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRotateContinuous();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.direction = vectors_gen_1.Quaternion.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.speed = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    RotateContinuous.decode = decode;
+})(RotateContinuous = exports.RotateContinuous || (exports.RotateContinuous = {}));
+function createBaseMoveContinuous() {
+    return { direction: undefined, speed: 0 };
+}
+/**
+ * @public
+ */
+var MoveContinuous;
+(function (MoveContinuous) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.direction !== undefined) {
+            vectors_gen_1.Vector3.encode(message.direction, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.speed !== 0) {
+            writer.uint32(21).float(message.speed);
+        }
+        return writer;
+    }
+    MoveContinuous.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMoveContinuous();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.direction = vectors_gen_1.Vector3.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.speed = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    MoveContinuous.decode = decode;
+})(MoveContinuous = exports.MoveContinuous || (exports.MoveContinuous = {}));
+function createBaseTextureMoveContinuous() {
+    return { direction: undefined, speed: 0, movementType: undefined };
+}
+/**
+ * @public
+ */
+var TextureMoveContinuous;
+(function (TextureMoveContinuous) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.direction !== undefined) {
+            vectors_gen_1.Vector2.encode(message.direction, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.speed !== 0) {
+            writer.uint32(21).float(message.speed);
+        }
+        if (message.movementType !== undefined) {
+            writer.uint32(24).int32(message.movementType);
+        }
+        return writer;
+    }
+    TextureMoveContinuous.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTextureMoveContinuous();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.direction = vectors_gen_1.Vector2.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.speed = reader.float();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.movementType = reader.int32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    TextureMoveContinuous.decode = decode;
+})(TextureMoveContinuous = exports.TextureMoveContinuous || (exports.TextureMoveContinuous = {}));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.10.5",
+  "version": "7.10.6-18360040798.commit-8d5d559",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "files": [
@@ -33,5 +33,5 @@
   },
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "e0bb8d6f8ff5e9b69ba25bf8309a0b36a7f48d61"
+  "commit": "8d5d5591584187301bc3522264432b3e7d7ab38f"
 }