@dcl/ecs 7.1.12-4982571416.commit-0b87aa7 → 7.1.12-4983011170.commit-adaaaa2

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;
+}

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

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBPointerEvents_Entry = exports.PBPointerEvents_Info = exports.PBPointerEvents = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBPointerEvents() {
+    return { pointerEvents: [] };
+}
+/**
+ * @public
+ */
+var PBPointerEvents;
+(function (PBPointerEvents) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        for (const v of message.pointerEvents) {
+            PBPointerEvents_Entry.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    }
+    PBPointerEvents.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 = createBasePBPointerEvents();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.pointerEvents.push(PBPointerEvents_Entry.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBPointerEvents.decode = decode;
+})(PBPointerEvents = exports.PBPointerEvents || (exports.PBPointerEvents = {}));
+function createBasePBPointerEvents_Info() {
+    return { button: undefined, hoverText: undefined, maxDistance: undefined, showFeedback: undefined };
+}
+/**
+ * @public
+ */
+var PBPointerEvents_Info;
+(function (PBPointerEvents_Info) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.button !== undefined) {
+            writer.uint32(8).int32(message.button);
+        }
+        if (message.hoverText !== undefined) {
+            writer.uint32(18).string(message.hoverText);
+        }
+        if (message.maxDistance !== undefined) {
+            writer.uint32(29).float(message.maxDistance);
+        }
+        if (message.showFeedback !== undefined) {
+            writer.uint32(32).bool(message.showFeedback);
+        }
+        return writer;
+    }
+    PBPointerEvents_Info.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 = createBasePBPointerEvents_Info();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.button = reader.int32();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.hoverText = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.maxDistance = reader.float();
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.showFeedback = reader.bool();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBPointerEvents_Info.decode = decode;
+})(PBPointerEvents_Info = exports.PBPointerEvents_Info || (exports.PBPointerEvents_Info = {}));
+function createBasePBPointerEvents_Entry() {
+    return { eventType: 0, eventInfo: undefined };
+}
+/**
+ * @public
+ */
+var PBPointerEvents_Entry;
+(function (PBPointerEvents_Entry) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.eventType !== 0) {
+            writer.uint32(8).int32(message.eventType);
+        }
+        if (message.eventInfo !== undefined) {
+            PBPointerEvents_Info.encode(message.eventInfo, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    }
+    PBPointerEvents_Entry.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 = createBasePBPointerEvents_Entry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.eventType = reader.int32();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.eventInfo = PBPointerEvents_Info.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBPointerEvents_Entry.decode = decode;
+})(PBPointerEvents_Entry = exports.PBPointerEvents_Entry || (exports.PBPointerEvents_Entry = {}));

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

@@ -0,0 +1,26 @@
+import _m0 from "protobufjs/minimal";
+import { InputAction, PointerEventType } from "./common/input_action.gen";
+import { RaycastHit } from "./common/raycast_hit.gen";
+/** renderer append a new object of this in each command, there can be many commands per frames */
+/**
+ * @public
+ */
+export interface PBPointerEventsResult {
+    /** identifier of the input */
+    button: InputAction;
+    hit: RaycastHit | undefined;
+    state: PointerEventType;
+    /** monotonic counter */
+    timestamp: number;
+    /** if the input is analog then we store it here */
+    analog?: number | undefined;
+    /** number of tick in which the event was produced, equals to EngineInfo.tick_number */
+    tickNumber: number;
+}
+/**
+ * @public
+ */
+export declare namespace PBPointerEventsResult {
+    function encode(message: PBPointerEventsResult, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEventsResult;
+}

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

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBPointerEventsResult = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const raycast_hit_gen_1 = require("./common/raycast_hit.gen");
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBPointerEventsResult() {
+    return { button: 0, hit: undefined, state: 0, timestamp: 0, analog: undefined, tickNumber: 0 };
+}
+/**
+ * @public
+ */
+var PBPointerEventsResult;
+(function (PBPointerEventsResult) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.button !== 0) {
+            writer.uint32(8).int32(message.button);
+        }
+        if (message.hit !== undefined) {
+            raycast_hit_gen_1.RaycastHit.encode(message.hit, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.state !== 0) {
+            writer.uint32(32).int32(message.state);
+        }
+        if (message.timestamp !== 0) {
+            writer.uint32(40).uint32(message.timestamp);
+        }
+        if (message.analog !== undefined) {
+            writer.uint32(53).float(message.analog);
+        }
+        if (message.tickNumber !== 0) {
+            writer.uint32(56).uint32(message.tickNumber);
+        }
+        return writer;
+    }
+    PBPointerEventsResult.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 = createBasePBPointerEventsResult();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.button = reader.int32();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.hit = raycast_hit_gen_1.RaycastHit.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.state = reader.int32();
+                    continue;
+                case 5:
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.timestamp = reader.uint32();
+                    continue;
+                case 6:
+                    if (tag !== 53) {
+                        break;
+                    }
+                    message.analog = reader.float();
+                    continue;
+                case 7:
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.tickNumber = reader.uint32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBPointerEventsResult.decode = decode;
+})(PBPointerEventsResult = exports.PBPointerEventsResult || (exports.PBPointerEventsResult = {}));

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

