Попытка установить VBO: s в C #, используя TAO и OpenGL TK framework.

Question

Я пытаюсь установить свои вершины, индексы и точки текстуры на VBO: s и рисовать их с помощью моего метода рисования, все это в C # под фреймворком TAO / OpenGL TK.Но мой экран показывает только черный экран.Я тестировал без VBO: s, и тогда это работает.Но с моими вершинами, индексами и точками текстуры я не могу добиться успеха.

Мой код:

private float[] vertices;
private byte[] indices;
private float[] texture;

private int[] mVertexBuffer;
private int[] mIndicesBuffer;
private int[] mTextureBuffer;

//...Constructor start
vertices = new float[] {
                                            -1.0f, -1.0f, 1.0f,
                                            1.0f, -1.0f, 1.0f,
                                            -1.0f, 1.0f, 1.0f,
                                            1.0f, 1.0f, 1.0f,

                                            1.0f, -1.0f, 1.0f,
                                            1.0f, -1.0f, -1.0f, 
                                            1.0f, 1.0f, 1.0f, 
                                            1.0f, 1.0f, -1.0f,

                                            1.0f, -1.0f, -1.0f, 
                                            -1.0f, -1.0f, -1.0f, 
                                            1.0f, 1.0f, -1.0f, 
                                            -1.0f, 1.0f, -1.0f,

                                            -1.0f, -1.0f, -1.0f, 
                                            -1.0f, -1.0f, 1.0f, 
                                            -1.0f, 1.0f, -1.0f, 
                                            -1.0f, 1.0f, 1.0f,

                                            -1.0f, -1.0f, -1.0f, 
                                            1.0f, -1.0f, -1.0f, 
                                            -1.0f, -1.0f, 1.0f, 
                                            1.0f, -1.0f, 1.0f,

                                            -1.0f, 1.0f, 1.0f, 
                                            1.0f, 1.0f, 1.0f, 
                                            -1.0f, 1.0f, -1.0f, 
                                            1.0f, 1.0f, -1.0f, 
                                            };

texture = new float[] {
                                                                                           0.0f, 1.0f,                                                1.0f, 1.0f,                                                0.0f, 0.0f,                                                 1.0f, 0.0f,                                                 
                                            0.0f, 1.0f, 
                                            1.0f, 1.0f, 
                                            0.0f, 0.0f, 
                                            1.0f, 0.0f, 

                                            0.0f, 1.0f, 
                                            1.0f, 1.0f, 
                                            0.0f, 0.0f, 
                                            1.0f, 0.0f, 

                                            0.0f, 1.0f, 
                                            1.0f, 1.0f, 
                                            0.0f, 0.0f, 
                                            1.0f, 0.0f, 

                                            0.0f, 1.0f, 
                                            1.0f, 1.0f, 
                                            0.0f, 0.0f, 
                                            1.0f, 0.0f, 

                                            0.0f, 1.0f, 
                                            1.0f, 1.0f, 
                                            0.0f, 0.0f, 
                                            1.0f, 0.0f,  
                                            };

indices = new byte[] {
                                            0, 1, 3, 0, 3, 2,                                                4, 5, 7, 4, 7, 6,
                                            8, 9, 11, 8, 11, 10,
                                            12, 13, 15, 12, 15, 14, 
                                            16, 17, 19, 16, 19, 18, 
                                             20, 21, 23, 20, 23, 22, 
                                            };

mVertexBuffer = new int[1];
mIndicesBuffer = new int[1];
mTextureBuffer = new int[1];

//...Constructor end

