//! [schemenotfound]
Technique* GBufferSchemeHandler::handleSchemeNotFound(unsigned short schemeIndex,
const String& schemeName, Material* originalMaterial, unsigned short lodIndex,
const Renderable* rend)
{
Ogre::MaterialManager& matMgr = Ogre::MaterialManager::getSingleton();
String curSchemeName = matMgr.getActiveScheme();
matMgr.setActiveScheme(MaterialManager::DEFAULT_SCHEME_NAME);
Technique* originalTechnique = originalMaterial->getBestTechnique(lodIndex, rend);
matMgr.setActiveScheme(curSchemeName);
Technique* gBufferTech = originalMaterial->createTechnique();
gBufferTech->removeAllPasses();
gBufferTech->setSchemeName(schemeName);
#ifdef OGRE_BUILD_COMPONENT_RTSHADERSYSTEM
RTShader::ShaderGenerator& rtShaderGen = RTShader::ShaderGenerator::getSingleton();
rtShaderGen.createShaderBasedTechnique(originalTechnique, "NoGBuffer");
#else
Technique* noGBufferTech = originalMaterial->createTechnique();
noGBufferTech->removeAllPasses();
noGBufferTech->setSchemeName("NoGBuffer");
#endif
for (unsigned short i=0; i<originalTechnique->getNumPasses(); i++)
{
Pass* originalPass = originalTechnique->getPass(i);
PassProperties props = inspectPass(originalPass, lodIndex, rend);
if (!props.isDeferred)
{
#ifdef OGRE_BUILD_COMPONENT_RTSHADERSYSTEM
rtShaderGen.validateMaterial("NoGBuffer", originalMaterial->getName(), originalMaterial->getGroup());
#else
//Just copy the technique so it gets rendered regularly
Pass* clonePass = noGBufferTech->createPass();
*clonePass = *originalPass;
#endif
continue;
}
Pass* newPass = gBufferTech->createPass();
MaterialGenerator::Perm perm = getPermutation(props);
const Ogre::MaterialPtr& templateMat = mMaterialGenerator.getMaterial(perm);
//We assume that the GBuffer technique contains only one pass. But its true.
*newPass = *(templateMat->getTechnique(0)->getPass(0));
fillPass(newPass, originalPass, props);
}
return gBufferTech;
}
void MaterialGenerator::createOccluderTechnique()
{
Technique* occluderpasstech = mMaterial->createTechnique();
occluderpasstech->setName("occluder");
occluderpasstech->setSchemeName("occluder");
Pass* occluderpass = occluderpasstech->createPass();
HighLevelGpuProgramManager& hmgr = HighLevelGpuProgramManager::getSingleton();
// choose vertex program
std::string vprogname = "occluder_vs";
if ( mDef->mProps->transparent )
vprogname = "occluder_coord_vs";
//TODO:this is a workaround until a valid sun material is available to be used.
if(StringUtil::startsWith(this->mDef->getName(), "sky/"))
{
//use the sky object as the sun
vprogname = mVertexProgram->getName();
}
// choose fragment program
std::string fprogname = "occluder_ps";
if ( mDef->mProps->transparent )
fprogname = "occluder_alpha_ps";
//TODO:this is a workaround until a valid sun material is available to be used.
if(StringUtil::startsWith(this->mDef->getName(), "sky/"))
{
//use the sky object as the sun
fprogname = mFragmentProgram->getName();
}
occluderpass->setVertexProgram(vprogname);
occluderpass->setFragmentProgram(fprogname);
if (mDef->mProps->alphaRejectValue > 0)
occluderpass->setAlphaRejectSettings(mDef->mProps->alphaRejectFunc, mDef->mProps->alphaRejectValue);
if ( !mDef->mProps->transparent )
{
occluderpass->setCullingMode( chooseCullingMode() );
if(StringUtil::startsWith(this->mDef->getName(), "sky/"))
{
//Set the sky object as the sun
occluderpass->createTextureUnitState( mDiffuseMap );
}
}
else
{
occluderpass->setCullingMode( CULL_NONE );
occluderpass->setAlphaRejectSettings(CMPF_GREATER_EQUAL, 128);
occluderpass->createTextureUnitState( mDiffuseMap );
}
}
void MaterialGenerator::createSSAOTechnique()
{
Technique* ssaopasstech = mMaterial->createTechnique();
ssaopasstech->setName("geom");
ssaopasstech->setSchemeName("geom");
Pass* ssaopass = ssaopasstech->createPass();
ssaopass->setDepthWriteEnabled( mDef->mProps->depthWrite );
ssaopass->setDepthCheckEnabled( mDef->mProps->depthCheck );
HighLevelGpuProgramManager& hmgr = HighLevelGpuProgramManager::getSingleton();
// choose vertex program
std::string vprogname = "geom_vs";
if ( mDef->mProps->transparent )
vprogname = "geom_coord_vs";
// choose fragment program
std::string fprogname = "geom_ps";
if ( !mDef->mProps->ssao )
fprogname = "geom_white_ps"; // no contribution to ssao, will just return (0,0,0,0)
else if ( mDef->mProps->transparent )
fprogname = "geom_alpha_ps";
ssaopass->setVertexProgram(vprogname);
ssaopass->setFragmentProgram(fprogname);
if (mDef->mProps->ssaoReject)
ssaopass->setAlphaRejectSettings(CMPF_GREATER, 128);
if ( !mDef->mProps->transparent )
{
ssaopass->setCullingMode( chooseCullingMode() );
}
else
{
ssaopass->setCullingMode( CULL_NONE );
ssaopass->setAlphaRejectSettings(CMPF_GREATER_EQUAL, 128);
ssaopass->createTextureUnitState( mDiffuseMap );
}
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorC::SM2Profile::addTechnique(
const MaterialPtr& mat, const Terrain* terrain, TechniqueType tt)
{
Technique* tech = mat->createTechnique();
tech->setSchemeName("GBuffer");
// Only supporting one pass
Pass* pass = tech->createPass();
//pass->setName("NO_DEFERRED");
GpuProgramManager& gmgr = GpuProgramManager::getSingleton();
HighLevelGpuProgramManager& hmgr = HighLevelGpuProgramManager::getSingleton();
if (!mShaderGen)
{
if (hmgr.isLanguageSupported("cg"))
mShaderGen = OGRE_NEW ShaderHelperCg();
else
{
// todo
}
// check SM3 features
mSM3Available = GpuProgramManager::getSingleton().isSyntaxSupported("ps_3_0");
mSM4Available = GpuProgramManager::getSingleton().isSyntaxSupported("ps_4_0");
}
HighLevelGpuProgramPtr vprog = mShaderGen->generateVertexProgram(this, terrain, tt);
HighLevelGpuProgramPtr fprog = mShaderGen->generateFragmentProgram(this, terrain, tt);
pass->setVertexProgram(vprog->getName());
pass->setFragmentProgram(fprog->getName());
if (tt == HIGH_LOD || tt == RENDER_COMPOSITE_MAP)
{
// global normal map
TextureUnitState* tu = pass->createTextureUnitState();
tu->setTextureName(terrain->getTerrainNormalMap()->getName());
tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
// global colour map
if (terrain->getGlobalColourMapEnabled() && isGlobalColourMapEnabled())
{
tu = pass->createTextureUnitState(terrain->getGlobalColourMap()->getName());
tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
}
// light map
if (isLightmapEnabled())
{
tu = pass->createTextureUnitState(terrain->getLightmap()->getName());
tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
}
// blend maps
uint maxLayers = getMaxLayers(terrain);
uint numBlendTextures = std::min(terrain->getBlendTextureCount(maxLayers), terrain->getBlendTextureCount());
uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount()));
for (uint i = 0; i < numBlendTextures; ++i)
{
tu = pass->createTextureUnitState(terrain->getBlendTextureName(i));
tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
}
// layer textures
for (uint i = 0; i < numLayers; ++i)
{
// diffuse / specular
pass->createTextureUnitState(terrain->getLayerTextureName(i, 0));
// normal / height
pass->createTextureUnitState(terrain->getLayerTextureName(i, 1));
}
}
else
{
// LOW_LOD textures
// composite map
TextureUnitState* tu = pass->createTextureUnitState();
tu->setTextureName(terrain->getCompositeMap()->getName());
tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
// That's it!
}
}
