@dcl/ecs 7.1.18-5157707330.commit-091fce4 → 7.1.18-5158337338.commit-735bf67

package/dist/systems/events.d.ts

@@ -33,6 +33,15 @@ export interface PointerEventsSystem {
     /**
      * @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;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @deprecated Use onPointerDown with (pointerData, cb)
      * @param entity - Entity to attach the callback
      * @param cb - Function to execute when click fires
      * @param opts - Opts to trigger Feedback and Button
@@ -41,6 +50,15 @@ export interface PointerEventsSystem {
     /**
      * @public
      * Execute callback when the user releases 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
+     */
+    onPointerUp(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @deprecated Use onPointerUp with (pointerData, cb)
      * @param entity - Entity to attach the callback
      * @param cb - Function to execute when click fires
      * @param opts - Opts to trigger Feedback and Button

package/dist/systems/events.js

@@ -76,6 +76,28 @@ export function createPointerEventsSystem(engine, inputSystem) {
             }
         }
     });
+    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);
+    };
     return {
         removeOnClick(entity) {
             removeEvent(entity, EventType.Click);
@@ -86,25 +108,16 @@ export function createPointerEventsSystem(engine, inputSystem) {
         removeOnPointerUp(entity) {
             removeEvent(entity, EventType.Up);
         },
-        onClick(entity, cb, opts) {
-            const options = getDefaultOpts(opts);
+        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);
         },
-        onPointerDown(entity, cb, opts) {
-            const options = getDefaultOpts(opts);
-            removeEvent(entity, EventType.Down);
-            getEvent(entity).set(EventType.Down, { cb, opts: options });
-            setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
-        },
-        onPointerUp(entity, cb, opts) {
-            const options = getDefaultOpts(opts);
-            removeEvent(entity, EventType.Up);
-            getEvent(entity).set(EventType.Up, { cb, opts: options });
-            setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options);
-        }
+        onPointerDown,
+        onPointerUp
     };
 }

package/dist/systems/raycast.d.ts

@@ -45,6 +45,15 @@ export interface RaycastSystem {
      * @public
      * Execute callback when the entity receives a RaycastResult component update.
      * Uses a Vector3 entity-local direction value to calculate the ray direction
+     * @param raycastData -  Entity to attach the callback and Raycast configuration options
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     */
+    registerLocalDirectionRaycast(raycastData: {
+        entity: Entity;
+        opts?: Partial<LocalDirectionRaycastOptions>;
+    }, callback: RaycastSystemCallback): void;
+    /**
+     * @deprecated use registerLocalDirectionRaycast(raycastData, cb) instead
      * @param entity - Entity to attach the callback
      * @param callback - Function to execute when the entity's RaycastResult component is updated
      * @param options - Raycast configuration options
@@ -54,6 +63,15 @@ export interface RaycastSystem {
      * @public
      * Execute callback when the entity receives a RaycastResult component update.
      * Uses a Vector3 global direction value to calculate the ray direction
+     * @param raycastData - Entity to attach the callback
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     */
+    registerGlobalDirectionRaycast(raycastData: {
+        entity: Entity;
+        opts?: Partial<GlobalDirectionRaycastOptions>;
+    }, callback: RaycastSystemCallback): void;
+    /**
+     * @deprecated use registerGlobalDirectionRaycast(raycastData, cb) instead
      * @param entity - Entity to attach the callback
      * @param callback - Function to execute when the entity's RaycastResult component is updated
      * @param options - Raycast configuration options
@@ -63,6 +81,15 @@ export interface RaycastSystem {
      * @public
      * Execute callback when the entity receives a RaycastResult component update.
      * Uses a Vector3 global target position to calculate the ray direction
+     * @param raycastData - Entity to attach the callback and Raycast configuration options
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     */
+    registerGlobalTargetRaycast(raycastData: {
+        entity: Entity;
+        opts?: Partial<GlobalTargetRaycastOptions>;
+    }, callback: RaycastSystemCallback): void;
+    /**
+     * @deprecated use registerGlobalTargetRaycast(raycastData, cb) instead
      * @param entity - Entity to attach the callback
      * @param callback - Function to execute when the entity's RaycastResult component is updated
      * @param options - Raycast configuration options
@@ -72,9 +99,46 @@ export interface RaycastSystem {
      * @public
      * Execute callback when the entity receives a RaycastResult component update.
      * Uses an target Entity value to calculate the ray direction
+     * @param raycastData - Entity to attach the callback
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     * @param options - Raycast configuration options
+     */
+    registerTargetEntityRaycast(raycastData: {
+        entity: Entity;
+        opts?: Partial<TargetEntityRaycastOptions>;
+    }, callback: RaycastSystemCallback): void;
+    /**
+     * @deprecated use registerTargetEntityRaycast(raycastData, cb) instead
      * @param entity - Entity to attach the callback
      * @param callback - Function to execute when the entity's RaycastResult component is updated
      * @param options - Raycast configuration options
      */
     registerTargetEntityRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<TargetEntityRaycastOptions>): void;