public void setBuffers() {
        gl.glGenBuffersARB(1, mVertexBuffer);
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, mVertexBuffer[0]);
        gl.glBufferDataARB(GL.GL_ARRAY_BUFFER_ARB,
        (IntPtr)(vertices.Length * sizeof(float)),
  vertices, GL.GL_STATIC_DRAW_ARB);

        gl.glGenBuffersARB(1, mIndicesBuffer);
        gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, mIndicesBuffer[0]);
        gl.glBufferDataARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB,
         (IntPtr)(indices.Length * sizeof(float)),
  indices, GL.GL_DYNAMIC_DRAW_ARB);

        gl.glGenBuffersARB(1, mTextureBuffer);
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, mTextureBuffer[0]);
        gl.glBufferDataARB(GL.GL_ARRAY_BUFFER_ARB,
         (IntPtr)(texture.Length * sizeof(float)),
  texture, GL.GL_STATIC_DRAW_ARB);
  }

    public void draw()
    {
        gl.glBegin(gl.GL_TRIANGLES);

        gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
        gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);

        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, mVertexBuffer[0]);
        gl.glVertexPointer(3, GL.GL_FLOAT, 0, mVertexBuffer);
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, mTextureBuffer[0]);
        gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, mTextureBuffer);

        gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, mIndicesBuffer[0]);

        gl.glDrawElements(GL.GL_TRIANGLES, indices.Length,
 gl.GL_UNSIGNED_BYTE, mIndicesBuffer);

        gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
        gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
        gl.glEnd();

    }

Вершины / индексы / точки текстуры работают в моей среде C ++ VBO, но не здесь,Так что я предполагаю, что что-то упустил из-за привязки.

Answer 1

На самом деле, я искал это тоже несколько недель. Теперь у меня есть правильное рабочее решение.

Есть несколько проблем, о которых вам нужно знать, чтобы успешно создать Vertex Buffer Object. Первая проблема заключается в том, что люди все портят. GL_INDEX_ARRAY не для твоих indices. Вы должны использовать GL_INDEX_ARRAY, когда используете цветовой массив для сглаживания цветов между вертами.

Другая проблема заключается в том, что Tao framework использует IntPtr.Zero для смещения, а не обычный 0. Вы используете последний параметр в вызове glDrawElements как стиль Vertex Array, когда это Vertex Buffer Object.

С другой стороны, похоже, что вы смешиваете два разных понятия вместе. Вы пытаетесь загрузить свои данные в буфер, который вам полностью удастся, если вы используете опубликованный код. Проблема в том, что вы используете неправильную команду GL_ARRAY_BUFFER. Для вашего indices вы должны использовать GL_ELEMENT_ARRAY_BUFFER.

С учетом сказанного я покажу одно решение, использующее стандарт Vertex Arrays, а другое - Vertex Buffer Objects. Я надеюсь, что это прояснит ситуацию.

Вершинные массивы :

public void draw()
{
     gl.glEnableClientState(gl.GL_VERTEX_ARRAY);
     gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY);

     gl.glVertexPointer(3, gl.GL_FLOAT, 0, verticesArray);
     gl.glTexCoordPointer(2, gl.GL_FLOAT, 0, textureArray);

     //With Vertex Arrays, the last parameter is your pointer to your indices
     gl.glDrawElements(gl.GL_TRIANGLES, indices.Length,
                               gl.GL_UNSIGNED_SHORT, indicesArray);

     gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY);
     gl.glDisableClientState(gl.GL_VERTEX_ARRAY);
}

Объекты буфера вершин :

//This should be used in the constructor 
//or in another method than the draw method
mVertexBuffer = new int[1];
mTextureBuffer = new int[1];
mIndexBuffer = new int[1];

gl.glGenBuffers(1, mVertexBuffer);
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, mVertexBuffer[0]);
gl.glBufferData(gl.GL_ARRAY_BUFFER,
     (IntPtr)(verticesArray.Length * sizeof(float)),
                  verticesArray, gl.GL_STATIC_DRAW);

gl.glGenBuffers(1, mTextureBuffer);
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, mTextureBuffer[0]);
gl.glBufferData(gl.GL_ARRAY_BUFFER,
     (IntPtr)(textureArray.Length * sizeof(float)),
                  textureArray, gl.GL_STATIC_DRAW);

gl.glGenBuffers(1, mIndexBuffer);
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer[0]);
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER,
     (IntPtr)(indicesArray.Length * sizeof(short)),
                  indicesArray, gl.GL_STATIC_DRAW);

