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

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

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 = {}));