3d 处理3：如何将轴保持在默认位置？

我在Processing 3.5.4中制作了一个3D益智游戏，用户点击益智方块旋转它们。

用户可以进行的旋转有：

• 按鼠标右键单击X轴（向上）
• 按左键单击Y轴（向右）
• Z轴（从上表面到右表面），按“中心”单击

问题是，每个立方体也会随轴旋转。这意味着，如果我在Y轴上旋转一个
立方体，然后我想在X轴上旋转它，它不会像预期的那样旋转，但它会在Z轴上逆时针旋转。
我猜轴也会随着立方体旋转，因此如果我将立方体向右旋转，Z轴将变成
X轴，如果我继续旋转，Z轴和X轴将反转，依此类推。

我说得对吗？如果是，如何将轴保持在默认位置？

注：如果可能的话，我不想使用图书馆。

拼图立方体的代码：

    public class PuzzleCube
    {
        private final float l;
        private final PVector position;
        private float angX, angY, angZ;
        private float endX, endY, endZ;
        private boolean rotateX, rotateY, rotateZ;
        private final int puzzleWidth, puzzleHeight;
        private final PImage[] textures;

        public PuzzleCube(float l, PVector position, int puzzleWidth,
            int puzzleHeight, PImage[] textures)
        {
            textureMode(NORMAL);
            this.l = l;
            this.position = position;
            this.puzzleWidth = puzzleWidth;
            this.puzzleHeight = puzzleHeight;
            this.textures = textures;
            angX = 0.0;
            angY = 0.0;
            angZ = 0.0;
            endX = HALF_PI;
            endY = HALF_PI;
            endZ = HALF_PI;
            rotateX = false;
            rotateY = false;
            rotateZ = false;
        }

        private void update()
        {
            if (rotateX)
                turnX();
            if (rotateY)
                turnY();
            if (rotateZ)
                turnZ();
        }

        public void draw(float u, float v)
        {

            update();
            float h = (float) 1 / puzzleWidth; // For UV coordinates
            float w = (float) 1 / puzzleHeight; // For UV coordinates
            pushMatrix();
            // Placing the cube in the right position
            translate(position.x + (l / 2) * (puzzleWidth - 3),
                      position.y + (l / 2) * (puzzleHeight - 3));
            // Rotating the cube
            rotateY(angY);
            rotateX(angX);
            rotateZ(angZ);
            // Puzzle cube creation here...
            // With beginShape(), endShape() and texture()
            // Not posted due to the length of the code
            popMatrix();
        }

        private void turnX()
        {
            final double inc = HALF_PI / (frameRate / 6);
            if (angX < endX)
                angX += inc;
            if (angX >= endX)
            {
                angX = endX;
                endX += HALF_PI;
                rotateX = false;
            }
        }

        private void turnY()
        {
            final double inc = HALF_PI / (frameRate / 6);
            if (angY < endY)
                angY += inc;
            if (angY >= endY)
            {
                angY = endY;
                endY += HALF_PI;
                rotateY = false;
            }
        }

        private void turnZ()
        {
            final double inc = HALF_PI / (frameRate / 6);
            if (angZ < endZ)
                angZ += inc;
            if (angZ >= endZ)
            {
                angZ = endZ;
                endZ += HALF_PI;
                rotateZ = false;
            }
        }

公共类
{
私人最终浮动利率；
私人最终PVector位置；
私人浮动焦虑，焦虑，焦虑；
私有浮点endX、endY、endZ；
私有布尔rotateX、rotateY、rotateZ；
私有最终整型拼图宽度、拼图高度；
私人最终PImage[]纹理；
公共拼图立方体（浮点l、PVector位置、整数拼图宽度、，
int拼图高度，PImage[]纹理）
{
纹理模式（正常）；
这个。l=l；
这个位置=位置；
this.拼图宽度=拼图宽度；
this.拼图高度=拼图高度；
这个。纹理=纹理；
angX=0.0；
angY=0.0；
angZ=0.0；
endX=半π；
endY=半π；
endZ=半π；
rotateX=假；
rotateY=false；
rotateZ=假；
}
私有void更新（）
{
if（rotateX）
turnX（）；
if（rotateY）
turnY（）；
如果（旋转）
turnZ（）；
}
公共无效提款（浮动u、浮动v）
{
更新（）；
float h=（float）1/puzzleWidth；//用于UV坐标
float w=（float）1/puzzleHeight；//用于UV坐标
pushMatrix（）；
//将立方体放置在正确的位置
平移（位置x+（l/2）*（宽度-3），
位置y+（l/2）*（高度-3））；
//旋转立方体
罗蒂（angY）；
rotateX（angX）；
rotateZ（angZ）；
//在这里创建拼图立方体。。。
//使用beginShape（）、endShape（）和texture（）
//由于代码长度而未过帐
popMatrix（）；
}
私有void turnX（）
{
最终双inc=半π/（帧率/6）；
如果（angX=endX）
{
angX=endX；
endX+=半π；
rotateX=假；
}
}
私家车
{
最终双inc=半π/（帧率/6）；
如果（angY=endY）
{
angY=endY；
endY+=半π；
rotateY=false；
}
}
二等兵
{
最终双inc=半π/（帧率/6）；
if（angZ=endZ）
{
angZ=endZ；
endZ+=半π；
rotateZ=假；
}
}