@dcl/playground-assets 7.18.2-21450088960.commit-3c16004 → 7.18.2-21457748765.commit-7ae2e38

package/dist/alpha.d.ts

@@ -1619,6 +1619,27 @@ export declare function createPointerEventsSystem(engine: IEngine, inputSystem:
  */
 export declare function createReactBasedUiSystem(engine: IEngine, pointerSystem: PointerEventsSystem): ReactBasedUiSystem;
 
+/**
+ * Creates a timer system bound to a specific engine instance.
+ *
+ * @param targetEngine - The engine instance to bind timers to
+ * @returns A Timers object with setTimeout, clearTimeout, setInterval, and clearInterval methods
+ *
+ * @example
+ * ```ts
+ * import { Engine } from '@dcl/sdk/ecs'
+ * import { createTimers } from '@dcl/sdk/ecs'
+ *
+ * const engine = Engine()
+ * const timers = createTimers(engine)
+ *
+ * timers.setTimeout(() => console.log('done'), 1000)
+ * ```
+ *
+ * @public
+ */
+export declare function createTimers(targetEngine: IEngine): Timers;
+
 /**
  * @public
  * @returns tween helper to be used on the scene
@@ -1983,6 +2004,7 @@ export declare type EventSystemOptions = {
     maxDistance?: number;
     showFeedback?: boolean;
     showHighlight?: boolean;
+    maxPlayerDistance?: number;
 };
 
 /**
@@ -1999,6 +2021,90 @@ export declare type ExcludeUndefined<T> = {
  */
 export declare const executeTask: (task: Task<unknown>) => void;
 
+/**
+ * Flattened material interface for simplified property access
+ * @public
+ */
+export declare interface FlatMaterial {
+    /**
+     * Access to the main texture properties (works for both PBR and Unlit materials)
+     */
+    readonly texture: FlatTexture;
+    /**
+     * Access to the alpha texture properties (works for both PBR and Unlit materials)
+     */
+    readonly alphaTexture: FlatTexture;
+    /**
+     * Access to the emissive texture properties (PBR only - returns undefined for Unlit materials)
+     */
+    readonly emissiveTexture: FlatTexture | undefined;
+    /**
+     * Access to the bump/normal texture properties (PBR only - returns undefined for Unlit materials)
+     */
+    readonly bumpTexture: FlatTexture | undefined;
+    /**
+     * Alpha test threshold (0-1). Default: 0.5
+     */
+    alphaTest: number | undefined;
+    /**
+     * Whether the material casts shadows. Default: true
+     */
+    castShadows: boolean | undefined;
+    /**
+     * Albedo/base color (PBR only). Default: white
+     */
+    albedoColor: PBColor4 | undefined;
+    /**
+     * Emissive color (PBR only). Default: black
+     */
+    emissiveColor: PBColor3 | undefined;
+    /**
+     * Reflectivity color (PBR only). Default: white
+     */
+    reflectivityColor: PBColor3 | undefined;
+    /**
+     * Transparency mode (PBR only). Default: MTM_AUTO
+     */
+    transparencyMode: MaterialTransparencyMode | undefined;
+    /**
+     * Metallic value 0-1 (PBR only). Default: 0.5
+     */
+    metallic: number | undefined;
+    /**
+     * Roughness value 0-1 (PBR only). Default: 0.5
+     */
+    roughness: number | undefined;
+    /**
+     * Specular intensity (PBR only). Default: 1
+     */
+    specularIntensity: number | undefined;
+    /**
+     * Emissive intensity (PBR only). Default: 2
+     */
+    emissiveIntensity: number | undefined;
+    /**
+     * Direct light intensity (PBR only). Default: 1
+     */
+    directIntensity: number | undefined;
+    /**
+     * Diffuse color (Unlit only). Default: white
+     */
+    diffuseColor: PBColor4 | undefined;
+}
+
+/**
+ * Flattened texture interface for simplified property access
+ * @public
+ */
+export declare interface FlatTexture {
+    /** Path to the texture file */
+    src: string | undefined;
+    /** Texture wrapping behavior */
+    wrapMode: TextureWrapMode | undefined;
+    /** Texture filtering mode */
+    filterMode: TextureFilterMode | undefined;
+}
+
 /**
  * @public
  */
@@ -2053,6 +2159,66 @@ export declare function getCompositeRootComponent(engine: IEngine): LastWriteWin
 
 export declare const getDefaultOpts: (opts?: Partial<EventSystemOptions>) => EventSystemOptions;
 
+/**
+ * Get all entities that have the given entity as their parent
+ * @public
+ * @param engine - the engine running the entities
+ * @param parent - the parent entity to find children for
+ * @returns An array of entities that have the given parent
+ *
+ * Example:
+ * ```ts
+ * const children = getEntitiesWithParent(engine, myEntity)
+ * for (const child of children) {
+ *   // process each child entity
+ * }
+ * ```
+ */
+export declare function getEntitiesWithParent(engine: Pick<IEngine, 'getEntitiesWith' | 'defineComponentFromSchema'>, parent: Entity): Entity[];
+
+/**
+ * Get the world position of an entity, taking into account the full parent hierarchy.
+ * This computes the world-space position by accumulating all parent transforms
+ * (position, rotation, and scale).
+ *
+ * When the entity has AvatarAttach and Transform, the renderer updates the Transform
+ * with avatar-relative values (including the exact anchor point offset for hand, head, etc.).
+ * This function combines the player's transform with those values to compute the world position.
+ *
+ * @public
+ * @param engine - the engine running the entities
+ * @param entity - the entity to get the world position for
+ * @returns The entity's position in world space. Returns `{x: 0, y: 0, z: 0}` if the entity has no Transform.
+ *
+ * Example:
+ * ```ts
+ * const worldPos = getWorldPosition(engine, childEntity)
+ * console.log(`World position: ${worldPos.x}, ${worldPos.y}, ${worldPos.z}`)
+ * ```
+ */
+export declare function getWorldPosition(engine: WorldTransformEngine, entity: Entity): Vector3Type;
+
+/**
+ * Get the world rotation of an entity, taking into account the full parent hierarchy.
+ * This computes the world-space rotation by combining all parent rotations.
+ *
+ * When the entity has AvatarAttach and Transform, the renderer updates the Transform
+ * with avatar-relative values (including the exact anchor point rotation for hand, head, etc.).
+ * This function combines the player's rotation with those values to compute the world rotation.
+ *
+ * @public
+ * @param engine - the engine running the entities
+ * @param entity - the entity to get the world rotation for
+ * @returns The entity's rotation in world space as a quaternion. Returns identity quaternion `{x: 0, y: 0, z: 0, w: 1}` if the entity has no Transform.
+ *
+ * Example:
+ * ```ts
+ * const worldRot = getWorldRotation(engine, childEntity)
+ * console.log(`World rotation: ${worldRot.x}, ${worldRot.y}, ${worldRot.z}, ${worldRot.w}`)
+ * ```
+ */
+export declare function getWorldRotation(engine: WorldTransformEngine, entity: Entity): QuaternionType;
+
 export declare type GlobalDirectionRaycastOptions = RaycastSystemOptions & GlobalDirectionRaycastSystemOptions;
 
 export declare type GlobalDirectionRaycastSystemOptions = {
@@ -2804,6 +2970,42 @@ export declare interface MaterialComponentDefinitionExtended extends LastWriteWi
      * @param material - the PBR data for this material
      */
     setPbrMaterial: (entity: Entity, material: PBMaterial_PbrMaterial) => void;
+    /**
+     * Get a readonly flattened accessor for the material's properties.
+     * Simplifies reading material properties without navigating nested unions.
+     * Works for both PBR and Unlit materials.
+     * Throws if the entity does not have a Material component.
+     * @param entity - Entity with the Material component
+     * @returns A readonly accessor object with direct access to material properties
+     *
+     */
+    getFlat: (entity: Entity) => ReadonlyFlatMaterial;
+    /**
+     * Get a readonly flattened accessor for the material's properties, or null if the entity
+     * does not have a Material component.
+     * @param entity - Entity to check for Material component
+     * @returns A readonly accessor object, or null if no Material component exists
+     *
+     */
+    getFlatOrNull: (entity: Entity) => ReadonlyFlatMaterial | null;
+    /**
+     * Get a mutable flattened accessor for the material's properties.
+     * Simplifies reading/writing material properties without navigating nested unions.
+     * Works for both PBR and Unlit materials.
+     * Throws if the entity does not have a Material component.
+     * @param entity - Entity with the Material component
+     * @returns A mutable accessor object with direct access to material properties
+     *
+     */
+    getFlatMutable: (entity: Entity) => FlatMaterial;
+    /**
+     * Get a mutable flattened accessor for the material's properties, or null if the entity
+     * does not have a Material component.
+     * @param entity - Entity to check for Material component
+     * @returns A mutable accessor object, or null if no Material component exists
+     *
+     */
+    getFlatMutableOrNull: (entity: Entity) => FlatMaterial | null;
 }
 
 /**
@@ -5112,6 +5314,29 @@ export declare namespace PBPlayerIdentityData {
  *
  * It also supports simple visual feedback when interactions occur, by showing floating text.
  * More sophisticated feedback requires the use of other components.
+ *
+ * Distance rules
+ * --------------
+ * PointerEvents can enforce interaction range using two independent distance checks:
+ *
+ * - Camera distance (`max_distance`): distance from the active camera to the target entity.
+ * - Player distance (`max_player_distance`): distance from the avatar/player position to the target entity.
+ *
+ * How the interaction checks are combined:
+ *
+ * 1) Only `max_distance` is present
+ *    - The interaction is allowed only if the camera distance is <= `max_distance`.
+ *
+ * 2) Only `max_player_distance` is present
+ *    - The interaction is allowed only if the player distance is <= `max_player_distance`.
+ *
+ * 3) Both `max_distance` and `max_player_distance` are present
+ *    - The interaction is allowed if ANY of the checks passes (OR logic):
+ *      (camera distance <= `max_distance`) OR (player distance <= `max_player_distance`).
+ *
+ * 4) Neither `max_distance` nor `max_player_distance` is present
+ *    - The system behaves as if `max_distance` were set to its default value (10),
+ *      i.e., it uses the camera distance check with a threshold of 10.
  */
 /**
  * @public
@@ -5161,6 +5386,8 @@ export declare interface PBPointerEvents_Info {
     showFeedback?: boolean | undefined;
     /** enable or disable hover highlight (default true) */
     showHighlight?: boolean | undefined;
+    /** range of interaction from the avatar's position (default 0) */
+    maxPlayerDistance?: number | undefined;
 }
 
 /**
@@ -7021,6 +7248,90 @@ export declare type ReadonlyComponentSchema<T extends [ComponentDefinition<unkno
     [K in keyof T]: T[K] extends ComponentDefinition<unknown> ? ReturnType<T[K]['get']> : never;
 };
 
+/**
+ * Readonly flattened material interface for read-only property access
+ * @public
+ */
+export declare interface ReadonlyFlatMaterial {
+    /**
+     * Access to the main texture properties (works for both PBR and Unlit materials)
+     */
+    readonly texture: ReadonlyFlatTexture;
+    /**
+     * Access to the alpha texture properties (works for both PBR and Unlit materials)
+     */
+    readonly alphaTexture: ReadonlyFlatTexture;
+    /**
+     * Access to the emissive texture properties (PBR only - returns undefined for Unlit materials)
+     */
+    readonly emissiveTexture: ReadonlyFlatTexture | undefined;
+    /**
+     * Access to the bump/normal texture properties (PBR only - returns undefined for Unlit materials)
+     */
+    readonly bumpTexture: ReadonlyFlatTexture | undefined;
+    /**
+     * Alpha test threshold (0-1). Default: 0.5
+     */
+    readonly alphaTest: number | undefined;
+    /**
+     * Whether the material casts shadows. Default: true
+     */
+    readonly castShadows: boolean | undefined;
+    /**
+     * Albedo/base color (PBR only). Default: white
+     */
+    readonly albedoColor: PBColor4 | undefined;
+    /**
+     * Emissive color (PBR only). Default: black
+     */
+    readonly emissiveColor: PBColor3 | undefined;
+    /**
+     * Reflectivity color (PBR only). Default: white
+     */
+    readonly reflectivityColor: PBColor3 | undefined;
+    /**
+     * Transparency mode (PBR only). Default: MTM_AUTO
+     */
+    readonly transparencyMode: MaterialTransparencyMode | undefined;
+    /**
+     * Metallic value 0-1 (PBR only). Default: 0.5
+     */
+    readonly metallic: number | undefined;
+    /**
+     * Roughness value 0-1 (PBR only). Default: 0.5
+     */
+    readonly roughness: number | undefined;
+    /**
+     * Specular intensity (PBR only). Default: 1
+     */
+    readonly specularIntensity: number | undefined;
+    /**
+     * Emissive intensity (PBR only). Default: 2
+     */
+    readonly emissiveIntensity: number | undefined;
+    /**
+     * Direct light intensity (PBR only). Default: 1
+     */
+    readonly directIntensity: number | undefined;
+    /**
+     * Diffuse color (Unlit only). Default: white
+     */
+    readonly diffuseColor: PBColor4 | undefined;
+}
+
+/**
+ * Readonly flattened texture interface for read-only property access
+ * @public
+ */
+export declare interface ReadonlyFlatTexture {
+    /** Path to the texture file */
+    readonly src: string | undefined;
+    /** Texture wrapping behavior */
+    readonly wrapMode: TextureWrapMode | undefined;
+    /** Texture filtering mode */
+    readonly filterMode: TextureFilterMode | undefined;
+}
+
 /**
  * @public
  */
