@dcl/ecs 7.1.4-4492843881.commit-442dfb1 → 7.1.4-4502579506.commit-4147243

package/dist/components/generated/pb/decentraland/sdk/components/animator.gen.d.ts

@@ -1,21 +1,35 @@
+/**
+ * The Animator component is a container for multiple potential animations an Entity can display,
+ * separately or at the same time. It can be used to start, stop or blend animations; as well as
+ * to inspect their playback state.
+ *
+ * Animations have a `weight` property, which determines how pronounced the animation will be. This
+ * can be adjusted to blend animations together, or gracefully transition from one to the next.
+ */
 /**
  * @public
  */
 export interface PBAnimator {
+    /** a collection of animations and their current state */
     states: PBAnimationState[];
 }
+/** AnimationState indicates the status and configuration of one available animation. */
 /**
  * @public
  */
 export interface PBAnimationState {
+    /** the identifier for this animation, to use in scene code */
     name: string;
+    /** the animation path in the `files` array of the scene manifest */
     clip: string;
+    /** whether this animation is currently playing */
     playing?: boolean | undefined;
-    /** default=1.0s */
+    /** the "weight" of this animation (see below, default: 1.0) */
     weight?: number | undefined;
-    /** default=1.0 */
+    /** the playback speed (default: 1.0) */
     speed?: number | undefined;
-    /** default=true */
+    /** whether the animation repeats until stopped (default: true) */
     loop?: boolean | undefined;
+    /** whether the Entity is restored to its prior state when done */
     shouldReset?: boolean | undefined;
 }

package/dist/components/generated/pb/decentraland/sdk/components/audio_source.gen.d.ts

@@ -1,12 +1,26 @@
+/**
+ * The AudioSource component can play an audio clips bundled with the scene, controlling some
+ * of the behavior.
+ *
+ * In each AudioSource instance, the sound is spatially located at the associated entity’s position,
+ * given by its Transform.
+ *
+ * Note that the `audio_clip_url` is not actually a URL, but rather the path of a file bundled with
+ * the scene and declared in its manifest. The name was chosen because the URL use-case will
+ * eventually be supported.
+ */
 /**
  * @public
  */
 export interface PBAudioSource {
+    /** whether the clip is currently playing. */
     playing?: boolean | undefined;
-    /** default=1.0f */
+    /** the audio volume (default: 1.0). */
     volume?: number | undefined;
+    /** whether the clip should restart when finished. */
     loop?: boolean | undefined;
-    /** default=1.0f */
+    /** the audio pitch (default: 1.0). */
     pitch?: number | undefined;
+    /** the clip path as given in the `files` array of the scene's manifest. */
     audioClipUrl: string;
 }

package/dist/components/generated/pb/decentraland/sdk/components/audio_stream.gen.d.ts

@@ -1,9 +1,16 @@
+/**
+ * The AudioStream component can play external audio clips given a URL, streaming it in real-time.
+ *
+ * Despite being attached to a particular entity, the sound is not affected by its position.
+ */
 /**
  * @public
  */
 export interface PBAudioStream {
+    /** whether the clip is currently playing */
     playing?: boolean | undefined;
-    /** default=1.0f */
+    /** the audio volume (default: 1.0) */
     volume?: number | undefined;
+    /** the audio stream HTTP URL */
     url: string;
 }

package/dist/components/generated/pb/decentraland/sdk/components/avatar_attach.gen.d.ts

@@ -1,3 +1,4 @@
+/** AvatarAnchorPointType determines the part of the avatar's body that anchors the Entity. */
 /**
  * @public
  */
@@ -7,11 +8,22 @@ export declare const enum AvatarAnchorPointType {
     AAPT_LEFT_HAND = 2,
     AAPT_RIGHT_HAND = 3
 }
