//-------------------------------------------------------------------------------
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;
}
void TerrainProjectionMarker::AddMaterial(const string& matName)
{
// check if material is already added or there's no material
if( _targetMaterials.find(matName) != _targetMaterials.end() ||
matName.empty() )
{
return;
}
string matName2 = "StoreMat";
// get the material ptr
Ogre::MaterialPtr mat = (Ogre::MaterialPtr)Ogre::MaterialManager::getSingleton().getByName(matName);
// create a new pass in the material to render the decal
Ogre::Pass* pass = mat->getTechnique(0)->createPass();
// set up the decal's texture unit
Ogre::TextureUnitState *texState = pass->createTextureUnitState(GetTextureName());
texState->setProjectiveTexturing(true, _projectionFrustum);
texState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
texState->setTextureFiltering(Ogre::FO_POINT, Ogre::FO_LINEAR, Ogre::FO_NONE);
texState->setAlphaOperation(Ogre::LBX_ADD);
// set our pass to blend the decal over the model's regular texture
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthBias(2.5f, 2.5f);
pass->setDepthCheckEnabled(false);
// set the decal to be self illuminated instead of lit by scene lighting
pass->setLightingEnabled(false);
// save pass in map
_targetMaterials[matName] = pass;
}
void SkyDome::setAtmosphereDepthImage (const Ogre::String& atmosphereDepth)
{
if (!mShadersEnabled) {
return;
}
Ogre::TextureUnitState* atmosphereTus =
mMaterial->getTechnique (0)->getPass (0)->getTextureUnitState(1);
atmosphereTus->setTextureName (atmosphereDepth, Ogre::TEX_TYPE_1D);
atmosphereTus->setTextureAddressingMode (Ogre::TextureUnitState::TAM_CLAMP, Ogre::TextureUnitState::TAM_WRAP, Ogre::TextureUnitState::TAM_WRAP);
}
void SkyDome::setSkyGradientsImage (const Ogre::String& gradients)
{
Ogre::TextureUnitState* gradientsTus =
mMaterial->getTechnique (0)->getPass (0)->getTextureUnitState(0);
gradientsTus->setTextureAddressingMode (Ogre::TextureUnitState::TAM_CLAMP);
// Per 1.4 compatibility. Not tested with recent svn.
#if OGRE_VERSION < ((1 << 16) | (3 << 8))
gradientsTus->setTextureName (gradients, Ogre::TEX_TYPE_2D, -1, true);
#else
gradientsTus->setTextureName (gradients, Ogre::TEX_TYPE_2D);
gradientsTus->setIsAlpha (true);
#endif
}
void Simple::addShadow(Ogre::Technique* technique, const TerrainPageShadow* terrainPageShadow, Ogre::MaterialPtr material, std::set<std::string>& managedTextures) const
{
Ogre::Pass* shadowPass = technique->createPass();
shadowPass->setSceneBlending(Ogre::SBT_MODULATE);
shadowPass->setLightingEnabled(false);
// shadowPass->setFog(true, Ogre::FOG_NONE);
Ogre::TextureUnitState * textureUnitStateSplat = shadowPass->createTextureUnitState();
Ogre::TexturePtr texture = updateShadowTexture(material, terrainPageShadow, managedTextures);
textureUnitStateSplat->setTextureName(texture->getName());
textureUnitStateSplat->setTextureCoordSet(0);
textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
}
void OgreCursor::setImage(const std::string& filename)
{
//std::cerr << __PRETTY_FUNCTION__ << filename << std::endl;
_texture = Ogre::TextureManager::getSingleton().load(filename, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); //"General"
Ogre::TextureUnitState *pTexState;
if (_material->getTechnique(0)->getPass(0)->getNumTextureUnitStates())
{
pTexState = _material->getTechnique(0)->getPass(0)->getTextureUnitState(0);
}
else
{
pTexState = _material->getTechnique(0)->getPass(0)->createTextureUnitState(_texture->getName());
}
pTexState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
pTexState->setTextureName(filename);
_material->getTechnique(0)->getPass(0)->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
}
void Decal::registerPass(Ogre::Pass* _Pass)
{
unregister();
_Pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
_Pass->setCullingMode(Ogre::CULL_NONE);
_Pass->setDepthBias(1,1);
_Pass->setLightingEnabled(false);
_Pass->setDepthWriteEnabled(false);
Ogre::TextureUnitState *DecalTexture = _Pass->createTextureUnitState(mTextureName);
DecalTexture->setProjectiveTexturing(true, mProjector);
DecalTexture->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
DecalTexture->setTextureFiltering(Ogre::FO_LINEAR, Ogre::FO_LINEAR, Ogre::FO_NONE);
DecalTexture->setAlphaOperation(Ogre::LBX_MODULATE, Ogre::LBS_TEXTURE, Ogre::LBS_MANUAL, 1.0, mTransparency);
mRegisteredPass = _Pass;
}
void RenderWindow::CreateRenderTargetOverlay(int width, int height)
{
width = max(1, width);
height = max(1, height);
Ogre::TexturePtr renderTarget = Ogre::TextureManager::getSingleton().createManual(
rttTextureName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D, width, height, 0, Ogre::PF_A8R8G8B8, Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
Ogre::MaterialPtr rttMaterial = Ogre::MaterialManager::getSingleton().create(
rttMaterialName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::TextureUnitState *rttTuState = rttMaterial->getTechnique(0)->getPass(0)->createTextureUnitState();
rttTuState->setTextureName(rttTextureName);
rttTuState->setTextureFiltering(Ogre::TFO_NONE);
rttTuState->setNumMipmaps(1);
rttTuState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
rttMaterial->setFog(true, Ogre::FOG_NONE); ///\todo Check, shouldn't here be false?
rttMaterial->setReceiveShadows(false);
rttMaterial->setTransparencyCastsShadows(false);
rttMaterial->getTechnique(0)->getPass(0)->setSceneBlending(Ogre::SBF_SOURCE_ALPHA, Ogre::SBF_ONE_MINUS_SOURCE_ALPHA);
rttMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
rttMaterial->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false);
rttMaterial->getTechnique(0)->getPass(0)->setLightingEnabled(false);
rttMaterial->getTechnique(0)->getPass(0)->setCullingMode(Ogre::CULL_NONE);
overlayContainer = Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "MainWindow Overlay Panel");
overlayContainer->setMaterialName(rttMaterialName);
overlayContainer->setMetricsMode(Ogre::GMM_PIXELS);
overlayContainer->setPosition(0, 0);
overlayContainer->setDimensions((Ogre::Real)width, (Ogre::Real)height);
overlayContainer->setPosition(0,0);
overlay = Ogre::OverlayManager::getSingleton().create("MainWindow Overlay");
overlay->add2D(static_cast<Ogre::OverlayContainer *>(overlayContainer));
overlay->setZOrder(500);
overlay->show();
// ResizeOverlay(width, height);
}
Ogre::MaterialPtr OgrePlanarReflectionMaterial::createMaterial(const Ogre::TexturePtr& texture, const Ogre::Camera& projectionCamera)
{
using namespace::Ogre;
Ogre::MaterialPtr matPtr = MaterialManager::getSingleton().create(this->getName(),"General");
Ogre::TextureUnitState* t;
if(! textureFilename.getValue().empty() )
{
t = matPtr->getTechnique(0)->getPass(0)->createTextureUnitState(textureFilename.getValue());
}
t = matPtr->getTechnique(0)->getPass(0)->createTextureUnitState(texture->getName() );
t->setColourOperationEx(Ogre::LBX_BLEND_MANUAL, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT,
Ogre::ColourValue::White, Ogre::ColourValue::White,
blendingFactor.getValue());
t->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
t->setProjectiveTexturing(true,&projectionCamera);
matPtr->compile();
return matPtr;
}
void Simple::addLightingPass(Ogre::Technique* technique, std::set<std::string>& managedTextures) const
{
Ogre::Pass* lightingPass = technique->createPass();
lightingPass->setSceneBlending(Ogre::SBT_MODULATE);
lightingPass->setLightingEnabled(false);
Ogre::TextureUnitState * textureUnitStateSplat = lightingPass->createTextureUnitState();
//we need an unique name for our alpha texture
std::stringstream lightingTextureNameSS;
lightingTextureNameSS << technique->getParent()->getName() << "_lighting";
const Ogre::String lightingTextureName(lightingTextureNameSS.str());
Ogre::TexturePtr texture = static_cast<Ogre::TexturePtr>(Ogre::Root::getSingletonPtr()->getTextureManager()->getByName(lightingTextureName));
if (texture.isNull()) {
texture = Ogre::Root::getSingletonPtr()->getTextureManager()->createManual(lightingTextureName, "General", Ogre::TEX_TYPE_2D, mPage.getBlendMapSize(), mPage.getBlendMapSize(), 1, Ogre::PF_L8, Ogre::TU_DYNAMIC_WRITE_ONLY);
managedTextures.insert(texture->getName());
}
Ogre::Image ogreImage;
ogreImage.loadDynamicImage(const_cast<unsigned char*>(mLightingImage->getData()), mLightingImage->getResolution(), mLightingImage->getResolution(), 1, Ogre::PF_L8);
texture->loadImage(ogreImage);
//blit the whole image to the hardware buffer
Ogre::PixelBox sourceBox(ogreImage.getPixelBox());
//blit for each mipmap
for (unsigned int i = 0; i <= texture->getNumMipmaps(); ++i) {
Ogre::HardwarePixelBufferSharedPtr hardwareBuffer(texture->getBuffer(0, i));
hardwareBuffer->blitFromMemory(sourceBox);
}
textureUnitStateSplat->setTextureName(texture->getName());
textureUnitStateSplat->setTextureCoordSet(0);
textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
}
void RenderState::createScene()
{
////////////////////// Volume texture
// breadVolume.createTexture("media/fields/imagen3-1.field", "volumeTex");
// breadVolume.createTexture("media/fields/mengel3d.field", "volumeTex");
// breadVolume.createTexture("media/fields/3Dbread.256.field", "volumeTex");
breadDensityVolume.createTexture("media/fields/warped.field", "densityTex");
breadDensityTex = breadDensityVolume.getTexturePtr();
if (breadDensityTex.isNull()) {
printf("Error generating density texture");
exit();
}
breadCrustVolume.createTexture("media/fields/warpedC.field", "crustTex");
breadCrustTex = breadCrustVolume.getTexturePtr();
if (breadCrustTex.isNull()) {
printf("Error generating crust texture");
exit();
}
breadOcclusionVolume.createTexture("media/fields/warpedO.field", "occlusionTex");
breadOcclusionTex = breadOcclusionVolume.getTexturePtr();
if (breadOcclusionTex.isNull()) {
printf("Error generating occlusion texture");
exit();
}
///////////////////// Volume bounding cubes
breadVolumeBoundingCubes.create(breadDensityVolume, 32, 1, 255, _sceneMgr);
//////////// Background color
Ogre::Viewport* vp = OgreFramework::getSingletonPtr()->_viewport;
vp->setBackgroundColour (ColourValue(0.1,0.1,0.1));
//////////// Light
_sceneMgr->setAmbientLight(ColourValue(0.1,0.1,0.1));
light = _sceneMgr->createLight("Light");
// light->setType(Light::LT_POINT);
light->setType(Light::LT_SPOTLIGHT);
light->setPosition(100,100,100);
light->setDirection(100,-100,100);
light->setDiffuseColour(1,1,1);
light->setSpecularColour(1.0,1.0,1.0);
light->setSpotlightRange(Radian(M_PI/2), Radian(M_PI/3));
// light->setAttenuation(20, 0.5, 1, 1);
//////////// Shadows
// _sceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);
// _sceneMgr->setShadowTextureSettings( 256, 2);
// _sceneMgr->setShadowTextureConfig( 0, 512, 512, PF_FLOAT16_R, 50 );
////////////////////// BREAD
breadEntity = _sceneMgr->createEntity("BreadEntity", "Cube01.mesh");
breadNode = _sceneMgr->getRootSceneNode()->createChildSceneNode("BreadNode");
breadNode->attachObject(breadEntity);
breadNode->setOrientation(Quaternion::IDENTITY);
breadNode->setPosition(Vector3(0, 0, 0));
breadNode->setScale(Vector3(20,20,20));
// breadEntity->setRenderQueueGroup(RENDER_QUEUE_8);
breadEntity->setCastShadows(true);
breadEntity->getSubEntity(0)->setMaterialName("Bread","General");
breadMat = breadEntity->getSubEntity(0)->getMaterial();
Ogre::Pass* breadPass = breadMat->getTechnique(0)->getPass(0);
Ogre::TextureUnitState* posTU = breadPass->createTextureUnitState("rayPos");
Ogre::TextureUnitState* dirTU = breadPass->createTextureUnitState("rayDir");
posTU->setTextureName("rayPos");
dirTU->setTextureName("rayDir");
posTU->setTextureFiltering(TFO_NONE);
dirTU->setTextureFiltering(TFO_NONE);
posTU->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
dirTU->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
/////////////////////// TABLE
tableEntity = _sceneMgr->createEntity("PlaneEntity", "Plane.mesh");
tableEntity->getSubEntity(0)->setMaterialName("Table","General");
tableEntity->setCastShadows(false);
tableNode = _sceneMgr->getRootSceneNode()->createChildSceneNode("PlaneNode");
tableNode->attachObject(tableEntity);
tableNode->setOrientation(Quaternion::IDENTITY);
tableNode->setPosition(Vector3(0, 0, 0));
tableNode->setScale(Vector3(10,10,10));
/////////////////////// KNIFE
knifeEntity = _sceneMgr->createEntity("KnifeEntity", "knife.mesh");
knifeEntity->getSubEntity(0)->setMaterialName("Knife","General");
knifeEntity->setCastShadows(false);
knifeNode = _sceneMgr->getRootSceneNode()->createChildSceneNode("KnifeNode");
knifeNode->attachObject(knifeEntity);
Quaternion ori(Radian(-0.5), Vector3(0,1,0));
knifeNode->setOrientation(ori);
knifeNode->setPosition(Vector3(30, 1, -30));
knifeNode->setScale(Vector3(50,50,50));
// Create background rectangle covering the whole screen
Rectangle2D* rect = new Rectangle2D(true);
rect->setCorners(-1.0, 1.0, 1.0, -1.0);
rect->setMaterial("Degrade");
rect->setCastShadows(false);
// Render the background before everything else
rect->setRenderQueueGroup(RENDER_QUEUE_BACKGROUND);
// Use infinite AAB to always stay visible
AxisAlignedBox aabInf;
aabInf.setInfinite();
rect->setBoundingBox(aabInf);
// Attach background to the scene
backgroundNode =_sceneMgr->getRootSceneNode()->createChildSceneNode("Background");
backgroundNode->attachObject(rect);
/////////////// Light obj
// Create background rectangle covering the whole screen
lightEntity = _sceneMgr->createEntity("LightEntity", "Cube01.mesh");
lightNode = _sceneMgr->getRootSceneNode()->createChildSceneNode("Light");
lightEntity->getSubEntity(0)->setMaterialName("White","General");
lightEntity->setCastShadows(false);
lightNode->attachObject(lightEntity);
lightNode->setPosition(light->getPosition());
lightNode->showBoundingBox(false);
///////////////////////// Set visibility masks for all entities
lightEntity->setVisibilityFlags(RF_MAIN);
rect->setVisibilityFlags(RF_MAIN);
knifeEntity->setVisibilityFlags(RF_MAIN);
tableEntity->setVisibilityFlags(RF_MAIN);
breadEntity->setVisibilityFlags(RF_MAIN);
}
Ogre::MaterialPtr MaterialGenerator::create(bool renderCompositeMap, bool displayCompositeMap)
{
assert(!renderCompositeMap || !displayCompositeMap);
static int count = 0;
std::stringstream name;
name << "terrain/mat" << count++;
if (!mShaders)
{
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create(name.str(),
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::Technique* technique = mat->getTechnique(0);
technique->removeAllPasses();
if (displayCompositeMap)
{
Ogre::Pass* pass = technique->createPass();
pass->setVertexColourTracking(Ogre::TVC_AMBIENT|Ogre::TVC_DIFFUSE);
pass->createTextureUnitState(mCompositeMap)->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
}
else
{
assert(mLayerList.size() == mBlendmapList.size()+1);
std::vector<Ogre::TexturePtr>::iterator blend = mBlendmapList.begin();
for (std::vector<LayerInfo>::iterator layer = mLayerList.begin(); layer != mLayerList.end(); ++layer)
{
Ogre::Pass* pass = technique->createPass();
pass->setLightingEnabled(false);
pass->setVertexColourTracking(Ogre::TVC_NONE);
// TODO: How to handle fog?
pass->setFog(true, Ogre::FOG_NONE);
bool first = (layer == mLayerList.begin());
Ogre::TextureUnitState* tus;
if (!first)
{
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthFunction(Ogre::CMPF_EQUAL);
tus = pass->createTextureUnitState((*blend)->getName());
tus->setAlphaOperation(Ogre::LBX_BLEND_TEXTURE_ALPHA,
Ogre::LBS_TEXTURE,
Ogre::LBS_TEXTURE);
tus->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA,
Ogre::LBS_TEXTURE,
Ogre::LBS_TEXTURE);
tus->setIsAlpha(true);
tus->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
float scale = (16/(16.f+1.f));
tus->setTextureScale(1.f/scale,1.f/scale);
}
// Add the actual layer texture on top of the alpha map.
tus = pass->createTextureUnitState(layer->mDiffuseMap);
if (!first)
tus->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA,
Ogre::LBS_TEXTURE,
Ogre::LBS_CURRENT);
tus->setTextureScale(1/16.f,1/16.f);
if (!first)
++blend;
}
if (!renderCompositeMap)
{
Ogre::Pass* lightingPass = technique->createPass();
lightingPass->setSceneBlending(Ogre::SBT_MODULATE);
lightingPass->setVertexColourTracking(Ogre::TVC_AMBIENT|Ogre::TVC_DIFFUSE);
lightingPass->setFog(true, Ogre::FOG_NONE);
}
}
return mat;
}
#if TERRAIN_USE_SHADER
else
{
sh::MaterialInstance* material = sh::Factory::getInstance().createMaterialInstance (name.str());
material->setProperty ("allow_fixed_function", sh::makeProperty<sh::BooleanValue>(new sh::BooleanValue(false)));
if (displayCompositeMap)
{
sh::MaterialInstancePass* p = material->createPass ();
p->setProperty ("vertex_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_vertex")));
p->setProperty ("fragment_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_fragment")));
p->mShaderProperties.setProperty ("is_first_pass", sh::makeProperty(new sh::BooleanValue(true)));
p->mShaderProperties.setProperty ("render_composite_map", sh::makeProperty(new sh::BooleanValue(false)));
p->mShaderProperties.setProperty ("display_composite_map", sh::makeProperty(new sh::BooleanValue(true)));
p->mShaderProperties.setProperty ("num_layers", sh::makeProperty (new sh::StringValue("0")));
p->mShaderProperties.setProperty ("num_blendmaps", sh::makeProperty (new sh::StringValue("0")));
p->mShaderProperties.setProperty ("normal_map_enabled", sh::makeProperty (new sh::BooleanValue(false)));
p->mShaderProperties.setProperty ("parallax_enabled", sh::makeProperty (new sh::BooleanValue(false)));
p->mShaderProperties.setProperty ("normal_maps",
sh::makeProperty (new sh::IntValue(0)));
sh::MaterialInstanceTextureUnit* tex = p->createTextureUnit ("compositeMap");
tex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(mCompositeMap)));
tex->setProperty ("tex_address_mode", sh::makeProperty (new sh::StringValue("clamp")));
// shadow. TODO: repeated, put in function
if (mShadows)
{
for (int i = 0; i < (mSplitShadows ? 3 : 1); ++i)
{
sh::MaterialInstanceTextureUnit* shadowTex = p->createTextureUnit ("shadowMap" + Ogre::StringConverter::toString(i));
shadowTex->setProperty ("content_type", sh::makeProperty<sh::StringValue> (new sh::StringValue("shadow")));
}
}
p->mShaderProperties.setProperty ("shadowtexture_offset", sh::makeProperty (new sh::StringValue(
Ogre::StringConverter::toString(1))));
p->mShaderProperties.setProperty ("pass_index", sh::makeProperty(new sh::IntValue(0)));
}
else
{
bool shadows = mShadows && !renderCompositeMap;
int layerOffset = 0;
while (layerOffset < (int)mLayerList.size())
{
int blendmapOffset = (layerOffset == 0) ? 1 : 0; // the first layer of the first pass is the base layer and does not need a blend map
// Check how many layers we can fit in this pass
int numLayersInThisPass = 0;
int numBlendTextures = 0;
std::vector<std::string> blendTextures;
int remainingTextureUnits = OGRE_MAX_TEXTURE_LAYERS;
if (shadows)
remainingTextureUnits -= (mSplitShadows ? 3 : 1);
while (remainingTextureUnits && layerOffset + numLayersInThisPass < (int)mLayerList.size())
{
int layerIndex = numLayersInThisPass + layerOffset;
int neededTextureUnits=0;
int neededBlendTextures=0;
if (layerIndex != 0)
{
std::string blendTextureName = mBlendmapList[getBlendmapIndexForLayer(layerIndex)]->getName();
if (std::find(blendTextures.begin(), blendTextures.end(), blendTextureName) == blendTextures.end())
{
blendTextures.push_back(blendTextureName);
++neededBlendTextures;
++neededTextureUnits; // blend texture
}
}
++neededTextureUnits; // layer texture
// Check if this layer has a normal map
if (mNormalMapping && !mLayerList[layerIndex].mNormalMap.empty() && !renderCompositeMap)
++neededTextureUnits; // normal map
if (neededTextureUnits <= remainingTextureUnits)
{
// We can fit another!
remainingTextureUnits -= neededTextureUnits;
numBlendTextures += neededBlendTextures;
++numLayersInThisPass;
}
else
break; // We're full
}
sh::MaterialInstancePass* p = material->createPass ();
p->setProperty ("vertex_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_vertex")));
p->setProperty ("fragment_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_fragment")));
if (layerOffset != 0)
{
p->setProperty ("scene_blend", sh::makeProperty(new sh::StringValue("alpha_blend")));
// Only write if depth is equal to the depth value written by the previous pass.
p->setProperty ("depth_func", sh::makeProperty(new sh::StringValue("equal")));
}
p->mShaderProperties.setProperty ("render_composite_map", sh::makeProperty(new sh::BooleanValue(renderCompositeMap)));
p->mShaderProperties.setProperty ("display_composite_map", sh::makeProperty(new sh::BooleanValue(displayCompositeMap)));
p->mShaderProperties.setProperty ("num_layers", sh::makeProperty (new sh::StringValue(Ogre::StringConverter::toString(numLayersInThisPass))));
p->mShaderProperties.setProperty ("num_blendmaps", sh::makeProperty (new sh::StringValue(Ogre::StringConverter::toString(numBlendTextures))));
p->mShaderProperties.setProperty ("normal_map_enabled",
sh::makeProperty (new sh::BooleanValue(false)));
// blend maps
// the index of the first blend map used in this pass
int blendmapStart;
if (mLayerList.size() == 1) // special case. if there's only one layer, we don't need blend maps at all
blendmapStart = 0;
else
blendmapStart = getBlendmapIndexForLayer(layerOffset+blendmapOffset);
for (int i = 0; i < numBlendTextures; ++i)
{
sh::MaterialInstanceTextureUnit* blendTex = p->createTextureUnit ("blendMap" + Ogre::StringConverter::toString(i));
blendTex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(mBlendmapList[blendmapStart+i]->getName())));
blendTex->setProperty ("tex_address_mode", sh::makeProperty (new sh::StringValue("clamp")));
}
// layer maps
bool anyNormalMaps = false;
bool anyParallax = false;
size_t normalMaps = 0;
for (int i = 0; i < numLayersInThisPass; ++i)
{
const LayerInfo& layer = mLayerList[layerOffset+i];
// diffuse map
sh::MaterialInstanceTextureUnit* diffuseTex = p->createTextureUnit ("diffuseMap" + Ogre::StringConverter::toString(i));
diffuseTex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(layer.mDiffuseMap)));
// normal map (optional)
bool useNormalMap = mNormalMapping && !mLayerList[layerOffset+i].mNormalMap.empty() && !renderCompositeMap;
bool useParallax = useNormalMap && mParallaxMapping && layer.mParallax;
bool useSpecular = layer.mSpecular;
if (useNormalMap)
{
anyNormalMaps = true;
anyParallax = anyParallax || useParallax;
sh::MaterialInstanceTextureUnit* normalTex = p->createTextureUnit ("normalMap" + Ogre::StringConverter::toString(i));
normalTex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(layer.mNormalMap)));
}
p->mShaderProperties.setProperty ("use_normal_map_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::BooleanValue(useNormalMap)));
p->mShaderProperties.setProperty ("use_parallax_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::BooleanValue(useParallax)));
p->mShaderProperties.setProperty ("use_specular_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::BooleanValue(useSpecular)));
boost::hash_combine(normalMaps, useNormalMap);
boost::hash_combine(normalMaps, useNormalMap && layer.mParallax);
boost::hash_combine(normalMaps, useSpecular);
if (i+layerOffset > 0)
{
int blendTextureIndex = getBlendmapIndexForLayer(layerOffset+i);
std::string blendTextureComponent = getBlendmapComponentForLayer(layerOffset+i);
p->mShaderProperties.setProperty ("blendmap_component_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::StringValue(Ogre::StringConverter::toString(blendTextureIndex-blendmapStart) + "." + blendTextureComponent)));
}
else
{
// just to make it shut up about blendmap_component_0 not existing in the first pass.
// it might be retrieved, but will never survive the preprocessing step.
p->mShaderProperties.setProperty ("blendmap_component_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::StringValue("")));
}
}
p->mShaderProperties.setProperty ("normal_map_enabled",
sh::makeProperty (new sh::BooleanValue(anyNormalMaps)));
p->mShaderProperties.setProperty ("parallax_enabled",
sh::makeProperty (new sh::BooleanValue(anyParallax)));
// Since the permutation handler can't handle dynamic property names,
// combine normal map settings for all layers into one value
p->mShaderProperties.setProperty ("normal_maps",
sh::makeProperty (new sh::IntValue(normalMaps)));
// shadow
if (shadows)
{
for (int i = 0; i < (mSplitShadows ? 3 : 1); ++i)
{
sh::MaterialInstanceTextureUnit* shadowTex = p->createTextureUnit ("shadowMap" + Ogre::StringConverter::toString(i));
shadowTex->setProperty ("content_type", sh::makeProperty<sh::StringValue> (new sh::StringValue("shadow")));
}
}
p->mShaderProperties.setProperty ("shadowtexture_offset", sh::makeProperty (new sh::StringValue(
Ogre::StringConverter::toString(numBlendTextures + numLayersInThisPass))));
// Make sure the pass index is fed to the permutation handler, because blendmap components may be different
p->mShaderProperties.setProperty ("pass_index", sh::makeProperty(new sh::IntValue(layerOffset)));
assert ((int)p->mTexUnits.size() == OGRE_MAX_TEXTURE_LAYERS - remainingTextureUnits);
layerOffset += numLayersInThisPass;
}
}
}
#endif
return Ogre::MaterialManager::getSingleton().getByName(name.str());
}
void MaterialGenerator::createTexUnits(Ogre::Pass* pass)
{
Ogre::TextureUnitState* tu;
// diffuse / light / blend maps
if (needDiffuseMap())
{
tu = pass->createTextureUnitState( mDiffuseMap );
tu->setName("diffuseMap");
tu->setTextureAddressingMode(mDef->mProps->textureAddressMode);
mDiffuseTexUnit = mTexUnit_i; mTexUnit_i++;
}
if (needLightMap())
{
tu = pass->createTextureUnitState( mLightMap );
tu->setName("lightMap");
tu->setTextureAddressingMode(mDef->mProps->textureAddressMode);
mLightTexUnit = mTexUnit_i; mTexUnit_i++;
}
if (needBlendMap())
{
tu = pass->createTextureUnitState( mBlendMap );
tu->setName("blendMap");
tu->setTextureAddressingMode(mDef->mProps->textureAddressMode);
mBlendTexUnit = mTexUnit_i; mTexUnit_i++;
}
// spec map
if (needSpecMap())
{
tu = pass->createTextureUnitState( mSpecMap );
tu->setName("specMap");
tu->setTextureAddressingMode(mDef->mProps->textureAddressMode);
mSpecTexUnit = mTexUnit_i; mTexUnit_i++;
}
// reflectivity map
if (needReflectivityMap())
{
tu = pass->createTextureUnitState( mReflMap );
tu->setName("reflectivityMap");
tu->setTextureAddressingMode(mDef->mProps->textureAddressMode);
mReflTexUnit = mTexUnit_i; mTexUnit_i++;
}
// global terrain lightmap (static)
if (needTerrainLightMap())
{
tu = pass->createTextureUnitState(String("white.png")); // texture name set later (in changeShadows)
tu->setName("terrainLightMap");
mTerrainLightTexUnit = mTexUnit_i; mTexUnit_i++;
}
// alpha map
if (needAlphaMap())
{
tu = pass->createTextureUnitState( mAlphaMap );
tu->setName("alphaMap");
mAlphaTexUnit = mTexUnit_i; mTexUnit_i++;
}
// normal map
if (needNormalMap())
{
tu = pass->createTextureUnitState( mNormalMap );
tu->setName("normalMap");
mNormalTexUnit = mTexUnit_i; mTexUnit_i++;
}
// env map
if (needEnvMap())
{
tu = pass->createTextureUnitState( mDef->mProps->envMap );
tu->setName("envMap");
tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
mEnvTexUnit = 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++;
}
}
}
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 ParticleMaterialGenerator::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();
// particledepth pass
Ogre::Pass* particleDepthPass = technique->createPass();
particleDepthPass->setAmbient( mDef->mProps->ambient.x, mDef->mProps->ambient.y, mDef->mProps->ambient.z );
particleDepthPass->setDiffuse( mDef->mProps->diffuse.x, mDef->mProps->diffuse.y, mDef->mProps->diffuse.z, 1.0 );
particleDepthPass->setSpecular(mDef->mProps->specular.x, mDef->mProps->specular.y, mDef->mProps->specular.z, mDef->mProps->specular.w);
particleDepthPass->setFog(true); // actually this disables fog
if (!mDef->mProps->lighting)
particleDepthPass->setLightingEnabled(false);
if (mDef->mProps->sceneBlend == SBM_ALPHA_BLEND)
particleDepthPass->setSceneBlending(SBT_TRANSPARENT_ALPHA);
else if (mDef->mProps->sceneBlend == SBM_COLOUR_BLEND)
particleDepthPass->setSceneBlending(SBT_TRANSPARENT_COLOUR);
else if (mDef->mProps->sceneBlend == SBM_ADD)
particleDepthPass->setSceneBlending(SBT_ADD);
else if (mDef->mProps->sceneBlend == SBM_MODULATE)
particleDepthPass->setSceneBlending(SBT_MODULATE);
particleDepthPass->setDepthWriteEnabled( mDef->mProps->depthWrite );
particleDepthPass->setDepthCheckEnabled( mDef->mProps->depthCheck );
particleDepthPass->setTransparentSortingEnabled( mDef->mProps->transparentSorting );
particleDepthPass->setAlphaRejectFunction( mDef->mProps->alphaRejectFunc );
particleDepthPass->setAlphaRejectValue( mDef->mProps->alphaRejectValue );
Ogre::TextureUnitState* tu = particleDepthPass->createTextureUnitState( mDiffuseMap );
tu->setName("diffuseMap");
tu->setTextureAddressingMode(mDef->mProps->textureAddressMode);
tu = particleDepthPass->createTextureUnitState();
tu->setName("depthMap");
tu->setTextureAddressingMode(mDef->mProps->textureAddressMode);
// create shaders
HighLevelGpuProgramPtr fragmentProg, vertexProg;
try
{
vertexProg = createSoftParticleVertexProgram();
fragmentProg = createSoftParticleFragmentProgram();
}
catch (Ogre::Exception& e) {
LogO(e.getFullDescription());
}
if (fragmentProg.isNull() || vertexProg.isNull() ||
!fragmentProg->isSupported() || !vertexProg->isSupported())
{
LogO("[MaterialFactory] WARNING: ambient shader for material '" + mDef->getName()
+ "' is not supported.");
}
else
{
particleDepthPass->setVertexProgram(vertexProg->getName());
particleDepthPass->setFragmentProgram(fragmentProg->getName());
}
createSSAOTechnique();
createOccluderTechnique();
// indicate we need depth buffer set every frame
mParent->softMtrs.push_back(mDef->getName());
}
// void TerrainPageSurfaceCompiler::addTextureUnitsToPass(Ogre::Pass* pass, const Ogre::String& splatTextureName) {
//
// if (getMaxTextureUnits() - pass->getNumTextureUnitStates() < 2 || pass->getParent()->getNumPasses() > 1) {
// addPassToTechnique(pass->getParent(), splatTextureName);
// // S_LOG_WARNING("Trying to add texture units to pass with too few available texture unit states.");
// return;
// }
//
// S_LOG_VERBOSE("Adding new texture unit (detailtexture: " << mTextureName << " alphatexture: " << splatTextureName << ") to pass nr " << pass->getIndex() << " in technique for material " << pass->getParent()->getParent()->getName());
//
// /* pass->setSelfIllumination(Ogre::ColourValue(1,1,1));
// pass->setAmbient(Ogre::ColourValue(1,1,1));
// pass->setDiffuse(Ogre::ColourValue(1,1,1));
// pass->setLightingEnabled(true);*/
// Ogre::TextureUnitState * textureUnitStateSplat = pass->createTextureUnitState();
// textureUnitStateSplat->setTextureName(splatTextureName);
//
// textureUnitStateSplat->setTextureCoordSet(0);
// textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
// textureUnitStateSplat->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE);
// textureUnitStateSplat->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT);
// textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
// // textureUnitStateSplat->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE);
// // textureUnitStateSplat->setColourOperationEx(Ogre::LBX_BLEND_TEXTURE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE);
//
// Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
// textureUnitState->setTextureName(mTextureName);
// textureUnitState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
// /* textureUnitState->setTextureCoordSet(0);*/
// textureUnitState->setTextureScale(0.025, 0.025);
// textureUnitState->setColourOperationEx(Ogre::LBX_BLEND_CURRENT_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);
//
// /* Ogre::TextureUnitState * alphaTextureState= pass->createTextureUnitState();
// alphaTextureState->setTextureName(mTextureName);
// // alphaTextureState->setTextureName(splatTextureName);
// alphaTextureState->setTextureCoordSet(0);
// alphaTextureState->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
// alphaTextureState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
// alphaTextureState->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE);
//
//
//
// // detailTextureState->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE);
// // detailTextureState->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT);
//
// Ogre::TextureUnitState * detailTextureState = pass->createTextureUnitState();
// detailTextureState ->setTextureName(splatTextureName);
// // detailTextureState ->setTextureName(mTextureName);
// detailTextureState ->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
// detailTextureState ->setTextureCoordSet(0);
// detailTextureState ->setTextureScale(0.01, 0.01);
// //detailTextureState ->setColourOperationEx(Ogre::LBX_BLEND_CURRENT_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);*/
//
// }
//
Ogre::Pass* Simple::addPassToTechnique(const TerrainPageGeometry& geometry, Ogre::Technique* technique, const Layer& layer, std::set<std::string>& managedTextures) const
{
//check if we instead can reuse the existing pass
// if (technique->getNumPasses() != 0) {
// Ogre::Pass* pass = technique->getPass(technique->getNumPasses() - 1);
// if (4 - pass->getNumTextureUnitStates() >= 2) {
// //there's more than two texture units available, use those instead of creating a new pass
// S_LOG_VERBOSE("Reusing existing pass. ("<< pass->getNumTextureUnitStates() << " of "<< mNumberOfTextureUnitsOnCard << " texture unit used)");
// addTextureUnitsToPass(pass, splatTextureName);
// return pass;
// }
//
// }
const OgreImage& ogreImage = *layer.blendMap;
Ogre::Image image;
image.loadDynamicImage(const_cast<unsigned char*>(ogreImage.getData()), ogreImage.getResolution(), ogreImage.getResolution(), 1, Ogre::PF_A8);
std::stringstream splatTextureNameSS;
splatTextureNameSS << "terrain_" << mPage.getWFPosition().x() << "_" << mPage.getWFPosition().y() << "_" << technique->getNumPasses();
const Ogre::String splatTextureName(splatTextureNameSS.str());
Ogre::TexturePtr blendMapTexture;
if (Ogre::Root::getSingletonPtr()->getTextureManager()->resourceExists(splatTextureName)) {
blendMapTexture = static_cast<Ogre::TexturePtr>(Ogre::Root::getSingletonPtr()->getTextureManager()->getByName(splatTextureName));
blendMapTexture->loadImage(image);
Ogre::HardwarePixelBufferSharedPtr hardwareBuffer(blendMapTexture->getBuffer());
//blit the whole image to the hardware buffer
Ogre::PixelBox sourceBox(image.getPixelBox());
hardwareBuffer->blitFromMemory(sourceBox);
} else {
blendMapTexture = Ogre::Root::getSingletonPtr()->getTextureManager()->loadImage(splatTextureName, "General", image, Ogre::TEX_TYPE_2D, 0);
managedTextures.insert(blendMapTexture->getName());
}
//we need to create the image, update it and then destroy it again (to keep the memory usage down)
// if (layer->getBlendMapTextureName() == "") {
// //no texture yet; let's create one
// layer->createBlendMapImage();
// layer->updateBlendMapImage(geometry);
// layer->createTexture();
// } else {
// //a texture exists, so we just need to update the image
// layer->updateBlendMapImage(geometry); //calling this will also update the texture since the method will blit the image onto it
// }
Ogre::Pass* pass = technique->createPass();
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setAmbient(1, 1, 1);
pass->setDiffuse(1, 1, 1, 1);
pass->setLightingEnabled(false);
Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
textureUnitState->setTextureName(layer.surfaceLayer.getDiffuseTextureName());
textureUnitState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
textureUnitState->setTextureCoordSet(0);
textureUnitState->setTextureScale(1.0f / layer.surfaceLayer.getScale(), 1.0f / layer.surfaceLayer.getScale());
Ogre::TextureUnitState * textureUnitStateSplat = pass->createTextureUnitState();
textureUnitStateSplat->setTextureName(blendMapTexture->getName());
textureUnitStateSplat->setTextureCoordSet(0);
textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
// textureUnitStateSplat->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE);
textureUnitStateSplat->setAlphaOperation(Ogre::LBX_BLEND_DIFFUSE_COLOUR, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);
textureUnitStateSplat->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT);
return pass;
}
