@dcl/protocol 1.0.0-22583117520.commit-28394c4 → 1.0.0-22584214067.commit-276e5b7

package/out-ts/decentraland/sdk/components/common/input_action.gen.ts

@@ -17,6 +17,7 @@ export enum InputAction {
   IA_ACTION_4 = 11,
   IA_ACTION_5 = 12,
   IA_ACTION_6 = 13,
+  IA_MODIFIER = 14,
   UNRECOGNIZED = -1,
 }
 
@@ -64,6 +65,9 @@ export function inputActionFromJSON(object: any): InputAction {
     case 13:
     case "IA_ACTION_6":
       return InputAction.IA_ACTION_6;
+    case 14:
+    case "IA_MODIFIER":
+      return InputAction.IA_MODIFIER;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -101,6 +105,8 @@ export function inputActionToJSON(object: InputAction): string {
       return "IA_ACTION_5";
     case InputAction.IA_ACTION_6:
       return "IA_ACTION_6";
+    case InputAction.IA_MODIFIER:
+      return "IA_MODIFIER";
     case InputAction.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
@@ -113,6 +119,8 @@ export enum PointerEventType {
   PET_DOWN = 1,
   PET_HOVER_ENTER = 2,
   PET_HOVER_LEAVE = 3,
+  PET_PROXIMITY_ENTER = 4,
+  PET_PROXIMITY_LEAVE = 5,
   UNRECOGNIZED = -1,
 }
 
@@ -130,6 +138,12 @@ export function pointerEventTypeFromJSON(object: any): PointerEventType {
     case 3:
     case "PET_HOVER_LEAVE":
       return PointerEventType.PET_HOVER_LEAVE;
+    case 4:
+    case "PET_PROXIMITY_ENTER":
+      return PointerEventType.PET_PROXIMITY_ENTER;
+    case 5:
+    case "PET_PROXIMITY_LEAVE":
+      return PointerEventType.PET_PROXIMITY_LEAVE;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -147,8 +161,45 @@ export function pointerEventTypeToJSON(object: PointerEventType): string {
       return "PET_HOVER_ENTER";
     case PointerEventType.PET_HOVER_LEAVE:
       return "PET_HOVER_LEAVE";
+    case PointerEventType.PET_PROXIMITY_ENTER:
+      return "PET_PROXIMITY_ENTER";
+    case PointerEventType.PET_PROXIMITY_LEAVE:
+      return "PET_PROXIMITY_LEAVE";
     case PointerEventType.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
   }
 }
+
+export enum InteractionType {
+  CURSOR = 0,
+  PROXIMITY = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function interactionTypeFromJSON(object: any): InteractionType {
+  switch (object) {
+    case 0:
+    case "CURSOR":
+      return InteractionType.CURSOR;
+    case 1:
+    case "PROXIMITY":
+      return InteractionType.PROXIMITY;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return InteractionType.UNRECOGNIZED;
+  }
+}
+
+export function interactionTypeToJSON(object: InteractionType): string {
+  switch (object) {
+    case InteractionType.CURSOR:
+      return "CURSOR";
+    case InteractionType.PROXIMITY:
+      return "PROXIMITY";
+    case InteractionType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}

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

@@ -4,6 +4,9 @@ import {
   InputAction,
   inputActionFromJSON,
   inputActionToJSON,
+  InteractionType,
+  interactionTypeFromJSON,
+  interactionTypeToJSON,
   PointerEventType,
   pointerEventTypeFromJSON,
   pointerEventTypeToJSON,
@@ -76,14 +79,22 @@ export interface PBPointerEvents_Info {
     | boolean
     | undefined;
   /** range of interaction from the avatar's position (default 0) */
-  maxPlayerDistance?: number | undefined;
+  maxPlayerDistance?:
+    | number
+    | undefined;
+  /** resolution order when multiple events overlap, higher wins (default 0) */
+  priority?: number | undefined;
 }
 
 export interface PBPointerEvents_Entry {
   /** the kind of interaction to detect */
   eventType: PointerEventType;
   /** additional configuration for this detection */
-  eventInfo: PBPointerEvents_Info | undefined;
+  eventInfo:
+    | PBPointerEvents_Info
+    | undefined;
+  /** the type of interaction source (default 0 == CURSOR) */
+  interactionType?: InteractionType | undefined;
 }
 
 function createBasePBPointerEvents(): PBPointerEvents {
@@ -158,6 +169,7 @@ function createBasePBPointerEvents_Info(): PBPointerEvents_Info {
     showFeedback: undefined,
     showHighlight: undefined,
     maxPlayerDistance: undefined,
+    priority: undefined,
   };
 }
 
@@ -181,6 +193,9 @@ export namespace PBPointerEvents_Info {
     if (message.maxPlayerDistance !== undefined) {
       writer.uint32(53).float(message.maxPlayerDistance);
     }
+    if (message.priority !== undefined) {
+      writer.uint32(56).uint32(message.priority);
+    }
     return writer;
   }
 
@@ -233,6 +248,13 @@ export namespace PBPointerEvents_Info {
 
           message.maxPlayerDistance = reader.float();
           continue;
+        case 7:
+          if (tag !== 56) {
+            break;
+          }
+
+          message.priority = reader.uint32();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -250,6 +272,7 @@ export namespace PBPointerEvents_Info {
       showFeedback: isSet(object.showFeedback) ? Boolean(object.showFeedback) : undefined,
       showHighlight: isSet(object.showHighlight) ? Boolean(object.showHighlight) : undefined,
       maxPlayerDistance: isSet(object.maxPlayerDistance) ? Number(object.maxPlayerDistance) : undefined,
+      priority: isSet(object.priority) ? Number(object.priority) : undefined,
     };
   }
 
@@ -262,6 +285,7 @@ export namespace PBPointerEvents_Info {
     message.showFeedback !== undefined && (obj.showFeedback = message.showFeedback);
     message.showHighlight !== undefined && (obj.showHighlight = message.showHighlight);
     message.maxPlayerDistance !== undefined && (obj.maxPlayerDistance = message.maxPlayerDistance);
+    message.priority !== undefined && (obj.priority = Math.round(message.priority));
     return obj;
   }
 
@@ -277,12 +301,13 @@ export namespace PBPointerEvents_Info {
     message.showFeedback = object.showFeedback ?? undefined;
     message.showHighlight = object.showHighlight ?? undefined;
     message.maxPlayerDistance = object.maxPlayerDistance ?? undefined;
+    message.priority = object.priority ?? undefined;
     return message;
   }
 }
 
 function createBasePBPointerEvents_Entry(): PBPointerEvents_Entry {
-  return { eventType: 0, eventInfo: undefined };
+  return { eventType: 0, eventInfo: undefined, interactionType: undefined };
 }
 
 export namespace PBPointerEvents_Entry {
@@ -293,6 +318,9 @@ export namespace PBPointerEvents_Entry {
     if (message.eventInfo !== undefined) {
       PBPointerEvents_Info.encode(message.eventInfo, writer.uint32(18).fork()).ldelim();
     }
+    if (message.interactionType !== undefined) {
+      writer.uint32(24).int32(message.interactionType);
+    }
     return writer;
   }
 
@@ -317,6 +345,13 @@ export namespace PBPointerEvents_Entry {
 
           message.eventInfo = PBPointerEvents_Info.decode(reader, reader.uint32());
           continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.interactionType = reader.int32() as any;
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -330,6 +365,7 @@ export namespace PBPointerEvents_Entry {
     return {
       eventType: isSet(object.eventType) ? pointerEventTypeFromJSON(object.eventType) : 0,
       eventInfo: isSet(object.eventInfo) ? PBPointerEvents_Info.fromJSON(object.eventInfo) : undefined,
+      interactionType: isSet(object.interactionType) ? interactionTypeFromJSON(object.interactionType) : undefined,
     };
   }
 
@@ -338,6 +374,10 @@ export namespace PBPointerEvents_Entry {
     message.eventType !== undefined && (obj.eventType = pointerEventTypeToJSON(message.eventType));
     message.eventInfo !== undefined &&
       (obj.eventInfo = message.eventInfo ? PBPointerEvents_Info.toJSON(message.eventInfo) : undefined);
+    message.interactionType !== undefined &&
+      (obj.interactionType = message.interactionType !== undefined
+        ? interactionTypeToJSON(message.interactionType)
+        : undefined);
     return obj;
   }
 
@@ -353,6 +393,7 @@ export namespace PBPointerEvents_Entry {
     message.eventInfo = (object.eventInfo !== undefined && object.eventInfo !== null)
       ? PBPointerEvents_Info.fromPartial(object.eventInfo)
       : undefined;
+    message.interactionType = object.interactionType ?? undefined;
     return message;
   }
 }

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

@@ -262,6 +262,8 @@ export interface PBTween {
     | { $case: "rotateContinuous"; rotateContinuous: RotateContinuous }
     | { $case: "moveContinuous"; moveContinuous: MoveContinuous }
     | { $case: "textureMoveContinuous"; textureMoveContinuous: TextureMoveContinuous }
+    | { $case: "moveRotateScale"; moveRotateScale: MoveRotateScale }
+    | { $case: "moveRotateScaleContinuous"; moveRotateScaleContinuous: MoveRotateScaleContinuous }
     | undefined;
   /** default true (pause or running) */
   playing?:
@@ -287,6 +289,15 @@ export interface Scale {
   end: Vector3 | undefined;
 }
 
+export interface MoveRotateScale {
+  positionStart: Vector3 | undefined;
+  positionEnd: Vector3 | undefined;
+  rotationStart: Quaternion | undefined;
+  rotationEnd: Quaternion | undefined;
+  scaleStart: Vector3 | undefined;
+  scaleEnd: Vector3 | undefined;
+}
+
 /**
  * This tween mode allows to move the texture of a PbrMaterial or UnlitMaterial.
  * You can also specify the movement type (offset or tiling)
@@ -310,6 +321,13 @@ export interface MoveContinuous {
   speed: number;
 }
 
+export interface MoveRotateScaleContinuous {
+  positionDirection: Vector3 | undefined;
+  rotationDirection: Quaternion | undefined;
+  scaleDirection: Vector3 | undefined;
+  speed: number;
+}
+
 export interface TextureMoveContinuous {
   direction: Vector2 | undefined;
   speed: number;
@@ -351,6 +369,12 @@ export namespace PBTween {
       case "textureMoveContinuous":
         TextureMoveContinuous.encode(message.mode.textureMoveContinuous, writer.uint32(90).fork()).ldelim();
         break;
+      case "moveRotateScale":
+        MoveRotateScale.encode(message.mode.moveRotateScale, writer.uint32(98).fork()).ldelim();
+        break;
+      case "moveRotateScaleContinuous":
+        MoveRotateScaleContinuous.encode(message.mode.moveRotateScaleContinuous, writer.uint32(106).fork()).ldelim();
+        break;
     }
     if (message.playing !== undefined) {
       writer.uint32(48).bool(message.playing);
@@ -437,6 +461,23 @@ export namespace PBTween {
             textureMoveContinuous: TextureMoveContinuous.decode(reader, reader.uint32()),
           };
           continue;
+        case 12:
+          if (tag !== 98) {
+            break;
+          }
+
+          message.mode = { $case: "moveRotateScale", moveRotateScale: MoveRotateScale.decode(reader, reader.uint32()) };
+          continue;
+        case 13:
+          if (tag !== 106) {
+            break;
+          }
+
+          message.mode = {
+            $case: "moveRotateScaleContinuous",
+            moveRotateScaleContinuous: MoveRotateScaleContinuous.decode(reader, reader.uint32()),
+          };
+          continue;
         case 6:
           if (tag !== 48) {
             break;
@@ -481,6 +522,13 @@ export namespace PBTween {
           $case: "textureMoveContinuous",
           textureMoveContinuous: TextureMoveContinuous.fromJSON(object.textureMoveContinuous),
         }
+        : isSet(object.moveRotateScale)
+        ? { $case: "moveRotateScale", moveRotateScale: MoveRotateScale.fromJSON(object.moveRotateScale) }
+        : isSet(object.moveRotateScaleContinuous)
+        ? {
+          $case: "moveRotateScaleContinuous",
+          moveRotateScaleContinuous: MoveRotateScaleContinuous.fromJSON(object.moveRotateScaleContinuous),
+        }
         : undefined,
       playing: isSet(object.playing) ? Boolean(object.playing) : undefined,
       currentTime: isSet(object.currentTime) ? Number(object.currentTime) : undefined,
@@ -510,6 +558,14 @@ export namespace PBTween {
       (obj.textureMoveContinuous = message.mode?.textureMoveContinuous
         ? TextureMoveContinuous.toJSON(message.mode?.textureMoveContinuous)
         : undefined);
+    message.mode?.$case === "moveRotateScale" &&
+      (obj.moveRotateScale = message.mode?.moveRotateScale
+        ? MoveRotateScale.toJSON(message.mode?.moveRotateScale)
+        : undefined);
+    message.mode?.$case === "moveRotateScaleContinuous" &&
+      (obj.moveRotateScaleContinuous = message.mode?.moveRotateScaleContinuous
+        ? MoveRotateScaleContinuous.toJSON(message.mode?.moveRotateScaleContinuous)
+        : undefined);
     message.playing !== undefined && (obj.playing = message.playing);
     message.currentTime !== undefined && (obj.currentTime = message.currentTime);
     return obj;
@@ -569,6 +625,26 @@ export namespace PBTween {
         textureMoveContinuous: TextureMoveContinuous.fromPartial(object.mode.textureMoveContinuous),
       };
     }
+    if (
+      object.mode?.$case === "moveRotateScale" &&
+      object.mode?.moveRotateScale !== undefined &&
+      object.mode?.moveRotateScale !== null
+    ) {
+      message.mode = {
+        $case: "moveRotateScale",
+        moveRotateScale: MoveRotateScale.fromPartial(object.mode.moveRotateScale),
+      };
+    }
+    if (
+      object.mode?.$case === "moveRotateScaleContinuous" &&
+      object.mode?.moveRotateScaleContinuous !== undefined &&
+      object.mode?.moveRotateScaleContinuous !== null
+    ) {
+      message.mode = {
+        $case: "moveRotateScaleContinuous",
+        moveRotateScaleContinuous: MoveRotateScaleContinuous.fromPartial(object.mode.moveRotateScaleContinuous),
+      };
+    }
     message.playing = object.playing ?? undefined;
     message.currentTime = object.currentTime ?? undefined;
     return message;
@@ -807,6 +883,153 @@ export namespace Scale {
   }
 }
 
+function createBaseMoveRotateScale(): MoveRotateScale {
+  return {
+    positionStart: undefined,
+    positionEnd: undefined,
+    rotationStart: undefined,
+    rotationEnd: undefined,
+    scaleStart: undefined,
+    scaleEnd: undefined,
+  };
+}
+
+export namespace MoveRotateScale {
+  export function encode(message: MoveRotateScale, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.positionStart !== undefined) {
+      Vector3.encode(message.positionStart, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.positionEnd !== undefined) {
+      Vector3.encode(message.positionEnd, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.rotationStart !== undefined) {
+      Quaternion.encode(message.rotationStart, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.rotationEnd !== undefined) {
+      Quaternion.encode(message.rotationEnd, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.scaleStart !== undefined) {
+      Vector3.encode(message.scaleStart, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.scaleEnd !== undefined) {
+      Vector3.encode(message.scaleEnd, writer.uint32(50).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): MoveRotateScale {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMoveRotateScale();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.positionStart = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.positionEnd = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.rotationStart = Quaternion.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.rotationEnd = Quaternion.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.scaleStart = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.scaleEnd = Vector3.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): MoveRotateScale {
+    return {
+      positionStart: isSet(object.positionStart) ? Vector3.fromJSON(object.positionStart) : undefined,
+      positionEnd: isSet(object.positionEnd) ? Vector3.fromJSON(object.positionEnd) : undefined,
+      rotationStart: isSet(object.rotationStart) ? Quaternion.fromJSON(object.rotationStart) : undefined,
+      rotationEnd: isSet(object.rotationEnd) ? Quaternion.fromJSON(object.rotationEnd) : undefined,
+      scaleStart: isSet(object.scaleStart) ? Vector3.fromJSON(object.scaleStart) : undefined,
+      scaleEnd: isSet(object.scaleEnd) ? Vector3.fromJSON(object.scaleEnd) : undefined,
+    };
+  }
+
+  export function toJSON(message: MoveRotateScale): unknown {
+    const obj: any = {};
+    message.positionStart !== undefined &&
+      (obj.positionStart = message.positionStart ? Vector3.toJSON(message.positionStart) : undefined);
+    message.positionEnd !== undefined &&
+      (obj.positionEnd = message.positionEnd ? Vector3.toJSON(message.positionEnd) : undefined);
+    message.rotationStart !== undefined &&
+      (obj.rotationStart = message.rotationStart ? Quaternion.toJSON(message.rotationStart) : undefined);
+    message.rotationEnd !== undefined &&
+      (obj.rotationEnd = message.rotationEnd ? Quaternion.toJSON(message.rotationEnd) : undefined);
+    message.scaleStart !== undefined &&
+      (obj.scaleStart = message.scaleStart ? Vector3.toJSON(message.scaleStart) : undefined);
+    message.scaleEnd !== undefined && (obj.scaleEnd = message.scaleEnd ? Vector3.toJSON(message.scaleEnd) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<MoveRotateScale>, I>>(base?: I): MoveRotateScale {
+    return MoveRotateScale.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<MoveRotateScale>, I>>(object: I): MoveRotateScale {
+    const message = createBaseMoveRotateScale();
+    message.positionStart = (object.positionStart !== undefined && object.positionStart !== null)
+      ? Vector3.fromPartial(object.positionStart)
+      : undefined;
+    message.positionEnd = (object.positionEnd !== undefined && object.positionEnd !== null)
+      ? Vector3.fromPartial(object.positionEnd)
+      : undefined;
+    message.rotationStart = (object.rotationStart !== undefined && object.rotationStart !== null)
+      ? Quaternion.fromPartial(object.rotationStart)
+      : undefined;
+    message.rotationEnd = (object.rotationEnd !== undefined && object.rotationEnd !== null)
+      ? Quaternion.fromPartial(object.rotationEnd)
+      : undefined;
+    message.scaleStart = (object.scaleStart !== undefined && object.scaleStart !== null)
+      ? Vector3.fromPartial(object.scaleStart)
+      : undefined;
+    message.scaleEnd = (object.scaleEnd !== undefined && object.scaleEnd !== null)
+      ? Vector3.fromPartial(object.scaleEnd)
+      : undefined;
+    return message;
+  }
+}
+
 function createBaseTextureMove(): TextureMove {
   return { start: undefined, end: undefined, movementType: undefined };
 }
@@ -1044,6 +1267,116 @@ export namespace MoveContinuous {
   }
 }
 
+function createBaseMoveRotateScaleContinuous(): MoveRotateScaleContinuous {
+  return { positionDirection: undefined, rotationDirection: undefined, scaleDirection: undefined, speed: 0 };
+}
+
+export namespace MoveRotateScaleContinuous {
+  export function encode(message: MoveRotateScaleContinuous, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.positionDirection !== undefined) {
+      Vector3.encode(message.positionDirection, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.rotationDirection !== undefined) {
+      Quaternion.encode(message.rotationDirection, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.scaleDirection !== undefined) {
+      Vector3.encode(message.scaleDirection, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.speed !== 0) {
+      writer.uint32(37).float(message.speed);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): MoveRotateScaleContinuous {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMoveRotateScaleContinuous();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.positionDirection = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.rotationDirection = Quaternion.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.scaleDirection = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 37) {
+            break;
+          }
+
+          message.speed = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): MoveRotateScaleContinuous {
+    return {
+      positionDirection: isSet(object.positionDirection) ? Vector3.fromJSON(object.positionDirection) : undefined,
+      rotationDirection: isSet(object.rotationDirection) ? Quaternion.fromJSON(object.rotationDirection) : undefined,
+      scaleDirection: isSet(object.scaleDirection) ? Vector3.fromJSON(object.scaleDirection) : undefined,
+      speed: isSet(object.speed) ? Number(object.speed) : 0,
+    };
+  }
+
+  export function toJSON(message: MoveRotateScaleContinuous): unknown {
+    const obj: any = {};
+    message.positionDirection !== undefined &&
+      (obj.positionDirection = message.positionDirection ? Vector3.toJSON(message.positionDirection) : undefined);
+    message.rotationDirection !== undefined &&
+      (obj.rotationDirection = message.rotationDirection ? Quaternion.toJSON(message.rotationDirection) : undefined);
+    message.scaleDirection !== undefined &&
+      (obj.scaleDirection = message.scaleDirection ? Vector3.toJSON(message.scaleDirection) : undefined);
+    message.speed !== undefined && (obj.speed = message.speed);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<MoveRotateScaleContinuous>, I>>(
+    base?: I,
+  ): MoveRotateScaleContinuous {
+    return MoveRotateScaleContinuous.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<MoveRotateScaleContinuous>, I>>(
+    object: I,
+  ): MoveRotateScaleContinuous {
+    const message = createBaseMoveRotateScaleContinuous();
+    message.positionDirection = (object.positionDirection !== undefined && object.positionDirection !== null)
+      ? Vector3.fromPartial(object.positionDirection)
+      : undefined;
+    message.rotationDirection = (object.rotationDirection !== undefined && object.rotationDirection !== null)
+      ? Quaternion.fromPartial(object.rotationDirection)
+      : undefined;
+    message.scaleDirection = (object.scaleDirection !== undefined && object.scaleDirection !== null)
+      ? Vector3.fromPartial(object.scaleDirection)
+      : undefined;
+    message.speed = object.speed ?? 0;
+    return message;
+  }
+}
+
 function createBaseTextureMoveContinuous(): TextureMoveContinuous {
   return { direction: undefined, speed: 0, movementType: undefined };
 }