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

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

@@ -0,0 +1,176 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+export var ColliderLayer;
+(function (ColliderLayer) {
+    ColliderLayer[ColliderLayer["CL_NONE"] = 0] = "CL_NONE";
+    ColliderLayer[ColliderLayer["CL_POINTER"] = 1] = "CL_POINTER";
+    ColliderLayer[ColliderLayer["CL_PHYSICS"] = 2] = "CL_PHYSICS";
+})(ColliderLayer || (ColliderLayer = {}));
+function createBasePBMeshCollider() {
+    return { collisionMask: undefined, mesh: undefined };
+}
+/**
+ * Internal
+ */
+export const PBMeshCollider = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.collisionMask !== undefined) {
+            writer.uint32(8).int32(message.collisionMask);
+        }
+        if (message.mesh?.$case === 'box') {
+            PBMeshCollider_BoxMesh.encode(message.mesh.box, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.mesh?.$case === 'sphere') {
+            PBMeshCollider_SphereMesh.encode(message.mesh.sphere, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.mesh?.$case === 'cylinder') {
+            PBMeshCollider_CylinderMesh.encode(message.mesh.cylinder, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.mesh?.$case === 'plane') {
+            PBMeshCollider_PlaneMesh.encode(message.mesh.plane, writer.uint32(42).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 = createBasePBMeshCollider();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collisionMask = reader.int32();
+                    break;
+                case 2:
+                    message.mesh = { $case: 'box', box: PBMeshCollider_BoxMesh.decode(reader, reader.uint32()) };
+                    break;
+                case 3:
+                    message.mesh = { $case: 'sphere', sphere: PBMeshCollider_SphereMesh.decode(reader, reader.uint32()) };
+                    break;
+                case 4:
+                    message.mesh = { $case: 'cylinder', cylinder: PBMeshCollider_CylinderMesh.decode(reader, reader.uint32()) };
+                    break;
+                case 5:
+                    message.mesh = { $case: 'plane', plane: PBMeshCollider_PlaneMesh.decode(reader, reader.uint32()) };
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMeshCollider_BoxMesh() {
+    return {};
+}
+/**
+ * Internal
+ */
+export const PBMeshCollider_BoxMesh = {
+    encode(_, writer = _m0.Writer.create()) {
+        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 = createBasePBMeshCollider_BoxMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMeshCollider_CylinderMesh() {
+    return { radiusTop: undefined, radiusBottom: undefined };
+}
+/**
+ * Internal
+ */
+export const PBMeshCollider_CylinderMesh = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.radiusTop !== undefined) {
+            writer.uint32(13).float(message.radiusTop);
+        }
+        if (message.radiusBottom !== undefined) {
+            writer.uint32(21).float(message.radiusBottom);
+        }
+        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 = createBasePBMeshCollider_CylinderMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.radiusTop = reader.float();
+                    break;
+                case 2:
+                    message.radiusBottom = reader.float();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMeshCollider_PlaneMesh() {
+    return {};
+}
+/**
+ * Internal
+ */
+export const PBMeshCollider_PlaneMesh = {
+    encode(_, writer = _m0.Writer.create()) {
+        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 = createBasePBMeshCollider_PlaneMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMeshCollider_SphereMesh() {
+    return {};
+}
+/**
+ * Internal
+ */
+export const PBMeshCollider_SphereMesh = {
+    encode(_, writer = _m0.Writer.create()) {
+        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 = createBasePBMeshCollider_SphereMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,65 @@
+import _m0 from 'protobufjs/minimal';
+export interface PBMeshRenderer {
+    mesh?: {
+        $case: 'box';
+        box: PBMeshRenderer_BoxMesh;
+    } | {
+        $case: 'sphere';
+        sphere: PBMeshRenderer_SphereMesh;
+    } | {
+        $case: 'cylinder';
+        cylinder: PBMeshRenderer_CylinderMesh;
+    } | {
+        $case: 'plane';
+        plane: PBMeshRenderer_PlaneMesh;
+    };
+}
+export interface PBMeshRenderer_BoxMesh {
+    uvs: number[];
+}
+export interface PBMeshRenderer_CylinderMesh {
+    /** default=1.0 */
+    radiusTop?: number | undefined;
+    /** default=1.0 */
+    radiusBottom?: number | undefined;
+}
+export interface PBMeshRenderer_PlaneMesh {
+    uvs: number[];
+}
+export interface PBMeshRenderer_SphereMesh {
+}
+/**
+ * Internal
+ */
+export declare const PBMeshRenderer: {
+    encode(message: PBMeshRenderer, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer;
+};
+/**
+ * Internal
+ */
+export declare const PBMeshRenderer_BoxMesh: {
+    encode(message: PBMeshRenderer_BoxMesh, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_BoxMesh;
+};
+/**
+ * Internal
+ */
+export declare const PBMeshRenderer_CylinderMesh: {
+    encode(message: PBMeshRenderer_CylinderMesh, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_CylinderMesh;
+};
+/**
+ * Internal
+ */
+export declare const PBMeshRenderer_PlaneMesh: {
+    encode(message: PBMeshRenderer_PlaneMesh, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_PlaneMesh;
+};
+/**
+ * Internal
+ */
+export declare const PBMeshRenderer_SphereMesh: {
+    encode(_: PBMeshRenderer_SphereMesh, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_SphereMesh;
+};

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

@@ -0,0 +1,196 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBMeshRenderer() {
+    return { mesh: undefined };
+}
+/**
+ * Internal
+ */
+export const PBMeshRenderer = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.mesh?.$case === 'box') {
+            PBMeshRenderer_BoxMesh.encode(message.mesh.box, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.mesh?.$case === 'sphere') {
+            PBMeshRenderer_SphereMesh.encode(message.mesh.sphere, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.mesh?.$case === 'cylinder') {
+            PBMeshRenderer_CylinderMesh.encode(message.mesh.cylinder, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.mesh?.$case === 'plane') {
+            PBMeshRenderer_PlaneMesh.encode(message.mesh.plane, 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 = createBasePBMeshRenderer();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.mesh = { $case: 'box', box: PBMeshRenderer_BoxMesh.decode(reader, reader.uint32()) };
+                    break;
+                case 2:
+                    message.mesh = { $case: 'sphere', sphere: PBMeshRenderer_SphereMesh.decode(reader, reader.uint32()) };
+                    break;
+                case 3:
+                    message.mesh = { $case: 'cylinder', cylinder: PBMeshRenderer_CylinderMesh.decode(reader, reader.uint32()) };
+                    break;
+                case 4:
+                    message.mesh = { $case: 'plane', plane: PBMeshRenderer_PlaneMesh.decode(reader, reader.uint32()) };
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMeshRenderer_BoxMesh() {
+    return { uvs: [] };
+}
+/**
+ * Internal
+ */
+export const PBMeshRenderer_BoxMesh = {
+    encode(message, writer = _m0.Writer.create()) {
+        writer.uint32(10).fork();
+        for (const v of message.uvs) {
+            writer.float(v);
+        }
+        writer.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 = createBasePBMeshRenderer_BoxMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uvs.push(reader.float());
+                        }
+                    }
+                    else {
+                        message.uvs.push(reader.float());
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMeshRenderer_CylinderMesh() {
+    return { radiusTop: undefined, radiusBottom: undefined };
+}
+/**
+ * Internal
+ */
+export const PBMeshRenderer_CylinderMesh = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.radiusTop !== undefined) {
+            writer.uint32(13).float(message.radiusTop);
+        }
+        if (message.radiusBottom !== undefined) {
+            writer.uint32(21).float(message.radiusBottom);
+        }
+        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 = createBasePBMeshRenderer_CylinderMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.radiusTop = reader.float();
+                    break;
+                case 2:
+                    message.radiusBottom = reader.float();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMeshRenderer_PlaneMesh() {
+    return { uvs: [] };
+}
+/**
+ * Internal
+ */
+export const PBMeshRenderer_PlaneMesh = {
+    encode(message, writer = _m0.Writer.create()) {
+        writer.uint32(10).fork();
+        for (const v of message.uvs) {
+            writer.float(v);
+        }
+        writer.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 = createBasePBMeshRenderer_PlaneMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uvs.push(reader.float());
+                        }
+                    }
+                    else {
+                        message.uvs.push(reader.float());
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMeshRenderer_SphereMesh() {
+    return {};
+}
+/**
+ * Internal
+ */
+export const PBMeshRenderer_SphereMesh = {
+    encode(_, writer = _m0.Writer.create()) {
+        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 = createBasePBMeshRenderer_SphereMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,41 @@
+import { Color3 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+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
+}
+export interface PBNftShape {
+    src: string;
+    /** default = PictureFrameStyle.Classic */
+    style?: NftFrameType | undefined;
+    /** default = decentraland.common.Color3(0.6404918, 0.611472, 0.8584906) */
+    color?: Color3 | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBNftShape: {
+    encode(message: PBNftShape, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBNftShape;
+};

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

@@ -0,0 +1,73 @@
+/* eslint-disable */
+import { Color3 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+export 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 || (NftFrameType = {}));
+function createBasePBNftShape() {
+    return { src: '', style: undefined, color: undefined };
+}
+/**
+ * Internal
+ */
+export const PBNftShape = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.src !== '') {
+            writer.uint32(10).string(message.src);
+        }
+        if (message.style !== undefined) {
+            writer.uint32(16).int32(message.style);
+        }
+        if (message.color !== undefined) {
+            Color3.encode(message.color, writer.uint32(26).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 = createBasePBNftShape();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.src = reader.string();
+                    break;
+                case 2:
+                    message.style = reader.int32();
+                    break;
+                case 3:
+                    message.color = Color3.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,34 @@
+import { InputAction } from './common/input_action.gen';
+import { PointerEventType } from './pointer_hover_feedback.gen';
+import { RaycastHit } from './raycast_result.gen';
+import _m0 from 'protobufjs/minimal';
+/** the renderer will set this component to the root entity once per frame with all the events */
+export interface PBPointerEventsResult {
+    /** a list of the last N pointer commands (from the engine) */
+    commands: PBPointerEventsResult_PointerCommand[];
+}
+/** this message represents a pointer event, used both for UP and DOWN actions */
+export interface PBPointerEventsResult_PointerCommand {
+    /** identifier of the input */
+    button: InputAction;
+    hit: RaycastHit | undefined;
+    state: PointerEventType;
+    /** could be a Lamport timestamp */
+    timestamp: number;
+    /** if the input is analog then we store it here */
+    analog?: number | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBPointerEventsResult: {
+    encode(message: PBPointerEventsResult, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEventsResult;
+};
+/**
+ * Internal
+ */
+export declare const PBPointerEventsResult_PointerCommand: {
+    encode(message: PBPointerEventsResult_PointerCommand, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEventsResult_PointerCommand;
+};

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

@@ -0,0 +1,89 @@
+import { RaycastHit } from './raycast_result.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBPointerEventsResult() {
+    return { commands: [] };
+}
+/**
+ * Internal
+ */
+export const PBPointerEventsResult = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.commands) {
+            PBPointerEventsResult_PointerCommand.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 = createBasePBPointerEventsResult();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.commands.push(PBPointerEventsResult_PointerCommand.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBPointerEventsResult_PointerCommand() {
+    return { button: 0, hit: undefined, state: 0, timestamp: 0, analog: undefined };
+}
+/**
+ * Internal
+ */
+export const PBPointerEventsResult_PointerCommand = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.button !== 0) {
+            writer.uint32(8).int32(message.button);
+        }
+        if (message.hit !== undefined) {
+            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).int32(message.timestamp);
+        }
+        if (message.analog !== undefined) {
+            writer.uint32(53).float(message.analog);
+        }
+        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 = createBasePBPointerEventsResult_PointerCommand();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.button = reader.int32();
+                    break;
+                case 2:
+                    message.hit = RaycastHit.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.state = reader.int32();
+                    break;
+                case 5:
+                    message.timestamp = reader.int32();
+                    break;
+                case 6:
+                    message.analog = reader.float();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};