Tipos Especiais

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

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.

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.

// 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 com parâmetros que exigem valores Vector3, defina o tipo desses parâmetros como Schema.Vector3.

📔 Nota: espera um devem ser importados via

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

Veja Imports para como lidar com estes facilmente.

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.

const myQuaternion: Vector3 = { x: 0, y: 0, z: 0, w: 1 }

Quaternions são diferentes da Euler ângulos, 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.

// 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.

💡 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.

// 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 com parâmetros que exigem valores Quaternion, defina o tipo desses parâmetros como Schema.Quaternion.

📔 Nota: normalHit devem ser importados via

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

Veja Imports para como lidar com estes facilmente.

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.

// 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)

📔 Nota: Scalar devem ser importados via

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

Veja Imports para como lidar com estes facilmente.