@dcl/ecs 7.20.2-22231111352.commit-d2f6f0a → 7.20.2-22309446491.commit-b942bde

package/dist/engine/input.js

@@ -118,9 +118,8 @@ export function createInputSystem(engine) {
         }
         if (!up || !down)
             return null;
-        // If the DOWN command has happened before or at the same time as the UP command, a click has happened.
-        // Same-timestamp is possible when both events are produced within the same renderer tick.
-        if (down.timestamp <= up.timestamp && timestampIsCurrentFrame(up.timestamp)) {
+        // If the DOWN command has happen before the UP commands, it means that that a clicked has happen
+        if (down.timestamp < up.timestamp && timestampIsCurrentFrame(up.timestamp)) {
             return { up, down };
         }
         return null;
@@ -186,11 +185,17 @@ export function createInputSystem(engine) {
     function isPressed(inputAction) {
         return globalState.buttonState.get(inputAction)?.state === 1 /* PointerEventType.PET_DOWN */;
     }
+    function* getInputCommands() {
+        for (let i = globalState.thisFrameCommands.length - 1; i >= 0; i--) {
+            yield globalState.thisFrameCommands[i];
+        }
+    }
     return {
         isPressed,
         getClick,
         getInputCommand,
         isClicked,
-        isTriggered
+        isTriggered,
+        getInputCommands
     };
 }

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './schemas';
 export * from './runtime/initialization';
 export * from './runtime/types';
 export * from './runtime/helpers';
+export * from './runtime/globals';
 export { cyclicParentingChecker } from './systems/cyclicParentingChecker';
 export * from './systems/events';
 export * from './systems/raycast';

package/dist/index.js

@@ -4,6 +4,7 @@ export * from './schemas';
 export * from './runtime/initialization';
 export * from './runtime/types';
 export * from './runtime/helpers';
+export * from './runtime/globals';
 export { cyclicParentingChecker } from './systems/cyclicParentingChecker';
 export * from './systems/events';
 export * from './systems/raycast';

package/dist/runtime/globals.d.ts

@@ -1,4 +1,14 @@
 /**
- * Internal utilities for standardized globalThis access.
+ * Utilities for standardized globalThis access.
+ * @public
  */
-export {};
+/**
+ * Type-safe globalThis property access.
+ * @public
+ */
+export declare function getGlobal<T>(key: string): T | undefined;
+/**
+ * Sets a globalThis property as a polyfill (only if undefined/null).
+ * @public
+ */
+export declare function setGlobalPolyfill<T>(key: string, value: T): void;

package/dist/runtime/globals.js

@@ -1,16 +1,17 @@
 /**
- * Internal utilities for standardized globalThis access.
+ * Utilities for standardized globalThis access.
+ * @public
  */
 /**
  * Type-safe globalThis property access.
- * @internal
+ * @public
  */
 export function getGlobal(key) {
     return globalThis[key];
 }
 /**
  * Sets a globalThis property as a polyfill (only if undefined/null).
- * @internal
+ * @public
  */
 export function setGlobalPolyfill(key, value) {
     ;

package/dist/systems/events.d.ts

@@ -18,6 +18,12 @@ export type EventSystemOptions = {
     showHighlight?: boolean;
     maxPlayerDistance?: number;
 };
+/**
+ * @public
+ */
+export type EventSystemOptionsCallback = EventSystemOptions & {
+    cb: EventSystemCallback;
+};
 export declare const getDefaultOpts: (opts?: Partial<EventSystemOptions>) => EventSystemOptions;
 /**
  * @public
@@ -47,11 +53,37 @@ export interface PointerEventsSystem {
      * @param entity - Entity where the callback was attached
      */
     removeOnPointerHoverLeave(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDrag event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDrag(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDragLocked event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDragLocked(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDragEnd event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDragEnd(entity: Entity): void;
+    /**
+     * @public
+     * Execute callbacks when the user presses one of the InputButtons pointing at the entity
+     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     */
+    onPointerDown(pointerData: {
+        entity: Entity;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
     /**
      * @public
      * Execute callback when the user press the InputButton pointing at the entity
      * @param pointerData - Entity to attach the callback, Opts to trigger Feedback and Button
-     * @param cb - Function to execute when click fires
      */
     onPointerDown(pointerData: {
         entity: Entity;
@@ -64,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
@@ -101,6 +142,64 @@ export interface PointerEventsSystem {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callbacks when the user drags the pointer from inside the entity
+     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     */
+    onPointerDrag(pointerData: {
+        entity: Entity;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
+    /**
+     * @public
+     * Execute callback when the user clicks and drags the pointer from inside the entity
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when click fires
+     */
+    onPointerDrag(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callbacks when the user drags the pointer from inside the entity, locking the cursor in place.
+     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     */
+    onPointerDragLocked(pointerData: {
+        entity: Entity;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
+    /**
+     * @public
+     * Execute callback when the user clicks and drags the pointer from inside the entity,
+     * locking the cursor in place
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when click fires
+     */
+    onPointerDragLocked(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callbacks when the user releases a button after a drag
+     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     */
+    onPointerDragEnd(pointerData: {
+        entity: Entity;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
+    /**
+     * @public
+     * Execute callback when the user releases the button after a drag
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when click fires
+     */
+    onPointerDragEnd(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
 }
 /**
  * @public

package/dist/systems/events.js

@@ -18,6 +18,9 @@ export function createPointerEventsSystem(engine, inputSystem) {
         EventType[EventType["Up"] = 2] = "Up";
         EventType[EventType["HoverEnter"] = 3] = "HoverEnter";
         EventType[EventType["HoverLeave"] = 4] = "HoverLeave";
+        EventType[EventType["Drag"] = 5] = "Drag";
+        EventType[EventType["DragLocked"] = 6] = "DragLocked";
+        EventType[EventType["DragEnd"] = 7] = "DragEnd";
     })(EventType || (EventType = {}));
     const eventsMap = new Map();
     function getEvent(entity) {
@@ -53,77 +56,148 @@ export function createPointerEventsSystem(engine, inputSystem) {
         else if (eventType === EventType.HoverEnter) {
             return 2 /* PointerEventType.PET_HOVER_ENTER */;
         }
+        else if (eventType === EventType.Drag) {
+            return 5 /* PointerEventType.PET_DRAG */;
+        }
+        else if (eventType === EventType.DragLocked) {
+            return 4 /* PointerEventType.PET_DRAG_LOCKED */;
+        }
+        else if (eventType === EventType.DragEnd) {
+            return 6 /* PointerEventType.PET_DRAG_END */;
+        }
         return 1 /* PointerEventType.PET_DOWN */;
     }
+    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 === 5 /* PointerEventType.PET_DRAG */) {
+            return EventType.Drag;
+        }
+        else if (pet === 4 /* PointerEventType.PET_DRAG_LOCKED */) {
+            return EventType.DragLocked;
+        }
+        else if (pet === 6 /* 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) === 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)
-                        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) {
+                    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) {
-                    const command = inputSystem.getInputCommand(opts.button, getPointerEvent(eventType), entity);
-                    if (command) {
-                        checkNotThenable(cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+                const anyData = typeMap.get(3 /* InputAction.IA_ANY */);
+                if (anyData) {
+                    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)) {
+                        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)) {
+                        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 = 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);
-    };
-    const onPointerHoverEnter = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = 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 = getDefaultOpts(opts);
-        removeEvent(entity, EventType.HoverLeave);
-        getEvent(entity).set(EventType.HoverLeave, { cb, opts: options });
-        setPointerEvent(entity, 3 /* PointerEventType.PET_HOVER_LEAVE */, options);
+    // 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, ...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, ...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) {
@@ -141,18 +215,22 @@ export function createPointerEventsSystem(engine, inputSystem) {
         removeOnPointerHoverLeave(entity) {
             removeEvent(entity, EventType.HoverLeave);
         },
-        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);
+        removeOnPointerDrag(entity) {
+            removeEvent(entity, EventType.Drag);
+        },
+        removeOnPointerDragLocked(entity) {
+            removeEvent(entity, EventType.DragLocked);
+        },
+        removeOnPointerDragEnd(entity) {
+            removeEvent(entity, EventType.DragEnd);
         },
-        onPointerDown,
-        onPointerUp,
-        onPointerHoverEnter,
-        onPointerHoverLeave
+        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)
     };
 }

package/dist/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/systems/raycast.js

@@ -58,6 +58,8 @@ export 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/dist-cjs/components/extended/AvatarEquippedData.d.ts

@@ -0,0 +1,10 @@
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
+import { PBAvatarEquippedData } from '../generated/pb/decentraland/sdk/components/avatar_equipped_data.gen';
+/**
+ * @public
+ */
+export type AvatarEquippedDataComponentDefinitionExtended = LastWriteWinElementSetComponentDefinition<AvatarEquippedDataType>;
+export type AvatarEquippedDataType = Omit<PBAvatarEquippedData, 'forceRender'> & {
+    forceRender?: string[] | undefined;
+};
+export declare function defineAvatarEquippedDataComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): AvatarEquippedDataComponentDefinitionExtended;

package/dist-cjs/components/extended/AvatarEquippedData.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineAvatarEquippedDataComponent = void 0;
+const AvatarEquippedData_gen_1 = require("../generated/AvatarEquippedData.gen");
+function defineAvatarEquippedDataComponent(engine) {
+    const patchedSchema = { ...AvatarEquippedData_gen_1.AvatarEquippedDataSchema };
+    const origSerialize = patchedSchema.serialize;
+    patchedSchema.serialize = (value, builder) => {
+        if (value.forceRender === undefined) {
+            origSerialize({ forceRender: [], ...value }, builder);
+        }
+        else {
+            origSerialize(value, builder);
+        }
+    };
+    const theComponent = engine.defineComponentFromSchema('core::AvatarEquippedData', patchedSchema);
+    return theComponent;
+}
+exports.defineAvatarEquippedDataComponent = defineAvatarEquippedDataComponent;

package/dist-cjs/components/extended/AvatarShape.d.ts

@@ -0,0 +1,10 @@
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
+import { PBAvatarShape } from '../generated/pb/decentraland/sdk/components/avatar_shape.gen';
+/**
+ * @public
+ */
+export type AvatarShapeComponentDefinitionExtended = LastWriteWinElementSetComponentDefinition<AvatarShapeType>;
+export type AvatarShapeType = Omit<PBAvatarShape, 'forceRender'> & {
+    forceRender?: string[] | undefined;
+};
+export declare function defineAvatarShapeComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): AvatarShapeComponentDefinitionExtended;

package/dist-cjs/components/extended/AvatarShape.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineAvatarShapeComponent = void 0;
+const AvatarShape_gen_1 = require("../generated/AvatarShape.gen");
+function defineAvatarShapeComponent(engine) {
+    const patchedSchema = { ...AvatarShape_gen_1.AvatarShapeSchema };
+    const origSerialize = patchedSchema.serialize;
+    patchedSchema.serialize = (value, builder) => {
+        if (value.forceRender === undefined) {
+            origSerialize({ forceRender: [], ...value }, builder);
+        }
+        else {
+            origSerialize(value, builder);
+        }
+    };
+    const theComponent = engine.defineComponentFromSchema('core::AvatarShape', patchedSchema);
+    return theComponent;
+}
+exports.defineAvatarShapeComponent = defineAvatarShapeComponent;

package/dist-cjs/components/extended/MeshCollider.d.ts

@@ -34,5 +34,13 @@ export interface MeshColliderComponentDefinitionExtended extends LastWriteWinEle
      * @param colliderMask - the set of layer where the collider reacts, default: Physics and Pointer
      */
     setSphere(entity: Entity, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
+    /**
+     * @public
+     * Set a gltf internal mesh in the MeshCollider component
+     * @param entity - entity to create or replace the MeshRenderer component
+     * @param source - the path to the gltf
+     * @param meshName - the name of the mesh in the gltf
+     */
+    setGltfMesh(entity: Entity, source: string, meshName: string, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
 }
 export declare function defineMeshColliderComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): MeshColliderComponentDefinitionExtended;

package/dist-cjs/components/extended/MeshCollider.js

@@ -37,6 +37,12 @@ function defineMeshColliderComponent(engine) {
                 mesh: { $case: 'sphere', sphere: {} },
                 collisionMask: getCollisionMask(colliderLayers)
             });
+        },
+        setGltfMesh(entity, source, meshName, colliderLayers) {
+            theComponent.createOrReplace(entity, {
+                mesh: { $case: 'gltf', gltf: { gltfSrc: source, name: meshName } },
+                collisionMask: getCollisionMask(colliderLayers)
+            });
         }
     };
 }

package/dist-cjs/components/extended/MeshRenderer.d.ts

@@ -32,5 +32,13 @@ export interface MeshRendererComponentDefinitionExtended extends LastWriteWinEle
      * @param entity - entity to create or replace the MeshRenderer component
      */
     setSphere(entity: Entity): void;
+    /**
+     * @public
+     * Set a gltf internal mesh in the MeshRenderer component
+     * @param entity - entity to create or replace the MeshRenderer component
+     * @param source - the path to the gltf
+     * @param meshName - the name of the mesh in the gltf
+     */
+    setGltfMesh(entity: Entity, source: string, meshName: string): void;
 }
 export declare function defineMeshRendererComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): MeshRendererComponentDefinitionExtended;

package/dist-cjs/components/extended/MeshRenderer.js

@@ -25,6 +25,11 @@ function defineMeshRendererComponent(engine) {
             theComponent.createOrReplace(entity, {
                 mesh: { $case: 'sphere', sphere: {} }
             });
+        },
+        setGltfMesh(entity, source, meshName) {
+            theComponent.createOrReplace(entity, {
+                mesh: { $case: 'gltf', gltf: { gltfSrc: source, name: meshName } }
+            });
         }
     };
 }

