> For the complete documentation index, see [llms.txt](https://docs.decentraland.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/camera.md).

# Cámara

Aprende a controlar la cámara del jugador

Como creador, puedes tener control total sobre la cámara del jugador. De forma predeterminada, los jugadores pueden elegir libremente entre la cámara en primera o tercera persona mientras exploran tu escena, pero puedes imponer una modalidad de cámara diferente.

Las cámaras virtuales pueden ser estáticas, girar para mirar siempre al jugador o a otra Entity, o estar conectadas al jugador o a otra Entity para acompañarlos siempre.

{% hint style="warning" %}
**📔 Nota**: Para alternar entre las cámaras predeterminadas en primera y tercera persona, consulta [Áreas modificadoras de cámara](#1st-and-3rd-person-camera-modes).
{% endhint %}

## Modos de cámara en primera y tercera persona

Normalmente, los jugadores pueden alternar entre las cámaras en primera y tercera persona pulsando V en el teclado. Usa una `CameraModeArea` para forzar el modo de cámara en primera o tercera persona para todos los jugadores que se encuentren dentro de un área específica de tu escena.

```ts
const entity = engine.addEntity()

CameraModeArea.create(entity, {
	area: Vector3.create(4, 3, 4),
	mode: CameraType.CT_FIRST_PERSON,
})
```

Si el modo de cámara actual de un jugador no coincide con el de la `CameraModeArea`, cambiará a ese modo de cámara. Aparecerá un mensaje emergente en pantalla para aclarar que el cambio se debe a la escena. Mientras estén dentro del área, los jugadores no podrán cambiar el modo de cámara. Cuando un jugador salga del `CameraModeArea`, se restaurará el modo de cámara que tenía antes de entrar.

Usa `CameraModeArea` en regiones donde los jugadores tendrían una experiencia significativamente mejor con un modo de cámara específico. Por ejemplo, la primera persona es ideal si el jugador necesita hacer clic en un objeto pequeño, mientras que la tercera persona puede servir para que los jugadores noten una Entity que tu escena tenga colocada sobre su cabeza. No des por sentado que los jugadores saben cómo cambiar de modo de cámara: es posible que muchos jugadores nuevos no sepan que pueden hacerlo o que no recuerden qué tecla deben pulsar.

{% hint style="warning" %}
**📔 Nota**: Las áreas modificadoras de cámara se ven afectadas por la *posición* y la *rotación* del componente Transform de su Entity anfitriona, pero no se ven afectadas por la *escala*.
{% endhint %}

{% hint style="warning" %}
**📔 Nota**: Si se superponen varias áreas modificadoras de cámara, tendrá prioridad la última que instancie el código de tu escena.
{% endhint %}

Al crear un componente `CameraModeArea` debes proporcionar lo siguiente:

* `area`: Tamaño del área modificadora
* `mode`: Modo de cámara que se forzará en esta área, según la enumeración `CameraType` .

Los modos de cámara compatibles son:

* `CameraType.CT_FIRST_PERSON`
* `CameraType.CT_THIRD_PERSON`

### Consultar el modo de cámara

Puedes consultar el modo de cámara del jugador usando el componente `CameraMode` en la `engine.CameraEntity`.

```ts
const cameraMode = CameraMode.get(engine.CameraEntity)
if (cameraMode.mode === CameraType.CT_FIRST_PERSON) {
	console.log('The player is using the 1st person camera')
} else {
	console.log('The player is using the 3rd person camera')
}
```

También puedes suscribirte a los cambios en el modo de cámara usando `onChange` función `CameraMode` component.

```ts
CameraMode.onChange(engine.CameraEntity, (cameraMode) => {
	if (!cameraMode) return
	console.log('The player\'s camera mode changed to', cameraMode.mode)
})
```

## Uso de cámaras virtuales

Para usar un comportamiento de cámara personalizado en tu escena, necesitas dos cosas:

* Crear una cámara virtual: crea una entidad en tu escena y asígnale un componente `VirtualCamera`.
* Asignar esa cámara virtual: añade un componente `MainCamera` a la [entidad reservada](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/entities-components.md#reserved-entities) `engine.CameraEntity`, con una referencia a la entidad que tenga el componente `VirtualCamera` .

La cámara se adjuntará entonces a la entidad que tenga el componente `VirtualCamera` . Si la entidad se mueve o gira, la cámara se moverá con ella.

```ts
function main() {
	const myCustomCamera = engine.addEntity()
	Transform.create(myCustomCamera, {
		position: Vector3.create(1, 2, 1),
	})
	VirtualCamera.create(myCustomCamera, {})

	const mainCamera = MainCamera.createOrReplace(engine.CameraEntity, {
		virtualCameraEntity: myCustomCamera,
	})
}
```

En este ejemplo, la cámara permanecerá siempre en una posición fija de la escena, mientras el jugador esté dentro de los límites de la escena. En cuanto el jugador salga de esos límites, se restablecerá el comportamiento predeterminado de la cámara.

### Campo de visión

Configura el campo de visión (FOV) de una cámara virtual con la propiedad `fov` , en grados. Solo se aplica mientras esta cámara virtual esté activa.

```ts
const cinematicCamera = engine.addEntity()
Transform.create(cinematicCamera, {
	position: Vector3.create(8, 3, 2),
})
VirtualCamera.create(cinematicCamera, {
	fov: 45,
})
```

Un FOV más estrecho (valor más bajo) acerca la imagen, lo que resulta útil para escenas cinemáticas o para apuntar. Un FOV más amplio (valor más alto) muestra una mayor parte de la escena, lo que resulta útil para vistas panorámicas.

{% hint style="warning" %}
**📔 Nota**: Configura `fov` en cada cámara virtual que crees. Si lo omites, no obtendrás un valor neutro de 60 grados: el cliente reutiliza instancias de cámara agrupadas sin restablecer la lente, por lo que una cámara sin `fov` conserva el campo de visión que haya dejado en esa instancia una cámara anterior. Una cámara destinada a mostrar una vista aérea amplia podría iniciarse con el zoom muy acercado.
{% endhint %}

Tu escena puede incluir tantas entidades con un componente `VirtualCamera`como quieras, y puedes cambiar dinámicamente entre varias cámaras virtuales a medida que el jugador se mueve o realiza determinadas acciones. Solo puede haber una cámara virtual activa a la vez; esta se asigna mediante el componente `MainCamera` en `engine.CameraEntity`.

Para volver al comportamiento predeterminado de la cámara, establece el valor en `undefined` en `MainCamera.virtualCameraEntity`. Entonces, el jugador puede cambiar libremente entre las cámaras en primera y tercera persona. Si quieres que el jugador use solo uno de estos dos modos, puedes usar un [Camera modifier areas](#1st-and-3rd-person-camera-modes) para forzar uno de los dos.

{% hint style="warning" %}
**📔 Nota**: Libera la cámara con `undefined`, nunca con `0`. Solo un valor ausente devuelve el control al jugador. Un valor de `0` es `engine.RootEntity`, que no tiene ningún `VirtualCamera`, así que el motor mantiene activa la última cámara virtual y el jugador se queda atrapado en esa vista.

Esto puede causar problemas en el código que guarda y restaura la cámara, porque `virtualCameraEntity` es opcional y su valor es `undefined` en una `MainCamera`recién creada. Un valor alternativo de tipo `?? 0` o `|| 0` convierte ese valor en un `0` que se vuelve a asignar más adelante. Comprueba que la entidad exista antes de restaurarla:

```ts
function restoreCamera(previous: Entity | undefined) {
	const camera = MainCamera.getMutableOrNull(engine.CameraEntity)
	if (!camera) return
	// Only restore a camera that really exists, otherwise release control
	camera.virtualCameraEntity = previous && VirtualCamera.has(previous) ? previous : undefined
}
```

{% endhint %}

{% hint style="warning" %}
**📔 Nota**: Las áreas modificadoras de cámara solo afectan al jugador si no hay cámaras virtuales activas. Si la escena está usando una cámara virtual y el jugador entra en un área modificadora de cámara, no ocurre nada.

Si un modelo 3D incluye un nodo `camera` como parte de su contenido, el SDK no puede usarlo. Debes crear todas las cámaras como entidades con el SDK.
{% endhint %}

```ts
function main() {
	// custom virtual camera
	const myCustomCamera = engine.addEntity()
	Transform.create(myCustomCamera, {
		position: Vector3.create(1, 2, 1),
	})
	VirtualCamera.create(myCustomCamera, {})

	const mainCamera = MainCamera.createOrReplace(engine.CameraEntity, {
		virtualCameraEntity: myCustomCamera,
	})

	// clickable cube
	const clickCube = engine.addEntity()
	Transform.create(clickCube, { position: Vector3.create(8, 0, 8) })
	MeshRenderer.setBox(clickCube)
	MeshCollider.setBox(clickCube)
	pointerEventsSystem.onPointerDown(
		{
			entity: clickCube,
			opts: { button: InputAction.IA_POINTER, hoverText: 'Reset camera' },
		},
		() => {
			// reset camera to default behavior
			const mainCamera = MainCamera.getMutable(engine.CameraEntity)
			mainCamera.virtualCameraEntity = undefined
		}
	)
}
```

{% hint style="info" %}
**💡 Consejo**: Cuando la cámara se aleja del Avatar, suele ser buena práctica también congelar los movimientos del Avatar. Así, el jugador no se mueve a ciegas y choca con obstáculos. Consulta [Modificadores de entrada](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/avatares/locomotion.md#freeze-the-player)
{% endhint %}

Para permitir que el jugador dirija una cámara virtual con el mouse, lee la `screenDelta` propiedad del componente `PrimaryPointerInfo` para ver cuánto se movió el cursor en cada frame y, luego, aplica ese movimiento a la rotación de la cámara. Esto funciona incluso cuando el cursor está bloqueado. Consulta [Movimiento del mouse](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/mouse-movement.md) para ver un ejemplo completo de control de cámara con el mouse.

## Vista aérea

Puedes usar una cámara virtual para ver la escena desde arriba. Esto puede ser una variación divertida de la perspectiva habitual de tu Avatar y permitir diferentes mecánicas de juego.

Evita colocar una cámara que mire exactamente hacia abajo. En su lugar, inclínala siempre un poco; incluso 1 grado es suficiente. Esto se debe a que los controles de dirección del jugador se basan en la perspectiva de la cámara, no en la orientación del Avatar. Si la cámara mira directamente desde arriba, no hay una definición clara de cuál es cada dirección. Una inclinación imperceptible de 1 grado basta para establecer una dirección hacia delante.

```ts
function main() {
	// cámara con vista aérea
	const myCustomCamera = engine.addEntity()
	Transform.create(myCustomCamera, {
		position: Vector3.create(8, 5, 8),
		rotation: Quaternion.fromEulerDegrees(91, 0, 0),
		// Ten en cuenta que la rotación es de 91º, no de 90º
	})
	VirtualCamera.create(myCustomCamera, {})

	const mainCamera = MainCamera.createOrReplace(engine.CameraEntity, {
		virtualCameraEntity: myCustomCamera,
	})
}
```

## Campo de visión

Puedes establecer un campo de visión (FOV) personalizado en una cámara virtual con la propiedad `fov` El valor se expresa en grados. Establécelo siempre: no hay un valor predeterminado al que recurrir, y una cámara sin `fov` hereda la lente que dejó una cámara anterior que utilizó la misma instancia agrupada.

```ts
VirtualCamera.create(myCustomCamera, {
	fov: 90,
})
```

Un FOV más amplio (valor más alto) muestra más elementos de la escena a la vez y crea una sensación de velocidad, lo que puede ser útil en juegos de carreras. Un FOV más estrecho (valor más bajo) acerca la imagen y es útil para apuntar o para tomas cinematográficas.

### Cambiar el nivel de zoom

El cliente lee `fov` solo cuando una cámara se activa. Cambiar `fov` en la cámara que ya está activa no produce ningún efecto.

Para acercar o alejar la imagen, crea una cámara virtual por cada nivel de zoom y cambia `MainCamera.virtualCameraEntity` entre ellas:

```ts
import { engine, MainCamera, Transform, VirtualCamera } from '@dcl/sdk/ecs'
import { Vector3 } from '@dcl/sdk/math'

// Dos cámaras en la misma posición: una con un campo de visión amplio y otra acercada
const position = Vector3.create(8, 2, 8)

const wideCamera = engine.addEntity()
Transform.create(wideCamera, { position })
VirtualCamera.create(wideCamera, { fov: 70 })

const zoomedCamera = engine.addEntity()
Transform.create(zoomedCamera, { position })
VirtualCamera.create(zoomedCamera, { fov: 30 })

// Cambia entre ellas para acercar o alejar la imagen
function zoomIn() {
	MainCamera.createOrReplace(engine.CameraEntity, { virtualCameraEntity: zoomedCamera })
}

function zoomOut() {
	MainCamera.createOrReplace(engine.CameraEntity, { virtualCameraEntity: wideCamera })
}
```

Volver a asignar la cámara que ya está activa tampoco produce ningún efecto, así que cambia a una entidad distinta cada vez.

## Transiciones de cámara

Cada vez que la escena cambia de una cámara virtual a otra, o entre el comportamiento predeterminado de la cámara y las cámaras virtuales, los jugadores ven una transición. La posición, la rotación y los demás parámetros de la cámara virtual cambian suavemente durante un período de tiempo.

La configuración de transición de una cámara virtual determina cómo se realiza la transición *a* esa cámara, desde cualquier otra cámara de la escena, incluida la predeterminada. No afectan a la forma en que haces la transición *desde* esa cámara.

Al volver a la cámara del propio jugador, cuando borras el `virtualCameraEntity` de `MainCamera`, siempre se aplica una transición fija de 0,5 segundos, con una aceleración y desaceleración suaves. El `defaultTransition` de la cámara virtual que dejas no lo cambia.

```ts
VirtualCamera.create(myCustomCamera1, {
	defaultTransition: { transitionMode: VirtualCamera.Transition.Time(6) },
})
```

{% hint style="info" %}
**💡 Consejo**: Para evitar una transición y cambiar a una cámara al instante, establece en 0 el tiempo o la velocidad de transición.
{% endhint %}

Según tu caso de uso, puede que prefieras establecer la velocidad de la transición en lugar de su duración:

* **Tiempo fijo**: Estableces la duración de la transición y la cámara se moverá a la velocidad necesaria para completar el recorrido en ese intervalo de tiempo.
* **Velocidad fija**: Estableces la velocidad a la que quieres que se mueva la cámara virtual durante la transición; la duración dependerá de la distancia. El valor de velocidad se interpreta como **metros por segundo**.

A continuación se muestran ejemplos de ambos modos de transición:

```ts
// fixed duration
VirtualCamera.create(myCustomCamera1, {
	defaultTransition: { transitionMode: VirtualCamera.Transition.Time(6) },
})

// fixed speed
VirtualCamera.create(myCustomCamera1, {
	defaultTransition: { transitionMode: VirtualCamera.Transition.Speed(3) },
})
```

A continuación se muestra un ejemplo completo con dos cámaras virtuales y transiciones entre ellas:

```ts
function main() {
	// custom virtual camera 1
	const myCustomCamera1 = engine.addEntity()
	Transform.create(myCustomCamera1, {
		position: Vector3.create(1, 2, 1),
	})
	VirtualCamera.create(myCustomCamera1, {
		defaultTransition: { transitionMode: VirtualCamera.Transition.Time(1) },
	})

	// custom virtual camera 2
	const myCustomCamera2 = engine.addEntity()
	Transform.create(myCustomCamera2, {
		position: Vector3.create(1, 2, 1),
	})
	VirtualCamera.create(myCustomCamera2, {
		defaultTransition: { transitionMode: VirtualCamera.Transition.Time(3) },
	})

	const mainCamera = MainCamera.createOrReplace(engine.CameraEntity, {
		virtualCameraEntity: myCustomCamera1,
	})

	// clickable cube
	const clickCube = engine.addEntity()
	Transform.create(clickCube, { position: Vector3.create(8, 0, 8) })
	MeshRenderer.setBox(clickCube)
	MeshCollider.setBox(clickCube)
	pointerEventsSystem.onPointerDown(
		{
			entity: clickCube,
			opts: { button: InputAction.IA_POINTER, hoverText: 'Reset camera' },
		},
		() => {
			// reset camera to default behavior
			const mainCamera = MainCamera.getMutable(engine.CameraEntity)
			mainCamera.virtualCameraEntity =
				mainCamera.virtualCameraEntity == myCustomCamera1
					? myCustomCamera2
					: myCustomCamera1
		}
	)
}
```

Las transiciones siempre siguen una línea recta, sin tener en cuenta los obstáculos del recorrido. En su lugar, puedes crear una transición manual usando otra cámara virtual como intermediaria, lo que te dará control total sobre sus movimientos. Esta cámara virtual intermediaria podría realizar un [Tween](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/move-entities.md#move-between-two-points) desde la posición de la primera cámara hasta la posición de la segunda, o seguir un recorrido más personalizado que evite obstáculos o incluya un desvío cinematográfico.

## Seguimiento de la cámara

Puedes configurar una cámara virtual para que siempre apunte en la dirección del jugador o hacia una entidad específica de la escena. La posición de la cámara permanecerá estática, pero su rotación cambiará para mantener siempre centrada a esta entidad.

Esto se puede conseguir con la propiedad `lookAtEntity` del componente `VirtualCamera` . Para seguir al jugador, usa la [entidad reservada](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/arquitectura/entities-components.md#reserved-entities) `engine.PlayerEntity`.

```ts
const myCustomCamera1 = engine.addEntity()
Transform.create(myCustomCamera1, {
	position: Vector3.create(1, 2, 1),
})
VirtualCamera.create(myCustomCamera1, {
	lookAtEntity: engine.PlayerEntity,
})
```

Si la cámara sigue a una entidad, esto solo cambiará la rotación, no la posición de la cámara.

A medida que gira la cámara, el Transform de la entidad que tiene el componente `VirtualCamera` no cambia. Sin embargo, puedes leer la rotación de la cámara desde el Transform de `engine.CameraEntity`. La rotación y la posición de esta entidad serán absolutas; no estarán condicionadas por las de la entidad que tiene el componente `VirtualCamera` La rotación de este Transform se ve afectada por el comportamiento `lookAtEntity` .

{% hint style="warning" %}
**📔 Nota**: Si configuras la cámara virtual con un `lookAtEntity` que haga referencia a la misma entidad que contiene la cámara virtual, o a la entidad `engine.CameraEntity` , el comportamiento resultante será el mismo que si no asignaras ninguna entidad.
{% endhint %}

## Adjuntarla al jugador

Otro uso de la cámara virtual es seguir al jugador desde una distancia o un ángulo personalizados, adjuntando una cámara virtual a la entidad del jugador. Ten en cuenta que el jugador no puede cambiar libremente la rotación de la cámara, por lo que, en este caso, la rotación de la cámara quedará fijada según la de la cámara virtual. Esto puede ser útil, por ejemplo, en juegos de carreras, en los que se espera que el jugador mire siempre hacia delante.

```ts
function main() {
	const myCustomCamera = engine.addEntity()
	Transform.create(myCustomCamera, {
		position: Vector3.create(0, 1, 5),
		parent: engine.PlayerEntity,
	})
	VirtualCamera.create(myCustomCamera, {
		defaultTransition: { transitionMode: VirtualCamera.Transition.Time(2) },
	})

	const mainCamera = MainCamera.createOrReplace(engine.CameraEntity, {
		virtualCameraEntity: myCustomCamera,
	})
}
```

## Cámaras y colliders

Cuando la cámara de un jugador se mueve en modo de tercera persona, los colliders pueden bloquearla o no, según las capas de colisión asignadas a las entidades. Ten esto en cuenta al diseñar tu escena; quizá quieras evitar que la cámara atraviese paredes u otras entidades.

Consulta [Colliders](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/colliders.md#cameras-and-colliders) para obtener más detalles sobre cómo configurar los colliders de tu escena.

## Modo de espectador (cámara de observador)

Puedes crear un modo de espectador que cambie el movimiento normal del avatar del jugador por una cámara de movimiento libre o que siga a otros jugadores. Esto resulta útil para los roles de observador en juegos competitivos, las cámaras de dirección de eventos en directo o los sistemas de repetición.

Este patrón combina varias funciones del SDK:

| Función                             | API del SDK                               | Propósito                                                      |
| ----------------------------------- | ----------------------------------------- | -------------------------------------------------------------- |
| Vista de cámara personalizada       | `VirtualCamera` + `MainCamera`            | Reemplaza la cámara del jugador                                |
| Congelar el movimiento del avatar   | `InputModifier` (`disableAll: true`)      | Libera WASD para controlar la cámara                           |
| Seguir a los jugadores de la escena | `onEnterScene` / `onLeaveScene`           | Crea una lista de objetivos a los que seguir                   |
| Controles de cámara                 | `inputSystem.isPressed(InputAction.IA_*)` | WASD para controlar la inclinación y el giro; E/F para el zoom |
| Mirar con el ratón                  | `PrimaryPointerInfo.screenDelta`          | Girar la cámara con el ratón                                   |

### Arquitectura del rig de cámara

Usa un **rig de dos entidades** para que el yaw y el pitch sean independientes:

```
rigRoot (entidad)           -- posición en el mundo + rotación de yaw
└── rigCamera (hija)       -- rotación de pitch + desplazamiento de órbita
    └── VirtualCamera
```

`rigRoot` controla el yaw (giro a izquierda/derecha) y se interpola hacia el objetivo de seguimiento o un pivote de cámara libre. `rigCamera` controla el pitch (inclinación hacia arriba/abajo) y la distancia de órbita desde la raíz. Al separar el yaw y el pitch en dos Transforms, las operaciones con ángulos de Euler son sencillas.

### Activar y desactivar

```ts
// Activar el modo espectador
const rigRoot = engine.addEntity()
Transform.create(rigRoot, {
  position: Vector3.create(8, 8, 8),
  rotation: Quaternion.fromEulerDegrees(0, 0, 0),
})

const rigCamera = engine.addEntity()
Transform.create(rigCamera, { parent: rigRoot })
VirtualCamera.create(rigCamera, {})

MainCamera.createOrReplace(engine.CameraEntity, { virtualCameraEntity: rigCamera })
InputModifier.createOrReplace(engine.PlayerEntity, {
  mode: InputModifier.Mode.Standard({ disableAll: true }),
})
```

```ts
// Desactivar el modo espectador
// IMPORTANTE: limpia MainCamera ANTES de eliminar la entidad VirtualCamera.
// Si eliminas primero la entidad, el motor sigue vinculado a una entidad inexistente
// y la vista cae a los pies del jugador.
const mainCamera = MainCamera.getMutableOrNull(engine.CameraEntity)
if (mainCamera) mainCamera.virtualCameraEntity = undefined

engine.removeEntity(rigCamera)
engine.removeEntity(rigRoot)

InputModifier.createOrReplace(engine.PlayerEntity, {
  mode: InputModifier.Mode.Standard({ disableAll: false }),
})
```

{% hint style="danger" %}
**Advertencia:** Limpia siempre `MainCamera.virtualCameraEntity` antes de eliminar la entidad de la cámara. Si eliminas primero la entidad, el motor conserva una referencia inexistente y la vista deja de funcionar.
{% endhint %}

### Límites de la cámara

El motor desactiva las `VirtualCamera` entidades que se desplazan fuera de los límites de las parcelas de la escena. Si la cámara sale del área de la escena, deja de funcionar sin aviso. Limita la posición de la cámara para que permanezca dentro del cuadro delimitador alineado con los ejes (AABB) de la escena en cada frame, dejando un pequeño margen.

```ts
// Límites de ejemplo para una escena de una parcela de 1x1 (16 m x 16 m)
const BOUNDS_MIN = Vector3.create(0, 0, 0)
const BOUNDS_MAX = Vector3.create(16, 20, 16)
const BOUNDS_MARGIN = 0.5
```

En escenas más grandes, configura los límites para que coincidan con las parcelas de tu `scene.json` . El límite de altura de la escena es de 330 metros, independientemente del número de parcelas. Para una escena de 4x4 parcelas, podrías usar `Vector3.create(64, 330, 64)`.

### Seguir a jugadores

Usa `onEnterScene` y `onLeaveScene` para crear una lista en tiempo real de los jugadores de tu Scene. Después, los jugadores pueden ir cambiando entre los objetivos de seguimiento con las teclas (por ejemplo, `IA_ACTION_3` y `IA_ACTION_4`). Al seguir a un jugador, la raíz del rig se interpola hacia la posición Transform del jugador seguido, y la cámara secundaria orbita a una distancia configurable.

```ts
import { onEnterScene, onLeaveScene } from '@dcl/sdk/src/players'

const playerEntities = new Map<string, Entity>()
let playerIds: string[] = []

onEnterScene((player) => {
  if (!player) return
  playerIds.push(player.userId)
  playerEntities.set(player.userId, player.entity)
})

onLeaveScene((userId) => {
  if (!userId) return
  playerIds = playerIds.filter((id) => id !== userId)
  playerEntities.delete(userId)
})
```

Para seguir a un jugador en cada frame, interpola la raíz del rig hacia su posición:

```ts
const followEntity = playerEntities.get(followTargetId)
if (followEntity) {
  const targetPos = Transform.get(followEntity).position
  const rootTransform = Transform.getMutable(rigRoot)
  rootTransform.position = Vector3.lerp(
    rootTransform.position,
    Vector3.add(targetPos, Vector3.create(0, 1, 0)),
    0.1
  )
}
```

Consulta [El jugador entra o sale de la Scene](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/event-listeners.md#player-enters-or-leaves-scene) para obtener más información sobre `onEnterScene` y `onLeaveScene`.

### Controlar la cámara con el mouse al observar

Lee `PrimaryPointerInfo.screenDelta` en cada frame para girar la cámara con el mouse. Esto funciona mientras el puntero está bloqueado. Consulta [Movimiento del mouse](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/mouse-movement.md) para ver un ejemplo completo de control de la cámara con el mouse.

```ts
const MOUSE_SENSITIVITY = 0.15 // degrees per pixel
let yaw = 0
let pitch = 45

function spectateMouseLook() {
  const isLocked = PointerLock.getOrNull(engine.CameraEntity)?.isPointerLocked ?? false
  if (!isLocked) return

  const delta = PrimaryPointerInfo.getOrNull(engine.RootEntity)?.screenDelta
  if (!delta) return

  yaw = (yaw + delta.x * MOUSE_SENSITIVITY) % 360
  // delta.y crece hacia abajo, por lo que mover el mouse hacia arriba da un valor negativo: sumarlo inclina la cámara hacia arriba; limita el valor para evitar que se voltee
  pitch = Math.max(-25, Math.min(80, pitch + delta.y * MOUSE_SENSITIVITY))
}
```

{% hint style="warning" %}
**Nota:** `screenDelta` solo está disponible en escritorio. En dispositivos móviles siempre devuelve `0`. Si tu Scene está pensada para dispositivos móviles, diseña una alternativa basada en controles táctiles.
{% endhint %}

### Implementación de referencia completa

La [`33,20-spectate-mode`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/33,20-spectate-mode) scene de prueba contiene un module independiente de modo espectador en `src/spectate.ts`. Admite modos de cámara libre y de seguimiento, controles WASD y de orientación con el ratón, alternancia entre jugadores, zoom de distancia orbital, limitación a los límites definidos y un HUD en pantalla que muestra los controles y el objetivo de seguimiento actual.

Para usarlo en tu propio proyecto:

1. Copia `src/spectate.ts` en tu scene.
2. Haz Update de `PIVOT`, `BOUNDS_MIN`y `BOUNDS_MAX` al principio del file para que coincidan con los parcels de tu scene. Este es el error de integración más común.
3. Conecta `toggleSpectate()` a cualquier trigger: una entity en la que se pueda hacer click, un button de la UI o la pulsación de una tecla.

{% hint style="info" %}
**💡 Consejo**: Para ver ejemplos funcionales de control de cámara, consulta la [`2,22-virtual-cameras`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/2,22-virtual-cameras) scene de prueba, que alterna entre varias `VirtualCamera` entities a través de `MainCamera` , incluidas `lookAtEntity` orientada hacia el jugador y una cámara animada mediante Tween; [`32,20-virtual-camera-mouse-look`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/32,20-virtual-camera-mouse-look), que controla una cámara orientada con el ratón mientras el pointer está bloqueado; [`33,20-spectate-mode`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/33,20-spectate-mode), que implementa una cámara de espectador completa con modos de seguimiento y cámara libre; y [`9,99-modifier-areas`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/9,99-modifier-areas), que impone un modo de cámara dentro de un volumen mediante `CameraModeArea`.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/camera.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