+    /**
+     * @public
+     * Creates Raycast local direction opts with defaults
+     */
+    localDirectionOptions(options?: Partial<LocalDirectionRaycastOptions>): RaycastSystemOptions;
+    /**
+     * @public
+     * Creates Raycast global direction opts with defaults
+     */
+    globalDirectionOptions(options?: Partial<GlobalDirectionRaycastOptions>): RaycastSystemOptions;
+    /**
+     * @public
+     * Creates Raycast global target direction opts with defaults
+     */
+    globalTargetOptions(options?: Partial<GlobalTargetRaycastOptions>): RaycastSystemOptions;
+    /**
+     * @public
+     * Creates Raycast target entity opts with defaults
+     */
+    targetEntitytOptions(options?: Partial<TargetEntityRaycastOptions>): RaycastSystemOptions;
+    /**
+     * @public
+     * Immediate mode Raycast to be used on a sytem rather than callbacks
+     *
+     * Use the options helper to create the specified raycast i.e. localDirectionOptions(opts)
+     */
+    registerRaycast(entity: Entity, options: RaycastSystemOptions): DeepReadonlyObject<PBRaycastResult> | null;
 }

package/dist/systems/raycast.js

@@ -4,8 +4,8 @@ import { EntityState } from '../engine/entity';
  * @internal
  */
 export function createRaycastSystem(engine) {
-    const raycastComponent = components.Raycast(engine);
-    const raycastResultComponent = components.RaycastResult(engine);
+    const Raycast = components.Raycast(engine);
+    const RaycastResult = components.RaycastResult(engine);
     const entitiesCallbackResultMap = new Map();
     const defaultOptions = {
         maxDistance: 16,
@@ -46,30 +46,30 @@ export function createRaycastSystem(engine) {
             targetEntity: options.targetEntity || 0
         }
     });
