// 替换指定纹理层的纹理
bool TerrainImpl::setPaintTexutreName(size_t nPaintChannel , const String &strTextureName)
{
Technique *pTech = mMaterial->getTechnique(0);
Pass *pass = pTech->getPass(nPaintChannel / SPLATTING_TEXTURE_NUM);
if(pass)
{
TextureUnitState *texture = pass->getTextureUnitState(COVERAGE_TEXTURE_NUM + (nPaintChannel % SPLATTING_TEXTURE_NUM));
if(texture)
{
texture->setTextureName(strTextureName);
return texture->getTextureName() == strTextureName && !texture->_getTexturePtr().isNull() && texture->_getTexturePtr()->isLoaded();
}
}
return false;
}
void DepthComposerInstance::notifyMaterialSetup(uint pass_id, Ogre::MaterialPtr &mat)
{
//LogManager::getSingleton ().logMessage (
// "Caelum::DepthComposer: Material setup");
Pass* pass = mat->getBestTechnique ()->getPass (0);
TextureUnitState *depthTus = pass->getTextureUnitState(1);
if (depthTus->getTextureName () != mDepthRenderer->getDepthRenderTexture ()->getName()) {
depthTus->setTextureName (mDepthRenderer->getDepthRenderTexture ()->getName ());
LogManager::getSingleton ().logMessage (
"Caelum::DepthComposer: Assigned depth texture in compositor material");
}
mParams.setup(pass->getFragmentProgramParameters ());
}
void MeshObject::loadMesh()
{
try
{
Ogre::String resourceGroup = Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME;
mesh = static_cast<Ogre::MeshPtr>(Ogre::MeshManager::getSingleton().create(meshName, resourceGroup));
if(backgroundLoading)
{
mesh->setBackgroundLoaded(true);
mesh->addListener(this);
ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(
Ogre::MeshManager::getSingletonPtr()->getResourceType(),
mesh->getName(),
resourceGroup,
false,
0,
0,
0);
// try to load its textures in the background
for(int i=0; i<mesh->getNumSubMeshes(); i++)
{
SubMesh *sm = mesh->getSubMesh(i);
String materialName = sm->getMaterialName();
Ogre::MaterialPtr mat = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName(materialName)); //, resourceGroup));
if(mat.isNull()) continue;
for(int tn=0; tn<mat->getNumTechniques(); tn++)
{
Technique *t = mat->getTechnique(tn);
for(int pn=0; pn<t->getNumPasses(); pn++)
{
Pass *p = t->getPass(pn);
for(int tun=0; tun<p->getNumTextureUnitStates(); tun++)
{
TextureUnitState *tu = p->getTextureUnitState(tun);
String textureName = tu->getTextureName();
// now add this texture to the background loading queue
Ogre::TexturePtr tex = static_cast<Ogre::TexturePtr>(Ogre::TextureManager::getSingleton().create(textureName, resourceGroup));
tex->setBackgroundLoaded(true);
tex->addListener(this);
ticket = Ogre::ResourceBackgroundQueue::getSingleton().load(
Ogre::TextureManager::getSingletonPtr()->getResourceType(),
tex->getName(),
resourceGroup,
false,
0,
0,
0);
}
}
}
}
}
if(!backgroundLoading)
postProcess();
}
catch (Ogre::Exception* e)
{
LOG("exception while loading mesh: " + e->getFullDescription());
}
}
void WaterMaterialGenerator::generate()
{
mMaterial = prepareMaterial(mDef->getName());
resetTexUnitCounter();
// we need a lot of uniform constants, disabling shadows reduces them significantly so that it can still run on PS2
const RenderSystemCapabilities *caps = Root::getSingleton().getRenderSystem()->getCapabilities();
if(!caps->isShaderProfileSupported("ps_4_0") && !caps->isShaderProfileSupported("fp40"))
mDef->mProps->receivesShadows = false;
// -------------------------- Main technique ----------------------------- //
Ogre::Technique* technique = mMaterial->createTechnique();
// Main pass -----------------------------------------------------------
Ogre::Pass* pass = technique->createPass();
pass->setCullingMode(CULL_NONE);
pass->setDepthWriteEnabled(true);
if (!mParent->getRefract())
pass->setSceneBlending(SBT_TRANSPARENT_ALPHA);
Ogre::TextureUnitState* tu;
// normal map
mNormalMap = pickTexture(&mDef->mProps->normalMaps);
tu = pass->createTextureUnitState( mNormalMap );
tu->setName("normalMap");
mNormalTexUnit = mTexUnit_i; mTexUnit_i++;
// global terrain lightmap (static)
if (needTerrainLightMap())
{
tu = pass->createTextureUnitState(""); // texture name set later (in changeShadows)
tu->setName("terrainLightMap");
mTerrainLightTexUnit = mTexUnit_i; mTexUnit_i++;
}
if (mParent->getRefract())
{
tu = pass->createTextureUnitState( "PlaneRefraction" );
tu->setName("refractionMap");
tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
mScreenRefrUnit = mTexUnit_i++;
}
if (mParent->getReflect())
{
tu = pass->createTextureUnitState( "PlaneReflection" );
tu->setName("reflectionMap");
tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
mScreenReflUnit = mTexUnit_i++;
}
//else
{
// retrieve sky texture name from scene
std::string skyTexName;
if (mParent->pApp->terrain)
{
MaterialPtr mtrSky = MaterialManager::getSingleton().getByName(mParent->pApp->sc.skyMtr);
if(!mtrSky.isNull())
{
Pass* passSky = mtrSky->getTechnique(0)->getPass(0);
TextureUnitState* tusSky = passSky->getTextureUnitState(0);
skyTexName = tusSky->getTextureName();
}
}
else skyTexName = String("white.png");
tu = pass->createTextureUnitState( skyTexName );
tu->setName("skyMap");
tu->setTextureAddressingMode(TextureUnitState::TAM_MIRROR);
mEnvTexUnit = mTexUnit_i++;
}
// waterDepth
tu = pass->createTextureUnitState( "waterDepth.png" );
tu->setName("depthMap");
tu->setTextureAddressingMode(TextureUnitState::TAM_BORDER);
tu->setTextureBorderColour(ColourValue::White); // outside tex water always visible
mWaterDepthUnit = mTexUnit_i; mTexUnit_i++;
// realtime shadow maps
if (needShadows())
{
mShadowTexUnit_start = mTexUnit_i;
for (int i = 0; i < mParent->getNumShadowTex(); ++i)
{
tu = pass->createTextureUnitState();
tu->setName("shadowMap" + toStr(i));
tu->setContentType(TextureUnitState::CONTENT_SHADOW);
tu->setTextureAddressingMode(TextureUnitState::TAM_BORDER);
tu->setTextureBorderColour(ColourValue::White);
mTexUnit_i++;
}
}
// shader
if (!mShaderCached)
{
mVertexProgram = createVertexProgram();
mFragmentProgram = createFragmentProgram();
}
pass->setVertexProgram(mVertexProgram->getName());
pass->setFragmentProgram(mFragmentProgram->getName());
if (mShaderCached)
{
individualFragmentProgramParams(pass->getFragmentProgramParameters());
individualVertexProgramParams(pass->getFragmentProgramParameters());
}
// ----------------------------------------------------------------------- //
createSSAOTechnique();
createOccluderTechnique();
// indicate we need 'time' parameter set every frame
mParent->timeMtrs.push_back(mDef->getName());
/*
if (mDef->getName() == "Grease_jelly")
{
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());
}
/**/
}
void CarReflection::Create()
{
bFirstFrame = true;
if (pSet->refl_mode == "single") cubetexName = "ReflectionCube"; // single: use 1st cubemap
else if (pSet->refl_mode == "full")
{
cubetexName = "ReflectionCube" + toStr(iIndex);
// first cubemap: no index
if (cubetexName == "ReflectionCube0")
cubetexName = "ReflectionCube";
}
else /* static */
cubetexName = "ReflectionCube";
TextureManager* tm = TextureManager::getSingletonPtr();
int size = ciShadowSizesA[pSet->refl_size]; // /2 ?
// create cube render texture
if (! (pSet->refl_mode == "single" && iIndex != 0) )
{
cubetex = tm->createManual(cubetexName,
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_CUBE_MAP,
size,size, 0/*mips*/, PF_R8G8B8, TU_RENDERTARGET);
//LogO("created rt cube");
for (int face = 0; face < 6; face++)
{
Camera* mCam = pSceneMgr->createCamera("Reflect_" + toStr(iIndex) + "_" + toStr(face));
mCam->setAspectRatio(1.0f); mCam->setFOVy(Degree(90));
mCam->setNearClipDistance(0.1);
//mCam->setFarClipDistance(pSet->refl_dist); //sky-
RenderTarget* mRT = cubetex->getBuffer(face)->getRenderTarget();
//LogO( "rt face Name: " + mRT->getName() );
mRT->removeAllViewports();
Viewport* vp = mRT->addViewport(mCam);
vp->setOverlaysEnabled(false);
vp->setVisibilityMask(RV_MaskReflect);
mRT->setAutoUpdated(false);
//mRT->addListener(this); //-
mCam->setPosition(Vector3::ZERO);
Vector3 lookAt(0,0,0), up(0,0,0), right(0,0,0); switch(face)
{
case 0: lookAt.x =-1; up.y = 1; right.z = 1; break; // +X
case 1: lookAt.x = 1; up.y = 1; right.z =-1; break; // -X
case 2: lookAt.y =-1; up.z = 1; right.x = 1; break; // +Y
case 3: lookAt.y = 1; up.z =-1; right.x = 1; break; // -Y
case 4: lookAt.z = 1; up.y = 1; right.x =-1; break; // +Z
case 5: lookAt.z =-1; up.y = 1; right.x =-1; break; // -Z
}
Quaternion orient( right, up, lookAt ); mCam->setOrientation( orient );
pCams[face] = mCam;
pRTs[face] = mRT;
}
}
// Iterate through our materials and add an index to ReflectionCube texture reference
for (int i=0; i < NumMaterials; i++)
{
MaterialPtr mtr = MaterialManager::getSingleton().getByName(sMtr[i]);
if (!mtr.isNull())
{ Material::TechniqueIterator techIt = mtr->getTechniqueIterator();
while (techIt.hasMoreElements())
{ Technique* tech = techIt.getNext();
Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{ Pass* pass = passIt.getNext();
Pass::TextureUnitStateIterator tusIt = pass->getTextureUnitStateIterator();
while (tusIt.hasMoreElements())
{
TextureUnitState* tus = tusIt.getNext();
if (tus->getTextureName() == "ReflectionCube")
tus->setTextureName(cubetexName);
} } } } }
}