package/dist-cjs/components/generated/AvatarLocomotionSettings.gen.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-cjs/components/generated/AvatarLocomotionSettings.gen.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarLocomotionSettingsSchema = void 0;
+const avatar_locomotion_settings_gen_1 = require("./pb/decentraland/sdk/components/avatar_locomotion_settings.gen");
+/**
+ * @internal
+ */
+exports.AvatarLocomotionSettingsSchema = {
+    COMPONENT_ID: 1211,
+    serialize(value, builder) {
+        const writer = avatar_locomotion_settings_gen_1.PBAvatarLocomotionSettings.encode(value);
+        const buffer = new Uint8Array(writer.finish(), 0, writer.len);
+        builder.writeBuffer(buffer, false);
+    },
+    deserialize(reader) {
+        return avatar_locomotion_settings_gen_1.PBAvatarLocomotionSettings.decode(reader.buffer(), reader.remainingBytes());
+    },
+    create() {
+        // TODO: this is a hack.
+        return avatar_locomotion_settings_gen_1.PBAvatarLocomotionSettings.decode(new Uint8Array());
+    },
+    jsonSchema: {
+        type: "object",
+        properties: {},
+        serializationType: "protocol-buffer",
+        protocolBuffer: "PBAvatarLocomotionSettings"
+    }
+};

package/dist-cjs/components/generated/AvatarMovement.gen.d.ts

@@ -0,0 +1 @@
+export {};