@dcl/ecs 7.1.8-4756315995.commit-6d7fbd0 → 7.1.8-4757726595.commit-28cb54f

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from './runtime/initialization';
 export * from './runtime/types';
 export { cyclicParentingChecker } from './systems/cyclicParentingChecker';
 export * from './systems/events';
+export * from './systems/raycast';
 export * from './systems/async-task';
 export * from './engine/entity';
 export * from './components/types';

package/dist/index.js

@@ -5,6 +5,7 @@ export * from './runtime/initialization';
 export * from './runtime/types';
 export { cyclicParentingChecker } from './systems/cyclicParentingChecker';
 export * from './systems/events';
+export * from './systems/raycast';
 export * from './systems/async-task';
 export * from './engine/entity';
 export * from './components/types';

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

@@ -6,6 +6,7 @@ import { IEngine } from '../../engine';
 import { Task } from '../../systems/async-task';
 import { PointerEventsSystem } from '../../systems/events';
 import { IInputSystem } from './../../engine/input';
+import { RaycastSystem } from '../../systems/raycast';
 /**
  * @public
  * The engine is the part of the scene that sits in the middle and manages all of the other parts.
@@ -31,10 +32,16 @@ export declare const inputSystem: IInputSystem;
 export { IInputSystem };
 /**
  * @public
- * Register callback functions to a particular entity.
+ * Register callback functions to a particular entity on input events.
  */
 export declare const pointerEventsSystem: PointerEventsSystem;
 export { PointerEventsSystem };
+/**
+ * @public
+ * Register callback functions to a particular entity on raycast results.
+ */
+export declare const raycastSystem: RaycastSystem;
+export { RaycastSystem };
 /**
  * @public
  * Runs an async function

package/dist/runtime/initialization/index.js

@@ -4,8 +4,9 @@
  */
 import { Engine } from '../../engine';
 import { createTaskSystem } from '../../systems/async-task';
-import { createPointerEventSystem } from '../../systems/events';
+import { createPointerEventsSystem } from '../../systems/events';
 import { createInputSystem } from './../../engine/input';
+import { createRaycastSystem } from '../../systems/raycast';
 /**
  * @public
  * The engine is the part of the scene that sits in the middle and manages all of the other parts.
@@ -30,9 +31,14 @@ export const engine = /* @__PURE__ */ Engine();
 export const inputSystem = /* @__PURE__ */ createInputSystem(engine);
 /**
  * @public
- * Register callback functions to a particular entity.
+ * Register callback functions to a particular entity on input events.
  */
-export const pointerEventsSystem = /* @__PURE__ */ createPointerEventSystem(engine, inputSystem);
+export const pointerEventsSystem = /* @__PURE__ */ createPointerEventsSystem(engine, inputSystem);
+/**
+ * @public
+ * Register callback functions to a particular entity on raycast results.
+ */
+export const raycastSystem = /* @__PURE__ */ createRaycastSystem(engine);
 /**
  * @public
  * Runs an async function

package/dist/systems/events.js

@@ -4,7 +4,7 @@ import { checkNotThenable } from '../runtime/invariant';
 /**
  * @internal
  */
