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

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

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBRaycast = exports.RaycastQueryType = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const vectors_gen_1 = require("../../common/vectors.gen");
+const protobufPackageSarasa = "decentraland.sdk.components";
+/** RaycastQueryType indicates whether the ray should stop on the first collition, or continue. */
+/**
+ * @public
+ */
+var RaycastQueryType;
+(function (RaycastQueryType) {
+    /** RQT_HIT_FIRST - Pick the first (not necessarily the closest) hit within the range */
+    RaycastQueryType[RaycastQueryType["RQT_HIT_FIRST"] = 0] = "RQT_HIT_FIRST";
+    /** RQT_QUERY_ALL - Pick all hits within the range */
+    RaycastQueryType[RaycastQueryType["RQT_QUERY_ALL"] = 1] = "RQT_QUERY_ALL";
+    /** RQT_NONE - Do not perform the raycast, only set the raycast result with empty hits */
+    RaycastQueryType[RaycastQueryType["RQT_NONE"] = 2] = "RQT_NONE";
+})(RaycastQueryType = exports.RaycastQueryType || (exports.RaycastQueryType = {}));
+function createBasePBRaycast() {
+    return {
+        timestamp: undefined,
+        originOffset: undefined,
+        direction: undefined,
+        maxDistance: 0,
+        queryType: 0,
+        continuous: undefined,
+        collisionMask: undefined,
+    };
+}
+/**
+ * @public
+ */
+var PBRaycast;
+(function (PBRaycast) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.timestamp !== undefined) {
+            writer.uint32(8).uint32(message.timestamp);
+        }
+        if (message.originOffset !== undefined) {
+            vectors_gen_1.Vector3.encode(message.originOffset, writer.uint32(18).fork()).ldelim();
+        }
+        switch (message.direction?.$case) {
+            case "localDirection":
+                vectors_gen_1.Vector3.encode(message.direction.localDirection, writer.uint32(50).fork()).ldelim();
+                break;
+            case "globalDirection":
+                vectors_gen_1.Vector3.encode(message.direction.globalDirection, writer.uint32(26).fork()).ldelim();
+                break;
+            case "globalTarget":
+                vectors_gen_1.Vector3.encode(message.direction.globalTarget, writer.uint32(58).fork()).ldelim();
+                break;
+            case "targetEntity":
+                writer.uint32(80).uint32(message.direction.targetEntity);
+                break;
+        }
+        if (message.maxDistance !== 0) {
+            writer.uint32(37).float(message.maxDistance);
+        }
+        if (message.queryType !== 0) {
+            writer.uint32(40).int32(message.queryType);
+        }
+        if (message.continuous !== undefined) {
+            writer.uint32(64).bool(message.continuous);
+        }
+        if (message.collisionMask !== undefined) {
+            writer.uint32(72).uint32(message.collisionMask);
+        }
+        return writer;
+    }
+    PBRaycast.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 = createBasePBRaycast();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.timestamp = reader.uint32();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.originOffset = vectors_gen_1.Vector3.decode(reader, reader.uint32());
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.direction = { $case: "localDirection", localDirection: vectors_gen_1.Vector3.decode(reader, reader.uint32()) };
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.direction = { $case: "globalDirection", globalDirection: vectors_gen_1.Vector3.decode(reader, reader.uint32()) };
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.direction = { $case: "globalTarget", globalTarget: vectors_gen_1.Vector3.decode(reader, reader.uint32()) };
+                    continue;
+                case 10:
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.direction = { $case: "targetEntity", targetEntity: reader.uint32() };
+                    continue;
+                case 4:
+                    if (tag !== 37) {
+                        break;
+                    }
+                    message.maxDistance = reader.float();
+                    continue;
+                case 5:
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.queryType = reader.int32();
+                    continue;
+                case 8:
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.continuous = reader.bool();
+                    continue;
+                case 9:
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.collisionMask = reader.uint32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBRaycast.decode = decode;
+})(PBRaycast = exports.PBRaycast || (exports.PBRaycast = {}));

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

