OverlayContainer* MenuSheet::createOverlay(int id, const std::string& text, int x, int y, int w, int h) {
std::string ovname = mName + "/" + Ogre::StringConverter::toString(id);
OverlayContainer* ov;
if (text.empty())
ov = static_cast<OverlayContainer*>(OverlayManager::getSingleton().createOverlayElement("Panel", ovname));
else
ov = static_cast<OverlayContainer*>(OverlayManager::getSingleton().createOverlayElement("TextArea", ovname));
ov->setMetricsMode(GMM_PIXELS);
// text area centered around X point, so we create it with w/2 surplus
if (text.empty())
ov->setPosition(x, y);
else
ov->setPosition(x + w/2, y);
ov->setDimensions(w, h);
ov->setCaption(text);
ov->setParameter("font_name", mFont);
ov->setParameter("char_height", StringConverter::toString(mFontSize));
ov->setParameter("alignment", "center");
ov->show();
mOverlay->add2D(ov);
return ov;
}
void GraphicsController::addTextureDebugOverlay(const Ogre::String& texname, size_t i)
{
using namespace Ogre;
Overlay* debugOverlay = OverlayManager::getSingleton().getByName("PRJZ/DebugOverlay");
MaterialPtr debugMat = MaterialManager::getSingleton().getByName("PRJZ/BasicTexture", "PROJECT_ZOMBIE");
if(debugMat.isNull())
OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "PRJZ/BasicTexture material was not found.", "GraphicsController::addTextureDebugOverlay");
debugMat->getTechnique(0)->getPass(0)->setLightingEnabled(false);
TextureUnitState *t = debugMat->getTechnique(0)->getPass(0)->createTextureUnitState(texname);
t->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
Ogre::TexturePtr tex = Ogre::TextureManager::getSingleton().getByName(texname);
Ogre::Real tWidth = tex->getWidth();
Ogre::Real tHeight = tex->getHeight();
//ratio
Ogre::Real ratio = tHeight / tWidth;
OverlayContainer* debugPanel = (OverlayContainer*)
(OverlayManager::getSingleton().createOverlayElement("Panel", "Ogre/DebugTexPanel" + StringConverter::toString(i)));
debugPanel->_setPosition(0.0, 0.0);
debugPanel->_setDimensions(0.5f, 0.5f * ratio);
debugPanel->setMaterialName(debugMat->getName());
debugOverlay->add2D(debugPanel);
}
//---------------------------------------------------------------------
void OverlayManager::destroyAllOverlayElementsImpl(ElementMap& elementMap)
{
ElementMap::iterator i;
while ((i = elementMap.begin()) != elementMap.end())
{
OverlayElement* element = i->second;
// Get factory to delete
FactoryMap::iterator fi = mFactories.find(element->getTypeName());
if (fi == mFactories.end())
{
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate factory for element "
+ element->getName(),
"OverlayManager::destroyAllOverlayElements");
}
// remove from parent, if any
OverlayContainer* parent;
if ((parent = element->getParent()) != 0)
{
parent->_removeChild(element->getName());
}
// children of containers will be auto-removed when container is destroyed.
// destroy the element and remove it from the list
fi->second->destroyOverlayElement(element);
elementMap.erase(i);
}
}
//-----------------------------------------------------------------------------------
void Sample_Compositor::setupControls(void)
{
mTrayMgr->createButton(TL_TOPLEFT, "PageButton", "Compositors", 175);
for (size_t i=0; i < COMPOSITORS_PER_PAGE; i++)
{
String checkBoxName = "Compositor_" + Ogre::StringConverter::toString(i);
CheckBox* cb = mTrayMgr->createCheckBox(TL_TOPLEFT, checkBoxName, "Compositor", 175);
cb->hide();
}
changePage(0);
mDebugTextureSelectMenu = mTrayMgr->createThickSelectMenu(TL_TOPRIGHT, "DebugRTTSelectMenu", "Debug RTT", 180, 5);
mDebugTextureSelectMenu->addItem("None");
mTrayMgr->createSeparator(TL_TOPRIGHT, "DebugRTTSep1"); // this is a hack to give the debug RTT a bit more room
DecorWidget* debugRTTPanel = mTrayMgr->createDecorWidget(TL_NONE, "DebugRTTPanel", "SdkTrays/Picture");
OverlayContainer* debugRTTContainer = (OverlayContainer*)debugRTTPanel->getOverlayElement();
mDebugTextureTUS = debugRTTContainer->getMaterial()->getBestTechnique()->getPass(0)->getTextureUnitState(0);
//mDebugTextureTUS->setTextureName("CompositorDemo/DebugView");
debugRTTContainer->setDimensions(128, 128);
debugRTTContainer->getChild("DebugRTTPanel/PictureFrame")->setDimensions(144, 144);
debugRTTPanel->hide();
mTrayMgr->createSeparator(TL_TOPRIGHT, "DebugRTTSep2"); // this is a hack to give the debug RTT a bit more room
mTrayMgr->showCursor();
mTrayMgr->showLogo(TL_BOTTOMLEFT);
mTrayMgr->toggleAdvancedFrameStats();
}
int ShadowManager::updateShadowTechnique()
{
float scoef = 0.5;
gEnv->sceneManager->setShadowColour(Ogre::ColourValue(0.563 + scoef, 0.578 + scoef, 0.625 + scoef));
gEnv->sceneManager->setShowDebugShadows(false);
RoR::App::GfxShadowType type = RoR::App::GetGfxShadowType();
if (type == RoR::App::GFX_SHADOW_TYPE_TEXTURE)
{
gEnv->sceneManager->setShadowFarDistance(RoR::App::GetGfxSightRange());
processTextureShadows();
}
else if (type == RoR::App::GFX_SHADOW_TYPE_PSSM)
{
processPSSM();
if (gEnv->sceneManager->getShowDebugShadows())
{
// add the overlay elements to show the shadow maps:
// init overlay elements
OverlayManager& mgr = Ogre::OverlayManager::getSingleton();
Overlay* overlay = mgr.create("DebugOverlay");
for (int i = 0; i < PSSM_Shadows.ShadowsTextureNum; ++i)
{
TexturePtr tex = gEnv->sceneManager->getShadowTexture(i);
// Set up a debug panel to display the shadow
MaterialPtr debugMat = MaterialManager::getSingleton().create("Ogre/DebugTexture" + StringConverter::toString(i), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
debugMat->getTechnique(0)->getPass(0)->setLightingEnabled(false);
TextureUnitState* t = debugMat->getTechnique(0)->getPass(0)->createTextureUnitState(tex->getName());
t->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
OverlayContainer* debugPanel = (OverlayContainer*)(OverlayManager::getSingleton().createOverlayElement("Panel", "Ogre/DebugTexPanel" + StringConverter::toString(i)));
debugPanel->_setPosition(0.8, i * 0.25);
debugPanel->_setDimensions(0.2, 0.24);
debugPanel->setMaterialName(debugMat->getName());
debugPanel->setEnabled(true);
overlay->add2D(debugPanel);
overlay->show();
}
}
}
return 0;
}
// -------------------------------------------------------------------------
OgreBulletGuiListener::OgreBulletGuiListener(OgreBulletListener *listener, Ogre::RenderWindow *win) :
mListener(listener),
mWindow(win),
mMouseOverlay(0),
mMousePanel(0)
{
/******************* CREATE Cursor Overlay ***************************/
mMouseOverlay = (Overlay*)OverlayManager::getSingleton().getByName("GuiOverlay");
if (mMouseOverlay)
{
mMousePanel = OverlayManager::getSingleton().getOverlayElement ("GUIMouse");
}
else
{
mMouseOverlay = OverlayManager::getSingletonPtr()->create("GuiOverlay");
mMouseOverlay->setZOrder(600);
mMousePanel = (Ogre::OverlayElement *)
OverlayManager::getSingletonPtr()->createOverlayElement("Panel", "GUIMouse");
mMousePanel->setMaterialName("OgreBulletDemos/TargetSights");
TexturePtr mouseTex = TextureManager::getSingleton().load("target.png", "Bullet");
mMousePanel->setWidth (mouseTex->getWidth() / (float)win->getWidth());
mMousePanel->setHeight (mouseTex->getHeight() / (float)win->getHeight());
Ogre::OverlayContainer *mouseContainer = (Ogre::OverlayContainer*)
OverlayManager::getSingletonPtr()->createOverlayElement("Panel", "GUIContainer");
mMouseOverlay->add2D(mouseContainer);
mouseContainer->addChild(mMousePanel);
}
mMouseOverlay->show();
TexturePtr mouseTex = TextureManager::getSingleton().load("target.png", "Bullet");
mMouseCursorHalfWidth = (Real(mouseTex->getWidth()) / mWindow->getWidth()) * 0.5;
mMouseCursorHalfHeight = (Real(mouseTex->getHeight()) / mWindow->getHeight ()) * 0.5;
/******************* CREATE GUI ***************************/
mGui = new BetaGUI::GUI("OgreBulletGui", "BlueHighway", 14, win);
OverlayContainer* mouseCursor = mGui->createMousePointer(Vector2(32, 32), "bgui.pointer");
mouseCursor->hide();
mGui->injectMouse(mWindow->getWidth() * 0.5, mWindow->getHeight() * 0.5, false);
}
OverlayElement* OverlayContainer::clone(const String& instanceName)
{
OverlayContainer *newContainer;
newContainer = static_cast<OverlayContainer*>(OverlayElement::clone(instanceName));
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
OverlayElement* oldChildElement = it.getNext();
if (oldChildElement->isCloneable())
{
OverlayElement* newChildElement = oldChildElement->clone(instanceName);
newContainer->_addChild(newChildElement);
}
}
return newContainer;
}
//-------------------------------------------------------------------------------------
void ScriptInterpreter::createScene(void)
{
if (mScriptSourceMode == SSM_SCRIPTDIR)
{
ResourceGroupManager::getSingleton().destroyResourceGroup("Scripts");
ResourceGroupManager::getSingleton().createResourceGroup("Scripts");
ResourceGroupManager::getSingleton().addResourceLocation(mScriptDir, "FileSystem", "Scripts");
}
mDefaultTriangleBuffer = PlaneGenerator().buildTriangleBuffer();
Overlay* o = OverlayManager::getSingleton().create("myOverlay");
OverlayContainer* cont = (OverlayContainer*)OverlayManager::getSingleton().createOverlayElement("Panel","myCont");
o->add2D(cont);
mTextMessage = OverlayManager::getSingleton().createOverlayElement("TextArea","myText");
cont->addChild(mTextMessage);
mTextMessage->setCaption("Ogre program");
mTextMessage->setParameter("font_name","SdkTrays/Caption");
o->show();
checkScriptModified();
}
//-----------------------------------------------------------------------
void OverlayProfileSessionListener::finializeSession()
{
OverlayContainer* container = dynamic_cast<OverlayContainer*>(mProfileGui);
if (container)
{
OverlayContainer::ChildIterator children = container->getChildIterator();
while (children.hasMoreElements())
{
OverlayElement* element = children.getNext();
OverlayContainer* parent = element->getParent();
if (parent) parent->removeChild(element->getName());
OverlayManager::getSingleton().destroyOverlayElement(element);
}
}
if(mProfileGui)
OverlayManager::getSingleton().destroyOverlayElement(mProfileGui);
if(mOverlay)
OverlayManager::getSingleton().destroy(mOverlay);
mProfileBars.clear();
}
void HUD::multiplayer()
{
OverlayManager& overlayManager = OverlayManager::getSingleton();
// Create a panel
OverlayContainer* panel = static_cast<OverlayContainer*>(
overlayManager.createOverlayElement("Panel", "MultiplayerPanel"));
panel->setMetricsMode(Ogre::GMM_PIXELS);
panel->setPosition(20, 20);
panel->setDimensions(200, 250);
panel->setMaterialName("PanelAchtergrondImage"); // Optional background material
// Create a text area
m_textMessages = static_cast<TextAreaOverlayElement*>(
overlayManager.createOverlayElement("TextArea", "MultiplayerTextArea"));
m_textMessages->setMetricsMode(Ogre::GMM_PIXELS);
m_textMessages->setPosition(10, 50);
m_textMessages->setDimensions(150, 100);
m_textMessages->setCaption("GoClient 0.1");
m_textMessages->setCharHeight(16);
m_textMessages->setFontName("ArialFont");
m_textMessages->setColourBottom(ColourValue(0.6, 0.6, 0.6));
m_textMessages->setColourTop(ColourValue(1, 1, 1));
// Create an overlay, and add the panel
m_overlay = overlayManager.create("MultiplayerOverlay");
m_overlay->add2D(panel);
// Add the text area to the panel
panel->addChild(m_textMessages);
// Show the overlay
m_overlay->show();
}
void OverlayHelper::SafeDestroyOverlayElement(OverlayElement *item)
{
if (item->isContainer())
{
OverlayContainer *container = (OverlayContainer*) item;
// Arrggghh the variable is protected
// ((OverlayContainer*)item)->mOverlay->remove2D((OverlayContainer*)item);
OverlayManager::OverlayMapIterator iter1 = OverlayManager::getSingleton().getOverlayIterator();
while (iter1.hasMoreElements())
{
iter1.getNext()->remove2D(container);
}
OverlayContainer::ChildIterator iter2 = container->getChildIterator();
while (iter2.hasMoreElements())
{
iter2.getNext()->_setParent(0);
}
OverlayContainer::ChildContainerIterator iter3 = container->getChildContainerIterator();
while (iter3.hasMoreElements())
{
iter3.getNext()->_setParent(0);
}
}
if (item->getParent())
item->getParent()->removeChild(item->getName());
OverlayManager::getSingleton().destroyOverlayElement(item);
unsigned i;
i=0;
while (i < timedOverlays.Size())
{
if (timedOverlays[i].overlayElement==item)
timedOverlays.RemoveAtIndex(i);
else
i++;
}
}
//-----------------------------------------------------------------------
void Profiler::setEnabled(bool enabled)
{
if (!mInitialized && enabled)
{
// the user wants to enable the Profiler for the first time
// so we initialize the GUI stuff
initialize();
mInitialized = true;
}
else
{
OverlayContainer* container = dynamic_cast<OverlayContainer*>(mProfileGui);
if (container)
{
OverlayContainer::ChildIterator children = container->getChildIterator();
while (children.hasMoreElements())
{
OverlayElement* element = children.getNext();
OverlayContainer* parent = element->getParent();
if (parent) parent->removeChild(element->getName());
OverlayManager::getSingleton().destroyOverlayElement(element);
}
}
if(mProfileGui)
OverlayManager::getSingleton().destroyOverlayElement(mProfileGui);
if(mOverlay)
OverlayManager::getSingleton().destroy(mOverlay);
mProfileBars.clear();
mInitialized = false;
mEnabled = false;
}
// We store this enable/disable request until the frame ends
// (don't want to screw up any open profiles!)
mNewEnableState = enabled;
}
void Splash::createScene()
{
log("[Loading] Creating the splash screen...");
// Loading picture
overlayManager = &OverlayManager::getSingleton();
overlay = overlayManager->create("LoadingOverlay");
((MaterialPtr)MaterialManager::getSingleton().create("LoadingMaterial","splash"))->getTechnique(0)->getPass(0)->createTextureUnitState("loading.png");
OverlayContainer* panel = static_cast<OverlayContainer*>(overlayManager->createOverlayElement("Panel","LoadingPanel"));
panel->setMaterialName("LoadingMaterial");
panel->setDimensions(1,0.96f);
// Progess bar
OverlayContainer* progressBar = static_cast<OverlayContainer*>(overlayManager->createOverlayElement("Panel","ProgressBar"));
progressBar->setDimensions(1,0.04f);
progressBar->setPosition(0,0.96f);
MaterialPtr progressBGMat = MaterialManager::getSingleton().create("progressBG","splash");
progressBGMat->getTechnique(0)->getPass(0)->createTextureUnitState()->setColourOperationEx(LBX_SOURCE1,LBS_MANUAL,LBS_CURRENT,ColourValue(0.9f, 0.9f, 0.9f));;
MaterialPtr progressFGMat = MaterialManager::getSingleton().create("progressFG","splash");
progressFGMat->getTechnique(0)->getPass(0)->createTextureUnitState()->setColourOperationEx(LBX_SOURCE1,LBS_MANUAL,LBS_CURRENT,ColourValue(0.23f, 0.88f, 0.5f));;
progressBG = static_cast<OverlayContainer*>(overlayManager->createOverlayElement("Panel","ProgressBarBG"));
progressBG->setMaterialName("progressBG");
progressBG->setDimensions(1,1);
progressFG = static_cast<OverlayContainer*>(overlayManager->createOverlayElement("Panel","ProgressBarFG"));
progressFG->setMaterialName("progressFG");
progressFG->setDimensions(0,1);
// Loading text
FontManager::getSingleton().getByName("BlueHighway")->load(); // HACK: Workaround for bug #324 in Ogre
progressText = static_cast<TextAreaOverlayElement*>(overlayManager->createOverlayElement("TextArea", "text"));
progressText->setMetricsMode(GuiMetricsMode::GMM_RELATIVE);
progressText->setLeft(0.01f);
progressText->setTop(0.01f);
progressText->setHorizontalAlignment(GHA_LEFT);
progressText->setVerticalAlignment(GVA_TOP);
progressText->setFontName("BlueHighway");
progressText->setCharHeight(0.03f);
progressText->setColour(Ogre::ColourValue(0,0,0));
progressBar->addChild(progressBG);
progressBar->addChild(progressFG);
progressBar->addChild(progressText);
overlay->add2D(panel);
overlay->add2D(progressBar);
overlay->show();
}
//-----------------------------------------------------------------------
OverlayContainer* Profiler::createContainer() {
OverlayContainer* container = (OverlayContainer*)
OverlayManager::getSingleton().createOverlayElement(
"BorderPanel", "profiler");
container->setMetricsMode(GMM_PIXELS);
container->setMaterialName("Core/StatsBlockCenter");
container->setHeight(mGuiHeight);
container->setWidth(mGuiWidth * 2 + 15);
container->setParameter("border_size", "1 1 1 1");
container->setParameter("border_material", "Core/StatsBlockBorder");
container->setParameter("border_topleft_uv", "0.0000 1.0000 0.0039 0.9961");
container->setParameter("border_top_uv", "0.0039 1.0000 0.9961 0.9961");
container->setParameter("border_topright_uv", "0.9961 1.0000 1.0000 0.9961");
container->setParameter("border_left_uv","0.0000 0.9961 0.0039 0.0039");
container->setParameter("border_right_uv","0.9961 0.9961 1.0000 0.0039");
container->setParameter("border_bottomleft_uv","0.0000 0.0039 0.0039 0.0000");
container->setParameter("border_bottom_uv","0.0039 0.0039 0.9961 0.0000");
container->setParameter("border_bottomright_uv","0.9961 0.0039 1.0000 0.0000");
container->setLeft(5);
container->setTop(5);
return container;
}
/// Shadows config
//---------------------------------------------------------------------------------------------------
void App::changeShadows()
{
QTimer ti; ti.update(); /// time
// get settings
bool enabled = pSet->shadow_type != 0;
bool bDepth = pSet->shadow_type >= 2;
bool bSoft = pSet->shadow_type == 3;
pSet->shadow_size = std::max(0,std::min(ciShadowNumSizes-1, pSet->shadow_size));
int fTex = /*2048*/ ciShadowSizesA[pSet->shadow_size], fTex2 = fTex/2;
int num = /*3*/ pSet->shadow_count;
// disable 4 shadow textures (does not work because no texcoord's left in shader)
if (num == 4) num = 3;
TerrainMaterialGeneratorB::SM2Profile* matProfile = 0;
if (mTerrainGlobals)
{
matProfile = (TerrainMaterialGeneratorB::SM2Profile*) mTerrainGlobals->getDefaultMaterialGenerator()->getActiveProfile();
if (matProfile)
{ matProfile->setReceiveDynamicShadowsEnabled(enabled);
matProfile->setReceiveDynamicShadowsLowLod(true);
matProfile->setGlobalColourMapEnabled(false);
matProfile->setLayerSpecularMappingEnabled(pSet->ter_mtr >= 1); // ter mtr
matProfile->setLayerNormalMappingEnabled( pSet->ter_mtr >= 2);
matProfile->setLayerParallaxMappingEnabled(pSet->ter_mtr >= 3);
} }
if (!enabled) {
mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE); /*return;*/ }
else
{
// General scene setup
//mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED);
mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED);
mSceneMgr->setShadowFarDistance(pSet->shadow_dist); // 3000
mSceneMgr->setShadowTextureCountPerLightType(Light::LT_DIRECTIONAL, num);
if (mPSSMSetup.isNull())
{
// shadow camera setup
PSSMShadowCameraSetup* pssmSetup = new PSSMShadowCameraSetup();
#ifndef ROAD_EDITOR
pssmSetup->setSplitPadding(mSplitMgr->mCameras.front()->getNearClipDistance());
//pssmSetup->setSplitPadding(10);
pssmSetup->calculateSplitPoints(num, mSplitMgr->mCameras.front()->getNearClipDistance(), mSceneMgr->getShadowFarDistance());
#else
pssmSetup->setSplitPadding(mCamera->getNearClipDistance());
//pssmSetup->setSplitPadding(10);
pssmSetup->calculateSplitPoints(num, mCamera->getNearClipDistance(), mSceneMgr->getShadowFarDistance());
#endif
for (int i=0; i < num; ++i)
{ //int size = i==0 ? fTex : fTex2;
const Real cAdjfA[5] = {2, 1, 0.5, 0.25, 0.125};
pssmSetup->setOptimalAdjustFactor(i, cAdjfA[std::min(i, 4)]);
}
materialFactory->setPSSMCameraSetup(pssmSetup);
mPSSMSetup.bind(pssmSetup);
}
mSceneMgr->setShadowCameraSetup(mPSSMSetup);
mSceneMgr->setShadowTextureCount(num);
for (int i=0; i < num; ++i)
{ int size = i==0 ? fTex : fTex2;
PixelFormat pf;
if (bDepth && !bSoft) pf = PF_FLOAT32_R;
else if (bSoft) pf = PF_FLOAT16_RGB;
else pf = PF_X8B8G8R8;
mSceneMgr->setShadowTextureConfig(i, size, size, pf);
}
mSceneMgr->setShadowTextureSelfShadow(bDepth ? true : false); //-?
mSceneMgr->setShadowCasterRenderBackFaces((bDepth && !bSoft) ? true : false);
String shadowCasterMat;
if (bDepth && !bSoft) shadowCasterMat = "PSSM/shadow_caster";
else if (bSoft) shadowCasterMat = "PSVSM/shadow_caster";
else shadowCasterMat = StringUtil::BLANK;
mSceneMgr->setShadowTextureCasterMaterial(shadowCasterMat);
if (matProfile && terrain) {
matProfile->setReceiveDynamicShadowsDepth(bDepth);
matProfile->setReceiveDynamicShadowsPSSM(static_cast<PSSMShadowCameraSetup*>(mPSSMSetup.get()));
MaterialPtr mtr = matProfile->generateForCompositeMap(terrain);
//LogO(mtr->getBestTechnique()->getPass(0)->getTextureUnitState(0)->getName());
//LogO(String("Ter mtr: ") + mtr->getName());
}
}
materialFactory->setTerrain(terrain);
materialFactory->setNumShadowTex(num);
materialFactory->setShadows(pSet->shadow_type != 0);
materialFactory->setShadowsDepth(bDepth);
materialFactory->setShadowsSoft(bSoft);
materialFactory->generate();
#if 0 // shadow tex overlay
// add the overlay elements to show the shadow maps:
// init overlay elements
OverlayManager& mgr = OverlayManager::getSingleton();
Overlay* overlay;
// destroy if already exists
if (overlay = mgr.getByName("DebugOverlay"))
mgr.destroy(overlay);
overlay = mgr.create("DebugOverlay");
TexturePtr tex;
for (size_t i = 0; i < 2; ++i) {
//TexturePtr tex = mSceneMgr->getShadowTexture(i);
if (i == 0) tex = TextureManager::getSingleton().getByName("PlaneReflection");
else tex = TextureManager::getSingleton().getByName("PlaneRefraction");
// Set up a debug panel to display the shadow
if (MaterialManager::getSingleton().resourceExists("Ogre/DebugTexture" + toStr(i)))
MaterialManager::getSingleton().remove("Ogre/DebugTexture" + toStr(i));
MaterialPtr debugMat = MaterialManager::getSingleton().create(
"Ogre/DebugTexture" + toStr(i),
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
debugMat->getTechnique(0)->getPass(0)->setLightingEnabled(false);
TextureUnitState *t = debugMat->getTechnique(0)->getPass(0)->createTextureUnitState(tex->getName());
t->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
OverlayContainer* debugPanel;
// destroy container if exists
try
{
if (debugPanel =
static_cast<OverlayContainer*>(
mgr.getOverlayElement("Ogre/DebugTexPanel" + toStr(i)
)))
mgr.destroyOverlayElement(debugPanel);
}
catch (Ogre::Exception&) {}
debugPanel = (OverlayContainer*)
(OverlayManager::getSingleton().createOverlayElement("Panel", "Ogre/DebugTexPanel" + StringConverter::toString(i)));
debugPanel->_setPosition(0.8, i*0.25);
debugPanel->_setDimensions(0.2, 0.24);
debugPanel->setMaterialName(debugMat->getName());
debugPanel->show();
overlay->add2D(debugPanel);
overlay->show();
}
#endif
// ------------------- update the paged-geom materials
// grass is not cloned, just need to set new shader parameters
if (grass)
{
GrassLoader *grassLoader = static_cast<GrassLoader*>(grass->getPageLoader());
for (std::list<GrassLayer*>::iterator it= grassLoader->getLayerList().begin();
it != grassLoader->getLayerList().end(); ++it)
{
GrassLayer* layer = (*it);
layer->applyShader();
}
}
// trees are more complicated since they are cloned
//!todo this doesn't work (tree material does not update immediately)
if(trees)
{
trees->reloadGeometry();
std::vector<ResourcePtr> reosurceToDelete;
ResourceManager::ResourceMapIterator it = MaterialManager::getSingleton().getResourceIterator();
while (it.hasMoreElements())
{
ResourcePtr material = it.getNext();
String materialName = material->getName();
std::string::size_type pos =materialName.find("BatchMat|");
if( pos != std::string::npos ) {
reosurceToDelete.push_back(material);
}
}
for(int i=0;i<reosurceToDelete.size();i++)
{
MaterialManager::getSingleton().remove(reosurceToDelete[i]);
}
}
UpdPSSMMaterials();
ti.update(); /// time
float dt = ti.dt * 1000.f;
LogO(String("::: Time Shadows: ") + toStr(dt) + " ms");
}
/// Shadows config
//---------------------------------------------------------------------------------------------------
void CScene::changeShadows()
{
Ogre::Timer ti;
// get settings
SETTINGS* pSet = app->pSet;
bool enabled = pSet->shadow_type != Sh_None;
bool bDepth = pSet->shadow_type >= Sh_Depth;
bool bSoft = pSet->shadow_type == Sh_Soft;
pSet->shadow_size = std::max(0,std::min(ciShadowSizesNum-1, pSet->shadow_size));
int fTex = ciShadowSizesA[pSet->shadow_size], fTex2 = fTex/2;
int num = pSet->shadow_count;
sh::Vector4* fade = new sh::Vector4(
pSet->shadow_dist,
pSet->shadow_dist * 0.6, // fade start
0, 0);
sh::Factory* mFactory = app->mFactory;
SceneManager* mSceneMgr = app->mSceneMgr;
if (terrain)
mFactory->setTextureAlias("TerrainLightMap", terrain->getLightmap()->getName());
// disable 4 shadow textures (does not work because no texcoord's left in shader)
if (num == 4) num = 3;
if (!enabled)
mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
else
{
// General scene setup
//mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED);
mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED);
mSceneMgr->setShadowFarDistance(pSet->shadow_dist); // 3000
mSceneMgr->setShadowTextureCountPerLightType(Light::LT_DIRECTIONAL, num);
if (num == 1) // 1 tex, fast
{
ShadowCameraSetupPtr mShadowCameraSetup = ShadowCameraSetupPtr(new LiSPSMShadowCameraSetup());
mSceneMgr->setShadowCameraSetup(mShadowCameraSetup);
}else
{ if (mPSSMSetup.isNull()) // pssm
{
PSSMShadowCameraSetup* pssmSetup = new PSSMShadowCameraSetup();
#ifndef SR_EDITOR
pssmSetup->setSplitPadding(app->mSplitMgr->mCameras.front()->getNearClipDistance());
pssmSetup->calculateSplitPoints(num, app->mSplitMgr->mCameras.front()->getNearClipDistance(), mSceneMgr->getShadowFarDistance());
#else
pssmSetup->setSplitPadding(app->mCamera->getNearClipDistance());
pssmSetup->calculateSplitPoints(num, app->mCamera->getNearClipDistance(), app->mSceneMgr->getShadowFarDistance());
#endif
for (int i=0; i < num; ++i)
{ //int size = i==0 ? fTex : fTex2;
const Real cAdjfA[5] = {2, 1, 0.5, 0.25, 0.125};
pssmSetup->setOptimalAdjustFactor(i, cAdjfA[std::min(i, 4)]);
}
mPSSMSetup.bind(pssmSetup);
}
mSceneMgr->setShadowCameraSetup(mPSSMSetup);
}
mSceneMgr->setShadowTextureCount(num);
for (int i=0; i < num; ++i)
{ int size = i==0 ? fTex : fTex2;
PixelFormat pf;
if (bDepth && !bSoft) pf = PF_FLOAT32_R;
else if (bSoft) pf = PF_FLOAT16_RGB;
else pf = PF_X8B8G8R8;
mSceneMgr->setShadowTextureConfig(i, size, size, pf);
}
mSceneMgr->setShadowTextureSelfShadow(bDepth ? true : false); //-?
mSceneMgr->setShadowCasterRenderBackFaces((bDepth && !bSoft) ? true : false);
mSceneMgr->setShadowTextureCasterMaterial(bDepth ? "shadowcaster_default" : "");
}
mSceneMgr->setShadowColour(Ogre::ColourValue(0,0,0,1));
#if 0 /// TEST overlays
// add overlay elements to show shadow or terrain maps
OverlayManager& mgr = OverlayManager::getSingleton();
Overlay* overlay = mgr.getByName("DebugOverlay");
if (overlay)
mgr.destroy(overlay);
overlay = mgr.create("DebugOverlay");
TexturePtr tex;
#if 0 /// shadow
for (int i = 0; i < pSet->shadow_count; ++i)
{
TexturePtr tex = mSceneMgr->getShadowTexture(i);
#else /// terrain
for (int i = 0; i < 2/*pSet->shadow_count*/; ++i)
{
TexturePtr tex = !terrain ? mSceneMgr->getShadowTexture(i) :
i==0 ? terrain->getCompositeMap() : terrain->getLightmap();
#endif
// Set up a debug panel to display the shadow
if (MaterialManager::getSingleton().resourceExists("Ogre/DebugTexture" + toStr(i)))
MaterialManager::getSingleton().remove("Ogre/DebugTexture" + toStr(i));
MaterialPtr debugMat = MaterialManager::getSingleton().create(
"Ogre/DebugTexture" + toStr(i), rgDef);
debugMat->getTechnique(0)->getPass(0)->setLightingEnabled(false);
TextureUnitState *t = debugMat->getTechnique(0)->getPass(0)->createTextureUnitState(tex->getName());
t->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
OverlayContainer* debugPanel;
// destroy container if exists
try
{
if (debugPanel = static_cast<OverlayContainer*>(mgr.getOverlayElement("Ogre/DebugTexPanel" + toStr(i))))
mgr.destroyOverlayElement(debugPanel);
}
catch (Ogre::Exception&) {}
debugPanel = (OverlayContainer*)
(OverlayManager::getSingleton().createOverlayElement("Panel", "Ogre/DebugTexPanel" + StringConverter::toString(i)));
debugPanel->_setPosition(0.8, i*0.31); //aspect.. 0.25 0.24
debugPanel->_setDimensions(0.2, 0.3);
debugPanel->setMaterialName(debugMat->getName());
debugPanel->show();
overlay->add2D(debugPanel);
overlay->show();
}
#endif
UpdPSSMMaterials();
// rebuild static geom after materials change
if (vdrTrack)
{
vdrTrack->destroy();
vdrTrack->build();
}
LogO(String("::: Time Shadows: ") + fToStr(ti.getMilliseconds(),0,3) + " ms");
}
/// . . . . . . . .
void CScene::UpdPSSMMaterials()
{
if (app->pSet->shadow_type == Sh_None) return;
if (app->pSet->shadow_count == 1) // 1 tex
{
float dist = app->pSet->shadow_dist;
sh::Vector3* splits = new sh::Vector3(dist, 0,0); //dist*2, dist*3);
sh::Factory::getInstance().setSharedParameter("pssmSplitPoints", sh::makeProperty<sh::Vector3>(splits));
return;
}
if (!mPSSMSetup.get()) return;
//-- pssm params
PSSMShadowCameraSetup* pssmSetup = static_cast<PSSMShadowCameraSetup*>(mPSSMSetup.get());
const PSSMShadowCameraSetup::SplitPointList& sp = pssmSetup->getSplitPoints();
const int last = sp.size()-1;
sh::Vector3* splits = new sh::Vector3(
sp[std::min(1,last)], sp[std::min(2,last)], sp[std::min(3,last)] );
sh::Factory::getInstance().setSharedParameter("pssmSplitPoints", sh::makeProperty<sh::Vector3>(splits));
}