@dcl/ecs 7.22.5 → 7.22.6-25007982108.commit-83012ab

package/dist-cjs/runtime/helpers/tree.d.ts

@@ -2,12 +2,6 @@ import { Entity } from '../../engine/entity';
 import { ComponentDefinition, IEngine } from '../../engine';
 import { Vector3Type } from '../../schemas/custom/Vector3';
 import { QuaternionType } from '../../schemas/custom/Quaternion';
-/**
- * @public
- * Rotate a vector by a quaternion
- * Uses the formula: v' = q * v * q^(-1), optimized version
- */
-export declare function rotateVectorByQuaternion(v: Vector3Type, q: QuaternionType): Vector3Type;
 /**
  * Get an iterator of entities that follow a tree structure for a component
  * @public

package/dist-cjs/runtime/helpers/tree.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWorldRotation = exports.getWorldPosition = exports.getEntitiesWithParent = exports.removeEntityWithChildren = exports.getComponentEntityTree = exports.rotateVectorByQuaternion = void 0;
+exports.getWorldRotation = exports.getWorldPosition = exports.getEntitiesWithParent = exports.removeEntityWithChildren = exports.getComponentEntityTree = void 0;
 const components = __importStar(require("../../components"));
 /**
  * @internal
@@ -61,7 +61,7 @@ function multiplyQuaternions(q1, q2) {
     };
 }
 /**
- * @public
+ * @internal
  * Rotate a vector by a quaternion
  * Uses the formula: v' = q * v * q^(-1), optimized version
  */
@@ -80,7 +80,6 @@ function rotateVectorByQuaternion(v, q) {
         z: iz * qw + iw * -qz + ix * -qy - iy * -qx
     };
 }
-exports.rotateVectorByQuaternion = rotateVectorByQuaternion;
 /** @internal Identity transform values */
 const IDENTITY_POSITION = { x: 0, y: 0, z: 0 };
 const IDENTITY_ROTATION = { x: 0, y: 0, z: 0, w: 1 };

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

@@ -12,7 +12,6 @@ import { AssetLoadLoadingStateSystem } from '../../systems/assetLoad';
 import { TweenSystem } from '../../systems/tween';
 import { TriggerAreaEventsSystem } from '../../systems/triggerArea';
 import { createTimers, Timers } from '../helpers/timers';
-import { PhysicsSystem } from '../../systems/physics';
 /**
  * @public
  * The engine is the part of the scene that sits in the middle and manages all of the other parts.
@@ -78,12 +77,6 @@ export { TriggerAreaEventsSystem };
  */
 export declare const timers: Timers;
 export { Timers, createTimers };
-/**
- * @public
- * Physics helpers for applying impulses and forces to the player.
- */
-export declare const Physics: PhysicsSystem;
-export { PhysicsSystem };
 /**
  * @public
  * Runs an async function

package/dist-cjs/runtime/initialization/index.js

@@ -4,7 +4,7 @@
  * init and it'll be changing.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeTask = exports.Physics = exports.createTimers = exports.timers = exports.triggerAreaEventsSystem = exports.tweenSystem = exports.assetLoadLoadingStateSystem = exports.videoEventsSystem = exports.raycastSystem = exports.pointerEventsSystem = exports.inputSystem = exports.engine = void 0;
+exports.executeTask = exports.createTimers = exports.timers = exports.triggerAreaEventsSystem = exports.tweenSystem = exports.assetLoadLoadingStateSystem = exports.videoEventsSystem = exports.raycastSystem = exports.pointerEventsSystem = exports.inputSystem = exports.engine = void 0;
 const engine_1 = require("../../engine");
 const async_task_1 = require("../../systems/async-task");
 const events_1 = require("../../systems/events");
@@ -18,7 +18,6 @@ const triggerArea_1 = require("../../systems/triggerArea");
 const timers_1 = require("../helpers/timers");
 Object.defineProperty(exports, "createTimers", { enumerable: true, get: function () { return timers_1.createTimers; } });
 const globals_1 = require("../globals");
-const physics_1 = require("../../systems/physics");
 /**
  * @public
  * The engine is the part of the scene that sits in the middle and manages all of the other parts.
@@ -81,11 +80,6 @@ exports.timers = (0, timers_1.createTimers)(exports.engine);
 (0, globals_1.setGlobalPolyfill)('clearTimeout', exports.timers.clearTimeout);
 (0, globals_1.setGlobalPolyfill)('setInterval', exports.timers.setInterval);
 (0, globals_1.setGlobalPolyfill)('clearInterval', exports.timers.clearInterval);
-/**
- * @public
- * Physics helpers for applying impulses and forces to the player.
- */
-exports.Physics = (0, physics_1.createPhysicsSystem)(exports.engine);
 /**
  * Adds pointer event collider system only in DEV env
  */