-export function createPointerEventSystem(engine, inputSystem) {
+export function createPointerEventsSystem(engine, inputSystem) {
     const PointerEvents = components.PointerEvents(engine);
     let EventType;
     (function (EventType) {

package/dist/systems/raycast.d.ts

@@ -0,0 +1,80 @@
+import { RaycastQueryType, PBRaycastResult } from '../components';
+import { DeepReadonlyObject, Entity } from '../engine';
+import { Vector3 } from '../components/generated/pb/decentraland/common/vectors.gen';
+/**
+ * @public
+ */
+export type RaycastSystemCallback = (event: DeepReadonlyObject<PBRaycastResult>) => void;
+/**
+ * @public
+ */
+export type RaycastSystemOptions = {
+    originOffset?: Vector3 | undefined;
+    maxDistance: number;
+    queryType: RaycastQueryType;
+    continuous?: boolean | undefined;
+    collisionMask?: number | undefined;
+};
+export type LocalDirectionRaycastSystemOptions = {
+    direction?: Vector3;
+};
+export type LocalDirectionRaycastOptions = RaycastSystemOptions & LocalDirectionRaycastSystemOptions;
+export type GlobalDirectionRaycastSystemOptions = {
+    direction?: Vector3;
+};
+export type GlobalDirectionRaycastOptions = RaycastSystemOptions & GlobalDirectionRaycastSystemOptions;
+export type GlobalTargetRaycastSystemOptions = {
+    target?: Vector3;
+};
+export type GlobalTargetRaycastOptions = RaycastSystemOptions & GlobalTargetRaycastSystemOptions;
+export type TargetEntityRaycastSystemOptions = {
+    targetEntity?: number;
+};
+export type TargetEntityRaycastOptions = RaycastSystemOptions & TargetEntityRaycastSystemOptions;
+/**
+ * @public
+ */
+export interface RaycastSystem {
+    /**
+     * @public
+     * Remove the callback for raycast event
+     * @param entity - Entity where the callback was attached
+     */
+    removeRaycasterEntity(entity: Entity): void;
+    /**
+     * @public
+     * Execute callback when the entity receives a RaycastResult component update.
+     * Uses a Vector3 entity-local direction value to calculate the ray direction
+     * @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
+     */
+    registerLocalDirectionRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<LocalDirectionRaycastOptions>): void;
+    /**
+     * @public
+     * Execute callback when the entity receives a RaycastResult component update.
+     * Uses a Vector3 global direction value to calculate the ray direction
+     * @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
+     */
+    registerGlobalDirectionRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<GlobalDirectionRaycastOptions>): void;
+    /**
+     * @public
+     * Execute callback when the entity receives a RaycastResult component update.
+     * Uses a Vector3 global target position to calculate the ray direction
+     * @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
+     */
+    registerGlobalTargetRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<GlobalTargetRaycastOptions>): void;
+    /**
+     * @public
+     * Execute callback when the entity receives a RaycastResult component update.
+     * Uses an target Entity value to calculate the ray direction
+     * @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;
+}

package/dist/systems/raycast.js

@@ -0,0 +1,97 @@
+import * as components from '../components';
+import { EntityState } from '../engine/entity';
+/**
+ * @internal
+ */
+export function createRaycastSystem(engine) {
+    const raycastComponent = components.Raycast(engine);
+    const raycastResultComponent = components.RaycastResult(engine);
+    const entitiesCallbackResultMap = new Map();
+    const defaultOptions = {
+        maxDistance: 16,
+        queryType: 0 /* RaycastQueryType.RQT_HIT_FIRST */,
+        continuous: false,
+        originOffset: { x: 0, y: 0, z: 0 },
+        collisionMask: 2 /* ColliderLayer.CL_PHYSICS */
+    };
+    const getLocalDirectionRaycastDefaultOptions = (options = {}) => ({
+        ...defaultOptions,
+        ...options,
+        directionRawValue: {
+            $case: 'localDirection',
+            localDirection: options.direction || { x: 0, y: 0, z: 1 }
+        }
+    });
+    const getGlobalDirectionRaycastDefaultOptions = (options = {}) => ({
+        ...defaultOptions,
+        ...options,
+        directionRawValue: {
+            $case: 'globalDirection',
+            globalDirection: options.direction || { x: 0, y: 0, z: 1 }
+        }
+    });
+    const getGlobalTargetRaycastDefaultOptions = (options = {}) => ({
+        ...defaultOptions,
+        ...options,
+        directionRawValue: {
+            $case: 'globalTarget',
+            globalTarget: options.target || { x: 0, y: 0, z: 0 }
+        }
+    });
+    const getTargetEntityRaycastDefaultOptions = (options = {}) => ({
+        ...defaultOptions,
+        ...options,
+        directionRawValue: {
+            $case: 'targetEntity',
+            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;
+        entitiesCallbackResultMap.set(entity, { callback: callback });
+    }
+    function removeRaycast(entity) {
+        raycastComponent.deleteFrom(entity);
+        raycastResultComponent.deleteFrom(entity);
+        entitiesCallbackResultMap.delete(entity);
+    }
+    // @internal
+    engine.addSystem(function EventSystem() {
+        for (const [entity, data] of entitiesCallbackResultMap) {
+            const raycast = raycastComponent.getOrNull(entity);
+            if (engine.getEntityState(entity) === EntityState.Removed || !raycast) {
+                entitiesCallbackResultMap.delete(entity);
+                continue;
+            }
+            const currentResult = raycastResultComponent.getOrNull(entity);
+            if (!currentResult)
+                continue;
+            data.callback(currentResult);
+            if (!raycast.continuous)
+                removeRaycast(entity);
+        }
+    });
+    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));
+        },
+        registerTargetEntityRaycast(entity, callback, opts) {
+            registerRaycast(entity, callback, getTargetEntityRaycastDefaultOptions(opts));
+        }
+    };
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.1.8-4756315995.commit-6d7fbd0",
+  "version": "7.1.8-4757726595.commit-28cb54f",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "dependencies": {
-    "@dcl/js-runtime": "7.1.8-4756315995.commit-6d7fbd0"
+    "@dcl/js-runtime": "7.1.8-4757726595.commit-28cb54f"
   },
   "devDependencies": {
     "ts-proto": "^1.122.0"
@@ -34,5 +34,5 @@
   },
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "6d7fbd0161e9d081ffb08992f9b6695f5ee026ab"
+  "commit": "28cb54f0e017f80c02592ebe17b35faaef720882"
 }