Java LWJGL-高度贴图未正确渲染

根据奥斯卡·韦尔霍克（Oskar Veerhoek）的youtube教程，我正在尝试在我的游戏中实现一个高度图。我遵循这些步骤，得到了一些方法：

private static void setUpHeightmap() {
    try {
        // Load the heightmap-image from its resource file
        BufferedImage heightmapImage = ImageIO.read(new File("res/img/heightmap.bmp"));
        // Initialise the data array, which holds the heights of the heightmap-vertices, with the correct dimensions
        data = new float[heightmapImage.getWidth()][heightmapImage.getHeight()];
        // Lazily initialise the convenience class for extracting the separate red, green, blue, or alpha channels
        // an int in the default RGB color model and default sRGB colourspace.
        Color colour;
        // Iterate over the pixels in the image on the x-axis
        for (int z = 0; z < data.length; z++) {
            // Iterate over the pixels in the image on the y-axis
            for (int x = 0; x < data[z].length; x++) {
                // Retrieve the colour at the current x-location and y-location in the image
                colour = new Color(heightmapImage.getRGB(z, x));
                // Store the value of the red channel as the height of a heightmap-vertex in 'data'. The choice for
                // the red channel is arbitrary, since the heightmap-image itself only has white, gray, and black.
                data[z][x] = colour.getRed();
            }
        }
        // Create an input stream for the 'lookup texture', a texture that will used by the fragment shader to
        // determine which colour matches which height on the heightmap
        FileInputStream heightmapLookupInputStream = new FileInputStream("res/img/heightmap_lookup.png");
        // Create a class that will give us information about the image file (width and height) and give us the
        // texture data in an OpenGL-friendly manner
        PNGDecoder decoder = new PNGDecoder(heightmapLookupInputStream);
        // Create a ByteBuffer in which to store the contents of the texture. Its size is the width multiplied by
        // the height and 4, which stands for the amount of bytes a float is in Java.
        ByteBuffer buffer = BufferUtils.createByteBuffer(4 * decoder.getWidth() * decoder.getHeight());
        // 'Decode' the texture and store its data in the buffer we just created
        decoder.decode(buffer, decoder.getWidth() * 4, PNGDecoder.Format.RGBA);
        // Make the contents of the ByteBuffer readable to OpenGL (and unreadable to us)
        buffer.flip();
        // Close the input stream for the heightmap 'lookup texture'
        heightmapLookupInputStream.close();
        // Generate a texture handle for the 'lookup texture'
        lookupTexture = glGenTextures();
        glBindTexture(GL_TEXTURE_2D, lookupTexture);
        // Hand the texture data to OpenGL
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, decoder.getWidth(), decoder.getHeight(), 0, GL_RGBA,
                GL_UNSIGNED_BYTE, buffer);
    } catch (IOException e) {
        e.printStackTrace();
    }
    // Use the GL_NEAREST texture filter so that the sampled texel (texture pixel) is not smoothed out. Usually
    // using GL_NEAREST will make the textured shape appear pixelated, but in this case using the alternative,
    // GL_LINEAR, will make the sharp transitions between height-colours ugly.
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    // Generate a display list handle for the display list that will store the heightmap vertex data
    heightmapDisplayList = glGenLists(1);
    // TODO: Add alternative VBO rendering for pseudo-compatibility with version 3 and higher.
    glNewList(heightmapDisplayList, GL_COMPILE);
    // Scale back the display list so that its proportions are acceptable.
    glScalef(0.2f, 0.06f, 0.2f);
    // Iterate over the 'strips' of heightmap data.
    for (int z = 0; z < data.length - 1; z++) {
        // Render a triangle strip for each 'strip'.
        glBegin(GL_TRIANGLE_STRIP);
        for (int x = 0; x < data[z].length; x++) {
            // Take a vertex from the current strip
            glVertex3f(x, data[z][x], z);
            // Take a vertex from the next strip
            glVertex3f(x, data[z + 1][x], z + 1);
        }
        glEnd();
    }
    glEndList();
}
private static void setUpShaders() {
    shaderProgram = ShaderLoader.loadShaderPair("res/shaders/landscape.vs", "res/shaders/landscape.fs");
    glUseProgram(shaderProgram);
    // The following call is redundant because the default value is already 0, but illustrates how you would use
    // multiple textures
    glUniform1i(glGetUniformLocation(shaderProgram, "lookup"), 0);
}

private static void setUpStates() {
    camera.applyOptimalStates();
    glPointSize(2);
    // Enable the sorting of shapes from far to near
    glEnable(GL_DEPTH_TEST);
    // Set the background to a blue sky colour
    glClearColor(0, 0.75f, 1, 1);
    // Remove the back (bottom) faces of shapes for performance
    //glEnable(GL_CULL_FACE);
}

当我运行游戏时，高度图不会显示，屏幕上的模型会像这样被压扁：

---

我认为这与错误地渲染高度并将其应用于我的模型有关。但我真的不知道，因为我对3D开发非常陌生。一些帮助将是惊人的！谢谢

要从图像中获取高度贴图信息，只需编写以下代码：

try {
    BufferedImage height = ImageIO.read(new File("utah.jpg"));
    hm = new double[height.getHeight()][height.getWidth()];
        for (int row = 0; row < height.getHeight(); row++) {
            for (int col = 0; col < height.getWidth(); col++) {
                hm[row][col] = (height.getRGB(col, row) & 255) / 255.0;

            }
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

要绘制点，只需执行以下从JOGL到LWJGL的转换：

            gl.glPushMatrix();

            for (int x = 0; x < (257 - 1); x++) {
                gl.glBegin(GL.GL_TRIANGLE_STRIP);
                for (int z = 0; z < (257 - 1); z++) {
                    double[] row = hm[0];
                    double y = hm[(x * hm.length) % 10][(z + row.length) % 10]
                            * 5;
                    gl.glColor3d(1, 1, 1);
                    gl.glVertex3d(x, y, z);
                    //gl.glTexCoord3d(x, y, z);
                    y = hm[((x + 1) * hm.length) % 10][((z + 1) + row.length) % 10]
                            * 5;
                    gl.glColor3d(1, 1, 1);
                    gl.glVertex3d(x + 1, y, z + 1);
                    //gl.glTexCoord3d(x + 1, y, z + 1);
                }
                gl.glEnd();
            }
            gl.glPopMatrix();