> 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-pt/scenes-sdk7/fundamentos-de-conteudo-3d/camera.md). # Câmera Saiba como controlar a câmera do jogador Como criador, você pode ter controle total sobre a câmera do player. Por padrão, os players são livres para escolher entre um modo de câmera em 1ª ou 3ª pessoa enquanto exploram sua scene, mas você pode impor uma modalidade de câmera diferente. As câmeras virtuais podem ser estáticas, podem girar para sempre olhar para o player ou para alguma outra entity, ou podem ser anexadas ao player ou a alguma outra entity para que estejam sempre acompanhando. {% hint style="warning" %} **📔 Observação**: Para alternar entre as câmeras padrão de 1ª e 3ª pessoa, veja [Áreas modificadoras de câmera](#1st-and-3rd-person-camera-modes). {% endhint %} ## modos de câmera em 1ª e 3ª pessoa Normalmente, os players podem alternar livremente entre a câmera em primeira e terceira pessoa pressionando V no teclado. Use uma `CameraModeArea` para forçar o modo de câmera para 1ª ou 3ª pessoa para todos os players que fiquem dentro de uma área específica na sua scene. ```ts const entity = engine.addEntity() CameraModeArea.create(entity, { area: Vector3.create(4, 3, 4), mode: CameraType.CT_FIRST_PERSON, }) ``` Se o modo de câmera atual de um player não corresponder ao da `CameraModeArea`, eles farão a transição para esse modo de câmera. Um toast aparece na tela para esclarecer que essa mudança se deve à scene. Enquanto estiverem dentro, os players não podem alterar o modo de câmera. Quando um player sair da `CameraModeArea`, o modo de câmera será restaurado para o que ele tinha antes de entrar. Use `CameraModeArea` em regiões onde os players teriam uma experiência significativamente melhor usando um modo de câmera específico. Por exemplo, a primeira pessoa é ideal se o player precisar clicar em um objeto pequeno, ou a terceira pessoa pode ser útil para os players perceberem alguma entity que a sua scene tenha anexado acima da cabeça deles. Não presuma que os players saibam como alternar os modos de câmera; muitos players de primeira viagem podem não saber que têm essa opção, ou não lembrar a tecla para fazer isso. {% hint style="warning" %} **📔 Observação**: As áreas modificadoras de câmera são afetadas pelo *position* e *rotation* da Transform component da host entity, mas não são afetadas pelo *scale*. {% endhint %} {% hint style="warning" %} **📔 Observação**: Se você sobrepor várias áreas modificadoras de câmera, a última a ser instanciada pelo código da sua scene terá prioridade sobre as outras. {% endhint %} Ao criar um `CameraModeArea` component, você deve fornecer o seguinte: * `area`: Tamanho da área modificadora * `mode`: Qual modo de câmera forçar nesta área, a partir do `CameraType` . Os modos de câmera suportados são: * `CameraType.CT_FIRST_PERSON` * `CameraType.CT_THIRD_PERSON` ### Consultar o modo de câmera Você pode consultar o modo de câmera do player usando o `CameraMode` component na `engine.CameraEntity`. ```ts const cameraMode = CameraMode.get(engine.CameraEntity) if (cameraMode.mode === CameraType.CT_FIRST_PERSON) { console.log('O player está usando a câmera em 1ª pessoa') } else { console.log('O player está usando a câmera em 3ª pessoa') } ``` Você também pode se inscrever para alterações no modo de câmera usando o `onChange` função no `CameraMode` component. ```ts CameraMode.onChange(engine.CameraEntity, (cameraMode) => { if (!cameraMode) return console.log('O modo de câmera do player mudou para', cameraMode.mode) }) ``` ## Usando câmeras virtuais Para usar um comportamento de câmera personalizado na sua scene, você precisa de duas coisas: * Criar uma Virtual Camera: Crie uma entity na sua scene e dê a ela uma `VirtualCamera`. * Atribuir essa câmera virtual: Adicione uma `MainCamera` componente na [entidade reservada](/creator/content-creator-pt/scenes-sdk7/arquitetura/entities-components.md#reserved-entities) `engine.CameraEntity`, com uma referência à entity com a `VirtualCamera` component. A câmera então será anexada à entity com o `VirtualCamera` component. Se a entity se mover ou girar, a câmera se moverá com ela. ```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, }) } ``` Neste exemplo, a câmera estará sempre em uma posição fixa na scene, contanto que o player permaneça dentro dos limites da scene. Assim que o player sair dos limites da scene, o comportamento padrão da câmera será restaurado. ### Campo de visão Você pode substituir o campo de visão padrão (FOV) do Explorer para uma câmera virtual definindo a `fov` propriedade, em graus. A substituição se aplica apenas enquanto essa câmera virtual estiver ativa. Se omitido, `fov` usa o padrão do Explorer (normalmente 60 graus). ```ts const cinematicCamera = engine.addEntity() Transform.create(cinematicCamera, { position: Vector3.create(8, 3, 2), }) VirtualCamera.create(cinematicCamera, { fov: 45, }) ``` Um FOV mais estreito (valor menor) dá zoom, útil para cutscenes ou mira. Um FOV mais amplo (valor maior) mostra mais da scene, útil para vistas panorâmicas. Sua scene pode incluir quantas entities com um `VirtualCamera`component quiser, e alternar dinamicamente entre várias câmeras virtuais à medida que o player se move, ou conforme realiza certas ações. Apenas uma câmera virtual fica ativa em qualquer momento, isso é atribuído pela `MainCamera` componente em `engine.CameraEntity`. Para voltar ao comportamento padrão da câmera, defina o valor para `undefined` em `MainCamera.virtualCameraEntity`. O player então fica livre para alternar entre as câmeras de 1ª e 3ª pessoa. Se você quiser que o player use apenas um desses dois modos, você pode usar um [Áreas modificadoras de câmera](#1st-and-3rd-person-camera-modes) para forçar um dos dois. {% hint style="warning" %} **📔 Observação**: As áreas modificadoras de câmera só têm efeito no player se nenhuma câmera virtual estiver ativa. Se a scene estiver usando uma câmera virtual e o player entrar em uma área modificadora de câmera, nada acontece. Se um modelo 3D incluir um `camera` node como parte do seu conteúdo, isso não pode ser usado pelo SDK. Você deve criar todas as câmeras como entities com o SDK. {% endhint %} ```ts function main() { // virtual camera personalizada const myCustomCamera = engine.addEntity() Transform.create(myCustomCamera, { position: Vector3.create(1, 2, 1), }) VirtualCamera.create(myCustomCamera, {}) const mainCamera = MainCamera.createOrReplace(engine.CameraEntity, { virtualCameraEntity: myCustomCamera, }) // cubo clicável 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: 'Redefinir câmera' }, }, () => { // redefinir a câmera para o comportamento padrão const mainCamera = MainCamera.getMutable(engine.CameraEntity) mainCamera.virtualCameraEntity = undefined } ) } ``` {% hint style="info" %} **💡 Dica**: Quando a câmera se afasta do avatar, geralmente é uma boa prática também congelar os movimentos do avatar. Dessa forma, o player não anda às cegas para dentro de obstáculos. Veja [Input Modifiers](/creator/content-creator-pt/scenes-sdk7/interatividade/avatares/locomotion.md#freeze-the-player) {% endhint %} Para permitir que o player direcione uma câmera virtual com o mouse, leia o `screenDelta` property do `PrimaryPointerInfo` component para ver até onde o cursor se moveu em cada frame e então aplique esse movimento à rotação da câmera. Isso funciona mesmo enquanto o cursor está bloqueado. Veja [Movimento do mouse](/creator/content-creator-pt/scenes-sdk7/interatividade/mouse-movement.md) para um exemplo completo de mouselook. ## Vista aérea Você pode usar uma câmera virtual para ver a scene de uma vista de cima para baixo; isso pode ser uma variação divertida da perspectiva normal do seu avatar e habilitar diferentes mecânicas de jogo. Você deve evitar colocar uma câmera olhando em uma direção perfeitamente reta para baixo. Em vez disso, incline sempre a câmera levemente, até 1 grau já basta. Isso acontece porque os controles de direção do player são baseados na perspectiva da câmera, não na orientação do avatar. Se a câmera estiver olhando de uma vista aérea perfeita, não há uma definição clara de qual direção é qual. Uma inclinação imperceptível de 1 grau é suficiente para estabelecer uma direção para frente. ```ts function main() { // câmera de vista aérea const myCustomCamera = engine.addEntity() Transform.create(myCustomCamera, { position: Vector3.create(8, 5, 8), rotation: Quaternion.fromEulerDegrees(91, 0, 0), // Observe que a rotação é 91º, não 90º }) VirtualCamera.create(myCustomCamera, {}) const mainCamera = MainCamera.createOrReplace(engine.CameraEntity, { virtualCameraEntity: myCustomCamera, }) } ``` ## Campo de visão Você pode definir um campo de visão personalizado (FOV) em uma câmera virtual com a `fov` propriedade. O valor é em graus. Se omitido, o padrão é 60. ```ts VirtualCamera.create(myCustomCamera, { fov: 90, }) ``` Um FOV mais amplo (valor maior) mostra mais da scene de uma vez e cria uma sensação de velocidade, o que pode ser útil para jogos de corrida. Um FOV mais estreito (valor menor) dá zoom e é útil para mira ou planos cinematográficos. ## Transições de câmera Sempre que a scene alterna entre câmeras virtuais, ou entre o comportamento padrão da câmera e câmeras virtuais, os players veem uma transição. A posição, a rotação e quaisquer outros parâmetros da câmera virtual mudam suavemente ao longo de um período de tempo. As configurações de transição em uma câmera virtual determinam como você faz a transição *para* essa câmera, a partir de qualquer outra câmera na scene, incluindo a padrão. Elas não afetam como você faz a transição *out* dessa câmera. ```ts VirtualCamera.create(myCustomCamera1, { defaultTransition: { transitionMode: VirtualCamera.Transition.Time(6) }, }) ``` {% hint style="info" %} **💡 Dica**: Para evitar uma transição e mudar instantaneamente para uma câmera, defina o tempo ou a velocidade da transição como 0. {% endhint %} Dependendo do seu caso de uso, você pode preferir definir a velocidade da transição em vez da duração: * **Tempo fixo**: Você define a duração da transição; a câmera se moverá tão rápido quanto precisar para completar o caminho nesse período de tempo. * **Velocidade fixa**: Você define o quão rápido deseja que a câmera virtual se mova durante a transição; a duração dependerá da distância. O valor usado para a velocidade é interpretado como **metros por segundo**. Abaixo estão exemplos para ambos esses modos de transição: ```ts // duração fixa VirtualCamera.create(myCustomCamera1, { defaultTransition: { transitionMode: VirtualCamera.Transition.Time(6) }, }) // velocidade fixa VirtualCamera.create(myCustomCamera1, { defaultTransition: { transitionMode: VirtualCamera.Transition.Speed(3) }, }) ``` Abaixo está um exemplo completo com duas câmeras virtuais, e transições entre elas: ```ts function main() { // câmera virtual personalizada 1 const myCustomCamera1 = engine.addEntity() Transform.create(myCustomCamera1, { position: Vector3.create(1, 2, 1), }) VirtualCamera.create(myCustomCamera1, { defaultTransition: { transitionMode: VirtualCamera.Transition.Time(1) }, }) // câmera virtual personalizada 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, }) // cubo clicável 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: 'Redefinir câmera' }, }, () => { // redefinir a câmera para o comportamento padrão const mainCamera = MainCamera.getMutable(engine.CameraEntity) mainCamera.virtualCameraEntity = mainCamera.virtualCameraEntity == myCustomCamera1 ? myCustomCamera2 : myCustomCamera1 } ) } ``` As transições sempre se movem em linha reta, sem considerar quaisquer obstáculos no caminho. Em vez disso, você poderia criar uma transição manualmente usando outra câmera virtual como intermediária; dessa forma você teria controle total sobre os movimentos dela. Essa câmera virtual intermediária poderia fazer um [Tween](/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/move-entities.md#move-between-two-points) do movimento da posição da primeira câmera até a posição da segunda câmera, ou seguir um caminho mais personalizado que evite obstáculos ou faça um desvio cinematográfico. ## Seguimento da câmera Você pode configurar uma câmera virtual para que ela sempre fique voltada na direção do player, ou de alguma entity específica na scene. A posição da câmera permanecerá estática, mas sua rotação mudará para manter essa entity sempre centralizada. Isso pode ser alcançado com o `lookAtEntity` property no `VirtualCamera` component. Para seguir o player, use o [entidade reservada](/creator/content-creator-pt/scenes-sdk7/arquitetura/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, }) ``` Se uma entity estiver sendo seguida pela câmera, isso só alterará a rotação, não a posição da câmera. À medida que a câmera gira, o Transform da entity com o `VirtualCamera` component não muda. No entanto, você pode ler a rotação da câmera a partir do Transform em `engine.CameraEntity`. A rotação e a posição dessa entity serão absolutas; elas não serão condicionadas pelas da entity com o `VirtualCamera` component. A rotação desse transform é afetada pelo comportamento `lookAtEntity` . {% hint style="warning" %} **📔 Observação**: Se você configurar a câmera virtual com um `lookAtEntity` que faz referência à mesma entity que contém a câmera virtual, ou à `engine.CameraEntity` entity, o comportamento resultante será o mesmo que não atribuir nenhuma entity. {% endhint %} ## Anexar ao player Outro uso da câmera virtual é seguir o player a uma distância ou ângulo personalizados, anexando uma câmera virtual à entity do player. Note que o player não pode alterar livremente a rotação da câmera, então, nesse caso, a rotação da câmera ficará fixa à da câmera virtual. Isso pode ser útil, por exemplo, para jogos de corrida, nos quais se espera que o player esteja sempre olhando para frente. ```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âmeras e colliders Quando a câmera de um jogador se move no modo de terceira pessoa, a câmera pode ser bloqueada por colliders ou não, dependendo das layers de colisão atribuídas às entities. Tenha isso em mente ao projetar sua scene; talvez você queira impedir que a câmera atravesse paredes ou outras entities. Veja [Colliders](/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/colliders.md#cameras-and-colliders) para mais detalhes sobre como configurar colliders para a sua scene. ## Modo espectador (câmera de observador) Você pode construir um modo espectador que alterna o player do movimento normal do avatar para uma câmera de livre exploração ou que segue o player. Isso é útil para funções de observador em jogos competitivos, câmeras de diretor para eventos ao vivo ou sistemas de replay. O padrão combina vários recursos do SDK: | Recurso | API do SDK | Propósito | | ------------------------------ | ----------------------------------------- | ------------------------------------ | | Visão de câmera personalizada | `VirtualCamera` + `MainCamera` | Substitui a câmera do player | | Congelar movimento do avatar | `InputModifier` (`disableAll: true`) | Libera WASD para controlar a câmera | | Rastrear players na scene | `onEnterScene` / `onLeaveScene` | Constrói uma lista de alvos a seguir | | Controles da câmera | `inputSystem.isPressed(InputAction.IA_*)` | WASD para pitch/yaw, E/F para zoom | | Controle da câmera com o mouse | `PrimaryPointerInfo.screenDelta` | Girar a câmera com o mouse | ### Arquitetura do rig da câmera Use um **rig de duas entities** para que yaw e pitch permaneçam independentes: ``` rigRoot (entity) -- posição no mundo + rotação de yaw └── rigCamera (child) -- rotação de pitch + deslocamento de órbita └── VirtualCamera ``` `rigRoot` mantém o yaw (giro esquerda/direita) e é interpolado em direção ao alvo seguido ou a um pivô de free-cam. `rigCamera` cuida do pitch (inclinação para cima/baixo) e da distância de órbita a partir da raiz. Separar yaw e pitch em dois Transforms mantém a matemática de Euler simples. ### Ativar e desativar ```ts // Ativar o 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 // Desativar o modo espectador // IMPORTANTE: limpe MainCamera ANTES de remover a entity VirtualCamera. // Se você remover a entity primeiro, o engine continua vinculado a uma referência morta // e a visão cai para os pés do player. 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" %} **Aviso:** Sempre limpe `MainCamera.virtualCameraEntity` antes de remover a entity da câmera. Remover a entity primeiro deixa o engine apontando para uma referência morta, fazendo a visão quebrar. {% endhint %} ### Limites da câmera O engine desabilita `VirtualCamera` entities que saem dos limites de parcel da sua scene. Se a câmera sair da área da scene, ela para de funcionar silenciosamente. Limite a posição da câmera para permanecer dentro da caixa delimitadora alinhada aos eixos (AABB) da scene a cada frame, com uma pequena margem. ```ts // Exemplo de limites para uma scene de 1x1 parcel (16m x 16m) const BOUNDS_MIN = Vector3.create(0, 0, 0) const BOUNDS_MAX = Vector3.create(16, 20, 16) const BOUNDS_MARGIN = 0.5 ``` Para scenes maiores, defina os limites para corresponder aos seus `scene.json` parcels. O limite de altura da scene é 330 metros independentemente da quantidade de parcels. Uma scene de 4x4 parcels poderia usar `Vector3.create(64, 330, 64)`. ### Seguindo players Use `onEnterScene` e `onLeaveScene` para construir uma lista ao vivo de players na sua scene. Os players podem então alternar entre alvos a seguir com teclas (por exemplo, `IA_ACTION_3` e `IA_ACTION_4`). Ao seguir um player, a raiz do rig interpola em direção à posição do Transform do player seguido, e a câmera filha orbita a uma distância configurável. ```ts import { onEnterScene, onLeaveScene } from '@dcl/sdk/src/players' const playerEntities = new Map() 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 um player a cada frame, interpole a raiz do rig em direção à posição dele: ```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 ) } ``` Veja [Player entra ou sai da scene](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-enters-or-leaves-scene) para mais sobre `onEnterScene` e `onLeaveScene`. ### Controle do mouse enquanto espectando Leia `PrimaryPointerInfo.screenDelta` a cada frame para girar a câmera com o mouse. Isso funciona enquanto o pointer está bloqueado. Veja [Movimento do mouse](/creator/content-creator-pt/scenes-sdk7/interatividade/mouse-movement.md) para um exemplo completo de mouselook. ```ts const MOUSE_SENSITIVITY = 0.15 // graus por 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 cresce para baixo, então mover o mouse para cima é negativo: adicioná-lo inclina a câmera para cima; limite para evitar inversão pitch = Math.max(-25, Math.min(80, pitch + delta.y * MOUSE_SENSITIVITY)) } ``` {% hint style="warning" %} **Observação:** `screenDelta` é exclusivo para desktop. No mobile ele sempre informa `0`. Se a sua scene for voltada para mobile, crie uma alternativa baseada em toque. {% endhint %} ### Implementação completa de referência O [`33,20-spectate-mode`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/33,20-spectate-mode) a cena de teste contém um módulo de espectador autônomo em `src/spectate.ts`. Ele suporta os modos free-cam e follow-cam, controles WASD + mouse-look, alternância entre players, zoom da distância de órbita, limitação aos limites e um HUD na tela mostrando os controles e o alvo atual seguido. Para usá-lo no seu próprio projeto: 1. Copiar `src/spectate.ts` na sua scene. 2. Atualizar `PIVOT`, `BOUNDS_MIN`, e `BOUNDS_MAX` no topo do arquivo para corresponder aos parcels da sua scene. Esse é o erro de integração mais comum. 3. Conecte `toggleSpectate()` a qualquer gatilho: uma entity clicável, um botão de UI ou uma tecla. {% hint style="info" %} **💡 Dica**: Para exemplos funcionais de controle de câmera, veja a [`2,22-virtual-cameras`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/2,22-virtual-cameras) scene de teste, que alterna várias `VirtualCamera` entities através de `MainCamera` incluindo `lookAtEntity` apontada para o player e uma câmera com tween; [`32,20-virtual-camera-mouse-look`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/32,20-virtual-camera-mouse-look), que aciona uma câmera mouselook enquanto o pointer está bloqueado; [`33,20-spectate-mode`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/33,20-spectate-mode), que implementa uma câmera completa de espectador/observador com modos follow-cam e free-cam; e [`9,99-modifier-areas`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/9,99-modifier-areas), que força um modo de câmera dentro de um volume com `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-pt/scenes-sdk7/fundamentos-de-conteudo-3d/camera.md?ask=&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.