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

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

@@ -0,0 +1,326 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBMaterial_PbrMaterial = exports.PBMaterial_UnlitMaterial = exports.PBMaterial = exports.MaterialTransparencyMode = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const colors_gen_1 = require("../../common/colors.gen");
+const texture_gen_1 = require("../../common/texture.gen");
+const protobufPackageSarasa = "decentraland.sdk.components";
+/**
+ * @public
+ */
+var MaterialTransparencyMode;
+(function (MaterialTransparencyMode) {
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_OPAQUE"] = 0] = "MTM_OPAQUE";
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_ALPHA_TEST"] = 1] = "MTM_ALPHA_TEST";
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_ALPHA_BLEND"] = 2] = "MTM_ALPHA_BLEND";
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_ALPHA_TEST_AND_ALPHA_BLEND"] = 3] = "MTM_ALPHA_TEST_AND_ALPHA_BLEND";
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_AUTO"] = 4] = "MTM_AUTO";
+})(MaterialTransparencyMode = exports.MaterialTransparencyMode || (exports.MaterialTransparencyMode = {}));
+function createBasePBMaterial() {
+    return { material: undefined };
+}
+/**
+ * @public
+ */
+var PBMaterial;
+(function (PBMaterial) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        switch (message.material?.$case) {
+            case "unlit":
+                PBMaterial_UnlitMaterial.encode(message.material.unlit, writer.uint32(10).fork()).ldelim();
+                break;
+            case "pbr":
+                PBMaterial_PbrMaterial.encode(message.material.pbr, writer.uint32(18).fork()).ldelim();
+                break;
+        }
+        return writer;
+    }
+    PBMaterial.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 = createBasePBMaterial();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.material = { $case: "unlit", unlit: PBMaterial_UnlitMaterial.decode(reader, reader.uint32()) };
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.material = { $case: "pbr", pbr: PBMaterial_PbrMaterial.decode(reader, reader.uint32()) };
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMaterial.decode = decode;
+})(PBMaterial = exports.PBMaterial || (exports.PBMaterial = {}));
+function createBasePBMaterial_UnlitMaterial() {
+    return { texture: undefined, alphaTest: undefined, castShadows: undefined, diffuseColor: undefined };
+}
+/**
+ * @public
+ */
+var PBMaterial_UnlitMaterial;
+(function (PBMaterial_UnlitMaterial) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.texture !== undefined) {
+            texture_gen_1.TextureUnion.encode(message.texture, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.alphaTest !== undefined) {
+            writer.uint32(21).float(message.alphaTest);
+        }
+        if (message.castShadows !== undefined) {
+            writer.uint32(24).bool(message.castShadows);
+        }
+        if (message.diffuseColor !== undefined) {
+            colors_gen_1.Color4.encode(message.diffuseColor, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    }
+    PBMaterial_UnlitMaterial.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 = createBasePBMaterial_UnlitMaterial();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.texture = texture_gen_1.TextureUnion.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.alphaTest = reader.float();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.castShadows = reader.bool();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.diffuseColor = colors_gen_1.Color4.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMaterial_UnlitMaterial.decode = decode;
+})(PBMaterial_UnlitMaterial = exports.PBMaterial_UnlitMaterial || (exports.PBMaterial_UnlitMaterial = {}));
+function createBasePBMaterial_PbrMaterial() {
+    return {
+        texture: undefined,
+        alphaTest: undefined,
+        castShadows: undefined,
+        alphaTexture: undefined,
+        emissiveTexture: undefined,
+        bumpTexture: undefined,
+        albedoColor: undefined,
+        emissiveColor: undefined,
+        reflectivityColor: undefined,
+        transparencyMode: undefined,
+        metallic: undefined,
+        roughness: undefined,
+        glossiness: undefined,
+        specularIntensity: undefined,
+        emissiveIntensity: undefined,
+        directIntensity: undefined,
+    };
+}
+/**
+ * @public
+ */
+var PBMaterial_PbrMaterial;
+(function (PBMaterial_PbrMaterial) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.texture !== undefined) {
+            texture_gen_1.TextureUnion.encode(message.texture, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.alphaTest !== undefined) {
+            writer.uint32(21).float(message.alphaTest);
+        }
+        if (message.castShadows !== undefined) {
+            writer.uint32(24).bool(message.castShadows);
+        }
+        if (message.alphaTexture !== undefined) {
+            texture_gen_1.TextureUnion.encode(message.alphaTexture, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.emissiveTexture !== undefined) {
+            texture_gen_1.TextureUnion.encode(message.emissiveTexture, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.bumpTexture !== undefined) {
+            texture_gen_1.TextureUnion.encode(message.bumpTexture, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.albedoColor !== undefined) {
+            colors_gen_1.Color4.encode(message.albedoColor, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.emissiveColor !== undefined) {
+            colors_gen_1.Color3.encode(message.emissiveColor, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.reflectivityColor !== undefined) {
+            colors_gen_1.Color3.encode(message.reflectivityColor, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.transparencyMode !== undefined) {
+            writer.uint32(80).int32(message.transparencyMode);
+        }
+        if (message.metallic !== undefined) {
+            writer.uint32(93).float(message.metallic);
+        }
+        if (message.roughness !== undefined) {
+            writer.uint32(101).float(message.roughness);
+        }
+        if (message.glossiness !== undefined) {
+            writer.uint32(109).float(message.glossiness);
+        }
+        if (message.specularIntensity !== undefined) {
+            writer.uint32(117).float(message.specularIntensity);
+        }
+        if (message.emissiveIntensity !== undefined) {
+            writer.uint32(125).float(message.emissiveIntensity);
+        }
+        if (message.directIntensity !== undefined) {
+            writer.uint32(133).float(message.directIntensity);
+        }
+        return writer;
+    }
+    PBMaterial_PbrMaterial.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 = createBasePBMaterial_PbrMaterial();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.texture = texture_gen_1.TextureUnion.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.alphaTest = reader.float();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.castShadows = reader.bool();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.alphaTexture = texture_gen_1.TextureUnion.decode(reader, reader.uint32());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.emissiveTexture = texture_gen_1.TextureUnion.decode(reader, reader.uint32());
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.bumpTexture = texture_gen_1.TextureUnion.decode(reader, reader.uint32());
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.albedoColor = colors_gen_1.Color4.decode(reader, reader.uint32());
+                    continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.emissiveColor = colors_gen_1.Color3.decode(reader, reader.uint32());
+                    continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.reflectivityColor = colors_gen_1.Color3.decode(reader, reader.uint32());
+                    continue;
+                case 10:
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.transparencyMode = reader.int32();
+                    continue;
+                case 11:
+                    if (tag !== 93) {
+                        break;
+                    }
+                    message.metallic = reader.float();
+                    continue;
+                case 12:
+                    if (tag !== 101) {
+                        break;
+                    }
+                    message.roughness = reader.float();
+                    continue;
+                case 13:
+                    if (tag !== 109) {
+                        break;
+                    }
+                    message.glossiness = reader.float();
+                    continue;
+                case 14:
+                    if (tag !== 117) {
+                        break;
+                    }
+                    message.specularIntensity = reader.float();
+                    continue;
+                case 15:
+                    if (tag !== 125) {
+                        break;
+                    }
+                    message.emissiveIntensity = reader.float();
+                    continue;
+                case 16:
+                    if (tag !== 133) {
+                        break;
+                    }
+                    message.directIntensity = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMaterial_PbrMaterial.decode = decode;
+})(PBMaterial_PbrMaterial = exports.PBMaterial_PbrMaterial || (exports.PBMaterial_PbrMaterial = {}));

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

@@ -0,0 +1,120 @@
+import _m0 from "protobufjs/minimal";
+/** ColliderLayer determines the kind of collision to detect, in OR-able bit flag form. */
+/**
+ * @public
+ */
+export declare const enum ColliderLayer {
+    /** CL_NONE - no collisions */
+    CL_NONE = 0,
+    /** CL_POINTER - collisions with the player's pointer ray (e.g. mouse cursor hovering) */
+    CL_POINTER = 1,
+    /** CL_PHYSICS - collision affecting your player's physics i.e. walls, floor, moving platfroms */
+    CL_PHYSICS = 2,
+    CL_RESERVED1 = 4,
+    CL_RESERVED2 = 8,
+    CL_RESERVED3 = 16,
+    CL_RESERVED4 = 32,
+    CL_RESERVED5 = 64,
+    CL_RESERVED6 = 128,
+    CL_CUSTOM1 = 256,
+    CL_CUSTOM2 = 512,
+    CL_CUSTOM3 = 1024,
+    CL_CUSTOM4 = 2048,
+    CL_CUSTOM5 = 4096,
+    CL_CUSTOM6 = 8192,
+    CL_CUSTOM7 = 16384,
+    CL_CUSTOM8 = 32768
+}
+/**
+ * The MeshCollider component provides basic collision detection between Entities and Avatars. It
+ * can behave like a cube, a plane, a sphere or a cylinder.
+ *
+ * The Entity's Transform affects the MeshCollider, scaling it and rotating it appropriately. If
+ * the Transform for the collision mesh must be different than the Transform for rendering the Entity,
+ * two different Entities must be used.
+ *
+ * More complex shapes require the use of a `GltfContainer` component.
+ */
+/**
+ * @public
+ */
+export interface PBMeshCollider {
+    /** enabled ColliderLayers (default CL_POINTER | CL_PHYSICS) */
+    collisionMask?: number | undefined;
+    mesh?: {
+        $case: "box";
+        box: PBMeshCollider_BoxMesh;
+    } | {
+        $case: "sphere";
+        sphere: PBMeshCollider_SphereMesh;
+    } | {
+        $case: "cylinder";
+        cylinder: PBMeshCollider_CylinderMesh;
+    } | {
+        $case: "plane";
+        plane: PBMeshCollider_PlaneMesh;
+    };
+}
+/** BoxMesh is a prism shape that contains the Entity. */
+/**
+ * @public
+ */
+export interface PBMeshCollider_BoxMesh {
+}
+/** CylinderMesh is a truncated cone shape that contains the Entity. */
+/**
+ * @public
+ */
+export interface PBMeshCollider_CylinderMesh {
+    /** (default 0.5) */
+    radiusTop?: number | undefined;
+    /** (default 0.5) */
+    radiusBottom?: number | undefined;
+}
+/** PlaneMesh is a 2D rectangle described by the Entity's Transform. */
+/**
+ * @public
+ */
+export interface PBMeshCollider_PlaneMesh {
+}
+/** SphereMesh is a sphere shape that contains the Entity. */
+/**
+ * @public
+ */
+export interface PBMeshCollider_SphereMesh {
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider {
+    function encode(message: PBMeshCollider, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider_BoxMesh {
+    function encode(_: PBMeshCollider_BoxMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_BoxMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider_CylinderMesh {
+    function encode(message: PBMeshCollider_CylinderMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_CylinderMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider_PlaneMesh {
+    function encode(_: PBMeshCollider_PlaneMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_PlaneMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider_SphereMesh {
+    function encode(_: PBMeshCollider_SphereMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_SphereMesh;
+}

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

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBMeshCollider_SphereMesh = exports.PBMeshCollider_PlaneMesh = exports.PBMeshCollider_CylinderMesh = exports.PBMeshCollider_BoxMesh = exports.PBMeshCollider = exports.ColliderLayer = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+/** ColliderLayer determines the kind of collision to detect, in OR-able bit flag form. */
+/**
+ * @public
+ */
+var ColliderLayer;
+(function (ColliderLayer) {
+    /** CL_NONE - no collisions */
+    ColliderLayer[ColliderLayer["CL_NONE"] = 0] = "CL_NONE";
+    /** CL_POINTER - collisions with the player's pointer ray (e.g. mouse cursor hovering) */
+    ColliderLayer[ColliderLayer["CL_POINTER"] = 1] = "CL_POINTER";
+    /** CL_PHYSICS - collision affecting your player's physics i.e. walls, floor, moving platfroms */
+    ColliderLayer[ColliderLayer["CL_PHYSICS"] = 2] = "CL_PHYSICS";
+    ColliderLayer[ColliderLayer["CL_RESERVED1"] = 4] = "CL_RESERVED1";
+    ColliderLayer[ColliderLayer["CL_RESERVED2"] = 8] = "CL_RESERVED2";
+    ColliderLayer[ColliderLayer["CL_RESERVED3"] = 16] = "CL_RESERVED3";
+    ColliderLayer[ColliderLayer["CL_RESERVED4"] = 32] = "CL_RESERVED4";
+    ColliderLayer[ColliderLayer["CL_RESERVED5"] = 64] = "CL_RESERVED5";
+    ColliderLayer[ColliderLayer["CL_RESERVED6"] = 128] = "CL_RESERVED6";
+    ColliderLayer[ColliderLayer["CL_CUSTOM1"] = 256] = "CL_CUSTOM1";
+    ColliderLayer[ColliderLayer["CL_CUSTOM2"] = 512] = "CL_CUSTOM2";
+    ColliderLayer[ColliderLayer["CL_CUSTOM3"] = 1024] = "CL_CUSTOM3";
+    ColliderLayer[ColliderLayer["CL_CUSTOM4"] = 2048] = "CL_CUSTOM4";
+    ColliderLayer[ColliderLayer["CL_CUSTOM5"] = 4096] = "CL_CUSTOM5";
+    ColliderLayer[ColliderLayer["CL_CUSTOM6"] = 8192] = "CL_CUSTOM6";
+    ColliderLayer[ColliderLayer["CL_CUSTOM7"] = 16384] = "CL_CUSTOM7";
+    ColliderLayer[ColliderLayer["CL_CUSTOM8"] = 32768] = "CL_CUSTOM8";
+})(ColliderLayer = exports.ColliderLayer || (exports.ColliderLayer = {}));
+function createBasePBMeshCollider() {
+    return { collisionMask: undefined, mesh: undefined };
+}
+/**
+ * @public
+ */
+var PBMeshCollider;
+(function (PBMeshCollider) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.collisionMask !== undefined) {
+            writer.uint32(8).uint32(message.collisionMask);
+        }
+        switch (message.mesh?.$case) {
+            case "box":
+                PBMeshCollider_BoxMesh.encode(message.mesh.box, writer.uint32(18).fork()).ldelim();
+                break;
+            case "sphere":
+                PBMeshCollider_SphereMesh.encode(message.mesh.sphere, writer.uint32(26).fork()).ldelim();
+                break;
+            case "cylinder":
+                PBMeshCollider_CylinderMesh.encode(message.mesh.cylinder, writer.uint32(34).fork()).ldelim();
+                break;
+            case "plane":
+                PBMeshCollider_PlaneMesh.encode(message.mesh.plane, writer.uint32(42).fork()).ldelim();
+                break;
+        }
+        return writer;
+    }
+    PBMeshCollider.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 = createBasePBMeshCollider();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.collisionMask = reader.uint32();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.mesh = { $case: "box", box: PBMeshCollider_BoxMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.mesh = { $case: "sphere", sphere: PBMeshCollider_SphereMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.mesh = { $case: "cylinder", cylinder: PBMeshCollider_CylinderMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.mesh = { $case: "plane", plane: PBMeshCollider_PlaneMesh.decode(reader, reader.uint32()) };
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider.decode = decode;
+})(PBMeshCollider = exports.PBMeshCollider || (exports.PBMeshCollider = {}));
+function createBasePBMeshCollider_BoxMesh() {
+    return {};
+}
+/**
+ * @public
+ */
+var PBMeshCollider_BoxMesh;
+(function (PBMeshCollider_BoxMesh) {
+    function encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    }
+    PBMeshCollider_BoxMesh.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 = createBasePBMeshCollider_BoxMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider_BoxMesh.decode = decode;
+})(PBMeshCollider_BoxMesh = exports.PBMeshCollider_BoxMesh || (exports.PBMeshCollider_BoxMesh = {}));
+function createBasePBMeshCollider_CylinderMesh() {
+    return { radiusTop: undefined, radiusBottom: undefined };
+}
+/**
+ * @public
+ */
+var PBMeshCollider_CylinderMesh;
+(function (PBMeshCollider_CylinderMesh) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.radiusTop !== undefined) {
+            writer.uint32(13).float(message.radiusTop);
+        }
+        if (message.radiusBottom !== undefined) {
+            writer.uint32(21).float(message.radiusBottom);
+        }
+        return writer;
+    }
+    PBMeshCollider_CylinderMesh.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 = createBasePBMeshCollider_CylinderMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.radiusTop = reader.float();
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.radiusBottom = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider_CylinderMesh.decode = decode;
+})(PBMeshCollider_CylinderMesh = exports.PBMeshCollider_CylinderMesh || (exports.PBMeshCollider_CylinderMesh = {}));
+function createBasePBMeshCollider_PlaneMesh() {
+    return {};
+}
+/**
+ * @public
+ */
+var PBMeshCollider_PlaneMesh;
+(function (PBMeshCollider_PlaneMesh) {
+    function encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    }
+    PBMeshCollider_PlaneMesh.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 = createBasePBMeshCollider_PlaneMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider_PlaneMesh.decode = decode;
+})(PBMeshCollider_PlaneMesh = exports.PBMeshCollider_PlaneMesh || (exports.PBMeshCollider_PlaneMesh = {}));
+function createBasePBMeshCollider_SphereMesh() {
+    return {};
+}
+/**
+ * @public
+ */
+var PBMeshCollider_SphereMesh;
+(function (PBMeshCollider_SphereMesh) {
+    function encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    }
+    PBMeshCollider_SphereMesh.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 = createBasePBMeshCollider_SphereMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider_SphereMesh.decode = decode;
+})(PBMeshCollider_SphereMesh = exports.PBMeshCollider_SphereMesh || (exports.PBMeshCollider_SphereMesh = {}));