void ReplaceTextureOnMaterial(Ogre::MaterialPtr material, const std::string& original_name, const std::string& texture_name)
{
if (material.isNull())
return;
Ogre::TextureManager &tm = Ogre::TextureManager::getSingleton();
Ogre::TexturePtr tex = tm.getByName(texture_name);
Ogre::Material::TechniqueIterator iter = material->getTechniqueIterator();
while(iter.hasMoreElements())
{
Ogre::Technique *tech = iter.getNext();
assert(tech);
Ogre::Technique::PassIterator passIter = tech->getPassIterator();
while(passIter.hasMoreElements())
{
Ogre::Pass *pass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator texIter = pass->getTextureUnitStateIterator();
while(texIter.hasMoreElements())
{
Ogre::TextureUnitState *texUnit = texIter.getNext();
if (texUnit->getTextureName() == original_name)
{
if (tex.get())
texUnit->setTextureName(texture_name);
else
texUnit->setTextureName("TextureMissing.png");
}
}
}
}
}
/**
* Destroy / unload the memory of a material
* @param mat MaterialName
*/
void GUIHelper::destroyMaterial(const Ogre::String &matName)
{
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName(matName);
if(mat.isNull()) return;
Ogre::Material::TechniqueIterator tit = mat->getTechniqueIterator();
while(tit.hasMoreElements()){
Ogre::Technique *t = tit.peekNext();
ASSERT(t);
Ogre::Technique::PassIterator pit = t->getPassIterator();
while(pit.hasMoreElements()){
Ogre::Pass *pass = pit.peekNext();
ASSERT(pass);
Ogre::Pass::TextureUnitStateIterator tuit =
pass->getTextureUnitStateIterator();
while(tuit.hasMoreElements()){
Ogre::TextureUnitState *tus = tuit.peekNext();
ASSERT(tus);
const Ogre::String &textName = tus->getTextureName();
Ogre::TextureManager::getSingleton().unload(textName);
Ogre::TextureManager::getSingleton().remove(textName);
tuit.moveNext();
}
pit.moveNext();
}
tit.moveNext();
}
Ogre::MaterialManager::getSingleton().unload(matName);
Ogre::MaterialManager::getSingleton().remove(matName);
}
void EC_WidgetCanvas::SetSelfIllumination(bool illuminating)
{
if (material_name_.empty())
return;
Ogre::ColourValue emissiveColor;
if (illuminating)
emissiveColor = Ogre::ColourValue(1.0f, 1.0f, 1.0f, 1.0f);
else
emissiveColor = Ogre::ColourValue(0.0f, 0.0f, 0.0f, 0.0f);
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(material_name_);
if (!material.isNull())
{
Ogre::Material::TechniqueIterator iter = material->getTechniqueIterator();
while(iter.hasMoreElements())
{
Ogre::Technique *tech = iter.getNext();
if (!tech)
continue;
Ogre::Technique::PassIterator passIter = tech->getPassIterator();
while(passIter.hasMoreElements())
{
Ogre::Pass *pass = passIter.getNext();
if (pass)
pass->setSelfIllumination(emissiveColor);
}
}
}
}
bool MainCamera::validateCompositionTargetPass(Ogre::CompositionTargetPass& compositionPass)
{
Ogre::CompositionTargetPass::PassIterator compPassIter = compositionPass.getPassIterator();
while (compPassIter.hasMoreElements()) {
Ogre::CompositionPass* compositorPass = compPassIter.getNext();
compositorPass->getMaterial()->load();
Ogre::Material::TechniqueIterator techIter = compositorPass->getMaterial()->getSupportedTechniqueIterator();
while (techIter.hasMoreElements()) {
Ogre::Technique::PassIterator _passIter = techIter.getNext()->getPassIterator();
while (_passIter.hasMoreElements()) {
Ogre::Pass* pass = _passIter.getNext();
//Also disallow camera polygon mode overide. This is because if it's turned on,
//and the camera is switched to polygon mode, the end result will be one single
//large polygon being shown. This is not what we want.
pass->setPolygonModeOverrideable(false);
if (pass->hasFragmentProgram()) {
if (pass->getFragmentProgram()->hasCompileError()) {
return false;
}
}
}
}
}
return true;
}
CreatureAnimation::CreatureAnimation(const MWWorld::Ptr& ptr, OEngine::Render::OgreRenderer& _rend): Animation(_rend)
{
mInsert = ptr.getRefData().getBaseNode();
MWWorld::LiveCellRef<ESM::Creature> *ref = ptr.get<ESM::Creature>();
assert (ref->base != NULL);
if(!ref->base->model.empty())
{
const std::string &mesh = "meshes\\" + ref->base->model;
std::string meshNumbered = mesh + getUniqueID(mesh) + ">|";
NifOgre::NIFLoader::load(meshNumbered);
mBase = mRend.getScene()->createEntity(meshNumbered);
mBase->setVisibilityFlags(RV_Actors);
bool transparent = false;
for (unsigned int i=0; i < mBase->getNumSubEntities(); ++i)
{
Ogre::MaterialPtr mat = mBase->getSubEntity(i)->getMaterial();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements())
{
Ogre::Technique* tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{
Ogre::Pass* pass = passIt.getNext();
if (pass->getDepthWriteEnabled() == false)
transparent = true;
}
}
}
mBase->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
std::string meshZero = mesh + "0000>|";
if((mTransformations = (NIFLoader::getSingletonPtr())->getAnim(meshZero)))
{
for(std::size_t init = 0; init < mTransformations->size(); init++)
{
mRindexI.push_back(0);
mTindexI.push_back(0);
}
mStopTime = mTransformations->begin()->getStopTime();
mStartTime = mTransformations->begin()->getStartTime();
mShapes = (NIFLoader::getSingletonPtr())->getShapes(meshZero);
}
mTextmappings = NIFLoader::getSingletonPtr()->getTextIndices(meshZero);
mInsert->attachObject(mBase);
}
}
CreatureAnimation::CreatureAnimation(const MWWorld::Ptr& ptr): Animation()
{
mInsert = ptr.getRefData().getBaseNode();
MWWorld::LiveCellRef<ESM::Creature> *ref = ptr.get<ESM::Creature>();
assert (ref->mBase != NULL);
if(!ref->mBase->mModel.empty())
{
std::string mesh = "meshes\\" + ref->mBase->mModel;
mEntityList = NifOgre::NIFLoader::createEntities(mInsert, &mTextKeys, mesh);
for(size_t i = 0; i < mEntityList.mEntities.size(); i++)
{
Ogre::Entity *ent = mEntityList.mEntities[i];
ent->setVisibilityFlags(RV_Actors);
bool transparent = false;
for (unsigned int j=0; j < ent->getNumSubEntities() && !transparent; ++j)
{
Ogre::MaterialPtr mat = ent->getSubEntity(j)->getMaterial();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements() && !transparent)
{
Ogre::Technique* tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements() && !transparent)
{
Ogre::Pass* pass = passIt.getNext();
if (pass->getDepthWriteEnabled() == false)
transparent = true;
}
}
}
ent->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
}
if(mEntityList.mSkelBase)
{
Ogre::AnimationStateSet *aset = mEntityList.mSkelBase->getAllAnimationStates();
Ogre::AnimationStateIterator as = aset->getAnimationStateIterator();
while(as.hasMoreElements())
{
Ogre::AnimationState *state = as.getNext();
state->setEnabled(true);
state->setLoop(false);
}
}
}
}
//copied from ogre sample browser
Ogre::Technique* gkMaterialLoader::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName,
Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend)
{
#ifdef OGREKIT_USE_RTSHADER_SYSTEM
Ogre::RTShader::ShaderGenerator* shaderGenerator = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
GK_ASSERT(shaderGenerator);
Ogre::Technique* generatedTech = 0;
if (schemeName == Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME)
{
bool techniqueCreated;
techniqueCreated = shaderGenerator->createShaderBasedTechnique(
originalMaterial->getName(), Ogre::MaterialManager::DEFAULT_SCHEME_NAME, schemeName);
if (techniqueCreated)
{
shaderGenerator->validateMaterial(schemeName, originalMaterial->getName());
Ogre::Material::TechniqueIterator itTech = originalMaterial->getTechniqueIterator();
while (itTech.hasMoreElements())
{
Ogre::Technique* curTech = itTech.getNext();
if (curTech->getSchemeName() == schemeName)
{
generatedTech = curTech;
break;
}
}
}
}
if (!generatedTech)
{
gkLogMessage("Material: " << schemeName << " isn't found.");
}
else
{
gkLogMessage("Material: " << schemeName << " is found.");
}
return generatedTech;
#else
return 0;
#endif
}
void
Terrain::_applyFogMode(const Ogre::MaterialPtr& material, Ogre::FogMode oldFogMode, Ogre::FogMode newFogMode) const
{
if (oldFogMode == newFogMode)
return;
if (mData->mSupportedFogReplacements.empty())
return;
Ogre::String newProgramName;
Ogre::Material::TechniqueIterator ti = material->getTechniqueIterator();
while (ti.hasMoreElements())
{
Ogre::Technique* technique = ti.getNext();
Ogre::Technique::PassIterator pi = technique->getPassIterator();
while (pi.hasMoreElements())
{
Ogre::Pass* pass = pi.getNext();
if (pass->hasVertexProgram() &&
_checkFogProgramName(pass->getVertexProgram(), oldFogMode, newFogMode, newProgramName))
{
pass->setVertexProgram(newProgramName);
}
if (pass->hasFragmentProgram() &&
_checkFogProgramName(pass->getFragmentProgram(), oldFogMode, newFogMode, newProgramName))
{
pass->setFragmentProgram(newProgramName);
}
if (pass->hasShadowCasterVertexProgram() &&
_checkFogProgramName(pass->getShadowCasterVertexProgram(), oldFogMode, newFogMode, newProgramName))
{
pass->setShadowCasterVertexProgram(newProgramName);
}
if (pass->hasShadowReceiverVertexProgram() &&
_checkFogProgramName(pass->getShadowReceiverVertexProgram(), oldFogMode, newFogMode, newProgramName))
{
pass->setShadowReceiverVertexProgram(newProgramName);
}
if (pass->hasShadowReceiverFragmentProgram() &&
_checkFogProgramName(pass->getShadowReceiverFragmentProgram(), oldFogMode, newFogMode, newProgramName))
{
pass->setShadowReceiverFragmentProgram(newProgramName);
}
}
}
}
void GroundFog::findFogPassesByName (const Ogre::String& passName) {
Ogre::MaterialManager *matManager = Ogre::MaterialManager::getSingletonPtr();
Ogre::MaterialManager::ResourceMapIterator matIt = matManager->getResourceIterator();
while (matIt.hasMoreElements()) {
Ogre::MaterialPtr mat = matIt.getNext();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements()) {
Ogre::Technique *tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements()) {
Ogre::Pass *pass = passIt.getNext();
if (pass->getName() == passName) {
mPasses.insert(pass);
}
}
}
}
forceUpdate();
}
/** This class demonstrates basic usage of the RTShader system.
It sub class the material manager listener class and when a target scheme callback
is invoked with the shader generator scheme it tries to create an equivalent shader
based technique based on the default technique of the given material.
*/
Ogre::Technique* MaterialMgrListener::handleSchemeNotFound(unsigned short schemeIndex,
const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex,
const Ogre::Renderable* rend)
{
Ogre::Technique* generatedTech = NULL;
// Case this is the default shader generator scheme.
if (schemeName == Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME)
{
bool techniqueCreated;
// Create shader generated technique for this material.
techniqueCreated = mShaderGenerator->createShaderBasedTechnique(
originalMaterial->getName(),
Ogre::MaterialManager::DEFAULT_SCHEME_NAME,
schemeName);
// Case technique registration succeeded.
if (techniqueCreated)
{
// Force creating the shaders for the generated technique.
mShaderGenerator->validateMaterial(schemeName, originalMaterial->getName());
// Grab the generated technique.
Ogre::Material::TechniqueIterator itTech = originalMaterial->getTechniqueIterator();
while (itTech.hasMoreElements())
{
Ogre::Technique* curTech = itTech.getNext();
if (curTech->getSchemeName() == schemeName)
{
generatedTech = curTech;
break;
}
}
}
}
return generatedTech;
}
void GetTextureNamesFromMaterial(Ogre::MaterialPtr material, StringVector& textures)
{
textures.clear();
if (material.isNull())
return;
// Use a set internally to avoid duplicates
std::set<std::string> textures_set;
Ogre::Material::TechniqueIterator iter = material->getTechniqueIterator();
while(iter.hasMoreElements())
{
Ogre::Technique *tech = iter.getNext();
assert(tech);
Ogre::Technique::PassIterator passIter = tech->getPassIterator();
while(passIter.hasMoreElements())
{
Ogre::Pass *pass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator texIter = pass->getTextureUnitStateIterator();
while(texIter.hasMoreElements())
{
Ogre::TextureUnitState *texUnit = texIter.getNext();
const std::string& texname = texUnit->getTextureName();
if (!texname.empty())
textures_set.insert(texname);
}
}
}
std::set<std::string>::iterator i = textures_set.begin();
while (i != textures_set.end())
{
textures.push_back(*i);
++i;
}
}
ActivatorAnimation::ActivatorAnimation(const MWWorld::Ptr &ptr)
: Animation(ptr)
{
MWWorld::LiveCellRef<ESM::Activator> *ref = mPtr.get<ESM::Activator>();
assert (ref->mBase != NULL);
if(!ref->mBase->mModel.empty())
{
std::string mesh = "meshes\\" + ref->mBase->mModel;
createEntityList(mPtr.getRefData().getBaseNode(), mesh);
for(size_t i = 0;i < mEntityList.mEntities.size();i++)
{
Ogre::Entity *ent = mEntityList.mEntities[i];
bool transparent = false;
for (unsigned int j=0;j < ent->getNumSubEntities() && !transparent; ++j)
{
Ogre::MaterialPtr mat = ent->getSubEntity(j)->getMaterial();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements() && !transparent)
{
Ogre::Technique* tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements() && !transparent)
{
Ogre::Pass* pass = passIt.getNext();
if (pass->getDepthWriteEnabled() == false)
transparent = true;
}
}
}
ent->setVisibilityFlags(RV_Misc);
ent->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
}
setAnimationSource(mesh);
}
}
// unload all about this mesh. The mesh itself and the textures.
// BETWEEN FRAME OPERATION
void VisCalcFrustDist::unloadTheMesh(Ogre::MeshPtr meshP) {
if (m_shouldCullTextures) {
Ogre::Mesh::SubMeshIterator smi = meshP->getSubMeshIterator();
while (smi.hasMoreElements()) {
Ogre::SubMesh* oneSubMesh = smi.getNext();
Ogre::String subMeshMaterialName = oneSubMesh->getMaterialName();
Ogre::MaterialPtr subMeshMaterial = (Ogre::MaterialPtr)Ogre::MaterialManager::getSingleton().getByName(subMeshMaterialName);
if (!subMeshMaterial.isNull()) {
Ogre::Material::TechniqueIterator techIter = subMeshMaterial->getTechniqueIterator();
while (techIter.hasMoreElements()) {
Ogre::Technique* oneTech = techIter.getNext();
Ogre::Technique::PassIterator passIter = oneTech->getPassIterator();
while (passIter.hasMoreElements()) {
Ogre::Pass* onePass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator tusIter = onePass->getTextureUnitStateIterator();
while (tusIter.hasMoreElements()) {
Ogre::TextureUnitState* oneTus = tusIter.getNext();
Ogre::String texName = oneTus->getTextureName();
Ogre::TexturePtr texP = (Ogre::TexturePtr)Ogre::TextureManager::getSingleton().getByName(texName);
if (!texP.isNull()) {
// if (texP.useCount() <= 1) {
texP->unload();
LG::IncStat(LG::StatCullTexturesUnloaded);
// LG::Log("unloadTheMesh: unloading texture %s", texName.c_str());
// }
}
}
}
}
}
}
}
if (m_shouldCullMeshes) {
LG::OLMeshTracker::Instance()->MakeUnLoaded(meshP->getName(), Ogre::String(), NULL);
LG::IncStat(LG::StatCullMeshesUnloaded);
// LG::Log("unloadTheMesh: unloading mesh %s", mshName.c_str());
}
}
void GroundFog::findFogPassesByName (const Ogre::String& passName) {
Ogre::MaterialManager *matManager = Ogre::MaterialManager::getSingletonPtr();
Ogre::MaterialManager::ResourceMapIterator matIt = matManager->getResourceIterator();
while (matIt.hasMoreElements()) {
#if (OGRE_VERSION < ((1 << 16) | (9 << 8) | 0))
Ogre::MaterialPtr mat = matIt.getNext();
#else
Ogre::MaterialPtr mat = matIt.getNext().staticCast<Ogre::Material>();
#endif
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements()) {
Ogre::Technique *tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements()) {
Ogre::Pass *pass = passIt.getNext();
if (pass->getName() == passName) {
mPasses.insert(pass);
}
}
}
}
forceUpdate();
}
bool OgreMaterialResource::SetData(Foundation::AssetPtr source)
{
// Remove old material if any
RemoveMaterial();
references_.clear();
original_textures_.clear();
Ogre::MaterialManager& matmgr = Ogre::MaterialManager::getSingleton();
OgreRenderingModule::LogDebug("Parsing material " + source->GetId());
if (!source)
{
OgreRenderingModule::LogError("Null source asset data pointer");
return false;
}
if (!source->GetSize())
{
OgreRenderingModule::LogError("Zero sized material asset");
return false;
}
Ogre::DataStreamPtr data = Ogre::DataStreamPtr(new Ogre::MemoryDataStream(const_cast<u8 *>(source->GetData()), source->GetSize()));
static int tempname_count = 0;
tempname_count++;
std::string tempname = "TempMat" + ToString<int>(tempname_count);
try
{
int num_materials = 0;
int brace_level = 0;
bool skip_until_next = false;
int skip_brace_level = 0;
// Parsed/modified material script
std::ostringstream output;
while (!data->eof())
{
Ogre::String line = data->getLine();
// Skip empty lines & comments
if ((line.length()) && (line.substr(0, 2) != "//"))
{
// Process opening/closing braces
if (!ResourceHandler::ProcessBraces(line, brace_level))
{
// If not a brace and on level 0, it should be a new material; replace name
if ((brace_level == 0) && (line.substr(0, 8) == "material"))
{
if (num_materials == 0)
{
line = "material " + tempname;
++num_materials;
}
else
{
OgreRenderingModule::LogWarning("More than one material defined in material asset " + source->GetId() + " - only first one supported");
break;
}
}
else
{
// Check for textures
if ((line.substr(0, 8) == "texture ") && (line.length() > 8))
{
std::string tex_name = line.substr(8);
// Note: we assume all texture references are asset based. ResourceHandler checks later whether this is true,
// before requesting the reference
references_.push_back(Foundation::ResourceReference(tex_name, OgreTextureResource::GetTypeStatic()));
original_textures_.push_back(tex_name);
// Replace any / with \ in the material, then change the texture names back later, so that Ogre does not go nuts
ReplaceCharInplace(line, '/', '\\');
ReplaceCharInplace(line, ':', '@');
}
}
// Write line to the modified copy
if (!skip_until_next)
output << line << std::endl;
}
else
{
// Write line to the modified copy
if (!skip_until_next)
output << line << std::endl;
if (brace_level <= skip_brace_level)
skip_until_next = false;
}
}
}
std::string output_str = output.str();
Ogre::DataStreamPtr modified_data = Ogre::DataStreamPtr(new Ogre::MemoryDataStream((u8 *)(&output_str[0]), output_str.size()));
matmgr.parseScript(modified_data, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::MaterialPtr tempmat;
tempmat = matmgr.getByName(tempname);
if (tempmat.isNull())
{
OgreRenderingModule::LogWarning(std::string("Failed to create an Ogre material from material asset ") +
source->GetId());
return false;
}
if(!tempmat->getNumTechniques())
{
OgreRenderingModule::LogWarning("Failed to create an Ogre material from material asset " +
source->GetId());
return false;
}
ogre_material_ = tempmat->clone(id_);
tempmat.setNull();
matmgr.remove(tempname);
if (ogre_material_.isNull())
{
OgreRenderingModule::LogWarning("Failed to create an Ogre material from material asset " +
source->GetId());
return false;
}
// Now go through all the texturenames and restore \ back to / and @ to :
Ogre::Material::TechniqueIterator iter = ogre_material_->getTechniqueIterator();
while (iter.hasMoreElements())
{
Ogre::Technique *tech = iter.getNext();
Ogre::Technique::PassIterator passIter = tech->getPassIterator();
while (passIter.hasMoreElements())
{
Ogre::Pass *pass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator texIter = pass->getTextureUnitStateIterator();
while (texIter.hasMoreElements())
{
Ogre::TextureUnitState *texUnit = texIter.getNext();
std::string texname = texUnit->getTextureName();
if (texname.find('\\') != std::string::npos)
{
ReplaceCharInplace(texname, '\\', '/');
ReplaceCharInplace(texname, '@', ':');
texUnit->setTextureName(texname);
}
}
}
}
//workaround: if receives shadows, check the amount of shadowmaps. If only 1 specified, add 2 more to support 3 shadowmaps
if(ogre_material_->getReceiveShadows() && shadowquality_ == Shadows_High && ogre_material_->getNumTechniques() > 0)
{
Ogre::Technique *tech = ogre_material_->getTechnique(0);
if(tech)
{
Ogre::Technique::PassIterator passiterator = tech->getPassIterator();
while(passiterator.hasMoreElements())
{
Ogre::Pass* pass = passiterator.getNext();
Ogre::Pass::TextureUnitStateIterator texiterator = pass->getTextureUnitStateIterator();
int shadowmaps = 0;
while(texiterator.hasMoreElements())
{
Ogre::TextureUnitState* state = texiterator.getNext();
if(state->getContentType() == Ogre::TextureUnitState::CONTENT_SHADOW)
{
shadowmaps++;
}
}
if(shadowmaps>0 && shadowmaps<3)
{
Ogre::TextureUnitState* sm2 = pass->createTextureUnitState();
sm2->setContentType(Ogre::TextureUnitState::CONTENT_SHADOW);
Ogre::TextureUnitState* sm3 = pass->createTextureUnitState();
sm3->setContentType(Ogre::TextureUnitState::CONTENT_SHADOW);
}
}
}
}
} catch (Ogre::Exception &e)
{
OgreRenderingModule::LogWarning(e.what());
OgreRenderingModule::LogWarning("Failed to parse Ogre material " + source->GetId() + ".");
try
{
if (!matmgr.getByName(tempname).isNull())
Ogre::MaterialManager::getSingleton().remove(tempname);
}
catch (...) {}
return false;
}
return true;
}
bool OgreMaterialProperties::CreateProperties()
{
Ogre::MaterialPtr matPtr = material_->GetMaterial();
if (matPtr.isNull())
return false;
// Material
Ogre::Material::TechniqueIterator tIter = matPtr->getTechniqueIterator();
while(tIter.hasMoreElements())
{
// Technique
Ogre::Technique *tech = tIter.getNext();
Ogre::Technique::PassIterator pIter = tech->getPassIterator();
while(pIter.hasMoreElements())
{
// Pass
Ogre::Pass *pass = pIter.getNext();
if (!pass)
continue;
if(pass->hasVertexProgram())
{
// Vertex program
const Ogre::GpuProgramPtr &verProg = pass->getVertexProgram();
if (!verProg.isNull())
{
Ogre::GpuProgramParametersSharedPtr verPtr = pass->getVertexProgramParameters();
if (verPtr->hasNamedParameters())
{
// Named parameters (constants)
Ogre::GpuConstantDefinitionIterator mapIter = verPtr->getConstantDefinitionIterator();
while(mapIter.hasMoreElements())
{
QString paramName = mapIter.peekNextKey().c_str();
const Ogre::GpuConstantDefinition ¶mDef = mapIter.getNext();
// Filter names that end with '[0]'
int found = paramName.indexOf("[0]");
if (found != -1)
continue;
// Ignore auto parameters
bool is_auto_param = false;
Ogre::GpuProgramParameters::AutoConstantIterator autoConstIter = verPtr->getAutoConstantIterator();
while(autoConstIter.hasMoreElements())
{
Ogre::GpuProgramParameters::AutoConstantEntry autoConstEnt = autoConstIter.getNext();
if (autoConstEnt.physicalIndex == paramDef.physicalIndex)
{
is_auto_param = true;
break;
}
}
if (is_auto_param)
continue;
if (!paramDef.isFloat())
continue;
size_t count = paramDef.elementSize * paramDef.arraySize;
QVector<float> paramValue;
QVector<float>::iterator iter;
paramValue.resize(count);
verPtr->_readRawConstants(paramDef.physicalIndex, count, &*paramValue.begin());
QTextStream vector_string;
QString string;
vector_string.setString(&string, QIODevice::WriteOnly);
for(iter = paramValue.begin(); iter != paramValue.end(); ++iter)
vector_string << *iter << " ";
// Add QPROPERTY. Add to "VP" to the end of the parameter name in order to identify VP parameters.
QMap<QString, QVariant> typeValuePair;
typeValuePair[GpuConstantTypeToString(paramDef.constType)] = *vector_string.string();
setProperty(paramName.append(" VP").toLatin1(), QVariant(typeValuePair));
}
}
}
}
if(pass->hasFragmentProgram())
{
// Fragment program
const Ogre::GpuProgramPtr fragProg = pass->getFragmentProgram();
if (!fragProg.isNull())
{
Ogre::GpuProgramParametersSharedPtr fragPtr = pass->getFragmentProgramParameters();
if (!fragPtr.isNull())
{
if (fragPtr->hasNamedParameters())
{
// Named parameters (constants)
Ogre::GpuConstantDefinitionIterator mapIter = fragPtr->getConstantDefinitionIterator();
while(mapIter.hasMoreElements())
{
QString paramName = mapIter.peekNextKey().c_str();
const Ogre::GpuConstantDefinition ¶mDef = mapIter.getNext();
// Filter names that end with '[0]'
int found = paramName.indexOf("[0]");
if (found != -1)
continue;
// Ignore auto parameters
bool is_auto_param = false;
Ogre::GpuProgramParameters::AutoConstantIterator autoConstIter = fragPtr->getAutoConstantIterator();
while(autoConstIter.hasMoreElements())
{
Ogre::GpuProgramParameters::AutoConstantEntry autoConstEnt = autoConstIter.getNext();
if (autoConstEnt.physicalIndex == paramDef.physicalIndex)
{
is_auto_param = true;
break;
}
}
if (is_auto_param)
continue;
if (!paramDef.isFloat())
continue;
size_t count = paramDef.elementSize * paramDef.arraySize;
QVector<float> paramValue;
QVector<float>::iterator iter;
paramValue.resize(count);
fragPtr->_readRawConstants(paramDef.physicalIndex, count, &*paramValue.begin());
QTextStream vector_string;
QString string;
vector_string.setString(&string, QIODevice::WriteOnly);
for(iter = paramValue.begin(); iter != paramValue.end(); ++iter)
vector_string << *iter << " ";
// Add QPROPERTY. Add to " FP" to the end of the parameter name in order to identify FP parameters
TypeValuePair typeValuePair;
typeValuePair[GpuConstantTypeToString(paramDef.constType)] = *vector_string.string();
setProperty(paramName.append(" FP").toLatin1(), QVariant(typeValuePair));
}
}
}
}
}
Ogre::Pass::TextureUnitStateIterator texIter = pass->getTextureUnitStateIterator();
while(texIter.hasMoreElements())
{
// Texture units
const Ogre::TextureUnitState *tu = texIter.getNext();
// Don't insert tu's with empty texture names (i.e. shadowMap)
// add to " TU" to the end of the parameter name in order to identify texture units.
if(tu->getTextureName().size() > 0)
{
QString tuName(tu->getName().c_str());
// Add QPROPERTY
TypeValuePair typeValuePair;
typeValuePair[TextureTypeToString(tu->getTextureType())] = tu->getTextureName().c_str();
setProperty(tuName.append(" TU").toLatin1(), typeValuePair);
}
}
}
}
return true;
}
Ogre::MaterialPtr OgreMaterialProperties::ToOgreMaterial()
{
// Make clone from the original and uset that for creating the new material.
Ogre::MaterialPtr matPtr = material_->GetMaterial();
Ogre::MaterialPtr matPtrClone = matPtr->clone(objectName().toStdString() + "Clone");
// Material
if (!matPtrClone.isNull())
{
// Technique
Ogre::Material::TechniqueIterator tIter = matPtrClone->getTechniqueIterator();
while(tIter.hasMoreElements())
{
Ogre::Technique *tech = tIter.getNext();
Ogre::Technique::PassIterator pIter = tech->getPassIterator();
while(pIter.hasMoreElements())
{
// Pass
Ogre::Pass *pass = pIter.getNext();
if (!pass)
continue;
if (pass->hasVertexProgram())
{
// Vertex program
const Ogre::GpuProgramPtr &verProg = pass->getVertexProgram();
if (!verProg.isNull())
{
Ogre::GpuProgramParametersSharedPtr verPtr = pass->getVertexProgramParameters();
if (verPtr->hasNamedParameters())
{
// Named parameters (constants)
Ogre::GpuConstantDefinitionIterator mapIter = verPtr->getConstantDefinitionIterator();
int constNum = 0;
while(mapIter.hasMoreElements())
{
QString paramName(mapIter.peekNextKey().c_str());
const Ogre::GpuConstantDefinition ¶mDef = mapIter.getNext();
// Filter names that end with '[0]'
if (paramName.lastIndexOf("[0]") != -1)
continue;
if (!paramDef.isFloat())
continue;
size_t size = paramDef.elementSize * paramDef.arraySize;
QVector<float> newParamValue;
QVector<float>::iterator it;
newParamValue.resize(size);
// Find the corresponding property value.
QVariant val = property(paramName.append(" VP").toLatin1());
if (!val.isValid() || val.isNull())
continue;
TypeValuePair typeValuePair = val.toMap();
QString newValueString(typeValuePair.begin().value().toByteArray());
newValueString.trimmed();
// fill the float vector with new values
it = newParamValue.begin();
int i = 0, j = 0;
bool ok = true;
while(j != -1 && ok)
{
j = newValueString.indexOf(' ', i);
QString newValue = newValueString.mid(i, j == -1 ? j : j - i);
if (!newValue.isEmpty())
{
*it = newValue.toFloat(&ok);
++it;
}
i = j + 1;
}
// Set the new value.
///\todo use the exact count rather than just 4 values if needed.
if (size == 16)
{
Ogre::Matrix4 matrix(newParamValue[0], newParamValue[1], newParamValue[2], newParamValue[3],
newParamValue[4], newParamValue[5], newParamValue[6], newParamValue[7],
newParamValue[8], newParamValue[9], newParamValue[10], newParamValue[11],
newParamValue[12], newParamValue[13], newParamValue[14], newParamValue[15]);
#if OGRE_VERSION_MINOR <= 6 && OGRE_VERSION_MAJOR <= 1
verPtr->_writeRawConstant(paramDef.physicalIndex, matrix);
#else
verPtr->_writeRawConstant(paramDef.physicalIndex, matrix, size);
#endif
}
else
{
Ogre::Vector4 vector(newParamValue[0], newParamValue[1], newParamValue[2], newParamValue[3]);
verPtr->_writeRawConstant(paramDef.physicalIndex, vector);
}
}
}
}
}
if (pass->hasFragmentProgram())
{
// Fragment program
const Ogre::GpuProgramPtr &fragProg = pass->getFragmentProgram();
if (!fragProg.isNull())
{
Ogre::GpuProgramParametersSharedPtr fragPtr = pass->getFragmentProgramParameters();
if (!fragPtr.isNull())
{
if (fragPtr->hasNamedParameters())
{
// Named parameters (constants)
Ogre::GpuConstantDefinitionIterator mapIter = fragPtr->getConstantDefinitionIterator();
while(mapIter.hasMoreElements())
{
QString paramName(mapIter.peekNextKey().c_str());
const Ogre::GpuConstantDefinition ¶mDef = mapIter.getNext();
// Filter names that end with '[0]'
if (paramName.lastIndexOf("[0]") != -1)
continue;
if (!paramDef.isFloat())
continue;
size_t size = paramDef.elementSize * paramDef.arraySize;
QVector<float> newParamValue;
QVector<float>::iterator it;
newParamValue.resize(size);
// Find the corresponding property value.
QVariant val = property(paramName.append(" FP").toLatin1());
if (!val.isValid() || val.isNull())
continue;
TypeValuePair typeValuePair = val.toMap();
QString newValueString(typeValuePair.begin().value().toByteArray());
newValueString.trimmed();
// Fill the float vector with new values.
it = newParamValue.begin();
int i = 0, j = 0;
bool ok = true;
while(j != -1 && ok)
{
j = newValueString.indexOf(' ', i);
QString newValue = newValueString.mid(i, j == -1 ? j : j - i);
if (!newValue.isEmpty())
{
*it = *it = newValue.toFloat(&ok);
++it;
}
i = j + 1;
}
// Set the new value.
///\todo use the exact count rather than just 4 values if needed.
if (size == 16)
{
Ogre::Matrix4 matrix(newParamValue[0], newParamValue[1], newParamValue[2], newParamValue[3],
newParamValue[4], newParamValue[5], newParamValue[6], newParamValue[7],
newParamValue[8], newParamValue[9], newParamValue[10], newParamValue[11],
newParamValue[12], newParamValue[13], newParamValue[14], newParamValue[15]);
#if OGRE_VERSION_MINOR <= 6 && OGRE_VERSION_MAJOR <= 1
fragPtr->_writeRawConstant(paramDef.physicalIndex, matrix);
#else
fragPtr->_writeRawConstant(paramDef.physicalIndex, matrix, size);
#endif
}
else
{
Ogre::Vector4 vector(newParamValue[0], newParamValue[1], newParamValue[2], newParamValue[3]);
fragPtr->_writeRawConstant(paramDef.physicalIndex, vector);
}
}
}
}
}
}
Ogre::Pass::TextureUnitStateIterator texIter = pass->getTextureUnitStateIterator();
while(texIter.hasMoreElements())
{
// Texture units
Ogre::TextureUnitState *tu = texIter.getNext();
// Replace the texture name (uuid) with the new one
QString tu_name(tu->getName().c_str());
QVariant val = property(tu_name.append(" TU").toLatin1());
if (!val.isValid() || val.isNull())
continue;
TypeValuePair typeValuePair = val.toMap();
QString newValueString(typeValuePair.begin().value().toByteArray());
newValueString.trimmed();
tu->setTextureName(newValueString.toStdString());
/*
//QString new_texture_name = iter->second;
RexUUID new_name(iter->second);
// If new texture is UUID-based one, make sure the corresponding RexOgreTexture gets created,
// because we may not be able to load it later if load fails now
if (RexUUID::IsValid(new_texture_name))
{
RexUUID imageID(new_texture_name);
if (!imageID.IsNull())
{
image* image = imageList.getImage(imageID);
if (image)
{
image->getOgreTexture();
}
}
}
//tu->setTextureName(iter->second);
*/
}
}
}
return matPtrClone;
}
matPtrClone.setNull();
return matPtrClone;
}
//-----------------------------------------------------------------------
void TerrainLiquidObject::_prepareProjector(void)
{
if (mProjectorName.empty() || !mProjectorSize)
return;
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(mMaterialName);
if (material.isNull())
return;
bool hasProjector = false;
{
Ogre::Material::TechniqueIterator ti = material->getTechniqueIterator();
while (ti.hasMoreElements())
{
Ogre::Technique* technique = ti.getNext();
Ogre::Technique::PassIterator pi = technique->getPassIterator();
while (pi.hasMoreElements())
{
Ogre::Pass* pass = pi.getNext();
Ogre::Pass::TextureUnitStateIterator tusi = pass->getTextureUnitStateIterator();
while (tusi.hasMoreElements())
{
Ogre::TextureUnitState* tus = tusi.getNext();
if (Ogre::StringUtil::startsWith(tus->getName(), "Fairy/Projector", false))
{
hasProjector = true;
}
}
}
}
}
if (!hasProjector)
return;
ObjectPtr object = mSystem->getSceneInfo()->findObjectByName(mProjectorName);
if (!object)
return;
Variant directionValue = object->getProperty("direction");
if (directionValue.empty() || directionValue.type() != typeid(Ogre::Vector3))
return;
Ogre::Vector3 direction = VariantCast<Ogre::Vector3>(directionValue);
direction.normalise();
Ogre::String name = material->getName() + Ogre::StringConverter::toString((Ogre::ulong)this);
mProjectionCamera = mTerrainLiquid->getParentSceneNode()->getCreator()->createCamera(name);
mProjectionCamera->setAutoAspectRatio(false);
mProjectionCamera->setAspectRatio(1.0f);
mProjectionCamera->setFixedYawAxis(false);
mProjectionCamera->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
mProjectionCamera->setFOVy(Ogre::Degree(90));
mProjectionCamera->setDirection(-direction);
mProjectionCamera->setNearClipDistance(mProjectorSize / 2);
mProjectionCamera->setFarClipDistance(mProjectorSize + 5000.0f);
mTerrainLiquid->setProjectionCamera(mProjectionCamera);
mProjectionMaterial = material->clone(name);
{
Ogre::Material::TechniqueIterator ti = mProjectionMaterial->getTechniqueIterator();
while (ti.hasMoreElements())
{
Ogre::Technique* technique = ti.getNext();
Ogre::Technique::PassIterator pi = technique->getPassIterator();
while (pi.hasMoreElements())
{
Ogre::Pass* pass = pi.getNext();
Ogre::Pass::TextureUnitStateIterator tusi = pass->getTextureUnitStateIterator();
while (tusi.hasMoreElements())
{
Ogre::TextureUnitState* tus = tusi.getNext();
if (Ogre::StringUtil::startsWith(tus->getName(), "Fairy/Projector", false))
{
tus->setProjectiveTexturing(true, mProjectionCamera);
}
}
}
}
}
mProjectionMaterial->load();
}
void BatchPage::_updateShaders()
{
if (!shadersSupported)
return;
uint32 i = 0;
BatchedGeometry::SubBatchIterator it = batch->getSubBatchIterator();
while (it.hasMoreElements()){
BatchedGeometry::SubBatch *subBatch = it.getNext();
MaterialPtr mat = unfadedMaterials[i++];
//Check if lighting should be enabled
bool lightingEnabled = false;
for (unsigned short t = 0; t < mat->getNumTechniques(); ++t){
Technique *tech = mat->getTechnique(t);
for (unsigned short p = 0; p < tech->getNumPasses(); ++p){
Pass *pass = tech->getPass(p);
if (pass->getLightingEnabled()) {
lightingEnabled = true;
break;
}
}
if (lightingEnabled)
break;
}
//Compile the CG shader script based on various material / fade options
StringUtil::StrStreamType tmpName;
tmpName << "BatchPage_";
if (fadeEnabled)
tmpName << "fade_";
if (lightingEnabled)
tmpName << "lit_";
if (subBatch->vertexData->vertexDeclaration->findElementBySemantic(VES_DIFFUSE) != NULL)
tmpName << "clr_";
for (unsigned short i = 0; i < subBatch->vertexData->vertexDeclaration->getElementCount(); ++i)
{
const VertexElement *el = subBatch->vertexData->vertexDeclaration->getElement(i);
if (el->getSemantic() == VES_TEXTURE_COORDINATES) {
String uvType = "";
switch (el->getType()) {
case VET_FLOAT1: uvType = "1"; break;
case VET_FLOAT2: uvType = "2"; break;
case VET_FLOAT3: uvType = "3"; break;
case VET_FLOAT4: uvType = "4"; break;
}
tmpName << uvType << '_';
}
}
tmpName << "vp";
const String vertexProgName = tmpName.str();
String shaderLanguage = ShaderHelper::getShaderLanguage();
//If the shader hasn't been created yet, create it
if (HighLevelGpuProgramManager::getSingleton().getByName(vertexProgName).isNull())
{
Pass *pass = mat->getTechnique(0)->getPass(0);
String vertexProgSource;
if(!shaderLanguage.compare("hlsl") || !shaderLanguage.compare("cg"))
{
vertexProgSource =
"void main( \n"
" float4 iPosition : POSITION, \n"
" float3 normal : NORMAL, \n"
" out float4 oPosition : POSITION, \n";
if (subBatch->vertexData->vertexDeclaration->findElementBySemantic(VES_DIFFUSE) != NULL) vertexProgSource +=
" float4 iColor : COLOR, \n";
unsigned texNum = 0;
for (unsigned short i = 0; i < subBatch->vertexData->vertexDeclaration->getElementCount(); ++i) {
const VertexElement *el = subBatch->vertexData->vertexDeclaration->getElement(i);
if (el->getSemantic() == VES_TEXTURE_COORDINATES) {
String uvType = "";
switch (el->getType()) {
case VET_FLOAT1: uvType = "float"; break;
case VET_FLOAT2: uvType = "float2"; break;
case VET_FLOAT3: uvType = "float3"; break;
case VET_FLOAT4: uvType = "float4"; break;
}
vertexProgSource +=
" " + uvType + " iUV" + StringConverter::toString(texNum) + " : TEXCOORD" + StringConverter::toString(texNum) + ", \n"
" out " + uvType + " oUV" + StringConverter::toString(texNum) + " : TEXCOORD" + StringConverter::toString(texNum) + ", \n";
++texNum;
}
}
vertexProgSource +=
" out float oFog : FOG, \n"
" out float4 oColor : COLOR, \n"
" uniform float4 iFogParams, \n";
if (lightingEnabled) vertexProgSource +=
" uniform float4 objSpaceLight, \n"
" uniform float4 lightDiffuse, \n"
" uniform float4 lightAmbient, \n";
if (fadeEnabled) vertexProgSource +=
" uniform float3 camPos, \n";
vertexProgSource +=
" uniform float4x4 worldViewProj, \n"
" uniform float fadeGap, \n"
" uniform float invisibleDist )\n"
"{ \n";
if (lightingEnabled) {
//Perform lighting calculations (no specular)
vertexProgSource +=
" float3 light = normalize(objSpaceLight.xyz - (iPosition.xyz * objSpaceLight.w)); \n"
" float diffuseFactor = max(dot(normal, light), 0); \n";
if (subBatch->vertexData->vertexDeclaration->findElementBySemantic(VES_DIFFUSE) != NULL)
vertexProgSource += "oColor = (lightAmbient + diffuseFactor * lightDiffuse) * iColor; \n";
else
vertexProgSource += "oColor = (lightAmbient + diffuseFactor * lightDiffuse); \n";
} else {
if (subBatch->vertexData->vertexDeclaration->findElementBySemantic(VES_DIFFUSE) != NULL)
vertexProgSource += "oColor = iColor; \n";
else
vertexProgSource += "oColor = float4(1, 1, 1, 1); \n";
}
if (fadeEnabled) vertexProgSource +=
//Fade out in the distance
" float dist = distance(camPos.xz, iPosition.xz); \n"
" oColor.a *= (invisibleDist - dist) / fadeGap; \n";
texNum = 0;
for (unsigned short i = 0; i < subBatch->vertexData->vertexDeclaration->getElementCount(); ++i) {
const VertexElement *el = subBatch->vertexData->vertexDeclaration->getElement(i);
if (el->getSemantic() == VES_TEXTURE_COORDINATES) {
vertexProgSource +=
" oUV" + StringConverter::toString(texNum) + " = iUV" + StringConverter::toString(texNum) + "; \n";
++texNum;
}
}
vertexProgSource +=
" oPosition = mul(worldViewProj, iPosition); \n";
if (sceneMgr->getFogMode() == Ogre::FOG_EXP2) {
vertexProgSource +=
" oFog = 1 - clamp (pow (2.71828, -oPosition.z * iFogParams.x), 0, 1); \n";
} else {
vertexProgSource +=
" oFog = oPosition.z; \n";
}
vertexProgSource += "}";
}
if(!shaderLanguage.compare("glsl"))
{
vertexProgSource =
"uniform float fadeGap; \n"
"uniform float invisibleDist; \n";
if (lightingEnabled) vertexProgSource +=
"uniform vec4 objSpaceLight; \n"
"uniform vec4 lightDiffuse; \n"
"uniform vec4 lightAmbient; \n";
if (fadeEnabled) vertexProgSource +=
"uniform vec3 camPos; \n";
vertexProgSource +=
"void main() \n"
"{ \n";
if (lightingEnabled)
{
//Perform lighting calculations (no specular)
vertexProgSource +=
" vec3 light = normalize(objSpaceLight.xyz - (gl_Vertex.xyz * objSpaceLight.w)); \n"
" float diffuseFactor = max(dot(gl_Normal, light), 0.0); \n";
if (subBatch->vertexData->vertexDeclaration->findElementBySemantic(VES_DIFFUSE) != NULL)
{
vertexProgSource += " gl_FrontColor = (lightAmbient + diffuseFactor * lightDiffuse) * gl_Color; \n";
}
else
{
vertexProgSource += " gl_FrontColor = (lightAmbient + diffuseFactor * lightDiffuse); \n";
}
}
else
{
if (subBatch->vertexData->vertexDeclaration->findElementBySemantic(VES_DIFFUSE) != NULL)
{
vertexProgSource += " gl_FrontColor = gl_Color; \n";
}
else
{
vertexProgSource += " gl_FrontColor = vec4(1.0, 1.0, 1.0, 1.0); \n";
}
}
if (fadeEnabled)
{
vertexProgSource +=
//Fade out in the distance
" float dist = distance(camPos.xz, gl_Vertex.xz); \n"
" gl_FrontColor.a *= (invisibleDist - dist) / fadeGap; \n";
}
unsigned texNum = 0;
for (unsigned short i = 0; i < subBatch->vertexData->vertexDeclaration->getElementCount(); ++i)
{
const VertexElement *el = subBatch->vertexData->vertexDeclaration->getElement(i);
if (el->getSemantic() == VES_TEXTURE_COORDINATES)
{
vertexProgSource +=
" gl_TexCoord[" + StringConverter::toString(texNum) + "] = gl_MultiTexCoord" + StringConverter::toString(texNum) + "; \n";
++texNum;
}
}
vertexProgSource +=
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; \n";
if (sceneMgr->getFogMode() == Ogre::FOG_EXP2) {
vertexProgSource +=
" gl_FogFragCoord = clamp(exp(- gl_Fog.density * gl_Fog.density * gl_Position.z * gl_Position.z), 0.0, 1.0); \n";
} else {
vertexProgSource +=
" gl_FogFragCoord = gl_Position.z; \n";
}
vertexProgSource += "}";
}
HighLevelGpuProgramPtr vertexShader = HighLevelGpuProgramManager::getSingleton().createProgram(
vertexProgName,
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
shaderLanguage, GPT_VERTEX_PROGRAM);
vertexShader->setSource(vertexProgSource);
if (shaderLanguage == "hlsl")
{
vertexShader->setParameter("target", "vs_1_1");
vertexShader->setParameter("entry_point", "main");
}
else if(shaderLanguage == "cg")
{
vertexShader->setParameter("profiles", "vs_1_1 arbvp1");
vertexShader->setParameter("entry_point", "main");
}
// GLSL can only have one entry point "main".
vertexShader->load();
if (vertexShader->hasCompileError()) {
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Error loading the batching vertex shader.", "BatchPage::_updateShaders()");
}
}
std::string fragmentProgramName("BatchFragStandard");
String fragmentProgSource;
//We also need a fragment program to go with our vertex program. Especially on ATI cards on Linux where we can't mix shaders and the fixed function pipeline.
HighLevelGpuProgramPtr fragShader = static_cast<HighLevelGpuProgramPtr>(HighLevelGpuProgramManager::getSingleton().getByName(fragmentProgramName));
if (fragShader.isNull()){
Pass *pass = mat->getTechnique(0)->getPass(0);
if (shaderLanguage == "glsl") {
fragmentProgSource = "uniform sampler2D diffuseMap;\n"
"void main() {"
" gl_FragColor = texture2D(diffuseMap, gl_TexCoord[0].st);"
" gl_FragColor.rgb = mix(gl_Fog.color, (gl_LightModel.ambient * gl_FragColor + gl_FragColor), gl_FogFragCoord).rgb;"
"}";
} else {
fragmentProgSource = "void main \n"
"( \n"
" float2 iTexcoord : TEXCOORD0, \n"
" float iFog : FOG, \n"
" out float4 oColour : COLOR, \n"
" uniform sampler2D diffuseTexture : TEXUNIT0, \n"
" uniform float3 iFogColour \n"
") \n"
"{ \n"
" oColour = tex2D(diffuseTexture, iTexcoord.xy); \n"
" oColour.xyz = lerp(oColour.xyz, iFogColour, iFog);\n"
"}";
}
fragShader = HighLevelGpuProgramManager::getSingleton().createProgram(
fragmentProgramName,
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
shaderLanguage, GPT_FRAGMENT_PROGRAM);
fragShader->setSource(fragmentProgSource);
if (shaderLanguage == "hlsl") {
fragShader->setParameter("entry_point", "main");
fragShader->setParameter("target", "ps_2_0");
} else if (shaderLanguage == "cg") {
fragShader->setParameter("profiles", "ps_2_0 arbfp1");
fragShader->setParameter("entry_point", "main");
}
fragShader->load();
if (fragShader->hasCompileError()) {
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Error loading the batching fragment shader.", "BatchPage::_updateShaders()");
}
}
//Now that the shader is ready to be applied, apply it
StringUtil::StrStreamType materialSignature;
materialSignature << "BatchMat|";
materialSignature << mat->getName() << "|";
if (fadeEnabled){
materialSignature << visibleDist << "|";
materialSignature << invisibleDist << "|";
}
//Search for the desired material
MaterialPtr generatedMaterial = MaterialManager::getSingleton().getByName(materialSignature.str());
if (generatedMaterial.isNull()){
//Clone the material
generatedMaterial = mat->clone(materialSignature.str());
//And apply the fade shader
Ogre::Material::TechniqueIterator I = generatedMaterial->getSupportedTechniqueIterator();
while (I.hasMoreElements()) {
Technique *tech = I.getNext();
for (unsigned short p = 0; p < tech->getNumPasses(); ++p){
Pass *pass = tech->getPass(p);
//Setup vertex program
if (pass->getVertexProgramName() == "")
pass->setVertexProgram(vertexProgName);
if (pass->getFragmentProgramName() == "" && fragShader->isSupported())
pass->setFragmentProgram(fragmentProgramName);
try{
GpuProgramParametersSharedPtr params = pass->getVertexProgramParameters();
params->setIgnoreMissingParams(true);
if (lightingEnabled) {
params->setNamedAutoConstant("objSpaceLight", GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE);
params->setNamedAutoConstant("lightDiffuse", GpuProgramParameters::ACT_DERIVED_LIGHT_DIFFUSE_COLOUR);
params->setNamedAutoConstant("lightAmbient", GpuProgramParameters::ACT_DERIVED_AMBIENT_LIGHT_COLOUR);
//params->setNamedAutoConstant("matAmbient", GpuProgramParameters::ACT_SURFACE_AMBIENT_COLOUR);
}
if (shaderLanguage.compare("glsl") == 0) {
//glsl can use the built in gl_ModelViewProjectionMatrix
params->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
} else {
params->setNamedAutoConstant("iFogParams", GpuProgramParameters::ACT_FOG_PARAMS);
}
if (fadeEnabled)
{
params->setNamedAutoConstant("camPos", GpuProgramParameters::ACT_CAMERA_POSITION_OBJECT_SPACE);
//Set fade ranges
params->setNamedAutoConstant("invisibleDist", GpuProgramParameters::ACT_CUSTOM);
params->setNamedConstant("invisibleDist", invisibleDist);
params->setNamedAutoConstant("fadeGap", GpuProgramParameters::ACT_CUSTOM);
params->setNamedConstant("fadeGap", invisibleDist - visibleDist);
if (pass->getAlphaRejectFunction() == CMPF_ALWAYS_PASS)
pass->setSceneBlending(SBT_TRANSPARENT_ALPHA);
}
if (pass->hasFragmentProgram()) {
params = pass->getFragmentProgramParameters();
params->setIgnoreMissingParams(true);
params->setNamedAutoConstant("iFogColour", GpuProgramParameters::ACT_FOG_COLOUR);
}
}
catch (...) {
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Error configuring batched geometry transitions. If you're using materials with custom vertex shaders, they will need to implement fade transitions to be compatible with BatchPage.", "BatchPage::_updateShaders()");
}
}
}
}
//Apply the material
subBatch->setMaterial(generatedMaterial);
}
}
bool ModelBackgroundLoader::poll(const TimeFrame& timeFrame)
{
#if OGRE_THREAD_SUPPORT
if (mState == LS_UNINITIALIZED) {
//Start to load the meshes
for (SubModelDefinitionsStore::const_iterator I_subModels = mModel.getDefinition()->getSubModelDefinitions().begin(); I_subModels != mModel.getDefinition()->getSubModelDefinitions().end(); ++I_subModels) {
Ogre::MeshPtr meshPtr = static_cast<Ogre::MeshPtr> (Ogre::MeshManager::getSingleton().getByName((*I_subModels)->getMeshName()));
if (meshPtr.isNull() || !meshPtr->isPrepared()) {
try {
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().prepare(Ogre::MeshManager::getSingleton().getResourceType(), (*I_subModels)->getMeshName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
addTicket(ticket);
}
} catch (const std::exception& ex) {
S_LOG_FAILURE("Could not load the mesh " << (*I_subModels)->getMeshName() << " when loading model " << mModel.getName() << "." << ex);
continue;
}
}
}
mState = LS_MESH_PREPARING;
return poll(timeFrame);
} else if (mState == LS_MESH_PREPARING) {
if (areAllTicketsProcessed()) {
mState = LS_MESH_PREPARED;
return poll(timeFrame);
}
} else if (mState == LS_MESH_PREPARED) {
for (SubModelDefinitionsStore::const_iterator I_subModels = mModel.getDefinition()->getSubModelDefinitions().begin(); I_subModels != mModel.getDefinition()->getSubModelDefinitions().end(); ++I_subModels) {
Ogre::MeshPtr meshPtr = static_cast<Ogre::MeshPtr> (Ogre::MeshManager::getSingleton().getByName((*I_subModels)->getMeshName()));
if (!meshPtr.isNull()) {
if (!meshPtr->isLoaded()) {
#if OGRE_THREAD_SUPPORT == 1
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(Ogre::MeshManager::getSingleton().getResourceType(), meshPtr->getName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
// meshPtr->setBackgroundLoaded(true);
addTicket(ticket);
}
#else
if (!timeFrame.isTimeLeft()) {
return false;
}
try {
meshPtr->load();
} catch (const std::exception& ex) {
S_LOG_FAILURE("Could not load the mesh " << meshPtr->getName() << " when loading model " << mModel.getName() << "." << ex);
continue;
}
#endif
}
}
}
mState = LS_MESH_LOADING;
return poll(timeFrame);
} else if (mState == LS_MESH_LOADING) {
if (areAllTicketsProcessed()) {
mState = LS_MESH_LOADED;
return poll(timeFrame);
}
} else if (mState == LS_MESH_LOADED) {
for (SubModelDefinitionsStore::const_iterator I_subModels = mModel.getDefinition()->getSubModelDefinitions().begin(); I_subModels != mModel.getDefinition()->getSubModelDefinitions().end(); ++I_subModels) {
Ogre::MeshPtr meshPtr = static_cast<Ogre::MeshPtr> (Ogre::MeshManager::getSingleton().getByName((*I_subModels)->getMeshName()));
if (!meshPtr.isNull()) {
if (meshPtr->isLoaded()) {
Ogre::Mesh::SubMeshIterator subMeshI = meshPtr->getSubMeshIterator();
while (subMeshI.hasMoreElements()) {
Ogre::SubMesh* submesh(subMeshI.getNext());
Ogre::MaterialPtr materialPtr = static_cast<Ogre::MaterialPtr> (Ogre::MaterialManager::getSingleton().getByName(submesh->getMaterialName()));
if (materialPtr.isNull() || !materialPtr->isPrepared()) {
// S_LOG_VERBOSE("Preparing material " << materialPtr->getName());
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().prepare(Ogre::MaterialManager::getSingleton().getResourceType(),submesh->getMaterialName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
addTicket(ticket);
}
}
}
}
}
for (PartDefinitionsStore::const_iterator I_parts = (*I_subModels)->getPartDefinitions().begin(); I_parts != (*I_subModels)->getPartDefinitions().end(); ++I_parts) {
if ((*I_parts)->getSubEntityDefinitions().size() > 0) {
for (SubEntityDefinitionsStore::const_iterator I_subEntities = (*I_parts)->getSubEntityDefinitions().begin(); I_subEntities != (*I_parts)->getSubEntityDefinitions().end(); ++I_subEntities) {
const std::string& materialName = (*I_subEntities)->getMaterialName();
if (materialName != "") {
Ogre::MaterialPtr materialPtr = static_cast<Ogre::MaterialPtr> (Ogre::MaterialManager::getSingleton().getByName(materialName));
if (materialPtr.isNull() || !materialPtr->isPrepared()) {
// S_LOG_VERBOSE("Preparing material " << materialName);
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().prepare(Ogre::MaterialManager::getSingleton().getResourceType(), materialName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
addTicket(ticket);
}
}
}
}
}
}
}
mState = LS_MATERIAL_PREPARING;
return poll(timeFrame);
} else if (mState == LS_MATERIAL_PREPARING) {
if (areAllTicketsProcessed()) {
mState = LS_MATERIAL_PREPARED;
return poll(timeFrame);
}
} else if (mState == LS_MATERIAL_PREPARED) {
for (SubModelDefinitionsStore::const_iterator I_subModels = mModel.getDefinition()->getSubModelDefinitions().begin(); I_subModels != mModel.getDefinition()->getSubModelDefinitions().end(); ++I_subModels) {
Ogre::MeshPtr meshPtr = static_cast<Ogre::MeshPtr> (Ogre::MeshManager::getSingleton().getByName((*I_subModels)->getMeshName()));
Ogre::Mesh::SubMeshIterator subMeshI = meshPtr->getSubMeshIterator();
while (subMeshI.hasMoreElements()) {
Ogre::SubMesh* submesh(subMeshI.getNext());
Ogre::MaterialPtr materialPtr = static_cast<Ogre::MaterialPtr> (Ogre::MaterialManager::getSingleton().getByName(submesh->getMaterialName()));
if (!materialPtr.isNull() && !materialPtr->isLoaded()) {
#if OGRE_THREAD_SUPPORT == 1
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(Ogre::MaterialManager::getSingleton().getResourceType(), materialPtr->getName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
// materialPtr->setBackgroundLoaded(true);
addTicket(ticket);
}
#else
Ogre::Material::TechniqueIterator techIter = materialPtr->getSupportedTechniqueIterator();
while (techIter.hasMoreElements()) {
Ogre::Technique* tech = techIter.getNext();
Ogre::Technique::PassIterator passIter = tech->getPassIterator();
while (passIter.hasMoreElements()) {
Ogre::Pass* pass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator tusIter = pass->getTextureUnitStateIterator();
while (tusIter.hasMoreElements()) {
Ogre::TextureUnitState* tus = tusIter.getNext();
unsigned int frames = tus->getNumFrames();
for (unsigned int i = 0; i < frames; ++i) {
if (!timeFrame.isTimeLeft()) {
return false;
}
//This will automatically load the texture.
// S_LOG_VERBOSE("Loading texture " << tus->getTextureName());
Ogre::TexturePtr texturePtr = tus->_getTexturePtr(i);
}
}
}
}
if (!timeFrame.isTimeLeft()) {
return false;
}
// S_LOG_VERBOSE("Loading material " << materialPtr->getName());
materialPtr->load();
#endif
}
}
for (PartDefinitionsStore::const_iterator I_parts = (*I_subModels)->getPartDefinitions().begin(); I_parts != (*I_subModels)->getPartDefinitions().end(); ++I_parts) {
if ((*I_parts)->getSubEntityDefinitions().size() > 0) {
for (SubEntityDefinitionsStore::const_iterator I_subEntities = (*I_parts)->getSubEntityDefinitions().begin(); I_subEntities != (*I_parts)->getSubEntityDefinitions().end(); ++I_subEntities) {
const std::string& materialName = (*I_subEntities)->getMaterialName();
if (materialName != "") {
Ogre::MaterialPtr materialPtr = static_cast<Ogre::MaterialPtr> (Ogre::MaterialManager::getSingleton().getByName(materialName));
if (!materialPtr.isNull() && !materialPtr->isLoaded()) {
#if OGRE_THREAD_SUPPORT == 1
Ogre::BackgroundProcessTicket ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(Ogre::MaterialManager::getSingleton().getResourceType(), materialPtr->getName(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, 0, 0, createListener());
if (ticket) {
addTicket(ticket);
}
#else
Ogre::Material::TechniqueIterator techIter = materialPtr->getSupportedTechniqueIterator();
while (techIter.hasMoreElements()) {
Ogre::Technique* tech = techIter.getNext();
Ogre::Technique::PassIterator passIter = tech->getPassIterator();
while (passIter.hasMoreElements()) {
Ogre::Pass* pass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator tusIter = pass->getTextureUnitStateIterator();
while (tusIter.hasMoreElements()) {
Ogre::TextureUnitState* tus = tusIter.getNext();
unsigned int frames = tus->getNumFrames();
for (unsigned int i = 0; i < frames; ++i) {
if (!timeFrame.isTimeLeft()) {
return false;
}
//This will automatically load the texture.
// S_LOG_VERBOSE("Loading texture " << tus->getTextureName());
Ogre::TexturePtr texturePtr = tus->_getTexturePtr(i);
}
}
}
}
if (!timeFrame.isTimeLeft()) {
return false;
}
// S_LOG_VERBOSE("Loading material " << materialPtr->getName());
materialPtr->load();
#endif
}
}
}
}
}
}
mState = LS_MATERIAL_LOADING;
return poll(timeFrame);
} else if (mState == LS_MATERIAL_LOADING) {
if (areAllTicketsProcessed()) {
mState = LS_DONE;
return true;
}
} else {
return true;
}
return false;
#else
//If there's no threading support, just return here.
return true;
#endif
}
void Objects::insertMesh (const MWWorld::Ptr& ptr, const std::string& mesh)
{
Ogre::SceneNode* insert = ptr.getRefData().getBaseNode();
assert(insert);
Ogre::AxisAlignedBox bounds = Ogre::AxisAlignedBox::BOX_NULL;
NifOgre::EntityList entities = NifOgre::NIFLoader::createEntities(insert, NULL, mesh);
for(size_t i = 0;i < entities.mEntities.size();i++)
{
const Ogre::AxisAlignedBox &tmp = entities.mEntities[i]->getBoundingBox();
bounds.merge(Ogre::AxisAlignedBox(insert->_getDerivedPosition() + tmp.getMinimum(),
insert->_getDerivedPosition() + tmp.getMaximum())
);
}
Ogre::Vector3 extents = bounds.getSize();
extents *= insert->getScale();
float size = std::max(std::max(extents.x, extents.y), extents.z);
bool small = (size < Settings::Manager::getInt("small object size", "Viewing distance")) && Settings::Manager::getBool("limit small object distance", "Viewing distance");
// do not fade out doors. that will cause holes and look stupid
if (ptr.getTypeName().find("Door") != std::string::npos)
small = false;
if (mBounds.find(ptr.getCell()) == mBounds.end())
mBounds[ptr.getCell()] = Ogre::AxisAlignedBox::BOX_NULL;
mBounds[ptr.getCell()].merge(bounds);
bool transparent = false;
for(size_t i = 0;i < entities.mEntities.size();i++)
{
Ogre::Entity *ent = entities.mEntities[i];
for (unsigned int i=0; i<ent->getNumSubEntities(); ++i)
{
Ogre::MaterialPtr mat = ent->getSubEntity(i)->getMaterial();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements())
{
Ogre::Technique* tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{
Ogre::Pass* pass = passIt.getNext();
if (pass->getDepthWriteEnabled() == false)
transparent = true;
}
}
}
}
if(!mIsStatic || !Settings::Manager::getBool("use static geometry", "Objects") || transparent)
{
for(size_t i = 0;i < entities.mEntities.size();i++)
{
Ogre::Entity *ent = entities.mEntities[i];
ent->setRenderingDistance(small ? Settings::Manager::getInt("small object distance", "Viewing distance") : 0);
ent->setVisibilityFlags(mIsStatic ? (small ? RV_StaticsSmall : RV_Statics) : RV_Misc);
ent->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
}
}
else
{
Ogre::StaticGeometry* sg = 0;
if (small)
{
if( mStaticGeometrySmall.find(ptr.getCell()) == mStaticGeometrySmall.end())
{
uniqueID = uniqueID +1;
sg = mRenderer.getScene()->createStaticGeometry( "sg" + Ogre::StringConverter::toString(uniqueID));
mStaticGeometrySmall[ptr.getCell()] = sg;
sg->setRenderingDistance(Settings::Manager::getInt("small object distance", "Viewing distance"));
}
else
sg = mStaticGeometrySmall[ptr.getCell()];
}
else
{
if( mStaticGeometry.find(ptr.getCell()) == mStaticGeometry.end())
{
uniqueID = uniqueID +1;
sg = mRenderer.getScene()->createStaticGeometry( "sg" + Ogre::StringConverter::toString(uniqueID));
mStaticGeometry[ptr.getCell()] = sg;
}
else
sg = mStaticGeometry[ptr.getCell()];
}
// This specifies the size of a single batch region.
// If it is set too high:
// - there will be problems choosing the correct lights
// - the culling will be more inefficient
// If it is set too low:
// - there will be too many batches.
sg->setRegionDimensions(Ogre::Vector3(2500,2500,2500));
sg->setVisibilityFlags(small ? RV_StaticsSmall : RV_Statics);
sg->setCastShadows(true);
sg->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
for(size_t i = 0;i < entities.mEntities.size();i++)
{
Ogre::Entity *ent = entities.mEntities[i];
insert->detachObject(ent);
sg->addEntity(ent,insert->_getDerivedPosition(),insert->_getDerivedOrientation(),insert->_getDerivedScale());
mRenderer.getScene()->destroyEntity(ent);
}
}
}
NpcAnimation::NpcAnimation(const MWWorld::Ptr& ptr, Ogre::SceneNode* node, MWWorld::InventoryStore& _inv, int visibilityFlags)
: Animation(), mStateID(-1), mInv(_inv), timeToChange(0), mVisibilityFlags(visibilityFlags),
robe(mInv.end()), helmet(mInv.end()), shirt(mInv.end()),
cuirass(mInv.end()), greaves(mInv.end()),
leftpauldron(mInv.end()), rightpauldron(mInv.end()),
boots(mInv.end()),
leftglove(mInv.end()), rightglove(mInv.end()), skirtiter(mInv.end()),
pants(mInv.end())
{
MWWorld::LiveCellRef<ESM::NPC> *ref = ptr.get<ESM::NPC>();
for (int init = 0; init < 27; init++)
{
mPartslots[init] = -1; //each slot is empty
mPartPriorities[init] = 0;
}
const ESMS::ESMStore &store = MWBase::Environment::get().getWorld()->getStore();
const ESM::Race *race = store.races.find(ref->base->mRace);
std::string hairID = ref->base->mHair;
std::string headID = ref->base->mHead;
headModel = "meshes\\" + store.bodyParts.find(headID)->mModel;
hairModel = "meshes\\" + store.bodyParts.find(hairID)->mModel;
npcName = ref->base->mName;
isFemale = !!(ref->base->mFlags&ESM::NPC::Female);
isBeast = !!(race->mData.mFlags&ESM::Race::Beast);
bodyRaceID = "b_n_"+ref->base->mRace;
std::transform(bodyRaceID.begin(), bodyRaceID.end(), bodyRaceID.begin(), ::tolower);
mInsert = node;
assert(mInsert);
std::string smodel = (!isBeast ? "meshes\\base_anim.nif" : "meshes\\base_animkna.nif");
mEntityList = NifOgre::NIFLoader::createEntities(mInsert, &mTextKeys, smodel);
for(size_t i = 0;i < mEntityList.mEntities.size();i++)
{
Ogre::Entity *base = mEntityList.mEntities[i];
base->getUserObjectBindings ().setUserAny (Ogre::Any(-1));
base->setVisibilityFlags(mVisibilityFlags);
bool transparent = false;
for(unsigned int j=0;j < base->getNumSubEntities();++j)
{
Ogre::MaterialPtr mat = base->getSubEntity(j)->getMaterial();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements())
{
Ogre::Technique* tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{
Ogre::Pass* pass = passIt.getNext();
if (pass->getDepthWriteEnabled() == false)
transparent = true;
}
}
}
base->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
}
if(mEntityList.mSkelBase)
{
Ogre::AnimationStateSet *aset = mEntityList.mSkelBase->getAllAnimationStates();
Ogre::AnimationStateIterator as = aset->getAnimationStateIterator();
while(as.hasMoreElements())
{
Ogre::AnimationState *state = as.getNext();
state->setEnabled(true);
state->setLoop(false);
}
}
float scale = race->mData.mHeight.mMale;
if (isFemale) {
scale = race->mData.mHeight.mFemale;
}
mInsert->scale(scale, scale, scale);
updateParts();
}
void GrassLayerBase::_updateShaders()
{
if (shaderNeedsUpdate) {
shaderNeedsUpdate = false;
//Proceed only if there is no custom vertex shader and the user's computer supports vertex shaders
const RenderSystemCapabilities *caps = Root::getSingleton().getRenderSystem()->getCapabilities();
if (caps->hasCapability(RSC_VERTEX_PROGRAM) && geom->getShadersEnabled()) {
//Calculate fade range
float farViewDist = geom->getDetailLevels().front()->getFarRange();
float fadeRange = farViewDist / 1.2247449f;
//Note: 1.2247449 ~= sqrt(1.5), which is necessary since the far view distance is measured from the centers
//of pages, while the vertex shader needs to fade grass completely out (including the closest corner)
//before the page center is out of range.
//Generate a string ID that identifies the current set of vertex shader options
StringUtil::StrStreamType tmpName;
tmpName << "GrassVS_";
if (animate)
tmpName << "anim_";
if (blend)
tmpName << "blend_";
if (lighting)
tmpName << "lighting_";
tmpName << renderTechnique << "_";
tmpName << fadeTechnique << "_";
if (fadeTechnique == FADETECH_GROW || fadeTechnique == FADETECH_ALPHAGROW)
tmpName << maxHeight << "_";
tmpName << farViewDist << "_";
tmpName << "vp";
const String vsName = tmpName.str();
//Generate a string ID that identifies the material combined with the vertex shader
const String matName = material->getName() + "_" + vsName;
//Check if the desired material already exists (if not, create it)
MaterialPtr tmpMat = MaterialManager::getSingleton().getByName(matName);
if (tmpMat.isNull()) {
//Clone the original material
tmpMat = material->clone(matName);
//Disable lighting
tmpMat->setLightingEnabled(false);
//tmpMat->setReceiveShadows(false);
//Check if the desired shader already exists (if not, compile it)
String shaderLanguage = ShaderHelper::getShaderLanguage();
HighLevelGpuProgramPtr vertexShader = HighLevelGpuProgramManager::getSingleton().getByName(vsName);
if (vertexShader.isNull()) {
//Generate the grass shader
String vertexProgSource;
if (!shaderLanguage.compare("hlsl") || !shaderLanguage.compare("cg")) {
vertexProgSource = "void main( \n"
" float4 iPosition : POSITION, \n"
" float4 iColor : COLOR, \n"
" float2 iUV : TEXCOORD0, \n"
" out float4 oPosition : POSITION, \n"
" out float4 oColor : COLOR, \n"
" out float2 oUV : TEXCOORD0, \n";
if (lighting)
vertexProgSource += " uniform float4 objSpaceLight, \n"
" uniform float4 lightDiffuse, \n"
" uniform float4 lightAmbient, \n";
if (animate)
vertexProgSource += " uniform float time, \n"
" uniform float frequency, \n"
" uniform float4 direction, \n";
if (fadeTechnique == FADETECH_GROW || fadeTechnique == FADETECH_ALPHAGROW)
vertexProgSource += " uniform float grassHeight, \n";
if (renderTechnique == GRASSTECH_SPRITE || lighting)
vertexProgSource += " float4 iNormal : NORMAL, \n";
vertexProgSource += " uniform float4x4 worldViewProj, \n"
" uniform float3 camPos, \n"
" uniform float fadeRange ) \n"
"{ \n"
" oColor.rgb = iColor.rgb; \n"
" float4 position = iPosition; \n"
" float dist = distance(camPos.xz, position.xz); \n";
if (lighting) {
vertexProgSource += " float3 light = normalize(objSpaceLight.xyz - (iPosition.xyz * objSpaceLight.w)); \n"
" float diffuseFactor = max(dot(float4(0,1,0,0), light), 0); \n"
" oColor = (lightAmbient + diffuseFactor * lightDiffuse) * iColor; \n";
} else {
vertexProgSource += " oColor.rgb = iColor.rgb; \n";
}
if (fadeTechnique == FADETECH_ALPHA || fadeTechnique == FADETECH_ALPHAGROW)
vertexProgSource +=
//Fade out in the distance
" oColor.a = 2.0f - (2.0f * dist / fadeRange); \n";
else
vertexProgSource += " oColor.a = 1.0f; \n";
vertexProgSource += " float oldposx = position.x; \n";
if (renderTechnique == GRASSTECH_SPRITE)
vertexProgSource +=
//Face the camera
" float3 dirVec = (float3)position - (float3)camPos; \n"
" float3 p = normalize(cross(float4(0,1,0,0), dirVec)); \n"
" position += float4(p.x * iNormal.x, iNormal.y, p.z * iNormal.x, 0); \n";
if (animate)
vertexProgSource += " if (iUV.y == 0.0f){ \n"
//Wave grass in breeze
" float offset = sin(time + oldposx * frequency); \n"
" position += direction * offset; \n"
" } \n";
if (blend && animate)
vertexProgSource += " else { \n";
else if (blend)
vertexProgSource += " if (iUV.y != 0.0f){ \n";
if (blend)
vertexProgSource +=
//Blend the base of nearby grass into the terrain
" oColor.a = clamp(oColor.a, 0, 1) * 4.0f * ((dist / fadeRange) - 0.1f); \n"
" } \n";
if (fadeTechnique == FADETECH_GROW || fadeTechnique == FADETECH_ALPHAGROW)
vertexProgSource += " float offset = (2.0f * dist / fadeRange) - 1.0f; \n"
" position.y -= grassHeight * clamp(offset, 0, 1); ";
vertexProgSource += " oPosition = mul(worldViewProj, position); \n";
vertexProgSource += " oUV = iUV;\n"
"}";
} else {
//Must be glsl
if (lighting) {
vertexProgSource = "uniform vec4 objSpaceLight; \n"
"uniform vec4 lightDiffuse; \n"
"uniform vec4 lightAmbient; \n";
}
if (animate) {
vertexProgSource += "uniform float time; \n"
"uniform float frequency; \n"
"uniform vec4 direction; \n";
}
if (fadeTechnique == FADETECH_GROW || fadeTechnique == FADETECH_ALPHAGROW) {
vertexProgSource += "uniform float grassHeight; \n";
}
vertexProgSource += "uniform vec3 camPos; \n"
"uniform float fadeRange; \n"
"\n"
"void main()"
"{ \n"
" vec4 color = gl_Color; \n"
" vec4 position = gl_Vertex; \n"
" float dist = distance(camPos.xz, position.xz); \n";
if (lighting) {
vertexProgSource += " vec3 light = normalize(objSpaceLight.xyz - (gl_Vertex.xyz * objSpaceLight.w)); \n"
" float diffuseFactor = max( dot( vec3(0.0,1.0,0.0), light), 0.0); \n"
" color = (lightAmbient + diffuseFactor * lightDiffuse) * gl_Color; \n";
} else {
vertexProgSource += " color.xyz = gl_Color.xyz; \n";
}
if (fadeTechnique == FADETECH_ALPHA || fadeTechnique == FADETECH_ALPHAGROW) {
vertexProgSource +=
//Fade out in the distance
" color.w = 2.0 - (2.0 * dist / fadeRange); \n";
} else {
vertexProgSource += " color.w = 1.0; \n";
}
if (renderTechnique == GRASSTECH_SPRITE) {
vertexProgSource +=
//Face the camera
" vec3 dirVec = position.xyz - camPos.xyz; \n"
" vec3 p = normalize(cross(vec3(0.0,1.0,0.0), dirVec)); \n"
" position += vec4(p.x * gl_Normal.x, gl_Normal.y, p.z * gl_Normal.x, 0.0); \n";
}
if (animate) {
vertexProgSource += " if (gl_MultiTexCoord0.y == 0.0) \n"
" { \n"
//Wave grass in breeze
" position += direction * sin(time + gl_Vertex.x * frequency); \n"
" } \n";
}
if (blend && animate) {
vertexProgSource += " else \n"
" { \n";
} else if (blend) {
vertexProgSource += " if (gl_MultiTexCoord0.y != 0.0) \n"
" { \n";
}
if (blend) {
vertexProgSource +=
//Blend the base of nearby grass into the terrain
" color.w = clamp(color.w, 0.0, 1.0) * 4.0 * ((dist / fadeRange) - 0.1); \n"
" } \n";
}
if (fadeTechnique == FADETECH_GROW || fadeTechnique == FADETECH_ALPHAGROW) {
vertexProgSource += " position.y -= grassHeight * clamp((2.0 * dist / fadeRange) - 1.0, 0.0, 1.0); \n";
}
vertexProgSource += " gl_Position = gl_ModelViewProjectionMatrix * position; \n"
" gl_FrontColor = color; \n"
" gl_TexCoord[0] = gl_MultiTexCoord0; \n";
if (geom->getSceneManager()->getFogMode() == Ogre::FOG_EXP2) {
vertexProgSource += " gl_FogFragCoord = clamp(exp(- gl_Fog.density * gl_Fog.density * gl_Position.z * gl_Position.z), 0.0, 1.0); \n";
} else {
vertexProgSource += " gl_FogFragCoord = gl_Position.z; \n";
}
vertexProgSource += "}";
}
vertexShader = HighLevelGpuProgramManager::getSingleton().createProgram(vsName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, shaderLanguage, GPT_VERTEX_PROGRAM);
vertexShader->setSource(vertexProgSource);
if (shaderLanguage == "hlsl") {
vertexShader->setParameter("target", "vs_1_1");
vertexShader->setParameter("entry_point", "main");
} else if (shaderLanguage == "cg") {
vertexShader->setParameter("profiles", "vs_1_1 arbvp1");
vertexShader->setParameter("entry_point", "main");
}
// GLSL can only have one entry point "main".
vertexShader->load();
}
//Now the vertex shader (vertexShader) has either been found or just generated
//(depending on whether or not it was already generated).
tmpMat->load();
Ogre::Material::TechniqueIterator techIterator = tmpMat->getSupportedTechniqueIterator();
while (techIterator.hasMoreElements()) {
Ogre::Technique* tech = techIterator.getNext();
//Apply the shader to the material
Pass *pass = tech->getPass(0);
pass->setVertexProgram(vsName);
GpuProgramParametersSharedPtr params = pass->getVertexProgramParameters();
if (shaderLanguage.compare("glsl"))
//glsl can use the built in gl_ModelViewProjectionMatrix
params->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
params->setNamedAutoConstant("camPos", GpuProgramParameters::ACT_CAMERA_POSITION_OBJECT_SPACE);
params->setNamedAutoConstant("fadeRange", GpuProgramParameters::ACT_CUSTOM, 1);
if (animate) {
params->setNamedConstant("time", 1.0f);
params->setNamedConstant("frequency", 1.0f);
params->setNamedConstant("direction", Ogre::Vector4::ZERO);
}
if (lighting) {
params->setNamedAutoConstant("objSpaceLight", GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE);
params->setNamedAutoConstant("lightDiffuse", GpuProgramParameters::ACT_DERIVED_LIGHT_DIFFUSE_COLOUR);
params->setNamedAutoConstant("lightAmbient", GpuProgramParameters::ACT_DERIVED_AMBIENT_LIGHT_COLOUR);
}
if (fadeTechnique == FADETECH_GROW || fadeTechnique == FADETECH_ALPHAGROW) {
params->setNamedConstant("grassHeight", maxHeight * 1.05f);
}
pass->getVertexProgramParameters()->setNamedConstant("fadeRange", fadeRange);
}
}
//Now the material (tmpMat) has either been found or just created (depending on whether or not it was already
//created). The appropriate vertex shader should be applied and the material is ready for use.
//Apply the new material
material = tmpMat;
}
Ogre::Technique* tech = material->getBestTechnique();
if (tech && tech->getNumPasses()) {
Ogre::Pass* pass = tech->getPass(0);
if (pass->hasVertexProgram()) {
Ogre::GpuProgramParametersSharedPtr params = pass->getVertexProgramParameters();
if (!params.isNull()) {
params->setIgnoreMissingParams(true);
}
}
}
}
}
const Ogre::MaterialPtr&
Terrain::_getGridMaterial(const TerrainData::GridInfo &gridInfo, ushort depthBias, int nTileX, int nTileZ)
{
assert(mData != NULL);
size_t textureIds[TerrainData::NumLayers] = { 0 };
for (size_t i = 0; i < TerrainData::NumLayers; ++i)
{
if (gridInfo.layers[i].pixmapId)
{
textureIds[i] = _getPixmapAtlasId(gridInfo.layers[i].pixmapId - 1) + 1;
}
}
assert(textureIds[0] && "Internal fault while create grid material");
bool lightmapped = mData->mLightmapImage && getLightmapQuality() != LMQ_NONE;
Ogre::ulong lightmapId = lightmapped ? (nTileZ << 16) | nTileX : ~0;
MaterialId id(textureIds[0], textureIds[1], lightmapId, depthBias);
// find the material that already created
MaterialMap::const_iterator it = mMaterials.find(id);
if (it != mMaterials.end())
return it->second;
Ogre::String name = "Terrain/";
if (!mData->mName.empty())
name += mData->mName + "/";
name += Ogre::StringConverter::toString(textureIds[0]) + "." + Ogre::StringConverter::toString(textureIds[1]);
if (depthBias)
name += "_" + Ogre::StringConverter::toString(depthBias);
Ogre::String lightmapName = "<Lightmap>(" +
Ogre::StringConverter::toString(nTileX / mData->mTileSize) + "," +
Ogre::StringConverter::toString(nTileZ / mData->mTileSize) + ")";
if (lightmapped)
name += "_" + lightmapName;
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(name);
if (material.isNull())
{
// get user supplied material
Ogre::String templateName = textureIds[1] ? "TwoLayer" : "OneLayer";
if (lightmapped)
templateName += "Lightmap";
TerrainData::MaterialTemplates::const_iterator it =
mData->mMaterialTemplates.find(templateName);
if (it == mData->mMaterialTemplates.end())
OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND,
"Can't found grid material template for '" + templateName + "'!",
"Terrain::_getGridMaterial");
const Ogre::String& baseName = it->second;
Ogre::MaterialPtr templateMaterial = Ogre::MaterialManager::getSingleton().getByName(baseName);
if (templateMaterial.isNull())
OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND,
"Can't load grid material template '" + baseName + "'!",
"Terrain::_getGridMaterial");
// clone the material
material = templateMaterial->clone(name, true, BRUSH_RESOURCE_GROUP_NAME);
// Setup texture alias list
Ogre::AliasTextureNamePairList aliasList;
aliasList["<layer0>"] = mAtlases[textureIds[0]-1].texture->getName();
if (textureIds[1])
aliasList["<layer1>"] = mAtlases[textureIds[1]-1].texture->getName();
if (lightmapped)
aliasList["<lightmap>"] = lightmapName;
// Applies texture names
material->applyTextureAliases(aliasList);
// Applies surface params
_applySurfaceParams(material);
// Applies fog
_applyFogMode(material, Ogre::FOG_NONE, mCurrentFogMode);
// Adjust other material attributes
Ogre::Material::TechniqueIterator ti = material->getTechniqueIterator();
while (ti.hasMoreElements())
{
Ogre::Technique* technique = ti.getNext();
Ogre::Technique::PassIterator pi = technique->getPassIterator();
while (pi.hasMoreElements())
{
Ogre::Pass* pass = pi.getNext();
if (depthBias)
{
#if OGRE_VERSION >= 0x010300
pass->setDepthBias(depthBias + pass->getDepthBiasConstant(), pass->getDepthBiasSlopeScale());
#else
pass->setDepthBias(depthBias + pass->getDepthBias());
#endif
}
}
}
}
// The material will load on demand
std::pair<MaterialMap::iterator, bool> inserted =
mMaterials.insert(MaterialMap::value_type(id, material));
assert(inserted.second && "Internal fault while create grid material");
return inserted.first->second;
}