Java LWJGL高度映射渲染

你好，我不想做基于高度图的游戏，我有优化问题。我通常在DisplayList中渲染，但当我想渲染heightmap 512x512时，我只有20-30 fps。我在vbo中尝试了一些东西，但不起作用。以下是显示列表渲染的源代码：

    public class Heightmap {
    public static final Vector2f CHUNK_XZ = new Vector2f(256, 256);

    public int CHUNK_ID;

    private float[][] chunk_data = null;
    private Vector3f[][] chunk_color_data = null;

    private Vector3f pos;
    private Vector3f scale = new Vector3f(10, 10, 10);

    private boolean visible = true;

    private int displayID;

    private Texture texture;

    public Heightmap(Vector3f pos) {
        this.pos = pos;

        chunk_data = new float[(int) CHUNK_XZ.x][(int) CHUNK_XZ.y];
        chunk_color_data = new Vector3f[(int) CHUNK_XZ.x][(int) CHUNK_XZ.y];

        for(int x = 0; x < chunk_data.length; x++) {
            for(int y = 0; y < chunk_data[0].length; y++) {
                chunk_data[x][y] = 1.0f;
                chunk_color_data[x][y] = new Vector3f(0f, 0f, (float) Math.random());
            }
        }

        try {
            texture = TextureLoader.getTexture("jpg", new FileInputStream(new File("grassy.jpg")));
        } catch (IOException e) {
            e.printStackTrace();
        }

        displayID = glGenLists(1);

        GL11.glNewList(displayID, GL11.GL_COMPILE);
        texture.bind();

        GL11.glPushMatrix();
        GL11.glScalef(scale.x, scale.y, scale.z);

        GL11.glBegin(GL11.GL_QUADS);

        int heightmapExaggeration = 10;

        for(int x=0; x < chunk_data.length; x++) {
            for(int y=0; y < chunk_data[x].length; y++) {
                GL11.glColor3f(chunk_color_data[x][y].getX(), chunk_color_data[x][y].getY(), chunk_color_data[x][y].getZ());
                GL11.glTexCoord2f(0, 0);
                GL11.glVertex3f(x*0.25f, getHeightAt(x, y)*heightmapExaggeration, y*0.25f);
                GL11.glTexCoord2f(1, 0);
                GL11.glVertex3f((x+1)*0.25f, getHeightAt(x+1, y)*heightmapExaggeration, y*0.25f);
                GL11.glTexCoord2f(1, 1);
                GL11.glVertex3f((x+1)*0.25f, getHeightAt(x+1, y+1)*heightmapExaggeration, (y+1)*0.25f);
                GL11.glTexCoord2f(0, 1);
                GL11.glVertex3f(x*0.25f, getHeightAt(x, y+1)*heightmapExaggeration, (y+1)*0.25f);
            }
        }

        GL11.glEnd();
        GL11.glPopMatrix();
        texture.release();
        GL11.glEndList();
    }
    public Chunk(float[][] chunk_data, Vector3f[][] chunk_color_data, Vector3f pos) {
        this.chunk_data = chunk_data;
        this.chunk_color_data = chunk_color_data;
        this.pos = pos;

        try {
            texture = TextureLoader.getTexture("jpg", new FileInputStream(new File("grassy.jpg")));
        } catch (IOException e) {
            e.printStackTrace();
        }

        displayID = glGenLists(1);

        GL11.glNewList(displayID, GL11.GL_COMPILE);
        texture.bind();

        GL11.glPushMatrix();
        GL11.glScalef(scale.x, scale.y, scale.z);

        GL11.glBegin(GL11.GL_QUADS);

        int heightmapExaggeration = 10;
        for(int x=0; x < chunk_data.length; x++){
            for(int y=0; y < chunk_data[x].length; y++){
                GL11.glColor3f(chunk_color_data[x][y].getX(), chunk_color_data[x][y].getY(), chunk_color_data[x][y].getZ());
                GL11.glTexCoord2f(0, 0);
                GL11.glVertex3f(x*0.25f, getHeightAt(x, y)*heightmapExaggeration, y*0.25f);
                GL11.glTexCoord2f(1, 0);
                GL11.glVertex3f((x+1)*0.25f, getHeightAt(x+1, y)*heightmapExaggeration, y*0.25f);
                GL11.glTexCoord2f(1, 1);
                GL11.glVertex3f((x+1)*0.25f, getHeightAt(x+1, y+1)*heightmapExaggeration, (y+1)*0.25f);
                GL11.glTexCoord2f(0, 1);
                GL11.glVertex3f(x*0.25f, getHeightAt(x, y+1)*heightmapExaggeration, (y+1)*0.25f);
            }
        }

        GL11.glEnd();
        GL11.glPopMatrix();
        texture.release();
        GL11.glEndList();

    }
    public float getHeightAt(int x, int z){
        try {
            return chunk_data[x][z];
        } catch(Exception e) {
            return 0;
        }
    }
    public void render() {
        glPushMatrix();
        glTranslatef(pos.x, pos.y, pos.z);
        glCallList(displayID);
        glPopMatrix();
    }
    public void setChunkDataAtCoords(int x, int y, float value) {
        this.chunk_data[x][y] = value;
    }
    public float[][] getChunk_data() {
        return chunk_data;
    }
    public Vector3f[][] getChunk_color_data() {
        return chunk_color_data;
    }
    public Vector3f getPos() {
        return pos;
    }
    public Vector3f getScale() {
        return scale;
    }
    public void setChunk_data(float[][] chunk_data) {
        this.chunk_data = chunk_data;
    }
    public void setChunk_color_data(Vector3f[][] chunk_color_data) {
        this.chunk_color_data = chunk_color_data;
    }
    public void setChunkColorDataAtCoords(int x, int y, Vector3f color) {
        chunk_color_data[x][y] = color;
    }
    public void setPos(Vector3f pos) { 
        this.pos = pos;
    }
    public void setScale(Vector3f scale) {
        this.scale = scale;
    }
    public boolean isVisible() {
        return visible;
    }
    public void setVisible(boolean visible) {
        this.visible = visible;
    }
}