-    function registerRaycast(entity, callback, options) {
-        const raycast = raycastComponent.getOrCreateMutable(entity);
-        raycast.maxDistance = options.maxDistance;
-        raycast.originOffset = options.originOffset;
-        raycast.collisionMask = options.collisionMask;
-        raycast.direction = options.directionRawValue;
-        raycast.continuous = options.continuous;
-        raycast.queryType = options.queryType;
+    function registerRaycastWithCallback(entity, raycastValue, callback) {
+        const raycast = Raycast.getOrCreateMutable(entity);
+        raycast.maxDistance = raycastValue.maxDistance;
+        raycast.originOffset = raycastValue.originOffset;
+        raycast.collisionMask = raycastValue.collisionMask;
+        raycast.direction = raycastValue.directionRawValue;
+        raycast.continuous = raycastValue.continuous;
+        raycast.queryType = raycastValue.queryType;
         entitiesCallbackResultMap.set(entity, { callback: callback });
     }
     function removeRaycast(entity) {
-        raycastComponent.deleteFrom(entity);
-        raycastResultComponent.deleteFrom(entity);
+        Raycast.deleteFrom(entity);
+        RaycastResult.deleteFrom(entity);
         entitiesCallbackResultMap.delete(entity);
     }
     // @internal
     engine.addSystem(function EventSystem() {
         for (const [entity, data] of entitiesCallbackResultMap) {
-            const raycast = raycastComponent.getOrNull(entity);
+            const raycast = Raycast.getOrNull(entity);
             if (engine.getEntityState(entity) === EntityState.Removed || !raycast) {
                 entitiesCallbackResultMap.delete(entity);
                 continue;
             }
-            const currentResult = raycastResultComponent.getOrNull(entity);
+            const currentResult = RaycastResult.getOrNull(entity);
             if (!currentResult)
                 continue;
             data.callback(currentResult);
@@ -77,21 +77,62 @@ export function createRaycastSystem(engine) {
                 removeRaycast(entity);
         }
     });
+    const registerLocalDirectionRaycast = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return registerLocalDirectionRaycast({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        registerRaycastWithCallback(entity, getLocalDirectionRaycastDefaultOptions(opts), cb);
+    };
+    const registerGlobalDirectionRaycast = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return registerGlobalDirectionRaycast({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        registerRaycastWithCallback(entity, getGlobalDirectionRaycastDefaultOptions(opts), cb);
+    };
+    const registerGlobalTargetRaycast = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return registerGlobalTargetRaycast({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        registerRaycastWithCallback(entity, getGlobalTargetRaycastDefaultOptions(opts), cb);
+    };
+    const registerTargetEntityRaycast = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return registerTargetEntityRaycast({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        registerRaycastWithCallback(entity, getTargetEntityRaycastDefaultOptions(opts), cb);
+    };
     return {
         removeRaycasterEntity(entity) {
             removeRaycast(entity);
         },
-        registerLocalDirectionRaycast(entity, callback, opts) {
-            registerRaycast(entity, callback, getLocalDirectionRaycastDefaultOptions(opts));
-        },
-        registerGlobalDirectionRaycast(entity, callback, opts) {
-            registerRaycast(entity, callback, getGlobalDirectionRaycastDefaultOptions(opts));
-        },
-        registerGlobalTargetRaycast(entity, callback, opts) {
-            registerRaycast(entity, callback, getGlobalTargetRaycastDefaultOptions(opts));
+        registerLocalDirectionRaycast,
+        registerGlobalDirectionRaycast,
+        registerGlobalTargetRaycast,
+        registerTargetEntityRaycast,
+        registerRaycast(entity, opts) {
+            const raycast = Raycast.getOrNull(entity);
+            if (!raycast)
+                Raycast.create(entity, { ...opts, direction: opts.directionRawValue });
+            const value = RaycastResult.getOrNull(entity);
+            if (value) {
+                if (!opts.continuous) {
+                    RaycastResult.deleteFrom(entity);
+                    Raycast.deleteFrom(entity);
+                }
+            }
+            return value;
         },
-        registerTargetEntityRaycast(entity, callback, opts) {
-            registerRaycast(entity, callback, getTargetEntityRaycastDefaultOptions(opts));
-        }
+        localDirectionOptions: getLocalDirectionRaycastDefaultOptions,
+        globalDirectionOptions: getGlobalDirectionRaycastDefaultOptions,
+        globalTargetOptions: getGlobalTargetRaycastDefaultOptions,
+        targetEntitytOptions: getTargetEntityRaycastDefaultOptions
     };
 }

package/dist/systems/videoEvents.d.ts

@@ -11,4 +11,9 @@ export interface VideoEventsSystem {
     removeVideoEventsEntity(entity: Entity): void;
     registerVideoEventsEntity(entity: Entity, callback: VideoEventsSystemCallback): void;
     hasVideoEventsEntity(entity: Entity): boolean;
+    /**
+     * Returns the latest state of the VideoEvent
+     * @param entity - Entity to retrieve the video status
+     */
+    getVideoState(entity: Entity): DeepReadonlyObject<PBVideoEvent> | undefined;
 }

package/dist/systems/videoEvents.js

@@ -28,23 +28,14 @@ export function createVideoEventsSystem(engine) {
             }
             // Compare with last state
             const videoEvent = videoEventComponent.get(entity);
-            const values = videoEvent.values();
-            const valuesAmount = videoEvent.size;
-            let latestVideoEventComponentState = undefined;
-            // get latest component state
-            let index = 0;
-            for (const value of values) {
-                if (index === valuesAmount - 1)
-                    latestVideoEventComponentState = value;
-                index++;
-            }
-            if (latestVideoEventComponentState === undefined ||
-                (data.lastVideoState !== undefined && data.lastVideoState === latestVideoEventComponentState.state))
+            const values = Array.from(videoEvent.values());
+            const lastValue = values[videoEvent.size - 1];
+            if (lastValue === undefined || (data.lastVideoState !== undefined && data.lastVideoState === lastValue.state))
                 continue;
-            data.callback(latestVideoEventComponentState);
+            data.callback(lastValue);
             entitiesCallbackVideoStateMap.set(entity, {
                 callback: data.callback,
-                lastVideoState: latestVideoEventComponentState.state
+                lastVideoState: lastValue.state
             });
         }
     });
@@ -57,6 +48,12 @@ export function createVideoEventsSystem(engine) {
         },
         hasVideoEventsEntity(entity) {
             return hasVideoEventsEntity(entity);
+        },
+        getVideoState(entity) {
+            const videoEvent = videoEventComponent.get(entity);
+            const values = Array.from(videoEvent.values());
+            const lastValue = values[videoEvent.size - 1];
+            return lastValue;
         }
     };
 }

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

@@ -33,6 +33,15 @@ export interface PointerEventsSystem {
     /**
      * @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;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @deprecated Use onPointerDown with (pointerData, cb)
      * @param entity - Entity to attach the callback
      * @param cb - Function to execute when click fires
      * @param opts - Opts to trigger Feedback and Button
@@ -41,6 +50,15 @@ export interface PointerEventsSystem {
     /**
      * @public
      * Execute callback when the user releases 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
+     */
+    onPointerUp(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @deprecated Use onPointerUp with (pointerData, cb)
      * @param entity - Entity to attach the callback
      * @param cb - Function to execute when click fires
      * @param opts - Opts to trigger Feedback and Button

package/dist-cjs/systems/events.js

@@ -102,6 +102,28 @@ function createPointerEventsSystem(engine, inputSystem) {
             }
         }
     });
