高度图生成中途完成

Question

目前，我正在尝试制作一个噪声生成的高度图并用 opengl 显示它。我正在关注 this tutorial，但我的高度图似乎不起作用。它似乎只生成（或显示）了它应该生成的一半。

这是带有颜色法线的高度图：

如您所见，尽管这应该是一个正方形，但它看起来是一个边缘未完成的矩形。

这是我的高度图生成代码：

public class HeightMap extends GameModel {

    private static final float START_X = -0.5f;
    private static final float START_Z = -0.5f;

    public HeightMap(float minY, float maxY, float persistence, int width, int height) {
        super(createMesh(minY, maxY, persistence, width, height));
    }

    protected static Mesh createMesh(final float minY, final float maxY, final float persistence, final int width,
            final int height) {
        SimplexNoise noise = new SimplexNoise(128, persistence, 2);// Utils.getRandom().nextInt());

        float xStep = Math.abs(START_X * 2) / width;
        float zStep = Math.abs(START_Z * 2) / height;

        List<Float> positions = new ArrayList<>();
        List<Integer> indices = new ArrayList<>();

        for (int x = 0; x < width; x++) {
            for (int z = 0; z < height; z++) {
                // scale from [-0.5, 0.5] to [minY, maxY]
                float heightY = (float) ((noise.getNoise(x, z) + 0.5f) * (maxY - minY) + minY);

                positions.add(START_X + x * xStep);
                positions.add(heightY);
                positions.add(START_Z + z * zStep);

                // Create indices
                if (x < width - 1 && z < height - 1) {
                    int leftTop = z * width + x;
                    int leftBottom = (z + 1) * width + x;
                    int rightBottom = (z + 1) * width + x + 1;
                    int rightTop = z * width + x + 1;

                    indices.add(leftTop);
                    indices.add(leftBottom);
                    indices.add(rightTop);

                    indices.add(rightTop);
                    indices.add(leftBottom);
                    indices.add(rightBottom);
                }
            }
        }

        float[] verticesArr = Utils.listToArray(positions);
        float[] colorArr = new float[positions.size()];
        for (int i = 0; i < colorArr.length; i += 3) {
            colorArr[i] = (float) i / colorArr.length;
            colorArr[i + 1] = (float) .25f;
            colorArr[i + 2] = (float) 0;
        }
        int[] indicesArr = indices.stream().mapToInt((i) -> i).toArray();

        float[] normalArr = calcNormals(verticesArr, width, height);

        return new Mesh(verticesArr, colorArr, normalArr, indicesArr);
    }

    private static float[] calcNormals(float[] posArr, int width, int height) {
        Vector3f v0 = new Vector3f();
        Vector3f v1 = new Vector3f();
        Vector3f v2 = new Vector3f();
        Vector3f v3 = new Vector3f();
        Vector3f v4 = new Vector3f();
        Vector3f v12 = new Vector3f();
        Vector3f v23 = new Vector3f();
        Vector3f v34 = new Vector3f();
        Vector3f v41 = new Vector3f();
        List<Float> normals = new ArrayList<>();
        Vector3f normal = new Vector3f();
        for (int row = 0; row < height; row++) {
            for (int col = 0; col < width; col++) {
                if (row > 0 && row < height - 1 && col > 0 && col < width - 1) {
                    int i0 = row * width * 3 + col * 3;
                    v0.x = posArr[i0];
                    v0.y = posArr[i0 + 1];
                    v0.z = posArr[i0 + 2];

                    int i1 = row * width * 3 + (col - 1) * 3;
                    v1.x = posArr[i1];
                    v1.y = posArr[i1 + 1];
                    v1.z = posArr[i1 + 2];
                    v1 = v1.sub(v0);

                    int i2 = (row + 1) * width * 3 + col * 3;
                    v2.x = posArr[i2];
                    v2.y = posArr[i2 + 1];
                    v2.z = posArr[i2 + 2];
                    v2 = v2.sub(v0);

                    int i3 = (row) * width * 3 + (col + 1) * 3;
                    v3.x = posArr[i3];
                    v3.y = posArr[i3 + 1];
                    v3.z = posArr[i3 + 2];
                    v3 = v3.sub(v0);

                    int i4 = (row - 1) * width * 3 + col * 3;
                    v4.x = posArr[i4];
                    v4.y = posArr[i4 + 1];
                    v4.z = posArr[i4 + 2];
                    v4 = v4.sub(v0);

                    v1.cross(v2, v12);
                    v12.normalize();

                    v2.cross(v3, v23);
                    v23.normalize();

                    v3.cross(v4, v34);
                    v34.normalize();

                    v4.cross(v1, v41);
                    v41.normalize();

                    normal = v12.add(v23).add(v34).add(v41);
                    normal.normalize();
                } else {
                    normal.x = 0;
                    normal.y = 1;
                    normal.z = 0;
                }
                normal.normalize();
                normals.add(normal.x);
                normals.add(normal.y);
                normals.add(normal.z);
            }
        }
        return Utils.listToArray(normals);
    }

}

Answer 1

大胆猜测：您使用的是 16 位索引，但将索引缓冲区的大小指定为 8 位索引（通过将缓冲区大小设置为缓冲区中的元素数）？

从屏幕截图来看，显然只绘制了上半部分，因此我认为问题出在索引缓冲区的创建或绘制调用上。

也许您在绘图调用中使用了错误数量的索引？就像您改用三角形的数量一样？或者假定三角形扇形而不是三角形的数字？

您必须 post 缓冲区对象的实际绘制调用和生成才能获得更多信息。

或者至少根据您使用的渲染库标记您的问题，因为它不是普通的 OpenGL。

高度图生成中途完成

Heightmap generation finishes halfway through

opengl

perlin-noise