@@ -0,0 +1,32 @@
+import _m0 from "protobufjs/minimal";
+import { Vector3 } from "../../common/vectors.gen";
+import { RaycastHit } from "./common/raycast_hit.gen";
+/**
+ * The PBRaycast component and PBRaycastResult are defined in https://adr.decentraland.org/adr/ADR-200
+ *
+ * The RaycastResult component is added to an Entity when the results of a previously attached
+ * Raycast component are available. It contains information about the ray and any objects it
+ * collided with.
+ */
+/**
+ * @public
+ */
+export interface PBRaycastResult {
+    /** timestamp is a correlation id, copied from the PBRaycast */
+    timestamp?: number | 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;
+    /** zero or more hits */
+    hits: RaycastHit[];
+    /** number of tick in which the event was produced, equals to EngineInfo.tick_number */
+    tickNumber: number;
+}
+/**
+ * @public
+ */
+export declare namespace PBRaycastResult {
+    function encode(message: PBRaycastResult, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBRaycastResult;
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBRaycastResult = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const vectors_gen_1 = require("../../common/vectors.gen");
+const raycast_hit_gen_1 = require("./common/raycast_hit.gen");
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBRaycastResult() {
+    return { timestamp: undefined, globalOrigin: undefined, direction: undefined, hits: [], tickNumber: 0 };
+}
+/**
+ * @public
+ */
+var PBRaycastResult;
+(function (PBRaycastResult) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.timestamp !== undefined) {
+            writer.uint32(8).uint32(message.timestamp);
+        }
+        if (message.globalOrigin !== undefined) {
+            vectors_gen_1.Vector3.encode(message.globalOrigin, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.direction !== undefined) {
+            vectors_gen_1.Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.hits) {
+            raycast_hit_gen_1.RaycastHit.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.tickNumber !== 0) {
+            writer.uint32(40).uint32(message.tickNumber);
+        }
+        return writer;
+    }
+    PBRaycastResult.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 = createBasePBRaycastResult();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.timestamp = reader.uint32();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.globalOrigin = vectors_gen_1.Vector3.decode(reader, reader.uint32());
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.direction = vectors_gen_1.Vector3.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.hits.push(raycast_hit_gen_1.RaycastHit.decode(reader, reader.uint32()));
+                    continue;
+                case 5:
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.tickNumber = reader.uint32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBRaycastResult.decode = decode;
+})(PBRaycastResult = exports.PBRaycastResult || (exports.PBRaycastResult = {}));

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

