Vector3

classe Vector3

Vector3 é um vetor com 3 posições, respectivamente, X, Y e Z, ou seja, um vetor no espaço de dimensão 3d. Eles são usados para armazenar posições, direções, etc.

public class Vector3

— Construtores (9) —

Construtor	Descrição
Vector3()	Cria uma nova instância do Vector3 com todos os valores definidos como 0.
Vector3(float a)	Cria uma nova instância do Vector3 com os três eixos [X, Y, Z] definidos como o valor do argumento "a".
Vector3(int a)	Cria uma nova instância do Vector3 com os três eixos [X, Y, Z] definidos como o valor do argumento "a".
Vector3(float x, float y, float z)	Cria uma nova instância do Vector3 com X, Y e Z definidos como os argumentos "x", "y" e "z" respectivamente.
Vector3(int x, int y, int z)	Cria uma nova instância do Vector3 com X, Y e Z definidos como os argumentos "x", "y" e "z" respectivamente.
Vector3(float x, float y, int z)	Cria uma nova instância do Vector3 com X, Y e Z definidos como os argumentos "x", "y" e "z" respectivamente.
Vector3(int x, float y, int z)	Cria uma nova instância do Vector3 com X, Y e Z definidos como os argumentos "x", "y" e "z" respectivamente.
Vector3(int x, float y, float z)	Cria uma nova instância do Vector3 com X, Y e Z definidos como os argumentos "x", "y" e "z" respectivamente.
Vector3(int x, int y, float z)	Cria uma nova instância do Vector3 com X, Y e Z definidos como os argumentos "x", "y" e "z" respectivamente.
Vector3(int x, int y, int z)	Cria uma nova instância do Vector3 com X, Y e Z definidos como os argumentos "x", "y" e "z" respectivamente.

— Métodos (102) —

