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 CameraBlurListener::notifyMaterialRender(uint32 pass_id, MaterialPtr &mat)
{
if (pass_id == 999)
{
if (mApp->pGame->pause == false)
{
//acquire the texture flipping attribute in the first frame
if(compositorinstance)
{
mRequiresTextureFlipping = compositorinstance->getRenderTarget("previousscene")->requiresTextureFlipping();
compositorinstance=NULL;
}
// this is the camera you're using
#ifndef SR_EDITOR
Camera *cam = mApp->mSplitMgr->mCameras.front();
#else
Camera *cam = mApp->mCamera;
#endif
// get the pass
Pass *pass = mat->getBestTechnique()->getPass(0);
GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
const RenderTarget::FrameStats& stats = mApp->getWindow()->getStatistics();
float m_lastFPS =stats.lastFPS;
Matrix4 projectionMatrix = cam->getProjectionMatrix();
if (mRequiresTextureFlipping)
{
// Because we're not using setProjectionMatrix, this needs to be done here
// Invert transformed y
projectionMatrix[1][0] = -projectionMatrix[1][0];
projectionMatrix[1][1] = -projectionMatrix[1][1];
projectionMatrix[1][2] = -projectionMatrix[1][2];
projectionMatrix[1][3] = -projectionMatrix[1][3];
}
Matrix4 iVP = (projectionMatrix * cam->getViewMatrix()).inverse();
if (params->_findNamedConstantDefinition("EPF_ViewProjectionInverseMatrix"))
params->setNamedConstant("EPF_ViewProjectionInverseMatrix", iVP);
if (params->_findNamedConstantDefinition("EPF_PreviousViewProjectionMatrix"))
params->setNamedConstant("EPF_PreviousViewProjectionMatrix", prevviewproj);
if (params->_findNamedConstantDefinition("intensity"))
params->setNamedConstant("intensity", mApp->pSet->blur_int);
float interpolationFactor = m_lastFPS * 0.03f ; //* m_timeScale m_timeScale is a multiplier to control motion blur interactively
Quaternion current_orientation = cam->getDerivedOrientation();
Vector3 current_position = cam->getDerivedPosition();
Quaternion estimatedOrientation = Quaternion::Slerp(interpolationFactor, current_orientation, (m_pPreviousOrientation));
Vector3 estimatedPosition = (1-interpolationFactor) * current_position + interpolationFactor * (m_pPreviousPosition);
Matrix4 prev_viewMatrix = Math::makeViewMatrix(estimatedPosition, estimatedOrientation);//.inverse().transpose();
// compute final matrix
prevviewproj = projectionMatrix * prev_viewMatrix;
// update position and orientation for next update time
m_pPreviousOrientation = current_orientation;
m_pPreviousPosition = current_position;
}
}
}
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);
}
}
}
// HUD utils
//---------------------------------------------------------------------------------------------------------------
void CHud::UpdMiniTer()
{
MaterialPtr mm = MaterialManager::getSingleton().getByName("circle_minimap");
Pass* pass = mm->getTechnique(0)->getPass(0);
if (!pass) return;
try
{ GpuProgramParametersSharedPtr par = pass->getFragmentProgramParameters();
bool ter = app->scn->sc->ter;
if (par->_findNamedConstantDefinition("showTerrain",false))
par->setNamedConstant("showTerrain", pSet->mini_terrain && ter ? 1.f : 0.f);
if (par->_findNamedConstantDefinition("showBorder",false))
par->setNamedConstant("showBorder", pSet->mini_border && ter ? 1.f : 0.f);
if (par->_findNamedConstantDefinition("square",false))
par->setNamedConstant("square", pSet->mini_zoomed && ter ? 0.f : 1.f);
}
catch(...){ }
}
void DepthOfFieldEffect::notifyMaterialSetup(uint32 passId, MaterialPtr& material)
{
switch (passId)
{
case BlurPass:
{
//float pixelSize[2] = {
// 1.0f / (gEnv->ogreViewPort->getActualWidth() / BLUR_DIVISOR),
// 1.0f / (gEnv->ogreViewPort->getActualHeight() / BLUR_DIVISOR)};
// Adjust fragment program parameters
Ogre::Vector3 ps = Ogre::Vector3(1.0f / (mWidth / BLUR_DIVISOR),1.0f / (mHeight / BLUR_DIVISOR), 1.0f);
float pixelSize[3] = { ps.x, ps.y, ps.z };
GpuProgramParametersSharedPtr fragParams = material->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
if ((!fragParams.isNull())&&(fragParams->_findNamedConstantDefinition("pixelSize")))
fragParams->setNamedConstant("pixelSize", pixelSize, 1, 3);
break;
}
case OutputPass:
{
float pixelSizeScene[3] = {
1.0f / mWidth,
1.0f / mHeight,
0};
float pixelSizeBlur[3] = {
1.0f / (mWidth / BLUR_DIVISOR),
1.0f / (mHeight / BLUR_DIVISOR),
0};
// Adjust fragment program parameters
GpuProgramParametersSharedPtr fragParams =
material->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
if ((!fragParams.isNull())&&(fragParams->_findNamedConstantDefinition("pixelSizeScene")))
fragParams->setNamedConstant("pixelSizeScene", pixelSizeScene,1,3);
if ((!fragParams.isNull())&&(fragParams->_findNamedConstantDefinition("pixelSizeBlur")))
fragParams->setNamedConstant("pixelSizeBlur", pixelSizeBlur,1,3);
break;
}
}
}
//-----------------------------------------------------------------------------
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;
}
}
}
}
}
}
}
}
//-----------------------------------------------------------------------
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 SSAOListener::notifyMaterialRender(uint32 pass_id, MaterialPtr &mat)
{
if (pass_id != 42) // not SSAO, return
return;
// this is the camera you're using
#ifndef SR_EDITOR
Camera *cam = mApp->mSplitMgr->mCameras.front();
#else
Camera *cam = mApp->mCamera;
#endif
// calculate the far-top-right corner in view-space
Vector3 farCorner = cam->getViewMatrix(true) * cam->getWorldSpaceCorners()[4];
// get the pass
Pass *pass = mat->getBestTechnique()->getPass(0);
// get the vertex shader parameters
GpuProgramParametersSharedPtr params = pass->getVertexProgramParameters();
// set the camera's far-top-right corner
if (params->_findNamedConstantDefinition("farCorner"))
params->setNamedConstant("farCorner", farCorner);
// get the fragment shader parameters
params = pass->getFragmentProgramParameters();
// set the projection matrix we need
static const Matrix4 CLIP_SPACE_TO_IMAGE_SPACE(
0.5, 0, 0, 0.5,
0, -0.5, 0, 0.5,
0, 0, 1, 0,
0, 0, 0, 1);
if (params->_findNamedConstantDefinition("ptMat"))
params->setNamedConstant("ptMat", CLIP_SPACE_TO_IMAGE_SPACE * cam->getProjectionMatrixWithRSDepth());
if (params->_findNamedConstantDefinition("far"))
params->setNamedConstant("far", cam->getFarClipDistance());
}
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 DepthOfFieldEffect::preViewportUpdate(const Ogre::RenderTargetViewportEvent& evt)
{
float dofParams[4] = {mNearDepth, mFocalDepth, mFarDepth, mFarBlurCutoff};
// Adjust fragment program parameters for depth pass
GpuProgramParametersSharedPtr fragParams =
mDepthTechnique->getPass(0)->getFragmentProgramParameters();
if ((!fragParams.isNull())&&(fragParams->_findNamedConstantDefinition("dofParams")))
fragParams->setNamedConstant("dofParams", dofParams,1,4);
evt.source->setVisibilityMask(~DEPTHMAP_DISABLED);
// Add 'this' as a RenderableListener to replace the technique for all renderables
RenderQueue* queue = evt.source->getCamera()->getSceneManager()->getRenderQueue();
queue->setRenderableListener(this);
}
//-----------------------------------------------------------------------------
void GLSLProgramProcessor::bindTextureSamplers(Program* pCpuProgram, GpuProgramPtr pGpuProgram)
{
GpuProgramParametersSharedPtr pGpuParams = pGpuProgram->getDefaultParameters();
const UniformParameterList& progParams = pCpuProgram->getParameters();
UniformParameterConstIterator itParams;
// Bind the samplers.
for (itParams=progParams.begin(); itParams != progParams.end(); ++itParams)
{
const UniformParameterPtr pCurParam = *itParams;
const GpuConstantDefinition* gpuConstDef = pGpuParams->_findNamedConstantDefinition(pCurParam->getName());
if (pCurParam->isSampler())
{
pGpuParams->setNamedConstant(pCurParam->getName(), pCurParam->getIndex());
}
}
}
//-----------------------------------------------------------------------------
///
void StaticBillboardSet::updateAll(const Vector3 &cameraDirection)
{
// s_nSelfInstances will only be greater than 0 if one or more StaticBillboardSet's are using BB_METHOD_ACCELERATED
if (s_nSelfInstances == 0)
return;
//Set shader parameter so material will face camera
Vector3 forward = cameraDirection;
Vector3 vRight = forward.crossProduct(Vector3::UNIT_Y);
Vector3 vUp = forward.crossProduct(vRight);
vRight.normalise();
vUp.normalise();
//Even if camera is upside down, the billboards should remain upright
if (vUp.y < 0)
vUp *= -1;
// Precompute preRotatedQuad for both cases (BBO_CENTER, BBO_BOTTOM_CENTER)
Vector3 vPoint0 = (-vRight + vUp);
Vector3 vPoint1 = ( vRight + vUp);
Vector3 vPoint2 = (-vRight - vUp);
Vector3 vPoint3 = ( vRight - vUp);
float preRotatedQuad_BBO_CENTER[16] = // single prerotated quad oriented towards the camera
{
(float)vPoint0.x, (float)vPoint0.y, (float)vPoint0.z, 0.0f,
(float)vPoint1.x, (float)vPoint1.y, (float)vPoint1.z, 0.0f,
(float)vPoint2.x, (float)vPoint2.y, (float)vPoint2.z, 0.0f,
(float)vPoint3.x, (float)vPoint3.y, (float)vPoint3.z, 0.0f
};
vPoint0 = (-vRight + vUp + vUp);
vPoint1 = ( vRight + vUp + vUp);
vPoint2 = (-vRight);
vPoint3 = ( vRight);
float preRotatedQuad_BBO_BOTTOM_CENTER[16] =
{
(float)vPoint0.x, (float)vPoint0.y, (float)vPoint0.z, 0.0f,
(float)vPoint1.x, (float)vPoint1.y, (float)vPoint1.z, 0.0f,
(float)vPoint2.x, (float)vPoint2.y, (float)vPoint2.z, 0.0f,
(float)vPoint3.x, (float)vPoint3.y, (float)vPoint3.z, 0.0f
};
// Shaders uniform variables
static const Ogre::String uScroll = "uScroll", vScroll = "vScroll", preRotatedQuad0 = "preRotatedQuad[0]",
preRotatedQuad1 = "preRotatedQuad[1]", preRotatedQuad2 = "preRotatedQuad[2]", preRotatedQuad3 = "preRotatedQuad[3]";
// SVA for Ogre::Material hack
const GpuConstantDefinition *pGPU_ConstDef_preRotatedQuad0 = 0,
*pGPU_ConstDef_uScroll = 0, *pGPU_ConstDef_vScroll = 0;
// For each material in use by the billboard system..
SBMaterialRefList::iterator i1 = SBMaterialRef::getList().begin(), iend = SBMaterialRef::getList().end();
while (i1 != iend)
{
Ogre::Material *mat = i1->second->getMaterial();
// Ensure material is set up with the vertex shader
Pass *p = mat->getTechnique(0)->getPass(0);
if (!p->hasVertexProgram())
{
static const Ogre::String Sprite_vp = "Sprite_vp";
p->setVertexProgram(Sprite_vp);
// glsl can use the built in gl_ModelViewProjectionMatrix
if (!s_isGLSL)
p->getVertexProgramParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
GpuProgramParametersSharedPtr params = p->getVertexProgramParameters();
params->setNamedAutoConstant(uScroll, GpuProgramParameters::ACT_CUSTOM);
params->setNamedAutoConstant(vScroll, GpuProgramParameters::ACT_CUSTOM);
params->setNamedAutoConstant(preRotatedQuad0, GpuProgramParameters::ACT_CUSTOM);
params->setNamedAutoConstant(preRotatedQuad1, GpuProgramParameters::ACT_CUSTOM);
params->setNamedAutoConstant(preRotatedQuad2, GpuProgramParameters::ACT_CUSTOM);
params->setNamedAutoConstant(preRotatedQuad3, GpuProgramParameters::ACT_CUSTOM);
}
// Which prerotated quad use
const float *pQuad = i1->second->getOrigin() == BBO_CENTER ? preRotatedQuad_BBO_CENTER : preRotatedQuad_BBO_BOTTOM_CENTER;
// Update the vertex shader parameters
GpuProgramParametersSharedPtr params = p->getVertexProgramParameters();
//params->setNamedConstant(preRotatedQuad0, pQuad, 4);
//params->setNamedConstant(uScroll, p->getTextureUnitState(0)->getTextureUScroll());
//params->setNamedConstant(vScroll, p->getTextureUnitState(0)->getTextureVScroll());
// SVA some hack of Ogre::Material.
// Since material are cloned and use same vertex shader "Sprite_vp" hardware GPU indices
// must be same. I don`t know planes of Ogre Team to change this behaviour.
// Therefore this may be unsafe code. Instead of 3 std::map lookups(map::find(const Ogre::String&)) do only 1
{
const GpuConstantDefinition *def = params->_findNamedConstantDefinition(preRotatedQuad0, true);
if (def != pGPU_ConstDef_preRotatedQuad0) // new material, reread
{
pGPU_ConstDef_preRotatedQuad0 = def;
pGPU_ConstDef_uScroll = params->_findNamedConstantDefinition(uScroll, true);
pGPU_ConstDef_vScroll = params->_findNamedConstantDefinition(vScroll, true);
}
}
float fUScroll = (float)p->getTextureUnitState(0)->getTextureUScroll(),
fVScroll = (float)p->getTextureUnitState(0)->getTextureVScroll();
params->_writeRawConstants(pGPU_ConstDef_preRotatedQuad0->physicalIndex, pQuad, 16);
params->_writeRawConstants(pGPU_ConstDef_uScroll->physicalIndex, &fUScroll, 1);
params->_writeRawConstants(pGPU_ConstDef_vScroll->physicalIndex, &fVScroll, 1);
++i1; // next material in billboard system
}
}
void _init(void)
{
CompositorPtr compositor = CompositorManager::getSingleton().create(
_theType(), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
CompositionTechnique *t;
CompositionTechnique::TextureDefinition *td;
CompositionTargetPass *tp;
CompositionPass *pass;
t = compositor->createTechnique();
td = t->createTextureDefinition("scene");
td->width.viewport = 1;
td->height.viewport = 1;
td->format = PF_X8R8G8B8;
td = t->createTextureDefinition("blur0");
td->width.viewport = 0.5;
td->height.viewport = 0.5;
td->format = PF_X8R8G8B8;
td = t->createTextureDefinition("blur1");
td->width.viewport = 0.5;
td->height.viewport = 0.5;
td->format = PF_X8R8G8B8;
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
tp->setOutputName("blur0");
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/Floodlighting/DownSample");
pass->setInput(0, "scene");
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
tp->setOutputName("blur1");
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/Floodlighting/BlurHorizontal");
pass->setInput(0, "blur0");
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
tp->setOutputName("blur1");
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/Floodlighting/BlurVertical");
pass->setInput(0, "blur0");
tp = t->getOutputTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/Floodlighting/Blend");
pass->setInput(0, "scene");
pass->setInput(1, "blur1");
pass->setIdentifier(0xDEADBADE);
mBlurAmount = 0.2f;
mShineAmount = 0.3f;
// receive default parameters from material script
if (!pass->getMaterial().isNull())
{
GpuProgramParametersSharedPtr parameters = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
#if OGRE_VERSION >= 0x010300
const GpuConstantDefinition* def;
def = parameters->_findNamedConstantDefinition("blur_amount");
if (def)
parameters->_readRawConstants(def->physicalIndex, 1, &mBlurAmount);
def = parameters->_findNamedConstantDefinition("shine_amount");
if (def)
parameters->_readRawConstants(def->physicalIndex, 1, &mShineAmount);
#else
GpuProgramParameters::RealConstantEntry* entry;
entry = parameters->getNamedRealConstantEntry("blur_amount");
if (entry && entry->isSet)
mBlurAmount = entry->val[0];
entry = parameters->getNamedRealConstantEntry("shine_amount");
if (entry && entry->isSet)
mShineAmount = entry->val[0];
#endif
}
}