@dcl/ecs 7.0.0-3532389879.commit-c89c80c → 7.0.0-3568547351.commit-5420eac

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

@@ -0,0 +1,46 @@
+import { InputAction } from './common/input_action.gen';
+import _m0 from 'protobufjs/minimal';
+export declare const enum PointerEventType {
+    PET_UP = 0,
+    PET_DOWN = 1,
+    PET_HOVER_ENTER = 2,
+    PET_HOVER_LEAVE = 3
+}
+export interface PBPointerHoverFeedback {
+    pointerEvents: PBPointerHoverFeedback_Entry[];
+}
+export interface PBPointerHoverFeedback_Info {
+    /** default=InputAction.ANY */
+    button?: InputAction | undefined;
+    /** default='Interact' */
+    hoverText?: string | undefined;
+    /** default=10 */
+    maxDistance?: number | undefined;
+    /** default=true */
+    showFeedback?: boolean | undefined;
+}
+export interface PBPointerHoverFeedback_Entry {
+    eventType: PointerEventType;
+    eventInfo: PBPointerHoverFeedback_Info | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBPointerHoverFeedback: {
+    encode(message: PBPointerHoverFeedback, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerHoverFeedback;
+};
+/**
+ * Internal
+ */
+export declare const PBPointerHoverFeedback_Info: {
+    encode(message: PBPointerHoverFeedback_Info, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerHoverFeedback_Info;
+};
+/**
+ * Internal
+ */
+export declare const PBPointerHoverFeedback_Entry: {
+    encode(message: PBPointerHoverFeedback_Entry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerHoverFeedback_Entry;
+};

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

@@ -0,0 +1,126 @@
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+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 = {}));
+function createBasePBPointerHoverFeedback() {
+    return { pointerEvents: [] };
+}
+/**
+ * Internal
+ */
+export const PBPointerHoverFeedback = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.pointerEvents) {
+            PBPointerHoverFeedback_Entry.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBasePBPointerHoverFeedback();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pointerEvents.push(PBPointerHoverFeedback_Entry.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBPointerHoverFeedback_Info() {
+    return { button: undefined, hoverText: undefined, maxDistance: undefined, showFeedback: undefined };
+}
+/**
+ * Internal
+ */
+export const PBPointerHoverFeedback_Info = {
+    encode(message, writer = _m0.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;
+    },
+    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 = createBasePBPointerHoverFeedback_Info();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.button = reader.int32();
+                    break;
+                case 2:
+                    message.hoverText = reader.string();
+                    break;
+                case 3:
+                    message.maxDistance = reader.float();
+                    break;
+                case 4:
+                    message.showFeedback = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBPointerHoverFeedback_Entry() {
+    return { eventType: 0, eventInfo: undefined };
+}
+/**
+ * Internal
+ */
+export const PBPointerHoverFeedback_Entry = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.eventType !== 0) {
+            writer.uint32(8).int32(message.eventType);
+        }
+        if (message.eventInfo !== undefined) {
+            PBPointerHoverFeedback_Info.encode(message.eventInfo, writer.uint32(18).fork()).ldelim();
+        }
+        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 = createBasePBPointerHoverFeedback_Entry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.eventType = reader.int32();
+                    break;
+                case 2:
+                    message.eventInfo = PBPointerHoverFeedback_Info.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,11 @@
+import _m0 from 'protobufjs/minimal';
+export interface PBPointerLock {
+    isPointerLocked: boolean;
+}
+/**
+ * Internal
+ */
+export declare const PBPointerLock: {
+    encode(message: PBPointerLock, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerLock;
+};

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

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBPointerLock() {
+    return { isPointerLocked: false };
+}
+/**
+ * Internal
+ */
+export const PBPointerLock = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.isPointerLocked === true) {
+            writer.uint32(8).bool(message.isPointerLocked);
+        }
+        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 = createBasePBPointerLock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.isPointerLocked = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,19 @@
+import { Vector3 } from '../../common/vectors.gen';
+import _m0 from 'protobufjs/minimal';
+export declare const enum RaycastQueryType {
+    RQT_HIT_FIRST = 0,
+    RQT_QUERY_ALL = 1
+}
+export interface PBRaycast {
+    origin: Vector3 | undefined;
+    direction: Vector3 | undefined;
+    maxDistance: number;
+    queryType: RaycastQueryType;
+}
+/**
+ * Internal
+ */
+export declare const PBRaycast: {
+    encode(message: PBRaycast, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBRaycast;
+};

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

@@ -0,0 +1,58 @@
+/* eslint-disable */
+import { Vector3 } from '../../common/vectors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+export var RaycastQueryType;
+(function (RaycastQueryType) {
+    RaycastQueryType[RaycastQueryType["RQT_HIT_FIRST"] = 0] = "RQT_HIT_FIRST";
+    RaycastQueryType[RaycastQueryType["RQT_QUERY_ALL"] = 1] = "RQT_QUERY_ALL";
+})(RaycastQueryType || (RaycastQueryType = {}));
+function createBasePBRaycast() {
+    return { origin: undefined, direction: undefined, maxDistance: 0, queryType: 0 };
+}
+/**
+ * Internal
+ */
+export const PBRaycast = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.origin !== undefined) {
+            Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.direction !== undefined) {
+            Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.maxDistance !== 0) {
+            writer.uint32(37).float(message.maxDistance);
+        }
+        if (message.queryType !== 0) {
+            writer.uint32(40).int32(message.queryType);
+        }
+        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 = createBasePBRaycast();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    message.origin = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.direction = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.maxDistance = reader.float();
+                    break;
+                case 5:
+                    message.queryType = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,32 @@
+import { Vector3 } from '../../common/vectors.gen';
+import _m0 from 'protobufjs/minimal';
+export interface PBRaycastResult {
+    timestamp: number;
+    origin: Vector3 | undefined;
+    direction: Vector3 | undefined;
+    hits: RaycastHit[];
+}
+/** Position will be relative to the scene */
+export interface RaycastHit {
+    position: Vector3 | undefined;
+    origin: Vector3 | undefined;
+    direction: Vector3 | undefined;
+    normalHit: Vector3 | undefined;
+    length: number;
+    meshName?: string | undefined;
+    entityId?: number | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBRaycastResult: {
+    encode(message: PBRaycastResult, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBRaycastResult;
+};
+/**
+ * Internal
+ */
+export declare const RaycastHit: {
+    encode(message: RaycastHit, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): RaycastHit;
+};

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

@@ -0,0 +1,150 @@
+/* eslint-disable */
+import Long from 'long';
+import { Vector3 } from '../../common/vectors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBRaycastResult() {
+    return { timestamp: 0, origin: undefined, direction: undefined, hits: [] };
+}
+/**
+ * Internal
+ */
+export const PBRaycastResult = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.timestamp !== 0) {
+            writer.uint32(8).int32(message.timestamp);
+        }
+        if (message.origin !== undefined) {
+            Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.direction !== undefined) {
+            Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.hits) {
+            RaycastHit.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        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 = createBasePBRaycastResult();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.timestamp = reader.int32();
+                    break;
+                case 2:
+                    message.origin = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.direction = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.hits.push(RaycastHit.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBaseRaycastHit() {
+    return {
+        position: undefined,
+        origin: undefined,
+        direction: undefined,
+        normalHit: undefined,
+        length: 0,
+        meshName: undefined,
+        entityId: undefined
+    };
+}
+/**
+ * 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.origin !== undefined) {
+            Vector3.encode(message.origin, 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).int64(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.origin = 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 = longToNumber(reader.int64());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+var globalThis = (() => {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    if (typeof self !== 'undefined')
+        return self;
+    if (typeof window !== 'undefined')
+        return window;
+    if (typeof global !== 'undefined')
+        return global;
+    throw 'Unable to locate global object';
+})();
+function longToNumber(long) {
+    if (long.gt(Number.MAX_SAFE_INTEGER)) {
+        throw new globalThis.Error('Value is larger than Number.MAX_SAFE_INTEGER');
+    }
+    return long.toNumber();
+}
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
+}

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

@@ -0,0 +1,41 @@
+import { Font, TextAlignMode } from './common/texts.gen';
+import { Color3, Color4 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+export interface PBTextShape {
+    text: string;
+    /** default=F_SANS_SERIF */
+    font?: Font | undefined;
+    /** default=10 */
+    fontSize?: number | undefined;
+    fontAutoSize?: boolean | undefined;
+    /** default=TAM_CENTER_CENTER */
+    textAlign?: TextAlignMode | undefined;
+    /** default=1 */
+    width?: number | undefined;
+    /** default=1 */
+    height?: number | undefined;
+    paddingTop?: number | undefined;
+    paddingRight?: number | undefined;
+    paddingBottom?: number | undefined;
+    paddingLeft?: number | undefined;
+    lineSpacing?: number | undefined;
+    lineCount?: number | undefined;
+    textWrapping?: boolean | undefined;
+    shadowBlur?: number | undefined;
+    shadowOffsetX?: number | undefined;
+    shadowOffsetY?: number | undefined;
+    outlineWidth?: number | undefined;
+    /** default=(1.0,1.0,1.0) */
+    shadowColor?: Color3 | undefined;
+    /** default=(1.0,1.0,1.0) */
+    outlineColor?: Color3 | undefined;
+    /** default=(1.0,1.0,1.0) */
+    textColor?: Color4 | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBTextShape: {
+    encode(message: PBTextShape, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBTextShape;
+};