void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location)
{
const float* m1 = matrix1.AsFloat();
const float* m2 = matrix2.AsFloat();
bool equivalent = true;
for (int i=0;i<9;++i)
{
if( ! (fabsf(m1[i] - m2[i])< GetRangedEpsilon(m1[i], m2[i])) )
{
equivalent = false;
}
}
if( !equivalent )
{
fprintf(stderr, "%s, checking\n"
"(%f, %f, %f) (%f, %f, %f)\n"
"(%f, %f, %f) == (%f, %f, %f)\n"
"(%f, %f, %f) (%f, %f, %f)\n",
location,
m1[0], m1[1], m1[2], m2[0], m2[1], m2[2],
m1[3], m1[4], m1[5], m2[3], m2[4], m2[5],
m1[6], m1[7], m1[8], m2[6], m2[7], m2[8]);
tet_result(TET_FAIL);
}
else
{
tet_result(TET_PASS);
}
}
void MeshRenderer::DoRender( BufferIndex bufferIndex, const Matrix& modelViewMatrix, const Matrix& modelMatrix, const Matrix& viewMatrix, const Matrix& projectionMatrix, const Vector4& color )
{
MeshInfo& meshInfo = mMeshInfo[bufferIndex];
Mesh* mesh = meshInfo.mesh;
RenderMaterial& material = *(meshInfo.material);
BoneTransforms& boneTransforms = meshInfo.boneTransforms;
if( ! meshInfo.boneTransforms.transforms.empty() )
{
ApplyViewToBoneTransforms( meshInfo.boneTransforms, viewMatrix );
}
const int stride = sizeof(Dali::MeshData::Vertex);
Dali::MeshData::Vertex *v = 0;
mesh->UploadVertexData( *mContext, bufferIndex );
mesh->BindBuffers( *mContext );
GeometryType geometryType = GEOMETRY_TYPE_TEXTURED_MESH;
if( ! material.HasTexture() )
{
geometryType = GEOMETRY_TYPE_MESH;
}
GLsizei numBoneMatrices = (GLsizei)mesh->GetMeshData(Mesh::RENDER_THREAD).GetBoneCount();
// Select program type
ShaderSubTypes shaderType = SHADER_DEFAULT;
if( mShader->AreSubtypesRequired( geometryType ) )
{
if( numBoneMatrices )
{
if( mesh->GetMeshData(Mesh::RENDER_THREAD).HasColor() )
{
shaderType = SHADER_RIGGED_AND_VERTEX_COLOR;
}
else if( mAffectedByLighting )
{
shaderType = SHADER_RIGGED_AND_LIT;
}
else
{
shaderType = SHADER_RIGGED_AND_EVENLY_LIT;
}
}
else
{
if( mesh->GetMeshData(Mesh::RENDER_THREAD).HasColor() )
{
shaderType = SHADER_VERTEX_COLOR;
}
else if( ! mAffectedByLighting )
{
shaderType = SHADER_EVENLY_LIT;
} // else default
}
}
if( geometryType != mGeometryType || shaderType != mShaderType )
{
mGeometryType = geometryType;
mShaderType = shaderType;
ResetCustomUniforms();
}
Program& program = mShader->Apply( *mContext, bufferIndex, geometryType, modelMatrix, viewMatrix, modelViewMatrix, projectionMatrix, color, mShaderType );
GLint location = Program::UNIFORM_UNKNOWN;
GLint positionLoc = program.GetAttribLocation(Program::ATTRIB_POSITION);
GLint texCoordLoc = Program::ATTRIB_UNKNOWN;
GLint boneWeightsLoc = Program::ATTRIB_UNKNOWN;
GLint boneIndicesLoc = Program::ATTRIB_UNKNOWN;
GLint normalLoc = Program::ATTRIB_UNKNOWN;
GLint colorLoc = Program::ATTRIB_UNKNOWN;
mContext->VertexAttribPointer( positionLoc, 3, GL_FLOAT, GL_FALSE, stride, &v->x );
mContext->EnableVertexAttributeArray( positionLoc );
if( numBoneMatrices > 0 )
{
location = mCustomUniform[ shaderType ][ 0 ].GetUniformLocation( program, "uBoneCount" );
if( Program::UNIFORM_UNKNOWN != location )
{
program.SetUniform1i(location, numBoneMatrices);
}
location = mCustomUniform[ shaderType ][ 1 ].GetUniformLocation( program, "uBoneMatrices" );
if( Program::UNIFORM_UNKNOWN != location )
{
program.SetUniformMatrix4fv(location, numBoneMatrices, boneTransforms.viewTransforms[0].AsFloat());
}
if( mesh->GetMeshData(Mesh::RENDER_THREAD).HasNormals() )
{
location = mCustomUniform[ shaderType ][ 2 ].GetUniformLocation( program, "uBoneMatricesIT" );
if( Program::UNIFORM_UNKNOWN != location )
{
program.SetUniformMatrix3fv( location, numBoneMatrices, boneTransforms.inverseTransforms[0].AsFloat() );
}
}
boneWeightsLoc = program.GetAttribLocation( Program::ATTRIB_BONE_WEIGHTS );
if( Program::ATTRIB_UNKNOWN != boneWeightsLoc )
{
mContext->VertexAttribPointer( boneWeightsLoc, 4, GL_FLOAT, GL_FALSE, stride, &v->boneWeights[0] );
mContext->EnableVertexAttributeArray( boneWeightsLoc );
}
boneIndicesLoc = program.GetAttribLocation( Program::ATTRIB_BONE_INDICES );
if( Program::ATTRIB_UNKNOWN != boneIndicesLoc )
{
mContext->VertexAttribPointer( boneIndicesLoc, 4, GL_UNSIGNED_BYTE, GL_FALSE, stride, &v->boneIndices[0] );
mContext->EnableVertexAttributeArray( boneIndicesLoc );
}
}
if( material.HasTexture() )
{
material.BindTextures( program );
}
// Always use UV's - may be being used for another purpose by a custom shader!
texCoordLoc = program.GetAttribLocation(Program::ATTRIB_TEXCOORD);
if( Program::ATTRIB_UNKNOWN != texCoordLoc )
{
mContext->VertexAttribPointer( texCoordLoc, 2, GL_FLOAT, GL_FALSE, stride, &v->u );
mContext->EnableVertexAttributeArray( texCoordLoc );
}
if( mesh->GetMeshData(Mesh::RENDER_THREAD).HasNormals() )
{
normalLoc = program.GetAttribLocation(Program::ATTRIB_NORMAL);
if( Program::ATTRIB_UNKNOWN != normalLoc )
{
mContext->VertexAttribPointer( normalLoc, 3, GL_FLOAT, GL_FALSE, stride, &v->nX );
mContext->EnableVertexAttributeArray( normalLoc );
}
}
else if( mesh->GetMeshData(Mesh::RENDER_THREAD).HasColor() ) // Normals & color are mutually exclusive
{
colorLoc = program.GetAttribLocation(Program::ATTRIB_COLOR);
if( Program::ATTRIB_UNKNOWN != colorLoc)
{
mContext->VertexAttribPointer( colorLoc, 3, GL_FLOAT, GL_FALSE, stride, &v->vertexR );
mContext->EnableVertexAttributeArray( colorLoc );
}
}
material.SetUniforms( mRenderMaterialUniforms, program, shaderType );
if( mAffectedByLighting )
{
// Set light parameters
location = mCustomUniform[ shaderType ][ 3 ].GetUniformLocation( program, "uNumberOfLights" );
if( Program::UNIFORM_UNKNOWN != location )
{
program.SetUniform1i( location, mLightController->GetNumberOfLights() );
}
// Model View IT matrix required for vertex normal lighting calculation
location = mCustomUniform[ shaderType ][ 4 ].GetUniformLocation( program, "uModelViewIT" );
if( Program::UNIFORM_UNKNOWN != location )
{
Matrix3 modelViewInverseTranspose = modelViewMatrix;
modelViewInverseTranspose.Invert();
modelViewInverseTranspose.Transpose();
program.SetUniformMatrix3fv( location, 1, modelViewInverseTranspose.AsFloat() );
}
// only one active light supported at the moment (due to performance)
//if( numberOfLights > 0 )
{
Vector2 tempVector2;
Vector3 tempVector3;
Node& lightNode = mLightController->GetLight( 0 );
LightAttachment& light = dynamic_cast< LightAttachment& >( lightNode.GetAttachment() );
location = mCustomUniform[ shaderType ][ 5 ].GetUniformLocation( program, "uLight0.mType" );
if( Program::UNIFORM_UNKNOWN != location )
{
program.SetUniform1i( location, (GLint)light.GetType() );
}
location = mCustomUniform[ shaderType ][ 6 ].GetUniformLocation( program, "uLight0.mFallOff" );
if( Program::UNIFORM_UNKNOWN != location )
{
tempVector2 = light.GetFallOff();
program.SetUniform2f( location, tempVector2.x, tempVector2.y );
}
location = mCustomUniform[ shaderType ][ 7 ].GetUniformLocation( program, "uLight0.mSpotAngle" );
if( Program::UNIFORM_UNKNOWN != location )
{
tempVector2 = light.GetSpotAngle();
program.SetUniform2f( location, tempVector2.x, tempVector2.y );
}
location = mCustomUniform[ shaderType ][ 8 ].GetUniformLocation( program, "uLight0.mLightPos" );
if( Program::UNIFORM_UNKNOWN != location )
{
// light position in eyespace
Vector3 tempVector3( viewMatrix * Vector4(lightNode.GetWorldPosition(bufferIndex)) );
program.SetUniform3f( location, tempVector3.x, tempVector3.y, tempVector3.z );
}
location = mCustomUniform[ shaderType ][ 9 ].GetUniformLocation( program, "uLight0.mLightDir" );
if( Program::UNIFORM_UNKNOWN != location )
{
tempVector3 = light.GetDirection();
tempVector3.Normalize();
program.SetUniform3f( location, tempVector3.x, tempVector3.y, tempVector3.z );
}
location = mCustomUniform[ shaderType ][ 10 ].GetUniformLocation( program, "uLight0.mAmbient" );
if( Program::UNIFORM_UNKNOWN != location )
{
tempVector3 = light.GetAmbientColor();
program.SetUniform3f( location, tempVector3.r, tempVector3.g, tempVector3.b );
}
location = mCustomUniform[ shaderType ][ 11 ].GetUniformLocation( program, "uLight0.mDiffuse" );
if( Program::UNIFORM_UNKNOWN != location )
{
tempVector3 = light.GetDiffuseColor();
program.SetUniform3f( location, tempVector3.r, tempVector3.g, tempVector3.b );
}
location = mCustomUniform[ shaderType ][ 12 ].GetUniformLocation( program, "uLight0.mSpecular" );
if( Program::UNIFORM_UNKNOWN != location )
{
tempVector3 = light.GetSpecularColor();
program.SetUniform3f( location, tempVector3.r, tempVector3.g, tempVector3.b );
}
}
}
Dali::MeshData::VertexGeometryType vertexGeometry = mesh->GetMeshData(Mesh::RENDER_THREAD).GetVertexGeometryType();
switch( vertexGeometry )
{
case Dali::MeshData::TRIANGLES:
mContext->DrawElements(GL_TRIANGLES, mesh->GetFaceIndexCount(Mesh::RENDER_THREAD), GL_UNSIGNED_SHORT, 0);
DRAW_ELEMENT_RECORD(mesh->GetFaceIndexCount());
break;
case Dali::MeshData::LINES:
mContext->DrawElements(GL_LINES, mesh->GetFaceIndexCount(Mesh::RENDER_THREAD), GL_UNSIGNED_SHORT, 0);
DRAW_ELEMENT_RECORD(mesh->GetFaceIndexCount());
break;
case Dali::MeshData::POINTS:
mContext->DrawArrays(GL_POINTS, 0, mesh->GetFaceIndexCount(Mesh::RENDER_THREAD) );
DRAW_ARRAY_RECORD(mesh->GetFaceIndexCount());
}
if( normalLoc != Program::ATTRIB_UNKNOWN )
{
mContext->DisableVertexAttributeArray( normalLoc );
}
if( colorLoc != Program::ATTRIB_UNKNOWN )
{
mContext->DisableVertexAttributeArray( colorLoc );
}
mContext->DisableVertexAttributeArray( positionLoc );
if( texCoordLoc != Program::ATTRIB_UNKNOWN )
{
mContext->DisableVertexAttributeArray( texCoordLoc );
}
if( boneWeightsLoc != Program::ATTRIB_UNKNOWN )
{
mContext->DisableVertexAttributeArray( boneWeightsLoc );
}
if( boneIndicesLoc != Program::ATTRIB_UNKNOWN )
{
mContext->DisableVertexAttributeArray( boneIndicesLoc );
}
return;
}