Java围绕Y轴旋转3D顶点

我有一个3D模型，我需要绕Y轴旋转它的顶点（在我的例子中，该轴笔直向上）。例如，假设我有垂直 （3,2,3）（x，y，z）当我绕y轴旋转时，只有x和z会改变。我如何使用度在java中实现这一点？提前谢谢

（仅供参考）这是用于旋转我的hitbox上的点。每个“长方体”只是一个三角形，但被包裹在一个立方体中，所以我可以检查立方体中是否有一个点。这是按照每个模型的每个三角形进行的。这是完美的，因为我可以在有洞的网格中行走。然而，如果应用任何旋转，奇怪的事情开始发生

编辑：这是我使用Andys方法的代码

public static boolean checkPointCollision(Vector3f pos){
    boolean hit=false;
    float px=Math.round(pos.x);
    float py=Math.round(pos.y);
    float pz=Math.round(pos.z);
    px=pos.x;
    py=pos.y;
    pz=pos.z;

    long startTime=System.currentTimeMillis();

    float xmin,ymin,zmin,xmax,ymax,zmax,scale,rot;

    //Cube Collisions
    for (Entity entity : entities) {
        int colID=entity.getCollisionIndex();
        boolean entHasHitbox = entity.hasHitbox();
        if(colID!=-1 && hit==false && entHasHitbox){

            //Gets the entitys variables
            scale = entity.getScale();
            rot = entity.getRotY();
            //Converts to radians
            rot = (float) Math.toRadians(rot);

            xmin = 0;
            ymin = 0;
            zmin = 0;
            xmax = 0;
            ymax = 0;
            zmax = 0;

            switch(entity.getCollisionType()){
            case 1:
                if(entHasHitbox){

                    //Gets the entities hitbox
                    List<Vector3f> hitboxMins = entity.getHitboxMin();
                    List<Vector3f> hitboxMaxs = entity.getHitboxMax();

                    for (int i = 0; i < hitboxMins.size(); i++) {

                        //Gets the entities hitbox points
                        Vector3f min = hitboxMins.get(i);
                        Vector3f max = hitboxMaxs.get(i);

                        //Sets all local position vars to the hitboxes mins and maxes

                        xmin = min.x;
                        ymin = min.y;
                        zmin = min.z;
                        xmax = max.x;
                        ymax = max.y;
                        zmax = max.z;

                        //Applies the models scale

                        xmin *=scale;
                        ymin *=scale;
                        zmin *=scale;
                        xmax *=scale;
                        ymax *=scale;
                        zmax *=scale;

                        //Rotates points

                        float nxmin = (float) (Math.cos(rot) * xmin - Math.sin(rot) * zmin);
                        float nzmin = (float) (Math.sin(rot) * xmin + Math.cos(rot) * zmin);
                        float nxmax = (float) (Math.cos(rot) * xmax - Math.sin(rot) * zmax);
                        float nzmax = (float) (Math.sin(rot) * xmax + Math.cos(rot) * zmax);

                        //Sets old points to new ones

                        xmin = nxmin;
                        zmin = nzmin;
                        xmax = nxmax;
                        zmax = nzmax;

                        //Increase local points to the entitys world position

                        xmin += entity.getPosition().x;
                        xmax += entity.getPosition().x;
                        ymin += entity.getPosition().y;
                        ymax += entity.getPosition().y;
                        zmin += entity.getPosition().z;
                        zmax += entity.getPosition().z;

                        //Debug
                        if(entities.get(17)==entity){//entities.get(17).increaseRotation(0, 10, 0);
                            System.out.println(xmin+","+ymin+","+zmin);
                        }

                        //Check if point is in the hitbox

                        if(px>=xmin && px<=xmax
                                && py>=ymin && py<=ymax
                                && pz>=zmin && pz<=zmax)
                        {
                            hit=true;
                            //Ends to loop
                            i=hitboxMins.size();
                        }

                    }
                }
            break;
            }

        }
    }

    long endTime = System.currentTimeMillis()-startTime;
    if(endTime>10){
        System.out.println("Delay in Point Collision");
    }

    return hit;
}

公共静态布尔检查点冲突（Vector3f pos）{
布尔命中=假；
浮点px=数学四舍五入（位置x）；
浮动py=数学圆（位置y）；
浮动pz=数学圆（位置z）；
px=位置x；
py=位置y；
pz=位置z；
long startTime=System.currentTimeMillis（）；
浮子xmin，ymin，zmin，xmax，ymax，zmax，鳞片，腐烂；
//立方体碰撞
for（实体：实体）{
int colID=entity.getCollisionIndex（）；
布尔值entHasHitbox=entity.hasHitbox（）；
if（colID！=-1&&hit==false&&entHasHitbox）{
//获取实体的变量
scale=entity.getScale（）；
rot=entity.getRotY（）；
//转换为弧度
rot=（浮动）数学托拉迪安（rot）；
xmin=0；
ymin=0；
zmin=0；
xmax=0；
ymax=0；
zmax=0；
开关（entity.getCollisionType（））{
案例1：
如果（第四个盒子）{
//获取实体复选框
List hitboxMins=entity.getHitboxMin（）；
列出hitboxMaxs=entity.getHitboxMax（）；
对于（int i=0；i=xmin&&px=ymin&&py=zmin&&pz10）{
System.out.println（“点碰撞延迟”）；
}
回击；
}

将您的点乘以以下矩阵：

[ c 0 -s ]
[ 0 1  0 ]
[ s 0  c ]

i、 e

其中，

（x，y，z）

是原始坐标，

（newx，newy，newz）

是旋转坐标，

c=cos（angle）

和

s=sin（angle）

。请注意，Java的trig函数将其参数作为弧度，因此需要修改

如果您以前没有使用过矩阵，这相当于以下三个表达式：

newx = c * x - s * z
newy = y
newz = s * x + c * z

---

将你的度数转换为弧度。Hmm=/只是为了让你了解我在做什么，我正在旋转我的“对象”对话框上的点。实现你的等式后，我的角色旋转的任何对象都会直接穿过它们。我更新了项目以显示我的代码

newx = c * x - s * z
newy = y
newz = s * x + c * z