> 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/arquitetura/entities-components.md).

# Entities e Components

Aprenda o essencial sobre entities e components em uma scene do Decentraland

As cenas de Decentraland são construídas em torno de [*entities*, *components* e *systems*](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system). Este é um padrão comum na arquitetura de vários motores de jogo, que permite uma composição e escalabilidade fáceis.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-47dcd6cd9846e4d62d320e0ba061c9261d2e4f2a%2Fecs-big-picture.webp?alt=media)

## Visão geral

*Entities* são a unidade básica para construir tudo nas cenas de Decentraland. Todos os objetos 3D visíveis e invisíveis e os reprodutores de áudio da sua cena serão, cada um, uma entity. Uma entity não é mais do que um ID ao qual os components podem fazer referência. A entity em si não tem propriedades nem métodos próprios; serve simplesmente para agrupar vários components.

*Components* definem as características de uma entity. Por exemplo, um component `Transform` armazena as coordenadas, a rotação e a escala da entity. Um component `MeshRenderer` dá à entity uma forma visível (como um cubo ou uma esfera) quando é renderizada na cena; um component `Material` dá à entity uma cor ou textura. Também pode criar components personalizados para armazenar os dados necessários à sua cena. Por exemplo, um component personalizado `health` poderia armazenar o valor de saúde restante de uma entity e ser adicionado às entities que representam inimigos que não são jogadores num jogo.

Se estiver familiarizado com desenvolvimento Web, pense nas entities como o equivalente dos *elementos* numa árvore *DOM* , e nos components como *atributos* desses elementos.

No [Scene Editor no Creator Hub](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/primeiros-passos/about-editor.md), pode ver os components associados a uma entity selecionando-a.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-b7c82899df98d40a8760f7e0668ce2aaed751945%2Fcomponents-example.webp?alt=media)

{% hint style="warning" %}
**📔 Nota**: Nas versões anteriores do SDK, as Entities eram *objetos* instanciados e podiam ser expandidos para adicionar funções. A partir da versão 7.0 do SDK, as entities são apenas um ID. Esta estrutura adapta-se melhor aos princípios da [programação orientada a dados](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/data-oriented-programming.md) e pode melhorar o desempenho da cena.
{% endhint %}

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-a7a82338639fce594aa9a8459ae54b9579f3e0c1%2Fecs-components-new.webp?alt=media)

Components como `Transform`, `Material` ou qualquer um dos components de *forma* estão estreitamente ligados à renderização da cena. Se os valores destes components forem alterados, isso, por si só, basta para que o motor altere a forma como a cena é renderizada no frame seguinte.

O motor é a parte da cena que se encontra no centro e gere todas as outras partes. Determina que entities são renderizadas e como os jogadores interagem com elas. Também coordena que funções dos [systems](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/systems.md) são executadas e quando.

Os components destinam-se a armazenar dados sobre a entity a que fazem referência. Apenas podem armazenar esses dados; não os podem modificar por si próprios. Todas as alterações aos valores dos components são efetuadas pelos [Systems](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/systems.md). Os Systems são completamente independentes dos próprios components e entities. As entities e os components não têm conhecimento dos *systems* que atuam sobre eles.

## Sintaxe para entities e components

O exemplo abaixo mostra algumas operações básicas para declarar e configurar entities e components.

```ts
export function main() {
	// Criar uma entidade
	const door = engine.addEntity()

	// Dar uma posição à entidade através de um componente Transform
	Transform.create(door, {
		position: Vector3.create(5, 1, 5),
	})

	// Dar uma forma visível à entidade através de um componente GltfContainer
	GltfContainer.create(door, {
		src: 'assets/models/door.glb',
	})
}
```

{% hint style="warning" %}
**📔 Nota**: Nas versões anteriores do SDK, era necessário adicionar manualmente uma entidade ao engine para começar a renderizá-la. A partir da versão 7 do SDK, as entidades são adicionadas implicitamente ao engine assim que lhes é atribuído um componente.
{% endhint %}

Quando um componente é criado, é sempre atribuído a uma entidade principal. Os valores do componente afetam então a entidade.

{% hint style="info" %}
**💡 Sugestão**: Em vez de criar entidades uma a uma, pode criar de uma só vez uma árvore inteira de entidades e componentes a partir de um ficheiro [composite](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/composites.md) .
{% endhint %}

## Remover entidades

Para remover uma entidade do engine, use `engine.removeEntity()`. Esta função devolve um valor `boolean`: `true` se a entidade tiver sido removida, `false` se a remoção tiver sido recusada.

