# Posicionamento de Entities Podes definir a *posição*, *rotação* e *escala* de qualquer entity usando o `Transform` component. Isto pode ser usado em qualquer entity no espaço 3D, afetando onde a entity é renderizada. Isso inclui formas primitivas (cube, sphere, plane, etc), formas de texto 3D, formas de NFT e modelos 3D (`GltfContainer`). ## Use o Scene Editor no Creator Hub Ao adicionar um item à sua scene via o Scene Editor, ele inclui implicitamente um **Transform** component. Depois, você altera os valores no Transform component da entity implicitamente ao alterar a position, rotation ou scale de uma entity. Você também pode usar a UI do Scene Editor para fornecer valores numericamente para maior precisão. ## Essenciais de código ![](/files/bd50850b6fd34216f615151ed3a8b05c68ecec0f) ```ts // Criar uma nova entity const ball = engine.addEntity() // Dar a esta entity uma shape, para torná-la visível MeshRenderer.setSphere(ball) // Dar a esta entity um Transform component Transform.create(ball, { position: Vector3.create(5, 1, 5), scale: Vector3.create(1, 1, 1), rotation: Quaternion.Zero(), }) ``` Para mover, rotacionar ou redimensionar uma entity na sua scene ao longo de um período de tempo, altere os valores deste component incrementalmente, frame a frame. Veja [Mover entities](/creator/content-creator-pt/scenes-sdk7/essenciais-de-conteudo-3d/move-entities.md) para mais detalhes e boas práticas. {% hint style="warning" %} **📔 Nota**: `Vector3` e `Quaternion` devem ser importados via > `import { Vector3, Quaternion } from "@dcl/sdk/math"` Veja [Imports](/creator/content-creator-pt/scenes-sdk7/comecar/coding-scenes.md#imports) para saber como lidar facilmente com estes casos. {% endhint %} ## Position `posição` é um *vetor 3D*, ele define a position do centro da entity em todos os três eixos, *x*, *y*e *z*. Vê [Tipos de geometria](/creator/content-creator-pt/scenes-sdk7/essenciais-de-conteudo-3d/special-types.md) para mais detalhes. ```ts // Criar uma nova entity const ball = engine.addEntity() // Criar transform com uma position predefinida Transform.create(ball, { position: Vector3.create(5, 1, 5) } // Obter uma versão mutável do transform const mutableTransform = Transform.getMutable(ball) // Definir a position com um objeto mutableTransform.position = { x: 5, y: 1, z: 5 } // Definir a position com um objeto (sintaxe alternativa) mutableTransform.position = Vector3.create(2, 1, 4) // Definir cada eixo individualmente mutableTransform.position.x = 3 mutableTransform.position.y = 1 mutableTransform.position.z = 3 ``` Ao definir uma position, tenha em mente as seguintes considerações: * Os números num vetor de position representam *metros* (a menos que a entity seja filha de uma entity com escala). * Uma scene composta por um único parcel mede 16m x 16m. O centro da scene (ao nível do solo) está em `x:8, y:0, z:8`. Se a scene for composta por vários parcels, então o centro varia dependendo da sua disposição. * `x:0, y:0, z:0` refere-se ao *canto sudoeste* do parcel base da scene, ao nível do solo. > Dica: Ao visualizar uma prévia da scene, aparece uma bússola no ponto (0,0,0) da scene com rótulos para cada eixo como referência. > Nota: Você pode alterar o parcel base de uma scene editando o `base` atributo de *scene.json*. * Para se orientar melhor, use sua *left* mão: * o dedo indicador (apontando para a frente) é o *z* eixo * o dedo médio (apontando para o lado) é o *x* eixo * o polegar (apontando para cima) é o *y* eixo. * Se uma entity for filha de outra, então `x:0, y:0, z:0` refere-se ao centro da entity pai, onde quer que ela esteja na scene. * Cada entity na sua scene deve estar posicionada dentro dos limites dos parcels que ocupa em todos os momentos. Se uma entity sair desses limites, será gerado um erro. > Dica: Ao visualizar uma scene no modo de prévia, as entities que estão fora dos limites são destacadas em *vermelho*. * Sua scene também tem um limite de altura. Quanto mais parcels compuserem a scene, maior será o limite de construção. Veja [limitações da scene](/creator/content-creator-pt/scenes-sdk7/otimizacao/scene-limitations.md) para mais detalhes. ## Rotation `rotação` é armazenada como uma [*quaternion*](https://en.wikipedia.org/wiki/Quaternion), um sistema de quatro números, *x*, *y*, *z* e *w*. Cada um desses números vai de 0 a 1. Veja [Tipos de geometria](/creator/content-creator-pt/scenes-sdk7/essenciais-de-conteudo-3d/special-types.md) para mais detalhes. ```ts // Criar uma nova entity const cube = engine.addEntity() // Criar transform com uma rotation predefinida de 0 Transform.create(cube, { rotation: Quaternion.Zero() } // Obter uma versão mutável do transform const mutableTransform = Transform.getMutable(cube) // Definir a rotation com um objeto, a partir de ângulos de Euler mutableTransform.rotation = Quaternion.fromEulerDegrees(0, 90, 0) // Definir a rotation com um objeto mutableTransform.rotation = { x: 0.1, y: 0.5, z: 0.5, w: 0 } // Definir cada eixo individualmente mutableTransform.rotation.x = 0 mutableTransform.rotation.y = 1 mutableTransform.rotation.z = 0.3 mutableTransform.rotation.w = 0 ``` Você também pode definir o campo rotation com [*Euler* angles](https://en.wikipedia.org/wiki/Euler_angles), a mais comum *x*, *y* e *z* notação com números que vão de 0 a 360, com a qual a maioria das pessoas está familiarizada. Para usar ângulos de Euler, use uma das seguintes notações: ```ts // Criar transform com uma rotation predefinida em ângulos de Euler Transform.create(cube, { rotation: Quaternion.fromEulerDegrees(0, 90, 0) } // Obter uma versão mutável do transform const mutableTransform = Transform.getMutable(cube) // Definir a rotation com um objeto, a partir de ângulos de Euler mutableTransform.rotation = Quaternion.fromEulerDegrees(0, 90, 0) ``` Ao usar um *vetor 3D* para representar ângulos de Euler, *x*, *y* e *z* representam a rotation nesse eixo, medida em graus. Uma volta completa requer 360 graus. Ao obter a rotation de uma entity, por padrão ela retorna uma quaternion. Para obter a rotation expressa em ângulos de Euler, use `.toEuler()`: ```ts // Obter uma versão somente leitura do transform const transform = Transform.getMutable(cube) // Definir a rotation com um objeto, a partir de ângulos de Euler const eulerAngle = Quaternion.toEuler(transform.rotation) ``` ## Obtendo a Position e Rotation Globais de uma Entity O `getWorldPosition` e `getWorldRotation` functions retornam a position e rotation globais de uma entity. Isso significa que ela retorna a position ou rotation percebida em que o jogador verá o item, ignorando quaisquer hierarquias pai. * `getWorldPosition(engine, entity: Entity): Vector3Type`: Esta função retorna a position World de uma entity, levando em consideração todas as positions das entities pai, se a própria entity tiver alguma, retornando `{x: 0, y: 0, z: 0}` se a entity não tiver Transform. ```ts const worldPos = getWorldPosition(engine, childEntity) console.log(`World position: ${worldPos.x}, ${worldPos.y}, ${worldPos.z}`) ``` * `getWorldRotation(engine, entity: Entity): QuaternionType`: Esta função retorna a rotation World de uma entity, levando em consideração todas as rotations das entities pai, se a própria entity tiver alguma. Ela retorna um `Quaternion` type, retornando quaternion identidade `{x: 0, y: 0, z: 0, w: 1}` se a entity não tiver Transform. ```ts const worldRot = getWorldRotation(engine, childEntity) console.log(`World rotation: ${worldRot.x}, ${worldRot.y}, ${worldRot.z}, ${worldRot.w}`) ``` {% hint style="info" %} **Nota:** A position global e a rotation global são relativas às coordenadas dentro da scene e não a Genesis City. {% endhint %} ## Encarar o jogador Adicione um *Billboard* component a uma entity para que ela sempre gire para encarar o jogador. Billboards eram uma técnica comum usada em jogos 3D dos anos 90, onde a maioria das entities eram planos 2D que sempre encaravam o jogador. A mesma ideia também pode ser usada para rotacionar um modelo 3D. ```ts // Criar uma nova entity const cube = engine.addEntity() // Dar à entity uma shape visível MeshRenderer.setBox(cube) // Criar transform com uma position predefinida Transform.create(cube, { position: Vector3.create(5, 1, 5) } // Dar à entity um Billboard component Billboard.create(cube, {}) ``` Você pode configurar como o billboard se comporta com os seguintes parâmetros: * `billboardMode`: Usa um valor do `BillboardMode` para definir seu comportamento: * `BillboardMode.BM_ALL`: A entity rotaciona para encarar o jogador em todos os seus eixos de rotação. Se o jogador estiver alto acima da entity, a entity vai olhar para cima. * `BillboardMode.BM_NONE`: A entity não rotacionará de forma alguma. * `BillboardMode.BM_X`: A entity tem seu *x* eixo de rotação fixo. * `BillboardMode.BM_Y`: A entity tem seu *y* eixo de rotação fixo. Ela só gira para a esquerda e para a direita, não para cima e para baixo. Permanece perpendicular ao solo se o jogador estiver acima ou abaixo da entity. * `BillboardMode.BM_Z`: A entity tem seu *z* eixo de rotação fixo. ```ts // billboard plano const perpendicularPlane = engine.addEntity() Transform.create(perpendicularPlane, { position: Vector3.create(8, 1, 8), }) PlaneShape.create(perpendicularPlane) Billboard.create(perpendicularPlane, { billboardMode: BillboardMode.BM_Y, }) // etiqueta de texto const textLabel = engine.addEntity() Transform.create(textLabel, { position: Vector3.create(6, 1, 6), }) TextShape.create(textLabel, { text: 'Este texto é sempre legível', }) Billboard.create(textLabel) ``` {% hint style="info" %} **💡 Dica**: Billboards são muito úteis para adicionar a *text* entities, já que isso as torna sempre legíveis. {% endhint %} O `rotação` o valor do `Transform` component da entity não muda, enquanto o billboard acompanha os jogadores. Se uma entity tiver tanto um `Billboard` component e `Transform` component com `rotação` valores, os jogadores verão a entity rotacionando como um billboard. Se o billboard não afetar todos os eixos, os eixos restantes serão rotacionados de acordo com o `Transform` componente. {% hint style="warning" %} **📔 Nota**: Se houver vários jogadores presentes ao mesmo tempo, cada um verá as entities com billboard mode voltadas para si. As rotações do billboard são calculadas localmente para cada jogador e não afetam o que os outros veem. {% endhint %} ## Encarar um conjunto de coordenadas Para a entity A olhar para a entity B: ``` 1) Subtraia a position da entity A da entity B para obter um vetor que descreve a distância entre elas. 2) Normalize esse vetor, para que ele tenha comprimento 1, mantendo sua direção. 3) Use `Quaternion.lookRotation` para obter uma rotation Quaternion que descreva a rotação nessa direção. 4) Defina essa Quaternion como a rotation da entity A ``` ```ts export function turn(entity: Entity, target: ReadOnlyVector3) { const transform = Transform.getMutable(entity) const difference = Vector3.subtract(target, transform.position) const normalizedDifference = Vector3.normalize(difference) transform.rotation = Quaternion.lookRotation(normalizedDifference) } ``` ## Scale `escala` também é um *vetor 3D*, armazenada como um `Vector3` object, incluindo o fator de escala no *x*, *y* e *z* eixo. A shape da entity é escalada de acordo, seja ela uma primitive ou um modelo 3D. A escala padrão é 1, então atribua um valor maior que 1 para esticar uma entity ou menor que 1 para reduzi-la. ```ts // Criar uma nova entity const ball = engine.addEntity() // Criar transform com uma position predefinida Transform.create(ball, { scale: Vector3.create(5, 5, 5) } // Obter uma versão mutável do transform const mutableTransform = Transform.getMutable(ball) // Definir a scale com um Vector3 mutableTransform.scale = Vector3.create(2, 2, 2) // Definir a position com um objeto mutableTransform.scale = { x: 5, y: 1, z: 5 } // Definir cada eixo individualmente mutableTransform.scale.x = 3 mutableTransform.scale.y = 3 mutableTransform.scale.z = 2 ``` ## Herdar transforms do pai Quando uma entity está aninhada dentro de outra, as entities filhas herdam components dos pais. Isso significa que, se uma entity pai é posicionada, escalada ou rotacionada, suas entities filhas também são afetadas. Os valores de position, rotation e scale das entities filhas não substituem os dos pais; em vez disso, eles são combinados. Você atribui uma entity para ser pai de outra definindo o `parent` campo no `Transform` componente. da entity filha ```ts // Criar entities const parentEntity = engine.addEntity() const childEntity = engine.addEntity() // Criar um transform para o pai Transform.create(parentEntity, { position: Vector3.create(3, 1, 1), scale: Vector3.create(0.5, 0.5, 0.5), }) // Criar um transform para a filha e atribuí-la como filha Transform.create(childEntity, { position: Vector3.create(0, 1, 0), parent: parentEntity, }) ``` Neste exemplo, a entity filha será reduzida para 0.5, já que seu pai tem essa scale. A position da entity filha também será relativa à do seu pai. Temos que somar a position do pai à da filha. Nesse caso, como o pai está escalado para metade do seu tamanho, a transformação da filha também é reduzida proporcionalmente. Em termos absolutos, a filha está posicionada em `{ x: 3, y: 1.5, z: 1 }`. Se o pai tivesse um `rotação`, isso também afetaria a position final da filha, pois altera o eixo no qual a filha é deslocada. Se uma entity filha não tiver nenhum `posição` em seu Transform, o padrão é `0,0,0`, o que a manterá posicionada no mesmo local que seu pai. Você pode usar uma entity invisível sem nenhum shape component como pai para agrupar um conjunto de outras entities. Essa entity não será visível na scene renderizada, mas pode ser usada para agrupar suas filhas e aplicar um transform a todas elas. ## Anexar uma entity a um avatar Há três métodos para anexar uma entity ao jogador: * Torná-la filha da **Avatar Entity** * Torná-la filha da **Camera Entity** * Use a **AvatarAttach component** A forma mais simples de anexar uma entity ao avatar é definir o pai como a [reserved entity](/creator/content-creator-pt/scenes-sdk7/arquitetura/entities-components.md#reserved-entities) `engine.PlayerEntity`. A entity então se moverá junto com a position do jogador. ```ts let childEntity = engine.addEntity() MeshRenderer.setCylinder(childEntity) Transform.create(childEntity, { scale: Vector3.create(0.2, 0.2, 0.2), position: Vector3.create(0, 0.4, 0), parent: engine.PlayerEntity, }) ``` Você também pode definir uma entity como [reserved entity](/creator/content-creator-pt/scenes-sdk7/arquitetura/entities-components.md#reserved-entities) `engine.CameraEntity`. Ao usar a camera entity em primeira pessoa, a entity anexada seguirá os movimentos da câmera. Isso é ideal para manter algo sempre em vista, por exemplo, para manter o modelo 3D da arma sempre visível, mesmo quando a câmera aponta para cima. ```ts let childEntity = engine.addEntity() MeshRenderer.setCylinder(childEntity) Transform.create(childEntity, { scale: Vector3.create(0.2, 0.2, 0.2), position: Vector3.create(0, 0.4, 0), parent: engine.CameraEntity, }) ``` Para anexar um objeto a um dos bones do avatar e fazê-lo se mover junto com as animações do avatar, adicione um `AvatarAttach` component à entity. Você pode escolher diferentes anchor points no avatar; a maioria desses pontos está ligada à armature do jogador e segue suas animações. Por exemplo, ao usar o anchor point da mão direita, a entity anexada se moverá quando o avatar acenar ou balançar os braços enquanto corre, como se o jogador estivesse segurando a entity na mão. ```ts // Anexar ao jogador principal; se avatarId não estiver definido, engine.PlayerEntity é usado por padrão AvatarAttach.create(myEntity, { anchorPointId: AvatarAnchorPointType.AAPT_NAME_TAG, }) // Anexar a um jogador por ID AvatarAttach.create(myEntity, { avatarId: '0xAAAAAAAAAAAAAAAAA', anchorPointId: AvatarAnchorPointType.AAPT_NAME_TAG, }) ``` Ao criar um `AvatarAttach` component, passe um objeto com os seguintes dados: * `avatarId`: *Opcional* O ID do jogador ao qual anexar. Este é o mesmo que o endereço Ethereum do jogador, para aqueles jogadores conectados com uma wallet Ethereum. Se não for especificado, a entity é anexada ao avatar do jogador local. * `anchorPointId`: A que anchor point no esqueleto do avatar anexar a entity, usando um valor do enum `AvatarAnchorPointType`. {% hint style="warning" %} **📔 Nota**: Se você quiser que todos os jogadores na scene vejam um objeto anexado ao mesmo jogador, por exemplo, para que todos vejam que o Jogador A pegou um objeto e o está segurando na mão esquerda, então você deve fornecer um valor para `avatarId`. Se não for especificado, então todos os jogadores verão o objeto anexado aos seus próprios avatars. {% endhint %} O exemplo a seguir coloca uma entity anexada a um avatar específico, para que todos os outros jogadores a vejam anexada a esse mesmo avatar. ```ts import { getPlayer } from '@dcl/sdk/src/players' import { AvatarAnchorPointType, AvatarAttach, engine, Entity } from '@dcl/sdk/ecs' import { syncEntity } from '@dcl/sdk/src/network' async function attachToPlayer(){ let userData = await getPlayer() console.log(userData) if (!userData || !userData.wearables) return let entity = engine.addEntity() AvatarAttach.create(entity, { avatarId: userData.userId, anchorPointId: AvatarAnchorPointType.AAPT_RIGHT_HAND, }) // Outros components syncEntity(entity, [AvatarAttach.componentId]) } ``` Os seguintes anchor points estão disponíveis no `AvatarAnchorPointType` enum: * `AAPT_RIGHT_HAND`: Fixado na mão direita do jogador * `AAPT_LEFT_HAND`: Fixado na mão esquerda do jogador * `AAPT_HEAD`: Fixado ao centro da cabeça do jogador. * `AAPT_NECK`: Fixado à base do pescoço do jogador. * `AAPT_SPINE`: Fixado à seção superior da coluna. * `AAPT_SPINE1`: Fixado à seção média da coluna. * `AAPT_SPINE2`: Fixado à seção inferior da coluna. * `AAPT_HIP`: Fixado ao osso do quadril. * `AAPT_LEFT_SHOULDER`: Fixado ao ombro esquerdo. * `AAPT_LEFT_ARM`: Fixado ao primeiro osso do braço esquerdo, na altura do ombro. * `AAPT_LEFT_FOREARM`: Fixado ao osso do antebraço esquerdo. * `AAPT_LEFT_HAND_INDEX`: Fixado à ponta do dedo indicador esquerdo. * `AAPT_RIGHT_SHOULDER`: Fixado ao ombro direito. * `AAPT_RIGHT_ARM`: Fixado ao primeiro osso do braço direito, na altura do ombro. * `AAPT_RIGHT_FOREARM`: Fixado ao osso do antebraço direito. * `AAPT_RIGHT_HAND_INDEX`: Fixado à ponta do dedo indicador direito. * `AAPT_LEFT_UP_LEG`: Fixado ao osso superior da perna esquerda. * `AAPT_LEFT_LEG`: Fixado ao osso inferior da perna esquerda. * `AAPT_LEFT_FOOT`: Fixado ao tornozelo da perna esquerda. * `AAPT_LEFT_TOE_BASE`: Fixado à ponta do dedo do pé da perna esquerda. * `AAPT_RIGHT_UP_LEG`: Fixado ao osso superior da perna direita. * `AAPT_RIGHT_LEG`: Fixado ao osso inferior da perna direita. * `AAPT_RIGHT_FOOT`: Fixado ao tornozelo da perna direita. * `AAPT_RIGHT_TOE_BASE`: Fixado à ponta do dedo do pé da perna direita. * `.AAPT_NAME_TAG`: Flutua logo acima da name tag do jogador e não é afetado pelas animações do jogador. > Nota: A altura da name tag é ajustada dinamicamente com base na altura dos wearables que o jogador estiver usando. Então um jogador usando um chapéu alto terá sua name tag um pouco mais alta do que os outros. * `AAPT_POSITION` *OBSOLETO*: A position geral do jogador. Isso aparece a uma altura de 0.8 acima dos pés do jogador. > {% hint style="warning" %} \> \*\*📔 Nota\*\*: O \`AAPT\_POSITION\` está obsoleto. Para seguir a position geral do jogador, é melhor tornar a entity filha da Avatar Entity. Veja o início desta seção para um exemplo. > {% endhint %} {% hint style="info" %} **💡 Dica**: Para usar esses valores, escreva `AvatarAnchorPointType.` e o VS Code exibirá a lista completa de opções em um dropdown. {% endhint %} ![](/files/a2c8d4da7104cf562872fdaf65b5c35c7eef69a5) A renderização da entity é determinada localmente em cada instância da scene. Anexar uma entity a um jogador não a torna visível para outros jogadores que estão vendo esse jogador. Se uma entity estiver anexada ao jogador local padrão, cada jogador verá a entity como anexada ao seu próprio avatar. {% hint style="warning" %} **📔 Nota**: Entities anexadas a um avatar devem permanecer dentro dos limites da scene para serem renderizadas. Se um jogador sair da sua scene, quaisquer entities anexadas param de ser renderizadas até que o jogador volte. Smart wearables não têm essa limitação. {% endhint %} O `AvatarAttach` component substitui os valores no `Transform` component. Quaisquer valores que você colocar no `Transform` component são substituídos pela position relativa da entity em relação ao Transform do jogador; esses valores são atualizados frame a frame conforme o jogador se move e anima. Se você precisar posicionar uma entity com um offset do anchor point no avatar, ou com uma rotation ou scale diferente, faça isso por meio de uma entity pai. 1. Crie uma entity invisível com apenas um `Transform` e um `AvatarAttach` component. Seus valores de `Transform` serão substituídos conforme o jogador se move 2. Defina a entity que você deseja anexar como filha desse pai. Seus valores de `Transform` podem descrever o offset em relação ao anchor point. ```ts // Criar entity pai const parentEntity = engine.addEntity() // Anexar entity pai ao jogador AvatarAttach.create(parentEntity, { anchorPointId: AvatarAnchorPointType.AAPT_NAME_TAG, }) // Criar entity filha let childEntity = engine.addEntity() MeshRenderer.setCylinder(childEntity) Transform.create(childEntity, { scale: Vector3.create(0.2, 0.2, 0.2), position: Vector3.create(0, 0.4, 0), parent: parentEntity, }) ``` {% hint style="warning" %} **📔 Nota**: Se a entity anexada tiver colliders, esses colliders podem bloquear o movimento do jogador ou causar efeitos de tremor. Talvez você queira desativar a physics layer dos colliders da entity anexada. Veja [camadas de colisão](/creator/content-creator-pt/scenes-sdk7/essenciais-de-conteudo-3d/colliders.md#collision-layers) {% endhint %} {% hint style="warning" %} **📔 Nota**: Se você tiver uma entity filha e quiser saber a Position global e/ou Rotation dela, você pode usar as `getWorldPosition` e `getWorldRotation` functions. Você pode verificá-las em [Obtendo a Position e Rotation Globais](#getting-global-position-and-rotation-of-an-entity) . {% endhint %} ### Anexar a outros jogadores Você pode usar o `AvatarAttach` component para anexar uma entity a outro jogador. Para fazer isso, você deve saber o id do jogador. Para anexar uma entity ao avatar de outro jogador, você deve fornecer o ID do usuário no campo `avatarId`. Há [várias maneiras](/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-player-data) de obter esses dados. {% hint style="warning" %} **📔 Nota**: Para os jogadores conectados com uma wallet Ethereum, o seu `userId` é o mesmo que o endereço Ethereum deles. {% endhint %} Obtenha o `userId` para todos os outros jogadores próximos via `getPlayer()` ```ts executeTask(async () => { for (const [entity, data] of engine.getEntitiesWith(PlayerIdentityData)) { console.log('Player id: ', data.address) } }) ``` Usando isso em conjunto com `AvatarAttach`, você poderia usar o seguinte código para adicionar um cube flutuando acima da cabeça de cada outro jogador na scene: ```ts executeTask(async () => { for (const [entity, data] of engine.getEntitiesWith(PlayerIdentityData)) { const myEntity = engine.addEntity() MeshRenderer.setBox(myEntity) AvatarAttach.create(myEntity, { anchorPointId: AvatarAnchorPointType.AAPT_LEFT_HAND, avatarId: data.address, }) } }) ``` Veja outras formas de obter os IDs de outros usuários em [Obter Dados do Jogador](/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-player-data). ## Limites da scene Todas as entities na sua scene devem caber dentro dos limites da scene, pois o que está fora desses limites são parcels de terra que pertencem a outros jogadores. Se qualquer parte dos seus modelos se estender além desses limites ao executar uma prévia, essas partes que se estendem serão cortadas e não renderizadas, tanto ao executar uma prévia quanto na scene publicada. A position das entities na sua scene é verificada constantemente à medida que elas se movem; se uma entity sair da scene e depois retornar, ela será removida e depois renderizada normalmente novamente. Uma grade no chão da scene mostra os limites da scene, que por padrão vão de 0 a 16 no *x* e *z* eixo, e até 20 no *y* eixo. Você é livre para colocar entities abaixo do solo, abaixo de 0 no *y* eixo. {% hint style="info" %} **💡 Dica**: Se a sua scene precisar de mais parcels, você pode adicioná-los no `scene.json` arquivo do projeto. Veja [Scene metadata](/creator/content-creator-pt/scenes-sdk7/tipos-de-projetos/scene-metadata.md) para instruções. Depois de adicionados, você deverá ver a grade se estender para cobrir os parcels adicionais. {% endhint %} --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/essenciais-de-conteudo-3d/entity-positioning.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.