Nome	Descrição
float getX()	Retorna o valor X atual dentro deste vetor.
float getY()	Retorna o valor atual de Y dentro deste vetor.
float getZ()	Retorna o valor Z atual dentro deste vetor.
Vector2 getXY()	Retorna o valor atual de X e Y dentro deste vetor.
Vector2 getXZ()	Retorna o valor atual de X e Z dentro deste vetor.
Vector2 getYZ()	Retorna o valor atual de Y e Z dentro deste vetor.
Vector2 getYX()	Retorna o valor atual de Y e X dentro deste vetor.
Vector2 getZX()	Retorna o valor atual de Z e X dentro deste vetor.
Vector2 getZY()	Retorna o valor atual de Z e Y dentro deste vetor.
void setX(float value)	Define o valor X atual dentro deste vetor com um novo valor.
void setY(float value)	Define o valor Y atual dentro deste vetor com um novo valor.
void setZ(float value)	Define o valor Z atual dentro deste vetor com um novo valor.
void set(Vector3 value)	Define o valor atual dentro deste vetor com um novo vetor do argumento.
void set(float a)	Define o valor atual dentro deste vetor para um novo valor.
void set(float x, float y, float z)	Define o valor atual de X, Y e Z dentro deste vetor para um novo valor.
void SetXY(Vector2 v)	Define o valor atual de X e Y dentro deste vetor com um novo valor.
void SetXZ(Vector2 v)	Define o valor atual de X e Z dentro deste vetor com um novo valor.
void SetYZ(Vector2 v)	Define o valor atual de Y e Z dentro deste vetor com um novo valor.
void SetYX(Vector2 v)	Define o valor atual de Y e X dentro deste vetor com um novo valor.
void SetZX(Vector2 v)	Define o valor atual de Z e X dentro deste vetor com um novo valor.
void SetZY(Vector2 v)	Define o valor atual de Z e Y dentro deste vetor com um novo valor.
Vector3 mul(Vector3 value)	Multiplica os valores do vetor atual com os valores do vetor de entrada e retorna uma nova instância com esses valores multiplicados.
Vector3 mul(float x, float y, [float z])	Multiplica os valores do vetor atual com os valores de entrada X , Y e Z e retorna uma nova instância com esses valores multiplicados.
Vector3 mul(float a)	Multiplica os valores do vetor atual com a entrada "a" e retorna uma nova instância desses valores multiplicados.
void mulX(float value)	Multiplica o valor do argumento ao eixo X do vetor.
void mulY(float value)	Multiplica o valor do argumento ao eixo Y do vetor.
void mulZ(float value)	Multiplica o valor do argumento ao eixo Z do vetor.
void mulLocal(Vector3 value)	Multiplica os valores atuais do vetor pelos valores do vetor de entrada e aplica ao próprio vetor.
void mulLocal(Vector2 value)	Multiplica os valores atuais do vetor pelos valores do vetor de entrada e aplica ao próprio vetor.
void mulLocal(float a)	Multiplica os valores atuais do vetor pela entrada "a" e aplica ao próprio vetor.
void mulLocal(float x, float y, float z)	Multiplica os valores atuais do vetor pelos valores de entrada X , Y e Z e aplica ao próprio vetor.
Vector3 div(Vector3 value)	Divide os valores do vetor atual com os valores do vetor de entrada e retorna uma nova instância com esses valores divididos.
Vector3 div(float x, float y, [float z])	Divide os valores do vetor atual com os valores de entrada X , Y e Z e retorna uma nova instância com esses valores divididos.
Vector3 div(float a)	Divide os valores do vetor atual com a entrada "a" e retorna uma nova instância com esses valores divididos.
void divX(float value)	Divide o valor do argumento para o eixo X do vetor.
void divY(float value)	Divide o valor do argumento para o eixo Y do vetor.
void divZ(float value)	Divide o valor do argumento para o eixo Z do vetor.
void divLocal(Vector3 value)	Divide os valores vetoriais atuais com os valores vetoriais de entrada e aplica ao próprio vetor.
void divLocal(Vector2 value)	Divide os valores vetoriais atuais com os valores vetoriais de entrada e aplica ao próprio vetor.
void divLocal(float a)	Divide os valores atuais do vetor com a entrada "a" e aplica ao próprio vetor.
void divLocal(float x, float y, float z)	Divide os valores atuais do vetor com os valores de entrada X, Y e Z e aplica ao próprio vetor.
Vector3 sum(Vector3 value)	Incrementa os valores do vetor atual com os valores do vetor de entrada e retorna uma nova instância com esses valores incrementados.
Vector3 sum(float x, float y, float z)	Incrementa os valores do vetor atual com os valores de entrada X , Y e Z e retorna uma nova instância com esses valores incrementados.
Vector3 sum(float a)	Incrementa os valores do vetor atual com a entrada "a" e retorna uma nova instância com esses valores incrementados.
void sumX(float value)	Adiciona o valor do argumento ao eixo X do vetor.
void sumY(float value)	Adiciona o valor do argumento ao eixo Y do vetor.
void sumZ(float value)	Adiciona o valor do argumento ao eixo Z do vetor.
void sumLocal(Vector3 value)	Incrementa os valores atuais do vetor com os valores do vetor de entrada e aplica ao próprio vetor.
void sumLocal(Vector2 value)	Incrementa os valores atuais do vetor com os valores do vetor de entrada e aplica ao próprio vetor.
void sumLocal(float a)	Incrementa os valores atuais do vetor com a entrada "a" e aplica ao próprio vetor.
void sumLocal(float x, float y, float z)	Incrementa os valores atuais do vetor com os valores de entrada X , Y e Z e aplica ao próprio vetor.
Vector3 sub(Vector3 value)	Subtrai os valores do vetor atual com os valores do vetor de entrada e retorna uma nova instância com esses valores subtraídos.
Vector3 sub(float x, float y, float z)	Subtrai os valores do vetor atual com a entrada X , Y e Z e retorna uma nova instância com esses valores subtraídos.
Vector3 sub(float a)	Subtrai os valores atuais do vetor com a entrada "a" e retorna uma nova instância com esses valores subtraídos.
void subX(float value)	Subtrai o valor do argumento do eixo X do vetor.
void subY(float value)	Subtrai o valor do argumento do eixo Y do vetor.
void subZ(float value)	Subtrai o valor do argumento do eixo Z do vetor.
void subLocal(Vector3 value)	Subtrai os valores vetoriais atuais dos valores vetoriais de entrada e os aplica ao próprio vetor.
void subLocal(Vector2 value)	Subtrai os valores vetoriais atuais dos valores vetoriais de entrada e os aplica ao próprio vetor.
void subLocal(float a)	Subtrai os valores atuais do vetor com a entrada "a" e aplica ao próprio vetor.
void subLocal(float x, float y, float z)	Subtrai os valores atuais do vetor com a entrada X , Y e Z e aplica ao próprio vetor.
boolean equals(Vector3 value)	Compara o primeiro vetor com aquele no argumento, retorna verdadeiro se os valores corresponderem.
boolean equals(float a)	Compara o primeiro vetor com o valor do argumento, retorna verdadeiro se os valores corresponderem.
boolean equals(float x, float y, float z)	Compara o vetor com o valor dos argumentos respectivamente X, Y e Z, retorna verdadeiro se os valores corresponderem.
float length()	Retorna o comprimento do vetor com a raiz quadrada.
float sqrLength()	Retorna o comprimento do vetor sem raiz quadrada.
float distance(Vector3 value)	Retorna a distância entre dois vetores com a raiz quadrada.
float sqrDistance(Vector3 value)	Retorna a distância entre dois vetores sem a raiz quadrada.
Vector3 copy()	Retorna a cópia perfeita de um vetor.
String toString()	Retorna valores vetoriais para uma String.
String toString(int decimals)	Define o número de casas decimais que os eixos terão ao criar a String.
Vector3 zero()	Retorna um novo vetor com seus eixos em 0.
Vector3 one()	Retorna um novo vetor com seus eixos em 1.
Vector3 normalize()	Faz com que o vetor tenha uma magnitude de 1, o vetor mantém a mesma direção, mas seu comprimento é 1,0, se o vetor for muito pequeno para normalizar, ele é definido como zero.
void normalizeLocal()	Faz com que o vetor tenha magnitude 1, o vetor mantém a mesma direção, mas seu comprimento é 1,0, a diferença para "normalize" é que esse método aplica a modificação no próprio vetor, se o vetor for muito pequeno para normalizar, é definido como zero.
Vector3 sqrNormalize()	Faz com que o vetor tenha uma magnitude de 1 ao quadrado, o vetor mantém a mesma direção, mas seu comprimento é 1,0, se o vetor for muito pequeno para normalizar, ele é definido como zero.
void sqrNormalizeLocal()	Faz com que o vetor tenha magnitude 1 ao quadrado, o vetor mantém a mesma direção, mas seu comprimento é 1,0, a diferença para "normalize" é que esse método aplica a modificação no próprio vetor, se o vetor for muito pequeno para normalizar, é definido como zero.
float dot(Vector3 value)	Calcula o produto escalar deste vetor e o vetor passado no argumento e retorna o valor.
float dot(float a)	Calcula o produto escalar deste vetor e o valor passado no argumento e retorna o valor.
float dot(float x, float y, float z)	Calcula o produto escalar deste vetor e os valores passados, X, Y e Z no argumento e retorna o valor.
Vector3 cross(Vector3 value)	Produto vetorial de dois vetores. O produto vetorial de dois vetores resulta em um terceiro vetor que é perpendicular aos dois vetores de entrada. A magnitude do resultado é igual às magnitudes das duas entradas multiplicadas juntas e então multiplicadas pelo seno do ângulo entre as entradas.
Vector3 cross(float x, float y, float z)	Produto vetorial de dois vetores, respectivamente X, Y e Z, o produto vetorial de dois vetores resulta em um terceiro vetor que é perpendicular aos dois vetores de entrada. A magnitude do resultado é igual às magnitudes das duas entradas multiplicadas juntas e então multiplicadas pelo seno do ângulo entre as entradas.
void lerp(Vector3 value, float speed)	Suaviza esse vetor em outro com base em uma velocidade.
void lerp(float a, float speed)	Suaviza esse vetor em outro com base em uma velocidade.
void lerp(float x, float y, float z, float speed)	Suaviza um vetor em outro, respectivamente X, Y e Z com base em uma velocidade.
void lerpInSeconds(Vector3 value, float speed)	Suaviza um vetor em outro, com base em uma velocidade multiplicada por "Math.bySecond(1)".
void lerpInSeconds(float a, float speed)	Suaviza um vetor em outro, com base em uma velocidade multiplicada por "Math.bySecond(1)".
void lerpInSeconds(float x, float y, float z float speed)	Suaviza um vetor em outro, respectivamente X, Y e Z com base em uma velocidade multiplicada por "Math.bySecond(1)".
void blend(Vector3 value, float blend)	Mistura o vetor com outro.
void blend(float a, float blend)	Mistura o vetor com outro, dada uma porcentagem de 0-1.
void blend(float x, float y, float z)	Mistura o vetor com outro, respectivamente, X, Y e Z, dada uma porcentagem de 0-1.
float magnitude()	Retorna o comprimento deste vetor.
float sqrMagnitude()	Retorna o comprimento ao quadrado deste vetor.
Vector3 smoothDamp(Vector3 a, Vector3 b, Vector3 velocity, float smoothTime, float maxSpeed, float deltaTime)	Transforma um vetor em outro suavemente levando em consideração a passagem do tempo corretamente, para evitar que quedas na taxa de quadros causem um "tremor" no alisamento.
Vector3 smoothDamp(Vector3 a, Vector3 b, Vector3 velocity, float smoothTime, float maxSpeed, float deltaTime, Vector3 out)	Transforma um vetor em outro suavemente levando em consideração a passagem do tempo corretamente, para evitar que quedas na taxa de quadros causem um "tremor" no alisamento.
Vector3 triangleNormal(Vector3 a, Vector3 b, Vector3 c)	Calcula a normal de uma face dados seus 3 vértices.
Vector3 triangleNormal(Vector3 a, Vector3 b, Vector3 c, Vector3 out)	Calcula a normal de uma face dados seus 3 vértices.
Vector3 reflect(Vector3 dir, Vector3 normal)	Calcula o vetor de reflexão dados 2 outros vetores.
Vector3 reflect(Vector3 dir, Vector3 normal, Vector3 out)	Calcula o vetor de reflexão dado 2 outros vetores e o aplica ao próprio vetor do argumento "out".
float angle(Vector3 a, Vector3 b)	Calcula o ângulo em graus entre 2 vetores.
Vector3 rotateAroundPivot(Vector3 vector, float angle)	Rotaciona o vetor a quantidade de graus determinada pelo argumento "angle" em torno das coordenadas 0, 0, 0.
Vector3 rotateAroundPivot(Vector3 vector, Vector3 pivot, float angle)	Rotaciona o vetor a quantidade de graus determinada pelo argumento "angle" em torno das coordenadas "pivot".

