void App::materialCreated(sh::MaterialInstance* m, const std::string& configuration, unsigned short lodIndex)
{
Ogre::Technique* t = static_cast<sh::OgreMaterial*>(m->getMaterial())->getOgreTechniqueForConfiguration (configuration, lodIndex);
if (pSet->shadow_type == Sh_None)
{
t->setShadowCasterMaterial("");
return;
}
/*if (m->hasProperty("transparent") && m->hasProperty("cull_hardware") &&
sh::retrieveValue<sh::StringValue>(m->getProperty("cull_hardware"), 0).get() == "none")
{
// Crash !?
assert(!MaterialManager::getSingleton().getByName("PSSM/shadow_caster_nocull").isNull ());
t->setShadowCasterMaterial("shadowcaster_nocull");
}*/
if (m->hasProperty("instancing") && sh::retrieveValue<sh::StringValue>(m->getProperty("instancing"), 0).get() == "true")
{
t->setShadowCasterMaterial("shadowcaster_instancing");
}
if (!m->hasProperty("transparent") || !sh::retrieveValue<sh::BooleanValue>(m->getProperty("transparent"), 0).get())
{
t->setShadowCasterMaterial("shadowcaster_noalpha");
}
}
//-------------------------------------------------------------------------------
Ogre::MaterialPtr CSceneManagerEditor::buildDepthShadowMaterial(Ogre::MaterialPtr cpyMat)
{
if(mShadowsTechnique->get() >= (int)Ogre::SHADOWTYPE_TEXTURE_ADDITIVE && mShadowsTechnique->get() <= (int)Ogre::SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED)
{
Ogre::String matName = "DepthShadows/" + cpyMat->getName();
Ogre::MaterialPtr ret = Ogre::MaterialManager::getSingleton().getByName(matName);
if (ret.isNull())
{
ret = cpyMat->clone(matName);
Ogre::Technique *t = ret->getTechnique(0);
t->setShadowCasterMaterial("Ogre/shadow/depth/caster");
Ogre::Pass *p = t->getPass(0);
p->setVertexProgram("Ogre/shadow/receiver/depth/pssm3/vp");
p->setFragmentProgram("Ogre/shadow/receiver/depth/pssm3/fp");
Ogre::TextureUnitState *tu = p->createTextureUnitState();
tu->setName("shadow0");
tu->setContentType(Ogre::TextureUnitState::CONTENT_SHADOW);
tu->setTextureAddressingMode(Ogre::TextureUnitState::TAM_BORDER);
tu->setTextureBorderColour(Ogre::ColourValue(1,1,1,1));
tu = p->createTextureUnitState();
tu->setName("shadow1");
tu->setContentType(Ogre::TextureUnitState::CONTENT_SHADOW);
tu->setTextureAddressingMode(Ogre::TextureUnitState::TAM_BORDER);
tu->setTextureBorderColour(Ogre::ColourValue(1,1,1,1));
tu = p->createTextureUnitState();
tu->setName("shadow2");
tu->setContentType(Ogre::TextureUnitState::CONTENT_SHADOW);
tu->setTextureAddressingMode(Ogre::TextureUnitState::TAM_BORDER);
tu->setTextureBorderColour(Ogre::ColourValue(1,1,1,1));
Ogre::Vector4 splitPoints;
const Ogre::PSSMShadowCameraSetup::SplitPointList& splitPointList =
static_cast<Ogre::PSSMShadowCameraSetup*>(mPSSMSetup.get())->getSplitPoints();
for (int i = 0; i < 3; ++i)
{
splitPoints[i] = splitPointList[i];
}
p->getFragmentProgramParameters()->setNamedConstant("pssmSplitPoints", splitPoints);
}
return ret;
}
else
return cpyMat;
}
bool OgreMaterial::createConfiguration (const std::string& name)
{
for (int i=0; i<mMaterial->getNumTechniques(); ++i)
{
if (mMaterial->getTechnique(i) == mMaterial->getTechnique(name))
return false;
}
Ogre::Technique* t = mMaterial->createTechnique();
t->setSchemeName (name);
t->setName (name);
if (mShadowCasterMaterial != "")
t->setShadowCasterMaterial(mShadowCasterMaterial);
return true;
}
bool OgreMaterial::createConfiguration (const std::string& name, unsigned short lodIndex)
{
for (int i=0; i<mMaterial->getNumTechniques(); ++i)
{
if (mMaterial->getTechnique(i)->getSchemeName() == name && mMaterial->getTechnique(i)->getLodIndex() == lodIndex)
return false;
}
Ogre::Technique* t = mMaterial->createTechnique();
t->setSchemeName (name);
t->setLodIndex (lodIndex);
if (mShadowCasterMaterial != "")
t->setShadowCasterMaterial(mShadowCasterMaterial);
mMaterial->compile();
return true;
}
void MaterialGenerator::generate()
{
mMaterial = prepareMaterial(mDef->getName());
// reset some attributes
resetTexUnitCounter();
// choose textures from list (depending on user iTexSize setting)
chooseTextures();
// -------------------------- Main technique ----------------------------- //
Ogre::Technique* technique = mMaterial->createTechnique();
// Main pass
Ogre::Pass* pass = technique->createPass();
pass->setAmbient( mDef->mProps->ambient.x, mDef->mProps->ambient.y, mDef->mProps->ambient.z );
pass->setDiffuse( mDef->mProps->diffuse.x, mDef->mProps->diffuse.y, mDef->mProps->diffuse.z, 1.0 );
// shader assumes shininess in specular w component
pass->setSpecular(mDef->mProps->specular.x, mDef->mProps->specular.y, mDef->mProps->specular.z, mDef->mProps->specular.w);
pass->setCullingMode(chooseCullingMode());
pass->setFog(true); // turn off fixed function fog, we use shaders
if (!mDef->mProps->lighting)
pass->setLightingEnabled(false);
if (mDef->mProps->sceneBlend == SBM_ALPHA_BLEND)
pass->setSceneBlending(SBT_TRANSPARENT_ALPHA);
else if (mDef->mProps->sceneBlend == SBM_COLOUR_BLEND)
pass->setSceneBlending(SBT_TRANSPARENT_COLOUR);
else if (mDef->mProps->sceneBlend == SBM_ADD)
pass->setSceneBlending(SBT_ADD);
else if (mDef->mProps->sceneBlend == SBM_MODULATE)
pass->setSceneBlending(SBT_MODULATE);
pass->setDepthWriteEnabled( mDef->mProps->depthWrite );
pass->setDepthCheckEnabled( mDef->mProps->depthCheck );
pass->setTransparentSortingEnabled( mDef->mProps->transparentSorting );
pass->setAlphaRejectFunction( mDef->mProps->alphaRejectFunc );
pass->setAlphaRejectValue( mDef->mProps->alphaRejectValue );
if (mDef->mProps->depthBias != 0.f)
pass->setDepthBias( mDef->mProps->depthBias );
createTexUnits(pass);
// create shaders
if (!mShaderCached)
{
try
{
mVertexProgram = createVertexProgram();
mFragmentProgram = createFragmentProgram();
}
catch (Ogre::Exception& e) {
LogO(e.getFullDescription());
}
//!todo put this code into a function for reusability in other material generators
if (mFragmentProgram.isNull() || mVertexProgram.isNull() ||
!mFragmentProgram->isSupported() || !mVertexProgram->isSupported())
{
LogO("[MaterialFactory] WARNING: shader for material '" + mDef->getName()
+ "' is not supported");
LogO("[MaterialFactory] Vertex program source: ");
StringUtil::StrStreamType vSourceStr;
generateVertexProgramSource(vSourceStr);
LogO(vSourceStr.str());
LogO("[MaterialFactory] Fragment program source: ");
StringUtil::StrStreamType fSourceStr;
generateFragmentProgramSource(fSourceStr);
LogO(fSourceStr.str());
mVertexProgram.setNull(); mFragmentProgram.setNull();
return;
}
}
pass->setVertexProgram(mVertexProgram->getName());
pass->setFragmentProgram(mFragmentProgram->getName());
//set shadow caster
technique->setShadowCasterMaterial(chooseShadowCasterMaterial());
if (mShaderCached)
{
// set individual material shader params
individualVertexProgramParams(pass->getVertexProgramParameters());
individualFragmentProgramParams(pass->getFragmentProgramParameters());
}
// ----------------------------------------------------------------------- //
createSSAOTechnique();
createOccluderTechnique();
// indicate we need enable/disable wind parameter
// only needed for trees (wind == 2) because the wind effect has to be disabled before rendering impostors
if (mShader->wind == 2)
mParent->windMtrs.push_back( mDef->getName() );
if (mDef->mProps->fog)
mParent->fogMtrs.push_back( mDef->getName() );
/// uncomment to export to .material
//LogO(mDef->getName());
/**
//if (mDef->getName() == "Water_cyan")
/*{
MaterialSerializer serializer;
serializer.exportMaterial(mMaterial, "water.material");
}
/**/
/// uncomment to see full shader source code in log
/**
LogO(mDef->getName());
if (StringUtil::startsWith(mDef->getName(), "FluidWater" )) //"water" //_cyan"
{
LogO("[MaterialFactory] Vertex program source: ");
StringUtil::StrStreamType vSourceStr;
generateVertexProgramSource(vSourceStr);
LogO(vSourceStr.str());
LogO("[MaterialFactory] Fragment program source: ");
StringUtil::StrStreamType fSourceStr;
generateFragmentProgramSource(fSourceStr);
LogO(fSourceStr.str());
}
/**/
}