//Your draw method
public void draw()
{     
    gl.glEnableClientState(gl.GL_VERTEX_ARRAY);
    gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY);

    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, mVertexBuffer[0]);

    //Notice: IntPtr.Zero is used...
    gl.glVertexPointer(3, gl.GL_FLOAT, 0, IntPtr.Zero);

    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, mTextureBuffer[0]);

    //Notice: IntPtr.Zero is used...
    gl.glTexCoordPointer(2, gl.GL_FLOAT, 0, IntPtr.Zero); 
    gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer[0]);

    //Notice: IntPtr.Zero is used. Last parameter is
    //an offset using Vertex Buffer Objects and in Vertex Arrays
    //it is a pointer
    gl.glDrawElements(gl.GL_TRIANGLES, indices.Length,
             gl.GL_UNSIGNED_SHORT, IntPtr.Zero); 

    //Remember to unbind your buffer to prevent it to destroy
    //other draw calls or objects
    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0);
    gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, 0);

    gl.glDisableClientState(gl.GL_VERTEX_ARRAY);
    gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY);            
}

Надеюсь, это было полезно, мне понадобилось время, чтобы понять это.

Answer 2

Вот пример рабочего класса, основанный на ответе Шелли:

class Vbo {
    private float[] vertices;
    private ushort[] indices;
    private float[] texture;

    private int[] mVertexBuffer;
    private int[] mIndicesBuffer;
    private int[] mTextureBuffer;

    public Vbo() {
        vertices = new float[] {
                                        -1.0f, -1.0f, 1.0f,
                                        1.0f, -1.0f, 1.0f,
                                        -1.0f, 1.0f, 1.0f,
                                        1.0f, 1.0f, 1.0f,

                                        1.0f, -1.0f, 1.0f,
                                        1.0f, -1.0f, -1.0f, 
                                        1.0f, 1.0f, 1.0f, 
                                        1.0f, 1.0f, -1.0f,

                                        1.0f, -1.0f, -1.0f, 
                                        -1.0f, -1.0f, -1.0f, 
                                        1.0f, 1.0f, -1.0f, 
                                        -1.0f, 1.0f, -1.0f,

                                        -1.0f, -1.0f, -1.0f, 
                                        -1.0f, -1.0f, 1.0f, 
                                        -1.0f, 1.0f, -1.0f, 
                                        -1.0f, 1.0f, 1.0f,

                                        -1.0f, -1.0f, -1.0f, 
                                        1.0f, -1.0f, -1.0f, 
                                        -1.0f, -1.0f, 1.0f, 
                                        1.0f, -1.0f, 1.0f,

                                        -1.0f, 1.0f, 1.0f, 
                                        1.0f, 1.0f, 1.0f, 
                                        -1.0f, 1.0f, -1.0f, 
                                        1.0f, 1.0f, -1.0f, 
                                        };

        texture = new float[] {
                                                                                       0.0f, 1.0f,                                                1.0f, 1.0f,                                                0.0f, 0.0f,                                                 1.0f, 0.0f,                                                 
                                        0.0f, 1.0f, 
                                        1.0f, 1.0f, 
                                        0.0f, 0.0f, 
                                        1.0f, 0.0f, 

                                        0.0f, 1.0f, 
                                        1.0f, 1.0f, 
                                        0.0f, 0.0f, 
                                        1.0f, 0.0f, 

                                        0.0f, 1.0f, 
                                        1.0f, 1.0f, 
                                        0.0f, 0.0f, 
                                        1.0f, 0.0f, 

                                        0.0f, 1.0f, 
                                        1.0f, 1.0f, 
                                        0.0f, 0.0f, 
                                        1.0f, 0.0f, 

                                        0.0f, 1.0f, 
                                        1.0f, 1.0f, 
                                        0.0f, 0.0f, 
                                        1.0f, 0.0f,  
                                        };

        indices = new ushort[] {
                                        0, 1, 3, 0, 3, 2,                                                4, 5, 7, 4, 7, 6,
                                        8, 9, 11, 8, 11, 10,
                                        12, 13, 15, 12, 15, 14, 
                                        16, 17, 19, 16, 19, 18, 
                                         20, 21, 23, 20, 23, 22, 
                                        };

        for (int i = 0; i < vertices.Length; i++) {
            vertices[i] *= 2;
        }

        mVertexBuffer = new int[1];
        mIndicesBuffer = new int[1];
        mTextureBuffer = new int[1];



        Gl.glGenBuffers(1, mVertexBuffer);
        Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, mVertexBuffer[0]);
        Gl.glBufferData(Gl.GL_ARRAY_BUFFER,
             (IntPtr)(vertices.Length * sizeof(float)),
                          vertices, Gl.GL_STATIC_DRAW);