package/dist-cjs/systems/crdt/index.js

@@ -244,12 +244,6 @@ function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             const buffer = new ByteBuffer_1.ReadWriteByteBuffer();
             // Then we send all the new crdtMessages that the transport needs to process
             for (const message of crdtMessages) {
-                // Avoid echo messages
-                if (message.transportId === transportIndex)
-                    continue;
-                // Redundant message for the transport
-                if (!transport.filter(message))
-                    continue;
                 // Check if adding this message would exceed the size limit
                 const currentBufferSize = transportBuffer.toBinary().byteLength;
                 const messageSize = message.messageBuffer.byteLength;
@@ -266,6 +260,12 @@ function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                         continue;
                     }
                 }
+                // Avoid echo messages
+                if (message.transportId === transportIndex)
+                    continue;
+                // Redundant message for the transport
+                if (!transport.filter(message))
+                    continue;
                 const { entityId } = findNetworkId(message);
                 const transformNeedsFix = 'componentId' in message &&
                     message.componentId === Transform.componentId &&

package/dist-cjs/systems/events.d.ts

@@ -17,7 +17,12 @@ export type EventSystemOptions = {
     showFeedback?: boolean;
     showHighlight?: boolean;
     maxPlayerDistance?: number;
-    priority?: number;
+};
+/**
+ * @public
+ */
+export type EventSystemOptionsCallback = EventSystemOptions & {
+    cb: EventSystemCallback;
 };
 export declare const getDefaultOpts: (opts?: Partial<EventSystemOptions>) => EventSystemOptions;
 /**
@@ -50,33 +55,35 @@ export interface PointerEventsSystem {
     removeOnPointerHoverLeave(entity: Entity): void;
     /**
      * @public
-     * Remove the callback for onProximityDown event
+     * Remove the callback for onPointerDrag event
      * @param entity - Entity where the callback was attached
      */
-    removeOnProximityDown(entity: Entity): void;
+    removeOnPointerDrag(entity: Entity): void;
     /**
      * @public
-     * Remove the callback for onProximityUp event
+     * Remove the callback for onPointerDragLocked event
      * @param entity - Entity where the callback was attached
      */
-    removeOnProximityUp(entity: Entity): void;
+    removeOnPointerDragLocked(entity: Entity): void;
     /**
      * @public
-     * Remove the callback for onProximityEnter event
+     * Remove the callback for onPointerDragEnd event
      * @param entity - Entity where the callback was attached
      */
-    removeOnProximityEnter(entity: Entity): void;
+    removeOnPointerDragEnd(entity: Entity): void;
     /**
      * @public
-     * Remove the callback for onProximityLeave event
-     * @param entity - Entity where the callback was attached
+     * 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
      */
-    removeOnProximityLeave(entity: Entity): void;
+    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;
@@ -89,6 +96,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
@@ -128,41 +144,59 @@ export interface PointerEventsSystem {
     }, cb: EventSystemCallback): void;
     /**
      * @public
-     * Execute callback when the user presses the proximity button on the entity
+     * 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
      */