```ts
export function main() {
	// Criar uma entidade
	const door = engine.addEntity()

	// Dar uma forma visível à entidade através de um componente GltfContainer
	GltfContainer.create(door, {
		src: 'assets/models/door.glb',
	})

	// Remover entidade
	const removed = engine.removeEntity(door)
	console.log('Entity removed:', removed) // true
}
```

Se uma entidade removida tiver entidades filhas, estas passam a ter como entidade principal a predefinida `engine.RootEntity` entidade, que está posicionada na posição base da cena, com uma escala de *1*.

### Entidades reservadas pelo Renderer

Alguns IDs de entidade são reservados pelo Renderer para os avatares de jogadores remotos. Não pode remover estas entidades. Se chamar `engine.removeEntity()` numa entidade reservada pelo Renderer, a função devolve `false` e deixa todos os componentes intactos.

As [entidades reservadas com nome](#reserved-entities) (`engine.RootEntity`, `engine.PlayerEntity`, `engine.CameraEntity`) são um caso especial: `engine.removeEntity()` continua a devolver `false` para estas (os respetivos IDs nunca são libertados), mas os seus componentes **são** eliminados. Isto significa que pode limpar os seus próprios componentes destas entidades (por exemplo, removendo um `InputModifier` de `engine.PlayerEntity`), embora o próprio ID da Entity nunca seja libertado.

```ts
// A tentar remover uma Entity reservada
const result = engine.removeEntity(engine.PlayerEntity)
console.log(result) // false — o ID da Entity não é libertado
// Mas os Components da cena em PlayerEntity são removidos
```

Pode verificar o valor devolvido ao remover Entities para tratar casos extremos:

```ts
if (!engine.removeEntity(someEntity)) {
	console.log('Entity could not be removed (reserved)')
}
```

### Remover uma Entity com os respetivos filhos

Para remover uma Entity e também todos os seus filhos (e quaisquer filhos destes, recursivamente), utilize o `removeEntityWithChildren()` helper.

```ts
export function main() {
	// Criar a Entity principal
	const door = engine.addEntity()

	// Criar a Entity filha
	const doorKnob = engine.addEntity()

	// Dar uma forma visível às Entities
	GltfContainer.create(door, {
		src: 'models/door.glb',
	})
	GltfContainer.create(doorKnob, {
		src: 'models/doorKnob.glb',
	})

	// Principal
	Transform.create(doorKnob, {
		parent: door,
	})

	// Remover a Entity principal e as filhas
	removeEntityWithChildren(engine, door)
}
```

{% hint style="warning" %}
**Nota:** Se existir uma Entity reservada pelo renderer em qualquer ponto da árvore, `removeEntityWithChildren` remove todos os outros descendentes, mas mantém a Entity reservada. O valor de `Transform.parent` da Entity reservada apontará para uma Entity removida. Isto só acontece se a sua cena colocar uma Entity reservada como filha de uma Entity da cena, o que é pouco comum.
{% endhint %}

{% hint style="info" %}
**💡 Dica**: Em vez de remover uma Entity do engine, em alguns casos poderá ser melhor torná-la invisível, caso queira carregá-la novamente sem qualquer atraso. Consulte [Tornar invisível](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/shape-components.md#make-invisible)
{% endhint %}

### Remover Entities em segundo plano

Uma Entity é apenas um ID referenciado pelos seus Components. Por isso, ao remover uma Entity, está na verdade a remover cada um dos Components que a referenciam. Se remover manualmente todos os Components de uma Entity, o resultado para o jogador será igual ao de executar `engine.removeEntity()`. No entanto, `engine.removeEntity()` também realiza algumas tarefas internas adicionais, marcando o ID da Entity como já não utilizado, pelo que esta é sempre a forma recomendada de remover uma Entity.

## Entities aninhadas

Uma Entity pode ter outras Entities como filhas. Graças a isso, podemos organizar Entities em árvores, tal como o HTML de uma página Web.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-05ea75b83fc4f7f0d533368199638177ef38915b%2Fecs-nested-entities-new.webp?alt=media)

Para definir uma Entity como principal de outra, a Entity filha tem de ter um Component `Transform` Pode então definir o campo `parent` com uma referência à Entity principal.

```ts
export function main() {
	// Criar Entities
	const parentEntity = engine.addEntity()

	const childEntity = engine.addEntity()

	// Definir a Entity principal
	Transform.create(childEntity, {
		parent: parentEntity,
	})
}
```

Depois de atribuir uma Entity principal, é possível consultá-la na Entity filha através do campo `parent` do seu `Transform` componente.

```ts
// Obter o elemento principal de uma entidade
const parent = Transform.get(childEntity).parent
```

Se uma entidade principal tiver um `Transform` componente que afete a respetiva posição, escala ou rotação, as entidades filhas também serão afetadas. Os valores de posição ou rotação são somados, enquanto os valores de escala são multiplicados.

Se a entidade principal ou a entidade filha não tiver um `Transform` componente, serão usados os seguintes valores predefinidos.

* Para **posição**, o centro da entidade principal é *0, 0, 0*
* Para **rotação** a rotação da entidade principal é o quaternion *0, 0, 0, 1* (equivalente aos ângulos de Euler *0, 0, 0*)
* Para **escala**, considera-se que a entidade principal tem um tamanho de *1*. Qualquer redimensionamento da entidade principal afeta a escala e a posição proporcionalmente.

As entidades sem um componente de forma são invisíveis na cena. Podem ser usadas como contentores para gerir e posicionar várias entidades em grupo.

Para separar uma entidade filha da respetiva entidade principal, pode atribuir à entidade o valor `engine.RootEntity`.

```ts
const mutableChildTransform = Transform.getMutable(childEntity)
mutableChildTransform.parent = engine.RootEntity
```

{% hint style="warning" %}
**📔 Nota**: Ao lidar com entidades aninhadas sincronizadas com outros jogadores, use a função `parentEntity()` em vez da entidade `parent` em Transform. Consulte [Entidades com uma entidade principal](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/rede/serverless-multiplayer.md#parented-entities)
{% endhint %}

No Scene Editor, pode ver toda a hierarquia das entidades aninhadas na sua cena no painel à esquerda.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-55a529bfbd47e68e693cebfc82a98cb927678757%2Fentity-tree-example.webp?alt=media)

## Obter uma entidade por ID

Cada entidade na sua cena tem um número único *id*. Pode obter um componente referente a uma entidade específica do engine com base neste ID.

```typescript
// obter um componente Transform
Transform.get(1000 as Entity)
```

{% hint style="warning" %}
**📔 Nota**: Os IDs de entidade entre *0* e *511* são reservados pelo engine para entidades fixas, como o avatar do jogador, a cena base, etc.
{% endhint %}

Por exemplo, se um clique de um jogador ou um [raycast](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/raycasting.md) atingir uma entidade, será devolvido o ID da entidade atingida, e pode usar o comando acima para obter o componente Transform da entidade correspondente a esse ID. Também pode obter qualquer outro componente dessa entidade da mesma forma.

## Obter uma entidade por nome

Ao adicionar entidades através de arrastar e largar no Scene Editor, cada entidade tem um nome único. Use `engine.getEntityOrNullByName()` função para referenciar uma destas entidades no seu código. Passe o nome da entidade como uma string, tal como aparece na UI do Scene Editor, na vista em árvore à esquerda.

```ts
function main() {
	const door = engine.getEntityOrNullByName('door3')
}
```

{% hint style="warning" %}
**📔 Nota**: Certifique-se de que só utiliza `engine.getEntityOrNullByName()` dentro da função `main()` , em funções executadas depois de `main()`, ou num sistema. Se for utilizada fora destes contextos, as entidades criadas na UI do Scene Editor poderão ainda não estar instanciadas.
{% endhint %}

Pode executar qualquer ação numa entidade obtida através deste método, como adicionar ou remover Components, modificar valores de Components existentes ou remover a entidade do Engine.

```ts
function main() {
	// obter a Entity
	const door = engine.getEntityOrNullByName('door-3')
	// verificar se a Entity existe
	if (door) {
		// adicionar um callback de eventos de ponteiro
		pointerEventsSystem.onPointerDown(
			{
				entity: door,
				opts: { button: InputAction.IA_PRIMARY, hoverText: 'Open' },
			},
			function () {
				// abrir a porta
			}
		)
	}
}
```

Todas as entidades adicionadas através da UI do Scene Editor têm um Component `Name` , e pode iterar por todas elas da seguinte forma:

```ts
function main() {
	for (const [entity, name] of engine.getEntitiesWith(Name)) {
		console.log({ entity, name })
	}
}
```

## Adicionar ou substituir um Component

Cada entidade só pode ter um Component de cada tipo. Por exemplo, se tentar atribuir um Transform a uma entidade que já tenha um, isso causará um erro.

Para evitar este erro, pode utilizar `.createOrReplace` em vez de `.create`. Este comando substitui quaisquer Components existentes do mesmo tipo, se existirem; caso contrário, cria um novo Component, tal como `.create`.

```ts
Transform.createOrReplace(door, {
	position: Vector3.create(5, 1, 5),
})
```

{% hint style="warning" %}
**📔 Nota**: Como `.createOrReplace` executa uma verificação adicional antes de criar o Component, é sempre mais eficiente utilizar `.create`. Se tiver a certeza de que a entidade ainda não tem um Component como aquele que está a adicionar, utilize `.create`.
{% endhint %}

## Aceder a um Component de uma entidade

Pode aceder aos Components de uma entidade utilizando as funções `.get()` ou `getMutable()` da entidade.

```ts
export function main() {
	// Create entity
	const box = engine.addEntity()

	// Criar e adicionar um Component a essa entidade
	Transform.create(box)

	// Obter uma versão só de leitura do Component
	let transform = Transform.get(box)

	// Obter uma versão mutável do Component
	let transform = Transform.getMutable(box)
}
```

A função `get()` obtém uma referência só de leitura ao Component. Não pode alterar nenhum valor através desta referência ao Component.

Se quiser alterar os valores do Component, utilize a função `getMutable()` em vez disso. Se alterar os valores na versão mutável do Component, estará a afetar diretamente a entidade a que esse Component pertence.

Consulte [dados mutáveis](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/padroes-de-programacao/mutable-data.md) para obter mais detalhes.

{% hint style="warning" %}
**📔 Nota**: Utilize apenas `getMutable()` se for realmente alterar os valores do componente. Caso contrário, utilize sempre `get()`. Esta prática segue os princípios da [programação orientada a dados](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/data-oriented-programming.md), e pode melhorar significativamente o desempenho da cena.
{% endhint %}

```ts
// Obter uma versão mutável do Component
let transform = Transform.getMutable(box)

// altera um valor do componente
transform.scale.x = 5
```

O exemplo acima modifica diretamente o valor de *x* na escala do componente Transform.

Se não tiver a certeza de que a entidade possui o componente que está a tentar obter, utilize `getOrNull()` ou `getMutableOrNull()`.

{% hint style="warning" %}
**📔 Nota**: Evite utilizar `getOrNull()` ou `getMutableOrNull()` sempre que possível, pois estas funções fazem verificações adicionais e, por isso, são menos eficientes do que `.get()` e `getMutable()`.
{% endhint %}

```ts
//  getOrNull
const transformOrNull = Transform.getOrNull(myEntity)

//  getMutableOrNull
const mutableTransformOrNull = Transform.getMutableOrNull(myEntity)
```

Se o componente que está a tentar obter não existir na entidade:

* `get()` e `getMutable()` devolvem um erro.
* `getOrNull()` e `getMutableOrNull()` devolvem `Null`.

## Remover um componente de uma entidade

Para remover um componente de uma entidade, utilize o método `deleteFrom()` do tipo do componente.

```ts
Transform.deleteFrom(myEntity)
```

Se tentar remover um componente que não existe na entidade, esta ação não gera erros.

{% hint style="warning" %}
**📔 Nota**: Para remover todos os componentes de uma entidade de uma só vez, consulte [esta secção](#remove-entities)
{% endhint %}

## Verificar se existe um componente

Pode verificar se uma entidade possui uma instância de um determinado componente utilizando `has()` função. Esta função devolve *true* se o componente estiver presente, e *false* se não estiver. Isto pode ser muito útil para utilizar em lógica condicional na sua cena.

```ts
const hasTransform = Transform.has(myEntity)
```

{% hint style="info" %}
**💡 Dica**: Também pode [consultar componentes](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/querying-components.md) para obter uma lista completa das entidades que contêm um componente específico ou um conjunto específico de componentes. Não percorra manualmente todas as entidades da cena para verificar cada uma com `has()`, pois essa abordagem é muito menos eficiente.
{% endhint %}

## Verificar alterações num componente

Utilize a função `onChange` para executar uma função de callback sempre que os valores do componente forem alterados para uma determinada entidade. Isto funciona com qualquer componente e é um ótimo atalho para manter o código legível.

A função de callback pode incluir um parâmetro de entrada que contém o novo estado do componente.

```ts
Transform.onChange(cubeEntity, (newTransform) => {
	if (!newTransform) return
	console.log(
		'A posição do cubo mudou: ',
		newTransform.position,
		newTransform.rotation
	)
})

VisibilityComponent.onChange(cubeEntity, (newVisibilityComponent) => {
	if (!newVisibilityComponent) return
	console.log('A visibilidade do cubo mudou: ', newVisibilityComponent.visible)
})
```

Se o componente for removido da entidade, a função é chamada com um valor de entrada `undefined`.

{% hint style="info" %}
**💡 Dica**: A função `.onChange()` funciona tanto com componentes nativos do SDK como com [componentes personalizados](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/custom-components.md) definidos pelo criador.
{% endhint %}

## Obter entidades filhas

Para aceder a todas as entidades que são filhas diretas de uma entidade principal, utilize `getEntitiesWithParent`. Recebe como argumentos `engine` e a entidade `parent` e devolve uma lista de todas as entidades que têm essa entidade específica como entidade principal. Tenha em atenção que devolve apenas as filhas diretas, não as filhas das filhas.

```ts
import { getEntitiesWithParent } from '@dcl/sdk/ecs'

const children = getEntitiesWithParent(engine, myEntity)
for (const child of children) {
   // processar cada entidade filha
}
```

Para aceder a todos os descendentes de uma entidade, independentemente da profundidade da hierarquia, utilize a função `getComponentEntityTree()`. Em vez de percorrer manualmente a hierarquia nível a nível, esta função devolve uma lista simples de todos os descendentes, fácil de percorrer. Também filtra apenas as entidades que têm um determinado componente ou uma lista de componentes.

```ts
import { getComponentEntityTree } from '@dcl/sdk/ecs'

export function main() {
	// Criar uma entidade principal com entidades filhas aninhadas
	const parentEntity = engine.addEntity()
	Transform.create(parentEntity, {
		position: Vector3.create(8, 0, 8),
	})

	// ... suponha que a entidade principal tem várias entidades filhas e netas

	// Iterar sobre todos os descendentes da entidade principal
	for (const descendantEntity of getComponentEntityTree(
		engine,
		parentEntity,
		Transform
	)) {
		// Aceder a cada entidade descendente
		const transform = Transform.get(descendantEntity)
		console.log('Descendant position:', transform.position)
	}
}
```

A `getComponentEntityTree` a função recebe três parâmetros:

* `engine`: A instância do motor que executa as entidades
* `entity`: A entidade raiz a partir da qual começar
* `component`: O componente pelo qual filtrar (normalmente `Transform` para hierarquias espaciais)

A função devolve um gerador que produz cada entidade descendente na estrutura em árvore. Apenas as entidades que têm o componente especificado serão incluídas nos resultados.

Pode combinar isto com outras verificações de componentes para encontrar entidades específicas na sua hierarquia:

```ts
// Encontrar todos os descendentes com um nome específico
for (const descendantEntity of getComponentEntityTree(
	engine,
	parentEntity,
	Transform
)) {
	const name = Name.getOrNull(descendantEntity)
	if (name && name.value === 'targetEntity') {
		console.log('Found target entity:', descendantEntity)
	}
}
```

## Entidades reservadas

Alguns IDs de entidade estão reservados para entidades especiais que existem em todas as cenas. É possível aceder-lhes através dos seguintes aliases:

* `engine.RootEntity`
* `engine.PlayerEntity`
* `engine.CameraEntity`

{% hint style="warning" %}
**📔 Nota**: Evite fazer referência a estas entidades antes de serem inicializadas. Para evitar este problema, faça referência a estas entidades na função `main()` ou num sistema.
{% endhint %}

## A entidade raiz

Todas as entidades da cena são descendentes da `engine.RootEntity`, direta ou indiretamente.

Esta entidade não tem um componente Transform, mas é utilizada para gerir vários componentes que representam definições mais globais, como o controlo da [skybox](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/skybox-control.md), [posição do cursor](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#check-the-players-cursor-position), ou as [dimensões do ecrã](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/ui-2d/ui-positioning.md#responsive-ui-size).

## A entidade do jogador

A entidade `engine.PlayerEntity` representa o avatar do jogador.

Obtenha o componente `Transform` do jogador para obter a posição e a rotação atuais do jogador. Consulte [dados do utilizador](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md). O Transform do jogador é só de leitura; para o modificar, utilize `movePlayerTo()` função, [saber mais](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/avatares/move-player.md).

Também pode anexar objetos ao jogador definindo-os como filhos desta entidade, embora [Attach to Player](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/entity-positioning.md#attach-an-entity-to-an-avatar) seja normalmente a melhor opção para isso.

## A entidade da câmara

A `engine.CameraEntity` entidade representa a câmara do jogador.

Obtenha o componente `Transform` da câmara para obter a posição e a rotação da câmara. O Transform desta entidade também é só de leitura. Para modificar o ângulo ou a posição da câmara, utilize uma [câmara virtual](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/camera.md#using-virtual-cameras).

Também pode obter o componente `CameraMode` da câmara para saber se o jogador está a utilizar o modo de câmara em primeira ou terceira pessoa. Consulte [modo de câmara](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#check-the-players-camera-mode).


---

# 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/arquitetura/entities-components.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.
