Matemáticas Tridimensionales (1)

Videotutorial: https://www.bilibili.com/video/BV12s411g7gU?p=155

Tabla de contenido

Propiedades y métodos comunes de los vectores

vector

Una lista de números, que indica el desplazamiento direccional en cada dimensión; también es una cantidad física con tamaño y dirección, el tamaño y el módulo de longitud del vector, y la dirección es la dirección del vector en el espacio, que puede representar la posición y dirección del objeto

forma vectorial

el tamaño (módulo) del vector

la raíz cuadrada de la suma de los cuadrados de los componentes del vector

API:

Vector3.magnitude : longitud del módulo

Vector3..sqrMagnitude : el cuadrado del módulo

la dirección del vector

La obtención de la dirección del vector también se denomina "vector normalizado", o "vector normalizado", es decir, el vector unitario del vector (un vector de tamaño 1).

Significado geométrico: alargar o acortar el vector para que la longitud del módulo sea igual a 1

API:

Vector3.normalizado : obtiene el vector unitario de este vector

Vector3 vector2=vector1.normalized;//vector2为vector1的单位向量

Vector3.Normalize : Establece el propio vector como un vector unitario

vector1.Normalize();//将vector1自身设置为单位向量

private void Update()
{
    Demo01();
    Demo02();
}

//模长
private void Demo01()
{
    Vector3 pos = this.transform.position;

    float m01 = Mathf.Sqrt(Mathf.Pow(pos.x, 2) + Mathf.Pow(pos.y, 2) + Mathf.Pow(pos.z, 2));
    float m02 = pos.sqrMagnitude;
    float m03 = Vector3.Distance(Vector3.zero, pos);

    Debug.LogFormat("{0}--{1}--{2}", m01, m02, m03);
    
    Debug.DrawLine(Vector3.zero, pos);
}

//方向
private void Demo02()
{
    Vector3 pos = this.transform.position;
    Vector3 n01 = pos / pos.magnitude;
    Vector3 n02 = pos.normalized;

    Debug.DrawLine(Vector3.zero, n02, Color.red);
}

Operaciones vectoriales (1)

Resta vectorial : igual a la suma y resta de cada componente, se utiliza para calcular la distancia y la dirección relativa entre dos puntos

Significado geométrico: el vector a se resta del vector b, y el resultado se entiende como un vector que comienza en el punto final de b y termina en el punto final de a. dirección de b a a

Suma de vectores : igual a la suma de cada componente, aplicada al movimiento de objetos

Significado geométrico: agregue el vector a al vector b, trasládelo para que el punto inicial de b coincida con el punto final de a, y el resultado es un vector con el punto inicial de a como el punto inicial y el punto final de b como el punto final

Multiplicación y división vectorial y escalar

Multiplicación: Multiplica cada componente del vector por un escalar, k[xy,z]= [xk,yk,zk]

División: cada componente del vector se divide por un escalar; [x,y,z]/k = [x/k,y/k,z/k]

Significado geométrico: longitud del vector de escala

pd: cuando desee escalar un determinado vector a una longitud específica, primero puede obtener el vector de dirección del vector y luego multiplicarlo/dividirlo por el factor de escala


public Transform t1, t2, t3;

private void Update()
{
    Demo03();
}

//向量运算
private void Demo03()
{
    //t1相对于t2的位置
    //其大小为两点间距离
    Vector3 relativeDirection = t1.position - t2.position;

    //t3沿relativeDirection方向移动
    if (Input.GetKeyDown(KeyCode.A))
    //获取方向向量，避免两物体间距离对速度造成影响
    //t3.Translate(relativeDirection.normalized * 0.5f);
    t3.position+=relativeDirection.normalized;

    Debug.DrawLine(Vector3.zero, relativeDirection);
}

Funciones trigonométricas

medida de angulo

PI=180 grados 1 radián=180 grados/PI 1 ángulo=PI/180 grados

Ángulo --> radianes: radianes = número de ángulos * PI/180

API: Radian = número de grados * Mathf.Deg2Rad

Radianes --> Ángulo: Ángulo = número de radianes * 180/PI

API: ángulo = número de radianes * Mathf.Rad2Deg