公共类高度图{
公共静态最终向量2f CHUNK_XZ=新向量2f（256，256）；
公共int-CHUNK\u-ID；
私有浮点[][]数据块=null；
私有向量3f[][]块\u颜色\u数据=null；
私人向量3F pos；
私有向量3f标度=新向量3f（10,10,10）；
私有布尔可见=真；
私有int-displayID；
私有纹理；
公共高度图（矢量3F位置）{
this.pos=pos；
chunk_data=newfloat[（int）chunkxz.x][（int）chunkxz.y]；
chunk_color_data=新向量3f[（int）chunk_XZ.x][（int）chunk_XZ.y]；
对于（int x=0；x

和vbo渲染代码，但无法正常工作：

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;

import javax.imageio.ImageIO;

import org.lwjgl.BufferUtils;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL15.*;


public class Terrain {

    private int width = 200;
    private int height = 200;
    private int verticies = (3*(2*height)*width);
    private int indicies = ((height*2)*width);
    private FloatBuffer vBuffer = BufferUtils.createFloatBuffer(verticies);
    private IntBuffer iBuffer = BufferUtils.createIntBuffer(indicies);
    private IntBuffer ib = BufferUtils.createIntBuffer(indicies);
    private static float[][] data;

    public Terrain() {
        glPushMatrix();
        glScalef(0.6f, 0.6f, 0.6f);
        glTranslatef(0f, 10f, 0f);
        loadHeightImage();
        loadHeightVerticies();
        drawHeightMap();
        glPopMatrix();
    }

    public void loadHeightImage() {

        try {           
            BufferedImage heightmapImage = ImageIO.read(new File("height.jpg"));
            data = new float[heightmapImage.getWidth()][heightmapImage.getHeight()];
            Color colour;

            for (int x = 0; x < data.length; x++)
            {
                for (int z = 0; z < data[x].length; z++)
                {
                    colour = new Color(heightmapImage.getRGB(x, z));
                    data[z][x] = colour.getRed();

                }
            }
        } catch (IOException e){
            e.printStackTrace();
        }
    }

    public void loadHeightVerticies() {
        for (int z = 0; z < this.data.length - 1; z++) {
            for (int x = 0; x < this.data[z].length; x++) {

                vBuffer.put(x).put(this.data[z][x]).put(z);
                vBuffer.put(x).put(this.data[z + 1][x]).put(z + 1);
            }
        }

        this.vBuffer.flip();

        for (int n = 0; n < indicies; n++) {
            this.iBuffer.put( n);
        }

        this.iBuffer.flip();
    }

    public void drawHeightMap() {

        glGenBuffers(ib);
        int vHandle = ib.get(0);
        int iHandle = ib.get(1);

        glEnableClientState(GL_VERTEX_ARRAY);
        glBindBuffer(GL_ARRAY_BUFFER, vHandle);
        glBufferData(GL_ARRAY_BUFFER, vBuffer, GL_STATIC_DRAW);
        glVertexPointer(3, GL_FLOAT, 0, 0L);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iHandle);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, iBuffer, GL_STATIC_DRAW);

        for (int x = 0; x < 400; x++) {
            glDrawElements(GL_TRIANGLE_STRIP, 400, GL_UNSIGNED_SHORT, 1600 * x);
        }  

        glDisableClientState(GL_VERTEX_ARRAY);

        ib.put(0, vHandle);

        glDeleteBuffers(ib);
    }   
} 

导入java.awt.Color；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.IOException；
导入java.nio.FloatBuffer；
导入java.nio.IntBuffer；
导入java.nio.ShortBuffer；
导入javax.imageio.imageio；
导入org.lwjgl.BufferUtils；
导入静态org.lwjgl.opengl.GL11.*；
导入静态org.lwjgl.opengl.GL15.*；
公共级地形{
私有整数宽度=200；
私人内部高度=200；
私有整数=（3*（2*he）