Take the 2-minute tour ×
Game Development Stack Exchange is a question and answer site for professional and independent game developers. It's 100% free, no registration required.

I'm developing a game engine using OpenTK. I'm trying to get to grips with the use of VBO's. I've run into some trouble because somehow it doesn't render correctly. Thus far I've used immediate mode to render a test object, a test cube with a texture.

namespace SharpEngine.Utility.Mesh
{
    using System;
    using System.Collections.Generic;
    using OpenTK;
    using OpenTK.Graphics;
    using OpenTK.Graphics.OpenGL;
    using SharpEngine.Utility;
    using System.Drawing;

    public class ImmediateFaceBasedCube : IMesh
    {

        private IList<Face> faces = new List<Face>();

        public ImmediateFaceBasedCube()
        {
            IList<Vector3> allVertices = new List<Vector3>();
            //rechtsbovenvoor
            allVertices.Add(new Vector3(1.0f, 1.0f, 1.0f)); //0
            //rechtsbovenachter
            allVertices.Add(new Vector3(1.0f, 1.0f, -1.0f)); //1
            //linksbovenachter
            allVertices.Add(new Vector3(-1.0f, 1.0f, -1.0f)); //2
            //linksbovenvoor
            allVertices.Add(new Vector3(-1.0f, 1.0f, 1.0f)); //3
            //rechtsondervoor
            allVertices.Add(new Vector3(1.0f, -1.0f, 1.0f)); //4
            //rechtsonderachter
            allVertices.Add(new Vector3(1.0f, -1.0f, -1.0f)); //5
            //linksonderachter
            allVertices.Add(new Vector3(-1.0f, -1.0f, -1.0f)); //6
            //linksondervoor
            allVertices.Add(new Vector3(-1.0f, -1.0f, 1.0f)); //7

            IList<Vector2> textureCoordinates = new List<Vector2>();

            textureCoordinates.Add(new Vector2(0, 0));                      //AA - 0
            textureCoordinates.Add(new Vector2(0, 0.3333333f));             //AB - 1
            textureCoordinates.Add(new Vector2(0, 0.6666666f));             //AC - 2
            textureCoordinates.Add(new Vector2(0, 1));                      //AD - 3
            textureCoordinates.Add(new Vector2(0.3333333f, 0));             //BA - 4
            textureCoordinates.Add(new Vector2(0.3333333f, 0.3333333f));    //BB - 5
            textureCoordinates.Add(new Vector2(0.3333333f, 0.6666666f));    //BC - 6
            textureCoordinates.Add(new Vector2(0.3333333f, 1));             //BD - 7
            textureCoordinates.Add(new Vector2(0.6666666f, 0));             //CA - 8
            textureCoordinates.Add(new Vector2(0.6666666f, 0.3333333f));    //CB - 9
            textureCoordinates.Add(new Vector2(0.6666666f, 0.6666666f));    //CC -10
            textureCoordinates.Add(new Vector2(0.6666666f, 1));             //CD -11
            textureCoordinates.Add(new Vector2(1, 0));                      //DA -12
            textureCoordinates.Add(new Vector2(1, 0.3333333f));             //DB -13
            textureCoordinates.Add(new Vector2(1, 0.6666666f));             //DC -14
            textureCoordinates.Add(new Vector2(1, 1));                      //DD -15

            Vector3 copy1 = new Vector3(-2.0f, -2.5f, -3.5f);

            IList<Vector3> normals = new List<Vector3>();
            normals.Add(new Vector3(0, 1.0f, 0)); //0
            normals.Add(new Vector3(0, 0, 1.0f)); //1
            normals.Add(new Vector3(1.0f, 0, 0)); //2
            normals.Add(new Vector3(0, 0, -1.0f)); //3
            normals.Add(new Vector3(-1.0f, 0, 0)); //4
            normals.Add(new Vector3(0, -1.0f, 0)); //5

            //todo: move vertex normal and texture data to datastructure
            //todo: VBO based rendering

            //top face
            //1
            IList<VertexData> verticesT1 = new List<VertexData>();

            VertexData T1a = new VertexData();
            T1a.Normal = normals[0];
            T1a.TexCoord = textureCoordinates[5];
            T1a.Position = allVertices[3];
            verticesT1.Add(T1a);
            VertexData T1b = new VertexData();
            T1b.Normal = normals[0];
            T1b.TexCoord = textureCoordinates[9];
            T1b.Position = allVertices[0];
            verticesT1.Add(T1b);
            VertexData T1c = new VertexData();
            T1c.Normal = normals[0];
            T1c.TexCoord = textureCoordinates[10];
            T1c.Position = allVertices[1];
            verticesT1.Add(T1c);
            Face F1 = new Face(verticesT1);
            faces.Add(F1);

            //2
            IList<VertexData> verticesT2 = new List<VertexData>();
            VertexData T2a = new VertexData();
            T2a.Normal = normals[0];
            T2a.TexCoord = textureCoordinates[10];
            T2a.Position = allVertices[1];
            verticesT2.Add(T2a);
            VertexData T2b = new VertexData();
            T2b.Normal = normals[0];
            T2b.TexCoord = textureCoordinates[6];
            T2b.Position = allVertices[2];
            verticesT2.Add(T2b);
            VertexData T2c = new VertexData();
            T2c.Normal = normals[0];
            T2c.TexCoord = textureCoordinates[5];
            T2c.Position = allVertices[3];
            verticesT2.Add(T2c);
            Face F2 = new Face(verticesT2);
            faces.Add(F2);


            //front face
            //3
            IList<VertexData> verticesT3 = new List<VertexData>();
            VertexData T3a = new VertexData();
            T3a.Normal = normals[1];
            T3a.TexCoord = textureCoordinates[1];
            T3a.Position = allVertices[3];
            verticesT3.Add(T3a);
            VertexData T3b = new VertexData();
            T3b.Normal = normals[1];
            T3b.TexCoord = textureCoordinates[0];
            T3b.Position = allVertices[7];
            verticesT3.Add(T3b);
            VertexData T3c = new VertexData();
            T3c.Normal = normals[1];
            T3c.TexCoord = textureCoordinates[5];
            T3c.Position = allVertices[0];
            verticesT3.Add(T3c);
            Face F3 = new Face(verticesT3);
            faces.Add(F3);


            //4
            IList<VertexData> verticesT4 = new List<VertexData>();
            VertexData T4a = new VertexData();
            T4a.Normal = normals[1];
            T4a.TexCoord = textureCoordinates[5];
            T4a.Position = allVertices[0];
            verticesT4.Add(T4a);
            VertexData T4b = new VertexData();
            T4b.Normal = normals[1];
            T4b.TexCoord = textureCoordinates[0];
            T4b.Position = allVertices[7];
            verticesT4.Add(T4b);
            VertexData T4c = new VertexData();
            T4c.Normal = normals[1];
            T4c.TexCoord = textureCoordinates[4];
            T4c.Position = allVertices[4];
            verticesT4.Add(T4c);
            Face F4 = new Face(verticesT4);
            faces.Add(F4);

            //right face
            //5
            IList<VertexData> verticesT5 = new List<VertexData>();
            VertexData T5a = new VertexData();
            T5a.Normal = normals[2];
            T5a.TexCoord = textureCoordinates[2];
            T5a.Position = allVertices[0];
            verticesT5.Add(T5a);
            VertexData T5b = new VertexData();
            T5b.Normal = normals[2];
            T5b.TexCoord = textureCoordinates[1];
            T5b.Position = allVertices[4];
            verticesT5.Add(T5b);
            VertexData T5c = new VertexData();
            T5c.Normal = normals[2];
            T5c.TexCoord = textureCoordinates[6];
            T5c.Position = allVertices[1];
            verticesT5.Add(T5c);
            Face F5 = new Face(verticesT5);
            faces.Add(F5);

            //6
            IList<VertexData> verticesT6 = new List<VertexData>();
            VertexData T6a = new VertexData();
            T6a.Normal = normals[2];
            T6a.TexCoord = textureCoordinates[1];
            T6a.Position = allVertices[4];
            verticesT6.Add(T6a);
            VertexData T6b = new VertexData();
            T6b.Normal = normals[2];
            T6b.TexCoord = textureCoordinates[5];
            T6b.Position = allVertices[5];
            verticesT6.Add(T6b);
            VertexData T6c = new VertexData();
            T6c.Normal = normals[2];
            T6c.TexCoord = textureCoordinates[6];
            T6c.Position = allVertices[1];
            verticesT6.Add(T6c);
            Face F6 = new Face(verticesT6);
            faces.Add(F6);

            //back face
            //7
            IList<VertexData> verticesT7 = new List<VertexData>();
            VertexData T7a = new VertexData();
            T7a.Normal = normals[3];
            T7a.TexCoord = textureCoordinates[4];
            T7a.Position = allVertices[5];
            verticesT7.Add(T7a);
            VertexData T7b = new VertexData();
            T7b.Normal = normals[3];
            T7b.TexCoord = textureCoordinates[9];
            T7b.Position = allVertices[2];
            verticesT7.Add(T7b);
            VertexData T7c = new VertexData();
            T7c.Normal = normals[3];
            T7c.TexCoord = textureCoordinates[5];
            T7c.Position = allVertices[1];
            verticesT7.Add(T7c);
            Face F7 = new Face(verticesT7);
            faces.Add(F7);
            //8
            IList<VertexData> verticesT8 = new List<VertexData>();
            VertexData T8a = new VertexData();
            T8a.Normal = normals[3];
            T8a.TexCoord = textureCoordinates[9];
            T8a.Position = allVertices[2];
            verticesT8.Add(T8a);
            VertexData T8b = new VertexData();
            T8b.Normal = normals[3];
            T8b.TexCoord = textureCoordinates[4];
            T8b.Position = allVertices[5];
            verticesT8.Add(T8b);
            VertexData T8c = new VertexData();
            T8c.Normal = normals[3];
            T8c.TexCoord = textureCoordinates[8];
            T8c.Position = allVertices[6];
            verticesT8.Add(T8c);
            Face F8 = new Face(verticesT8);
            faces.Add(F8);


            //left face
            //9
            IList<VertexData> verticesT9 = new List<VertexData>();
            VertexData T9a = new VertexData();
            T9a.Normal = normals[4];
            T9a.TexCoord = textureCoordinates[8];
            T9a.Position = allVertices[6];
            verticesT9.Add(T9a);
            VertexData T9b = new VertexData();
            T9b.Normal = normals[4];
            T9b.TexCoord = textureCoordinates[13];
            T9b.Position = allVertices[3];
            verticesT9.Add(T9b);
            VertexData T9c = new VertexData();
            T9c.Normal = normals[4];
            T9c.TexCoord = textureCoordinates[9];
            T9c.Position = allVertices[2];
            verticesT9.Add(T9c);
            Face F9 = new Face(verticesT9);
            faces.Add(F9);
            //10
            IList<VertexData> verticesT10 = new List<VertexData>();
            VertexData T10a = new VertexData();
            T10a.Normal = normals[4];
            T10a.TexCoord = textureCoordinates[8];
            T10a.Position = allVertices[6];
            verticesT10.Add(T10a);
            VertexData T10b = new VertexData();
            T10b.Normal = normals[4];
            T10b.TexCoord = textureCoordinates[12];
            T10b.Position = allVertices[7];
            verticesT10.Add(T10b);
            VertexData T10c = new VertexData();
            T10c.Normal = normals[4];
            T10c.TexCoord = textureCoordinates[13];
            T10c.Position = allVertices[3];
            verticesT10.Add(T10c);
            Face F10 = new Face(verticesT10);
            faces.Add(F10);

            //bottom face
            //11
            IList<VertexData> verticesT11 = new List<VertexData>();
            VertexData T11a = new VertexData();
            T11a.Normal = normals[5];
            T11a.TexCoord = textureCoordinates[10];
            T11a.Position = allVertices[7];
            verticesT11.Add(T11a);
            VertexData T11b = new VertexData();
            T11b.Normal = normals[5];
            T11b.TexCoord = textureCoordinates[9];
            T11b.Position = allVertices[6];
            verticesT11.Add(T11b);
            VertexData T11c = new VertexData();
            T11c.Normal = normals[5];
            T11c.TexCoord = textureCoordinates[14];
            T11c.Position = allVertices[4];
            verticesT11.Add(T11c);
            Face F11 = new Face(verticesT11);
            faces.Add(F11);
            //12
            IList<VertexData> verticesT12 = new List<VertexData>();
            VertexData T12a = new VertexData();
            T12a.Normal = normals[5];
            T12a.TexCoord = textureCoordinates[13];
            T12a.Position = allVertices[5];
            verticesT12.Add(T12a);
            VertexData T12b = new VertexData();
            T12b.Normal = normals[5];
            T12b.TexCoord = textureCoordinates[14];
            T12b.Position = allVertices[4];
            verticesT12.Add(T12b);
            VertexData T12c = new VertexData();
            T12c.Normal = normals[5];
            T12c.TexCoord = textureCoordinates[9];
            T12c.Position = allVertices[6];
            verticesT12.Add(T12c);
            Face F12 = new Face(verticesT12);
            faces.Add(F12);
        }