+    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);
+    };
     return {
         removeOnClick(entity) {
             removeEvent(entity, EventType.Click);
@@ -112,26 +134,17 @@ function createPointerEventsSystem(engine, inputSystem) {
         removeOnPointerUp(entity) {
             removeEvent(entity, EventType.Up);
         },
-        onClick(entity, cb, opts) {
-            const options = getDefaultOpts(opts);
+        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);
         },
-        onPointerDown(entity, cb, opts) {
-            const options = getDefaultOpts(opts);
-            removeEvent(entity, EventType.Down);
-            getEvent(entity).set(EventType.Down, { cb, opts: options });
-            setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
-        },
-        onPointerUp(entity, cb, opts) {
-            const options = getDefaultOpts(opts);
-            removeEvent(entity, EventType.Up);
-            getEvent(entity).set(EventType.Up, { cb, opts: options });
-            setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options);
-        }
+        onPointerDown,
+        onPointerUp
     };
 }
 exports.createPointerEventsSystem = createPointerEventsSystem;

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

@@ -45,6 +45,15 @@ export interface RaycastSystem {
      * @public
      * Execute callback when the entity receives a RaycastResult component update.
      * Uses a Vector3 entity-local direction value to calculate the ray direction
+     * @param raycastData -  Entity to attach the callback and Raycast configuration options
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     */
+    registerLocalDirectionRaycast(raycastData: {
+        entity: Entity;
+        opts?: Partial<LocalDirectionRaycastOptions>;
+    }, callback: RaycastSystemCallback): void;
+    /**
+     * @deprecated use registerLocalDirectionRaycast(raycastData, cb) instead
      * @param entity - Entity to attach the callback
      * @param callback - Function to execute when the entity's RaycastResult component is updated
      * @param options - Raycast configuration options
@@ -54,6 +63,15 @@ export interface RaycastSystem {
      * @public
      * Execute callback when the entity receives a RaycastResult component update.
      * Uses a Vector3 global direction value to calculate the ray direction
+     * @param raycastData - Entity to attach the callback
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     */
+    registerGlobalDirectionRaycast(raycastData: {
+        entity: Entity;
+        opts?: Partial<GlobalDirectionRaycastOptions>;
+    }, callback: RaycastSystemCallback): void;
+    /**
+     * @deprecated use registerGlobalDirectionRaycast(raycastData, cb) instead
      * @param entity - Entity to attach the callback
      * @param callback - Function to execute when the entity's RaycastResult component is updated
      * @param options - Raycast configuration options
@@ -63,6 +81,15 @@ export interface RaycastSystem {
      * @public
      * Execute callback when the entity receives a RaycastResult component update.
      * Uses a Vector3 global target position to calculate the ray direction
+     * @param raycastData - Entity to attach the callback and Raycast configuration options
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     */
+    registerGlobalTargetRaycast(raycastData: {
+        entity: Entity;
+        opts?: Partial<GlobalTargetRaycastOptions>;
+    }, callback: RaycastSystemCallback): void;
+    /**
+     * @deprecated use registerGlobalTargetRaycast(raycastData, cb) instead
      * @param entity - Entity to attach the callback
      * @param callback - Function to execute when the entity's RaycastResult component is updated
      * @param options - Raycast configuration options
@@ -72,9 +99,46 @@ export interface RaycastSystem {
      * @public
      * Execute callback when the entity receives a RaycastResult component update.
      * Uses an target Entity value to calculate the ray direction
+     * @param raycastData - Entity to attach the callback
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     * @param options - Raycast configuration options
+     */
+    registerTargetEntityRaycast(raycastData: {
+        entity: Entity;
+        opts?: Partial<TargetEntityRaycastOptions>;
+    }, callback: RaycastSystemCallback): void;
+    /**
+     * @deprecated use registerTargetEntityRaycast(raycastData, cb) instead
      * @param entity - Entity to attach the callback
      * @param callback - Function to execute when the entity's RaycastResult component is updated
      * @param options - Raycast configuration options
      */
     registerTargetEntityRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<TargetEntityRaycastOptions>): void;
