@dcl/ecs 7.13.1-19324737285.commit-cb42004 → 7.13.1-19516109426.commit-e1e79aa

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

@@ -1,6 +1,7 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
 import { Color4 } from "../../common/colors.gen";
+import { Vector2 } from "../../common/vectors.gen";
 const protobufPackageSarasa = "decentraland.sdk.components";
 /**
  * @public
@@ -105,6 +106,65 @@ export var PointerFilterMode;
     PointerFilterMode[PointerFilterMode["PFM_NONE"] = 0] = "PFM_NONE";
     PointerFilterMode[PointerFilterMode["PFM_BLOCK"] = 1] = "PFM_BLOCK";
 })(PointerFilterMode || (PointerFilterMode = {}));
+/**
+ * @public
+ */
+export var ShowScrollBar;
+(function (ShowScrollBar) {
+    ShowScrollBar[ShowScrollBar["SSB_BOTH"] = 0] = "SSB_BOTH";
+    ShowScrollBar[ShowScrollBar["SSB_ONLY_VERTICAL"] = 1] = "SSB_ONLY_VERTICAL";
+    ShowScrollBar[ShowScrollBar["SSB_ONLY_HORIZONTAL"] = 2] = "SSB_ONLY_HORIZONTAL";
+    ShowScrollBar[ShowScrollBar["SSB_HIDDEN"] = 3] = "SSB_HIDDEN";
+})(ShowScrollBar || (ShowScrollBar = {}));
+function createBaseScrollPositionValue() {
+    return { value: undefined };
+}
+/**
+ * @public
+ */
+export var ScrollPositionValue;
+(function (ScrollPositionValue) {
+    function encode(message, writer = _m0.Writer.create()) {
+        switch (message.value?.$case) {
+            case "position":
+                Vector2.encode(message.value.position, writer.uint32(10).fork()).ldelim();
+                break;
+            case "reference":
+                writer.uint32(18).string(message.value.reference);
+                break;
+        }
+        return writer;
+    }
+    ScrollPositionValue.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 = createBaseScrollPositionValue();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.value = { $case: "position", position: Vector2.decode(reader, reader.uint32()) };
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = { $case: "reference", reference: reader.string() };
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    ScrollPositionValue.decode = decode;
+})(ScrollPositionValue || (ScrollPositionValue = {}));
 function createBasePBUiTransform() {
     return {
         parent: 0,
@@ -180,6 +240,9 @@ function createBasePBUiTransform() {
         borderLeftColor: undefined,
         borderRightColor: undefined,
         opacity: undefined,
+        elementId: undefined,
+        scrollPosition: undefined,
+        scrollVisible: undefined,
         zIndex: undefined,
     };
 }
@@ -408,6 +471,15 @@ export var PBUiTransform;
         if (message.opacity !== undefined) {
             writer.uint32(589).float(message.opacity);
         }
+        if (message.elementId !== undefined) {
+            writer.uint32(594).string(message.elementId);
+        }
+        if (message.scrollPosition !== undefined) {
+            ScrollPositionValue.encode(message.scrollPosition, writer.uint32(602).fork()).ldelim();
+        }
+        if (message.scrollVisible !== undefined) {
+            writer.uint32(608).int32(message.scrollVisible);
+        }
         if (message.zIndex !== undefined) {
             writer.uint32(616).int32(message.zIndex);
         }
@@ -859,6 +931,24 @@ export var PBUiTransform;
                     }
                     message.opacity = reader.float();
                     continue;