+/**
+ * The AvatarAttach component automatically repositions an Entity to maintain the same position and
+ * rotation relative to some part of an avatar, called the "anchor point". The Entity
+ * will follow this anchor as it moves.
+ *
+ * The Entity's own Transform is overridden by this component. To offset position and adjust scale,
+ * add a child to the anchored Entity and set a Transform on it instead.
+ *
+ * AvatarAnchorPointType indicates which part of the avatar the Entity must follow.
+ */
 /**
  * @public
  */
 export interface PBAvatarAttach {
-    /** default's to current player avatar id if not provided */
+    /** the user ID of the avatar (default: local user) */
     avatarId?: string | undefined;
+    /** the anchor point. */
     anchorPointId: AvatarAnchorPointType;
 }

package/dist/components/generated/pb/decentraland/sdk/components/avatar_attach.gen.js

@@ -1,6 +1,7 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
 const protobufPackageSarasa = "decentraland.sdk.components";
+/** AvatarAnchorPointType determines the part of the avatar's body that anchors the Entity. */
 /**
  * @public
  */

package/dist/components/generated/pb/decentraland/sdk/components/avatar_modifier_area.gen.d.ts

@@ -1,16 +1,36 @@
 import { Vector3 } from "../../common/vectors.gen";
+/** AvatarModifierType is an effect that should be applied to avatars inside the region. */
 /**
  * @public
  */
 export declare const enum AvatarModifierType {
+    /** AMT_HIDE_AVATARS - avatars are invisible */
     AMT_HIDE_AVATARS = 0,
+    /** AMT_DISABLE_PASSPORTS - selecting (e.g. clicking) an avatar will not bring up their profile. */
     AMT_DISABLE_PASSPORTS = 1
 }
+/**
+ * The AvatarModifierArea component can be attached to an Entity to define a region of space where
+ * avatar behavior changes.
+ *
+ * The Entity's Transform position determines the center-point of the region, while its size is
+ * given as a vector in the `area` property below. The Transform rotation is applied, but the scale
+ * is ignored.
+ *
+ * The modifier effect is only applied to avatars inside the region. It does not affect how players
+ * standing inside it see avatars on the other side of the boundary.
+ *
+ * Note that, while commonly used to delineate a 2D area in a scene (hence the name), the region
+ * is actually a 3D volume.
+ */
 /**
  * @public
  */
 export interface PBAvatarModifierArea {
+    /** the 3D size of the region */
     area: Vector3 | undefined;
+    /** user IDs that can enter and remain unaffected */
     excludeIds: string[];
+    /** list of modifiers to apply */
     modifiers: AvatarModifierType[];
 }

package/dist/components/generated/pb/decentraland/sdk/components/avatar_modifier_area.gen.js

@@ -2,12 +2,15 @@
 import _m0 from "protobufjs/minimal";
 import { Vector3 } from "../../common/vectors.gen";
 const protobufPackageSarasa = "decentraland.sdk.components";