-    onProximityDown(pointerData: {
+    onPointerDrag(pointerData: {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;
     /**
      * @public
-     * Execute callback when the user releases the proximity button on the entity
-     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
-     * @param cb - Function to execute when event fires
+     * 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
      */
-    onProximityUp(pointerData: {
+    onPointerDragLocked(pointerData: {
         entity: Entity;
-        opts?: Partial<EventSystemOptions>;
-    }, cb: EventSystemCallback): void;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
     /**
      * @public
-     * Execute callback when the entity enters the proximity zone of the user
+     * 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 event fires
+     * @param cb - Function to execute when click fires
      */
-    onProximityEnter(pointerData: {
+    onPointerDragLocked(pointerData: {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;
     /**
      * @public
-     * Execute callback when the entity leaves the proximity zone of the user
+     * 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 event fires
+     * @param cb - Function to execute when click fires
      */
-    onProximityLeave(pointerData: {
+    onPointerDragEnd(pointerData: {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;

package/dist-cjs/systems/events.js

@@ -45,14 +45,15 @@ function createPointerEventsSystem(engine, inputSystem) {
         EventType[EventType["Up"] = 2] = "Up";
         EventType[EventType["HoverEnter"] = 3] = "HoverEnter";
         EventType[EventType["HoverLeave"] = 4] = "HoverLeave";
-        EventType[EventType["ProximityEnter"] = 5] = "ProximityEnter";
-        EventType[EventType["ProximityLeave"] = 6] = "ProximityLeave";
+        EventType[EventType["Drag"] = 5] = "Drag";
+        EventType[EventType["DragLocked"] = 6] = "DragLocked";
+        EventType[EventType["DragEnd"] = 7] = "DragEnd";
     })(EventType || (EventType = {}));
     const eventsMap = new Map();
     function getEvent(entity) {
         return eventsMap.get(entity) || eventsMap.set(entity, new Map()).get(entity);
     }
-    function setPointerEvent(entity, type, opts, interactionType = 0 /* InteractionType.CURSOR */) {
+    function setPointerEvent(entity, type, opts) {
         const pointerEvent = PointerEvents.getMutableOrNull(entity) || PointerEvents.create(entity);
         pointerEvent.pointerEvents.push({
             eventType: type,
@@ -62,19 +63,15 @@ function createPointerEventsSystem(engine, inputSystem) {
                 showHighlight: opts.showHighlight,
                 hoverText: opts.hoverText,
                 maxDistance: opts.maxDistance,
-                maxPlayerDistance: opts.maxPlayerDistance,
-                priority: opts.priority
-            },
-            interactionType: interactionType ?? 0 /* InteractionType.CURSOR */
+                maxPlayerDistance: opts.maxPlayerDistance
+            }
         });
     }
-    function removePointerEvent(entity, type, button, interactionType = 0 /* InteractionType.CURSOR */) {
+    function removePointerEvent(entity, type, button) {
         const pointerEvent = PointerEvents.getMutableOrNull(entity);
         if (!pointerEvent)
             return;
-        pointerEvent.pointerEvents = pointerEvent.pointerEvents.filter((pointer) => !(pointer.eventInfo?.button === button &&
-            pointer.eventType === type &&
-            pointer.interactionType === interactionType));
+        pointerEvent.pointerEvents = pointerEvent.pointerEvents.filter((pointer) => !(pointer.eventInfo?.button === button && pointer.eventType === type));
     }
     function getPointerEvent(eventType) {
         if (eventType === EventType.Up) {
@@ -86,117 +83,148 @@ function createPointerEventsSystem(engine, inputSystem) {
         else if (eventType === EventType.HoverEnter) {
             return 2 /* PointerEventType.PET_HOVER_ENTER */;
         }
-        else if (eventType === EventType.ProximityEnter) {
-            return 4 /* PointerEventType.PET_PROXIMITY_ENTER */;
+        else if (eventType === EventType.Drag) {
+            return 7 /* PointerEventType.PET_DRAG */;
+        }
+        else if (eventType === EventType.DragLocked) {
+            return 6 /* PointerEventType.PET_DRAG_LOCKED */;
         }
-        else if (eventType === EventType.ProximityLeave) {
-            return 5 /* PointerEventType.PET_PROXIMITY_LEAVE */;
+        else if (eventType === EventType.DragEnd) {
+            return 8 /* PointerEventType.PET_DRAG_END */;
         }
         return 1 /* PointerEventType.PET_DOWN */;
     }
-    function removeEvent(entity, type, interactionType = 0 /* InteractionType.CURSOR */) {
+    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 === 7 /* PointerEventType.PET_DRAG */) {
+            return EventType.Drag;
+        }
+        else if (pet === 6 /* PointerEventType.PET_DRAG_LOCKED */) {
+            return EventType.DragLocked;
+        }
+        else if (pet === 8 /* PointerEventType.PET_DRAG_END */) {
+            return EventType.DragEnd;
+        }
+        else {
+            return EventType.Down;
+        }
+    }
+    function removeEvent(entity, type) {
         const event = getEvent(entity);
-        const pointerEvent = event.get(type);
-        if (pointerEvent?.opts.hoverText) {
-            removePointerEvent(entity, getPointerEvent(type), pointerEvent.opts.button);
+        const pointerEventList = event.get(type);
+        if (pointerEventList === undefined) {
+            return;
+        }
+        for (const button of pointerEventList.keys()) {
+            removePointerEvent(entity, getPointerEvent(type), button);
         }
         event.delete(type);
     }
     engine.addSystem(function EventSystem() {
-        for (const [entity, event] of eventsMap) {
+        if (eventsMap.size === 0) {
+            return;
+        }
+        for (const entity of eventsMap.keys()) {
             if (engine.getEntityState(entity) === entity_1.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;
             }
-            for (const [eventType, { cb, opts }] of event) {
-                if (eventType === EventType.Click) {
-                    const command = inputSystem.getClick(opts.button, entity);
-                    if (command)
-                        (0, invariant_1.checkNotThenable)(cb(command.up), 'Click event returned a thenable. Only synchronous functions are allowed');
+            const typeMap = entityMap.get(getEventType(command.state));
+            if (typeMap) {
+                const data = typeMap.get(command.button);
+                if (data) {
+                    (0, invariant_1.checkNotThenable)(data.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 ||
-                    eventType === EventType.ProximityEnter ||
-                    eventType === EventType.ProximityLeave) {
-                    const command = inputSystem.getInputCommand(opts.button, getPointerEvent(eventType), entity);
-                    if (command) {
-                        (0, invariant_1.checkNotThenable)(cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+                const anyData = typeMap.get(3 /* InputAction.IA_ANY */);
+                if (anyData) {
+                    (0, invariant_1.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)) {
+                        (0, invariant_1.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)) {
+                        (0, invariant_1.checkNotThenable)(anyData.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
                     }
                 }
             }
         }
     });
-    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 = (0, exports.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 = (0, exports.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 = (0, exports.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 = (0, exports.getDefaultOpts)(opts);
-        removeEvent(entity, EventType.HoverLeave);
-        getEvent(entity).set(EventType.HoverLeave, { cb, opts: options });
-        setPointerEvent(entity, 3 /* PointerEventType.PET_HOVER_LEAVE */, options);
-    };
-    const onProximityDown = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = (0, exports.getDefaultOpts)(opts);
-        removeEvent(entity, EventType.Down, 1 /* InteractionType.PROXIMITY */);
-        getEvent(entity).set(EventType.Down, { cb, opts: options });
-        setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options, 1 /* InteractionType.PROXIMITY */);
-    };
-    const onProximityUp = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = (0, exports.getDefaultOpts)(opts);
-        removeEvent(entity, EventType.Up, 1 /* InteractionType.PROXIMITY */);
-        getEvent(entity).set(EventType.Up, { cb, opts: options });
-        setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options, 1 /* InteractionType.PROXIMITY */);
-    };
-    const onProximityEnter = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = (0, exports.getDefaultOpts)(opts);
-        removeEvent(entity, EventType.ProximityEnter, 1 /* InteractionType.PROXIMITY */);
-        getEvent(entity).set(EventType.ProximityEnter, { cb, opts: options });
-        setPointerEvent(entity, 4 /* PointerEventType.PET_PROXIMITY_ENTER */, options, 1 /* InteractionType.PROXIMITY */);
-    };
-    const onProximityLeave = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = (0, exports.getDefaultOpts)(opts);
-        removeEvent(entity, EventType.ProximityLeave, 1 /* InteractionType.PROXIMITY */);
-        getEvent(entity).set(EventType.ProximityLeave, { cb, opts: options });
-        setPointerEvent(entity, 5 /* PointerEventType.PET_PROXIMITY_LEAVE */, options, 1 /* InteractionType.PROXIMITY */);
+    // 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, ...(0, exports.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, ...(0, exports.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);
+        };
     };
     return {
         removeOnClick(entity) {
@@ -214,35 +242,23 @@ function createPointerEventsSystem(engine, inputSystem) {
         removeOnPointerHoverLeave(entity) {
             removeEvent(entity, EventType.HoverLeave);
         },
-        removeOnProximityDown(entity) {
-            removeEvent(entity, EventType.Down, 1 /* InteractionType.PROXIMITY */);
-        },
-        removeOnProximityUp(entity) {
-            removeEvent(entity, EventType.Up, 1 /* InteractionType.PROXIMITY */);
+        removeOnPointerDrag(entity) {
+            removeEvent(entity, EventType.Drag);
         },
-        removeOnProximityEnter(entity) {
-            removeEvent(entity, EventType.ProximityEnter, 1 /* InteractionType.PROXIMITY */);
+        removeOnPointerDragLocked(entity) {
+            removeEvent(entity, EventType.DragLocked);
         },
-        removeOnProximityLeave(entity) {
-            removeEvent(entity, EventType.ProximityLeave, 1 /* InteractionType.PROXIMITY */);
-        },
-        onClick(value, cb) {
-            const { entity } = value;
-            const options = (0, exports.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);
+        removeOnPointerDragEnd(entity) {
+            removeEvent(entity, EventType.DragEnd);
         },
-        onPointerDown,
-        onPointerUp,
-        onPointerHoverEnter,
-        onPointerHoverLeave,
-        onProximityDown,
-        onProximityUp,
-        onProximityEnter,
-        onProximityLeave
+        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)
     };
 }
 exports.createPointerEventsSystem = createPointerEventsSystem;

package/dist-cjs/systems/raycast.d.ts

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

package/dist-cjs/systems/raycast.js

@@ -84,6 +84,8 @@ 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.22.5",
+  "version": "7.22.6-25007982108.commit-83012ab",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "files": [
@@ -31,8 +31,7 @@
     "displayName": "ECS",
     "tsconfig": "./tsconfig.json"
   },
-  "dependencies": {},
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "b6da827dbab8b88795119b50ab578d457e552d0c"
+  "commit": "83012ab4c851bdd7da6c424a20094149b7707019"
 }