@@ -0,0 +1,65 @@
+import _m0 from "protobufjs/minimal";
+import { Color3, Color4 } from "../../common/colors.gen";
+import { Font, TextAlignMode } from "./common/texts.gen";
+/**
+ * The TextShape component renders customizable floating text.
+ *
+ * The position and rotation of the text are defined by the Entity's Transform, while its size
+ * can either scale with the Transform or be fixed by a font size.
+ *
+ * Several options can be configured, including color, padding, line spacing and drop shadows.
+ */
+/**
+ * @public
+ */
+export interface PBTextShape {
+    /** the content */
+    text: string;
+    /** the font (default F_SANS_SERIF) */
+    font?: Font | undefined;
+    /** the font size (default 10) */
+    fontSize?: number | undefined;
+    /** override `font_size` to automatically fit in `width`/`height` */
+    fontAutoSize?: boolean | undefined;
+    /** X and Y alignment (default TAM_CENTER_CENTER) */
+    textAlign?: TextAlignMode | undefined;
+    /** available horizontal space (default 1) */
+    width?: number | undefined;
+    /** available vertical space (default 1) */
+    height?: number | undefined;
+    /** distance from text to top border (default 0) */
+    paddingTop?: number | undefined;
+    /** distance from text to right border (default 0) */
+    paddingRight?: number | undefined;
+    /** distance from text to bottom border (default 0) */
+    paddingBottom?: number | undefined;
+    /** distance from text to left border (default 0) */
+    paddingLeft?: number | undefined;
+    /** extra distance between lines (default 0) */
+    lineSpacing?: number | undefined;
+    /** maximum number of lines to display */
+    lineCount?: number | undefined;
+    /** wrap text when the border is reached (default false) */
+    textWrapping?: boolean | undefined;
+    /** blurriness of the drop shadow (default 0) */
+    shadowBlur?: number | undefined;
+    /** horizontal length of the shadow (default 0) */
+    shadowOffsetX?: number | undefined;
+    /** vertical length of the shadow (default 0) */
+    shadowOffsetY?: number | undefined;
+    /** width of the stroke outlining each letter (default 0) */
+    outlineWidth?: number | undefined;
+    /** drop shadow color (default [1.0, 1.0, 1.0]) */
+    shadowColor?: Color3 | undefined;
+    /** outline stroke color (default [1.0, 1.0, 1.0]) */
+    outlineColor?: Color3 | undefined;
+    /** text color (default [1.0, 1.0, 1.0]) */
+    textColor?: Color4 | undefined;
+}
+/**
+ * @public
+ */
+export declare namespace PBTextShape {
+    function encode(message: PBTextShape, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBTextShape;
+}

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

@@ -0,0 +1,250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBTextShape = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const colors_gen_1 = require("../../common/colors.gen");
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBTextShape() {
+    return {
+        text: "",
+        font: undefined,
+        fontSize: undefined,
+        fontAutoSize: undefined,
+        textAlign: undefined,
+        width: undefined,
+        height: undefined,
+        paddingTop: undefined,
+        paddingRight: undefined,
+        paddingBottom: undefined,
+        paddingLeft: undefined,
+        lineSpacing: undefined,
+        lineCount: undefined,
+        textWrapping: undefined,
+        shadowBlur: undefined,
+        shadowOffsetX: undefined,
+        shadowOffsetY: undefined,
+        outlineWidth: undefined,
+        shadowColor: undefined,
+        outlineColor: undefined,
+        textColor: undefined,
+    };
+}
+/**
+ * @public
+ */
+var PBTextShape;
+(function (PBTextShape) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.text !== "") {
+            writer.uint32(10).string(message.text);
+        }
+        if (message.font !== undefined) {
+            writer.uint32(16).int32(message.font);
+        }
+        if (message.fontSize !== undefined) {
+            writer.uint32(29).float(message.fontSize);
+        }
+        if (message.fontAutoSize !== undefined) {
+            writer.uint32(32).bool(message.fontAutoSize);
+        }
+        if (message.textAlign !== undefined) {
+            writer.uint32(40).int32(message.textAlign);
+        }
+        if (message.width !== undefined) {
+            writer.uint32(53).float(message.width);
+        }
+        if (message.height !== undefined) {
+            writer.uint32(61).float(message.height);
+        }
+        if (message.paddingTop !== undefined) {
+            writer.uint32(69).float(message.paddingTop);
+        }
+        if (message.paddingRight !== undefined) {
+            writer.uint32(77).float(message.paddingRight);
+        }
+        if (message.paddingBottom !== undefined) {
+            writer.uint32(85).float(message.paddingBottom);
+        }
+        if (message.paddingLeft !== undefined) {
+            writer.uint32(93).float(message.paddingLeft);
+        }
+        if (message.lineSpacing !== undefined) {
+            writer.uint32(101).float(message.lineSpacing);
+        }
+        if (message.lineCount !== undefined) {
+            writer.uint32(104).int32(message.lineCount);
+        }
+        if (message.textWrapping !== undefined) {
+            writer.uint32(112).bool(message.textWrapping);
+        }
+        if (message.shadowBlur !== undefined) {
+            writer.uint32(125).float(message.shadowBlur);
+        }
+        if (message.shadowOffsetX !== undefined) {
+            writer.uint32(133).float(message.shadowOffsetX);
+        }
+        if (message.shadowOffsetY !== undefined) {
+            writer.uint32(141).float(message.shadowOffsetY);
+        }
+        if (message.outlineWidth !== undefined) {
+            writer.uint32(149).float(message.outlineWidth);
+        }
+        if (message.shadowColor !== undefined) {
+            colors_gen_1.Color3.encode(message.shadowColor, writer.uint32(154).fork()).ldelim();
+        }
+        if (message.outlineColor !== undefined) {
+            colors_gen_1.Color3.encode(message.outlineColor, writer.uint32(162).fork()).ldelim();
+        }
+        if (message.textColor !== undefined) {
+            colors_gen_1.Color4.encode(message.textColor, writer.uint32(170).fork()).ldelim();
+        }
+        return writer;
+    }
+    PBTextShape.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 = createBasePBTextShape();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.text = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.font = reader.int32();
+                    continue;
+                case 3:
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.fontSize = reader.float();
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.fontAutoSize = reader.bool();
+                    continue;
+                case 5:
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.textAlign = reader.int32();
+                    continue;
+                case 6:
+                    if (tag !== 53) {
+                        break;
+                    }
+                    message.width = reader.float();
+                    continue;
+                case 7:
+                    if (tag !== 61) {
+                        break;
+                    }
+                    message.height = reader.float();
+                    continue;
+                case 8:
+                    if (tag !== 69) {
+                        break;
+                    }
+                    message.paddingTop = reader.float();
+                    continue;
+                case 9:
+                    if (tag !== 77) {
+                        break;
+                    }
+                    message.paddingRight = reader.float();
+                    continue;
+                case 10:
+                    if (tag !== 85) {
+                        break;
+                    }
+                    message.paddingBottom = reader.float();
+                    continue;
+                case 11:
+                    if (tag !== 93) {
+                        break;
+                    }
+                    message.paddingLeft = reader.float();
+                    continue;
+                case 12:
+                    if (tag !== 101) {
+                        break;
+                    }
+                    message.lineSpacing = reader.float();
+                    continue;
+                case 13:
+                    if (tag !== 104) {
+                        break;
+                    }
+                    message.lineCount = reader.int32();
+                    continue;
+                case 14:
+                    if (tag !== 112) {
+                        break;
+                    }
+                    message.textWrapping = reader.bool();
+                    continue;
+                case 15:
+                    if (tag !== 125) {
+                        break;
+                    }
+                    message.shadowBlur = reader.float();
+                    continue;
+                case 16:
+                    if (tag !== 133) {
+                        break;
+                    }
+                    message.shadowOffsetX = reader.float();
+                    continue;
+                case 17:
+                    if (tag !== 141) {
+                        break;
+                    }
+                    message.shadowOffsetY = reader.float();
+                    continue;
+                case 18:
+                    if (tag !== 149) {
+                        break;
+                    }
+                    message.outlineWidth = reader.float();
+                    continue;
+                case 19:
+                    if (tag !== 154) {
+                        break;
+                    }
+                    message.shadowColor = colors_gen_1.Color3.decode(reader, reader.uint32());
+                    continue;
+                case 20:
+                    if (tag !== 162) {
+                        break;
+                    }
+                    message.outlineColor = colors_gen_1.Color3.decode(reader, reader.uint32());
+                    continue;
+                case 21:
+                    if (tag !== 170) {
+                        break;
+                    }
+                    message.textColor = colors_gen_1.Color4.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBTextShape.decode = decode;
+})(PBTextShape = exports.PBTextShape || (exports.PBTextShape = {}));

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

