//-----------------------------------------------------------------------
void GLSLESProgramPipeline::updateUniformBlocks(GpuProgramParametersSharedPtr params,
uint16 mask, GpuProgramType fromProgType)
{
#if OGRE_NO_GLES3_SUPPORT == 0
// Iterate through the list of uniform buffers and update them as needed
GLUniformBufferIterator currentBuffer = mGLUniformBufferReferences.begin();
GLUniformBufferIterator endBuffer = mGLUniformBufferReferences.end();
const GpuProgramParameters::GpuSharedParamUsageList& sharedParams = params->getSharedParameters();
GpuProgramParameters::GpuSharedParamUsageList::const_iterator it, end = sharedParams.end();
for (it = sharedParams.begin(); it != end; ++it)
{
for (;currentBuffer != endBuffer; ++currentBuffer)
{
GLES2HardwareUniformBuffer* hwGlBuffer = static_cast<GLES2HardwareUniformBuffer*>(currentBuffer->get());
GpuSharedParametersPtr paramsPtr = it->getSharedParams();
// Block name is stored in mSharedParams->mName of GpuSharedParamUsageList items
GLint UniformTransform;
OGRE_CHECK_GL_ERROR(UniformTransform = glGetUniformBlockIndex(mGLProgramHandle, it->getName().c_str()));
OGRE_CHECK_GL_ERROR(glUniformBlockBinding(mGLProgramHandle, UniformTransform, hwGlBuffer->getGLBufferBinding()));
hwGlBuffer->writeData(0, hwGlBuffer->getSizeInBytes(), ¶msPtr->getFloatConstantList().front());
}
}
#endif
}
bool frameRenderingQueued(const FrameEvent& evt)
{
// update uniform buffer value
Real seconds = Root::getSingleton().getTimer()->getMilliseconds()/1000.0f;
GpuSharedParametersPtr param = GpuProgramManager::getSingleton().getSharedParameters("DataBlock");
param->setNamedConstant("roll", seconds);
return SdkSample::frameRenderingQueued(evt);
}
void ShadowManager::setManagedMaterialSplitPoints(Ogre::PSSMShadowCameraSetup::SplitPointList splitPointList)
{
Ogre::Vector4 splitPoints;
for (int i = 0; i < 3; ++i)
splitPoints[i] = splitPointList[i];
GpuSharedParametersPtr p = GpuProgramManager::getSingleton().getSharedParameters("pssm_params");
p->setNamedConstant("pssmSplitPoints", splitPoints);
}
void GLSLSeparableProgram::updateUniformBlocks(GpuProgramParametersSharedPtr params,
uint16 mask, GpuProgramType fromProgType)
{
//TODO Support uniform block arrays - need to figure how to do this via material.
// Iterate through the list of uniform blocks and update them as needed.
SharedParamsBufferMap::const_iterator currentPair = mSharedParamsBufferMap.begin();
SharedParamsBufferMap::const_iterator endPair = mSharedParamsBufferMap.end();
// const GpuProgramParameters::GpuSharedParamUsageList& sharedParams = params->getSharedParameters();
// const GpuProgramParameters::GpuSharedParamUsageList& sharedParams = params->getSharedParameters();
// GpuProgramParameters::GpuSharedParamUsageList::const_iterator it, end = sharedParams.end();
for (; currentPair != endPair; ++currentPair)
{
GpuSharedParametersPtr paramsPtr = currentPair->first;
//FIXME Possible buffer does not exist if no associated uniform block.
GL3PlusHardwareUniformBuffer* hwGlBuffer = static_cast<GL3PlusHardwareUniformBuffer*>(currentPair->second.get());
if (!paramsPtr->isDirty()) continue;
//FIXME does not check if current progrtype, or if shared param is active
GpuConstantDefinitionIterator parami = paramsPtr->getConstantDefinitionIterator();
for (int i = 0; parami.current() != parami.end(); parami.moveNext(), i++)
{
//String name = parami->;
//GpuConstantDefinition * param = GpuConstantConstantDefinition(name);
//const String* name = ¶mi.current()->first;
const GpuConstantDefinition* param = ¶mi.current()->second;
BaseConstantType baseType = GpuConstantDefinition::getBaseType(param->constType);
void* dataPtr;
size_t index = param->physicalIndex;
//TODO Maybe move to GpuSharedParams? Otherwise create bool buffer.
switch (baseType)
{
case BCT_FLOAT:
dataPtr = paramsPtr->getFloatPointer(index);
break;
case BCT_INT:
dataPtr = paramsPtr->getIntPointer(index);
break;
case BCT_DOUBLE:
dataPtr = paramsPtr->getDoublePointer(index);
break;
case BCT_UINT:
case BCT_BOOL:
dataPtr = paramsPtr->getUnsignedIntPointer(index);
break;
case BCT_SAMPLER:
case BCT_SUBROUTINE:
//TODO implement me!
default:
//TODO error handling
continue;
}
// in bytes
size_t length = param->arraySize * param->elementSize * 4;
size_t offset = hwGlBuffer->mBufferParamsLayout.offsets[i];
hwGlBuffer->writeData(offset, length, dataPtr);
}
paramsPtr->_markClean();
}
}
//---------------------------------------------------------------------
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);
}
}
}
}
}
