void LLWaterParamManager::updateShaderUniforms(LLGLSLShader * shader)
{
if (shader->mShaderGroup == LLGLSLShader::SG_WATER)
{
shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, LLWLParamManager::getInstance()->getRotatedLightDir().mV);
shader->uniform3fv(LLShaderMgr::WL_CAMPOSLOCAL, 1, LLViewerCamera::getInstance()->getOrigin().mV);
shader->uniform4fv(LLShaderMgr::WATER_FOGCOLOR, 1, LLDrawPoolWater::sWaterFogColor.mV);
shader->uniform4fv(LLShaderMgr::WATER_WATERPLANE, 1, mWaterPlane.mV);
shader->uniform1f(LLShaderMgr::WATER_FOGDENSITY, getFogDensity());
shader->uniform1f(LLShaderMgr::WATER_FOGKS, mWaterFogKS);
shader->uniform1f(LLViewerShaderMgr::DISTANCE_MULTIPLIER, 0);
}
}
void LLWaterParamManager::updateShaderUniforms(LLGLSLShader * shader)
{
if (shader->mShaderGroup == LLGLSLShader::SG_WATER)
{
shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, LLWLParamManager::instance()->getRotatedLightDir().mV);
shader->uniform3fv("camPosLocal", 1, LLViewerCamera::getInstance()->getOrigin().mV);
shader->uniform4fv("waterFogColor", 1, LLDrawPoolWater::sWaterFogColor.mV);
shader->uniform4fv("waterPlane", 1, mWaterPlane.mV);
shader->uniform1f("waterFogDensity", getFogDensity());
shader->uniform1f("waterFogKS", mWaterFogKS);
shader->uniform4f("distance_multiplier", 0, 0, 0, 0);
}
}
//-------------------------------------------------------------------------
void TerrainSceneManager::setupTerrainMaterial(void)
{
if (mCustomMaterialName == "")
{
// define our own material
mOptions.terrainMaterial =
MaterialManager::getSingleton().getByName(TERRAIN_MATERIAL_NAME);
// Make unique terrain material name
StringUtil::StrStreamType s;
s << mName << "/Terrain";
mOptions.terrainMaterial = MaterialManager::getSingleton().getByName(s.str());
if (mOptions.terrainMaterial.isNull())
{
mOptions.terrainMaterial = MaterialManager::getSingleton().create(
s.str(),
ResourceGroupManager::getSingleton().getWorldResourceGroupName());
}
else
{
mOptions.terrainMaterial->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
}
Pass* pass = mOptions.terrainMaterial->getTechnique(0)->getPass(0);
if ( mWorldTextureName != "" )
{
pass->createTextureUnitState( mWorldTextureName, 0 );
}
if ( mDetailTextureName != "" )
{
pass->createTextureUnitState( mDetailTextureName, 1 );
}
mOptions.terrainMaterial -> setLightingEnabled( mOptions.lit );
if (mOptions.lodMorph &&
mDestRenderSystem->getCapabilities()->hasCapability(RSC_VERTEX_PROGRAM) &&
GpuProgramManager::getSingleton().getByName("Terrain/VertexMorph").isNull())
{
// Create & assign LOD morphing vertex program
String syntax;
if (GpuProgramManager::getSingleton().isSyntaxSupported("arbvp1"))
{
syntax = "arbvp1";
}
else
{
syntax = "vs_1_1";
}
// Get source, and take into account current fog mode
FogMode fm = getFogMode();
const String& source = TerrainVertexProgram::getProgramSource(
fm, syntax);
GpuProgramPtr prog = GpuProgramManager::getSingleton().createProgramFromString(
"Terrain/VertexMorph", ResourceGroupManager::getSingleton().getWorldResourceGroupName(),
source, GPT_VERTEX_PROGRAM, syntax);
// Attach
pass->setVertexProgram("Terrain/VertexMorph");
// Get params
GpuProgramParametersSharedPtr params = pass->getVertexProgramParameters();
// worldviewproj
params->setAutoConstant(0, GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
// morph factor
params->setAutoConstant(4, GpuProgramParameters::ACT_CUSTOM, MORPH_CUSTOM_PARAM_ID);
// fog exp density(if relevant)
if (fm == FOG_EXP || fm == FOG_EXP2)
{
params->setConstant(5, Vector3(getFogDensity(), 0, 0));
// Override scene fog since otherwise it's applied twice
// Set to linear and we derive [0,1] fog value in the shader
pass->setFog(true, FOG_LINEAR, getFogColour(), 0, 1, 0);
}
// Also set shadow receiver program
const String& source2 = TerrainVertexProgram::getProgramSource(
fm, syntax, true);
prog = GpuProgramManager::getSingleton().createProgramFromString(
"Terrain/VertexMorphShadowReceive",
ResourceGroupManager::getSingleton().getWorldResourceGroupName(),
source2, GPT_VERTEX_PROGRAM, syntax);
pass->setShadowReceiverVertexProgram("Terrain/VertexMorphShadowReceive");
params = pass->getShadowReceiverVertexProgramParameters();
// worldviewproj
params->setAutoConstant(0, GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
// world
params->setAutoConstant(4, GpuProgramParameters::ACT_WORLD_MATRIX);
// texture view / proj
params->setAutoConstant(8, GpuProgramParameters::ACT_TEXTURE_VIEWPROJ_MATRIX);
// morph factor
params->setAutoConstant(12, GpuProgramParameters::ACT_CUSTOM, MORPH_CUSTOM_PARAM_ID);
if (mDetailTextureName != "")
{
pass->getTextureUnitState(1)->setTextureCoordSet(1);
}
// Set param index
mLodMorphParamName = "";
mLodMorphParamIndex = 4;
}
mOptions.terrainMaterial->load();
}
else
{
// Custom material
mOptions.terrainMaterial =
MaterialManager::getSingleton().getByName(mCustomMaterialName);
if (mOptions.terrainMaterial.isNull()){
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
"Material " + mCustomMaterialName + " not found.",
"TerrainSceneManager::setupTerrainMaterial");
}
mOptions.terrainMaterial->load();
}
// now set up the linkage between vertex program and LOD morph param
if (mOptions.lodMorph)
{
Technique* t = mOptions.terrainMaterial->getBestTechnique();
for (ushort i = 0; i < t->getNumPasses(); ++i)
{
Pass* p = t->getPass(i);
if (p->hasVertexProgram())
{
// we have to assume vertex program includes LOD morph capability
GpuProgramParametersSharedPtr params =
p->getVertexProgramParameters();
// Check to see if custom param is already there
GpuProgramParameters::AutoConstantIterator aci = params->getAutoConstantIterator();
bool found = false;
while (aci.hasMoreElements())
{
const GpuProgramParameters::AutoConstantEntry& ace = aci.getNext();
if (ace.paramType == GpuProgramParameters::ACT_CUSTOM &&
ace.data == MORPH_CUSTOM_PARAM_ID)
{
found = true;
}
}
if (!found)
{
if(mLodMorphParamName != "")
{
params->setNamedAutoConstant(mLodMorphParamName,
GpuProgramParameters::ACT_CUSTOM, MORPH_CUSTOM_PARAM_ID);
}
else
{
params->setAutoConstant(mLodMorphParamIndex,
GpuProgramParameters::ACT_CUSTOM, MORPH_CUSTOM_PARAM_ID);
}
}
}
}
}
}
