三角形点的距离变大，但是所有点的速度相同

我正在尝试在屏幕中心显示一堆颜色随机的三角形。具有各种连续和稳定速度的三角形应视其速度而消失（超出屏幕限制）。

实际上，我无法解决无法解决的问题。

三角初始化：

在每个三角形中，我将第一个点设置为[-0.1，0.1]中的某个位置。因此，我得到的第一点是（firstX，firstY）。接下来的两个点分别是（firstX-0.02f，firstY-0.02f）和（（firstX + 0.02f，firstY + 0.02f））。所以，所有三角形都应该是等边的，对不对？

接下来，对于每个三角形，我将X的速度和Y轴的速度都设置为[-1/2000，1/2000]。该速度是稳定的，并且对于每个三角形都不会改变。

三角更新：

如前所述，三角形会更新每一帧，因为它们以一定的速度移动。我知道我必须将其乘以deltaTime，但这暂时并不重要。

因此，在更新功能中，我基本上找到了每个三角形中的每个点，并根据该三角形的速度更新了它们的X和Y。

每个三角形的3个点中的每个点都具有相同的速度（但是，每个三角形的速度有所不同）。

我不明白为什么不是每个三角形都只是移动到屏幕的某个边缘然后消失了。

我看到的是三角形，它从靠近屏幕中心开始（正像所期望的那样，因为firstX和firstY的值接近于0），并且越来越大，而它们的速度似乎正在降低。

代码：

import java.util.Random;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Mesh;
import com.badlogic.gdx.graphics.VertexAttribute;
import com.badlogic.gdx.graphics.VertexAttributes.Usage;

public class MainMenu implements Screen {

    private MyGame game;
    private Mesh trianglesMesh;

    private int screenWidth, screenHeight;

    public static final int MAX_TRIANGLES_NUM = 2000;
    //2 for position, 4 for color
    public static final int COMPONENTS_NUM_PER_TRIANGLE = 6;

    //3 vertices per triangle
    private float[] vertices = new float[3 * COMPONENTS_NUM_PER_TRIANGLE * MAX_TRIANGLES_NUM];
    //horizontal and vertical speed for each triangle
    private float[] speeds = new float[2*MAX_TRIANGLES_NUM];


    public MainMenu(MyGame game) {
        this.game=game;

        screenWidth=Gdx.graphics.getWidth();
        screenHeight=Gdx.graphics.getHeight();

        //2 components for position, 4 components for color
        trianglesMesh = new Mesh(true, 3*MAX_TRIANGLES_NUM, 0, new VertexAttribute(Usage.Position, 2, "a_position"),
                                                           new VertexAttribute(Usage.Color, 4, "a_color"));
        initTriangles();
    }

    private void fillRandomColor(int curTriangle, int init, int max, Random random){
        for(int i=init;i<max;i++){
            vertices[curTriangle*COMPONENTS_NUM_PER_TRIANGLE+i]=random.nextFloat();
        }
    }
    private void initTriangles(){
        /*
         * How it works: Each triangle has an initial position that is inside the
         * visible area. Each one is given a speed to a random direction. Once a
         * triangle becomes invisible, there is a possibility that another one will
         * come into place. This possibility is true as long as the current number of
         * available triangles is less than MAX_TRIANGLES_NUM
         * */
        Random random = new Random();
        for(int currentTriangle=0;currentTriangle<MAX_TRIANGLES_NUM;currentTriangle++){
            //1st triangle point
            //X and Y init is [-0.1, 0.1]
            float firstX=(2*random.nextFloat()-1)/10, firstY=(2*random.nextFloat()-1)/10;

            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE]=firstX;
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+1]=firstY;
            fillRandomColor(currentTriangle, 2, 6, random);
            //2nd triangle point
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+6]=firstX-0.02f;
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+7]=firstY-0.02f;
            fillRandomColor(currentTriangle, 8, 12, random);
            //3rd triangle point
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+12]=firstX+0.02f;
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+13]=firstY+0.02f;
            fillRandomColor(currentTriangle, 14, 18, random);
            //setting up the continuous speed for the triangle
            speeds[currentTriangle*2]=(2*random.nextFloat()-1)/2000;
            speeds[currentTriangle*2+1]=(2*random.nextFloat()-1)/2000;
        }
    }

    private void updateTriangles(){
        /*
         * Updates the position of the triangles, discards the ones not visible
         * and possibly adds new ones.
         * */

        for(int currentTriangle=0;currentTriangle<MAX_TRIANGLES_NUM;currentTriangle++){
            //updating the position of every point in triangle

            //get the speed
            float speedX=speeds[currentTriangle*2];
            float speedY=speeds[currentTriangle*2+1];

            //update the Xs
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE]+=speedX;
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+6]+=speedX;
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+12]+=speedX;

            //update the Ys
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+1]+=speedY;
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+7]+=speedY;
            vertices[currentTriangle*COMPONENTS_NUM_PER_TRIANGLE+13]+=speedY;
        }
        trianglesMesh.setVertices(vertices);
    }

    @Override
    public void render(float delta) {
        // TODO Auto-generated method stub
        updateTriangles();

        Gdx.gl.glClear(GL20.GL_COLOR_CLEAR_VALUE);
        trianglesMesh.render(GL20.GL_TRIANGLES, 0, vertices.length);
        /*
         * TODO
         * Here must check when to go off the main menu screen.
         * 
         * if(condition){
         *     game.setScreen(someOtherAwesomeScene);
         * }
         * 
         * */
    }

    @Override
    public void resize(int width, int height) {
        // TODO Auto-generated method stub

    }

    @Override
    public void show() {
        // TODO Auto-generated method stub

    }

    @Override
    public void hide() {
        // TODO Auto-generated method stub

    }

    @Override
    public void pause() {
        // TODO Auto-generated method stub

    }

    @Override
    public void resume() {
        // TODO Auto-generated method stub

    }

    @Override
    public void dispose() {
        // TODO Auto-generated method stub

    }

}

我所看到的内容的预览：http : //i.imgur.com/fF7djBt.gif

我再说一遍，我只是希望这些三角形保持很小，就像它们以一定速度向屏幕边缘移动一样。我不明白

1. 它们如何变大？
2. 他们如何停止平等？
3. 为什么速度似乎降低了？