一个VBO中的多个多维数据集

Question

所以，我已经找到了实现这一点的方法。我的阵列看起来一团糟。这个问题很难解释，所以我会提供一些图片和代码。

编辑：问题是for循环和x1，y1，z1变量由浮点数控制

public void create() {
    setup();
    render();
}

private void makeCube() {
    texture = glGenBuffers();
    cube = glGenBuffers();

    FloatBuffer cubeBuffer;
    FloatBuffer textureBuffer;

    ArrayList<Float> cubeList = new ArrayList<>();
    ArrayList<Float> textureList = new ArrayList<>();

    float[] cubeFloat;
    float[] textureFloat;

    for (float x1 = 0; x1 < tileSize * width; x1 += tileSize) {
        for (float y1 = 0; y1 < tileSize * height; y1 += tileSize) {
            for (float z1 = -tileSize * depth; z1 < 0; z1 += tileSize) {
                float highX = x1 + tileSize;
                float highY = y1 + tileSize;
                float highZ = z1 + tileSize;

                float[] cubeData = new float[]{
                    /*Front Face*/
                    x1, y1, z1,
                    highX, y1, z1,
                    highX, highY, z1,
                    x1, highY, z1,
                    /*Back Face*/
                    x1, y1, highZ,
                    highX, y1, highZ,
                    highX, highY, highZ,
                    x1, highY, highZ,
                    /*Left Face*/
                    x1, y1, z1,
                    x1, y1, highZ,
                    x1, highY, highZ,
                    x1, highY, z1,
                    /*Right Face*/
                    highX, y1, z1,
                    highX, y1, highZ,
                    highX, highY, highZ,
                    highX, highY, z1,
                    /*Bottom Face*/
                    x1, y1, z1,
                    x1, y1, highZ,
                    highX, y1, highZ,
                    highX, y1, z1,
                    /*Top Face*/
                    x1, highY, z1,
                    x1, highY, highZ,
                    highX, highY, highZ,
                    highX, highY, z1};

                for (float f : cubeData) {
                    cubeList.add(f);
                }
            }
        }
    }

    cubeFloat = compileFloat(cubeList);

    for (int i = 0; i < (width * height * depth); i++) {
        float[] textureData = new float[]{
            0, 0,
            1, 0,
            1, 1,
            0, 1,
            0, 0,
            1, 0,
            1, 1,
            0, 1,
            0, 0,
            1, 0,
            1, 1,
            0, 1,
            0, 0,
            1, 0,
            1, 1,
            0, 1,
            0, 0,
            1, 0,
            1, 1,
            0, 1,
            0, 0,
            1, 0,
            1, 1,
            0, 1};

        for (Float f : textureData) {
            textureList.add(f);
        }
    }

    textureFloat = compileFloat(textureList);

    textureBuffer = asFloatBuffer(textureFloat);
    glBindBuffer(GL_ARRAY_BUFFER, texture);
    glBufferData(GL_ARRAY_BUFFER, textureBuffer, GL_DYNAMIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    cubeBuffer = asFloatBuffer(cubeFloat);
    glBindBuffer(GL_ARRAY_BUFFER, cube);
    glBufferData(GL_ARRAY_BUFFER, cubeBuffer, GL_DYNAMIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

private float[] compileFloat(ArrayList<Float> list) {
    float[] f = new float[list.size()];

    for (int i = 0; i < list.size(); i++) {
        f[i] = list.get(i);
    }

    return f;
}

private void renderCube() {
    textures.get(0).bind();

    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    glBindBuffer(GL_ARRAY_BUFFER, cube);
    glVertexPointer(3, GL_FLOAT, 0, 0);

    glBindBuffer(GL_ARRAY_BUFFER, texture);
    glTexCoordPointer(2, GL_FLOAT, 0, 0);

    glDrawArrays(GL_QUADS, 0, 24 * (width * height * depth));

    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}

private void render() {
    while (!Display.isCloseRequested()) {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();
        camera();

        renderCube();

        Display.update();
        Display.sync(30);
    }

    Display.destroy();
    System.exit(0);
}

private void setup() {
    try {
        Display.setDisplayMode(new DisplayMode(frameWidth, frameHeight));
        Display.setTitle("3D Project");
        Display.setVSyncEnabled(vSync);
        Display.create();
    } catch (LWJGLException ex) {
        Logger.getLogger(Camera.class.getName()).log(Level.SEVERE, null, ex);
    }

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(fov, (float) Display.getWidth() / (float) Display.getHeight(), zNear, zFar);
    //glOrtho(0, Display.getWidth(), Display.getHeight(), 0, -1, 1);
    glMatrixMode(GL_MODELVIEW);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);

    glLoadIdentity();

    loadTextures();

    makeCube();

}

制作3x3x1阵列会产生以下结果：

Answer 1

感谢您解释tileSize使用的值。值0.1不能以任何精度用浮点表示，它会退化为基数2中的重复分数，就像大家熟悉的基数10中的1/3一样。现在，如果你继续加上这个数字，这个数字并不完全是0.1，最终的结果将与你所期望的大不相同。

通常，最好避免使用浮点表达式进行循环控制。您可能会认为，因为编译器乐于接受浮点常量（如0.1），所以一切都很好，它可以准确地表示该数字，但如果您不理解浮点数学的机制，那么类似这样的奇怪事情可能会发生。

如果您感到好奇，可以在这里找到关于我提到的问题的更详细的解释。