+/** AvatarModifierType is an effect that should be applied to avatars inside the region. */
 /**
  * @public
  */
 export var AvatarModifierType;
 (function (AvatarModifierType) {
+    /** AMT_HIDE_AVATARS - avatars are invisible */
     AvatarModifierType[AvatarModifierType["AMT_HIDE_AVATARS"] = 0] = "AMT_HIDE_AVATARS";
+    /** AMT_DISABLE_PASSPORTS - selecting (e.g. clicking) an avatar will not bring up their profile. */
     AvatarModifierType[AvatarModifierType["AMT_DISABLE_PASSPORTS"] = 1] = "AMT_DISABLE_PASSPORTS";
 })(AvatarModifierType || (AvatarModifierType = {}));
 function createBasePBAvatarModifierArea() {

package/dist/components/generated/pb/decentraland/sdk/components/avatar_shape.gen.d.ts

@@ -1,33 +1,48 @@
 import { Color3 } from "../../common/colors.gen";
+/**
+ * The AvatarShape component contains the information required to draw and animate avatar, acting as
+ * a simplified GLTF container for this specific case.
+ *
+ * All fields (except ID) are optional have reasonable default values. In the case of `wearables`,
+ * each slot on the Avatar's body that is not explicitly included in the list has its own default.
+ *
+ * Note that, while AvatarShape can be attached to any Entity, it's only actually used in the global
+ * Avatar Scene. Other requirements are usually better served by GLTFs.
+ */
 /**
  * @public
  */
 export interface PBAvatarShape {
+    /** the user ID */
     id: string;
-    /** default = NPC */
+    /** visible name (default: "NPC") */
     name?: string | undefined;
-    /** default = urn:decentraland:off-chain:base-avatars:BaseFemale */
+    /** shape URN (default "urn:decentraland:off-chain:base-avatars:BaseFemale") */
     bodyShape?: string | undefined;
-    /** default = decentraland.common.Color3(R = 0.6f, G = 0.462f, B = 0.356f) */
+    /** RGB (default [0.6, 0.462, 0.356]) */
     skinColor?: Color3 | undefined;
-    /** default = decentraland.common.Color3(R = 0.283f, G = 0.142f, B = 0f) */
+    /** RGB (default [0.283, 0.142, 0]) */
     hairColor?: Color3 | undefined;
-    /** default = decentraland.common.Color3(R = 0.6f, G = 0.462f, B = 0.356f) */
+    /** RGB (default [0.6, 0.462, 0.356]) */
     eyeColor?: Color3 | undefined;
+    /** current emote animations */
     expressionTriggerId?: string | undefined;
-    /** default = timestamp */
+    /** start of emote animations (in the same order) */
     expressionTriggerTimestamp?: number | undefined;
+    /** whether to display the floating voice chat icon */
     talking?: boolean | undefined;
     /**
-     * default = ["urn:decentraland:off-chain:base-avatars:f_eyes_00",
-     *  "urn:decentraland:off-chain:base-avatars:f_eyebrows_00",
-     *  "urn:decentraland:off-chain:base-avatars:f_mouth_00"
-     *  "urn:decentraland:off-chain:base-avatars:standard_hair",
-     *  "urn:decentraland:off-chain:base-avatars:f_simple_yellow_tshirt",
-     *  "urn:decentraland:off-chain:base-avatars:f_brown_trousers",
-     *  "urn:decentraland:off-chain:base-avatars:bun_shoes"]
+     * Wearable URNs, one for each body slot.
+     *   Default values for each unspecified slot:
+     *     Eyes    : "urn:decentraland:off-chain:base-avatars:f_eyes_00",
+     *     Eyebrows: "urn:decentraland:off-chain:base-avatars:f_eyebrows_00",
+     *     Mouth   : "urn:decentraland:off-chain:base-avatars:f_mouth_00"
+     *     Hair    : "urn:decentraland:off-chain:base-avatars:standard_hair",
+     *     Shirt   : "urn:decentraland:off-chain:base-avatars:f_simple_yellow_tshirt",
+     *     Trousers: "urn:decentraland:off-chain:base-avatars:f_brown_trousers",
+     *     Shoes   : "urn:decentraland:off-chain:base-avatars:bun_shoes"]
      */
     wearables: string[];
-    /** default = [] */
+    /** available emotes (default empty) */
     emotes: string[];
 }

package/dist/components/generated/pb/decentraland/sdk/components/billboard.gen.d.ts

@@ -1,3 +1,4 @@
+/** BillboardMode indicates one or more axis for automatic rotation, in OR-able bit flag form. */
 /**
  * @public
  */
@@ -6,12 +7,21 @@ export declare const enum BillboardMode {
     BM_X = 1,
     BM_Y = 2,
     BM_Z = 4,
+    /** BM_ALL - bitwise combination BM_X | BM_Y | BM_Z */
     BM_ALL = 7
 }
+/**
+ * The Billboard component makes an Entity automatically reorient its rotation to face the camera.
+ * As the name indicates, it’s used to display in-game billboards and frequently combined with
+ * the TextShape component.
+ *
+ * Billboard only affects the Entity's rotation. Its scale and position are still determined by its
+ * Transform.
+ */
 /**
  * @public
  */
 export interface PBBillboard {
-    /** default=BM_ALL */
+    /** the BillboardMode (default: BM_ALL) */
     billboardMode?: BillboardMode | undefined;
 }

package/dist/components/generated/pb/decentraland/sdk/components/billboard.gen.js

@@ -1,6 +1,7 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
 const protobufPackageSarasa = "decentraland.sdk.components";
+/** BillboardMode indicates one or more axis for automatic rotation, in OR-able bit flag form. */
 /**
  * @public
  */
@@ -10,6 +11,7 @@ export var BillboardMode;
     BillboardMode[BillboardMode["BM_X"] = 1] = "BM_X";
     BillboardMode[BillboardMode["BM_Y"] = 2] = "BM_Y";
     BillboardMode[BillboardMode["BM_Z"] = 4] = "BM_Z";
+    /** BM_ALL - bitwise combination BM_X | BM_Y | BM_Z */
     BillboardMode[BillboardMode["BM_ALL"] = 7] = "BM_ALL";
 })(BillboardMode || (BillboardMode = {}));
 function createBasePBBillboard() {

package/dist/components/generated/pb/decentraland/sdk/components/camera_mode.gen.d.ts

@@ -1,7 +1,12 @@
 import { CameraType } from "./common/camera_type.gen";
+/**
+ * The CameraMode component can be used to determine whether the player is using a first-person o
+ * third-person view.
+ */
 /**
  * @public
  */
 export interface PBCameraMode {
+    /** the camera type (1st-person or 3rd-person) */
     mode: CameraType;
 }

package/dist/components/generated/pb/decentraland/sdk/components/camera_mode_area.gen.d.ts

@@ -1,9 +1,24 @@
 import { Vector3 } from "../../common/vectors.gen";
 import { CameraType } from "./common/camera_type.gen";
+/**
+ * The CameraModeArea component can be attached to an Entity to define a region of space where
+ * the player's camera mode (1st-person or 3rd-person) is overridden.
+ *
+ * The Entity's Transform position determines the center-point of the region, while its size is
+ * given as a vector in the `area` property below. The Transform rotation is applied, but the scale
+ * is ignored.
+ *
+ * When players leave the region, their previous setting is restored.
+ *
+ * Note that, while commonly used to delineate a 2D area in a scene (hence the name), the region
+ * is actually a 3D volume.
+ */
 /**
  * @public
  */
 export interface PBCameraModeArea {
+    /** the 3D size of the region */
     area: Vector3 | undefined;
+    /** the camera mode to enforce */
     mode: CameraType;
 }

package/dist/components/generated/pb/decentraland/sdk/components/common/camera_type.gen.d.ts

@@ -3,5 +3,7 @@
  */
 export declare const enum CameraType {
     CT_FIRST_PERSON = 0,
-    CT_THIRD_PERSON = 1
+    CT_THIRD_PERSON = 1,
+    /** CT_CINEMATIC - controlled by the scene */
+    CT_CINEMATIC = 2
 }

package/dist/components/generated/pb/decentraland/sdk/components/common/camera_type.gen.js

@@ -7,4 +7,6 @@ export var CameraType;
 (function (CameraType) {
     CameraType[CameraType["CT_FIRST_PERSON"] = 0] = "CT_FIRST_PERSON";
     CameraType[CameraType["CT_THIRD_PERSON"] = 1] = "CT_THIRD_PERSON";
+    /** CT_CINEMATIC - controlled by the scene */
+    CameraType[CameraType["CT_CINEMATIC"] = 2] = "CT_CINEMATIC";
 })(CameraType || (CameraType = {}));

package/dist/components/generated/pb/decentraland/sdk/components/common/input_action.gen.d.ts

@@ -17,3 +17,13 @@ export declare const enum InputAction {
     IA_ACTION_5 = 12,
     IA_ACTION_6 = 13
 }
+/** PointerEventType is a kind of interaction that can be detected. */
+/**
+ * @public
+ */
+export declare const enum PointerEventType {
+    PET_UP = 0,
+    PET_DOWN = 1,
+    PET_HOVER_ENTER = 2,
+    PET_HOVER_LEAVE = 3
+}

package/dist/components/generated/pb/decentraland/sdk/components/common/input_action.gen.js

@@ -20,3 +20,14 @@ export var InputAction;
     InputAction[InputAction["IA_ACTION_5"] = 12] = "IA_ACTION_5";
     InputAction[InputAction["IA_ACTION_6"] = 13] = "IA_ACTION_6";
 })(InputAction || (InputAction = {}));
