/* Set up rendering of the leaf nodes. */
void VertexBufferLeaf::setupRendering( VertexBufferState& state,
GLuint* data ) const
{
switch( state.getRenderMode() )
{
case RENDER_MODE_IMMEDIATE:
break;
case RENDER_MODE_BUFFER_OBJECT:
{
const char* charThis = reinterpret_cast< const char* >( this );
if( data[VERTEX_OBJECT] == state.INVALID )
data[VERTEX_OBJECT] = state.newBufferObject( charThis + 0 );
glBindBuffer( GL_ARRAY_BUFFER, data[VERTEX_OBJECT] );
glBufferData( GL_ARRAY_BUFFER, _vertexLength * sizeof( Vertex ),
&_globalData.vertices[_vertexStart], GL_STATIC_DRAW );
if( data[NORMAL_OBJECT] == state.INVALID )
data[NORMAL_OBJECT] = state.newBufferObject( charThis + 1 );
glBindBuffer( GL_ARRAY_BUFFER, data[NORMAL_OBJECT] );
glBufferData( GL_ARRAY_BUFFER, _vertexLength * sizeof( Normal ),
&_globalData.normals[_vertexStart], GL_STATIC_DRAW );
if( data[COLOR_OBJECT] == state.INVALID )
data[COLOR_OBJECT] = state.newBufferObject( charThis + 2 );
if( state.useColors() )
{
glBindBuffer( GL_ARRAY_BUFFER, data[COLOR_OBJECT] );
glBufferData( GL_ARRAY_BUFFER, _vertexLength * sizeof( Color ),
&_globalData.colors[_vertexStart], GL_STATIC_DRAW );
}
if( data[INDEX_OBJECT] == state.INVALID )
data[INDEX_OBJECT] = state.newBufferObject( charThis + 3 );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, data[INDEX_OBJECT] );
glBufferData( GL_ELEMENT_ARRAY_BUFFER,
_indexLength * sizeof( ShortIndex ),
&_globalData.indices[_indexStart], GL_STATIC_DRAW );
break;
}
case RENDER_MODE_DISPLAY_LIST:
default:
{
if( data[0] == state.INVALID )
{
char* key = (char*)( this );
if( state.useColors( ))
++key;
data[0] = state.newDisplayList( key );
}
glNewList( data[0], GL_COMPILE );
renderImmediate( state );
glEndList();
break;
}
}
}
/* Render the leaf with buffer objects. */
void VertexBufferLeaf::renderBufferObject( VertexBufferState& state ) const
{
GLuint buffers[4];
for( int i = 0; i < 4; ++i )
buffers[i] =
state.getBufferObject( reinterpret_cast< const char* >(this) + i );
if( buffers[VERTEX_OBJECT] == state.INVALID ||
buffers[NORMAL_OBJECT] == state.INVALID ||
buffers[COLOR_OBJECT] == state.INVALID ||
buffers[INDEX_OBJECT] == state.INVALID )
setupRendering( state, buffers );
if( state.useColors() )
{
glBindBuffer( GL_ARRAY_BUFFER, buffers[COLOR_OBJECT] );
glColorPointer( 4, GL_UNSIGNED_BYTE, 0, 0 );
}
glBindBuffer( GL_ARRAY_BUFFER, buffers[NORMAL_OBJECT] );
glNormalPointer( GL_FLOAT, 0, 0 );
glBindBuffer( GL_ARRAY_BUFFER, buffers[VERTEX_OBJECT] );
glVertexPointer( 3, GL_FLOAT, 0, 0 );
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, buffers[INDEX_OBJECT] );
glDrawElements( GL_TRIANGLES, GLsizei( _indexLength ), GL_UNSIGNED_SHORT, 0 );
}
/* Render the leaf with a display list. */
inline
void VertexBufferLeaf::renderDisplayList( VertexBufferState& state ) const
{
char* key = (char*)( this );
if( state.useColors( ))
++key;
GLuint displayList = state.getDisplayList( key );
if( displayList == state.INVALID )
setupRendering( state, &displayList );
glCallList( displayList );
}
/* Render the leaf with immediate mode primitives or vertex arrays. */
inline
void VertexBufferLeaf::renderImmediate( VertexBufferState& state ) const
{
glBegin( GL_TRIANGLES );
for( Index offset = 0; offset < _indexLength; ++offset )
{
const Index i =_vertexStart + _globalData.indices[_indexStart + offset];
if( state.useColors() )
glColor3ubv( &_globalData.colors[i][0] );
glNormal3fv( &_globalData.normals[i][0] );
glVertex3fv( &_globalData.vertices[i][0] );
}
glEnd();
}
/* Set up the common OpenGL state for rendering of all nodes. */
void VertexBufferRoot::_beginRendering( VertexBufferState& state ) const
{
state.resetRegion();
switch( state.getRenderMode() )
{
#ifdef GL_ARB_vertex_buffer_object
case RENDER_MODE_BUFFER_OBJECT:
glPushClientAttrib( GL_CLIENT_VERTEX_ARRAY_BIT );
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_NORMAL_ARRAY );
if( state.useColors() )
glEnableClientState( GL_COLOR_ARRAY );
#endif
case RENDER_MODE_DISPLAY_LIST:
case RENDER_MODE_IMMEDIATE:
default:
;
}
}
/* Render the leaf with immediate mode primitives or vertex arrays. */
inline
void VertexBufferLeaf::renderImmediate( VertexBufferState& state ) const
{
glBegin( GL_TRIANGLES );
for( Index offset = 0; offset < _indexLength; ++offset )
{
const Index i =_vertexStart + _globalData.indices[_indexStart + offset];
if( state.useColors() )
glColor4ubv( &_globalData.colors[i][0] );
glNormal3fv( &_globalData.normals[i][0] );
glVertex3fv( &_globalData.vertices[i][0] );
}
glEnd();
// if( state.useColors() )
// glColorPointer( 4, GL_UNSIGNED_BYTE, 0,
// &_globalData.colors[_vertexStart] );
// glNormalPointer( GL_FLOAT, 0, &_globalData.normals[_vertexStart] );
// glVertexPointer( 3, GL_FLOAT, 0, &_globalData.vertices[_vertexStart] );
// glDrawElements( GL_TRIANGLES, _indexLength, GL_UNSIGNED_SHORT,
// &_globalData.indices[_indexStart] );
}