@@ -0,0 +1,19 @@
+import _m0 from "protobufjs/minimal";
+/**
+ * PointerLock indicates whether the mouse pointer is automatically following the camera’s point of
+ * focus (locked), or can move freely on the screen (unlocked).
+ */
+/**
+ * @public
+ */
+export interface PBPointerLock {
+    /** whether the pointer is locked */
+    isPointerLocked: boolean;
+}
+/**
+ * @public
+ */
+export declare namespace PBPointerLock {
+    function encode(message: PBPointerLock, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerLock;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBPointerLock = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBPointerLock() {
+    return { isPointerLocked: false };
+}
+/**
+ * @public
+ */
+var PBPointerLock;
+(function (PBPointerLock) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.isPointerLocked === true) {
+            writer.uint32(8).bool(message.isPointerLocked);
+        }
+        return writer;
+    }
+    PBPointerLock.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 = createBasePBPointerLock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.isPointerLocked = reader.bool();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBPointerLock.decode = decode;
+})(PBPointerLock = exports.PBPointerLock || (exports.PBPointerLock = {}));

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

@@ -0,0 +1,63 @@
+import _m0 from "protobufjs/minimal";
+import { Vector3 } from "../../common/vectors.gen";
+/** RaycastQueryType indicates whether the ray should stop on the first collition, or continue. */
+/**
+ * @public
+ */
+export declare const enum RaycastQueryType {
+    /** RQT_HIT_FIRST - Pick the first (not necessarily the closest) hit within the range */
+    RQT_HIT_FIRST = 0,
+    /** RQT_QUERY_ALL - Pick all hits within the range */
+    RQT_QUERY_ALL = 1,
+    /** RQT_NONE - Do not perform the raycast, only set the raycast result with empty hits */
+    RQT_NONE = 2
+}
+/**
+ * The PBRaycast component and PBRaycastResult are defined in https://adr.decentraland.org/adr/ADR-200
+ *
+ * The Raycast component allows scenes to request raycasting from the game engine. The results will
+ * be available in a RaycastResult component set later on the same Entity.
+ */
+/**
+ * @public
+ */
+export interface PBRaycast {
+    /** Correlation ID, defined by the scene and used internally by the scene */
+    timestamp?: number | undefined;
+    /**
+     * How much to offset the starting point of the ray, relative to the entity's transform.
+     * Defaults to vec3(0,0,0)
+     */
+    originOffset?: Vector3 | undefined;
+    direction?: {
+        $case: "localDirection";
+        localDirection: Vector3;
+    } | {
+        $case: "globalDirection";
+        globalDirection: Vector3;
+    } | {
+        $case: "globalTarget";
+        globalTarget: Vector3;
+    } | {
+        $case: "targetEntity";
+        targetEntity: number;
+    };
+    /** Maximum length of the ray in virtual meters (global space) */
+    maxDistance: number;
+    /** the RaycastQueryType behavior */
+    queryType: RaycastQueryType;
+    /**
+     * Indicates the renderer to perform the raycast on every scene tick (ADR-148),
+     * otherwise it will be performed only once, defaults to false
+     */
+    continuous?: boolean | undefined;
+    /** Collision mask, by default CL_POINTER | CL_PHYSICS */
+    collisionMask?: number | undefined;
+}
+/**
+ * @public
+ */
+export declare namespace PBRaycast {
+    function encode(message: PBRaycast, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBRaycast;
+}