@dcl/protocol 1.0.0-9115457439.commit-926ebd1 → 1.0.0-9127033568.commit-26c5ae7

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/ui_text.gen.ts

@@ -28,11 +28,27 @@ export interface PBUiText {
     | Font
     | undefined;
   /** size of the text (default: 10) */
-  fontSize?: number | undefined;
+  fontSize?:
+    | number
+    | undefined;
+  /** width of the outline (default: 0) */
+  outlineWidth?:
+    | number
+    | undefined;
+  /** RGBA color of the outline (default: opaque black) */
+  outlineColor?: Color4 | undefined;
 }
 
 function createBasePBUiText(): PBUiText {
-  return { value: "", color: undefined, textAlign: undefined, font: undefined, fontSize: undefined };
+  return {
+    value: "",
+    color: undefined,
+    textAlign: undefined,
+    font: undefined,
+    fontSize: undefined,
+    outlineWidth: undefined,
+    outlineColor: undefined,
+  };
 }
 
 export namespace PBUiText {
@@ -52,6 +68,12 @@ export namespace PBUiText {
     if (message.fontSize !== undefined) {
       writer.uint32(40).int32(message.fontSize);
     }
+    if (message.outlineWidth !== undefined) {
+      writer.uint32(53).float(message.outlineWidth);
+    }
+    if (message.outlineColor !== undefined) {
+      Color4.encode(message.outlineColor, writer.uint32(58).fork()).ldelim();
+    }
     return writer;
   }
 
@@ -97,6 +119,20 @@ export namespace PBUiText {
 
           message.fontSize = reader.int32();
           continue;
+        case 6:
+          if (tag !== 53) {
+            break;
+          }
+
+          message.outlineWidth = reader.float();
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+
+          message.outlineColor = Color4.decode(reader, reader.uint32());
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -113,6 +149,8 @@ export namespace PBUiText {
       textAlign: isSet(object.textAlign) ? textAlignModeFromJSON(object.textAlign) : undefined,
       font: isSet(object.font) ? fontFromJSON(object.font) : undefined,
       fontSize: isSet(object.fontSize) ? Number(object.fontSize) : undefined,
+      outlineWidth: isSet(object.outlineWidth) ? Number(object.outlineWidth) : undefined,
+      outlineColor: isSet(object.outlineColor) ? Color4.fromJSON(object.outlineColor) : undefined,
     };
   }
 
@@ -124,6 +162,9 @@ export namespace PBUiText {
       (obj.textAlign = message.textAlign !== undefined ? textAlignModeToJSON(message.textAlign) : undefined);
     message.font !== undefined && (obj.font = message.font !== undefined ? fontToJSON(message.font) : undefined);
     message.fontSize !== undefined && (obj.fontSize = Math.round(message.fontSize));
+    message.outlineWidth !== undefined && (obj.outlineWidth = message.outlineWidth);
+    message.outlineColor !== undefined &&
+      (obj.outlineColor = message.outlineColor ? Color4.toJSON(message.outlineColor) : undefined);
     return obj;
   }
 
@@ -140,6 +181,10 @@ export namespace PBUiText {
     message.textAlign = object.textAlign ?? undefined;
     message.font = object.font ?? undefined;
     message.fontSize = object.fontSize ?? undefined;
+    message.outlineWidth = object.outlineWidth ?? undefined;
+    message.outlineColor = (object.outlineColor !== undefined && object.outlineColor !== null)
+      ? Color4.fromPartial(object.outlineColor)
+      : undefined;
     return message;
   }
 }

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

@@ -561,7 +561,11 @@ export interface PBUiTransform {
   paddingBottomUnit: YGUnit;
   paddingBottom: number;
   /** default: PointerFilterMode.PFM_NONE */
-  pointerFilter?: PointerFilterMode | undefined;
+  pointerFilter?:
+    | PointerFilterMode
+    | undefined;
+  /** default: 1 */
+  opacity?: number | undefined;
 }
 
 function createBasePBUiTransform(): PBUiTransform {
@@ -618,6 +622,7 @@ function createBasePBUiTransform(): PBUiTransform {
     paddingBottomUnit: 0,
     paddingBottom: 0,
     pointerFilter: undefined,
+    opacity: undefined,
   };
 }
 
@@ -779,6 +784,9 @@ export namespace PBUiTransform {
     if (message.pointerFilter !== undefined) {
       writer.uint32(416).int32(message.pointerFilter);
     }
+    if (message.opacity !== undefined) {
+      writer.uint32(429).float(message.opacity);
+    }
     return writer;
   }
 
@@ -1153,6 +1161,13 @@ export namespace PBUiTransform {
 
           message.pointerFilter = reader.int32() as any;
           continue;
+        case 53:
+          if (tag !== 429) {
+            break;
+          }
+
+          message.opacity = reader.float();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -1216,6 +1231,7 @@ export namespace PBUiTransform {
       paddingBottomUnit: isSet(object.paddingBottomUnit) ? yGUnitFromJSON(object.paddingBottomUnit) : 0,
       paddingBottom: isSet(object.paddingBottom) ? Number(object.paddingBottom) : 0,
       pointerFilter: isSet(object.pointerFilter) ? pointerFilterModeFromJSON(object.pointerFilter) : undefined,
+      opacity: isSet(object.opacity) ? Number(object.opacity) : undefined,
     };
   }
 
@@ -1279,6 +1295,7 @@ export namespace PBUiTransform {
       (obj.pointerFilter = message.pointerFilter !== undefined
         ? pointerFilterModeToJSON(message.pointerFilter)
         : undefined);
+    message.opacity !== undefined && (obj.opacity = message.opacity);
     return obj;
   }
 
