@dcl/ecs 7.1.12-4982829389.commit-f2f84bd → 7.1.12-4983011170.commit-adaaaa2

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

@@ -0,0 +1,96 @@
+import _m0 from "protobufjs/minimal";
+/**
+ * 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
+ */
+export interface PBMeshRenderer {
+    mesh?: {
+        $case: "box";
+        box: PBMeshRenderer_BoxMesh;
+    } | {
+        $case: "sphere";
+        sphere: PBMeshRenderer_SphereMesh;
+    } | {
+        $case: "cylinder";
+        cylinder: PBMeshRenderer_CylinderMesh;
+    } | {
+        $case: "plane";
+        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 0.5) */
+    radiusTop?: number | undefined;
+    /** (default 0.5) */
+    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
+ */
+export interface PBMeshRenderer_SphereMesh {
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer {
+    function encode(message: PBMeshRenderer, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer_BoxMesh {
+    function encode(message: PBMeshRenderer_BoxMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_BoxMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer_CylinderMesh {
+    function encode(message: PBMeshRenderer_CylinderMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_CylinderMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer_PlaneMesh {
+    function encode(message: PBMeshRenderer_PlaneMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_PlaneMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer_SphereMesh {
+    function encode(_: PBMeshRenderer_SphereMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_SphereMesh;
+}

package/dist-cjs/components/generated/pb/decentraland/sdk/components/mesh_renderer.gen.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBMeshRenderer_SphereMesh = exports.PBMeshRenderer_PlaneMesh = exports.PBMeshRenderer_CylinderMesh = exports.PBMeshRenderer_BoxMesh = exports.PBMeshRenderer = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBMeshRenderer() {
+    return { mesh: undefined };
+}
+/**
+ * @public
+ */
+var PBMeshRenderer;
+(function (PBMeshRenderer) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        switch (message.mesh?.$case) {
+            case "box":
+                PBMeshRenderer_BoxMesh.encode(message.mesh.box, writer.uint32(10).fork()).ldelim();
+                break;
+            case "sphere":
+                PBMeshRenderer_SphereMesh.encode(message.mesh.sphere, writer.uint32(18).fork()).ldelim();
+                break;
+            case "cylinder":
+                PBMeshRenderer_CylinderMesh.encode(message.mesh.cylinder, writer.uint32(26).fork()).ldelim();
+                break;
+            case "plane":
+                PBMeshRenderer_PlaneMesh.encode(message.mesh.plane, writer.uint32(34).fork()).ldelim();
+                break;
+        }
+        return writer;
+    }
+    PBMeshRenderer.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshRenderer();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.mesh = { $case: "box", box: PBMeshRenderer_BoxMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.mesh = { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.mesh = { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.mesh = { $case: "plane", plane: PBMeshRenderer_PlaneMesh.decode(reader, reader.uint32()) };
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer.decode = decode;
+})(PBMeshRenderer = exports.PBMeshRenderer || (exports.PBMeshRenderer = {}));
+function createBasePBMeshRenderer_BoxMesh() {
+    return { uvs: [] };
+}
+/**
+ * @public
+ */
+var PBMeshRenderer_BoxMesh;
+(function (PBMeshRenderer_BoxMesh) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        writer.uint32(10).fork();
+        for (const v of message.uvs) {
+            writer.float(v);
+        }
+        writer.ldelim();
+        return writer;
+    }
+    PBMeshRenderer_BoxMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshRenderer_BoxMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag === 13) {
+                        message.uvs.push(reader.float());
+                        continue;
+                    }
+                    if (tag === 10) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uvs.push(reader.float());
+                        }
+                        continue;
+                    }
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer_BoxMesh.decode = decode;
+})(PBMeshRenderer_BoxMesh = exports.PBMeshRenderer_BoxMesh || (exports.PBMeshRenderer_BoxMesh = {}));
+function createBasePBMeshRenderer_CylinderMesh() {
+    return { radiusTop: undefined, radiusBottom: undefined };
+}
+/**
+ * @public
+ */
+var PBMeshRenderer_CylinderMesh;
+(function (PBMeshRenderer_CylinderMesh) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.radiusTop !== undefined) {
+            writer.uint32(13).float(message.radiusTop);
+        }
+        if (message.radiusBottom !== undefined) {
+            writer.uint32(21).float(message.radiusBottom);
+        }
+        return writer;
+    }
+    PBMeshRenderer_CylinderMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshRenderer_CylinderMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.radiusTop = reader.float();
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.radiusBottom = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer_CylinderMesh.decode = decode;
+})(PBMeshRenderer_CylinderMesh = exports.PBMeshRenderer_CylinderMesh || (exports.PBMeshRenderer_CylinderMesh = {}));
+function createBasePBMeshRenderer_PlaneMesh() {
+    return { uvs: [] };
+}
+/**
+ * @public
+ */
+var PBMeshRenderer_PlaneMesh;
+(function (PBMeshRenderer_PlaneMesh) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        writer.uint32(10).fork();
+        for (const v of message.uvs) {
+            writer.float(v);
+        }
+        writer.ldelim();
+        return writer;
+    }
+    PBMeshRenderer_PlaneMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshRenderer_PlaneMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag === 13) {
+                        message.uvs.push(reader.float());
+                        continue;
+                    }
+                    if (tag === 10) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uvs.push(reader.float());
+                        }
+                        continue;
+                    }
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer_PlaneMesh.decode = decode;
+})(PBMeshRenderer_PlaneMesh = exports.PBMeshRenderer_PlaneMesh || (exports.PBMeshRenderer_PlaneMesh = {}));
+function createBasePBMeshRenderer_SphereMesh() {
+    return {};
+}
+/**
+ * @public
+ */
+var PBMeshRenderer_SphereMesh;
+(function (PBMeshRenderer_SphereMesh) {
+    function encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    }
+    PBMeshRenderer_SphereMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshRenderer_SphereMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer_SphereMesh.decode = decode;
+})(PBMeshRenderer_SphereMesh = exports.PBMeshRenderer_SphereMesh || (exports.PBMeshRenderer_SphereMesh = {}));