private void Demo01()
{
    //角度-->弧度：弧度=角度数*PI/180
    float d1 = 60;
    float r1 = d1 * Mathf.PI / 180;
    float r2 = d1 * Mathf.Deg2Rad;
    print("角度-->弧度：" + d1 + "-->" + r1 + "/" + r2);
}

private void Demo02()
{
    //弧度-->角度：角度=弧度数*180/PI
    float r1 = 3;
    float d1 = r1 * 180 / Mathf.PI;
    float d2 = r1 * Mathf.Rad2Deg;
    print("弧度-->角度：" + r1 + "-->" + d1 + "/" + d2);
}

Funciones trigonométricas

Estableció la relación entre la razón del ángulo y la longitud del lado en un triángulo rectángulo

Seno: sen x = a/c

Coseno: cos x = b/c

Tangente: tan x = a/b

API ( en radianes ):

Seno: Mathf.Sin

Coseno: Mathf.Cos

Título: Mathf.Tan

funciones trigonométricas inversas

El término general para funciones como arcoseno, arcocoseno y arcotangente; se puede usar para calcular ángulos en función de la longitud de ambos lados.

Arcoseno: arcsen a/c = x

Coseno inverso: arccos b/c = x

arco tangente: arctan a/b = x;

API ( en radianes ):

Arcoseno: Mathf.Asin

Arco coseno: Mathf.Acos

Arco tangente: Mathf.Atan

private void Demo03()
{
    //已知角度x，边长b，求边长a
    float x = 50, b = 20;
    float a = Mathf.Tan(x * Mathf.Deg2Rad);

    //已知边长a，边长b，求角度angle
    float angle = Mathf.Atan(a / b) * Mathf.Rad2Deg;

    print(angle);
}

private void Demo04()
{
    //将自身坐标系转换到世界坐标系中
    //Vector3 worldPos = transform.TransformPoint(0, 0, 10);

    //计算物体前方30度，10m远的坐标
    float x = Mathf.Sin(30 * Mathf.Deg2Rad) * 10;
    float z = Mathf.Cos(30 * Mathf.Deg2Rad) * 10;
    Vector3 worldPos = transform.TransformPoint(x, 0, z);
    print(worldPos);
}

Transform.TransformPoint (posición Vector3) : transforma la posición del espacio local al espacio mundial

Operaciones vectoriales (2)

punto multiplicar

También conocido como "producto punto" o "producto interno"

Significado geométrico: el vector unitario de dos vectores se multiplica y luego se multiplica por el coseno del ángulo entre ellos

ab=|a|·|b| porque<a,b>

Aplicación: Calcular el ángulo entre dos vectores; para un vector estandarizado, el resultado del producto escalar es igual al coseno del ángulo entre los dos vectores

API:

Vector3.Dot : el producto escalar de dos vectores. El producto escalar es un valor de punto flotante igual a multiplicar las magnitudes de los dos vectores y luego multiplicar por el coseno del ángulo entre los vectores.

public Transform t1, t2, t3;
//点乘
//计算两向量夹角的cos值
float dot = Vector3.Dot(t1.position.normalized,t2.position.normalized);
float angle= Mathf.Acos(dot)*Mathf.Rad2Deg;

pd: la multiplicación de puntos puede calcular el valor coseno del ángulo entre dos vectores, pero no puede determinar el cuadrante del ángulo; si desea determinar el cuadrante del ángulo, debe combinar el producto cruzado del vector

Para un vector estandarizado, si las dos direcciones son iguales, el resultado del producto escalar es 1; de lo contrario, el resultado del producto escalar es -1; el resultado de ser perpendiculares entre sí es 0

producto cruz

También conocido como "producto cruzado" o "producto externo"

Significado geométrico: el resultado es el vector vertical de la superficie formada por los dos vectores, y el módulo de longitud es el producto del módulo de longitud de los dos vectores multiplicado por el seno del ángulo comprendido

Aplicación: 1. Crear un vector perpendicular al plano 2. Determinar la posición relativa de dos vectores.

API:

Vector3.Cross : el producto cruzado de dos vectores, el producto cruzado de dos vectores genera un tercer vector, que es perpendicular a los dos vectores de entrada

