bool FunctionInvocation::FunctionInvocationLessThan::operator ()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const
{
// Check the function names first
if (lhs.getFunctionName() < rhs.getFunctionName())
return true;
// Next check the return type
if (lhs.getReturnType() < rhs.getReturnType())
return true;
// Check the number of operands
if (lhs.mOperands.size() < rhs.mOperands.size())
return true;
// Now that we've gotten past the two quick tests, iterate over operands
// Check the semantic and type. The operands must be in the same order as well.
OperandVector::const_iterator itLHSOps = lhs.mOperands.begin();
OperandVector::const_iterator itRHSOps = rhs.mOperands.begin();
for ( ; itLHSOps != lhs.mOperands.end(), itRHSOps != rhs.mOperands.end(); ++itLHSOps, ++itRHSOps)
{
if (itLHSOps->getSemantic() < itRHSOps->getSemantic())
return true;
if (itLHSOps->getParameter()->getType() < itRHSOps->getParameter()->getType())
return true;
}
return false;
}
bool FunctionInvocation::FunctionInvocationLessThan::operator ()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const
{
// Check the function names first
// Adding an exception to std::string sorting. I feel that functions beginning with an underscore should be placed before
// functions beginning with an alphanumeric character. By default strings are sorted based on the ASCII value of each character.
// Underscores have an ASCII value in between capital and lowercase characters. This is why the exception is needed.
if (lhs.getFunctionName() < rhs.getFunctionName())
{
if(rhs.getFunctionName().at(0) == '_')
return false;
else
return true;
}
if (lhs.getFunctionName() > rhs.getFunctionName())
{
if(lhs.getFunctionName().at(0) == '_')
return true;
else
return false;
}
// Next check the return type
if (lhs.getReturnType() < rhs.getReturnType())
return true;
if (lhs.getReturnType() > rhs.getReturnType())
return false;
// Check the number of operands
if (lhs.mOperands.size() < rhs.mOperands.size())
return true;
if (lhs.mOperands.size() > rhs.mOperands.size())
return false;
// Now that we've gotten past the two quick tests, iterate over operands
// Check the semantic and type. The operands must be in the same order as well.
OperandVector::const_iterator itLHSOps = lhs.mOperands.begin();
OperandVector::const_iterator itRHSOps = rhs.mOperands.begin();
for ( ; itLHSOps != lhs.mOperands.end(), itRHSOps != rhs.mOperands.end(); ++itLHSOps, ++itRHSOps)
{
if (itLHSOps->getSemantic() < itRHSOps->getSemantic())
return true;
if (itLHSOps->getSemantic() > itRHSOps->getSemantic())
return false;
if (itLHSOps->getParameter()->getType() < itRHSOps->getParameter()->getType())
return true;
if (itLHSOps->getParameter()->getType() > itRHSOps->getParameter()->getType())
return false;
}
return true;
}
bool FunctionInvocation::FunctionInvocationCompare::operator ()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const
{
// Check the function names first
if (lhs.getFunctionName() != rhs.getFunctionName())
return false;
// Next check the return type
if (lhs.getReturnType() != rhs.getReturnType())
return false;
// Check the number of operands
if (lhs.mOperands.size() != rhs.mOperands.size())
return false;
// Now that we've gotten past the two quick tests, iterate over operands
// Check the semantic and type. The operands must be in the same order as well.
OperandVector::const_iterator itLHSOps = lhs.mOperands.begin();
OperandVector::const_iterator itRHSOps = rhs.mOperands.begin();
for ( ; ((itLHSOps != lhs.mOperands.end()) && (itRHSOps != rhs.mOperands.end())); ++itLHSOps, ++itRHSOps)
{
if (itLHSOps->getSemantic() != itRHSOps->getSemantic())
return false;
GpuConstantType leftType = itLHSOps->getParameter()->getType();
GpuConstantType rightType = itRHSOps->getParameter()->getType();
if (Ogre::Root::getSingletonPtr()->getRenderSystem()->getName().find("OpenGL ES 2") != String::npos)
{
if (leftType == GCT_SAMPLER1D)
leftType = GCT_SAMPLER2D;
if (rightType == GCT_SAMPLER1D)
rightType = GCT_SAMPLER2D;
}
// If a swizzle mask is being applied to the parameter, generate the GpuConstantType to
// perform the parameter type comparison the way that the compiler will see it.
if ((itLHSOps->getFloatCount(itLHSOps->getMask()) > 0) ||
(itRHSOps->getFloatCount(itRHSOps->getMask()) > 0))
{
if (itLHSOps->getFloatCount(itLHSOps->getMask()) > 0)
{
leftType = (GpuConstantType)((itLHSOps->getParameter()->getType() - itLHSOps->getParameter()->getType()) +
itLHSOps->getFloatCount(itLHSOps->getMask()));
}
if (itRHSOps->getFloatCount(itRHSOps->getMask()) > 0)
{
rightType = (GpuConstantType)((itRHSOps->getParameter()->getType() - itRHSOps->getParameter()->getType()) +
itRHSOps->getFloatCount(itRHSOps->getMask()));
}
}
if (leftType != rightType)
return false;
}
// Passed all tests, they are the same
return true;
}
bool FunctionInvocation::FunctionInvocationLessThan::operator ()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const
{
// Check the function names first
// Adding an exception to std::string sorting. I feel that functions beginning with an underscore should be placed before
// functions beginning with an alphanumeric character. By default strings are sorted based on the ASCII value of each character.
// Underscores have an ASCII value in between capital and lowercase characters. This is why the exception is needed.
if (lhs.getFunctionName() < rhs.getFunctionName())
{
if(rhs.getFunctionName().at(0) == '_')
return false;
else
return true;
}
if (lhs.getFunctionName() > rhs.getFunctionName())
{
if(lhs.getFunctionName().at(0) == '_')
return true;
else
return false;
}
// Next check the return type
if (lhs.getReturnType() < rhs.getReturnType())
return true;
if (lhs.getReturnType() > rhs.getReturnType())
return false;
// Check the number of operands
if (lhs.mOperands.size() < rhs.mOperands.size())
return true;
if (lhs.mOperands.size() > rhs.mOperands.size())
return false;
// Now that we've gotten past the two quick tests, iterate over operands
// Check the semantic and type. The operands must be in the same order as well.
OperandVector::const_iterator itLHSOps = lhs.mOperands.begin();
OperandVector::const_iterator itRHSOps = rhs.mOperands.begin();
for ( ; ((itLHSOps != lhs.mOperands.end()) && (itRHSOps != rhs.mOperands.end())); ++itLHSOps, ++itRHSOps)
{
if (itLHSOps->getSemantic() < itRHSOps->getSemantic())
return true;
if (itLHSOps->getSemantic() > itRHSOps->getSemantic())
return false;
GpuConstantType leftType = itLHSOps->getParameter()->getType();
GpuConstantType rightType = itRHSOps->getParameter()->getType();
if (Ogre::Root::getSingletonPtr()->getRenderSystem()->getName().find("OpenGL ES 2") != String::npos)
{
if (leftType == GCT_SAMPLER1D)
leftType = GCT_SAMPLER2D;
if (rightType == GCT_SAMPLER1D)
rightType = GCT_SAMPLER2D;
}
// If a swizzle mask is being applied to the parameter, generate the GpuConstantType to
// perform the parameter type comparison the way that the compiler will see it.
if ((itLHSOps->getFloatCount(itLHSOps->getMask()) > 0) ||
(itRHSOps->getFloatCount(itRHSOps->getMask()) > 0))
{
if (itLHSOps->getFloatCount(itLHSOps->getMask()) > 0)
{
leftType = (GpuConstantType)((itLHSOps->getParameter()->getType() - itLHSOps->getParameter()->getType()) +
itLHSOps->getFloatCount(itLHSOps->getMask()));
}
if (itRHSOps->getFloatCount(itRHSOps->getMask()) > 0)
{
rightType = (GpuConstantType)((itRHSOps->getParameter()->getType() - itRHSOps->getParameter()->getType()) +
itRHSOps->getFloatCount(itRHSOps->getMask()));
}
}
if (leftType < rightType)
return true;
if (leftType > rightType)
return false;
}
return false;
}