平滑动画

Question

我已经编写了一些代码，可以从高度图中渲染3D世界，现在我也编写了允许行走的代码。问题是，当高度增加时，动画几乎“跳跃”，因为每个单元都相当大。有没有一种简单的方法可以让动画更流畅？（一般来说，我对OpenGL和3D渲染非常陌生，所以我不想讨论插值和更复杂的事情。）

Answer 1

试着做一些三角运算——在整数数组中映射点：

int [x][y][z]

你甚至可以让游戏为你做到这一点。发挥创造力。然后制作一个循环，将每个点映射出来，让“玩家”站在上面。如果仍然不起作用，请尝试使用浮动0.5增量的相同方法。希望我有所帮助。：）

Answer 2

你是在寻求如何顺利行动的帮助吗？比如加速？

如果是这样，你可以这样做：

你的玩家类应该有一个位置、速度和方向向量。不断地将你的速度加到你的位置上，就像这样

//mainloop...
{
position.add(velocity);
}

静止时，你的速度是

if(Key.W)
velocity.add(direction);

这基本上是加速度。现在停止，你应该把方向向量的一个百分比加到速度上，但方向相反。

public class Camera
{
    public final static Camera VIEW = new Camera();
    //
    public Vector3 position; 
    public Vector3 directionalVelocity, angularVelocity;
    public Vector3 rotation;
    public Vector3 cameraDirectionVector; // vector pointing in direction of camera

    public Camera()
    {
        this.position = new Vector3(0,0,0);
        this.rotation = new Vector3(0,0,0);
        this.directionalVelocity = new Vector3(0, 0, 0);
        this.angularVelocity = new Vector3(0, 0, 0);
        this.cameraDirectionVector = new Vector3(0, 0, 0);
        Mouse.setGrabbed(true);
    }
    public void setPosition(float x, float y, float z)
    {
        this.position.set(x, y, z);
    }
    public void setRotation(float x, float y, float z)
    {
        this.rotation.set(x, y, z);
    }

    private float walkAcc = 0.2f;
    private float mouseAcc = 0.2f;

    public void update()
    {
        GL11.glLoadIdentity(); // reset matrix
        GL11.glRotatef(rotation.x, 1, 0, 0);
        GL11.glRotatef(rotation.y, 0, 1, 0);
        GL11.glRotatef(rotation.z, 0, 0, 1);
        GL11.glTranslatef(position.x, position.y, position.z);
        //
            // mouse Input , increment angularVelocity
        if(Mouse.isGrabbed())
        {
            float mouseX = Mouse.getDX() * mouseAcc;
            float mouseY = Mouse.getDY() * mouseAcc;
            if(mouseY > 0 && this.rotation.x > -90)
                this.angularVelocity.x -= mouseY;
            if(mouseY < 0 && this.rotation.x < 90)
                this.angularVelocity.x += -mouseY;
            if(mouseX > 0)
                this.angularVelocity.y += mouseX;
            if(mouseX < 0)
                this.angularVelocity.y -= -mouseX;
                    // slow down mouse velocity
            this.applyFriction(this.angularVelocity, 0.4f);  
        }
        //
            // Keyboard input , add direction to velocity
        if(Keyboard.isKeyDown(Keyboard.KEY_W))
            this.walkForward(this.walkAcc);
        if(Keyboard.isKeyDown(Keyboard.KEY_S))
            this.walkBackwards(this.walkAcc);
        if(Keyboard.isKeyDown(Keyboard.KEY_D))
            this.strafeRight(this.walkAcc);
        if(Keyboard.isKeyDown(Keyboard.KEY_A))
            this.strafeLeft(this.walkAcc);
        if(Keyboard.isKeyDown(Keyboard.KEY_SPACE))
            this.directionalVelocity.y -= walkAcc;
        if(Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
            this.directionalVelocity.y += walkAcc;
            //
        //slow down walk speed
        this.applyFriction(this.directionalVelocity, 0.09f);
        //
            // add velocity to position
        this.position.add(this.directionalVelocity);
        this.rotation.add(this.angularVelocity);
        //
        this.updateCameraDirectionVector();
    }

   // Calculates a vector pointing in the direction of your cross hair
    public Vector3 updateCameraDirectionVector() 
    {

        //x = rsin(angle1)cos(angle2)
        //y = rsin(angle1)sin(angle2)
        //z = rcos(angle1)

        this.cameraDirectionVector.x = (float) (Math.sin(Math.toRadians(rotation.y)) * Math.cos(Math.toRadians(rotation.x)));
        this.cameraDirectionVector.z = (float) (-Math.cos(Math.toRadians(rotation.y)) * Math.cos(Math.toRadians(rotation.x)));
        this.cameraDirectionVector.y = (float) -Math.sin(Math.toRadians(rotation.x)); // good
        return this.cameraDirectionVector;
    }
    public void applyFriction(Vector3 vector, float speed)
    {
        //add a percentage of opposite direction to current direction
        vector.x += -vector.x * speed;
        vector.y += -vector.y * speed;
        vector.z += -vector.z * speed;
    }
    public void walkForward(float distance)
    {
        this.directionalVelocity.x -= this.cameraDirectionVector.x * distance;
        this.directionalVelocity.y -= this.cameraDirectionVector.y * distance;
        this.directionalVelocity.z -= this.cameraDirectionVector.z * distance;

    }
    public void walkBackwards(float distance)
    {
        this.directionalVelocity.x += this.cameraDirectionVector.x * distance;
        this.directionalVelocity.y += this.cameraDirectionVector.y * distance;
        this.directionalVelocity.z += this.cameraDirectionVector.z * distance;

    }
    public void strafeLeft(float distance)
    {
        // cross product with (0,1,0) ... y unit vector..
        this.directionalVelocity.x += -this.cameraDirectionVector.z * distance;
        this.directionalVelocity.z += this.cameraDirectionVector.x * distance;

    }
    public void strafeRight(float distance)
    {
        // cross product with -(0,1,0) ... y unit vector..
        this.directionalVelocity.x -= -this.cameraDirectionVector.z * distance;
        this.directionalVelocity.z -= this.cameraDirectionVector.x * distance;

    }
    @Override
    public String toString()
    {
        return this.position.x + " " + this.position.y + " " + this.position.z;
    }
}

//这是一个基本的向量类，我简化了它以便于阅读。

public class Vector3
{
   public float x,y,z;
   public Vector3(float x,float y, float z)
   {
   this.x = x;
   this.y = y;
   this.z = z;
   }
   public void add(Vector3 v)
   {
    this.x += v.x;
    this.y += v.y;
    this.z += v.z;
   }
 public void set(float x, float y ,float z)
   {
    this.x = x;
    this.y = y;
    this.z = z;
   }

}