@@ -1340,6 +1357,7 @@ export namespace PBUiTransform {
     message.paddingBottomUnit = object.paddingBottomUnit ?? 0;
     message.paddingBottom = object.paddingBottom ?? 0;
     message.pointerFilter = object.pointerFilter ?? undefined;
+    message.opacity = object.opacity ?? undefined;
     return message;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/protocol",
-  "version": "1.0.0-9115457439.commit-926ebd1",
+  "version": "1.0.0-9127033568.commit-26c5ae7",
   "description": "",
   "repository": "decentraland/protocol.git",
   "homepage": "https://github.com/decentraland/protocol#readme",
@@ -29,5 +29,5 @@
     "out-js",
     "public"
   ],
-  "commit": "926ebd1c80b68bf1e56242f4b76ef86856ea1bd5"
+  "commit": "26c5ae7313298e0623b2474d9625a359493728c1"
 }

package/proto/decentraland/sdk/components/avatar_modifier_area.proto

@@ -23,6 +23,8 @@ message PBAvatarModifierArea {
   decentraland.common.Vector3 area = 1;      // the 3D size of the region
   repeated string exclude_ids = 2;           // user IDs that can enter and remain unaffected
   repeated AvatarModifierType modifiers = 3; // list of modifiers to apply
+  optional AvatarMovementSettings movement_settings = 4;
+  optional bool use_collider_range = 5;      // if true, the player will be considered inside the area when they are within 0.3m of the area. default true
 }
 
 // AvatarModifierType is an effect that should be applied to avatars inside the region.
@@ -30,3 +32,22 @@ enum AvatarModifierType {
   AMT_HIDE_AVATARS = 0;      // avatars are invisible
   AMT_DISABLE_PASSPORTS = 1; // selecting (e.g. clicking) an avatar will not bring up their profile.
 }
+
+message AvatarMovementSettings {
+  optional AvatarControlType control_mode = 1;
+  // if not explicitly set, the following properties default to user's preference settings
+  optional float run_speed = 2;              // speed the player moves at, in m/s
+  optional float friction = 3;               // how fast the player gets up to speed or comes to rest. higher = more responsive
+  optional float gravity = 4;                // how fast the player accelerates vertically when not on a solid surface, in m/s. should normally be negative
+  optional float jump_height = 5;            // how high the player can jump, in meters. should normally be positive. gravity must have the same sign for jumping to be possible
+  optional float max_fall_speed = 6;         // max fall speed in m/s. should normally be negative
+  optional float turn_speed = 7;             // speed the player turns in tank mode, in radians/s
+  optional float walk_speed = 8;             // speed the player walks at, in m/s
+  optional bool allow_weighted_movement = 9; // whether to allow player to move at a slower speed (e.g. with a walk-key or when using a gamepad/joystick). defaults to true  
+}
+
+enum AvatarControlType {
+  CCT_NONE = 0;     // avatar cannot move
+  CCT_RELATIVE = 1; // avatar moves relative to the camera origin
+  CCT_TANK = 2;     // avatar moves like a tank: left/right rotate the player, forward/backward advance/retreat the player
+}

package/proto/decentraland/sdk/components/camera_mode_area.proto

@@ -9,7 +9,7 @@ import "decentraland/sdk/components/common/id.proto";
 option (common.ecs_component_id) = 1071;
 
 // 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 
@@ -19,7 +19,26 @@ option (common.ecs_component_id) = 1071;
 //
 // 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.
 message PBCameraModeArea {
-  decentraland.common.Vector3 area = 1; // the 3D size of the region
-  common.CameraType mode = 2;           // the camera mode to enforce
+  decentraland.common.Vector3 area = 1;                       // the 3D size of the region
+  common.CameraType mode = 2;                                 // the camera mode to enforce
+  optional CinematicSettings cinematic_settings = 3;
+  optional bool use_collider_range = 4;                       // if true, the player will be considered inside the area when they are within 0.3m of the area. default true
+}
+
+message CinematicSettings {
+  uint32 camera_entity = 1;           // Entity that defines the cinematic camera transform.
+                                      // Position -> camera's position
+                                      // Rotation -> camera's direction
+                                      // scale.z -> zoom level
+                                      // scale.x and scale.y -> unused
+  optional bool allow_manual_rotation = 2; // whether the user can move the camera's rotation. default false
+  optional float yaw_range = 3;       // how far the camera can rotate around the y-axis / look left/right, in radians. default unrestricted
+  optional float pitch_range = 4;     // how far the camera can rotate around the x-axis / look up-down, in radians. default unrestricted
+                                      // note: cameras can never look up/down further than Vec3::Y
+  optional float roll_range = 5;      // how far the camera can rotate around the z-axis / tilt, in radians. default unrestricted
+  optional float zoom_min = 6;        // minimum zoom level. must be greater than 0. defaults to the input zoom level
+  optional float zoom_max = 7;        // maximum zoom level. must be greater than 0. defaults to the input zoom level
 }

package/proto/decentraland/sdk/components/ui_text.proto

@@ -17,4 +17,6 @@ message PBUiText {
   optional common.TextAlignMode text_align = 3;  // alignment within the bounds (default: center)
   optional common.Font font = 4;                 // font for the text (default: sans-serif)
   optional int32 font_size = 5;                  // size of the text (default: 10)
+  optional float outline_width = 6;              // width of the outline (default: 0)
+  optional decentraland.common.Color4 outline_color = 7; // RGBA color of the outline (default: opaque black)
 }

package/proto/decentraland/sdk/components/ui_transform.proto

@@ -145,4 +145,5 @@ message PBUiTransform {
   float padding_bottom = 51;
   
   optional PointerFilterMode pointer_filter = 52; // default: PointerFilterMode.PFM_NONE
+  optional float opacity = 53; // default: 1
 }