@dcl/protocol 1.0.0-10955038136.commit-7fe9554 → 1.0.0-11502421172.commit-b32f4af

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

@@ -7,7 +7,7 @@ export const protobufPackage = "decentraland.sdk.components";
 
 /**
  * The CameraModeArea component can be attached to an Entity to define a region of space where
- * the player's camera mode (1st-person or 3rd-person) is overridden.
+ * the player's camera mode (1st-person, 3rd-person or cinematic) is overridden.
  *
  * The Entity's Transform position determines the center-point of the region, while its size is
  * given as a vector in the `area` property below. The Transform rotation is applied, but the scale
@@ -17,6 +17,8 @@ export const protobufPackage = "decentraland.sdk.components";
  *
  * Note that, while commonly used to delineate a 2D area in a scene (hence the name), the region
  * is actually a 3D volume.
+ *
+ * When mode is set to CtCinematic, the cinematic_settings field must also be provided.
  */
 export interface PBCameraModeArea {
   /** the 3D size of the region */
@@ -25,10 +27,47 @@ export interface PBCameraModeArea {
     | undefined;
   /** the camera mode to enforce */
   mode: CameraType;
+  cinematicSettings?:
+    | CinematicSettings
+    | undefined;
+  /** if true, the player will be considered inside the area when they are within 0.3m of the area. default true */
+  useColliderRange?: boolean | undefined;
+}
+
+export interface CinematicSettings {
+  /** Entity that defines the cinematic camera transform. */
+  cameraEntity: number;
+  /**
+   * Position -> camera's position
+   * Rotation -> camera's direction
+   * scale.z -> zoom level
+   * scale.x and scale.y -> unused
+   */
+  allowManualRotation?:
+    | boolean
+    | undefined;
+  /** how far the camera can rotate around the y-axis / look left/right, in radians. default unrestricted */
+  yawRange?:
+    | number
+    | undefined;
+  /** how far the camera can rotate around the x-axis / look up-down, in radians. default unrestricted */
+  pitchRange?:
+    | number
+    | undefined;
+  /** note: cameras can never look up/down further than Vec3::Y */
+  rollRange?:
+    | number
+    | undefined;
+  /** minimum zoom level. must be greater than 0. defaults to the input zoom level */
+  zoomMin?:
+    | number
+    | undefined;
+  /** maximum zoom level. must be greater than 0. defaults to the input zoom level */
+  zoomMax?: number | undefined;
 }
 
 function createBasePBCameraModeArea(): PBCameraModeArea {
-  return { area: undefined, mode: 0 };
+  return { area: undefined, mode: 0, cinematicSettings: undefined, useColliderRange: undefined };
 }
 
 export namespace PBCameraModeArea {
@@ -39,6 +78,12 @@ export namespace PBCameraModeArea {
     if (message.mode !== 0) {
       writer.uint32(16).int32(message.mode);
     }
+    if (message.cinematicSettings !== undefined) {
+      CinematicSettings.encode(message.cinematicSettings, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.useColliderRange !== undefined) {
+      writer.uint32(32).bool(message.useColliderRange);
+    }
     return writer;
   }
 
@@ -63,6 +108,20 @@ export namespace PBCameraModeArea {
 
           message.mode = reader.int32() as any;
           continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.cinematicSettings = CinematicSettings.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+
+          message.useColliderRange = reader.bool();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -76,6 +135,10 @@ export namespace PBCameraModeArea {
     return {
       area: isSet(object.area) ? Vector3.fromJSON(object.area) : undefined,
       mode: isSet(object.mode) ? cameraTypeFromJSON(object.mode) : 0,
+      cinematicSettings: isSet(object.cinematicSettings)
+        ? CinematicSettings.fromJSON(object.cinematicSettings)
+        : undefined,
+      useColliderRange: isSet(object.useColliderRange) ? Boolean(object.useColliderRange) : undefined,
     };
   }
 
@@ -83,6 +146,11 @@ export namespace PBCameraModeArea {
     const obj: any = {};
     message.area !== undefined && (obj.area = message.area ? Vector3.toJSON(message.area) : undefined);
     message.mode !== undefined && (obj.mode = cameraTypeToJSON(message.mode));
+    message.cinematicSettings !== undefined &&
+      (obj.cinematicSettings = message.cinematicSettings
+        ? CinematicSettings.toJSON(message.cinematicSettings)
+        : undefined);
+    message.useColliderRange !== undefined && (obj.useColliderRange = message.useColliderRange);
     return obj;
   }
 
@@ -94,6 +162,154 @@ export namespace PBCameraModeArea {
     const message = createBasePBCameraModeArea();
     message.area = (object.area !== undefined && object.area !== null) ? Vector3.fromPartial(object.area) : undefined;
     message.mode = object.mode ?? 0;
+    message.cinematicSettings = (object.cinematicSettings !== undefined && object.cinematicSettings !== null)
+      ? CinematicSettings.fromPartial(object.cinematicSettings)
+      : undefined;
+    message.useColliderRange = object.useColliderRange ?? undefined;
+    return message;
+  }
+}
+
+function createBaseCinematicSettings(): CinematicSettings {
+  return {
+    cameraEntity: 0,
+    allowManualRotation: undefined,
+    yawRange: undefined,
+    pitchRange: undefined,
+    rollRange: undefined,
+    zoomMin: undefined,
+    zoomMax: undefined,
+  };
+}
+
+export namespace CinematicSettings {
+  export function encode(message: CinematicSettings, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.cameraEntity !== 0) {
+      writer.uint32(8).uint32(message.cameraEntity);
+    }
+    if (message.allowManualRotation !== undefined) {
+      writer.uint32(16).bool(message.allowManualRotation);
+    }
+    if (message.yawRange !== undefined) {
+      writer.uint32(29).float(message.yawRange);
+    }
+    if (message.pitchRange !== undefined) {
+      writer.uint32(37).float(message.pitchRange);
+    }
+    if (message.rollRange !== undefined) {
+      writer.uint32(45).float(message.rollRange);
+    }
+    if (message.zoomMin !== undefined) {
+      writer.uint32(53).float(message.zoomMin);
+    }
+    if (message.zoomMax !== undefined) {
+      writer.uint32(61).float(message.zoomMax);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CinematicSettings {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCinematicSettings();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.cameraEntity = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.allowManualRotation = reader.bool();
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
+
+          message.yawRange = reader.float();
+          continue;
+        case 4:
+          if (tag !== 37) {
+            break;
+          }
+
+          message.pitchRange = reader.float();
+          continue;
+        case 5:
+          if (tag !== 45) {
+            break;
+          }
+
+          message.rollRange = reader.float();
+          continue;
+        case 6:
+          if (tag !== 53) {
+            break;
+          }
+
+          message.zoomMin = reader.float();
+          continue;
+        case 7:
+          if (tag !== 61) {
+            break;
+          }
+
+          message.zoomMax = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): CinematicSettings {
+    return {
+      cameraEntity: isSet(object.cameraEntity) ? Number(object.cameraEntity) : 0,
+      allowManualRotation: isSet(object.allowManualRotation) ? Boolean(object.allowManualRotation) : undefined,
+      yawRange: isSet(object.yawRange) ? Number(object.yawRange) : undefined,
+      pitchRange: isSet(object.pitchRange) ? Number(object.pitchRange) : undefined,
+      rollRange: isSet(object.rollRange) ? Number(object.rollRange) : undefined,
+      zoomMin: isSet(object.zoomMin) ? Number(object.zoomMin) : undefined,
+      zoomMax: isSet(object.zoomMax) ? Number(object.zoomMax) : undefined,
+    };
+  }
+
+  export function toJSON(message: CinematicSettings): unknown {
+    const obj: any = {};
+    message.cameraEntity !== undefined && (obj.cameraEntity = Math.round(message.cameraEntity));
+    message.allowManualRotation !== undefined && (obj.allowManualRotation = message.allowManualRotation);
+    message.yawRange !== undefined && (obj.yawRange = message.yawRange);
+    message.pitchRange !== undefined && (obj.pitchRange = message.pitchRange);
+    message.rollRange !== undefined && (obj.rollRange = message.rollRange);
+    message.zoomMin !== undefined && (obj.zoomMin = message.zoomMin);
+    message.zoomMax !== undefined && (obj.zoomMax = message.zoomMax);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CinematicSettings>, I>>(base?: I): CinematicSettings {
+    return CinematicSettings.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CinematicSettings>, I>>(object: I): CinematicSettings {
+    const message = createBaseCinematicSettings();
+    message.cameraEntity = object.cameraEntity ?? 0;
+    message.allowManualRotation = object.allowManualRotation ?? undefined;
+    message.yawRange = object.yawRange ?? undefined;
+    message.pitchRange = object.pitchRange ?? undefined;
+    message.rollRange = object.rollRange ?? undefined;
+    message.zoomMin = object.zoomMin ?? undefined;
+    message.zoomMax = object.zoomMax ?? undefined;
     return message;
   }
 }

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

@@ -10,10 +10,29 @@ export const protobufPackage = "decentraland.sdk.components";
  */
 export interface PBGltfContainerLoadingState {
   currentState: LoadingState;
+  /** all node paths in the gltf, which can be used with a GltfNode to inspect and modify the gltf contents */
+  nodePaths: string[];
+  /** all meshes in the gltf. unnamed meshes will be auto-assigned a name of the form `MeshX` or `MeshX/PrimitiveY` */
+  meshNames: string[];
+  /**
+   * where X is the mesh index and Y is the primitive index (and there is more than 1 primitive). note this may
+   * conflict with manually named meshes - to avoid any issues make sure all your meshes are explicitly named.
+   */
+  materialNames: string[];
+  /**
+   * X is the material index. note this may conflict with manually named materials - to avoid any issues make
+   * sure all your materials are explicitly named.
+   */
+  skinNames: string[];
+  /**
+   * X is the skin index. note this may conflict with manually named skins - to avoid any issues make sure all
+   * your skins are explicitly named.
+   */
+  animationNames: string[];
 }
 
 function createBasePBGltfContainerLoadingState(): PBGltfContainerLoadingState {
-  return { currentState: 0 };
+  return { currentState: 0, nodePaths: [], meshNames: [], materialNames: [], skinNames: [], animationNames: [] };
 }
 
 export namespace PBGltfContainerLoadingState {
@@ -21,6 +40,21 @@ export namespace PBGltfContainerLoadingState {
     if (message.currentState !== 0) {
       writer.uint32(8).int32(message.currentState);
     }
+    for (const v of message.nodePaths) {
+      writer.uint32(18).string(v!);
+    }
+    for (const v of message.meshNames) {
+      writer.uint32(26).string(v!);
+    }
+    for (const v of message.materialNames) {
+      writer.uint32(34).string(v!);
+    }
+    for (const v of message.skinNames) {
+      writer.uint32(42).string(v!);
+    }
+    for (const v of message.animationNames) {
+      writer.uint32(50).string(v!);
+    }
     return writer;
   }
 
@@ -38,6 +72,41 @@ export namespace PBGltfContainerLoadingState {
 
           message.currentState = reader.int32() as any;
           continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.nodePaths.push(reader.string());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.meshNames.push(reader.string());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.materialNames.push(reader.string());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.skinNames.push(reader.string());
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.animationNames.push(reader.string());
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -48,12 +117,44 @@ export namespace PBGltfContainerLoadingState {
   }
 
   export function fromJSON(object: any): PBGltfContainerLoadingState {
-    return { currentState: isSet(object.currentState) ? loadingStateFromJSON(object.currentState) : 0 };
+    return {
+      currentState: isSet(object.currentState) ? loadingStateFromJSON(object.currentState) : 0,
+      nodePaths: Array.isArray(object?.nodePaths) ? object.nodePaths.map((e: any) => String(e)) : [],
+      meshNames: Array.isArray(object?.meshNames) ? object.meshNames.map((e: any) => String(e)) : [],
+      materialNames: Array.isArray(object?.materialNames) ? object.materialNames.map((e: any) => String(e)) : [],
+      skinNames: Array.isArray(object?.skinNames) ? object.skinNames.map((e: any) => String(e)) : [],
+      animationNames: Array.isArray(object?.animationNames) ? object.animationNames.map((e: any) => String(e)) : [],
+    };
   }
 
   export function toJSON(message: PBGltfContainerLoadingState): unknown {
     const obj: any = {};
     message.currentState !== undefined && (obj.currentState = loadingStateToJSON(message.currentState));
+    if (message.nodePaths) {
+      obj.nodePaths = message.nodePaths.map((e) => e);
+    } else {
+      obj.nodePaths = [];
+    }
+    if (message.meshNames) {
+      obj.meshNames = message.meshNames.map((e) => e);
+    } else {
+      obj.meshNames = [];
+    }
+    if (message.materialNames) {
+      obj.materialNames = message.materialNames.map((e) => e);
+    } else {
+      obj.materialNames = [];
+    }
+    if (message.skinNames) {
+      obj.skinNames = message.skinNames.map((e) => e);
+    } else {
+      obj.skinNames = [];
+    }
+    if (message.animationNames) {
+      obj.animationNames = message.animationNames.map((e) => e);
+    } else {
+      obj.animationNames = [];
+    }
     return obj;
   }
 
@@ -68,6 +169,11 @@ export namespace PBGltfContainerLoadingState {
   ): PBGltfContainerLoadingState {
     const message = createBasePBGltfContainerLoadingState();
     message.currentState = object.currentState ?? 0;
+    message.nodePaths = object.nodePaths?.map((e) => e) || [];
+    message.meshNames = object.meshNames?.map((e) => e) || [];
+    message.materialNames = object.materialNames?.map((e) => e) || [];
+    message.skinNames = object.skinNames?.map((e) => e) || [];
+    message.animationNames = object.animationNames?.map((e) => e) || [];
     return message;
   }
 }

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

@@ -0,0 +1,116 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/**
+ * a GltfNode links a scene entity with a node from within a gltf, allowing the scene to inspect it or modify it.
+ * This component must be added to a direct child of an entity with a PBGltfContainer component, or
+ * to a direct child of another entity with a GltfNode component, and the referenced gltf node must be a descendent of the gltf node
+ * in the parent.
+ * The name must match the path of one of the nodes within the Gltf. These are available on the GltfContainerLoadingState component.
+ *
+ * The renderer will attach a PBGltfNodeState to the entity describing the state. Once the state is `GNS_READY`,
+ * - the `Transform` will be updated to match the position of the node within the gltf (relative to the gltf root, or the parent node),
+ * - a `MeshRenderer` with a GltfMesh mesh type will be added (if the gltf node has a mesh).
+ * - a `MeshCollider` with a GltfMesh mesh type will be added (if the gltf node has a collider).
+ * - a `Material` component including a GltfMaterial reference will be added (if the gltf node has a material).
+ *
+ * After creation, if an animation moves the node, the `Transform` will be updated.
+ *
+ * From the scene, you can modify various components to alter the gltf node:
+ * - modifying the `Transform` position/rotation/scale will move the node. The position is interpreted relative to the gltf root (or parent node),
+ *   regardless of any intermediate gltf node hierarchy.
+ *   If an animation is playing, the animation takes priority and the scene entity's position will be updated to match the animation.
+ * - `Visibility` can be added to hide or show the node and it's children in the gltf hierarchy.
+ * - `MeshRenderer` can be added/modified/removed to create/modify/remove a mesh on the node.
+ * - `MeshCollider` can be added/modified/removed to create/modify/remove a collider on the node.
+ * - `Material` can be added or modified to change the material properties. If the gltf node has a material, the original material will be
+ *   used as a base, and any gltf features (e.g. occlusion maps) from the gtlf spec that the renderer supports but that are not exposed in the
+ *   PBMaterial will be maintained.
+ *
+ * The scene can add additional entities as children to the gltf node, but structural modifications of the gltf are not possible:
+ * - changing the scene hierarchy will not change the gltf node hierarchy. Moving the entity out of the gltf will sever the link and
+ *   change the state to `GNS_FAILED`.
+ * - deleting the scene entity will not delete the gltf node.
+ *
+ * Removing the GltfNode will revert any changes to the original gltf. If the GltfNode component is removed and the mesh/collider/material
+ * are not removed, this will result in a duplication of these components as the previously-linked entity will retain it's components and
+ * the gltf node will also be displayed.
+ */
+export interface PBGltfNode {
+  /** the path of the target node in the Gltf. */
+  path: string;
+}
+
+function createBasePBGltfNode(): PBGltfNode {
+  return { path: "" };
+}
+
+export namespace PBGltfNode {
+  export function encode(message: PBGltfNode, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.path !== "") {
+      writer.uint32(10).string(message.path);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfNode {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBGltfNode();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.path = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBGltfNode {
+    return { path: isSet(object.path) ? String(object.path) : "" };
+  }
+
+  export function toJSON(message: PBGltfNode): unknown {
+    const obj: any = {};
+    message.path !== undefined && (obj.path = message.path);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBGltfNode>, I>>(base?: I): PBGltfNode {
+    return PBGltfNode.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBGltfNode>, I>>(object: I): PBGltfNode {
+    const message = createBasePBGltfNode();
+    message.path = object.path ?? "";
+    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/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;
+}