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::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::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; }