//点乘
//计算两向量夹角的cos值
float dot = Vector3.Dot(t1.position.normalized,t2.position.normalized);
float angle= Mathf.Acos(dot)*Mathf.Rad2Deg;

//叉乘
Vector3 cross=Vector3.Cross(t1.position,t2.position);
if(cross.y<0)
{
    angle=360-angle;
}
Debug.DrawLine(Vector3.zero,cross);

pd: Oriente el vector resultante de acuerdo con la "regla de la mano izquierda"

La longitud del módulo y el ángulo del vector obtenido por producto cruzado: 0~90 grados

Propiedades y métodos comunes de los vectores

propiedad estática

1. Vector3.up -->nuevo Vector3(0,1,0)

2. Vector3.abajo -->nuevo vector3(0,-1,0)

3. Vector3.izquierda -->nuevo Vector3(-1,0,0)

4. Vector3.derecha -->nuevo Vector3(1,0,0)

5. Vector3.adelante -->nuevo Vector3(0,0,1)

6. Vector3.atrás -->nuevo Vector3(0,0,-1)

método estático

1. Vector3.Lerp y Vector3.Lerp sin sujetar

Vector3.Lerp :

//将物体移动到(0,0,10)
//先快后慢 不能到达目标点（无限接近）
this.transform.position = Vector3.Lerp(this.transform.position, targetPos, 0.1f);

Vector3.LerpDesbloqueado :

configuración de parámetros

Haga clic en la propiedad Curva para editar la curva.

public AnimationCurve curve;
private float x = 0;
//持续时间
public float duration;

x += Time.deltaTime / duration;
//自然运动 起始点固定 终点固定 比例根据曲线变化
this.transform.position = Vector3.LerpUnclamped(Vector3.zero, targetPos, curve.Evaluate(x));

2. Vector3.MoveTowards(Vector3 current, Vector3 target, float maxDistanceDelta) : calcula la posición entre el punto especificado por current y el punto especificado por target, y la distancia de movimiento no excede la distancia especificada por maxDistanceDelta

actual	posición inicial del movimiento
objetivo	ubicación objetivo del movimiento
maxDistanciaDelta	La distancia recorrida por llamada

//将物体移动到(0,0,10)
//匀速移动，可到达目标点
this.transform.position = Vector3.MoveTowards(this.transform.position, targetPos, 1);

3. Vector3.SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed= Mathf.Infinity, float deltaTime= Time.deltaTime): cambia gradualmente un vector al objetivo deseado a lo largo del tiempo

actual	ubicación actual
objetivo	qué tratar de lograr
velocidad actual	velocidad actual, este valor es modificado por la función en cada llamada
SuavizarTiempo	Tiempo aproximado necesario para llegar a la meta. Cuanto menor sea el valor, más rápido se alcanzará la meta
máxima velocidad	Opción para permitir limitar la velocidad máxima
tiempo delta	El tiempo desde la última llamada a esta función. Time.deltaTime por defecto

4. Vector3.Angle(Vector3 from, Vector3 to) : devuelve el ángulo entre dos vectores en grados

de	vector de origen para medir la diferencia angular
a	vector objetivo para medir la diferencia angular

5. Vector3.ProjectOnPlane(Vector3 vector, Vector3 planeNormal) : Proyecta un vector en un plano definido por una normal (la normal es normal al plano)

avionNormal	dirección del vector al plano
vector	la posición del vector sobre el plano

public Transform t1;
public Vector3 planeNorm;
private Vector3 targetPos = new Vector3(0, 0, 10);

private void Update()
{
    Vector3 res = Vector3.ProjectOnPlane(t1.position, planeNorm);
    
    Debug.DrawLine(Vector3.zero, t1.position);
    Debug.DrawLine(Vector3.zero, res, Color.red);
}

configuración de parámetros

correr

6.Vector3.Reflect( Vector3 inDirection, Vector3 inNormal): refleja un vector desde el plano definido por la normal

El vector inNormal define un plano (la normal del plano es un vector perpendicular a su superficie), el vector inDirection se considera como una flecha direccional que ingresa al plano y el valor de retorno es un vector con el mismo tamaño que inDirection y la dirección de su dirección de reflexión