Question

我想根据自己的方向移动一个对象。该对象具有平移向量和旋转向量（度）。我可以调用方法移动并给它一个方向和对象应该移动的单位（如果你愿意，速度）。如果我给这个方法指的是“FORWARD”方向，而不是它应该朝着对象当前面向的方向移动。

我目前有这个代码：

/*
 * MIT License
 * 
 * Copyright (c) 2017 Ralph Niemitz
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
package de.ralleytn.engine.lunatic;

import javax.vecmath.Vector3f;

/**
 * Merges rotation with translation and adds translation based on rotation.
 * @author Ralph Niemitz/RalleYTN(ralph.niemitz@gmx.de)
 * @version 1.0.0
 * @since 1.0.0
 */
public interface Movable extends Translatable, Rotatable {

    /**
     * Moves the object into the given direction based on its own rotation.
     * @param direction the direction in which the object should be moved
     * @param units the number of units it should be moved
     * @since 1.0.0
     */
    public default void move(Direction direction, float units) {

        float nUnits = -units;
        Vector3f rotation = this.getRotation();

        if(direction == Direction.LEFT) {

            float rY = (float)Math.toRadians(rotation.y);
            float rZ = (float)Math.toRadians(rotation.z);

            float x = (float)Math.cos(rY) * nUnits;
            float y = (float)Math.sin(rZ) * units;
            float z = (float)Math.sin(rY) * nUnits;

            this.translate(x, y, z);

        } else if(direction == Direction.RIGHT) {

            // float rX = (float)Math.toRadians(rotation.x);
            float rY = (float)Math.toRadians(rotation.y);
            float rZ = (float)Math.toRadians(rotation.z);

            float x = (float)Math.cos(rY) * units;
            float y = (float)Math.sin(rZ) * nUnits;
            float z = (float)Math.sin(rY) * units;

            this.translate(x, y, z);

        } else if(direction == Direction.FORWARD) {

            float rX = (float)Math.toRadians(rotation.x);
            float rY = (float)Math.toRadians(rotation.y - 90.0F);

            float x = (float)Math.cos(rY) * units;
            float y = (float)Math.sin(rX) * nUnits;
            float z = (float)Math.sin(rY) * units;

            this.translate(x, y, z);

        } else if(direction == Direction.BACKWARD) {

            float rX = (float)Math.toRadians(rotation.x);
            float rY = (float)Math.toRadians(rotation.y - 90.0F);

            float x = (float)Math.cos(rY) * nUnits;
            float y = (float)Math.sin(rX) * units;
            float z = (float)Math.sin(rY) * nUnits;

            this.translate(x, y, z);

        } else if(direction == Direction.UP) {

            float rX = (float)Math.toRadians(rotation.x);
            float rZ = (float)Math.toRadians(rotation.z);

            float x = (float)Math.sin(rZ) * nUnits;
            float y = (float)Math.cos(rX) * units;
            float z = (float)Math.sin(rX) * nUnits;

            this.translate(x, y, z);

        } else if(direction == Direction.DOWN) {

            float rX = (float)Math.toRadians(rotation.x);
            float rZ = (float)Math.toRadians(rotation.z);

            float x = (float)Math.sin(rZ) * units;
            float y = (float)Math.cos(rX) * nUnits;
            float z = (float)Math.sin(rX) * units;

            this.translate(x, y, z);
        }
    }
}

它实际上并不像我想要的那样。我对3D很新，所以我没有那么多的知识。到目前为止我看到的所有解决方案都是针对Unity和C＃的，这对我没有帮助。

如果这很重要，我正在使用javax.vecmath包。

Answer 1

有不同的方式来完成你的要求。

其中一个应该是维护一个前向矢量，并在Object实例中表示你的旋转。前向矢量应该用 vec3（0,0,1）初始化;

我不知道什么是Vector3f rotation = this.getRotation();如果它是欧拉角（偏航，俯仰和滚转），你应该避免对自己进行三角测量并使用一些预定义函数来计算基于的旋转矩阵那些角度here

您可以在开始时只使用Rx和Ry，并使用以下方法：对于Ry来说glRotatef(value, 0, 1, 0);

glRotatef(value, 1, 0, 0);代表Rx

现在，每次完成旋转时，都应更新这些旋转值。从旋转矩阵开始，然后将此旋转矩阵应用于 InitialForwardvector 。

m_rotation = Matrix4f.identity().rotateX(Rx).rotateY(Ry);
m_forward  = m_rotation * vec3(0, 0, 1);

现在判断你的翻译时间

vec3 translationVector = speed * m_forward;
this.translate(translationVector.x, translationVector.y, translationVector.z);

如果你想向左转，你可以通过向旋转矩阵的偏航增加90°来计算左矢量。我不确定这是你在视频游戏中有时会想要的，只能在XZ平面上移动。

Matrix4f rotation = Matrix4f.identity().rotateX(Rx /* maybe 0 */).rotateY(Ry + 1.57);
m_left = m_rotation * vec3(0, 0, 1);

您还可以计算初始左侧矢量，删除上面的代码并使用相同的旋转矩阵但应用于左侧矢量，您将获得更好的性能。试着让你的initLeftVector与你的initialForward一行垂直。

vec3 initialLeft = vec3(1, 0, 0);
m_left = m_rotation * initialLeft;

LWJGL3根据自己的轮换移动实体

1 个答案: