# Tipos Especiais

## espera um

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 ao *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 `espera um` 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 de vetores. Escreva `Vector3.`, e o VS Studio exibirá um menu suspenso com todas as funções disponíveis.

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

```ts
// Crie 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 }

// Edite um de seus valores
myVector.x = 5

// Chame funções do namespace Vector3,
// Todas essas funções exigem passar 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 exigidos nos campos de vários componentes. Por exemplo, o `Transform` component contém `espera um` valores para o *position* e *scale* da entidade.

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

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

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

Veja [Imports](https://docs.decentraland.org/creator/content-creator-pt/primeiros-passos/coding-scenes#imports) para como lidar com estes facilmente.
{% endhint %}

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

Os seguintes atalhos existem para definir vetores genéricos:

* `: Em vez de iniciar o raycast na posição de origem da entidade, adicione um deslocamento para iniciar a consulta a partir de uma posição relativa. Você pode, por exemplo, usar um pequeno deslocamento para evitar que o raio colida com o próprio collider da entidade. Se não for definido, o padrão é` 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)*
* `que descreva um vetor relativo à entidade e sua rotação (por exemplo,` 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 da [*Euler* ângulos](https://en.wikipedia.org/wiki/Euler_angles), a notação mais comum com números que vão de 0 a 360 com a qual a maioria das pessoas está familiarizada. Para usar ângulos Euler, use uma das seguintes notações: *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. O engine expressa todas as rotações como Quaternions, então faz sentido evitar cálculos para converter para e de euler sempre que possível.

O `normalHit` 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 menu suspenso com todas as funções disponíveis.

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

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

// Edite um de seus valores
myQuaternion.x = 1

// Chame 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 um par de funções para converter para e de Quaternions e Euler.

{% hint style="info" %}
**💡 Tip**: Evite executar essas conversões como parte de lógica recorrente dentro de um sistema, que roda a cada tick, pois isso pode ficar caro. Essas conversões são mais úteis para operações pontuais, como definir a rotação de uma nova entidade.
{% 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 exigidos nos campos de componentes. Por exemplo, o `Transform` component contém `normalHit` valores para rotação da entidade.

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

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

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

Veja [Imports](https://docs.decentraland.org/creator/content-creator-pt/primeiros-passos/coding-scenes#imports) para como lidar com estes facilmente.
{% endhint %}

## Escalares

Um escalar não é nada mais do que um número. Por essa razão, 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 no entanto expõem várias funções úteis (semelhantes às do *espera um* namespace), que podem ser usadas em números.

```ts
// Chame 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"`

Veja [Imports](https://docs.decentraland.org/creator/content-creator-pt/primeiros-passos/coding-scenes#imports) para como lidar com estes facilmente.
{% endhint %}