@@ -0,0 +1,47 @@
+import _m0 from "protobufjs/minimal";
+import { BorderRect } from "../../common/border_rect.gen";
+import { Color4 } from "../../common/colors.gen";
+import { TextureUnion } from "../../common/texture.gen";
+/**
+ * @public
+ */
+export declare const enum BackgroundTextureMode {
+    /**
+     * NINE_SLICES - https://docs.unity3d.com/Manual/UIE-USS-SupportedProperties.html (Slicing section)
+     * https://forum.unity.com/threads/how-does-slicing-in-ui-tookkit-works.1235863/
+     * https://docs.unity3d.com/Manual/9SliceSprites.html
+     * https://developer.mozilla.org/en-US/docs/Web/CSS/border-image-slice
+     */
+    NINE_SLICES = 0,
+    /**
+     * CENTER - CENTER enables the texture to be rendered centered in relation to the
+     * element. If the element is smaller than the texture then the background
+     * should use the element as stencil to cut off the out-of-bounds area
+     */
+    CENTER = 1,
+    /**
+     * STRETCH - STRETCH enables the texture to cover all the area of the container,
+     * adopting its aspect ratio.
+     */
+    STRETCH = 2
+}
+/**
+ * @public
+ */
+export interface PBUiBackground {
+    /** default=(1.0, 1.0, 1.0, 1.0), pixel = color * sample2D(texture, uv) */
+    color?: Color4 | undefined;
+    texture?: TextureUnion | undefined;
+    textureMode: BackgroundTextureMode;
+    /** default=(1/3, 1/3, 1/3, 1/3) */
+    textureSlices?: BorderRect | undefined;
+    /** default=[0,0,0,1,1,0,1,0]: starting from bottom-left vertex clock-wise */
+    uvs: number[];
+}
+/**
+ * @public
+ */
+export declare namespace PBUiBackground {
+    function encode(message: PBUiBackground, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiBackground;
+}