@@ -7687,6 +7998,79 @@ export declare const enum TextWrap {
     TW_NO_WRAP = 1
 }
 
+export declare type TimerCallback = () => void;
+
+export declare type TimerId = number;
+
+export declare type Timers = {
+    /**
+     * Delays the execution of a function by a given amount of milliseconds.
+     *
+     * @param callback - The function to execute after the delay
+     * @param ms - The delay in milliseconds
+     * @returns A TimerId that can be used to cancel the timeout
+     *
+     * @example
+     * ```ts
+     * const timeoutId = timers.setTimeout(() => {
+     *   console.log('1 second passed')
+     * }, 1000)
+     * ```
+     */
+    setTimeout(callback: TimerCallback, ms: number): TimerId;
+    /**
+     * Cancels a timeout previously established by setTimeout.
+     *
+     * @param timerId - The TimerId returned by setTimeout
+     *
+     * @example
+     * ```ts
+     * const timeoutId = timers.setTimeout(() => {
+     *   console.log('This will not run')
+     * }, 1000)
+     *
+     * timers.clearTimeout(timeoutId)
+     * ```
+     */
+    clearTimeout(timerId: TimerId): void;
+    /**
+     * Repeatedly executes a function at specified intervals.
+     *
+     * @param callback - The function to execute at each interval
+     * @param ms - The interval in milliseconds
+     * @returns A TimerId that can be used to cancel the interval
+     *
+     * @example
+     * ```ts
+     * const intervalId = timers.setInterval(() => {
+     *   console.log('Printing this every 1 second')
+     * }, 1000)
+     * ```
+     */
+    setInterval(callback: TimerCallback, ms: number): TimerId;
+    /**
+     * Cancels an interval previously established by setInterval.
+     *
+     * @param timerId - The TimerId returned by setInterval
+     *
+     * @example
+     * ```ts
+     * const intervalId = timers.setInterval(() => {
+     *   console.log('This will stop')
+     * }, 1000)
+     *
+     * timers.clearInterval(intervalId)
+     * ```
+     */
+    clearInterval(timerId: TimerId): void;
+};
+
+/**
+ * @public
+ * Timer utilities for delayed and repeated execution.
+ */
+export declare const timers: Timers;
+
 /**
  * Constant used to convert a value to gamma space
  * @public
@@ -9032,6 +9416,9 @@ export declare interface VirtualCameraComponentDefinitionExtended extends LastWr
 /** @public */
 export declare const VisibilityComponent: LastWriteWinElementSetComponentDefinition<PBVisibilityComponent>;
 
+/** @public Engine type for world transform functions */
+export declare type WorldTransformEngine = Pick<IEngine, 'getEntitiesWith' | 'defineComponentFromSchema' | 'PlayerEntity'>;
+
 /**
  * @public
  */