如何获得自动瞄准的两个 3D 矢量之间的角度（俯仰/偏航）

Question

I'm trying to get the angles between two vectors (My Camera Position and Enemy Position) to create an autoaim/aimbot.

The game is Unity based, it uses the left handed coordinate system. XYZ is right, up, forward.

The game also uses degrees.

Here is the pseudocode I am trying but its failing to give me the proper pitch/yaw.

diff = camera_position - enemy_position
hypotenuse = sqrt(diff.x*diff.x + diff.y*diff.y)

angle.x = asinf(diff.z / hypotenuse) * (180 / PI);
angle.y = atan2(diff.y / diff.x) * (180 / PI);
angle.z = 0.0f;

Can someone help me with this? I am terrible at math.

Answer 1

I'm trying to get the angles between two vectors (My Camera Position and Enemy Position)

In Unity :

Use the Angle function from Vector3 structure.

float angle = Vector3.Angle(camera_position, enemy_position);

Or Individual angles:

float angleX = Vector3.Angle(new Vector3(camera_position.x, 0, 0), new Vector3(enemy_position.x, 0, 0));
float angleY = Vector3.Angle(new Vector3(0, camera_position.y, 0), new Vector3(0, enemy_position.y, 0));
float angleZ = Vector3.Angle(new Vector3(0, 0, camera_position.z), new Vector3(0, 0, enemy_position.z));

EDIT :

I'm not using the Unity engine. This is a separate module I am creating to rig my own autoaim. I'm trying to do get the proper math itself.

In C++ :

The code is explained in the Angle function below which is the last function

#include <iostream>
#include <numeric> //for inner_product
#include <vector> //For vector
#include <math.h> //For sqrt, acos and M_PI

float Dot(std::vector<float> lhs, std::vector<float> rhs);
float magnitude(std::vector<float> vec3);
float Angle(std::vector<float> from, std::vector<float> to);
std::vector<float> normalise();

int main()
{
    std::vector<float> from{3, 1, -2};
    std::vector<float> to{5, -3, -7 };

    float angle = Angle(from,to);
    std::cout<<"Angle: "<<angle<<std::endl;
    return 0;
}

//Find Dot/ Scalar product 
float Dot(std::vector<float> lhs, std::vector<float> rhs){
    return std::inner_product(lhs.begin(), lhs.end(), rhs.begin(), 0);
}

//Find the magnitude of the Vector
float magnitude(std::vector<float> vec3)//<! Vector magnitude
{
   return sqrt((vec3[0] * vec3[0]) + (vec3[1] * vec3[1]) + (vec3[2] * vec3[2]));
}

//Normalize Vector. Not needed here
std::vector<float> normalise(std::vector<float> vect)  
{
    std::vector<float> temp{0, 0, 0};
    float length = magnitude(vect);

    temp[0] = vect[0]/length;
    temp[1] = vect[1]/length;
    temp[2] = vect[2]/length;
    return temp;
}

float Angle(std::vector<float> from, std::vector<float> to){
   //Find the scalar/dot product of the provided 2 Vectors
   float dotProduct = Dot(from, to);
   //Find the product of both magnitudes of the vectors then divide dot from it
   dotProduct = dotProduct / (magnitude(from) * magnitude(to));
   //Get the arc cosin of the angle, you now have your angle in radians 
   float arcAcos = acos(dotProduct);
   //Convert to degrees by Multiplying the arc cosin by 180/M_PI
   float angle = arcAcos * 180 / M_PI;
   return angle; 
}

Answer 2

To calculate the angle between two 3d coordinates, in degrees you can use this CalcAngle Function:

#include <algorithm>
#define PI 3.1415927f

struct vec3
{
    float x, y, z;
}

vec3 Subtract(vec3 src, vec3 dst)
{
    vec3 diff;
    diff.x = src.x - dst.x;
    diff.y = src.y - dst.y;
    diff.z = src.z - dst.z;
    return diff;
}

float Magnitude(vec3 vec)
{
    return sqrtf(vec.x*vec.x + vec.y*vec.y + vec.z*vec.z);
}

float Distance(vec3 src, vec3 dst)
{
    vec3 diff = Subtract(src, dst);
    return Magnitude(diff);
}

vec3 CalcAngle(vec3 src, vec3 dst)
{
    vec3 angle;
    angle.x = -atan2f(dst.x - src.x, dst.y - src.y) / PI * 180.0f + 180.0f;
    angle.y = asinf((dst.z - src.z) / Distance(src, dst)) * 180.0f / PI;
    angle.z = 0.0f;

    return angle;
}

Complications:

Not all games use the same technique for angles and positions. Min and Max values for x, y and z angles can be different in every game. The basic idea is the same in all games, they just require minor modification to match each game. For example, in the game the code was written for, the X value has to be made negative at the end for it to work.

Another complication is X, Y and Z don't always represent the same variables in both coordinates and angle vec3s.