@dcl/protocol 1.0.0-22672716807.commit-22c32c9 → 1.0.0-22917704966.commit-8d5910d

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

@@ -0,0 +1,139 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+export enum GltfNodeStateValue {
+  GNSV_PENDING = 0,
+  GNSV_FAILED = 1,
+  GNSV_READY = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function gltfNodeStateValueFromJSON(object: any): GltfNodeStateValue {
+  switch (object) {
+    case 0:
+    case "GNSV_PENDING":
+      return GltfNodeStateValue.GNSV_PENDING;
+    case 1:
+    case "GNSV_FAILED":
+      return GltfNodeStateValue.GNSV_FAILED;
+    case 2:
+    case "GNSV_READY":
+      return GltfNodeStateValue.GNSV_READY;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return GltfNodeStateValue.UNRECOGNIZED;
+  }
+}
+
+export function gltfNodeStateValueToJSON(object: GltfNodeStateValue): string {
+  switch (object) {
+    case GltfNodeStateValue.GNSV_PENDING:
+      return "GNSV_PENDING";
+    case GltfNodeStateValue.GNSV_FAILED:
+      return "GNSV_FAILED";
+    case GltfNodeStateValue.GNSV_READY:
+      return "GNSV_READY";
+    case GltfNodeStateValue.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/**
+ * The state of a linked gltf node.
+ * If the state is GNSV_FAILED, the renderer may describe the failure in the error string.
+ */
+export interface PBGltfNodeState {
+  state: GltfNodeStateValue;
+  error?: string | undefined;
+}
+
+function createBasePBGltfNodeState(): PBGltfNodeState {
+  return { state: 0, error: undefined };
+}
+
+export namespace PBGltfNodeState {
+  export function encode(message: PBGltfNodeState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.state !== 0) {
+      writer.uint32(8).int32(message.state);
+    }
+    if (message.error !== undefined) {
+      writer.uint32(18).string(message.error);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfNodeState {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBGltfNodeState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.state = reader.int32() as any;
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.error = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBGltfNodeState {
+    return {
+      state: isSet(object.state) ? gltfNodeStateValueFromJSON(object.state) : 0,
+      error: isSet(object.error) ? String(object.error) : undefined,
+    };
+  }
+
+  export function toJSON(message: PBGltfNodeState): unknown {
+    const obj: any = {};
+    message.state !== undefined && (obj.state = gltfNodeStateValueToJSON(message.state));
+    message.error !== undefined && (obj.error = message.error);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBGltfNodeState>, I>>(base?: I): PBGltfNodeState {
+    return PBGltfNodeState.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBGltfNodeState>, I>>(object: I): PBGltfNodeState {
+    const message = createBasePBGltfNodeState();
+    message.state = object.state ?? 0;
+    message.error = object.error ?? undefined;
+    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;
+}

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

@@ -0,0 +1,265 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+export interface PBInputModifier {
+  mode?: { $case: "standard"; standard: PBInputModifier_StandardInput } | undefined;
+}
+
+/** when a boolean = false (default) the message is ignored and doesn't consume bandwidth */
+export interface PBInputModifier_StandardInput {
+  disableAll?: boolean | undefined;
+  disableWalk?: boolean | undefined;
+  disableJog?: boolean | undefined;
+  disableRun?: boolean | undefined;
+  disableJump?: boolean | undefined;
+  disableEmote?: boolean | undefined;
+  disableDoubleJump?: boolean | undefined;
+  disableGliding?: boolean | undefined;
+}
+
+function createBasePBInputModifier(): PBInputModifier {
+  return { mode: undefined };
+}
+
+export namespace PBInputModifier {
+  export function encode(message: PBInputModifier, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.mode?.$case) {
+      case "standard":
+        PBInputModifier_StandardInput.encode(message.mode.standard, writer.uint32(10).fork()).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBInputModifier {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBInputModifier();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.mode = { $case: "standard", standard: PBInputModifier_StandardInput.decode(reader, reader.uint32()) };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBInputModifier {
+    return {
+      mode: isSet(object.standard)
+        ? { $case: "standard", standard: PBInputModifier_StandardInput.fromJSON(object.standard) }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: PBInputModifier): unknown {
+    const obj: any = {};
+    message.mode?.$case === "standard" &&
+      (obj.standard = message.mode?.standard
+        ? PBInputModifier_StandardInput.toJSON(message.mode?.standard)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBInputModifier>, I>>(base?: I): PBInputModifier {
+    return PBInputModifier.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBInputModifier>, I>>(object: I): PBInputModifier {
+    const message = createBasePBInputModifier();
+    if (object.mode?.$case === "standard" && object.mode?.standard !== undefined && object.mode?.standard !== null) {
+      message.mode = { $case: "standard", standard: PBInputModifier_StandardInput.fromPartial(object.mode.standard) };
+    }
+    return message;
+  }
+}
+
+function createBasePBInputModifier_StandardInput(): PBInputModifier_StandardInput {
+  return {
+    disableAll: undefined,
+    disableWalk: undefined,
+    disableJog: undefined,
+    disableRun: undefined,
+    disableJump: undefined,
+    disableEmote: undefined,
+    disableDoubleJump: undefined,
+    disableGliding: undefined,
+  };
+}
+
+export namespace PBInputModifier_StandardInput {
+  export function encode(message: PBInputModifier_StandardInput, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.disableAll !== undefined) {
+      writer.uint32(8).bool(message.disableAll);
+    }
+    if (message.disableWalk !== undefined) {
+      writer.uint32(16).bool(message.disableWalk);
+    }
+    if (message.disableJog !== undefined) {
+      writer.uint32(24).bool(message.disableJog);
+    }
+    if (message.disableRun !== undefined) {
+      writer.uint32(32).bool(message.disableRun);
+    }
+    if (message.disableJump !== undefined) {
+      writer.uint32(40).bool(message.disableJump);
+    }
+    if (message.disableEmote !== undefined) {
+      writer.uint32(48).bool(message.disableEmote);
+    }
+    if (message.disableDoubleJump !== undefined) {
+      writer.uint32(56).bool(message.disableDoubleJump);
+    }
+    if (message.disableGliding !== undefined) {
+      writer.uint32(64).bool(message.disableGliding);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBInputModifier_StandardInput {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBInputModifier_StandardInput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.disableAll = reader.bool();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.disableWalk = reader.bool();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.disableJog = reader.bool();
+          continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+
+          message.disableRun = reader.bool();
+          continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+
+          message.disableJump = reader.bool();
+          continue;
+        case 6:
+          if (tag !== 48) {
+            break;
+          }
+
+          message.disableEmote = reader.bool();
+          continue;
+        case 7:
+          if (tag !== 56) {
+            break;
+          }
+
+          message.disableDoubleJump = reader.bool();
+          continue;
+        case 8:
+          if (tag !== 64) {
+            break;
+          }
+
+          message.disableGliding = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBInputModifier_StandardInput {
+    return {
+      disableAll: isSet(object.disableAll) ? Boolean(object.disableAll) : undefined,
+      disableWalk: isSet(object.disableWalk) ? Boolean(object.disableWalk) : undefined,
+      disableJog: isSet(object.disableJog) ? Boolean(object.disableJog) : undefined,
+      disableRun: isSet(object.disableRun) ? Boolean(object.disableRun) : undefined,
+      disableJump: isSet(object.disableJump) ? Boolean(object.disableJump) : undefined,
+      disableEmote: isSet(object.disableEmote) ? Boolean(object.disableEmote) : undefined,
+      disableDoubleJump: isSet(object.disableDoubleJump) ? Boolean(object.disableDoubleJump) : undefined,
+      disableGliding: isSet(object.disableGliding) ? Boolean(object.disableGliding) : undefined,
+    };
+  }
+
+  export function toJSON(message: PBInputModifier_StandardInput): unknown {
+    const obj: any = {};
+    message.disableAll !== undefined && (obj.disableAll = message.disableAll);
+    message.disableWalk !== undefined && (obj.disableWalk = message.disableWalk);
+    message.disableJog !== undefined && (obj.disableJog = message.disableJog);
+    message.disableRun !== undefined && (obj.disableRun = message.disableRun);
+    message.disableJump !== undefined && (obj.disableJump = message.disableJump);
+    message.disableEmote !== undefined && (obj.disableEmote = message.disableEmote);
+    message.disableDoubleJump !== undefined && (obj.disableDoubleJump = message.disableDoubleJump);
+    message.disableGliding !== undefined && (obj.disableGliding = message.disableGliding);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBInputModifier_StandardInput>, I>>(
+    base?: I,
+  ): PBInputModifier_StandardInput {
+    return PBInputModifier_StandardInput.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBInputModifier_StandardInput>, I>>(
+    object: I,
+  ): PBInputModifier_StandardInput {
+    const message = createBasePBInputModifier_StandardInput();
+    message.disableAll = object.disableAll ?? undefined;
+    message.disableWalk = object.disableWalk ?? undefined;
+    message.disableJog = object.disableJog ?? undefined;
+    message.disableRun = object.disableRun ?? undefined;
+    message.disableJump = object.disableJump ?? undefined;
+    message.disableEmote = object.disableEmote ?? undefined;
+    message.disableDoubleJump = object.disableDoubleJump ?? undefined;
+    message.disableGliding = object.disableGliding ?? undefined;
+    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;
+}

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

@@ -61,6 +61,14 @@ export interface PBMaterial {
     | { $case: "unlit"; unlit: PBMaterial_UnlitMaterial }
     | { $case: "pbr"; pbr: PBMaterial_PbrMaterial }
     | undefined;
+  /**
+   * A gltf material that may provide additional features not supported by the PbMaterial fields.
+   * If both gltf and material fields are provided, the gltf will be used only for extended features not
+   * supported by the PbMaterial.
+   * If this is provided and the `material` field is not provided, the renderer will update the material
+   * field with data that reflects the gltf material once it is loaded.
+   */
+  gltf?: PBMaterial_GltfMaterial | undefined;
 }
 
 export interface PBMaterial_UnlitMaterial {
@@ -145,8 +153,13 @@ export interface PBMaterial_PbrMaterial {
   directIntensity?: number | undefined;
 }
 
+export interface PBMaterial_GltfMaterial {
+  gltfSrc: string;
+  name: string;
+}
+
 function createBasePBMaterial(): PBMaterial {
-  return { material: undefined };
+  return { material: undefined, gltf: undefined };
 }
 
 export namespace PBMaterial {
@@ -159,6 +172,9 @@ export namespace PBMaterial {
         PBMaterial_PbrMaterial.encode(message.material.pbr, writer.uint32(18).fork()).ldelim();
         break;
     }
+    if (message.gltf !== undefined) {
+      PBMaterial_GltfMaterial.encode(message.gltf, writer.uint32(26).fork()).ldelim();
+    }
     return writer;
   }
 
@@ -183,6 +199,13 @@ export namespace PBMaterial {
 
           message.material = { $case: "pbr", pbr: PBMaterial_PbrMaterial.decode(reader, reader.uint32()) };
           continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.gltf = PBMaterial_GltfMaterial.decode(reader, reader.uint32());
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -199,6 +222,7 @@ export namespace PBMaterial {
         : isSet(object.pbr)
         ? { $case: "pbr", pbr: PBMaterial_PbrMaterial.fromJSON(object.pbr) }
         : undefined,
+      gltf: isSet(object.gltf) ? PBMaterial_GltfMaterial.fromJSON(object.gltf) : undefined,
     };
   }
 
@@ -208,6 +232,7 @@ export namespace PBMaterial {
       (obj.unlit = message.material?.unlit ? PBMaterial_UnlitMaterial.toJSON(message.material?.unlit) : undefined);
     message.material?.$case === "pbr" &&
       (obj.pbr = message.material?.pbr ? PBMaterial_PbrMaterial.toJSON(message.material?.pbr) : undefined);
+    message.gltf !== undefined && (obj.gltf = message.gltf ? PBMaterial_GltfMaterial.toJSON(message.gltf) : undefined);
     return obj;
   }
 
@@ -223,6 +248,9 @@ export namespace PBMaterial {
     if (object.material?.$case === "pbr" && object.material?.pbr !== undefined && object.material?.pbr !== null) {
       message.material = { $case: "pbr", pbr: PBMaterial_PbrMaterial.fromPartial(object.material.pbr) };
     }
+    message.gltf = (object.gltf !== undefined && object.gltf !== null)
+      ? PBMaterial_GltfMaterial.fromPartial(object.gltf)
+      : undefined;
     return message;
   }
 }
@@ -638,6 +666,79 @@ export namespace PBMaterial_PbrMaterial {
   }
 }
 
+function createBasePBMaterial_GltfMaterial(): PBMaterial_GltfMaterial {
+  return { gltfSrc: "", name: "" };
+}
+
+export namespace PBMaterial_GltfMaterial {
+  export function encode(message: PBMaterial_GltfMaterial, 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): PBMaterial_GltfMaterial {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBMaterial_GltfMaterial();
+    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): PBMaterial_GltfMaterial {
+    return {
+      gltfSrc: isSet(object.gltfSrc) ? String(object.gltfSrc) : "",
+      name: isSet(object.name) ? String(object.name) : "",
+    };
+  }
+
+  export function toJSON(message: PBMaterial_GltfMaterial): 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<PBMaterial_GltfMaterial>, I>>(base?: I): PBMaterial_GltfMaterial {
+    return PBMaterial_GltfMaterial.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBMaterial_GltfMaterial>, I>>(
+    object: I,
+  ): PBMaterial_GltfMaterial {
+    const message = createBasePBMaterial_GltfMaterial();
+    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