+    /**
+     * @public
+     * Creates Raycast local direction opts with defaults
+     */
+    localDirectionOptions(options?: Partial<LocalDirectionRaycastOptions>): RaycastSystemOptions;
+    /**
+     * @public
+     * Creates Raycast global direction opts with defaults
+     */
+    globalDirectionOptions(options?: Partial<GlobalDirectionRaycastOptions>): RaycastSystemOptions;
+    /**
+     * @public
+     * Creates Raycast global target direction opts with defaults
+     */
+    globalTargetOptions(options?: Partial<GlobalTargetRaycastOptions>): RaycastSystemOptions;
+    /**
+     * @public
+     * Creates Raycast target entity opts with defaults
+     */
+    targetEntitytOptions(options?: Partial<TargetEntityRaycastOptions>): RaycastSystemOptions;
+    /**
+     * @public
+     * Immediate mode Raycast to be used on a sytem rather than callbacks
+     *
+     * Use the options helper to create the specified raycast i.e. localDirectionOptions(opts)
+     */
+    registerRaycast(entity: Entity, options: RaycastSystemOptions): DeepReadonlyObject<PBRaycastResult> | null;
 }

package/dist-cjs/systems/raycast.js

@@ -30,8 +30,8 @@ const entity_1 = require("../engine/entity");
  * @internal
  */
 function createRaycastSystem(engine) {
-    const raycastComponent = components.Raycast(engine);
-    const raycastResultComponent = components.RaycastResult(engine);
+    const Raycast = components.Raycast(engine);
+    const RaycastResult = components.RaycastResult(engine);
     const entitiesCallbackResultMap = new Map();
     const defaultOptions = {
         maxDistance: 16,
@@ -72,30 +72,30 @@ function createRaycastSystem(engine) {
             targetEntity: options.targetEntity || 0
         }
     });
