# Tipos especiais

## Vector3

Decentraland usa *vector3* dados para representar caminhos, pontos no espaço e direções. Vetores 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 ter que lidar com a maioria das operações matemáticas com vetores. Escreva `Vector3.`, e o VS Studio exibirá um dropdown com todas as funções disponíveis.

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

```ts
// Criar um objeto vetor
let myVector = Vector3.create(3, 1, 5)

// Sintaxe alternativa para criar um objeto vetor
let myOtherVector: Vector3 = { x: 8, y: 1, z: 8 }

// Editar um dos seus valores
myVector.x = 5

// Chamar funções do namespace Vector3,
// Todas essas funções exigem a passagem de objetos Vector3 em seus parâmetros

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 componentes. Por exemplo, o `Transform` component contém `Vector3` valores para o *position* e *scale* da entidade.

Para criar um [component 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 `Schema.Vector3`.

{% hint style="warning" %}
**📔 Nota**: `Vector3` devem ser importados via

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

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

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

Os seguintes atalhos existem 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: Vector3 = { x: 0, y: 0, z: 0, w: 1 }
```

Quaternions são diferentes de [*Euler* ângulos](https://en.wikipedia.org/wiki/Euler_angles), a notação mais comum *x*, *y* e *z* notação com números que vai 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 que 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 mostrando a sintaxe de algumas operações básicas com Quaternions.

```ts
// Criar um objeto quaternion
let myQuaternion = Quaternion.crate(0, 0, 0, 1)

// Editar um dos seus valores
myQuaternion.x = 1

// Chamar funções do namespace quaternion
let midPoint = Quaternion.slerp(myQuaternion1, myQuaternion2, 0.5)

let rotationDifference = Quaternion.fromToRotation(
  myQuaternion1,
  myQuaternion2,
  Quaternion.Zero()
)
```

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 lógica recorrente dentro de um system, que roda a cada tick, pois isso pode ficar caro. Essas conversões são mais úteis para operações únicas, como definir a rotação de uma nova entity.
{% endhint %}

```ts
// De euler para Quaternion
let myQuaternion = Quaternion.fromEulerDegrees(90, 0, 0)

// De quaternion para Euler
let myEuler = Quaternion.toEulerAngles(myQuaternion)
```

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

Para criar um [component 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 `Schema.Quaternion`.

{% hint style="warning" %}
**📔 Nota**: `Quaternion` devem ser importados via

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

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

## Escalares

Um escalar nada mais é do que um número. Por esse motivo, 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
// Chamar funções da classe Scalar
let random = Scalar.randomRange(1, 100)

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

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

{% hint style="warning" %}
**📔 Nota**: `Scalar` devem ser importados via

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

Consulte [Imports](/creator/content-creator-pt/scenes-sdk7/comecar/coding-scenes.md#imports) para saber como lidar com isso facilmente.
{% 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/special-types.md?ask=<question>
```

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.