+                case 74:
+                    if (tag !== 594) {
+                        break;
+                    }
+                    message.elementId = reader.string();
+                    continue;
+                case 75:
+                    if (tag !== 602) {
+                        break;
+                    }
+                    message.scrollPosition = ScrollPositionValue.decode(reader, reader.uint32());
+                    continue;
+                case 76:
+                    if (tag !== 608) {
+                        break;
+                    }
+                    message.scrollVisible = reader.int32();
+                    continue;
                 case 77:
                     if (tag !== 616) {
                         break;

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

@@ -6,7 +6,6 @@ import { CameraTransition } from "./common/camera_transition.gen";
  * an 'instant' transition (like using speed/time = 0)
  * * The lookAtEntity defines to which entity the Camera has to look at constantly (independent from
  * the holding entity transform).
- * * The fov defines the Field of View of the virtual camera
  */
 /**
  * @public
@@ -14,8 +13,6 @@ import { CameraTransition } from "./common/camera_transition.gen";
 export interface PBVirtualCamera {
     defaultTransition?: CameraTransition | undefined;
     lookAtEntity?: number | undefined;
-    /** default: 60 */
-    fov?: number | undefined;
 }
 /**
  * @public

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

@@ -3,7 +3,7 @@ import _m0 from "protobufjs/minimal";
 import { CameraTransition } from "./common/camera_transition.gen";
 const protobufPackageSarasa = "decentraland.sdk.components";
 function createBasePBVirtualCamera() {
-    return { defaultTransition: undefined, lookAtEntity: undefined, fov: undefined };
+    return { defaultTransition: undefined, lookAtEntity: undefined };
 }
 /**
  * @public
@@ -17,9 +17,6 @@ export var PBVirtualCamera;
         if (message.lookAtEntity !== undefined) {
             writer.uint32(16).uint32(message.lookAtEntity);
         }
-        if (message.fov !== undefined) {
-            writer.uint32(29).float(message.fov);
-        }
         return writer;
     }
     PBVirtualCamera.encode = encode;
@@ -42,12 +39,6 @@ export var PBVirtualCamera;
                     }
                     message.lookAtEntity = reader.uint32();
                     continue;
-                case 3:
-                    if (tag !== 29) {
-                        break;
-                    }
-                    message.fov = reader.float();
-                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;

package/dist/components/index.d.ts

@@ -2,25 +2,27 @@ import { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDef
 import { IEngine } from '../engine/types';
 import { AnimatorComponentDefinitionExtended } from './extended/Animator';
 import { AudioSourceComponentDefinitionExtended } from './extended/AudioSource';
+import { AudioStreamComponentDefinitionExtended } from './extended/AudioStream';
+import { AvatarEquippedDataComponentDefinitionExtended } from './extended/AvatarEquippedData';
+import { AvatarShapeComponentDefinitionExtended } from './extended/AvatarShape';
+import { InputModifierComponentDefinitionExtended } from './extended/InputModifier';
 import { MaterialComponentDefinitionExtended } from './extended/Material';
 import { MeshColliderComponentDefinitionExtended } from './extended/MeshCollider';
 import { MeshRendererComponentDefinitionExtended } from './extended/MeshRenderer';
 import { TweenComponentDefinitionExtended } from './extended/Tween';
-import { LwwComponentGetter, GSetComponentGetter } from './generated/index.gen';
+import { VirtualCameraComponentDefinitionExtended } from './extended/VirtualCamera';
+import { GSetComponentGetter, LwwComponentGetter } from './generated/index.gen';
+import { MediaState } from './generated/pb/decentraland/sdk/components/common/media_state.gen';
 import { NameType } from './manual/Name';
-import { ISyncComponentsType } from './manual/SyncComponents';
 import { INetowrkEntityType } from './manual/NetworkEntity';
 import { INetowrkParentType } from './manual/NetworkParent';
+import { ISyncComponentsType } from './manual/SyncComponents';
 import { TransformComponentExtended } from './manual/Transform';
-import { AudioStreamComponentDefinitionExtended } from './extended/AudioStream';
-import { MediaState } from './generated/pb/decentraland/sdk/components/common/media_state.gen';
-import { VirtualCameraComponentDefinitionExtended } from './extended/VirtualCamera';
-import { InputModifierComponentDefinitionExtended } from './extended/InputModifier';
 import { LightSourceComponentDefinitionExtended } from './extended/LightSource';
 import { TriggerAreaComponentDefinitionExtended } from './extended/TriggerArea';
 import { TagsComponentDefinitionExtended } from './manual/Tags';
 export * from './generated/index.gen';
-export type { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition, LwwComponentGetter, GSetComponentGetter };
+export type { GrowOnlyValueSetComponentDefinition, GSetComponentGetter, LastWriteWinElementSetComponentDefinition, LwwComponentGetter };
 export declare const Transform: LwwComponentGetter<TransformComponentExtended>;
 export declare const Material: LwwComponentGetter<MaterialComponentDefinitionExtended>;
 export declare const Animator: LwwComponentGetter<AnimatorComponentDefinitionExtended>;
@@ -29,6 +31,8 @@ export declare const AudioStream: (engine: Pick<IEngine, 'defineComponentFromSch
 export declare const MeshRenderer: LwwComponentGetter<MeshRendererComponentDefinitionExtended>;
 export declare const MeshCollider: LwwComponentGetter<MeshColliderComponentDefinitionExtended>;
 export declare const Tween: LwwComponentGetter<TweenComponentDefinitionExtended>;
+export declare const AvatarShape: LwwComponentGetter<AvatarShapeComponentDefinitionExtended>;
+export declare const AvatarEquippedData: LwwComponentGetter<AvatarEquippedDataComponentDefinitionExtended>;
 export declare const VirtualCamera: LwwComponentGetter<VirtualCameraComponentDefinitionExtended>;
 export declare const InputModifier: LwwComponentGetter<InputModifierComponentDefinitionExtended>;
 export declare const LightSource: LwwComponentGetter<LightSourceComponentDefinitionExtended>;

package/dist/components/index.js

@@ -1,18 +1,20 @@
 import { defineAnimatorComponent } from './extended/Animator';
 import { defineAudioSourceComponent } from './extended/AudioSource';
+import { defineAudioStreamComponent } from './extended/AudioStream';
+import { defineAvatarEquippedDataComponent } from './extended/AvatarEquippedData';
+import { defineAvatarShapeComponent } from './extended/AvatarShape';
+import { defineInputModifierComponent } from './extended/InputModifier';
 import { defineMaterialComponent } from './extended/Material';
 import { defineMeshColliderComponent } from './extended/MeshCollider';
 import { defineMeshRendererComponent } from './extended/MeshRenderer';
 import { defineTweenComponent } from './extended/Tween';
+import { defineVirtualCameraComponent } from './extended/VirtualCamera';
+import { MediaState } from './generated/pb/decentraland/sdk/components/common/media_state.gen';
 import defineNameComponent from './manual/Name';
-import defineSyncComponent from './manual/SyncComponents';
 import defineNetworkEntity from './manual/NetworkEntity';
 import defineNetworkParent from './manual/NetworkParent';
+import defineSyncComponent from './manual/SyncComponents';
 import { defineTransformComponent } from './manual/Transform';
-import { defineAudioStreamComponent } from './extended/AudioStream';
-import { MediaState } from './generated/pb/decentraland/sdk/components/common/media_state.gen';
-import { defineVirtualCameraComponent } from './extended/VirtualCamera';
-import { defineInputModifierComponent } from './extended/InputModifier';
 import { defineLightSourceComponent } from './extended/LightSource';
 import { defineTriggerAreaComponent } from './extended/TriggerArea';
 import defineTagsComponent from './manual/Tags';
@@ -34,6 +36,10 @@ export const MeshCollider = (engine) => defineMeshColliderComponent(engine);
 /* @__PURE__ */
 export const Tween = (engine) => defineTweenComponent(engine);
 /* @__PURE__ */