+/** PointerEventType is a kind of interaction that can be detected. */
+/**
+ * @public
+ */
+export var PointerEventType;
+(function (PointerEventType) {
+    PointerEventType[PointerEventType["PET_UP"] = 0] = "PET_UP";
+    PointerEventType[PointerEventType["PET_DOWN"] = 1] = "PET_DOWN";
+    PointerEventType[PointerEventType["PET_HOVER_ENTER"] = 2] = "PET_HOVER_ENTER";
+    PointerEventType[PointerEventType["PET_HOVER_LEAVE"] = 3] = "PET_HOVER_LEAVE";
+})(PointerEventType || (PointerEventType = {}));

package/dist/components/generated/pb/decentraland/sdk/components/common/raycast_hit.gen.d.ts

@@ -0,0 +1,21 @@
+import { Vector3 } from "../../../common/vectors.gen";
+/** RaycastHit contains information about the intersection of a ray with a mesh. */
+/**
+ * @public
+ */
+export interface RaycastHit {
+    /** Position will be relative to the scene */
+    position: Vector3 | undefined;
+    /** the starting point of the ray in global coordinates */
+    globalOrigin: Vector3 | undefined;
+    /** the direction vector of the ray in global coordinates */
+    direction: Vector3 | undefined;
+    /** normal of the hit surface in global coordinates */
+    normalHit: Vector3 | undefined;
+    /** the distance between the ray origin and the hit position */
+    length: number;
+    /** mesh name, if collision happened inside a GltfContainer */
+    meshName?: string | undefined;
+    /** the ID of the Entity that has the impacted mesh attached */
+    entityId?: number | undefined;
+}

