//-----------------------------------------------------------------------------------
void PbsMaterial::createTexturUnits(Pass* pass)
{
GpuProgramParametersSharedPtr fragmentParams = pass->getFragmentProgramParameters();
fragmentParams->setIgnoreMissingParams(true);
// Create the texture unit states
for (int i = 0; i < ST_COUNT; i++)
{
SamplerContainer& s = _samplers[i];
if (s.status == SS_ACTIVE || s.status == SS_ADDED || s.status == SS_UPDATED)
{
s.textureUnitState = pass->createTextureUnitState();
s.textureUnitState->setName("in_map_" + s.name);
s.status = SS_UPDATED;
}
else
{
s.status = SS_NOT_ACTIVE;
}
}
// set the sampler name for the texture unit state
int size = pass->getNumTextureUnitStates();
for (int i = 0; i < size; i++)
{
TextureUnitState* tus = pass->getTextureUnitState(i);
fragmentParams->setNamedConstant(tus->getName(), i);
}
_hasSamplerChanged = true;
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorC::SM2Profile::ShaderHelper::updateVpParams(
const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const GpuProgramParametersSharedPtr& params)
{
params->setIgnoreMissingParams(true);
uint maxLayers = prof->getMaxLayers(terrain);
uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount()));
uint numUVMul = numLayers / 4;
if (numLayers % 4)
++numUVMul;
for (uint i = 0; i < numUVMul; ++i)
{
Vector4 uvMul(
terrain->getLayerUVMultiplier(i * 4),
terrain->getLayerUVMultiplier(i * 4 + 1),
terrain->getLayerUVMultiplier(i * 4 + 2),
terrain->getLayerUVMultiplier(i * 4 + 3)
);
params->setNamedConstant("uvMul_" + StringConverter::toString(i), uvMul);
}
if (terrain->_getUseVertexCompression() && tt != RENDER_COMPOSITE_MAP)
{
Real baseUVScale = 1.0f / (terrain->getSize() - 1);
params->setNamedConstant("baseUVScale", baseUVScale);
}
}
void CarModel::ChangeClr()
{
int i = iColor;
float c_h = pSet->gui.car_hue[i], c_s = pSet->gui.car_sat[i],
c_v = pSet->gui.car_val[i], gloss = pSet->gui.car_gloss[i], refl = pSet->gui.car_refl[i];
color.setHSB(1-c_h, c_s, c_v); //set, mini pos clr
MaterialPtr mtr = MaterialManager::getSingleton().getByName(sMtr[Mtr_CarBody]);
if (!mtr.isNull())
{ Material::TechniqueIterator techIt = mtr->getTechniqueIterator();
while (techIt.hasMoreElements())
{ Technique* tech = techIt.getNext();
Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{ Pass* pass = passIt.getNext();
if (pass->hasFragmentProgram())
{
GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
params->setNamedConstant("carColour", color);
params->setNamedConstant("glossiness", 1 - gloss);
params->setNamedConstant("reflectiveness", refl);
} } } }
if (pNickTxt)
pNickTxt->setTextColour(MyGUI::Colour(color.r,color.g,color.b));
// opp list text and mini pos colors - auto in hud update
}
void DepthOfFieldListener::notifyMaterialRender(uint32 pass_id, MaterialPtr &mat)
{
if(pass_id == 2)
{
float blurScale =.5f;
Vector4 pixelSize(1.0f / mViewportWidth, 1.0f / mViewportHeight,1.0f / (mViewportWidth * blurScale), 1.0f / (mViewportHeight * blurScale) );
Pass *pass = mat->getBestTechnique()->getPass(0);
GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
if (params->_findNamedConstantDefinition("pixelSize"))
params->setNamedConstant("pixelSize", pixelSize);
// this is the camera you're using
#ifndef SR_EDITOR
Camera *cam = mApp->mSplitMgr->mCameras.front();
#else
Camera *cam = mApp->mCamera;
#endif
if (params->_findNamedConstantDefinition("dofparams"))
{
Vector4 dofParams(0.0f,mApp->pSet->dof_focus,mApp->pSet->dof_far,1.0);
params->setNamedConstant("dofparams", dofParams);
}
}
}
void setUpBaseParameters(const GpuProgramParametersSharedPtr& params)
{
assert(params.isNull()==false);
struct AutoParamPair { String name; GpuProgramParameters::AutoConstantType type; };
//A list of auto params that might be present in the shaders generated
static const AutoParamPair AUTO_PARAMS[] = {
{ "vpWidth", GpuProgramParameters::ACT_VIEWPORT_WIDTH },
{ "vpHeight", GpuProgramParameters::ACT_VIEWPORT_HEIGHT },
{ "worldView", GpuProgramParameters::ACT_WORLDVIEW_MATRIX },
{ "invProj", GpuProgramParameters::ACT_INVERSE_PROJECTION_MATRIX },
{ "invView", GpuProgramParameters::ACT_INVERSE_VIEW_MATRIX },
{ "flip", GpuProgramParameters::ACT_RENDER_TARGET_FLIPPING },
{ "lightDiffuseColor", GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR },
{ "lightSpecularColor", GpuProgramParameters::ACT_LIGHT_SPECULAR_COLOUR },
{ "lightFalloff", GpuProgramParameters::ACT_LIGHT_ATTENUATION },
{ "lightPos", GpuProgramParameters::ACT_LIGHT_POSITION_VIEW_SPACE },
{ "lightDir", GpuProgramParameters::ACT_LIGHT_DIRECTION_VIEW_SPACE },
{ "spotParams", GpuProgramParameters::ACT_SPOTLIGHT_PARAMS },
{ "farClipDistance", GpuProgramParameters::ACT_FAR_CLIP_DISTANCE },
{ "shadowViewProjMat", GpuProgramParameters::ACT_TEXTURE_VIEWPROJ_MATRIX }
};
int numParams = sizeof(AUTO_PARAMS) / sizeof(AutoParamPair);
for (int i=0; i<numParams; i++)
{
if (params->_findNamedConstantDefinition(AUTO_PARAMS[i].name))
{
params->setNamedAutoConstant(AUTO_PARAMS[i].name, AUTO_PARAMS[i].type);
}
}
}
void GrassLoader::frameUpdate()
{
unsigned long currentTime = windTimer.getMilliseconds();
unsigned long ellapsedTime = currentTime - lastTime;
lastTime = currentTime;
float ellapsed = ellapsedTime / 1000.0f;
//Update the vertex shader parameters
std::list<GrassLayer*>::iterator it;
for (it = layerList.begin(); it != layerList.end(); ++it){
GrassLayer *layer = *it;
layer->_updateShaders();
GpuProgramParametersSharedPtr params = layer->material->getTechnique(0)->getPass(0)->getVertexProgramParameters();
if (layer->animate){
//Increment animation frame
layer->waveCount += ellapsed * (layer->animSpeed * Math::PI);
if (layer->waveCount > Math::PI*2) layer->waveCount -= Math::PI*2;
//Set vertex shader parameters
params->setNamedConstant("time", layer->waveCount);
params->setNamedConstant("frequency", layer->animFreq);
Vector3 direction = windDir * layer->animMag;
params->setNamedConstant("direction", Vector4(direction.x, direction.y, direction.z, 0));
}
}
}
//---------------------------------------------------------------------
void HighLevelGpuProgram::populateParameterNames(GpuProgramParametersSharedPtr params)
{
getConstantDefinitions();
params->_setNamedConstants(mConstantDefs);
// also set logical / physical maps for programs which use this
params->_setLogicalIndexes(mFloatLogicalToPhysical, mDoubleLogicalToPhysical, mIntLogicalToPhysical);
}
//-----------------------------------------------------------------------
void GLSLESProgramPipeline::updatePassIterationUniforms(GpuProgramParametersSharedPtr params)
{
if (params->hasPassIterationNumber())
{
size_t index = params->getPassIterationNumberIndex();
GLUniformReferenceIterator currentUniform = mGLUniformReferences.begin();
GLUniformReferenceIterator endUniform = mGLUniformReferences.end();
// Need to find the uniform that matches the multi pass entry
for (;currentUniform != endUniform; ++currentUniform)
{
// Get the index in the parameter real list
if (index == currentUniform->mConstantDef->physicalIndex)
{
#if OGRE_PLATFORM != OGRE_PLATFORM_NACL
GLuint progID = 0;
if (getVertexProgram() && currentUniform->mSourceProgType == GPT_VERTEX_PROGRAM)
{
progID = getVertexProgram()->getGLProgramHandle();
OGRE_CHECK_GL_ERROR(glProgramUniform1fvEXT(progID, currentUniform->mLocation, 1, params->getFloatPointer(index)));
}
if (mFragmentProgram && currentUniform->mSourceProgType == GPT_FRAGMENT_PROGRAM)
{
progID = mFragmentProgram->getGLProgramHandle();
OGRE_CHECK_GL_ERROR(glProgramUniform1fvEXT(progID, currentUniform->mLocation, 1, params->getFloatPointer(index)));
}
#endif
// There will only be one multipass entry
return;
}
}
}
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorC::SM2Profile::ShaderHelper::defaultFpParams(
const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const HighLevelGpuProgramPtr& prog)
{
GpuProgramParametersSharedPtr params = prog->getDefaultParameters();
params->setIgnoreMissingParams(true);
params->setNamedAutoConstant("fogColour", GpuProgramParameters::ACT_FOG_COLOUR);
params->setNamedAutoConstant("cFarDistance", Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
params->setNamedAutoConstant("viewMatrix", GpuProgramParameters::ACT_WORLDVIEW_MATRIX); // tout sauf Z : VIEW_MATRIX
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorA::SM2Profile::ShaderHelper::updateFpParams(
const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const GpuProgramParametersSharedPtr& params)
{
params->setIgnoreMissingParams(true);
// TODO - parameterise this?
Vector4 scaleBiasSpecular(0.03, -0.04, 32, 1);
params->setNamedConstant("scaleBiasSpecular", scaleBiasSpecular);
}
//-----------------------------------------------------------------------------
void ProgramProcessor::bindAutoParameters(Program* pCpuProgram, GpuProgramPtr pGpuProgram)
{
GpuProgramParametersSharedPtr pGpuParams = pGpuProgram->getDefaultParameters();
const UniformParameterList& progParams = pCpuProgram->getParameters();
UniformParameterConstIterator itParams;
for (itParams=progParams.begin(); itParams != progParams.end(); ++itParams)
{
const UniformParameterPtr pCurParam = *itParams;
const GpuConstantDefinition* gpuConstDef = pGpuParams->_findNamedConstantDefinition(pCurParam->getName());
if (gpuConstDef != NULL)
{
// Handle auto parameters.
if (pCurParam->isAutoConstantParameter())
{
if (pCurParam->isAutoConstantRealParameter())
{
pGpuParams->setNamedAutoConstantReal(pCurParam->getName(),
pCurParam->getAutoConstantType(),
pCurParam->getAutoConstantRealData());
}
else if (pCurParam->isAutoConstantIntParameter())
{
pGpuParams->setNamedAutoConstant(pCurParam->getName(),
pCurParam->getAutoConstantType(),
pCurParam->getAutoConstantIntData());
}
}
// Case this is not auto constant - we have to update its variability ourself.
else
{
gpuConstDef->variability |= pCurParam->getVariability();
// Update variability in the float map.
if (gpuConstDef->isSampler() == false)
{
GpuLogicalBufferStructPtr floatLogical = pGpuParams->getFloatLogicalBufferStruct();
if (floatLogical.get())
{
for (GpuLogicalIndexUseMap::const_iterator i = floatLogical->map.begin(); i != floatLogical->map.end(); ++i)
{
if (i->second.physicalIndex == gpuConstDef->physicalIndex)
{
i->second.variability |= gpuConstDef->variability;
break;
}
}
}
}
}
}
}
}
//-----------------------------------------------------------------------
GpuProgramParametersSharedPtr D3D10HLSLProgram::createParameters(void)
{
// Call superclass
GpuProgramParametersSharedPtr params = HighLevelGpuProgram::createParameters();
// D3D HLSL uses column-major matrices
params->setTransposeMatrices(true);
return params;
}
void ATI_FS_GLGpuProgram::bindProgramPassIterationParameters(GpuProgramParametersSharedPtr params)
{
if (params->hasPassIterationNumber())
{
size_t physicalIndex = params->getPassIterationNumberIndex();
size_t logicalIndex = params->getFloatLogicalIndexForPhysicalIndex(physicalIndex);
const float* pFloat = params->getFloatPointer(physicalIndex);
glSetFragmentShaderConstantATI( GL_CON_0_ATI + (GLuint)logicalIndex, pFloat);
}
}
void HDRListener::notifyMaterialRender(uint32 pass_id, MaterialPtr &mat)
{
if (pass_id == 600 || pass_id == 800)
{
Pass *pass = mat->getBestTechnique()->getPass(0);
GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
if (params->_findNamedConstantDefinition("toneMapSettings"))
{
Vector4 toneMapSettings(1-mApp->pSet->hdrParam1, mApp->pSet->hdrParam2, mApp->pSet->hdrParam3, 1.0);
params->setNamedConstant("toneMapSettings", toneMapSettings);
}
if (params->_findNamedConstantDefinition("bloomSettings"))
{
Vector4 bloomSettings(mApp->pSet->hdrBloomorig*2, mApp->pSet->hdrBloomint, 1.0, 1.0);
params->setNamedConstant("bloomSettings", bloomSettings);
}
if (params->_findNamedConstantDefinition("vignettingSettings"))
{
Vector4 vignettingSettings(mApp->pSet->vignRadius, mApp->pSet->vignDarkness, 1.0, 1.0);
params->setNamedConstant("vignettingSettings", vignettingSettings);
}
}
else if(pass_id == 989)
{
Pass *pass = mat->getBestTechnique()->getPass(0);
GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
if (params->_findNamedConstantDefinition("AdaptationScale"))
{
params->setNamedConstant("AdaptationScale", mApp->pSet->hdrAdaptationScale);
}
}
}
void MaterialGenerator::vertexProgramParams(HighLevelGpuProgramPtr program)
{
GpuProgramParametersSharedPtr params = program->getDefaultParameters();
//#ifndef _DEBUG
params->setIgnoreMissingParams(true);
//#endif
if (vpNeedWMat())
params->setNamedAutoConstant("wMat", GpuProgramParameters::ACT_WORLD_MATRIX);
params->setNamedAutoConstant("wvpMat", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
if (vpNeedWvMat())
params->setNamedAutoConstant("wvMat", GpuProgramParameters::ACT_WORLDVIEW_MATRIX);
if (fpNeedEyeVector() || mShader->wind == 1)
params->setNamedAutoConstant("eyePosition", GpuProgramParameters::ACT_CAMERA_POSITION);
params->setNamedAutoConstant("fogParams", GpuProgramParameters::ACT_FOG_PARAMS);
if (mShader->wind == 2)
params->setNamedConstant("enableWind", Real(1.0));
if(MRTSupported())
{
params->setNamedAutoConstant("far", GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
}
individualVertexProgramParams(params);
}
virtual GpuProgramPtr generateFragmentShader(Perm permutation)
{
/// Create shader
if (mMasterSource.empty())
{
DataStreamPtr ptrMasterSource;
if(GpuProgramManager::getSingleton().isSyntaxSupported("glsles"))
ptrMasterSource = ResourceGroupManager::getSingleton().openResource("DeferredShading/post/LightMaterial_ps.glsles",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
else
ptrMasterSource = ResourceGroupManager::getSingleton().openResource("DeferredShading/post/LightMaterial_ps.glsl",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
assert(ptrMasterSource.isNull()==false);
mMasterSource = ptrMasterSource->getAsString();
}
assert(mMasterSource.empty()==false);
// Create name
String name = mBaseName+StringConverter::toString(permutation)+"_ps";
// Create shader object
HighLevelGpuProgramPtr ptrProgram;
if(GpuProgramManager::getSingleton().isSyntaxSupported("glsles"))
{
ptrProgram = HighLevelGpuProgramManager::getSingleton().createProgram(name, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"glsles", GPT_FRAGMENT_PROGRAM);
ptrProgram->setParameter("profiles", "glsles");
}
else
{
ptrProgram = HighLevelGpuProgramManager::getSingleton().createProgram(name, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"glsl", GPT_FRAGMENT_PROGRAM);
ptrProgram->setParameter("profiles", "glsl150");
}
ptrProgram->setSource(mMasterSource);
// set up the preprocessor defines
// Important to do this before any call to get parameters, i.e. before the program gets loaded
ptrProgram->setParameter("preprocessor_defines", getPPDefines(permutation));
setUpBaseParameters(ptrProgram->getDefaultParameters());
// Bind samplers
GpuProgramParametersSharedPtr params = ptrProgram->getDefaultParameters();
int numSamplers = 0;
params->setNamedConstant("Tex0", (int)numSamplers++);
params->setNamedConstant("Tex1", (int)numSamplers++);
if(permutation & LightMaterialGenerator::MI_SHADOW_CASTER)
params->setNamedConstant("ShadowTex", (int)numSamplers++);
return GpuProgramPtr(ptrProgram);
}
void GLSLSeparableProgram::updatePassIterationUniforms(GpuProgramParametersSharedPtr params)
{
if (params->hasPassIterationNumber())
{
size_t index = params->getPassIterationNumberIndex();
GLUniformReferenceIterator currentUniform = mGLUniformReferences.begin();
GLUniformReferenceIterator endUniform = mGLUniformReferences.end();
// Need to find the uniform that matches the multi pass entry
for (;currentUniform != endUniform; ++currentUniform)
{
// Get the index in the parameter real list
if (index == currentUniform->mConstantDef->physicalIndex)
{
GLuint progID = 0;
if (mVertexShader && currentUniform->mSourceProgType == GPT_VERTEX_PROGRAM)
{
progID = mVertexShader->getGLProgramHandle();
}
if (mFragmentShader && currentUniform->mSourceProgType == GPT_FRAGMENT_PROGRAM)
{
progID = mFragmentShader->getGLProgramHandle();
}
if (mGeometryShader && currentUniform->mSourceProgType == GPT_GEOMETRY_PROGRAM)
{
progID = mGeometryShader->getGLProgramHandle();
}
if (mDomainShader && currentUniform->mSourceProgType == GPT_DOMAIN_PROGRAM)
{
progID = mDomainShader->getGLProgramHandle();
}
if (mHullShader && currentUniform->mSourceProgType == GPT_HULL_PROGRAM)
{
progID = mHullShader->getGLProgramHandle();
}
if (mComputeShader && currentUniform->mSourceProgType == GPT_COMPUTE_PROGRAM)
{
progID = mComputeShader->getGLProgramHandle();
}
OGRE_CHECK_GL_ERROR(glProgramUniform1fv(progID, currentUniform->mLocation, 1, params->getFloatPointer(index)));
// There will only be one multipass entry
return;
}
}
}
}
void FixedFuncPrograms::_updateParameter( GpuProgramParametersSharedPtr & programParameters, const String paramName, const void * value, const size_t sizeInBytes )
{
const GpuConstantDefinition& def = programParameters->getConstantDefinition(paramName);
if (def.isFloat())
{
memcpy((programParameters->getFloatPointer(def.physicalIndex)), value, sizeInBytes);
}
else
{
memcpy((programParameters->getIntPointer(def.physicalIndex)), value, sizeInBytes);
}
}
void WaterMaterialGenerator::vertexProgramParams(Ogre::HighLevelGpuProgramPtr program)
{
GpuProgramParametersSharedPtr params = program->getDefaultParameters();
params->setIgnoreMissingParams(true);
params->setNamedAutoConstant("wMat", GpuProgramParameters::ACT_WORLD_MATRIX);
params->setNamedAutoConstant("wvpMat", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
params->setNamedAutoConstant("fogParams", GpuProgramParameters::ACT_FOG_PARAMS);
individualVertexProgramParams(params);
}
void GLArbGpuProgram::bindProgramPassIterationParameters(GpuProgramParametersSharedPtr params)
{
if (params->hasPassIterationNumber())
{
GLenum type = getGLShaderType(mType);
size_t physicalIndex = params->getPassIterationNumberIndex();
size_t logicalIndex = params->getFloatLogicalIndexForPhysicalIndex(physicalIndex);
const float* pFloat = params->getFloatPointer(physicalIndex);
glProgramLocalParameter4fvARB(type, (GLuint)logicalIndex, pFloat);
}
}
bool frameStarted(const FrameEvent& evt)
{
//Set shader parameters
GpuProgramParametersSharedPtr geomParams = particleSystem->
getRenderToVertexBuffer()->getRenderToBufferMaterial()->
getTechnique(0)->getPass(0)->getGeometryProgramParameters();
geomParams->setNamedConstant("elapsedTime", evt.timeSinceLastFrame);
demoTime += evt.timeSinceLastFrame;
geomParams->setNamedConstant("globalTime", demoTime);
geomParams->setNamedConstant("frameGravity", GRAVITY_VECTOR * evt.timeSinceLastFrame);
return true;
}
//-----------------------------------------------------------------------
void UniformParameter::bind(GpuProgramParametersSharedPtr paramsPtr)
{
if (paramsPtr.get() != NULL)
{
const GpuConstantDefinition* def = paramsPtr->_findNamedConstantDefinition(mName);
if (def != NULL)
{
mParamsPtr = paramsPtr.get();
mPhysicalIndex = def->physicalIndex;
}
}
}
void MaterialFactory::setWind(bool wind)
{
for (std::vector<std::string>::iterator it=windMtrs.begin();
it != windMtrs.end(); ++it)
{
MaterialPtr mat = MaterialManager::getSingleton().getByName( (*it) );
if (mat->getTechnique(0)->getPass(0)->hasVertexProgram())
{
GpuProgramParametersSharedPtr vparams = mat->getTechnique(0)->getPass(0)->getVertexProgramParameters();
vparams->setIgnoreMissingParams(true);
vparams->setNamedConstant("enableWind", wind ? Real(1.0) : Real(0.0));
}
}
}
void GLArbGpuProgram::bindProgramPassIterationParameters(GpuProgramParametersSharedPtr params)
{
if (params->hasPassIterationNumber())
{
GLenum type = (mType == GPT_VERTEX_PROGRAM) ?
GL_VERTEX_PROGRAM_ARB : GL_FRAGMENT_PROGRAM_ARB;
size_t physicalIndex = params->getPassIterationNumberIndex();
size_t logicalIndex = params->getFloatLogicalIndexForPhysicalIndex(physicalIndex);
const float* pFloat = params->getFloatPointer(physicalIndex);
glProgramLocalParameter4fvARB(type, (GLuint)logicalIndex, pFloat);
}
}
void MaterialGenerator::individualVertexProgramParams(GpuProgramParametersSharedPtr params)
{
//#ifndef _DEBUG
params->setIgnoreMissingParams(true);
//#endif
if (needShadows())
for (int i=0; i<mParent->getNumShadowTex(); ++i)
{
params->setNamedAutoConstant("texWorldViewProjMatrix"+toStr(i), GpuProgramParameters::ACT_TEXTURE_WORLDVIEWPROJ_MATRIX, i);
}
params->setNamedConstant("enableFog", mDef->mProps->fog ? Real(1.0) : Real(0.0));
}
void MotionBlurListener::notifyMaterialRender(uint32 pass_id, MaterialPtr &mat)
{
if (pass_id != 120) return;
//LogO("notifyMaterialRender");
try
{ mat->load();
GpuProgramParametersSharedPtr fparams =
mat->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
fparams->setNamedConstant("blur", pApp->motionBlurIntensity);
}
catch (Exception& e)
{
LogO("Error setting motion blur");
}
}
//-----------------------------------------------------------------------
GpuProgramParametersSharedPtr UnifiedHighLevelGpuProgram::createParameters(void)
{
if (isSupported())
{
return _getDelegate()->createParameters();
}
else
{
// return a default set
GpuProgramParametersSharedPtr params = GpuProgramManager::getSingleton().createParameters();
// avoid any errors on parameter names that don't exist
params->setIgnoreMissingParams(true);
return params;
}
}
void FilmGrainListener::notifyMaterialRender(uint32 pass_id, MaterialPtr &mat)
{
if(pass_id == 1)
{
float noiseIntensity = 0.1f;
float exposure = 1-mApp->pSet->hdrParam3;
Vector4 grainparams(1.0f / mViewportWidth, 1.0f / mViewportHeight, noiseIntensity, exposure);
Pass *pass = mat->getBestTechnique()->getPass(0);
GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
if (params->_findNamedConstantDefinition("grainparams"))
params->setNamedConstant("grainparams", grainparams);
}
}
//-----------------------------------------------------------------------
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
}
//---------------------------------------------------------------------
void GpuProgramUsage::recreateParameters()
{
// Keep a reference to old ones to copy
GpuProgramParametersSharedPtr savedParams = mParameters;
// Create new params
mParameters = mProgram->createParameters();
// Copy old (matching) values across
// Don't use copyConstantsFrom since program may be different
if (!savedParams.isNull())
mParameters->copyMatchingNamedConstantsFrom(*savedParams.get());
mRecreateParams = false;
}