        public void draw()
        {
            GL.Begin(BeginMode.Triangles);

            foreach (Face  face in faces)
            {
                foreach (VertexData datapoint in face.verticesWithTexCoords)
                {
                    GL.Normal3(datapoint.Normal);
                    GL.TexCoord2(datapoint.TexCoord);
                    GL.Vertex3(datapoint.Position);
                }
            }
            GL.End();
        }

    }
}

Gets me this very nice picture: Immediate mode cube

The immediate mode cube renders nicely and taught me a bit on how to use OpenGL, but VBO's are the way to go. Since I read on the OpenTK forums that OpenTK has problems doing VA's or DL's, I decided to skip using those.

Now, I've tried to change this cube to a VBO by using the same vertex, normal and tc collections, and making float arrays from them by using the coordinates in combination with uint arrays which contain the index numbers from the immediate cube. (see the private functions at end of the code sample) Somehow this only renders two triangles

namespace SharpEngine.Utility.Mesh { using System; using System.Collections.Generic; using OpenTK; using OpenTK.Graphics; using OpenTK.Graphics.OpenGL; using SharpEngine.Utility; using System.Drawing;

public class VBOFaceBasedCube : IMesh
{

    private int VerticesVBOID;
    private int VerticesVBOStride;
    private int VertexCount;
    private int ELementBufferObjectID;
    private int textureCoordinateVBOID;
    private int textureCoordinateVBOStride;
    //private int textureCoordinateArraySize;
    private int normalVBOID;
    private int normalVBOStride;


    public VBOFaceBasedCube()
    {
        IList<Vector3> allVertices = new List<Vector3>();
        //rechtsbovenvoor
        allVertices.Add(new Vector3(1.0f, 1.0f, 1.0f)); //0
        //rechtsbovenachter
        allVertices.Add(new Vector3(1.0f, 1.0f, -1.0f)); //1
        //linksbovenachter
        allVertices.Add(new Vector3(-1.0f, 1.0f, -1.0f)); //2
        //linksbovenvoor
        allVertices.Add(new Vector3(-1.0f, 1.0f, 1.0f)); //3
        //rechtsondervoor
        allVertices.Add(new Vector3(1.0f, -1.0f, 1.0f)); //4
        //rechtsonderachter
        allVertices.Add(new Vector3(1.0f, -1.0f, -1.0f)); //5
        //linksonderachter
        allVertices.Add(new Vector3(-1.0f, -1.0f, -1.0f)); //6
        //linksondervoor
        allVertices.Add(new Vector3(-1.0f, -1.0f, 1.0f)); //7

        IList<Vector2> textureCoordinates = new List<Vector2>();

        textureCoordinates.Add(new Vector2(0, 0));                      //AA - 0
        textureCoordinates.Add(new Vector2(0, 0.3333333f));             //AB - 1
        textureCoordinates.Add(new Vector2(0, 0.6666666f));             //AC - 2
        textureCoordinates.Add(new Vector2(0, 1));                      //AD - 3
        textureCoordinates.Add(new Vector2(0.3333333f, 0));             //BA - 4
        textureCoordinates.Add(new Vector2(0.3333333f, 0.3333333f));    //BB - 5
        textureCoordinates.Add(new Vector2(0.3333333f, 0.6666666f));    //BC - 6
        textureCoordinates.Add(new Vector2(0.3333333f, 1));             //BD - 7
        textureCoordinates.Add(new Vector2(0.6666666f, 0));             //CA - 8
        textureCoordinates.Add(new Vector2(0.6666666f, 0.3333333f));    //CB - 9
        textureCoordinates.Add(new Vector2(0.6666666f, 0.6666666f));    //CC -10
        textureCoordinates.Add(new Vector2(0.6666666f, 1));             //CD -11
        textureCoordinates.Add(new Vector2(1, 0));                      //DA -12
        textureCoordinates.Add(new Vector2(1, 0.3333333f));             //DB -13
        textureCoordinates.Add(new Vector2(1, 0.6666666f));             //DC -14
        textureCoordinates.Add(new Vector2(1, 1));                      //DD -15

        Vector3 copy1 = new Vector3(-2.0f, -2.5f, -3.5f);

        IList<Vector3> normals = new List<Vector3>();
        normals.Add(new Vector3(0, 1.0f, 0)); //0
        normals.Add(new Vector3(0, 0, 1.0f)); //1
        normals.Add(new Vector3(1.0f, 0, 0)); //2
        normals.Add(new Vector3(0, 0, -1.0f)); //3
        normals.Add(new Vector3(-1.0f, 0, 0)); //4
        normals.Add(new Vector3(0, -1.0f, 0)); //5

        //todo: VBO based rendering
        uint[] vertexElements = {
                            3,0,1,  //01
                            1,2,3,  //02
                            3,7,0,  //03
                            0,7,4,  //04
                            0,4,1,  //05
                            4,5,1,  //06
                            5,2,1,  //07
                            2,5,6,  //08
                            6,3,2,  //09
                            6,7,5,  //10
                            7,6,4,  //11
                            5,4,6   //12
            };
        VertexCount = vertexElements.Length;
        IList<uint> vertexElementList = new List<uint>(vertexElements);
        uint[] normalElements = {
                            0,0,0,
                            0,0,0,
                            1,1,1,
                            1,1,1,
                            2,2,2,
                            2,2,2,
                            3,3,3,
                            3,3,3,
                            4,4,4,
                            4,4,4,
                            5,5,5,
                            5,5,5
            };
        IList<uint> normalElementList = new List<uint>(normalElements);
        uint[] textureIndexArray = {
                            5,9,10,
                            10,6,5,
                            1,0,5,
                            5,0,4,
                            2,1,6,
                            1,5,6,
                            4,9,5,
                            9,4,8,
                            8,13,9,
                            8,12,13,
                            10,9,14,
                            13,14,9
            };
        //textureCoordinateArraySize = textureIndexArray.Length;
        IList<uint> textureIndexList = new List<uint>(textureIndexArray);
        LoadVBO(allVertices, normals, textureCoordinates, vertexElements, normalElementList, textureIndexList);
    }


    public void draw()
    {
        //bind vertices
        //bind elements
        //bind normals
        //bind texture coordinates

        GL.EnableClientState(ArrayCap.VertexArray);
        GL.EnableClientState(ArrayCap.NormalArray);
        GL.EnableClientState(ArrayCap.TextureCoordArray);
        GL.BindBuffer(BufferTarget.ArrayBuffer, VerticesVBOID);
        GL.VertexPointer(3, VertexPointerType.Float, VerticesVBOStride, 0);

        GL.BindBuffer(BufferTarget.ArrayBuffer, normalVBOID);
        GL.NormalPointer(NormalPointerType.Float, normalVBOStride, 0);

        GL.BindBuffer(BufferTarget.ArrayBuffer, textureCoordinateVBOID);
        GL.TexCoordPointer(2, TexCoordPointerType.Float, textureCoordinateVBOStride, 0);
        GL.BindBuffer(BufferTarget.ElementArrayBuffer, ELementBufferObjectID);
        GL.DrawElements(BeginMode.Polygon, VertexCount, DrawElementsType.UnsignedShort, 0);
    }


    //loads a static VBO

    void LoadVBO(IList<Vector3> vertices, IList<Vector3> normals, IList<Vector2> texcoords, uint[] elements, IList<uint> normalIndices, IList<uint> texCoordIndices)
    {
        int size;

        //todo

        // To create a VBO:
        // 1) Generate the buffer handles for the vertex and element buffers.
        // 2) Bind the vertex buffer handle and upload your vertex data. Check that the buffer was uploaded correctly.
        // 3) Bind the element buffer handle and upload your element data. Check that the buffer was uploaded correctly.
        float[] verticesArray = convertVector3fListToFloatArray(vertices);
        float[] normalsArray = createFloatArrayFromListOfVector3ElementsAndIndices(normals, normalIndices);
        float[] textureCoordinateArray = createFloatArrayFromListOfVector2ElementsAndIndices(texcoords, texCoordIndices);
        GL.GenBuffers(1, out VerticesVBOID);
        GL.BindBuffer(BufferTarget.ArrayBuffer, VerticesVBOID);
        Console.WriteLine("load 1 - vertices");
        VerticesVBOStride = BlittableValueType.StrideOf(verticesArray);     
        GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(verticesArray.Length * sizeof(float)), verticesArray,
                      BufferUsageHint.StaticDraw);
        GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
        if (verticesArray.Length * BlittableValueType.StrideOf(verticesArray) != size)
        {
            throw new ApplicationException("Vertex data not uploaded correctly");
        }
        else
        {

            Console.WriteLine("load 1 finished ok");
            size = 0;
        }

        Console.WriteLine("load 2 - elements");
        GL.GenBuffers(1, out ELementBufferObjectID);
        GL.BindBuffer(BufferTarget.ElementArrayBuffer, ELementBufferObjectID);
        GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(elements.Length * sizeof(uint)), elements,
                      BufferUsageHint.StaticDraw);
        GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size);
        if (elements.Length * sizeof(uint) != size)
        {
            throw new ApplicationException("Element data not uploaded correctly");
        }
        else
        {
            size = 0;
            Console.WriteLine("load 2 finished ok");
        }

        GL.GenBuffers(1, out normalVBOID);
        GL.BindBuffer(BufferTarget.ArrayBuffer, normalVBOID);
        Console.WriteLine("load 3 - normals");
        normalVBOStride = BlittableValueType.StrideOf(normalsArray);
        GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(normalsArray.Length * sizeof(float)), normalsArray,
                      BufferUsageHint.StaticDraw);
        GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
        Console.WriteLine("load 3 - pre check");
        if (normalsArray.Length * BlittableValueType.StrideOf(normalsArray) != size)
        {
            throw new ApplicationException("Normal data not uploaded correctly");
        }
        else
        {
            Console.WriteLine("load 3 finished ok");
            size = 0;
        }


        GL.GenBuffers(1, out textureCoordinateVBOID);
        GL.BindBuffer(BufferTarget.ArrayBuffer, textureCoordinateVBOID);
        Console.WriteLine("load 4- texture coordinates");
        textureCoordinateVBOStride = BlittableValueType.StrideOf(textureCoordinateArray);
        GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(textureCoordinateArray.Length * textureCoordinateVBOStride), textureCoordinateArray,
                      BufferUsageHint.StaticDraw);
        GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size);
        if (textureCoordinateArray.Length * BlittableValueType.StrideOf(textureCoordinateArray) != size)
        {
            throw new ApplicationException("texture coordinate data not uploaded correctly");
        }
        else
        {
            Console.WriteLine("load 3 finished ok");
            size = 0;
        }
    }

    //used to convert vertex arrayss for use with VBO's
    private float[] convertVector3fListToFloatArray(IList<Vector3> input)
    {
        int arrayElementCount = input.Count * 3;
        float[] output = new float[arrayElementCount];
        int fillCount = 0;
        foreach (Vector3 v in input)
        {
            output[fillCount] = v.X;
            output[fillCount + 1] = v.Y;
            output[fillCount + 2] = v.Z;
            fillCount += 3;
        }
        return output;
    }

    //used for converting texture coordinate arrays for use with VBO's
    private float[] convertVector2List_to_floatArray(IList<Vector2> input)
    {
        int arrayElementCount = input.Count * 2;
        float[] output = new float[arrayElementCount];
        int fillCount = 0;
        foreach (Vector2 v in input)
        {
            output[fillCount] = v.X;
            output[fillCount + 1] = v.Y;
            fillCount += 2;
        }
        return output;
    }

    //used to create an array of floats from 
    private float[] createFloatArrayFromListOfVector3ElementsAndIndices(IList<Vector3> inputVectors, IList<uint> indices)
    {
        int arrayElementCount = inputVectors.Count * indices.Count * 3;
        float[] output = new float[arrayElementCount];
        int fillCount = 0;
        foreach (int i in indices)
        {
            output[fillCount] = inputVectors[i].X;
            output[fillCount + 1] = inputVectors[i].Y;
            output[fillCount + 2] = inputVectors[i].Z;
            fillCount += 3;
        }
        return output;
    }

    private float[] createFloatArrayFromListOfVector2ElementsAndIndices(IList<Vector2> inputVectors, IList<uint> indices)
    {
        int arrayElementCount = inputVectors.Count * indices.Count * 2;
        float[] output = new float[arrayElementCount];
        int fillCount = 0;
        foreach (int i in indices)
        {
            output[fillCount] = inputVectors[i].X;
            output[fillCount + 1] = inputVectors[i].Y;
            fillCount += 2;
        }
        return output;
    }
}

}

This code will only render two triangles and they're nothing like I had in mind: Rendering with VBO based cube

I've done some searching. In some other questions I read that, if I did something wrong, I'd get no rendering at all. Clearly, something gets sent to the GFX card, but it might be that I'm not sending the right data. I've tried altering the sequence in which the triangles are rendered by swapping some of the index numbers in the vert, tc and normal index arrays, but this doesn't seem to be of any effect. I'm slightly lost here. What am I doing wrong here?

share|improve this question
    
I assume you've tried working up from a known good example? Common issues I've seen with VBOs usually center around the stride length and setting the correct byte offsets for the vertices, texture and normal coordinates. Having errors in those might get you something on screen, but it would look strange. –  Byte56 Dec 10 '12 at 15:31
    
Aren't you only specifying 6 vertices in vertexElements? Which only makes 2 triangles? –  ForkandBeard Dec 10 '12 at 16:25
    
@ForkandBeard: Oops. I also made a tile class which was supposed to render just one face. I accidentally pasted that one instead of the cube class. Both won't work though. Pretty much the same picture is rendered, just with a different part of the texture being shown. –  Onno Dec 10 '12 at 16:32
    
@Byte56: The OpenTK example uses interleaved VBO's from the get-go. I thought it would be easier for me if I tried separate VBO's first, and then develop a cube rendering using the interleaved VBO's from there. Also, the OpenTK example is quite sparsely commented for a tutorial kind of code example. So I tried to figure out how to use the VBO from the example and the API docs. I did try playing around with the stride a bit, but that either got me GFX card memory exceptions or similar results to the picture shown. –  Onno Dec 10 '12 at 16:35
    
@Onno If there's an example of the interleaved VBOs, I think it would be easier to start with that. –  Byte56 Dec 10 '12 at 16:38
show 2 more comments

closed as too localized by Byte56, Trevor Powell, bummzack, Josh Petrie, Sean Middleditch Dec 28 '12 at 7:06

This question is unlikely to help any future visitors; it is only relevant to a small geographic area, a specific moment in time, or an extraordinarily narrow situation that is not generally applicable to the worldwide audience of the internet. For help making this question more broadly applicable, visit the help center.If this question can be reworded to fit the rules in the help center, please edit the question.

1 Answer

up vote 1 down vote accepted

Common issues I've seen with VBOs usually center around the stride length and setting the correct byte offsets for the vertices, texture and normal coordinates. Make sure you're using the correct values for the stride length. It's usually easiest to set these to constants since you know they're unlikely to change.

share|improve this answer
    
I couldn't have done it without your input though :) –  Onno Dec 12 '12 at 14:58
add comment

Not the answer you're looking for? Browse other questions tagged or ask your own question.