bool parseIntegerVec(std::string str, IntegerVec& intVector)
{
StringVector strVector = explodeString(str, ";");
IntegerVec tmpIntVector;
for(StringVector::iterator it = strVector.begin(); it != strVector.end(); ++it)
{
tmpIntVector = vectorAtoi(explodeString((*it), "-"));
if(!tmpIntVector[0] && it->substr(0, 1) != "0")
continue;
intVector.push_back(tmpIntVector[0]);
if(tmpIntVector.size() > 1)
{
while(tmpIntVector[0] < tmpIntVector[1])
intVector.push_back(++tmpIntVector[0]);
}
}
return true;
}
//---------------------------------------------------------------------
void GLSLProgramManagerCommon::parseIndividualConstant(const String& src, GpuNamedConstants& defs,
String::size_type currPos,
const String& filename, GpuSharedParametersPtr sharedParams)
{
GpuConstantDefinition def;
String paramName = "";
String::size_type endPos = src.find(";", currPos);
String line = src.substr(currPos, endPos - currPos);
// Remove spaces before opening square braces, otherwise
// the following split() can split the line at inappropriate
// places (e.g. "vec3 something [3]" won't work).
for (String::size_type sqp = line.find (" ["); sqp != String::npos;
sqp = line.find (" ["))
line.erase (sqp, 1);
// Split into tokens
StringVector parts = StringUtil::split(line, ", \t\r\n");
for (StringVector::iterator i = parts.begin(); i != parts.end(); ++i)
{
// Is this a type?
StringToEnumMap::iterator typei = mTypeEnumMap.find(*i);
if (typei != mTypeEnumMap.end())
{
completeDefInfo(typei->second, def);
}
else
{
// if this is not a type, and not empty, it should be a name
StringUtil::trim(*i);
if (i->empty()) continue;
// Skip over precision keywords
if(StringUtil::match((*i), "lowp") ||
StringUtil::match((*i), "mediump") ||
StringUtil::match((*i), "highp"))
continue;
String::size_type arrayStart = i->find("[", 0);
if (arrayStart != String::npos)
{
// potential name (if butted up to array)
String name = i->substr(0, arrayStart);
StringUtil::trim(name);
if (!name.empty())
paramName = name;
String::size_type arrayEnd = i->find("]", arrayStart);
String arrayDimTerm = i->substr(arrayStart + 1, arrayEnd - arrayStart - 1);
StringUtil::trim(arrayDimTerm);
// the array term might be a simple number or it might be
// an expression (e.g. 24*3) or refer to a constant expression
// we'd have to evaluate the expression which could get nasty
// TODO
def.arraySize = StringConverter::parseInt(arrayDimTerm);
}
else
{
paramName = *i;
def.arraySize = 1;
}
// Name should be after the type, so complete def and add
// We do this now so that comma-separated params will do
// this part once for each name mentioned
if (def.constType == GCT_UNKNOWN)
{
LogManager::getSingleton().logMessage("Problem parsing the following GLSL Uniform: '"
+ line + "' in file " + filename);
// next uniform
break;
}
// Special handling for shared parameters
if(sharedParams.isNull())
{
// Complete def and add
// increment physical buffer location
def.logicalIndex = 0; // not valid in GLSL
if (def.isFloat())
{
def.physicalIndex = defs.floatBufferSize;
defs.floatBufferSize += def.arraySize * def.elementSize;
}
else
{
def.physicalIndex = defs.intBufferSize;
defs.intBufferSize += def.arraySize * def.elementSize;
}
defs.map.insert(GpuConstantDefinitionMap::value_type(paramName, def));
// Generate array accessors
defs.generateConstantDefinitionArrayEntries(paramName, def);
}
else
{
try
{
const GpuConstantDefinition &sharedDef = sharedParams->getConstantDefinition(paramName);
(void)sharedDef; // Silence warning
}
catch (Exception& e)
{
// This constant doesn't exist so we'll create a new one
sharedParams->addConstantDefinition(paramName, def.constType);
}
}
}
}
}
//---------------------------------------------------------------------
void GLSLESProgramManagerCommon::extractConstantDefs(const String& src,
GpuNamedConstants& defs, const String& filename)
{
// Parse the output string and collect all uniforms
// NOTE this relies on the source already having been preprocessed
// which is done in GLSLESProgram::loadFromSource
String line;
String::size_type currPos = src.find("uniform");
while (currPos != String::npos)
{
GpuConstantDefinition def;
String paramName;
// Now check for using the word 'uniform' in a larger string & ignore
bool inLargerString = false;
if (currPos != 0)
{
char prev = src.at(currPos - 1);
if (prev != ' ' && prev != '\t' && prev != '\r' && prev != '\n'
&& prev != ';')
inLargerString = true;
}
if (!inLargerString && currPos + 7 < src.size())
{
char next = src.at(currPos + 7);
if (next != ' ' && next != '\t' && next != '\r' && next != '\n')
inLargerString = true;
}
// skip 'uniform'
currPos += 7;
if (!inLargerString)
{
// find terminating semicolon
String::size_type endPos = src.find(";", currPos);
if (endPos == String::npos)
{
// problem, missing semicolon, abort
break;
}
line = src.substr(currPos, endPos - currPos);
// Remove spaces before opening square braces, otherwise
// the following split() can split the line at inappropriate
// places (e.g. "vec3 something [3]" won't work).
for (String::size_type sqp = line.find (" ["); sqp != String::npos;
sqp = line.find (" ["))
line.erase (sqp, 1);
// Split into tokens
StringVector parts = StringUtil::split(line, ", \t\r\n");
for (StringVector::iterator i = parts.begin(); i != parts.end(); ++i)
{
// Is this a type?
StringToEnumMap::iterator typei = mTypeEnumMap.find(*i);
if (typei != mTypeEnumMap.end())
{
completeDefInfo(typei->second, def);
}
else
{
// if this is not a type, and not empty, it should be a name
StringUtil::trim(*i);
if (i->empty()) continue;
// Skip over precision keywords
if(StringUtil::match((*i), "lowp") ||
StringUtil::match((*i), "mediump") ||
StringUtil::match((*i), "highp"))
continue;
String::size_type arrayStart = i->find("[", 0);
if (arrayStart != String::npos)
{
// potential name (if butted up to array)
String name = i->substr(0, arrayStart);
StringUtil::trim(name);
if (!name.empty())
paramName = name;
String::size_type arrayEnd = i->find("]", arrayStart);
String arrayDimTerm = i->substr(arrayStart + 1, arrayEnd - arrayStart - 1);
StringUtil::trim(arrayDimTerm);
// the array term might be a simple number or it might be
// an expression (e.g. 24*3) or refer to a constant expression
// we'd have to evaluate the expression which could get nasty
// TODO
def.arraySize = StringConverter::parseUnsignedLong(arrayDimTerm);
}
else
{
paramName = *i;
def.arraySize = 1;
}
// Name should be after the type, so complete def and add
// We do this now so that comma-separated params will do
// this part once for each name mentioned
if (def.constType == GCT_UNKNOWN)
{
LogManager::getSingleton().logMessage(
"Problem parsing the following GLSL Uniform: '"
+ line + "' in file " + filename);
// next uniform
break;
}
// Complete def and add
// increment physical buffer location
def.logicalIndex = 0; // not valid in GLSL
if (def.isFloat())
{
def.physicalIndex = defs.floatBufferSize;
defs.floatBufferSize += def.arraySize * def.elementSize;
}
else
{
def.physicalIndex = defs.intBufferSize;
defs.intBufferSize += def.arraySize * def.elementSize;
}
defs.map.insert(GpuConstantDefinitionMap::value_type(paramName, def));
// Generate array accessors
defs.generateConstantDefinitionArrayEntries(paramName, def);
}
}
} // not commented or a larger symbol
// Find next one
currPos = src.find("uniform", currPos);
}
}