> 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/special-types.md).

# Tipos Especiais

Saiba quais tipos especiais existem, incluindo Vector, Quaternions e muito mais.

## Vector3

Decentraland usa *Vector3* dados para representar caminhos, pontos no espaço e direções. Vectors também podem ser usados para definir orientações de rotação, como uma alternativa mais amigável a *Quaternions*. Um objeto Vector3 contém valores numéricos para cada um dos *x*, *y*, e *z* eixo.

```ts
const myVector: Vector3 = { x: 8, y: 1, z: 8 }
```

O `Vector3` namespace contém uma série de métodos úteis que você pode chamar para evitar lidar com a maioria das operações matemáticas de vetores. Escreva `Vector3.`, e o VS Studio exibirá um dropdown com todas as funções disponíveis.

Abaixo estão algumas linhas que mostram a sintaxe de algumas operações básicas com vetores.

```ts
// Create a vector object
let myVector = Vector3.create(3, 1, 5)

// Alternative syntax to create a vector object
let myOtherVector: Vector3 = { x: 8, y: 1, z: 8 }

// Edit one of its values
myVector.x = 5

// Call functions from the Vector3 namespace,
// All these functions require passing Vector3 objects in their parameters

let normalizedVector = Vector3.normalize(myVector)

let distance = Vector3.distance(myVector, myOtherVector)

let midPoint = Vector3.lerp(myVector, myOtherVector, 0.5)
```

Objetos Vector3 são frequentemente necessários nos campos de vários Components. Por exemplo, o `Transform` Component contém `Vector3` valores para o *position* e *scale* da Entity.

Para criar um [componente personalizado](/creator/content-creator-pt/scenes-sdk7/arquitetura/custom-components.md) com parâmetros que exigem valores Vector3, defina o tipo desses parâmetros como `Schemas.Vector3`.

{% hint style="warning" %}
**📔 Observação**: `Vector3` devem ser importados via

> `import { Vector3 } from "@dcl/sdk/math"`

Veja [Imports](/creator/content-creator-pt/scenes-sdk7/primeiros-passos/coding-scenes.md#imports) para saber como lidar com isso facilmente.
{% endhint %}

### Atalhos para escrever vetores de direção

Existem os seguintes atalhos para definir vetores genéricos:

* `Vector3.Zero()` retorna *(0, 0, 0)*
* `Vector3.Up()` retorna *(0, 1, 0)*
* `Vector3.Down()` retorna *(0, -1, 0)*
* `Vector3.Left()` retorna *(-1, 0, 0)*
* `Vector3.Right()` retorna *(1, 0, 0)*
* `Vector3.Forward()` retorna *(0, 0, 1)*
* `Vector3.Backward()` retorna *(0, 0, -1)*

## Quaternions

Quaternions são usados para armazenar informações de rotação para o componente Transform. Um Quaternion é composto por quatro valores numéricos entre -1 e 1: *x*, *y*, *z*, *w*.

```ts
const myQuaternion: Quaternion = { x: 0, y: 0, z: 0, w: 1 }
```

Quaternions são diferentes de [*Euler* ângulos](https://en.wikipedia.org/wiki/Euler_angles), a mais comum *x*, *y* e *z* a notação com números que vão de 0 a 360 com a qual a maioria das pessoas está familiarizada. O engine expressa todas as rotações como Quaternions, então faz sentido evitar cálculos para converter de e para Euler sempre que possível.

O `Quaternion` namespace contém uma série de métodos úteis que você pode chamar para evitar ter de lidar com muitas operações matemáticas. Escreva `Quaternion.`, e o VS Studio exibirá um dropdown com todas as funções disponíveis.

Abaixo estão algumas linhas que mostram a sintaxe de algumas operações básicas com Quaternions.

```ts
// Create a quaternion object
let myQuaternion = Quaternion.create(0, 0, 0, 1)

// Edit one of its values
myQuaternion.x = 1

// Call functions from the quaternion namespace
let midPoint = Quaternion.slerp(myQuaternion1, myQuaternion2, 0.5)

// Get the rotation needed to turn from facing one direction to another,
// passing two direction Vector3 values
let rotation = Quaternion.fromToRotation(Vector3.Forward(), Vector3.Up())
```

Como é muito mais fácil pensar em termos de graus de Euler, o SDK inclui algumas funções para converter de e para Quaternions e Euler.

{% hint style="info" %}
**💡 Dica**: Evite executar essas conversões como parte de uma lógica recorrente dentro de um System, que roda a cada tick, pois isso pode ser custoso. Essas conversões são mais úteis para operações únicas, como definir a rotação de uma nova Entity.
{% endhint %}

```ts
// From euler to Quaternion
let myQuaternion = Quaternion.fromEulerDegrees(90, 0, 0)

// From quaternion to Euler
let myEuler = Quaternion.toEulerAngles(myQuaternion)
```

Objetos Quaternion são frequentemente necessários nos campos de Components. Por exemplo, o `Transform` Component contém `Quaternion` valores de rotação da Entity.

Para criar um [componente personalizado](/creator/content-creator-pt/scenes-sdk7/arquitetura/custom-components.md) com parâmetros que exigem valores Quaternion, defina o tipo desses parâmetros como `Schemas.Quaternion`.

{% hint style="warning" %}
**📔 Observação**: `Quaternion` devem ser importados via

> `import { Quaternion } from "@dcl/sdk/math"`

Veja [Imports](/creator/content-creator-pt/scenes-sdk7/primeiros-passos/coding-scenes.md#imports) para saber como lidar com isso facilmente.
{% endhint %}

## Escalares

Um escalar não é nada mais do que um número. Por isso, não faz muito sentido instanciar um `Scalar` objeto para armazenar dados, já que você pode fazer o mesmo com um número. As funções no `Scalar` namespace, porém, expõem várias funções úteis (semelhantes às do *Vector3* namespace), que podem ser usadas em números.

```ts
// Call functions from the Scalar class
let random = Scalar.randomRange(1, 100)

let midPoint = Scalar.lerp(number1, number2, 0.5)

let clampedValue = Scalar.clamp(myInput, 0, 100)
```

{% hint style="warning" %}
**📔 Observação**: `Scalar` devem ser importados via

> `import { Scalar } from "@dcl/sdk/math"`

Veja [Imports](/creator/content-creator-pt/scenes-sdk7/primeiros-passos/coding-scenes.md#imports) para saber como lidar com isso facilmente.
{% 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/special-types.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.