-    function registerRaycast(entity, callback, options) {
-        const raycast = raycastComponent.getOrCreateMutable(entity);
-        raycast.maxDistance = options.maxDistance;
-        raycast.originOffset = options.originOffset;
-        raycast.collisionMask = options.collisionMask;
-        raycast.direction = options.directionRawValue;
-        raycast.continuous = options.continuous;
-        raycast.queryType = options.queryType;
+    function registerRaycastWithCallback(entity, raycastValue, callback) {
+        const raycast = Raycast.getOrCreateMutable(entity);
+        raycast.maxDistance = raycastValue.maxDistance;
+        raycast.originOffset = raycastValue.originOffset;
+        raycast.collisionMask = raycastValue.collisionMask;
+        raycast.direction = raycastValue.directionRawValue;
+        raycast.continuous = raycastValue.continuous;
+        raycast.queryType = raycastValue.queryType;
         entitiesCallbackResultMap.set(entity, { callback: callback });
     }
     function removeRaycast(entity) {
-        raycastComponent.deleteFrom(entity);
-        raycastResultComponent.deleteFrom(entity);
+        Raycast.deleteFrom(entity);
+        RaycastResult.deleteFrom(entity);
         entitiesCallbackResultMap.delete(entity);
     }
     // @internal
     engine.addSystem(function EventSystem() {
         for (const [entity, data] of entitiesCallbackResultMap) {
-            const raycast = raycastComponent.getOrNull(entity);
+            const raycast = Raycast.getOrNull(entity);
             if (engine.getEntityState(entity) === entity_1.EntityState.Removed || !raycast) {
                 entitiesCallbackResultMap.delete(entity);
                 continue;
             }
-            const currentResult = raycastResultComponent.getOrNull(entity);
+            const currentResult = RaycastResult.getOrNull(entity);
             if (!currentResult)
                 continue;
             data.callback(currentResult);
@@ -103,22 +103,63 @@ function createRaycastSystem(engine) {
                 removeRaycast(entity);
         }
     });
+    const registerLocalDirectionRaycast = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return registerLocalDirectionRaycast({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        registerRaycastWithCallback(entity, getLocalDirectionRaycastDefaultOptions(opts), cb);
+    };
+    const registerGlobalDirectionRaycast = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return registerGlobalDirectionRaycast({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        registerRaycastWithCallback(entity, getGlobalDirectionRaycastDefaultOptions(opts), cb);
+    };
+    const registerGlobalTargetRaycast = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return registerGlobalTargetRaycast({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        registerRaycastWithCallback(entity, getGlobalTargetRaycastDefaultOptions(opts), cb);
+    };
+    const registerTargetEntityRaycast = (...args) => {
+        const [data, cb, maybeOpts] = args;
+        if (typeof data === 'number') {
+            return registerTargetEntityRaycast({ entity: data, opts: maybeOpts ?? {} }, cb);
+        }
+        const { entity, opts } = data;
+        registerRaycastWithCallback(entity, getTargetEntityRaycastDefaultOptions(opts), cb);
+    };
     return {
         removeRaycasterEntity(entity) {
             removeRaycast(entity);
         },
-        registerLocalDirectionRaycast(entity, callback, opts) {
-            registerRaycast(entity, callback, getLocalDirectionRaycastDefaultOptions(opts));
-        },
-        registerGlobalDirectionRaycast(entity, callback, opts) {
-            registerRaycast(entity, callback, getGlobalDirectionRaycastDefaultOptions(opts));
-        },
-        registerGlobalTargetRaycast(entity, callback, opts) {
-            registerRaycast(entity, callback, getGlobalTargetRaycastDefaultOptions(opts));
+        registerLocalDirectionRaycast,
+        registerGlobalDirectionRaycast,
+        registerGlobalTargetRaycast,
+        registerTargetEntityRaycast,
+        registerRaycast(entity, opts) {
+            const raycast = Raycast.getOrNull(entity);
+            if (!raycast)
+                Raycast.create(entity, { ...opts, direction: opts.directionRawValue });
+            const value = RaycastResult.getOrNull(entity);
+            if (value) {
+                if (!opts.continuous) {
+                    RaycastResult.deleteFrom(entity);
+                    Raycast.deleteFrom(entity);
+                }
+            }
+            return value;
         },
-        registerTargetEntityRaycast(entity, callback, opts) {
-            registerRaycast(entity, callback, getTargetEntityRaycastDefaultOptions(opts));
-        }
+        localDirectionOptions: getLocalDirectionRaycastDefaultOptions,
+        globalDirectionOptions: getGlobalDirectionRaycastDefaultOptions,
+        globalTargetOptions: getGlobalTargetRaycastDefaultOptions,
+        targetEntitytOptions: getTargetEntityRaycastDefaultOptions
     };
 }
 exports.createRaycastSystem = createRaycastSystem;

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

@@ -11,4 +11,9 @@ export interface VideoEventsSystem {
     removeVideoEventsEntity(entity: Entity): void;
     registerVideoEventsEntity(entity: Entity, callback: VideoEventsSystemCallback): void;
     hasVideoEventsEntity(entity: Entity): boolean;
+    /**
+     * Returns the latest state of the VideoEvent
+     * @param entity - Entity to retrieve the video status
+     */
+    getVideoState(entity: Entity): DeepReadonlyObject<PBVideoEvent> | undefined;
 }

package/dist-cjs/systems/videoEvents.js

@@ -54,23 +54,14 @@ function createVideoEventsSystem(engine) {
             }
             // Compare with last state
             const videoEvent = videoEventComponent.get(entity);
-            const values = videoEvent.values();
-            const valuesAmount = videoEvent.size;
-            let latestVideoEventComponentState = undefined;
-            // get latest component state
-            let index = 0;
-            for (const value of values) {
-                if (index === valuesAmount - 1)
-                    latestVideoEventComponentState = value;
-                index++;
-            }
-            if (latestVideoEventComponentState === undefined ||
-                (data.lastVideoState !== undefined && data.lastVideoState === latestVideoEventComponentState.state))
+            const values = Array.from(videoEvent.values());
+            const lastValue = values[videoEvent.size - 1];
+            if (lastValue === undefined || (data.lastVideoState !== undefined && data.lastVideoState === lastValue.state))
                 continue;
-            data.callback(latestVideoEventComponentState);
+            data.callback(lastValue);
             entitiesCallbackVideoStateMap.set(entity, {
                 callback: data.callback,
-                lastVideoState: latestVideoEventComponentState.state
+                lastVideoState: lastValue.state
             });
         }
     });
@@ -83,6 +74,12 @@ function createVideoEventsSystem(engine) {
         },
         hasVideoEventsEntity(entity) {
             return hasVideoEventsEntity(entity);
+        },
+        getVideoState(entity) {
+            const videoEvent = videoEventComponent.get(entity);
+            const values = Array.from(videoEvent.values());
+            const lastValue = values[videoEvent.size - 1];
+            return lastValue;
         }
     };
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.1.18-5157707330.commit-091fce4",
+  "version": "7.1.18-5158337338.commit-735bf67",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "dependencies": {
-    "@dcl/js-runtime": "7.1.18-5157707330.commit-091fce4"
+    "@dcl/js-runtime": "7.1.18-5158337338.commit-735bf67"
   },
   "files": [
     "dist",
@@ -25,7 +25,8 @@
     "directory": "packages/@dcl/ecs"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json"
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json",
+    "watch": "tsc -p tsconfig.json --watch"
   },
   "typedoc": {
     "entryPoint": "./src/index.ts",
@@ -35,5 +36,5 @@
   },
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "091fce4615f18681efcef4556b5fc76652a79639"
+  "commit": "735bf678b8390821dd0fdd6046e78963212bed6c"
 }