Java 如何使我的第一人称相机平滑？

我已经想出了如何制作一个简单的第一人称相机，但我想让相机窒息，任何方法都可以（即加速）

我还没有找到任何简单的方法来增加相机的平滑度，希望你们能帮上忙

相机类（在制品）

package entities;

import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.Display;
import org.lwjgl.util.vector.Vector3f;

import renderEngine.DisplayManager;
import terrains.Terrain;

public class Camera
{
    private float distanceFromPlayer = 50;
    private float angleAroundPlayer = 0;
    private boolean FPS = false;

    private Vector3f position = new Vector3f(110, 10, -52);
    private float pitch = 20;
    private float yaw;
    private float roll;

    private static final float RUN_SPEED = 20;
    private static final float GRAVITY = -50f;
    private static final float JUMP_POWER = 30;

    private int clickedOnPlayer = 0;

    private float upwardsSpeed = 0;

    private boolean isInAir = false;

    private Player player;

    public Camera(Player player)
    {
        this.player = player;
    }

    public void move(Terrain terrain)

        {

            Mouse.setGrabbed(true);
            this.yaw = (Mouse.getX());
            float MouseY = Mouse.getY();

            if(MouseY > 360)
            {
                pitch = 465 - MouseY;
            }

            if (yaw >= 1079)
            {
                Mouse.setCursorPosition(Display.getWidth() / 2 + 80,
                        Display.getHeight() / 2);
                this.yaw = 720;
            }
            else if (yaw <= 359)
            {
                Mouse.setCursorPosition(Display.getWidth() / 2 + 80,
                        Display.getHeight() / 2);
                this.yaw = 720;
            }

            if(pitch <= -100)
            {
                pitch = -100;
            }

            float theta = yaw - 720;

            float offsetX = (float) (2 * Math.sin(Math.toRadians(theta)));
            float offsetZ = (float) (2 * Math.cos(Math.toRadians(theta)));
            moveCamera();
            upwardsSpeed += GRAVITY * DisplayManager.getFrameTimeSeconds();
            position.y += upwardsSpeed * DisplayManager.getFrameTimeSeconds();
            player.getPosition().y += upwardsSpeed * DisplayManager.getFrameTimeSeconds();
            float terrainHeight = terrain.getHeightOfTerain(player.getPosition().x, player.getPosition().z);
            if (position.y - 10 <= terrainHeight)
            {
                upwardsSpeed = 0;
                isInAir = false;
                position.y = terrainHeight + 10;
                player.getPosition().y = terrainHeight;
            }

            player.getPosition().x = position.x - offsetX;
            player.getPosition().z = position.z + offsetZ;
            player.setRotY(180 - theta);

        }




    private void jump()
    {
        if (!isInAir)
        {
            this.upwardsSpeed = JUMP_POWER;
            isInAir = true;
        }
    }

    public void moveCamera()
    {
        float theta = yaw - 720;
        float offsetX = (float) (2 * Math.sin(Math.toRadians(theta)));
        float offsetZ = (float) (2 * Math.cos(Math.toRadians(theta)));
        if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
        {
            if (Keyboard.isKeyDown(Keyboard.KEY_W))
            {
                position.z -= ((offsetZ * RUN_SPEED * 3) * DisplayManager.getFrameTimeSeconds());
                position.x += ((offsetX * RUN_SPEED * 3) * DisplayManager.getFrameTimeSeconds());
            }
            else if (Keyboard.isKeyDown(Keyboard.KEY_S))
            {
                position.z += ((offsetZ * RUN_SPEED * 3) * DisplayManager.getFrameTimeSeconds());
                position.x -= ((offsetX * RUN_SPEED * 3) * DisplayManager.getFrameTimeSeconds());
            }
            else
            {
                position.x = position.x;
                position.z = position.z;
            }
            if (Keyboard.isKeyDown(Keyboard.KEY_D))
            {
                position.z += ((offsetX * RUN_SPEED * 3) * DisplayManager.getFrameTimeSeconds());
                position.x += ((offsetZ * RUN_SPEED * 3) * DisplayManager.getFrameTimeSeconds());
            }
            else if (Keyboard.isKeyDown(Keyboard.KEY_A))
            {
                position.z -= ((offsetX * RUN_SPEED * 3) * DisplayManager.getFrameTimeSeconds());
                position.x -= ((offsetZ * RUN_SPEED * 3) * DisplayManager.getFrameTimeSeconds());
            }
            else
            {
                position.x = position.x;
                position.z = position.z;
            }
            if (Keyboard.isKeyDown(Keyboard.KEY_SPACE))
            {
                jump();
            }
        }
        else
        {
            if (Keyboard.isKeyDown(Keyboard.KEY_W))
            {

                position.z -= ((offsetZ * RUN_SPEED) * DisplayManager.getFrameTimeSeconds());
                position.x += ((offsetX * RUN_SPEED) * DisplayManager.getFrameTimeSeconds());
            }
            else if (Keyboard.isKeyDown(Keyboard.KEY_S))
            {

                position.z += ((offsetZ * RUN_SPEED) * DisplayManager.getFrameTimeSeconds());
                position.x -= ((offsetX * RUN_SPEED) * DisplayManager.getFrameTimeSeconds());
            }
            else
            {
                position.x = position.x;
                position.z = position.z;
            }

            if (Keyboard.isKeyDown(Keyboard.KEY_D))
            {
                position.z += ((offsetX * RUN_SPEED) * DisplayManager.getFrameTimeSeconds());
                position.x += ((offsetZ * RUN_SPEED) * DisplayManager.getFrameTimeSeconds());
            }
            else if (Keyboard.isKeyDown(Keyboard.KEY_A))
            {
                position.z -= ((offsetX * RUN_SPEED) * DisplayManager.getFrameTimeSeconds());
                position.x -= ((offsetZ * RUN_SPEED) * DisplayManager.getFrameTimeSeconds());
            }
            else
            {
                position.x = position.x;
                position.z = position.z;
            }
            if (Keyboard.isKeyDown(Keyboard.KEY_SPACE))
            {
                jump();
            }
        }
    }