— Métodos Estático (9) —

Nome	Descrição
Vector3 Min(Vector3 value1, Vector3 value2)	Retorna um vetor formado pelos menores valores de dois vetores.
Vector3 Max(Vector3 value1, Vector3 value2)	Retorna um vetor formado pelos maiores valores de dois vetores.
Vector3 Negate(Vector3 value)	Retorna o valor negativo do vetor.
Vector3 up()	Retorna um novo Vector3 com seus valores sendo [0, 1, 0].
Vector3 down()	Retorna um novo Vector3 com seus valores sendo [0, -1, 0].
Vector3 back()	Retorna um novo Vector3 com seus valores sendo [0, 0, -1].
Vector3 forward()	Retorna um novo Vector3 com seus valores sendo [0, 0, 1].
Vector3 left()	Retorna um novo Vector3 com seus valores sendo [-1, 0, 0].
Vector3 right()	Retorna um novo Vector3 com seus valores sendo [1, 0, 0].

— Operadores (10) —

+ Soma 2 vetores e retorna um novo com o resultado.

Vector3 a = new Vector3(1, 0, 0);  
Vector3 b = new Vector3(1, 0, 1);  

a + b;

// a = {2, 0, 1}

- Diminui 2 vetores e retorna um novo com o resultado.

Vector3 a = new Vector3(6, 5, 4);  
Vector3 b = new Vector3(6, 2, 3);  

a - b;

// a = {0, 3, 1}

* Multiplica 2 vetores e retorna um novo com o resultado.

Vector3 a = new Vector3(5, 2, 4);  
Vector3 b = new Vector3(5, 2, 4);  

a * b;

// a = {25, 4, 16}

/ Divide 2 vetores e retorna um novo com o resultado.

Vector3 a = new Vector3(1, 2, 3);  
Vector3 b = new Vector3(1, 2, 3);  

a / b;

// a = {1, 1, 1}

+= Soma 2 vetores e aplique o resultado ao próprio vetor.

Vector3 a = new Vector3(5, 5, 5);  
Vector3 b = new Vector3(2, 3, 1);

a += b;

// a = {7, 8, 6}

-= Diminui 2 vetores e aplica o resultado ao próprio vetor.

Vector3 a = new Vector3(5, 5, 5);  
Vector3 b = new Vector3(4, 5, 1);

a -= b;

// a = {1, 0, 1}

/= Divide 2 vetores e aplica o resultado ao próprio vetor.

Vector3 a = new Vector3(10, 0, 0);  
Vector3 b = new Vector3(5, 0, 0);  

a /= b;

// a = {2, 0, 0}

*= Multiplica 2 vetores e aplica o resultado ao próprio vetor.

Vector3 a = new Vector3(2, 2, 2);
Vector3 b = new Vector3(4, 3, 2);