package/dist/components/generated/pb/decentraland/sdk/components/common/raycast_hit.gen.js

@@ -0,0 +1,82 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { Vector3 } from "../../../common/vectors.gen";
+const protobufPackageSarasa = "decentraland.sdk.components.common";
+function createBaseRaycastHit() {
+    return {
+        position: undefined,
+        globalOrigin: undefined,
+        direction: undefined,
+        normalHit: undefined,
+        length: 0,
+        meshName: undefined,
+        entityId: undefined,
+    };
+}
+/**
+ * @public
+ */
+/**
+ * @internal
+ */
+export const RaycastHit = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.position !== undefined) {
+            Vector3.encode(message.position, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.globalOrigin !== undefined) {
+            Vector3.encode(message.globalOrigin, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.direction !== undefined) {
+            Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.normalHit !== undefined) {
+            Vector3.encode(message.normalHit, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.length !== 0) {
+            writer.uint32(45).float(message.length);
+        }
+        if (message.meshName !== undefined) {
+            writer.uint32(50).string(message.meshName);
+        }
+        if (message.entityId !== undefined) {
+            writer.uint32(56).uint32(message.entityId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRaycastHit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.position = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.globalOrigin = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.direction = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.normalHit = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.length = reader.float();
+                    break;
+                case 6:
+                    message.meshName = reader.string();
+                    break;
+                case 7:
+                    message.entityId = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+};

package/dist/components/generated/pb/decentraland/sdk/components/gltf_container.gen.d.ts

@@ -1,7 +1,13 @@
+/**
+ * GltfContainer loads a GLTF file (and any additional files packaged inside) attached to an Entity.
+ *
+ * This allows the use of custom models, materials, collision boundaries and shapes that can't be
+ * achieved using MeshRenderer, MeshCollider and other standard components.
+ */
 /**
  * @public
  */
 export interface PBGltfContainer {
-    /** which file to load */
+    /** the GLTF file path as listed in the scene's manifest. */
     src: string;
 }

package/dist/components/generated/pb/decentraland/sdk/components/mesh_collider.gen.d.ts

@@ -1,16 +1,45 @@
+/** ColliderLayer determines the kind of collision to detect, in OR-able bit flag form. */
 /**
  * @public
  */
 export declare const enum ColliderLayer {
+    /** CL_NONE - no collisions */
     CL_NONE = 0,
+    /** CL_POINTER - collisions with the player's pointer ray (e.g. mouse cursor hovering) */
     CL_POINTER = 1,
-    CL_PHYSICS = 2
+    /** CL_PHYSICS - collision affecting your player's physics i.e. walls, floor, moving platfroms */
+    CL_PHYSICS = 2,
+    /** CL_VISIBLE_MESHES - all visible meshes, use with extreme care since the performance penalty is high */
+    CL_VISIBLE_MESHES = 4,
+    CL_RESERVED2 = 8,
+    CL_RESERVED3 = 16,
+    CL_RESERVED4 = 32,
+    CL_RESERVED5 = 64,
+    CL_RESERVED6 = 128,
+    CL_CUSTOM1 = 256,
+    CL_CUSTOM2 = 512,
+    CL_CUSTOM3 = 1024,
+    CL_CUSTOM4 = 2048,
+    CL_CUSTOM5 = 4096,
+    CL_CUSTOM6 = 8192,
+    CL_CUSTOM7 = 16384,
+    CL_CUSTOM8 = 32768
 }
+/**
+ * The MeshCollider component provides basic collision detection between Entities and Avatars. It
+ * can behave like a cube, a plane, a sphere or a cylinder.
+ *
+ * The Entity's Transform affects the MeshCollider, scaling it and rotating it appropriately. If
+ * the Transform for the collision mesh must be different than the Transform for rendering the Entity,
+ * two different Entities must be used.
+ *
+ * More complex shapes require the use of a `GltfContainer` component.
+ */
 /**
  * @public
  */
 export interface PBMeshCollider {
-    /** default = ColliderLayer.Physics | ColliderLayer.Pointer */
+    /** enabled ColliderLayers (default CL_POINTER | CL_PHYSICS) */
     collisionMask?: number | undefined;
     mesh?: {
         $case: "box";
@@ -26,25 +55,29 @@ export interface PBMeshCollider {
         plane: PBMeshCollider_PlaneMesh;
     };
 }
+/** BoxMesh is a prism shape that contains the Entity. */
 /**
  * @public
  */
 export interface PBMeshCollider_BoxMesh {
 }
+/** CylinderMesh is a truncated cone shape that contains the Entity. */
 /**
  * @public
  */
 export interface PBMeshCollider_CylinderMesh {
-    /** default=1.0 */
+    /** (default 1.0) */
     radiusTop?: number | undefined;
-    /** default=1.0 */
+    /** (default 1.0) */
     radiusBottom?: number | undefined;
 }
+/** PlaneMesh is a 2D rectangle described by the Entity's Transform. */
 /**
  * @public
  */
 export interface PBMeshCollider_PlaneMesh {
 }
+/** SphereMesh is a sphere shape that contains the Entity. */
 /**
  * @public
  */

package/dist/components/generated/pb/decentraland/sdk/components/mesh_collider.gen.js

@@ -1,14 +1,33 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
 const protobufPackageSarasa = "decentraland.sdk.components";
+/** ColliderLayer determines the kind of collision to detect, in OR-able bit flag form. */
 /**
  * @public
  */
 export var ColliderLayer;
 (function (ColliderLayer) {
+    /** CL_NONE - no collisions */
     ColliderLayer[ColliderLayer["CL_NONE"] = 0] = "CL_NONE";
+    /** CL_POINTER - collisions with the player's pointer ray (e.g. mouse cursor hovering) */
     ColliderLayer[ColliderLayer["CL_POINTER"] = 1] = "CL_POINTER";
+    /** CL_PHYSICS - collision affecting your player's physics i.e. walls, floor, moving platfroms */
     ColliderLayer[ColliderLayer["CL_PHYSICS"] = 2] = "CL_PHYSICS";
+    /** CL_VISIBLE_MESHES - all visible meshes, use with extreme care since the performance penalty is high */
+    ColliderLayer[ColliderLayer["CL_VISIBLE_MESHES"] = 4] = "CL_VISIBLE_MESHES";
+    ColliderLayer[ColliderLayer["CL_RESERVED2"] = 8] = "CL_RESERVED2";
+    ColliderLayer[ColliderLayer["CL_RESERVED3"] = 16] = "CL_RESERVED3";
+    ColliderLayer[ColliderLayer["CL_RESERVED4"] = 32] = "CL_RESERVED4";
+    ColliderLayer[ColliderLayer["CL_RESERVED5"] = 64] = "CL_RESERVED5";
+    ColliderLayer[ColliderLayer["CL_RESERVED6"] = 128] = "CL_RESERVED6";
+    ColliderLayer[ColliderLayer["CL_CUSTOM1"] = 256] = "CL_CUSTOM1";
+    ColliderLayer[ColliderLayer["CL_CUSTOM2"] = 512] = "CL_CUSTOM2";
+    ColliderLayer[ColliderLayer["CL_CUSTOM3"] = 1024] = "CL_CUSTOM3";
+    ColliderLayer[ColliderLayer["CL_CUSTOM4"] = 2048] = "CL_CUSTOM4";
+    ColliderLayer[ColliderLayer["CL_CUSTOM5"] = 4096] = "CL_CUSTOM5";
+    ColliderLayer[ColliderLayer["CL_CUSTOM6"] = 8192] = "CL_CUSTOM6";
+    ColliderLayer[ColliderLayer["CL_CUSTOM7"] = 16384] = "CL_CUSTOM7";
+    ColliderLayer[ColliderLayer["CL_CUSTOM8"] = 32768] = "CL_CUSTOM8";
 })(ColliderLayer || (ColliderLayer = {}));
 function createBasePBMeshCollider() {
     return { collisionMask: undefined, mesh: undefined };

package/dist/components/generated/pb/decentraland/sdk/components/mesh_renderer.gen.d.ts

@@ -1,3 +1,13 @@
+/**
+ * The MeshRenderer component renders a basic geometric shape for an Entity. It can be a cube, a
+ * plane, a sphere or a cylinder.
+ *
+ * The cube and plane variants can include a UV texture mapping, so specific areas of a material
+ * texture are rendered on different faces of the shape. They are serialized as a sequence of 2D
+ * `float` coordinates, one for each corner of each side of each face.
+ *
+ * More complex shapes require the use of a `GltfContainer` component.
+ */
 /**
  * @public
  */
@@ -16,27 +26,33 @@ export interface PBMeshRenderer {
         plane: PBMeshRenderer_PlaneMesh;
     };
 }
+/** BoxMesh renders a prism shape. */
 /**
  * @public
  */
 export interface PBMeshRenderer_BoxMesh {
+    /** 96-value texture map (2D * 6 faces * 2 sides * 4 vertices) */
     uvs: number[];
 }
+/** CylinderMesh renders a truncated cone shape. */
 /**
  * @public
  */
 export interface PBMeshRenderer_CylinderMesh {
-    /** default=1.0 */
+    /** (default 1.0) */
     radiusTop?: number | undefined;
-    /** default=1.0 */
+    /** (default 1.0) */
     radiusBottom?: number | undefined;
 }
+/** PlaneMesh renders a 2D rectangular shape. */
 /**
  * @public
  */
 export interface PBMeshRenderer_PlaneMesh {
+    /** 16-value texture map (2D * 1 face * 2 sides * 4 vertices) */
     uvs: number[];
 }
+/** SphereMesh renders a spherical shape. */
 /**
  * @public
  */