@dcl/ecs 7.21.1-22917715332.commit-e5d969d → 7.21.1-23203004012.commit-7c64ac2

package/dist/systems/events.d.ts

@@ -18,12 +18,6 @@ export type EventSystemOptions = {
     showHighlight?: boolean;
     maxPlayerDistance?: number;
 };
-/**
- * @public
- */
-export type EventSystemOptionsCallback = EventSystemOptions & {
-    cb: EventSystemCallback;
-};
 export declare const getDefaultOpts: (opts?: Partial<EventSystemOptions>) => EventSystemOptions;
 /**
  * @public
@@ -53,37 +47,11 @@ export interface PointerEventsSystem {
      * @param entity - Entity where the callback was attached
      */
     removeOnPointerHoverLeave(entity: Entity): void;
-    /**
-     * @public
-     * Remove the callback for onPointerDrag event
-     * @param entity - Entity where the callback was attached
-     */
-    removeOnPointerDrag(entity: Entity): void;
-    /**
-     * @public
-     * Remove the callback for onPointerDragLocked event
-     * @param entity - Entity where the callback was attached
-     */
-    removeOnPointerDragLocked(entity: Entity): void;
-    /**
-     * @public
-     * Remove the callback for onPointerDragEnd event
-     * @param entity - Entity where the callback was attached
-     */
-    removeOnPointerDragEnd(entity: Entity): void;
-    /**
-     * @public
-     * Execute callbacks when the user presses one of the InputButtons pointing at the entity
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
-     */
-    onPointerDown(pointerData: {
-        entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
     /**
      * @public
      * Execute callback when the user press the InputButton pointing at the entity
      * @param pointerData - Entity to attach the callback, Opts to trigger Feedback and Button
+     * @param cb - Function to execute when click fires
      */
     onPointerDown(pointerData: {
         entity: Entity;
@@ -96,15 +64,6 @@ export interface PointerEventsSystem {
      * @param opts - Opts to trigger Feedback and Button
      */
     onPointerDown(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void;
-    /**
-     * @public
-     * Execute callbacks when the user releases one of the InputButtons pointing at the entity
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
-     */
-    onPointerUp(pointerData: {
-        entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
     /**
      * @public
      * Execute callback when the user releases the InputButton pointing at the entity
@@ -142,64 +101,6 @@ export interface PointerEventsSystem {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;
-    /**
-     * @public
-     * Execute callbacks when the user drags the pointer from inside the entity
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
-     */
-    onPointerDrag(pointerData: {
-        entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
-    /**
-     * @public
-     * Execute callback when the user clicks and drags the pointer from inside the entity
-     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
-     * @param cb - Function to execute when click fires
-     */
-    onPointerDrag(pointerData: {
-        entity: Entity;
-        opts?: Partial<EventSystemOptions>;
-    }, cb: EventSystemCallback): void;
-    /**
-     * @public
-     * Execute callbacks when the user drags the pointer from inside the entity, locking the cursor in place.
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
-     */
-    onPointerDragLocked(pointerData: {
-        entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
-    /**
-     * @public
-     * Execute callback when the user clicks and drags the pointer from inside the entity,
-     * locking the cursor in place
-     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
-     * @param cb - Function to execute when click fires
-     */
-    onPointerDragLocked(pointerData: {
-        entity: Entity;
-        opts?: Partial<EventSystemOptions>;
-    }, cb: EventSystemCallback): void;
-    /**
-     * @public
-     * Execute callbacks when the user releases a button after a drag
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
-     */
-    onPointerDragEnd(pointerData: {
-        entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
-    /**
-     * @public
-     * Execute callback when the user releases the button after a drag
-     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
-     * @param cb - Function to execute when click fires
-     */
-    onPointerDragEnd(pointerData: {
-        entity: Entity;
-        opts?: Partial<EventSystemOptions>;
-    }, cb: EventSystemCallback): void;
 }
 /**
  * @public

package/dist/systems/events.js

@@ -18,9 +18,6 @@ export function createPointerEventsSystem(engine, inputSystem) {
         EventType[EventType["Up"] = 2] = "Up";
         EventType[EventType["HoverEnter"] = 3] = "HoverEnter";
         EventType[EventType["HoverLeave"] = 4] = "HoverLeave";
-        EventType[EventType["Drag"] = 5] = "Drag";
-        EventType[EventType["DragLocked"] = 6] = "DragLocked";
-        EventType[EventType["DragEnd"] = 7] = "DragEnd";
     })(EventType || (EventType = {}));
     const eventsMap = new Map();
     function getEvent(entity) {
@@ -56,148 +53,77 @@ export function createPointerEventsSystem(engine, inputSystem) {
         else if (eventType === EventType.HoverEnter) {
             return 2 /* PointerEventType.PET_HOVER_ENTER */;
         }
-        else if (eventType === EventType.Drag) {
-            return 5 /* PointerEventType.PET_DRAG */;
-        }
-        else if (eventType === EventType.DragLocked) {
-            return 4 /* PointerEventType.PET_DRAG_LOCKED */;
-        }
-        else if (eventType === EventType.DragEnd) {
-            return 6 /* PointerEventType.PET_DRAG_END */;
-        }
         return 1 /* PointerEventType.PET_DOWN */;
     }
-    function getEventType(pet) {
-        if (pet === 0 /* PointerEventType.PET_UP */) {
-            return EventType.Up;
-        }
-        else if (pet === 2 /* PointerEventType.PET_HOVER_ENTER */) {
-            return EventType.HoverEnter;
-        }
-        else if (pet === 3 /* PointerEventType.PET_HOVER_LEAVE */) {
-            return EventType.HoverLeave;
-        }
-        else if (pet === 5 /* PointerEventType.PET_DRAG */) {
-            return EventType.Drag;
-        }
-        else if (pet === 4 /* PointerEventType.PET_DRAG_LOCKED */) {
-            return EventType.DragLocked;
-        }
-        else if (pet === 6 /* PointerEventType.PET_DRAG_END */) {
-            return EventType.DragEnd;
-        }
-        else {
-            return EventType.Down;
-        }
-    }
     function removeEvent(entity, type) {
         const event = getEvent(entity);
-        const pointerEventList = event.get(type);
-        if (pointerEventList === undefined) {
-            return;
-        }
-        for (const button of pointerEventList.keys()) {
-            removePointerEvent(entity, getPointerEvent(type), button);
+        const pointerEvent = event.get(type);
+        if (pointerEvent?.opts.hoverText) {
+            removePointerEvent(entity, getPointerEvent(type), pointerEvent.opts.button);
         }
         event.delete(type);
     }
     engine.addSystem(function EventSystem() {
-        if (eventsMap.size === 0) {
-            return;
-        }
-        for (const entity of eventsMap.keys()) {
+        for (const [entity, event] of eventsMap) {
             if (engine.getEntityState(entity) === EntityState.Removed) {
                 eventsMap.delete(entity);
-            }
-        }
-        for (const command of inputSystem.getInputCommands()) {
-            const entity = command.hit?.entityId;
-            if (entity === undefined) {
-                continue;
-            }
-            const entityMap = eventsMap.get(entity);
-            if (entityMap === undefined) {
                 continue;
             }
-            const typeMap = entityMap.get(getEventType(command.state));
-            if (typeMap) {
-                const data = typeMap.get(command.button);
-                if (data) {
-                    checkNotThenable(data.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+            for (const [eventType, { cb, opts }] of event) {
+                if (eventType === EventType.Click) {
+                    const command = inputSystem.getClick(opts.button, entity);
+                    if (command)
+                        checkNotThenable(cb(command.up), 'Click event returned a thenable. Only synchronous functions are allowed');
                 }
-                const anyData = typeMap.get(3 /* InputAction.IA_ANY */);
-                if (anyData) {
-                    checkNotThenable(anyData.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
-                }
-            }
-            // check clicks separately
-            if (command.state === 0 /* PointerEventType.PET_UP */) {
-                const clickMap = entityMap.get(EventType.Click);
-                if (clickMap) {
-                    const data = clickMap.get(command.button);
-                    if (data && inputSystem.getClick(command.button, entity)) {
-                        checkNotThenable(data.cb(command), 'Click event returned a thenable. Only synchronous functions are allowed');
-                    }
-                    const anyData = clickMap.get(3 /* InputAction.IA_ANY */);
-                    if (anyData && inputSystem.getClick(command.button, entity)) {
-                        checkNotThenable(anyData.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+                if (eventType === EventType.Down ||
+                    eventType === EventType.Up ||
+                    eventType === EventType.HoverEnter ||
+                    eventType === EventType.HoverLeave) {
+                    const command = inputSystem.getInputCommand(opts.button, getPointerEvent(eventType), entity);
+                    if (command) {
+                        checkNotThenable(cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
                     }
                 }
             }
         }
     });
-    // return a function with the correct event type.
-    // we use onPointerDown as the "archetype" for the returned function, but it fits with
-    // all the onPointer* declarations
-    const onPointerFunction = (ty) => {
-        return (arg0, arg1, arg2) => {
-            let entity;
-            let optsList;
-            if (typeof arg0 === 'number') {
-                // called as onPointerDown(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void
-                entity = arg0;
-                const cb = arg1;
-                const opts = arg2;
-                optsList = [{ cb, ...getDefaultOpts(opts) }];
-            }
-            else if (typeof arg1 === 'function') {
-                // called as onPointerDown(pointerData: { entity: Entity; opts?: Partial<EventSystemOptions> }, cb: EventSystemCallback): void
-                const { entity: e, opts } = arg0;
-                const cb = arg1;
-                entity = e;
-                optsList = [{ cb, ...getDefaultOpts(opts) }];
-            }
-            else {
-                // called as onPointerDown(pointerData: { entity: Entity; optsList: EventSystemOptionsCallback[] }): void
-                const { entity: e, optsList: o } = arg0;
-                entity = e;
-                optsList = o;
-            }
-            const previous = getEvent(entity).get(ty) ?? new Map();
-            const callbacks = new Map();
-            for (const opts of optsList) {
-                const prevOpts = previous.get(opts.button);
-                if (prevOpts !== undefined) {
-                    if (prevOpts.hoverText !== opts.hoverText ||
-                        prevOpts.maxDistance !== opts.maxDistance ||
-                        prevOpts.showFeedback !== opts.showFeedback ||
-                        prevOpts.showHighlight !== opts.showHighlight) {
-                        removePointerEvent(entity, getPointerEvent(ty), opts.button);
-                        setPointerEvent(entity, getPointerEvent(ty), opts);
-                    }
-                }
-                else {
-                    setPointerEvent(entity, getPointerEvent(ty), opts);
-                }
-                callbacks.set(opts.button, opts);
-            }
-            for (const button of previous.keys()) {
-                if (!callbacks.has(button)) {
-                    removePointerEvent(entity, getPointerEvent(ty), button);
-                }
-            }
-            getEvent(entity).set(ty, callbacks);
-        };
+    const onPointerDown = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return onPointerDown({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        const options = getDefaultOpts(opts);
+        removeEvent(entity, EventType.Down);
+        getEvent(entity).set(EventType.Down, { cb, opts: options });
+        setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
+    };
+    const onPointerUp = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return onPointerUp({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        const options = getDefaultOpts(opts);
+        removeEvent(entity, EventType.Up);
+        getEvent(entity).set(EventType.Up, { cb, opts: options });
+        setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options);
+    };
+    const onPointerHoverEnter = (...args) => {
+        const [data, cb] = args;
+        const { entity, opts } = data;
+        const options = getDefaultOpts(opts);
+        removeEvent(entity, EventType.HoverEnter);
+        getEvent(entity).set(EventType.HoverEnter, { cb, opts: options });
+        setPointerEvent(entity, 2 /* PointerEventType.PET_HOVER_ENTER */, options);
+    };
+    const onPointerHoverLeave = (...args) => {
+        const [data, cb] = args;
+        const { entity, opts } = data;
+        const options = getDefaultOpts(opts);
+        removeEvent(entity, EventType.HoverLeave);
+        getEvent(entity).set(EventType.HoverLeave, { cb, opts: options });
+        setPointerEvent(entity, 3 /* PointerEventType.PET_HOVER_LEAVE */, options);
     };
     return {
         removeOnClick(entity) {
@@ -215,22 +141,18 @@ export function createPointerEventsSystem(engine, inputSystem) {
         removeOnPointerHoverLeave(entity) {
             removeEvent(entity, EventType.HoverLeave);
         },
-        removeOnPointerDrag(entity) {
-            removeEvent(entity, EventType.Drag);
-        },
-        removeOnPointerDragLocked(entity) {
-            removeEvent(entity, EventType.DragLocked);
-        },
-        removeOnPointerDragEnd(entity) {
-            removeEvent(entity, EventType.DragEnd);
+        onClick(value, cb) {
+            const { entity } = value;
+            const options = getDefaultOpts(value.opts);
+            // Clear previous event with over feedback included
+            removeEvent(entity, EventType.Click);
+            // Set new event
+            getEvent(entity).set(EventType.Click, { cb, opts: options });
+            setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
         },
-        onClick: onPointerFunction(EventType.Click),
-        onPointerDown: onPointerFunction(EventType.Down),
-        onPointerUp: onPointerFunction(EventType.Up),
-        onPointerHoverEnter: onPointerFunction(EventType.HoverEnter),
-        onPointerHoverLeave: onPointerFunction(EventType.HoverLeave),
-        onPointerDrag: onPointerFunction(EventType.Drag),
-        onPointerDragLocked: onPointerFunction(EventType.DragLocked),
-        onPointerDragEnd: onPointerFunction(EventType.DragEnd)
+        onPointerDown,
+        onPointerUp,
+        onPointerHoverEnter,
+        onPointerHoverLeave
     };
 }

package/dist/systems/raycast.d.ts

@@ -1,4 +1,4 @@
-import { RaycastQueryType, RaycastShape, PBRaycastResult } from '../components';
+import { RaycastQueryType, PBRaycastResult } from '../components';
 import { DeepReadonlyObject, Entity } from '../engine';
 import { Vector3 } from '../components/generated/pb/decentraland/common/vectors.gen';
 /**
@@ -14,8 +14,6 @@ export type RaycastSystemOptions = {
     queryType: RaycastQueryType;
     continuous?: boolean | undefined;
     collisionMask?: number | undefined;
-    shape?: RaycastShape | undefined;
-    includeWorld?: boolean | undefined;
 };
 export type LocalDirectionRaycastSystemOptions = {
     direction?: Vector3;

package/dist/systems/raycast.js

@@ -58,8 +58,6 @@ export function createRaycastSystem(engine) {
             raycast.direction = raycastValue.directionRawValue;
             raycast.continuous = raycastValue.continuous;
             raycast.queryType = raycastValue.queryType;
-            raycast.shape = raycastValue.shape;
-            raycast.includeWorld = raycastValue.includeWorld;
             entitiesCallbackResultMap.set(entity, { callback: callback });
         };
         nextTickRaycasts.push(onNextTick);

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

@@ -34,13 +34,5 @@ export interface MeshColliderComponentDefinitionExtended extends LastWriteWinEle
      * @param colliderMask - the set of layer where the collider reacts, default: Physics and Pointer
      */
     setSphere(entity: Entity, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
-    /**
-     * @public
-     * Set a gltf internal mesh in the MeshCollider component
-     * @param entity - entity to create or replace the MeshRenderer component
-     * @param source - the path to the gltf
-     * @param meshName - the name of the mesh in the gltf
-     */
-    setGltfMesh(entity: Entity, source: string, meshName: string, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
 }
 export declare function defineMeshColliderComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): MeshColliderComponentDefinitionExtended;

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

@@ -37,12 +37,6 @@ function defineMeshColliderComponent(engine) {
                 mesh: { $case: 'sphere', sphere: {} },
                 collisionMask: getCollisionMask(colliderLayers)
             });
-        },
-        setGltfMesh(entity, source, meshName, colliderLayers) {
-            theComponent.createOrReplace(entity, {
-                mesh: { $case: 'gltf', gltf: { gltfSrc: source, name: meshName } },
-                collisionMask: getCollisionMask(colliderLayers)
-            });
         }
     };
 }

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

@@ -32,13 +32,5 @@ export interface MeshRendererComponentDefinitionExtended extends LastWriteWinEle
      * @param entity - entity to create or replace the MeshRenderer component
      */
     setSphere(entity: Entity): void;
-    /**
-     * @public
-     * Set a gltf internal mesh in the MeshRenderer component
-     * @param entity - entity to create or replace the MeshRenderer component
-     * @param source - the path to the gltf
-     * @param meshName - the name of the mesh in the gltf
-     */
-    setGltfMesh(entity: Entity, source: string, meshName: string): void;
 }
 export declare function defineMeshRendererComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): MeshRendererComponentDefinitionExtended;

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

@@ -25,11 +25,6 @@ function defineMeshRendererComponent(engine) {
             theComponent.createOrReplace(entity, {
                 mesh: { $case: 'sphere', sphere: {} }
             });
-        },
-        setGltfMesh(entity, source, meshName) {
-            theComponent.createOrReplace(entity, {
-                mesh: { $case: 'gltf', gltf: { gltfSrc: source, name: meshName } }
-            });
         }
     };
 }

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

@@ -1,6 +1,38 @@
 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
+ * Partial params for Tween.Mode.MoveRotateScale(). At least one of position, rotation, or scale must be provided.
+ * Use this when building a mode for Tween.createOrReplace() or TweenSequence (e.g. only positionStart/positionEnd).
+ */
+export interface MoveRotateScaleModeParams {
+    /** Position tween (start → end). Optional. */
+    position?: {
+        start: Vector3;
+        end: Vector3;
+    };
+    /** Rotation tween (start → end). Optional. */
+    rotation?: {
+        start: Quaternion;
+        end: Quaternion;
+    };
+    /** Scale tween (start → end). Optional. */
+    scale?: {
+        start: Vector3;
+        end: Vector3;
+    };
+}
+/**
+ * @public
+ * Parameters for setMoveRotateScale. At least one of position, rotation, or scale must be provided.
+ */
+export interface SetMoveRotateScaleParams extends MoveRotateScaleModeParams {
+    /** Duration of the tween in milliseconds. */
+    duration: number;
+    /** Easing function (defaults to EF_LINEAR). */
+    easingFunction?: EasingFunction;
+}
 /**
  * @public
  */
@@ -33,13 +65,18 @@ export interface TweenHelper {
      * @returns a texture-move-continuous mode tween
      */
     TextureMoveContinuous: (textureMove: TextureMoveContinuous) => PBTween['mode'];
+    /**
+     * @returns a move-rotate-scale mode tween
+     * @param params - partial transform (at least one of position, rotation, scale); omit axes you don't need
+     */
+    MoveRotateScale: (params: MoveRotateScaleModeParams) => PBTween['mode'];
 }
 /**
  * @public
  */
 export interface TweenComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBTween> {
     /**
-     * Texture helpers with constructor
+     * Helpers with constructor
      */
     Mode: TweenHelper;
     /**
@@ -118,5 +155,15 @@ export interface TweenComponentDefinitionExtended extends LastWriteWinElementSet
      * @param duration - duration of the tween in milliseconds (defaults to 0 for infinite)
      */
     setTextureMoveContinuous(entity: Entity, direction: Vector2, speed: number, movementType?: TextureMovementType, duration?: number): void;
+    /**
+     * @public
+     *
+     * Creates or replaces a move-rotate-scale tween component that simultaneously animates
+     * an entity's position, rotation, and/or scale from start to end. Provide only the
+     * properties you need (at least one of position, rotation, or scale).
+     * @param entity - entity to apply the tween to
+     * @param params - object with optional position, rotation, scale (each with start/end), duration, and optional easingFunction
+     */
+    setMoveRotateScale(entity: Entity, params: SetMoveRotateScaleParams): void;
 }
 export declare function defineTweenComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): TweenComponentDefinitionExtended;

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

@@ -2,6 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineTweenComponent = void 0;
 const index_gen_1 = require("../generated/index.gen");
+function assertDuration(duration, apiName) {
+    if (!Number.isFinite(duration) || duration < 0) {
+        throw new Error(`${apiName}: duration must be a non-negative finite number`);
+    }
+}
+/** Shared validation for params that have optional position/rotation/scale with start & end. */
+function assertMoveRotateScaleAxesStartEnd(params, apiName) {
+    if (!params.position && !params.rotation && !params.scale) {
+        throw new Error(`${apiName}: at least one of position, rotation, or scale must be provided`);
+    }
+    if (params.position) {
+        const pos = params.position;
+        if (!pos.start || !pos.end) {
+            throw new Error(`${apiName}: position must have both start and end`);
+        }
+    }
+    if (params.rotation) {
+        const rot = params.rotation;
+        if (!rot.start || !rot.end) {
+            throw new Error(`${apiName}: rotation must have both start and end`);
+        }
+    }
+    if (params.scale) {
+        const scl = params.scale;
+        if (!scl.start || !scl.end) {
+            throw new Error(`${apiName}: scale must have both start and end`);
+        }
+    }
+}
 const TweenHelper = {
     Move(move) {
         return {
@@ -44,6 +73,21 @@ const TweenHelper = {
             $case: 'textureMoveContinuous',
             textureMoveContinuous
         };
+    },
+    MoveRotateScale(params) {
+        assertMoveRotateScaleAxesStartEnd(params, 'Tween.Mode.MoveRotateScale');
+        const moveRotateScale = {
+            positionStart: params.position ? params.position.start : undefined,
+            positionEnd: params.position ? params.position.end : undefined,
+            rotationStart: params.rotation ? params.rotation.start : undefined,
+            rotationEnd: params.rotation ? params.rotation.end : undefined,
+            scaleStart: params.scale ? params.scale.start : undefined,
+            scaleEnd: params.scale ? params.scale.end : undefined
+        };
+        return {
+            $case: 'moveRotateScale',
+            moveRotateScale
+        };
     }
 };
 function defineTweenComponent(engine) {
@@ -150,6 +194,28 @@ function defineTweenComponent(engine) {
                 easingFunction: 0 /* EasingFunction.EF_LINEAR */,
                 playing: true
             });
+        },
+        setMoveRotateScale(entity, params) {
+            assertMoveRotateScaleAxesStartEnd(params, 'setMoveRotateScale');
+            assertDuration(params.duration, 'setMoveRotateScale');
+            const { position, rotation, scale, duration, easingFunction = 0 /* EasingFunction.EF_LINEAR */ } = params;
+            const moveRotateScale = {
+                positionStart: position ? position.start : undefined,
+                positionEnd: position ? position.end : undefined,
+                rotationStart: rotation ? rotation.start : undefined,
+                rotationEnd: rotation ? rotation.end : undefined,
+                scaleStart: scale ? scale.start : undefined,
+                scaleEnd: scale ? scale.end : undefined
+            };
+            theComponent.createOrReplace(entity, {
+                mode: {
+                    $case: 'moveRotateScale',
+                    moveRotateScale
+                },
+                duration,
+                easingFunction,
+                playing: true
+            });
         }
     };
 }

package/dist-cjs/components/generated/PhysicsCombinedForce.gen.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhysicsCombinedForceSchema = void 0;
+const physics_combined_force_gen_1 = require("./pb/decentraland/sdk/components/physics_combined_force.gen");
+/**
+ * @internal
+ */
+exports.PhysicsCombinedForceSchema = {
+    COMPONENT_ID: 1216,
+    serialize(value, builder) {
+        const writer = physics_combined_force_gen_1.PBPhysicsCombinedForce.encode(value);
+        const buffer = new Uint8Array(writer.finish(), 0, writer.len);
+        builder.writeBuffer(buffer, false);
+    },
+    deserialize(reader) {
+        return physics_combined_force_gen_1.PBPhysicsCombinedForce.decode(reader.buffer(), reader.remainingBytes());
+    },
+    create() {
+        // TODO: this is a hack.
+        return physics_combined_force_gen_1.PBPhysicsCombinedForce.decode(new Uint8Array());
+    },
+    jsonSchema: {
+        type: "object",
+        properties: {},
+        serializationType: "protocol-buffer",
+        protocolBuffer: "PBPhysicsCombinedForce"
+    }
+};