@dcl/protocol 1.0.0-2569677750.commit-6ce832a → 1.0.0-25748996127.commit-767845e

package/out-ts/decentraland/sdk/components/mesh_renderer.gen.ts

@@ -0,0 +1,551 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/**
+ * The MeshRenderer component renders a basic geometric shape for an Entity. It can be a cube, a
+ * plane, a sphere, a cylinder, or a Gltf mesh.
+ *
+ * The cube and plane variants can include a UV texture mapping, so specific areas of a material
+ * texture are rendered on different faces of the shape. They are serialized as a sequence of 2D
+ * `float` coordinates, one for each corner of each side of each face.
+ */
+export interface PBMeshRenderer {
+  mesh?:
+    | { $case: "box"; box: PBMeshRenderer_BoxMesh }
+    | { $case: "sphere"; sphere: PBMeshRenderer_SphereMesh }
+    | { $case: "cylinder"; cylinder: PBMeshRenderer_CylinderMesh }
+    | { $case: "plane"; plane: PBMeshRenderer_PlaneMesh }
+    | { $case: "gltf"; gltf: PBMeshRenderer_GltfMesh }
+    | undefined;
+}
+
+/** BoxMesh renders a prism shape. */
+export interface PBMeshRenderer_BoxMesh {
+  /** 96-value texture map (2D * 6 faces * 2 sides * 4 vertices) */
+  uvs: number[];
+}
+
+/** CylinderMesh renders a truncated cone shape. */
+export interface PBMeshRenderer_CylinderMesh {
+  /** (default 0.5) */
+  radiusTop?:
+    | number
+    | undefined;
+  /** (default 0.5) */
+  radiusBottom?: number | undefined;
+}
+
+/** PlaneMesh renders a 2D rectangular shape. */
+export interface PBMeshRenderer_PlaneMesh {
+  /** 16-value texture map (2D * 1 face * 2 sides * 4 vertices) */
+  uvs: number[];
+}
+
+/** SphereMesh renders a spherical shape. */
+export interface PBMeshRenderer_SphereMesh {
+}
+
+/** A mesh from a Gltf. */
+export interface PBMeshRenderer_GltfMesh {
+  /** the GLTF file path as listed in the scene's manifest. */
+  gltfSrc: string;
+  /** the name of the mesh asset */
+  name: string;
+}
+
+function createBasePBMeshRenderer(): PBMeshRenderer {
+  return { mesh: undefined };
+}
+
+export namespace PBMeshRenderer {
+  export function encode(message: PBMeshRenderer, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.mesh?.$case) {
+      case "box":
+        PBMeshRenderer_BoxMesh.encode(message.mesh.box, writer.uint32(10).fork()).ldelim();
+        break;
+      case "sphere":
+        PBMeshRenderer_SphereMesh.encode(message.mesh.sphere, writer.uint32(18).fork()).ldelim();
+        break;
+      case "cylinder":
+        PBMeshRenderer_CylinderMesh.encode(message.mesh.cylinder, writer.uint32(26).fork()).ldelim();
+        break;
+      case "plane":
+        PBMeshRenderer_PlaneMesh.encode(message.mesh.plane, writer.uint32(34).fork()).ldelim();
+        break;
+      case "gltf":
+        PBMeshRenderer_GltfMesh.encode(message.mesh.gltf, writer.uint32(42).fork()).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.mesh = { $case: "box", box: PBMeshRenderer_BoxMesh.decode(reader, reader.uint32()) };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.mesh = { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.decode(reader, reader.uint32()) };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.mesh = { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.decode(reader, reader.uint32()) };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.mesh = { $case: "plane", plane: PBMeshRenderer_PlaneMesh.decode(reader, reader.uint32()) };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.mesh = { $case: "gltf", gltf: PBMeshRenderer_GltfMesh.decode(reader, reader.uint32()) };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBMeshRenderer {
+    return {
+      mesh: isSet(object.box)
+        ? { $case: "box", box: PBMeshRenderer_BoxMesh.fromJSON(object.box) }
+        : isSet(object.sphere)
+        ? { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.fromJSON(object.sphere) }
+        : isSet(object.cylinder)
+        ? { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.fromJSON(object.cylinder) }
+        : isSet(object.plane)
+        ? { $case: "plane", plane: PBMeshRenderer_PlaneMesh.fromJSON(object.plane) }
+        : isSet(object.gltf)
+        ? { $case: "gltf", gltf: PBMeshRenderer_GltfMesh.fromJSON(object.gltf) }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: PBMeshRenderer): unknown {
+    const obj: any = {};
+    message.mesh?.$case === "box" &&
+      (obj.box = message.mesh?.box ? PBMeshRenderer_BoxMesh.toJSON(message.mesh?.box) : undefined);
+    message.mesh?.$case === "sphere" &&
+      (obj.sphere = message.mesh?.sphere ? PBMeshRenderer_SphereMesh.toJSON(message.mesh?.sphere) : undefined);
+    message.mesh?.$case === "cylinder" &&
+      (obj.cylinder = message.mesh?.cylinder ? PBMeshRenderer_CylinderMesh.toJSON(message.mesh?.cylinder) : undefined);
+    message.mesh?.$case === "plane" &&
+      (obj.plane = message.mesh?.plane ? PBMeshRenderer_PlaneMesh.toJSON(message.mesh?.plane) : undefined);
+    message.mesh?.$case === "gltf" &&
+      (obj.gltf = message.mesh?.gltf ? PBMeshRenderer_GltfMesh.toJSON(message.mesh?.gltf) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBMeshRenderer>, I>>(base?: I): PBMeshRenderer {
+    return PBMeshRenderer.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBMeshRenderer>, I>>(object: I): PBMeshRenderer {
+    const message = createBasePBMeshRenderer();
+    if (object.mesh?.$case === "box" && object.mesh?.box !== undefined && object.mesh?.box !== null) {
+      message.mesh = { $case: "box", box: PBMeshRenderer_BoxMesh.fromPartial(object.mesh.box) };
+    }
+    if (object.mesh?.$case === "sphere" && object.mesh?.sphere !== undefined && object.mesh?.sphere !== null) {
+      message.mesh = { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.fromPartial(object.mesh.sphere) };
+    }
+    if (object.mesh?.$case === "cylinder" && object.mesh?.cylinder !== undefined && object.mesh?.cylinder !== null) {
+      message.mesh = { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.fromPartial(object.mesh.cylinder) };
+    }
+    if (object.mesh?.$case === "plane" && object.mesh?.plane !== undefined && object.mesh?.plane !== null) {
+      message.mesh = { $case: "plane", plane: PBMeshRenderer_PlaneMesh.fromPartial(object.mesh.plane) };
+    }
+    if (object.mesh?.$case === "gltf" && object.mesh?.gltf !== undefined && object.mesh?.gltf !== null) {
+      message.mesh = { $case: "gltf", gltf: PBMeshRenderer_GltfMesh.fromPartial(object.mesh.gltf) };
+    }
+    return message;
+  }
+}
+
+function createBasePBMeshRenderer_BoxMesh(): PBMeshRenderer_BoxMesh {
+  return { uvs: [] };
+}
+
+export namespace PBMeshRenderer_BoxMesh {
+  export function encode(message: PBMeshRenderer_BoxMesh, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    writer.uint32(10).fork();
+    for (const v of message.uvs) {
+      writer.float(v);
+    }
+    writer.ldelim();
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_BoxMesh {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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 === 13) {
+            message.uvs.push(reader.float());
+
+            continue;
+          }
+
+          if (tag === 10) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.uvs.push(reader.float());
+            }
+
+            continue;
+          }
+
+          break;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBMeshRenderer_BoxMesh {
+    return { uvs: Array.isArray(object?.uvs) ? object.uvs.map((e: any) => Number(e)) : [] };
+  }
+
+  export function toJSON(message: PBMeshRenderer_BoxMesh): unknown {
+    const obj: any = {};
+    if (message.uvs) {
+      obj.uvs = message.uvs.map((e) => e);
+    } else {
+      obj.uvs = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBMeshRenderer_BoxMesh>, I>>(base?: I): PBMeshRenderer_BoxMesh {
+    return PBMeshRenderer_BoxMesh.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBMeshRenderer_BoxMesh>, I>>(
+    object: I,
+  ): PBMeshRenderer_BoxMesh {
+    const message = createBasePBMeshRenderer_BoxMesh();
+    message.uvs = object.uvs?.map((e) => e) || [];
+    return message;
+  }
+}
+
+function createBasePBMeshRenderer_CylinderMesh(): PBMeshRenderer_CylinderMesh {
+  return { radiusTop: undefined, radiusBottom: undefined };
+}
+
+export namespace PBMeshRenderer_CylinderMesh {
+  export function encode(message: PBMeshRenderer_CylinderMesh, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.radiusTop !== undefined) {
+      writer.uint32(13).float(message.radiusTop);
+    }
+    if (message.radiusBottom !== undefined) {
+      writer.uint32(21).float(message.radiusBottom);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_CylinderMesh {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
+          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;
+  }
+
+  export function fromJSON(object: any): PBMeshRenderer_CylinderMesh {
+    return {
+      radiusTop: isSet(object.radiusTop) ? Number(object.radiusTop) : undefined,
+      radiusBottom: isSet(object.radiusBottom) ? Number(object.radiusBottom) : undefined,
+    };
+  }
+
+  export function toJSON(message: PBMeshRenderer_CylinderMesh): unknown {
+    const obj: any = {};
+    message.radiusTop !== undefined && (obj.radiusTop = message.radiusTop);
+    message.radiusBottom !== undefined && (obj.radiusBottom = message.radiusBottom);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBMeshRenderer_CylinderMesh>, I>>(
+    base?: I,
+  ): PBMeshRenderer_CylinderMesh {
+    return PBMeshRenderer_CylinderMesh.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBMeshRenderer_CylinderMesh>, I>>(
+    object: I,
+  ): PBMeshRenderer_CylinderMesh {
+    const message = createBasePBMeshRenderer_CylinderMesh();
+    message.radiusTop = object.radiusTop ?? undefined;
+    message.radiusBottom = object.radiusBottom ?? undefined;
+    return message;
+  }
+}
+
+function createBasePBMeshRenderer_PlaneMesh(): PBMeshRenderer_PlaneMesh {
+  return { uvs: [] };
+}
+
+export namespace PBMeshRenderer_PlaneMesh {
+  export function encode(message: PBMeshRenderer_PlaneMesh, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    writer.uint32(10).fork();
+    for (const v of message.uvs) {
+      writer.float(v);
+    }
+    writer.ldelim();
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_PlaneMesh {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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 === 13) {
+            message.uvs.push(reader.float());
+
+            continue;
+          }
+
+          if (tag === 10) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.uvs.push(reader.float());
+            }
+
+            continue;
+          }
+
+          break;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBMeshRenderer_PlaneMesh {
+    return { uvs: Array.isArray(object?.uvs) ? object.uvs.map((e: any) => Number(e)) : [] };
+  }
+
+  export function toJSON(message: PBMeshRenderer_PlaneMesh): unknown {
+    const obj: any = {};
+    if (message.uvs) {
+      obj.uvs = message.uvs.map((e) => e);
+    } else {
+      obj.uvs = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBMeshRenderer_PlaneMesh>, I>>(
+    base?: I,
+  ): PBMeshRenderer_PlaneMesh {
+    return PBMeshRenderer_PlaneMesh.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBMeshRenderer_PlaneMesh>, I>>(
+    object: I,
+  ): PBMeshRenderer_PlaneMesh {
+    const message = createBasePBMeshRenderer_PlaneMesh();
+    message.uvs = object.uvs?.map((e) => e) || [];
+    return message;
+  }
+}
+
+function createBasePBMeshRenderer_SphereMesh(): PBMeshRenderer_SphereMesh {
+  return {};
+}
+
+export namespace PBMeshRenderer_SphereMesh {
+  export function encode(_: PBMeshRenderer_SphereMesh, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_SphereMesh {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(_: any): PBMeshRenderer_SphereMesh {
+    return {};
+  }
+
+  export function toJSON(_: PBMeshRenderer_SphereMesh): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBMeshRenderer_SphereMesh>, I>>(
+    base?: I,
+  ): PBMeshRenderer_SphereMesh {
+    return PBMeshRenderer_SphereMesh.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBMeshRenderer_SphereMesh>, I>>(
+    _: I,
+  ): PBMeshRenderer_SphereMesh {
+    const message = createBasePBMeshRenderer_SphereMesh();
+    return message;
+  }
+}
+
+function createBasePBMeshRenderer_GltfMesh(): PBMeshRenderer_GltfMesh {
+  return { gltfSrc: "", name: "" };
+}
+
+export namespace PBMeshRenderer_GltfMesh {
+  export function encode(message: PBMeshRenderer_GltfMesh, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.gltfSrc !== "") {
+      writer.uint32(10).string(message.gltfSrc);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_GltfMesh {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBMeshRenderer_GltfMesh();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.gltfSrc = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBMeshRenderer_GltfMesh {
+    return {
+      gltfSrc: isSet(object.gltfSrc) ? String(object.gltfSrc) : "",
+      name: isSet(object.name) ? String(object.name) : "",
+    };
+  }
+
+  export function toJSON(message: PBMeshRenderer_GltfMesh): unknown {
+    const obj: any = {};
+    message.gltfSrc !== undefined && (obj.gltfSrc = message.gltfSrc);
+    message.name !== undefined && (obj.name = message.name);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBMeshRenderer_GltfMesh>, I>>(base?: I): PBMeshRenderer_GltfMesh {
+    return PBMeshRenderer_GltfMesh.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBMeshRenderer_GltfMesh>, I>>(
+    object: I,
+  ): PBMeshRenderer_GltfMesh {
+    const message = createBasePBMeshRenderer_GltfMesh();
+    message.gltfSrc = object.gltfSrc ?? "";
+    message.name = object.name ?? "";
+    return message;
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}