@dcl/protocol 1.0.0-3548510624.commit-7609438 → 1.0.0-35600014993.commit-874bb91

package/proto/decentraland/sdk/components/mesh_collider.proto

@@ -6,25 +6,31 @@ import "decentraland/sdk/components/common/id.proto";
 
 option (common.ecs_component_id) = 1019;
 
-enum ColliderLayer {
-  CL_NONE = 0;
-  CL_POINTER = 1;
-  CL_PHYSICS = 2;
-}
-
+// The MeshCollider component provides basic collision detection between Entities and Avatars. It 
+// can behave like a cube, a plane, a sphere or a cylinder. 
+//
+// The Entity's Transform affects the MeshCollider, scaling it and rotating it appropriately. If
+// the Transform for the collision mesh must be different than the Transform for rendering the Entity,
+// two different Entities must be used.
+//
+// More complex shapes require the use of a `GltfContainer` component.
 message PBMeshCollider {
+  // BoxMesh is a prism shape that contains the Entity.
   message BoxMesh {}
 
+  // CylinderMesh is a truncated cone shape that contains the Entity.
   message CylinderMesh {
-    optional float radius_top = 1; // default=1.0
-    optional float radius_bottom = 2; // default=1.0
+    optional float radius_top = 1;    // (default 0.5)
+    optional float radius_bottom = 2; // (default 0.5)
   }
 
+  // PlaneMesh is a 2D rectangle described by the Entity's Transform.
   message PlaneMesh {}
 
+  // SphereMesh is a sphere shape that contains the Entity.
   message SphereMesh {}
 
-  optional int32 collision_mask = 1; // default = ColliderLayer.Physics | ColliderLayer.Pointer
+  optional uint32 collision_mask = 1; // enabled ColliderLayers (default CL_POINTER | CL_PHYSICS)
 
   oneof mesh {
     BoxMesh box = 2;
@@ -33,3 +39,24 @@ message PBMeshCollider {
     PlaneMesh plane = 5;
   }
 }
+
+// ColliderLayer determines the kind of collision to detect, in OR-able bit flag form.
+enum ColliderLayer {
+  CL_NONE = 0;           // no collisions
+  CL_POINTER = 1;        // collisions with the player's pointer ray (e.g. mouse cursor hovering)
+  CL_PHYSICS = 2;        // collision affecting your player's physics i.e. walls, floor, moving platfroms
+  CL_PLAYER = 4;         // layer corresponding to any player avatar (main + remote)
+  CL_MAIN_PLAYER = 8;    // layer corresponding to the local (main) player avatar
+  CL_RESERVED3 = 16;
+  CL_RESERVED4 = 32;
+  CL_RESERVED5 = 64;
+  CL_RESERVED6 = 128;
+  CL_CUSTOM1 = 256;
+  CL_CUSTOM2 = 512;
+  CL_CUSTOM3 = 1024;
+  CL_CUSTOM4 = 2048;
+  CL_CUSTOM5 = 4096;
+  CL_CUSTOM6 = 8192;
+  CL_CUSTOM7 = 16384;
+  CL_CUSTOM8 = 32768;
+}

package/proto/decentraland/sdk/components/mesh_renderer.proto

@@ -4,20 +4,33 @@ package decentraland.sdk.components;
 import "decentraland/sdk/components/common/id.proto";
 option (common.ecs_component_id) = 1018;
 
+// The MeshRenderer component renders a basic geometric shape for an Entity. It can be a cube, a 
+// plane, a sphere or a cylinder.
+//
+// The cube and plane variants can include a UV texture mapping, so specific areas of a material 
+// texture are rendered on different faces of the shape. They are serialized as a sequence of 2D
+// `float` coordinates, one for each corner of each side of each face.
+//
+// More complex shapes require the use of a `GltfContainer` component.
 message PBMeshRenderer {
+    
+    // BoxMesh renders a prism shape.
     message BoxMesh {
-        repeated float uvs = 1;
+        repeated float uvs = 1; // 96-value texture map (2D * 6 faces * 2 sides * 4 vertices)
     }
 
+    // CylinderMesh renders a truncated cone shape.
     message CylinderMesh {
-        optional float radius_top = 1; // default=1.0
-        optional float radius_bottom = 2; // default=1.0
+        optional float radius_top = 1;    // (default 0.5)
+        optional float radius_bottom = 2; // (default 0.5)
     }
 
+    // PlaneMesh renders a 2D rectangular shape.
     message PlaneMesh {
-        repeated float uvs = 1;
+        repeated float uvs = 1; // 16-value texture map (2D * 1 face * 2 sides * 4 vertices)
     }
 
+    // SphereMesh renders a spherical shape.
     message SphereMesh {
     }
 

package/proto/decentraland/sdk/components/nft_shape.proto

@@ -7,6 +7,20 @@ import "decentraland/sdk/components/common/id.proto";
 
 option (common.ecs_component_id) = 1040;
 
+// The NftShape component renders a framed picture from an NFT. It supports PNG, JPEG and GIF files.
+//
+// The `urn` field is the URI of the NFT, and must follow the format 'urn:decentraland:<CHAIN>:<CONTRACT_STANDARD>:<CONTRACT_ADDRESS>:<TOKEN_ID>'
+// Example: 'urn:decentraland:ethereum:erc721:0x00000000:123'
+//
+// The picture frame can have several different styles, plus a background color for images that have
+// transparent pixels.
+message PBNftShape {
+  string urn = 1;                                // the URI of the NFT
+  optional NftFrameType style = 2;               // the frame style (default NFT_CLASSIC)
+  optional decentraland.common.Color3 color = 3; // RGB background (default [0.6404918, 0.611472, 0.8584906])
+}
+
+// NftFrameType is a predefined framing style for the image.
 enum NftFrameType {
   NFT_CLASSIC = 0;
   NFT_BAROQUE_ORNAMENT = 1;
@@ -31,10 +45,4 @@ enum NftFrameType {
   NFT_WOOD_TWIGS = 20;
   NFT_CANVAS = 21;
   NFT_NONE = 22;
-}
-
-message PBNftShape {
-  string src = 1;
-  optional NftFrameType style = 2; // default = PictureFrameStyle.Classic
-  optional decentraland.common.Color3 color = 3; // default = decentraland.common.Color3(0.6404918, 0.611472, 0.8584906)
-}
+}

package/proto/decentraland/sdk/components/particle_system.proto

@@ -0,0 +1,133 @@
+syntax = "proto3";
+
+package decentraland.sdk.components;
+
+import "decentraland/common/colors.proto";
+import "decentraland/common/floats.proto";
+import "decentraland/common/texture.proto";
+import "decentraland/common/vectors.proto";
+import "decentraland/sdk/components/common/id.proto";
+
+option (common.ecs_component_id) = 1217;
+
+message PBParticleSystem {
+  // --- Emission ---
+  optional bool active = 1;              // default = true
+  optional float rate = 2;              // default = 10. Particles emitted per second.
+  optional uint32 max_particles = 3;    // default = 1000. Maximum number of live particles.
+  optional float lifetime = 4;          // default = 5. Particle lifetime in seconds.
+
+  // --- Motion ---
+  optional float gravity = 5;           // default = 0. Multiplier of Explorer's physics engine Gravity (normally -9.81)
+  optional decentraland.common.Vector3 additional_force = 6; // Constant force vector applied to each particle (world space).
+
+  // --- Size ---
+  optional decentraland.common.FloatRange initial_size = 7;     // default = {1, 1}. Particle size at spawn.
+  optional decentraland.common.FloatRange size_over_time = 8;   // default = {1, 1}. Particle size lerped from start to end over its lifetime.
+
+  // --- Rotation ---
+  optional decentraland.common.Quaternion initial_rotation = 9;      // default = identity (0,0,0,1). 3D start rotation for each particle.
+  optional decentraland.common.Quaternion rotation_over_time = 10;   // default = identity (0,0,0,1). Per-axis angular velocity as quaternion; converted to Euler XYZ.
+  optional bool face_travel_direction = 28; // default = false. Particles orient along their velocity direction.
+
+  // --- Color ---
+  optional decentraland.common.ColorRange initial_color = 11;    // default = {white, white}. Particle color at spawn, randomized between start and end.
+  optional decentraland.common.ColorRange color_over_time = 12;  // default = {white, white}. Particle color lerped from start to end over its lifetime.
+
+  // --- Velocity ---
+  optional decentraland.common.FloatRange initial_velocity_speed = 13; // default = {1, 1}. Initial speed in m/s, randomized between start and end.
+
+  // --- Rendering ---
+  optional decentraland.common.Texture texture = 14; // Particle texture. default = null (plain white quad).
+  optional BlendMode blend_mode = 15;                // default = PSB_ALPHA
+  optional bool billboard = 16;  // default = true
+
+  // --- Sprite Sheet Animation ---
+  optional SpriteSheetAnimation sprite_sheet = 17;
+
+  // --- Emitter Shape ---
+  oneof shape {
+    Point point = 18;
+    Sphere sphere = 19;
+    Cone cone = 20;
+    Box box = 21;
+  }
+
+  // --- Simulation ---
+  optional bool loop = 24;     // default = true. Loop the emission cycle.
+  optional bool prewarm = 25;  // default = false. Start as if already simulated for one full loop cycle. Requires loop = true.
+  optional SimulationSpace simulation_space = 27; // default = PSS_LOCAL. Controls whether particles simulate in local or world space.
+
+  // --- Limit Velocity Over Lifetime ---
+  optional LimitVelocity limit_velocity = 26; // Clamps particle speed over its lifetime.
+
+  // --- Playback ---
+  optional PlaybackState playback_state = 22; // default = PS_PLAYING
+
+  // --- Emission Bursts ---
+  optional BurstConfiguration bursts = 29;
+
+  // ---- Nested types ----
+
+  // Sprite sheet (texture atlas) animation settings.
+  message SpriteSheetAnimation {
+    uint32 tiles_x = 1;      // Number of columns in the sprite sheet.
+    uint32 tiles_y = 2;      // Number of rows in the sprite sheet.
+    optional float frames_per_second = 3; // default = 30. Playback speed in frames per second.
+  }
+
+  // Clamps particle speed over lifetime.
+  message LimitVelocity {
+    float speed = 1;            // Maximum particle speed (m/s).
+    optional float dampen = 2;  // default = 1. Fraction (0–1) of excess velocity removed per frame. 1 = hard clamp.
+  }
+
+  // Emitter spawns particles from a single point.
+  message Point {}
+
+  // Emitter spawns particles from the surface or volume of a sphere.
+  message Sphere {
+    optional float radius = 1; // default = 1
+  }
+
+  // Emitter spawns particles from the base of a cone and projects them outward.
+  message Cone {
+    optional float angle = 1;  // default = 25. Half-angle of the cone in degrees.
+    optional float radius = 2; // default = 1. Base radius in meters.
+  }
+
+  // Emitter spawns particles from the surface or volume of a box.
+  message Box {
+    optional decentraland.common.Vector3 size = 1; // default = {1, 1, 1}
+  }
+
+  // Emission burst configuration.
+  message BurstConfiguration {
+    repeated Burst values = 1;
+  }
+  
+  message Burst {
+    float time = 1;                // Seconds from start of cycle.
+    uint32 count = 2;             // Particles to emit.
+    optional int32 cycles = 3;    // default = 1. Repeat count (0 = infinite).
+    optional float interval = 4;  // default = 0.01. Seconds between cycles.
+    optional float probability = 5; // default = 1.0. Emission chance [0,1].
+  }
+
+  enum BlendMode {
+    PSB_ALPHA = 0;     // Standard alpha transparency.
+    PSB_ADD = 1;       // Additive blending (brightens underlying pixels).
+    PSB_MULTIPLY = 2;  // Multiply blending (darkens underlying pixels).
+  }
+
+  enum PlaybackState {
+    PS_PLAYING = 0; // Particle system is emitting and simulating.
+    PS_PAUSED = 1;  // Simulation is frozen; no new particles are emitted.
+    PS_STOPPED = 2; // Simulation stopped and existing particles cleared.
+  }
+
+  enum SimulationSpace {
+    PSS_LOCAL = 0; // Particles move with the entity transform.
+    PSS_WORLD = 1; // Particles stay in world position after emission.
+  }
+}

package/proto/decentraland/sdk/components/physics_combined_force.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package decentraland.sdk.components;
+
+import "decentraland/common/vectors.proto";
+import "decentraland/sdk/components/common/id.proto";
+
+option (common.ecs_component_id) = 1216;
+
+/**
+ * This component applies a continuous physics force.
+
+ * @remarks Low-level component. Use Physics.applyForceToPlayer()/.removeForceToPlayer() instead.
+ * Direct manipulation will conflict with the force accumulation registry.
+ * Summary component: stores the accumulated result of all active forces registered by the scene in the current frame.
+
+ * State-like component: the force is applied every physics tick while the component is present on the entity.
+*/
+message PBPhysicsCombinedForce {
+    decentraland.common.Vector3 vector = 1; // Includes force direction and magnitude
+}

package/proto/decentraland/sdk/components/physics_combined_impulse.proto

@@ -0,0 +1,23 @@
+syntax = "proto3";
+
+package decentraland.sdk.components;
+
+import "decentraland/common/vectors.proto";
+import "decentraland/sdk/components/common/id.proto";
+
+option (common.ecs_component_id) = 1215;
+
+/**
+ * This component applies a one-shot physics summary impulse.
+ 
+ * @remarks Low-level component. Use Physics.applyImpulseToPlayer() instead.
+ * Direct manipulation will conflict with the force accumulation registry.
+ * Summary component: stores the accumulated result of all impulses registered by the scene in the current frame.
+ 
+ * Event-like component: each new impulse must increment the eventID to ensure delivery via CRDT, even if the direction is identical to the previous one.
+ * Renderer processes impulse with the unique ID only once. Increase eventID of the component to apply another impulse.
+*/
+message PBPhysicsCombinedImpulse {
+    decentraland.common.Vector3 vector = 1; // Includes impulse direction and magnitude
+    uint32 event_id = 2; // Monotonic counter to distinguish different impulses.
+}

package/proto/decentraland/sdk/components/player_identity_data.proto

@@ -0,0 +1,13 @@
+syntax = "proto3";
+package decentraland.sdk.components;
+
+import "decentraland/sdk/components/common/id.proto";
+option (common.ecs_component_id) = 1089;
+
+// PlayerIdentityData is used to read the information about the avatar's
+// identity. this component is written by the engine using the communications
+// transports' data.
+message PBPlayerIdentityData {
+  string address = 1; // ethereum address of this player
+  bool is_guest = 3;
+}

package/proto/decentraland/sdk/components/pointer_events.proto

@@ -0,0 +1,68 @@
+syntax = "proto3";
+
+package decentraland.sdk.components;
+
+import "decentraland/sdk/components/common/id.proto";
+import "decentraland/sdk/components/common/input_action.proto";
+
+option (common.ecs_component_id) = 1062;
+
+// PointerEvents adds configurable pointer-based interactions to the attached Entity.
+//
+// Events that match the criteria defined in the PointerEvents structure are reported back to the 
+// Entity via the PointerEventsResult component.
+//
+// Some examples of events that can be detected:
+// - Pointer hovering over the Entity.
+// - Held mouse button released over the Entity.
+// - Controller button pressed while targeting the Entity.
+// - Key pressed while targeting the Entity, but only in close range.
+//
+// It also supports simple visual feedback when interactions occur, by showing floating text.
+// More sophisticated feedback requires the use of other components.
+//
+// Distance rules
+// --------------
+// PointerEvents can enforce interaction range using two independent distance checks:
+//
+// - Player distance (`max_distance`): distance from the avatar/player position to the target entity.
+// - Camera distance (`max_camera_distance`): distance from the active camera to the target entity.
+//
+// `max_player_distance` is deprecated: it is an alias for `max_distance` (both are player distance).
+// If both are present, the larger of the two is used as the player distance threshold.
+//
+// How the interaction checks are combined:
+//
+// 1) Only `max_distance` is present
+//    - The interaction is allowed only if the player distance is <= `max_distance`.
+//
+// 2) Only `max_camera_distance` is present
+//    - The interaction is allowed only if the camera distance is <= `max_camera_distance`.
+//
+// 3) Both `max_distance` and `max_camera_distance` are present
+//    - The interaction is allowed if ANY of the checks passes (OR logic):
+//      (player distance <= `max_distance`) OR (camera distance <= `max_camera_distance`).
+//
+// 4) Neither `max_distance` nor `max_camera_distance` is present
+//    - The system behaves as if `max_distance` were set to its default value (10),
+//      i.e., it uses the player distance check with a threshold of 10.
+message PBPointerEvents {
+  message Info {
+    optional common.InputAction button = 1; // key/button in use (default IA_ANY)
+    optional string hover_text = 2;         // feedback on hover (default 'Interact')
+    optional float max_distance = 3;        // range of interaction from the avatar's position (default 10)
+    optional bool show_feedback = 4;        // enable or disable hover text and highlight (default true)
+    optional bool show_highlight = 5;       // enable or disable hover highlight (default true)
+    optional float max_player_distance = 6; // @deprecated use `max_distance` instead (same semantics)
+    optional uint32 priority = 7;           // resolution order when multiple events overlap, higher wins (default 0)
+    optional float max_camera_distance = 8; // range of interaction from the active camera's position (default none)
+  }
+
+  message Entry {
+    common.PointerEventType event_type = 1; // the kind of interaction to detect
+    Info event_info = 2;             // additional configuration for this detection
+    optional common.InteractionType interaction_type = 3; // the type of interaction source (default 0 == CURSOR)
+  }
+
+  repeated Entry pointer_events = 1; // the list of relevant events to detect
+}

package/proto/decentraland/sdk/components/pointer_events_result.proto

@@ -4,22 +4,16 @@ package decentraland.sdk.components;
 
 import "decentraland/sdk/components/common/id.proto";
 import "decentraland/sdk/components/common/input_action.proto";
-import "decentraland/sdk/components/pointer_hover_feedback.proto";
-import "decentraland/sdk/components/raycast_result.proto";
+import "decentraland/sdk/components/common/raycast_hit.proto";
 
 option (common.ecs_component_id) = 1063;
 
-// the renderer will set this component to the root entity once per frame with all the events
+// renderer append a new object of this in each command, there can be many commands per frames
 message PBPointerEventsResult {
-  // a list of the last N pointer commands (from the engine)
-  repeated PointerCommand commands = 1;
-
-  // this message represents a pointer event, used both for UP and DOWN actions
-  message PointerCommand {
-    common.InputAction button = 1; // identifier of the input
-    RaycastHit hit = 2;
-    PointerEventType state = 4;
-    int32 timestamp = 5; // could be a Lamport timestamp
-    optional float analog = 6; // if the input is analog then we store it here
-  }
+  common.InputAction button = 1; // identifier of the input
+  common.RaycastHit hit = 2;
+  common.PointerEventType state = 4;
+  uint32 timestamp = 5;          // monotonic counter
+  optional float analog = 6;     // if the input is analog then we store it here
+  uint32 tick_number = 7;        // number of tick in which the event was produced, equals to EngineInfo.tick_number
 }

package/proto/decentraland/sdk/components/pointer_lock.proto

@@ -4,6 +4,8 @@ package decentraland.sdk.components;
 import "decentraland/sdk/components/common/id.proto";
 option (common.ecs_component_id) = 1074;
 
+// PointerLock indicates whether the mouse pointer is automatically following the camera’s point of
+// focus (locked), or can move freely on the screen (unlocked).
 message PBPointerLock {
-  bool is_pointer_locked = 1;
+  bool is_pointer_locked = 1; // whether the pointer is locked
 }

package/proto/decentraland/sdk/components/primary_pointer_info.proto

@@ -0,0 +1,39 @@
+syntax = "proto3";
+package decentraland.sdk.components;
+
+import "decentraland/common/vectors.proto";
+import "decentraland/sdk/components/common/id.proto";
+
+option (common.ecs_component_id) = 1209;
+
+// The PBPrimaryPointerInfo component provides information about the current state of the primary 
+// pointer input device (mouse, touch, gamepad, or VR controller). It tracks the pointer's position,
+// movement, and interaction capabilities in both 2D screen space and 3D world space.
+//
+// This component is essential for:
+// - Tracking cursor/pointer position and movement
+// - Converting 2D screen coordinates to 3D world space interactions
+// - Supporting multiple input methods (mouse, touch, gamepad, VR)
+// - Enabling ray-based interactions for 3D object selection
+//
+// The component can be used to:
+// - Implement drag-and-drop functionality
+// - Handle touch interactions on mobile devices
+// - Support gamepad navigation
+// - Enable VR controller interactions
+// - Convert screen coordinates to world space rays for 3D interactions
+//
+// Note: Touch, Pad, and Wand support, as well as dragging, will be added later.
+message PBPrimaryPointerInfo {
+  optional PointerType pointer_type = 1;  // The type of input device being used
+  optional decentraland.common.Vector2 screen_coordinates = 2;  // Current position in screen space (pixels)
+  optional decentraland.common.Vector2 screen_delta = 3;  // Movement since last frame (pixels)
+  optional decentraland.common.Vector3 world_ray_direction = 4; // Direction vector for 3D ray casting
+}
+
+// PointerType enumerates the different input devices that can be used for pointer interactions.
+// Each type has specific characteristics and use cases in the virtual world.
+enum PointerType {
+  POT_NONE = 0;   // No pointer input
+  POT_MOUSE = 1;  // Traditional mouse input
+}

package/proto/decentraland/sdk/components/raycast.proto

@@ -7,14 +7,52 @@ import "decentraland/sdk/components/common/id.proto";
 
 option (common.ecs_component_id) = 1067;
 
-enum RaycastQueryType {
-  RQT_HIT_FIRST = 0;
-  RQT_QUERY_ALL = 1;
-}
-
+// The PBRaycast component and PBRaycastResult are defined in https://adr.decentraland.org/adr/ADR-200
+//
+// The Raycast component allows scenes to request raycasting from the game engine. The results will
+// be available in a RaycastResult component set later on the same Entity.
 message PBRaycast {
-  decentraland.common.Vector3 origin = 2;
-  decentraland.common.Vector3 direction = 3;
+  // Correlation ID, defined by the scene and used internally by the scene
+  optional uint32 timestamp = 1;
+
+  // How much to offset the starting point of the ray, relative to the entity's transform.
+  // Defaults to vec3(0,0,0)
+  optional decentraland.common.Vector3 origin_offset = 2;
+
+  oneof direction {
+    // The direction of the ray in local coordinates (relative to the origin point)
+    decentraland.common.Vector3 local_direction = 6;
+
+    // The direction of the ray in global coordinates (relative to origin)
+    decentraland.common.Vector3 global_direction = 3;
+
+    // Target coordinates of the raycast, in global coordinates
+    decentraland.common.Vector3 global_target = 7;
+
+    // Will point to the final world position of another entity
+    uint32 target_entity = 10;
+  }
+
+  // Maximum length of the ray in virtual meters (global space)
   float max_distance = 4;
+
+  // the RaycastQueryType behavior
   RaycastQueryType query_type = 5;
+
+  // Indicates the renderer to perform the raycast on every scene tick (ADR-148),
+  // otherwise it will be performed only once, defaults to false
+  optional bool continuous = 8;
+
+  // Collision mask, by default CL_POINTER | CL_PHYSICS
+  optional uint32 collision_mask = 9;
+}
+
+// RaycastQueryType indicates whether the ray should stop on the first collition, or continue.
+enum RaycastQueryType {
+  // Pick the first (not necessarily the closest) hit within the range
+  RQT_HIT_FIRST = 0;
+  // Pick all hits within the range
+  RQT_QUERY_ALL = 1;
+  // Do not perform the raycast, only set the raycast result with empty hits
+  RQT_NONE = 2;
 }

package/proto/decentraland/sdk/components/raycast_result.proto

@@ -1,25 +1,21 @@
 syntax = "proto3";
 package decentraland.sdk.components;
 
-import "decentraland/sdk/components/common/id.proto";
 import "decentraland/common/vectors.proto";
+import "decentraland/sdk/components/common/id.proto";
+import "decentraland/sdk/components/common/raycast_hit.proto";
 
 option (common.ecs_component_id) = 1068;
 
+// The PBRaycast component and PBRaycastResult are defined in https://adr.decentraland.org/adr/ADR-200
+//
+// The RaycastResult component is added to an Entity when the results of a previously attached
+// Raycast component are available. It contains information about the ray and any objects it
+// collided with.
 message PBRaycastResult {
-  int32 timestamp = 1;
-  decentraland.common.Vector3 origin = 2;
-  decentraland.common.Vector3 direction = 3;
-  repeated RaycastHit hits = 4;
+  optional uint32 timestamp = 1;                 // timestamp is a correlation id, copied from the PBRaycast
+  decentraland.common.Vector3 global_origin = 2; // the starting point of the ray in global coordinates
+  decentraland.common.Vector3 direction = 3;     // the direction vector of the ray in global coordinates
+  repeated decentraland.sdk.components.common.RaycastHit hits = 4; // zero or more hits
+  uint32 tick_number = 5;                        // number of tick in which the event was produced, equals to EngineInfo.tick_number
 }
-
-// Position will be relative to the scene  
-message RaycastHit {
-  decentraland.common.Vector3 position = 1;
-  decentraland.common.Vector3 origin = 2;
-  decentraland.common.Vector3 direction = 3;
-  decentraland.common.Vector3 normal_hit = 4;
-  float length = 5;
-  optional string mesh_name = 6;
-  optional int64 entity_id = 7;
-}

package/proto/decentraland/sdk/components/realm_info.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+package decentraland.sdk.components;
+
+import "decentraland/sdk/components/common/id.proto";
+option (common.ecs_component_id) = 1106;
+
+message PBRealmInfo {
+  string base_url = 1;                        // the domain of the realm server
+  string realm_name = 2;                      // the name of the realm server (more info https://adr.decentraland.org/adr/ADR-110)
+  int32 network_id = 3;                       // the network id (1=Ethereum, more info https://chainlist.org/)
+  string comms_adapter = 4;                   // comms adapter (more info https://adr.decentraland.org/adr/ADR-180)
+  bool is_preview = 5;                        // true if the scene is running as a local preview, instead of published in Decentraland.
+  optional string room = 6;                   // the room session id.
+  optional bool is_connected_scene_room = 7;  // true if the user is connected to the scene room.
+}

package/proto/decentraland/sdk/components/skybox_time.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+package decentraland.sdk.components;
+
+
+import "decentraland/sdk/components/common/id.proto";
+
+option (common.ecs_component_id) = 1210;
+
+// The SkyboxTime component allows controlling the time of day for the skybox,
+// affecting the lighting and appearance of the sky in the scene.
+message PBSkyboxTime {
+  uint32 fixed_time = 1;  // fixed time of day, represented as a number of seconds since the start of the day, where 0 is 00:00hs, 43200 is 12:00hs and 86400 is 24:00hs
+  optional TransitionMode transition_mode = 2;  // default = TransitionMode.TM_FORWARD, controls the direction of time transitions
+}
+
+// Controls the direction for animated skybox transitions
+enum TransitionMode {
+  TM_FORWARD = 0;   // transitions forward (default)
+  TM_BACKWARD = 1;  // transitions backward
+}