+export const AvatarShape = (engine) => defineAvatarShapeComponent(engine);
+/* @__PURE__ */
+export const AvatarEquippedData = (engine) => defineAvatarEquippedDataComponent(engine);
+/* @__PURE__ */
 export const VirtualCamera = (engine) => defineVirtualCameraComponent(engine);
 /* @__PURE__*/
 export const InputModifier = (engine) => defineInputModifierComponent(engine);

package/dist/components/types.d.ts

@@ -3,6 +3,8 @@ export type { AudioSourceComponentDefinitionExtended } from './extended/AudioSou
 export type { AudioStreamComponentDefinitionExtended } from './extended/AudioStream';
 export type { MeshRendererComponentDefinitionExtended } from './extended/MeshRenderer';
 export type { MeshColliderComponentDefinitionExtended } from './extended/MeshCollider';
+export type { AvatarEquippedDataComponentDefinitionExtended, AvatarEquippedDataType } from './extended/AvatarEquippedData';
+export type { AvatarShapeComponentDefinitionExtended, AvatarShapeType } from './extended/AvatarShape';
 export type { TextureHelper, MaterialComponentDefinitionExtended } from './extended/Material';
 export type { TweenHelper, TweenComponentDefinitionExtended } from './extended/Tween';
 export type { CameraTransitionHelper, VirtualCameraComponentDefinitionExtended } from './extended/VirtualCamera';