a *= b;

// a = {8, 6, 4}

++ Soma 1 ao vetor.

Vector3 a = new Vector3(5, 0, 0);

a++;

// a = {6, 0, 0}

-- Diminui 1 do vetor.

Vector3 a = new Vector3(5, 0, 0);  

a--;

// a = {4, 0, 0}

— Comparadores (5) —

>= Compara se o comprimento do vetor é maior ou igual ao outro.

Vector3 a = new Vector3(10,0,0);  

if(a >= 10){  

    // VERDADEIRO porque o comprimento do vetor "a" é 10 ou maior  
    
}

<= Compara se o comprimento do vetor é menor ou igual ao outro.

Vector3 a = new Vector3(10,0,0);  

if(a <= 15){  

    // VERDADEIRO porque o comprimento é menor que "15"   
    
}

> Compara se o comprimento do vetor é maior que o outro.

Vector3 a = new Vector3(10,0,0);  

if(a > 10){  

    // FALSO porque o comprimento do vetor "a" é 10 e não maior  
    
}

< Compara se o comprimento do vetor é maior que o outro.

Vector3 a = new Vector3(10,0,0);  

if(a < 10){  

    // FALSO porque o comprimento do vetor "a" não é menor que 10  
    
}

== Compara se os 3 eixos do Vector3 são iguais.

Vector3 a = new Vector3(10, 10, 10);
Vector3 b = new Vector3(10, 10, 10);

if(a == b){
  
    // VERDADEIRO porque o comprimento do vetor "a" é igual ao do vetor "b" 
    
}