@dcl/protocol 1.0.0-24197129021.commit-3a0cc03 → 1.0.0-24360053093.commit-d8b1cf7

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

@@ -1,6 +1,7 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
 import { Color4 } from "../../common/colors.gen";
+import { Vector2 } from "../../common/vectors.gen";
 
 export const protobufPackage = "decentraland.sdk.components";
 
@@ -472,6 +473,55 @@ export function pointerFilterModeToJSON(object: PointerFilterMode): string {
   }
 }
 
+export enum ShowScrollBar {
+  SSB_BOTH = 0,
+  SSB_ONLY_VERTICAL = 1,
+  SSB_ONLY_HORIZONTAL = 2,
+  SSB_HIDDEN = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function showScrollBarFromJSON(object: any): ShowScrollBar {
+  switch (object) {
+    case 0:
+    case "SSB_BOTH":
+      return ShowScrollBar.SSB_BOTH;
+    case 1:
+    case "SSB_ONLY_VERTICAL":
+      return ShowScrollBar.SSB_ONLY_VERTICAL;
+    case 2:
+    case "SSB_ONLY_HORIZONTAL":
+      return ShowScrollBar.SSB_ONLY_HORIZONTAL;
+    case 3:
+    case "SSB_HIDDEN":
+      return ShowScrollBar.SSB_HIDDEN;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ShowScrollBar.UNRECOGNIZED;
+  }
+}
+
+export function showScrollBarToJSON(object: ShowScrollBar): string {
+  switch (object) {
+    case ShowScrollBar.SSB_BOTH:
+      return "SSB_BOTH";
+    case ShowScrollBar.SSB_ONLY_VERTICAL:
+      return "SSB_ONLY_VERTICAL";
+    case ShowScrollBar.SSB_ONLY_HORIZONTAL:
+      return "SSB_ONLY_HORIZONTAL";
+    case ShowScrollBar.SSB_HIDDEN:
+      return "SSB_HIDDEN";
+    case ShowScrollBar.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface ScrollPositionValue {
+  value?: { $case: "position"; position: Vector2 } | { $case: "reference"; reference: string } | undefined;
+}
+
 export interface PBUiTransform {
   parent: number;
   rightOf: number;
@@ -616,10 +666,105 @@ export interface PBUiTransform {
   opacity?:
     | number
     | undefined;
+  /** reference for scroll_position. default empty */
+  elementId?:
+    | string
+    | undefined;
+  /** default position=(0,0) */
+  scrollPosition?:
+    | ScrollPositionValue
+    | undefined;
+  /** default ShowScrollBar.SSB_BOTH */
+  scrollVisible?:
+    | ShowScrollBar
+    | undefined;
   /** default: 0 — controls render stacking order. Higher values appear in front of lower values. */
   zIndex?: number | undefined;
 }
 
+function createBaseScrollPositionValue(): ScrollPositionValue {
+  return { value: undefined };
+}
+
+export namespace ScrollPositionValue {
+  export function encode(message: ScrollPositionValue, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.value?.$case) {
+      case "position":
+        Vector2.encode(message.value.position, writer.uint32(10).fork()).ldelim();
+        break;
+      case "reference":
+        writer.uint32(18).string(message.value.reference);
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ScrollPositionValue {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseScrollPositionValue();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.value = { $case: "position", position: Vector2.decode(reader, reader.uint32()) };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = { $case: "reference", reference: reader.string() };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ScrollPositionValue {
+    return {
+      value: isSet(object.position)
+        ? { $case: "position", position: Vector2.fromJSON(object.position) }
+        : isSet(object.reference)
+        ? { $case: "reference", reference: String(object.reference) }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: ScrollPositionValue): unknown {
+    const obj: any = {};
+    message.value?.$case === "position" &&
+      (obj.position = message.value?.position ? Vector2.toJSON(message.value?.position) : undefined);
+    message.value?.$case === "reference" && (obj.reference = message.value?.reference);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ScrollPositionValue>, I>>(base?: I): ScrollPositionValue {
+    return ScrollPositionValue.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ScrollPositionValue>, I>>(object: I): ScrollPositionValue {
+    const message = createBaseScrollPositionValue();
+    if (object.value?.$case === "position" && object.value?.position !== undefined && object.value?.position !== null) {
+      message.value = { $case: "position", position: Vector2.fromPartial(object.value.position) };
+    }
+    if (
+      object.value?.$case === "reference" && object.value?.reference !== undefined && object.value?.reference !== null
+    ) {
+      message.value = { $case: "reference", reference: object.value.reference };
+    }
+    return message;
+  }
+}
+
 function createBasePBUiTransform(): PBUiTransform {
   return {
     parent: 0,
@@ -695,6 +840,9 @@ function createBasePBUiTransform(): PBUiTransform {
     borderLeftColor: undefined,
     borderRightColor: undefined,
     opacity: undefined,
+    elementId: undefined,
+    scrollPosition: undefined,
+    scrollVisible: undefined,
     zIndex: undefined,
   };
 }
@@ -920,6 +1068,15 @@ export namespace PBUiTransform {
     if (message.opacity !== undefined) {
       writer.uint32(589).float(message.opacity);
     }
+    if (message.elementId !== undefined) {
+      writer.uint32(594).string(message.elementId);
+    }
+    if (message.scrollPosition !== undefined) {
+      ScrollPositionValue.encode(message.scrollPosition, writer.uint32(602).fork()).ldelim();
+    }
+    if (message.scrollVisible !== undefined) {
+      writer.uint32(608).int32(message.scrollVisible);
+    }
     if (message.zIndex !== undefined) {
       writer.uint32(616).int32(message.zIndex);
     }
@@ -1444,6 +1601,27 @@ export namespace PBUiTransform {
 
           message.opacity = reader.float();
           continue;
+        case 74:
+          if (tag !== 594) {
+            break;
+          }
+
+          message.elementId = reader.string();
+          continue;
+        case 75:
+          if (tag !== 602) {
+            break;
+          }
+
+          message.scrollPosition = ScrollPositionValue.decode(reader, reader.uint32());
+          continue;
+        case 76:
+          if (tag !== 608) {
+            break;
+          }
+
+          message.scrollVisible = reader.int32() as any;
+          continue;
         case 77:
           if (tag !== 616) {
             break;
@@ -1549,6 +1727,9 @@ export namespace PBUiTransform {
       borderLeftColor: isSet(object.borderLeftColor) ? Color4.fromJSON(object.borderLeftColor) : undefined,
       borderRightColor: isSet(object.borderRightColor) ? Color4.fromJSON(object.borderRightColor) : undefined,
       opacity: isSet(object.opacity) ? Number(object.opacity) : undefined,
+      elementId: isSet(object.elementId) ? String(object.elementId) : undefined,
+      scrollPosition: isSet(object.scrollPosition) ? ScrollPositionValue.fromJSON(object.scrollPosition) : undefined,
+      scrollVisible: isSet(object.scrollVisible) ? showScrollBarFromJSON(object.scrollVisible) : undefined,
       zIndex: isSet(object.zIndex) ? Number(object.zIndex) : undefined,
     };
   }
@@ -1662,6 +1843,13 @@ export namespace PBUiTransform {
     message.borderRightColor !== undefined &&
       (obj.borderRightColor = message.borderRightColor ? Color4.toJSON(message.borderRightColor) : undefined);
     message.opacity !== undefined && (obj.opacity = message.opacity);
+    message.elementId !== undefined && (obj.elementId = message.elementId);
+    message.scrollPosition !== undefined &&
+      (obj.scrollPosition = message.scrollPosition ? ScrollPositionValue.toJSON(message.scrollPosition) : undefined);
+    message.scrollVisible !== undefined &&
+      (obj.scrollVisible = message.scrollVisible !== undefined
+        ? showScrollBarToJSON(message.scrollVisible)
+        : undefined);
     message.zIndex !== undefined && (obj.zIndex = Math.round(message.zIndex));
     return obj;
   }
@@ -1753,6 +1941,11 @@ export namespace PBUiTransform {
       ? Color4.fromPartial(object.borderRightColor)
       : undefined;
     message.opacity = object.opacity ?? undefined;
+    message.elementId = object.elementId ?? undefined;
+    message.scrollPosition = (object.scrollPosition !== undefined && object.scrollPosition !== null)
+      ? ScrollPositionValue.fromPartial(object.scrollPosition)
+      : undefined;
+    message.scrollVisible = object.scrollVisible ?? undefined;
     message.zIndex = object.zIndex ?? undefined;
     return message;
   }

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@dcl/protocol",
-  "version": "1.0.0-24197129021.commit-3a0cc03",
+  "version": "1.0.0-24360053093.commit-d8b1cf7",
   "description": "",
-  "repository": "decentraland/protocol.git",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/decentraland/protocol.git"
+  },
   "homepage": "https://github.com/decentraland/protocol#readme",
   "bugs": "https://github.com/decentraland/protocol/issues",
   "keywords": [],
@@ -13,7 +16,7 @@
     "test": "./scripts/check-proto-compabitility.sh"
   },
   "devDependencies": {
-    "@protobuf-ts/protoc": "^2.11.0",
+    "@protobuf-ts/protoc": "^2.8.1",
     "proto-compatibility-tool": "^1.1.2-20220925163655.commit-25bd040",
     "typescript": "^5.0.4"
   },
@@ -30,5 +33,5 @@
     "out-js",
     "public"
   ],
-  "commit": "3a0cc035775e4cdc8564f6f714ba5912ac5cf8f8"
+  "commit": "d8b1cf76f8c72097d7a100422285ab1739f7ade7"
 }

package/proto/decentraland/common/texture.proto

@@ -36,10 +36,17 @@ message VideoTexture {
   optional TextureFilterMode filter_mode = 3; // default = FilterMode.Bilinear
 }
 
+message UiCanvasTexture {
+  uint32 ui_canvas_entity = 1;
+  optional TextureWrapMode wrap_mode = 2; // default = TextureWrapMode.Clamp
+  optional TextureFilterMode filter_mode = 3; // default = FilterMode.Bilinear
+}
+
 message TextureUnion {
   oneof tex {
     Texture texture = 1; // default = null
     AvatarTexture avatar_texture = 2; // default = null
     VideoTexture video_texture = 3; // default = null
+    UiCanvasTexture ui_texture = 4;
   }
-}
+}

package/proto/decentraland/kernel/apis/restricted_actions.proto

@@ -16,7 +16,6 @@ message TeleportToRequest {
 
 message TriggerEmoteRequest {
   string predefined_emote = 1;
-  optional uint32 mask = 2;
 }
 
 message ChangeRealmRequest {
@@ -41,7 +40,6 @@ message CommsAdapterRequest {
 message TriggerSceneEmoteRequest {
   string src = 1;
   optional bool loop = 2;
-  optional uint32 mask = 3;
 }
 
 message SuccessResponse {
@@ -50,26 +48,53 @@ message SuccessResponse {
 
 message TriggerEmoteResponse { }
 
-message MovePlayerToResponse { 
+message MovePlayerToResponse {
+  bool success = 1;
+}
+
+message WalkPlayerToRequest {
+  decentraland.common.Vector3 new_relative_position = 1;
+  float stop_threshold = 2;
+  optional float timeout = 3; // max seconds before the request is failed; not passed to the movement scene
+}
+
+message WalkPlayerToResponse {
   bool success = 1;
 }
 
 message TeleportToResponse { }
 
+message SetUiFocusRequest {
+  string element_id = 1;
+}
+
+message ClearUiFocusRequest { }
+
+message GetUiFocusRequest { }
+
+message UiFocusResponse { 
+  // the element that is/was focussed
+  optional string element_id = 1;
+}
+
 message CopyToClipboardRequest {
   string text = 1;
 }
 
 message EmptyResponse { }
 
-message StopEmoteRequest { }
-
 service RestrictedActionsService {
   // MovePlayerTo will move the player to a position relative to the current scene.
   // If 'duration' field is used in the request, the success response depends on the
   // whole interpolation being completed or interrupted (e.g: by input movement)
   rpc MovePlayerTo(MovePlayerToRequest) returns (MovePlayerToResponse) {}
 
+  // WalkPlayerTo will walk the player to a position relative to the current scene,
+  // managed by the movement controller scene. Returns success when the player reaches
+  // within stop_threshold distance, or false if the path is blocked, the player gets
+  // stuck, the player interrupts the walk with manual input, or the optional timeout expires.
+  rpc WalkPlayerTo(WalkPlayerToRequest) returns (WalkPlayerToResponse) {}
+
   // TeleportTo will move the user to the specified world LAND parcel coordinates
   rpc TeleportTo(TeleportToRequest) returns (TeleportToResponse) {}
 
@@ -92,9 +117,15 @@ service RestrictedActionsService {
   // TriggerSceneEmote will trigger an scene emote file in this current user
   rpc TriggerSceneEmote(TriggerSceneEmoteRequest) returns (SuccessResponse) {}
 
+  // Sets the focus to a specific UI element
+  rpc SetUiFocus(SetUiFocusRequest) returns (UiFocusResponse) {}
+
+  // Clears the focus from any currently focused textentry or dropdown
+  rpc ClearUiFocus(SetUiFocusRequest) returns (UiFocusResponse) {}
+
+  // Returns the element_id of any currently focused textentry or dropdown
+  rpc GetUiFocus(GetUiFocusRequest) returns (UiFocusResponse) {}
+
   // CopyToClipboard copies the provided text into the clipboard
   rpc CopyToClipboard(CopyToClipboardRequest) returns (EmptyResponse) {}
-
-  // StopEmote will stop the current emote
-  rpc StopEmote(StopEmoteRequest) returns (SuccessResponse) {}
 }

package/proto/decentraland/kernel/comms/rfc4/comms.proto

@@ -18,7 +18,6 @@ message Packet {
     PlayerEmote player_emote = 9;
     SceneEmote scene_emote = 10;
     MovementCompressed movement_compressed = 12;
-	LookAtPosition look_at_position = 13;
   }
   uint32 protocol_version = 11;
 }
@@ -85,32 +84,13 @@ message MovementCompressed {
   int32 temporal_data = 1; // bit-compressed: timestamp + animations 
   int64 movement_data = 2; // bit-compressed: position + velocity 
   int32 head_sync_data = 3; // bit-compressed: enabled flags + yaw + pitch
-  int32 point_at_data = 4; // bit-compressed: flag + point coordinates
+  int32 point_at_data = 4; // bit-compressed: flag + point coordinates 
 }
 
 message PlayerEmote {
   uint32 incremental_id = 1;
   string urn = 2;
   float timestamp = 3;
-  optional bool is_stopping = 4; // true means the emote has been stopped in the sender's client
-  optional bool is_repeating = 5; // true when it is not the first time the looping animation plays
-  optional int32 interaction_id = 6; // identifies an interaction univocaly, established when the start animation is triggered
-  optional int32 social_emote_outcome = 7; // -1 means it does not use an outcome animation
-  optional bool is_reacting = 8; // to a social emote started by other user
-  optional string social_emote_initiator = 9; // wallet address of the user that initiated social emote
-  optional string target_avatar = 10; // wallet address of the user whose avatar is the target of a directed emote
-  optional uint32 mask = 11; // mask for which bones an animation applies to.
-}
-
-// Message sent to force an avatar to look at a position
-message LookAtPosition
-{
-  float timestamp = 1;
-  // world position
-  float position_x = 2;
-  float position_y = 3;
-  float position_z = 4;
-  string target_avatar_wallet_address = 5;
 }
 
 message SceneEmote {
@@ -143,10 +123,6 @@ message ProfileResponse {
 message Chat {
   string message = 1;
   double timestamp = 2;
-
-  // Extension: optional forwarded_from to identify the original sender when
-  // messages are forwarded through an SFU
-  optional string forwarded_from = 3;
 }
 
 message Scene {

package/proto/decentraland/sdk/components/avatar_equipped_data.proto

@@ -10,4 +10,5 @@ option (common.ecs_component_id) = 1091;
 message PBAvatarEquippedData {
   repeated string wearable_urns = 1;
   repeated string emote_urns = 2;
-}
+  repeated string force_render = 3; // slots that will render even if hidden
+}

package/proto/decentraland/sdk/components/avatar_locomotion_settings.proto

@@ -15,7 +15,4 @@ message PBAvatarLocomotionSettings {
   optional float jump_height = 4;           // Height of a regular jump (in meters)
   optional float run_jump_height = 5;       // Height of a jump while running (in meters)
   optional float hard_landing_cooldown = 6; // Cooldown time after a hard landing before the avatar can move again (in seconds)
-  optional float double_jump_height = 7;    // Height of the double jump (in meters)
-  optional float gliding_speed = 8;         // Maximum speed when gliding (in meters per second)
-  optional float gliding_falling_speed = 9; // Maximum falling speed when gliding (in meters per second)
 }

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/avatar_movement.proto

@@ -0,0 +1,46 @@
+syntax = "proto3";
+
+package decentraland.sdk.components;
+
+import "decentraland/sdk/components/common/id.proto";
+import "decentraland/common/vectors.proto";
+
+option (common.ecs_component_id) = 1501;
+
+message PBAvatarMovement {
+  decentraland.common.Vector3 velocity = 1;
+  float orientation = 2;                                    // 0-360, we don't allow pitch/roll
+  optional decentraland.common.Vector3 ground_direction = 3;
+  optional bool walk_success = 4;                           // set for one frame when a walk_target ends: true = reached target, false = failed; absent = in progress or no walk
+}
+
+// engine behaviour (uses only capsule shapecasts and GJK closest point for portability):
+// 1: set avatar orientation from movement info -> P1
+// 2: record "ground collider" - nearest collider within threshold distance in ground_direction using avatar collider shapecast
+// 3: update all colliders, record previous transform and new transform.
+// 4: apply ground collider movement: take collider closest point, modify P1 translation and rotation by closest point translation and rotation change -> P2
+// 5: resolve collisions using position-based constraints
+//   initialize constraints to -inf, +inf
+//   repeat
+//       for each collider[i] that collides with the P3+N player:
+//           if closest point = capsule middle (i.e. collider collides with P3 collider but with radius 0), 
+//               ignore / continue
+//           else 
+//               update constraints based on minimum movement to escape collision
+//               e.g. if avatar is 1cm into the floor, constraint_min = max(constraint_min, vec3(0, 0.01, 0))
+//       reposition player to satisfy constraints for each axis:
+//           y: satsify floor before ceiling: new position = max(constraint_min, min(constraint_max, current position))
+//           x and z: if squashed, take average, else satisfy the required constraint
+//           if constraint_min > constraint_max then new position = average(constraint_min, constraint_max) 
+//           else new position = clamp(current position, constraint_min, constraint_max)
+//   while position !~= previous position
+// 6: apply velocity (collide and slide)
+//   disable anything we are initially colliding with
+//   shapecast avatar from position to position + velocity * timestep
+//   on impact:
+//       project velocity onto slide plane (standard "Collide & Slide")
+//       velocity = old velocity - (normal * dot(velocity, normal))
+//       repeat continue with residual velocity and residual time
+// 7: provide AvatarMovementInfo values
+//      actual velocity = (final - P3+N) / timestep
+//      external_velocity = (P3+N - P1) / timestep

package/proto/decentraland/sdk/components/avatar_movement_info.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package decentraland.sdk.components;
+
+import "decentraland/sdk/components/common/id.proto";
+import "decentraland/common/vectors.proto";
+import "decentraland/sdk/components/avatar_locomotion_settings.proto";
+import "decentraland/sdk/components/input_modifier.proto";
+
+option (common.ecs_component_id) = 1500;
+
+message PBAvatarMovementInfo {
+  float step_time = 1;                                      // the length of time the current step velocity will apply for
+  float previous_step_time = 2;                             // the length of time the previous step velocity applied for
+  decentraland.common.Vector3 requested_velocity = 3;       // the velocity requested for the previous frame
+  decentraland.common.Vector3 actual_velocity = 4;          // the resulting velocity taking collisions into account
+  decentraland.common.Vector3 external_velocity = 5;        // the velocity imparted by movement of the "ground" platform or pushing from other moving colliders
+  decentraland.sdk.components.PBAvatarLocomotionSettings active_avatar_locomotion_settings = 6;
+  decentraland.sdk.components.PBInputModifier active_input_modifier = 7;
+  optional decentraland.common.Vector3 walk_target = 8;    // if set, the movement scene should walk the player to this scene-relative position
+  optional float walk_threshold = 9;                        // stop distance for walk_target; considered reached when within this distance
+}

package/proto/decentraland/sdk/components/avatar_shape.proto

@@ -40,10 +40,6 @@ message PBAvatarShape {
   repeated string emotes = 11; // available emotes (default empty)
 
   optional bool show_only_wearables = 12; // hides the skin + hair + facial features (default: false)
+  repeated string force_render = 13; // slots that will render even if hidden
 }
 
-// Mask for which bones an animation applies to.
-enum AvatarEmoteMask {
-  AEM_FULL_BODY = 0;
-  AEM_UPPER_BODY = 1;
-}

package/proto/decentraland/sdk/components/camera_layer.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+package decentraland.sdk.components;
+
+import "decentraland/sdk/components/common/id.proto";
+import "decentraland/common/colors.proto";
+
+option (common.ecs_component_id) = 1503;
+
+message PBCameraLayer {
+    // layer to which these settings apply. must be > 0
+    // Layer 0 is the default "real world" layer viewed by the player and cannot be modified.
+    uint32 layer = 1;
+
+    // should the sun light affect this layer? default false
+    optional bool directional_light = 2;
+
+    // should this layer show player avatars? default false
+    optional bool show_avatars = 3;
+
+    // should this layer show the sky? default false
+    optional bool show_skybox = 4;
+
+    // should this layer show distance fog? default false
+    optional bool show_fog = 5;
+
+    // ambient light overrides for this layer. default -> use same as main camera
+    optional decentraland.common.Color3 ambient_color_override = 6;
+    optional float ambient_brightness_override = 7;
+}

package/proto/decentraland/sdk/components/camera_layers.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package decentraland.sdk.components;
+
+import "decentraland/sdk/components/common/id.proto";
+
+option (common.ecs_component_id) = 1208;
+
+message PBCameraLayers {
+    repeated uint32 layers = 1;
+}

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
 }