package/dist/engine/input.d.ts

@@ -32,6 +32,12 @@ export type IInputSystem = {
      * @returns the input command info or undefined if there is no command in the last tick-update
      */
     getInputCommand: (inputAction: InputAction, pointerEventType: PointerEventType, entity?: Entity) => PBPointerEventsResult | null;
+    /**
+     * @public
+     * Get an ordered iterator over events received within the current frame.
+     * @returns the iterator
+     */
+    getInputCommands: () => Generator<PBPointerEventsResult>;
 };
 /**
  * @public

package/dist/engine/input.js

@@ -185,11 +185,17 @@ export function createInputSystem(engine) {
     function isPressed(inputAction) {
         return globalState.buttonState.get(inputAction)?.state === 1 /* PointerEventType.PET_DOWN */;
     }
+    function* getInputCommands() {
+        for (let i = globalState.thisFrameCommands.length - 1; i >= 0; i--) {
+            yield globalState.thisFrameCommands[i];
+        }
+    }
     return {
         isPressed,
         getClick,
         getInputCommand,
         isClicked,
-        isTriggered
+        isTriggered,
+        getInputCommands
     };
 }

package/dist/runtime/initialization/index.d.ts

@@ -53,7 +53,7 @@ export declare const videoEventsSystem: VideoEventsSystem;
 export { VideoEventsSystem };
 /**
  * @public
- * Register callback functions to a particular entity on tween events.
+ * Register callback functions to a particular entity on video events.
  */
 export declare const tweenSystem: TweenSystem;
 export { TweenSystem };

package/dist/runtime/initialization/index.js

@@ -50,7 +50,7 @@ export const raycastSystem = /* @__PURE__ */ createRaycastSystem(engine);
 export const videoEventsSystem = /* @__PURE__ */ createVideoEventsSystem(engine);
 /**
  * @public
- * Register callback functions to a particular entity on tween events.
+ * Register callback functions to a particular entity on video events.
  */
 export const tweenSystem = createTweenSystem(engine);
 /**

package/dist/systems/events.d.ts

@@ -17,6 +17,12 @@ export type EventSystemOptions = {
     showFeedback?: boolean;
     showHighlight?: boolean;
 };
+/**
+ * @public
+ */
+export type EventSystemOptionsCallback = EventSystemOptions & {
+    cb: EventSystemCallback;
+};
 export declare const getDefaultOpts: (opts?: Partial<EventSystemOptions>) => EventSystemOptions;
 /**
  * @public
@@ -46,11 +52,37 @@ 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;
@@ -63,6 +95,15 @@ 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
@@ -100,6 +141,64 @@ 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