A step towards GL3

You can take a look at glim: http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Numb...
It tries to do similar thing in C++.

OGRE engine also has a similar interface.

http://www.ogre3d.org/wiki/index.php/ManualObject

Which data format of vertex arrays do you guys use for best speed/quality compromise..? I would guess short ints are "good enough" quailtywise for smaller models, while being half the size of floats, and one forth the size of doubles! In theory they should be 4x faster right? Even more obvious for normals/colors/texcoords, they really do not need to be floats/doubles, no need for such high precision.

I'm thinking of making VABuilder have one "nice, comfy" mode (doubles) and one "fast, not so comfy" mode (short ints). Maybe even split into two separate builder. Generic type T to define what data format to use..? Don't know, since might want different formats for positions/colors/texcoords/normals.

Comments? I know "measure, measure, measure" is the "answer to everything" when it comes to performance, but what is your experience?

Changing from VAs to VBOs means changing just two lines of code:

• You call GL.BufferData() to upload the data, instead of keeping it in yourself.
• You modify the last parameter of GL.Vertex/Normal/*Pointer()
to be a 0-based offset inside a single vertex, instead of a pointer to the actual data.

That's all, actually. Bonus points if you go all the way and replace GL.Vertex/Normal/ColorPointer() with GL.VertexAttribPointer() and a simple vertex shader.

Sounds hairy at first, but the strength of the GL3 approach will become apparent once you actually implement it. True, there is an initial explosion in setup code (you need to generate objects, upload data, run a shader) but guess what: you only need to write the setup code once. The final result is both cleaner and faster than immediate mode.

Edit: once you actually go the VBO route, you'll see that there's little need for emulating immediate. Check this out:

struct Vertex { public Vector3 Position; public Color4 Color; }
 
var data = new List<Vertex>();
data.Add(new Vertex() { Position = { 0, 0, 0 }, Color = { 0, 1, 0, 0 } });
data.Add(new Vertex() { Position = { 1, 0, 0 }, Color = { 0, 1, 0, 0 } });
data.Add(new Vertex() { Position = { 1, 0, 1 }, Color = { 0, 1, 0, 0 } });
data.Add(new Vertex() { Position = { 0, 0, 1 }, Color = { 0, 1, 0, 0 } });
 
GL.BufferData(..., data.ToArray());

My abstraction looks similar to this:

// Setup code
var device = new GraphicsDevice(Context);
 
var sky_program = new ShaderProgram(device)
{
    new VertexShader(Resources.SkyVS),
    new FragmentShader(Resources.SkyFS)
};
shader.SetUniform("ProjectionMatrix", ref Camera.Projection);
shader.SetUniform("SunPosition", Sun.Position);
 
var sky_vertices = new VertexBuffer<VertexPositionTexture>(device);
model_vertices.SetData(...);
 
var sky_elements = new ElementBufferShort(device, ElementType.Triangle);
model_elements .SetData(...);
 
var sky_texture = new CompressedTexture2D(device, Resources.SkyTexture);
var cloud_texture = new CompressedTexture2D(device, Resources.CloudTexture);
 
// Render code
shader.SetUniform("ModelviewMatrix", ref Camera.Modelview);
device.Render(shader, sky_vertices, sky_elements, sky_texture, cloud_texture);
 
// Clean-up code
device.Dispose();

Np.

I edited my post while you were posting, yet again. :)