        Gl.glGenBuffers(1, mTextureBuffer);
        Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, mTextureBuffer[0]);
        Gl.glBufferData(Gl.GL_ARRAY_BUFFER,
             (IntPtr)(texture.Length * sizeof(float)),
                          texture, Gl.GL_STATIC_DRAW);

        Gl.glGenBuffers(1, mIndicesBuffer);
        Gl.glBindBuffer(Gl.GL_ELEMENT_ARRAY_BUFFER, mIndicesBuffer[0]);
        Gl.glBufferData(Gl.GL_ELEMENT_ARRAY_BUFFER,
             (IntPtr)(indices.Length * sizeof(ushort)),
                          indices, Gl.GL_STATIC_DRAW);   
    }

    public void Render() {
        Gl.glEnableClientState(Gl.GL_VERTEX_ARRAY);
        Gl.glEnableClientState(Gl.GL_TEXTURE_COORD_ARRAY);

        Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, mVertexBuffer[0]);

        //Notice: IntPtr.Zero is used...
        Gl.glVertexPointer(3, Gl.GL_FLOAT, 0, IntPtr.Zero);

        Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, mTextureBuffer[0]);

        //Notice: IntPtr.Zero is used...
        Gl.glTexCoordPointer(2, Gl.GL_FLOAT, 0, IntPtr.Zero);
        Gl.glBindBuffer(Gl.GL_ELEMENT_ARRAY_BUFFER, mIndicesBuffer[0]);

        //Notice: IntPtr.Zero is used. Last parameter is
        //an offset using Vertex Buffer Objects and in Vertex Arrays
        //it is a pointer
        Gl.glDrawElements(Gl.GL_TRIANGLES, indices.Length, Gl.GL_UNSIGNED_SHORT, IntPtr.Zero);

        //Remember to unbind your buffer to prevent it to destroy
        //other draw calls or objects
        Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, 0);
        Gl.glBindBuffer(Gl.GL_ELEMENT_ARRAY_BUFFER, 0);

        Gl.glDisableClientState(Gl.GL_VERTEX_ARRAY);
        Gl.glDisableClientState(Gl.GL_TEXTURE_COORD_ARRAY); 
    }
}

Answer 3

Комментарии / модификации inline. Я не настроен проверять это, но это близко:

public void draw()
    {
        //gl.glBegin(gl.GL_TRIANGLES);  // no glBegin/glEnd at all -- that's immediate mode

        gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
        gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
        gl.glEnableClientState(GL.GL_INDEX_ARRAY);  // also using index array

        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, mVertexBuffer[0]);
        gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);  // with vertex arrays the last argument is a pointer, with VBOs it's an *offset*
        gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, mTextureBuffer[0]);
        gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);  // ditto

        gl.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, mIndicesBuffer[0]);

        //gl.glDrawElements(GL.GL_TRIANGLES, indices.Length, gl.GL_UNSIGNED_BYTE, mIndicesBuffer);  // this is vertex-array style
        gl.glIndexPointer(GL.GL_UNSIGNED_BYTE, 0, 0); // as above for all pointers
        gl.glDrawArrays(GL.GL_TRIANGLES, 0, indices.length);

        // You can probably leave these enabled to save time:
        gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
        gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
        gl.glDisableClientState(GL.GL_INDEX_ARRAY);            
        //gl.glEnd();

    }