void RsVertexBufferWinGL::SetStream()
{
// http://www.opengl.org/wiki/Vertex_Buffer_Object
for( BtU32 i=0; i<7; i++ )
{
glDisableVertexAttribArray( i );
}
// Bind the vertex buffer
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer); // for vertex coordinates
BtU32 offset = 0;
BtU32 stride = m_pFileData->m_nStride;
BtU32 vertexType = m_pFileData->m_type;
BtU32 index = 0;
if ( vertexType & VT_Position )
{
glEnableVertexAttribArray( 0 );
glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride, GL_BUFFER_OFFSET( offset ) );
offset += sizeof( MtVector3 );
++index;
}
if ( vertexType & VT_Normal )
{
glEnableVertexAttribArray( 1 );
glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, stride, GL_BUFFER_OFFSET( offset ) );
offset += sizeof( MtVector3 );
++index;
}
if (vertexType & VT_Colour)
{
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride, GL_BUFFER_OFFSET(offset));
offset += sizeof(BtU32);
++index;
}
if (vertexType & VT_UV0)
{
glEnableVertexAttribArray(5);
glVertexAttribPointer(5, 2, GL_FLOAT, GL_FALSE, stride, GL_BUFFER_OFFSET(offset));
offset += sizeof(MtVector2);
++index;
}
if (vertexType & VT_UV1)
{
offset += sizeof(MtVector2);
++index;
}
if ( vertexType & VT_Tangent )
{
offset += sizeof( MtVector3 );
++index;
}
if ( vertexType & VT_Binormal )
{
offset += sizeof( MtVector3 );
++index;
}
if ( vertexType & VT_Skin )
{
glEnableVertexAttribArray( 6 );
glVertexAttribPointer( 6, 4, GL_FLOAT, GL_FALSE, stride, GL_BUFFER_OFFSET( offset ) );
GLenum error = glGetError();
(void)error;
offset += sizeof( BtFloat ) * 4;
++index;
glEnableVertexAttribArray( 7 );
glVertexAttribPointer( 7, 4, GL_UNSIGNED_BYTE, GL_FALSE, stride, GL_BUFFER_OFFSET( offset ) );
error = glGetError();
(void)error;
offset += sizeof( BtU8 ) * 4;
++index;
}
if ( vertexType & VT_BlendShape )
{
offset += sizeof( MtVector3 );
offset += sizeof( MtVector3 );
offset += sizeof( MtVector3 );
}
}
void RsTextureWinGL::Render( RsTextureRenderable *pRenderable )
{
// Cache the current render target
RsRenderTarget *pRenderTarget = pRenderable->m_pRenderTarget;
// Set the shader
RsShaderWinGL *pShader = (RsShaderWinGL*)pRenderable->m_pShader;
RsPrimitiveWinGL* pPrimitives = (RsPrimitiveWinGL*) pRenderable->m_primitive;
if( pPrimitives->m_primitiveType == 1 )
{
int a=0;
a++;
}
// Cache the camera
const RsCamera &camera = pRenderTarget->GetCamera();
const MtMatrix4& m4Projection = camera.GetViewProjection();
const MtMatrix4& m4World = MtMatrix4::m_identity;
MtMatrix4 m4WorldViewScreen = m4World * m4Projection;
pShader->SetCamera( camera );
pShader->SetTechnique( "RsShaderT2" );
pShader->SetMatrix( RsHandles_WorldViewScreen, m4WorldViewScreen );
for( BtU32 i=0; i<7; i++ )
{
glDisableVertexAttribArray( i );
}
// Cache the texture
RsTextureWinGL* pTexture = (RsTextureWinGL*)pRenderable->m_pTexture;
// Set the texture
pTexture->SetTexture();
// Set vertex arrays
BtU32 stride = sizeof(RsVertex3);
// Cache the vertex buffer
BtU32 vertexBuffer = RsImplWinGL::GetVertexBuffer();
// Get the size
BtU32 dataSize = pPrimitives->m_numVertex * stride;
// bind VBO in order to use
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer );
GLenum error;
error = glGetError();
(void)error;
// upload data to VBO
glBufferData(GL_ARRAY_BUFFER, dataSize, pRenderable->m_pVertex, GL_DYNAMIC_DRAW);
error = glGetError();
(void)error;
/*
struct RsVertex3
{
MtVector3 m_v3Position;
MtVector3 m_v3Normal;
BtU32 m_colour;
MtVector2 m_v2UV;
MtVector2 m_v2UV2;
};
*/
BtU32 offset = 0;
glEnableVertexAttribArray( 0 );
glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride, GL_BUFFER_OFFSET( offset ) );
offset += sizeof( MtVector3 );
glEnableVertexAttribArray( 1 );
glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, stride, GL_BUFFER_OFFSET( offset ) );
offset += sizeof( MtVector3 );
glEnableVertexAttribArray( 4 );
glVertexAttribPointer( 4, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride, GL_BUFFER_OFFSET( offset ) );
offset += sizeof( BtU32 );
glEnableVertexAttribArray( 5);
glVertexAttribPointer( 5, 2, GL_FLOAT, GL_FALSE, stride, GL_BUFFER_OFFSET( offset ) );
offset += sizeof( MtVector2 );
// Draw the primitives
pShader->Draw( pRenderable->m_primitive );
}
void Model::drawModel()
{
// assume these client states are enabled: GL_VERTEX_ARRAY, GL_NORMAL_ARRAY, GL_TEXTURE_COORD_ARRAY
if (animated) {
if (animGeometry) {
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbuf);
glVertexPointer(3, GL_FLOAT, 0, 0);
glNormalPointer(GL_FLOAT, 0, GL_BUFFER_OFFSET(vbufsize));
} else {
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbuf);
glVertexPointer(3, GL_FLOAT, 0, 0);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, nbuf);
glNormalPointer(GL_FLOAT, 0, 0);
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, tbuf);
glTexCoordPointer(2, GL_FLOAT, 0, 0);
//glTexCoordPointer(2, GL_FLOAT, sizeof(ModelVertex), &origVertices[0].texcoords);
}
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glAlphaFunc (GL_GREATER, 0.3f);
for (size_t i=0; i<passes.size(); i++) {
ModelRenderPass &p = passes[i];
if (p.init(this)) {
// we don't want to render completely transparent parts
// render
if (animated) {
//glDrawElements(GL_TRIANGLES, p.indexCount, GL_UNSIGNED_SHORT, indices + p.indexStart);
// a GDC OpenGL Performace Tuning paper recommended glDrawRangeElements over glDrawElements
// I can't notice a difference but I guess it can't hurt
if ( supportVBO && supportDrawRangeElements) {
glDrawRangeElements(GL_TRIANGLES, p.vertexStart, p.vertexEnd, p.indexCount, GL_UNSIGNED_SHORT, indices + p.indexStart);
//} else if (!supportVBO) {
// glDrawElements(GL_TRIANGLES, p.indexCount, GL_UNSIGNED_SHORT, indices + p.indexStart);
} else {
glBegin(GL_TRIANGLES);
for (size_t k=0, b=p.indexStart; k<p.indexCount; k++,b++) {
uint16 a = indices[b];
glNormal3fv(normals[a]);
glTexCoord2fv(origVertices[a].texcoords);
glVertex3fv(vertices[a]);
}
glEnd();
}
} else {
glBegin(GL_TRIANGLES);
for (size_t k = 0, b=p.indexStart; k<p.indexCount; k++,b++) {
uint16 a = indices[b];
glNormal3fv(normals[a]);
glTexCoord2fv(origVertices[a].texcoords);
glVertex3fv(vertices[a]);
}
glEnd();
}
p.deinit();
}
}
// done with all render ops
glAlphaFunc (GL_GREATER, 0.0f);
glDisable (GL_ALPHA_TEST);
GLfloat czero[4] = {0,0,0,1};
glMaterialfv(GL_FRONT, GL_EMISSION, czero);
glColor4f(1,1,1,1);
glDepthMask(GL_TRUE);
}