    public void invertPitch(){
        this.pitch = -pitch;
    }




    public boolean getFPS()
    {
        return FPS;
    }

    public Vector3f getPosition()
    {
        return position;
    }

    public void setPosition(Vector3f position)
    {
        this.position = position;
    }

    public float getPitch()
    {
        return pitch;
    }

    public float getYaw()
    {
        return yaw;
    }

    public float getRoll()
    {
        return roll;
    }

    private void calculateCameraPosition(float horizDistance,
            float verticDistance)
    {
        float theta = player.getRotY() + angleAroundPlayer;
        float offsetX = (float) (horizDistance * Math
                .sin(Math.toRadians(theta)));
        float offsetZ = (float) (horizDistance * Math
                .cos(Math.toRadians(theta)));
        position.x = player.getPosition().x - offsetX;
        position.z = player.getPosition().z - offsetZ;
        position.y = player.getPosition().y + verticDistance;
    }

    private float calculateHorizontalDistance()
    {
        return (float) (distanceFromPlayer * Math.cos(Math.toRadians(pitch)));
    }

    private float calculateVerticalDistance()
    {
        return (float) (distanceFromPlayer * Math.sin(Math.toRadians(pitch)));
    }

    private void calculateZoom()
    {
        float zoomLevel = Mouse.getDWheel() * 0.1f;
        distanceFromPlayer -= zoomLevel;
    }

    private void calculatePitch()
    {
        if (Mouse.isButtonDown(0))
        {
            float pitchChange = Mouse.getDY() * 0.1f;
            pitch -= pitchChange;
        }
    }

    private void calculateAngleAroundPlayer()
    {
        if (Mouse.isButtonDown(0))
        {
            float angleChange = Mouse.getDX() * 0.3f;
            angleAroundPlayer -= angleChange;
        }
    }
}

包实体；
导入org.lwjgl.input.Keyboard；
导入org.lwjgl.input.Mouse；
导入org.lwjgl.opengl.Display；
导入org.lwjgl.util.vector.Vector3f；
导入renderEngine.DisplayManager；
导入地形。地形；
公共级摄像机
{
私人浮动距离与玩家=50；
私人浮动角度环绕玩家=0；
私有布尔FPS=false；
私有向量3f位置=新向量3f（110,10，-52）；
私人浮动螺距=20；
私人浮动偏航；
私人浮动辊；
专用静态最终浮动运行速度=20；
专用静态最终浮子重力=-50f；
专用静态最终浮动跃变功率=30；
私有int ClickedOnLayer=0；
私人向上浮动速度=0；
私有布尔值isInAir=false；
私人玩家；
公共摄像机（播放器）
{
this.player=player；
}
公共无效移动（地形）
{
鼠标。setgrapped（true）；
this.yaw=（Mouse.getX（））；
float MouseY=Mouse.getY（）；
如果（鼠标>360）
{
螺距=465-鼠标；
}
如果（偏航>=1079）
{
Mouse.setCursorPosition（Display.getWidth（）/2+80，
Display.getHeight（）/2）；
这个偏航=720；
}
else if（yaw非常简单。首先，将
move（）
方法更改为如下所示：

 public void move() {
    calculatePitch();
    calculateAngleAroundPlayer();
    this.yaw = 180 - (player.getRotY() + angleAroundPlayer);
    yaw %= 360;
}

其次，将
距离从player
更改为
0

private float distanceFromPlayer = 0;

希望这有帮助！（可能会）
我觉得这样做很愚蠢，我试图重写大部分课程，使之“简单”，谢谢！现在如果我想让玩家按照相机的方向前进，我会做一些不同的事情吗？或者我是不是忘记了？如果你只想让它成为第一人称，你真的不需要相机类。Since我认识这个LWJGL教程，我知道我在说什么。所以，删除摄影机类，在你的着色器类中，不要使用摄影机的变换矩阵，而是使用播放器。非常感谢你，非常高兴你能连接，因为你以前看过这个教程，再次感谢你！我已经更改了大部分着色器类，但其中一些已经更改是不是因为，在我的数学课上，它得到的俯仰和偏航的相机，但我不知道什么来取代它？