package/dist-cjs/components/generated/pb/decentraland/sdk/components/nft_shape.gen.d.ts

@@ -0,0 +1,58 @@
+import _m0 from "protobufjs/minimal";
+import { Color3 } from "../../common/colors.gen";
+/** NftFrameType is a predefined framing style for the image. */
+/**
+ * @public
+ */
+export declare const enum NftFrameType {
+    NFT_CLASSIC = 0,
+    NFT_BAROQUE_ORNAMENT = 1,
+    NFT_DIAMOND_ORNAMENT = 2,
+    NFT_MINIMAL_WIDE = 3,
+    NFT_MINIMAL_GREY = 4,
+    NFT_BLOCKY = 5,
+    NFT_GOLD_EDGES = 6,
+    NFT_GOLD_CARVED = 7,
+    NFT_GOLD_WIDE = 8,
+    NFT_GOLD_ROUNDED = 9,
+    NFT_METAL_MEDIUM = 10,
+    NFT_METAL_WIDE = 11,
+    NFT_METAL_SLIM = 12,
+    NFT_METAL_ROUNDED = 13,
+    NFT_PINS = 14,
+    NFT_MINIMAL_BLACK = 15,
+    NFT_MINIMAL_WHITE = 16,
+    NFT_TAPE = 17,
+    NFT_WOOD_SLIM = 18,
+    NFT_WOOD_WIDE = 19,
+    NFT_WOOD_TWIGS = 20,
+    NFT_CANVAS = 21,
+    NFT_NONE = 22
+}
+/**
+ * The NftShape component renders a framed picture from an NFT. It supports PNG, JPEG and GIF files.
+ *
+ * The `urn` field is the URI of the NFT, and must follow the format 'urn:decentraland:<CHAIN>:<CONTRACT_STANDARD>:<CONTRACT_ADDRESS>:<TOKEN_ID>'
+ * Example: 'urn:decentraland:ethereum:erc721:0x00000000:123'
+ *
+ * The picture frame can have several different styles, plus a background color for images that have
+ * transparent pixels.
+ */
+/**
+ * @public
+ */
+export interface PBNftShape {
+    /** the URI of the NFT */
+    urn: string;
+    /** the frame style (default NFT_CLASSIC) */
+    style?: NftFrameType | undefined;
+    /** RGB background (default [0.6404918, 0.611472, 0.8584906]) */
+    color?: Color3 | undefined;
+}
+/**
+ * @public
+ */
+export declare namespace PBNftShape {
+    function encode(message: PBNftShape, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBNftShape;
+}

package/dist-cjs/components/generated/pb/decentraland/sdk/components/nft_shape.gen.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBNftShape = exports.NftFrameType = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const colors_gen_1 = require("../../common/colors.gen");
+const protobufPackageSarasa = "decentraland.sdk.components";
+/** NftFrameType is a predefined framing style for the image. */
+/**
+ * @public
+ */
+var NftFrameType;
+(function (NftFrameType) {
+    NftFrameType[NftFrameType["NFT_CLASSIC"] = 0] = "NFT_CLASSIC";
+    NftFrameType[NftFrameType["NFT_BAROQUE_ORNAMENT"] = 1] = "NFT_BAROQUE_ORNAMENT";
+    NftFrameType[NftFrameType["NFT_DIAMOND_ORNAMENT"] = 2] = "NFT_DIAMOND_ORNAMENT";
+    NftFrameType[NftFrameType["NFT_MINIMAL_WIDE"] = 3] = "NFT_MINIMAL_WIDE";
+    NftFrameType[NftFrameType["NFT_MINIMAL_GREY"] = 4] = "NFT_MINIMAL_GREY";
+    NftFrameType[NftFrameType["NFT_BLOCKY"] = 5] = "NFT_BLOCKY";
+    NftFrameType[NftFrameType["NFT_GOLD_EDGES"] = 6] = "NFT_GOLD_EDGES";
+    NftFrameType[NftFrameType["NFT_GOLD_CARVED"] = 7] = "NFT_GOLD_CARVED";
+    NftFrameType[NftFrameType["NFT_GOLD_WIDE"] = 8] = "NFT_GOLD_WIDE";
+    NftFrameType[NftFrameType["NFT_GOLD_ROUNDED"] = 9] = "NFT_GOLD_ROUNDED";
+    NftFrameType[NftFrameType["NFT_METAL_MEDIUM"] = 10] = "NFT_METAL_MEDIUM";
+    NftFrameType[NftFrameType["NFT_METAL_WIDE"] = 11] = "NFT_METAL_WIDE";
+    NftFrameType[NftFrameType["NFT_METAL_SLIM"] = 12] = "NFT_METAL_SLIM";
+    NftFrameType[NftFrameType["NFT_METAL_ROUNDED"] = 13] = "NFT_METAL_ROUNDED";
+    NftFrameType[NftFrameType["NFT_PINS"] = 14] = "NFT_PINS";
+    NftFrameType[NftFrameType["NFT_MINIMAL_BLACK"] = 15] = "NFT_MINIMAL_BLACK";
+    NftFrameType[NftFrameType["NFT_MINIMAL_WHITE"] = 16] = "NFT_MINIMAL_WHITE";
+    NftFrameType[NftFrameType["NFT_TAPE"] = 17] = "NFT_TAPE";
+    NftFrameType[NftFrameType["NFT_WOOD_SLIM"] = 18] = "NFT_WOOD_SLIM";
+    NftFrameType[NftFrameType["NFT_WOOD_WIDE"] = 19] = "NFT_WOOD_WIDE";
+    NftFrameType[NftFrameType["NFT_WOOD_TWIGS"] = 20] = "NFT_WOOD_TWIGS";
+    NftFrameType[NftFrameType["NFT_CANVAS"] = 21] = "NFT_CANVAS";
+    NftFrameType[NftFrameType["NFT_NONE"] = 22] = "NFT_NONE";
+})(NftFrameType = exports.NftFrameType || (exports.NftFrameType = {}));
+function createBasePBNftShape() {
+    return { urn: "", style: undefined, color: undefined };
+}
+/**
+ * @public
+ */
+var PBNftShape;
+(function (PBNftShape) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.urn !== "") {
+            writer.uint32(10).string(message.urn);
+        }
+        if (message.style !== undefined) {
+            writer.uint32(16).int32(message.style);
+        }
+        if (message.color !== undefined) {
+            colors_gen_1.Color3.encode(message.color, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    }
+    PBNftShape.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBNftShape();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.urn = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.style = reader.int32();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.color = colors_gen_1.Color3.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBNftShape.decode = decode;
+})(PBNftShape = exports.PBNftShape || (exports.PBNftShape = {}));

package/dist-cjs/components/generated/pb/decentraland/sdk/components/pointer_events.gen.d.ts

@@ -0,0 +1,67 @@
+import _m0 from "protobufjs/minimal";
+import { InputAction, PointerEventType } from "./common/input_action.gen";
+/**
+ * PointerEvents adds configurable pointer-based interactions to the attached Entity.
+ *
+ * Events that match the criteria defined in the PointerEvents structure are reported back to the
+ * Entity via the PointerEventsResult component.
+ *
+ * Some examples of events that can be detected:
+ * - Pointer hovering over the Entity.
+ * - Held mouse button released over the Entity.
+ * - Controller button pressed while targeting the Entity.
+ * - Key pressed while targeting the Entity, but only in close range.
+ *
+ * It also supports simple visual feedback when interactions occur, by showing floating text.
+ * More sophisticated feedback requires the use of other components.
+ */
+/**
+ * @public
+ */
+export interface PBPointerEvents {
+    /** the list of relevant events to detect */
+    pointerEvents: PBPointerEvents_Entry[];
+}
+/**
+ * @public
+ */
+export interface PBPointerEvents_Info {
+    /** key/button in use (default IA_ANY) */
+    button?: InputAction | undefined;
+    /** feedback on hover (default 'Interact') */
+    hoverText?: string | undefined;
+    /** range of interaction (default 10) */
+    maxDistance?: number | undefined;
+    /** enable or disable hover text (default true) */
+    showFeedback?: boolean | undefined;
+}
+/**
+ * @public
+ */
+export interface PBPointerEvents_Entry {
+    /** the kind of interaction to detect */
+    eventType: PointerEventType;
+    /** additional configuration for this detection */
+    eventInfo: PBPointerEvents_Info | undefined;
+}
+/**
+ * @public
+ */
+export declare namespace PBPointerEvents {
+    function encode(message: PBPointerEvents, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEvents;
+}
+/**
+ * @public
+ */
+export declare namespace PBPointerEvents_Info {
+    function encode(message: PBPointerEvents_Info, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEvents_Info;
+}
+/**
+ * @public
+ */
+export declare namespace PBPointerEvents_Entry {
+    function encode(message: PBPointerEvents_Entry, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEvents_Entry;
+}