void TerrainManager::fixCompositorClearColor()
{
// hack
// now with extensive error checking
if (CompositorManager::getSingleton().hasCompositorChain(gEnv->mainCamera->getViewport()))
{
// //CompositorManager::getSingleton().getCompositorChain(gEnv->ogreCamera->getViewport())->getCompositor(0)->getTechnique()->getOutputTargetPass()->getPass(0)->setClearColour(fade_color);
CompositorInstance *co = CompositorManager::getSingleton().getCompositorChain(gEnv->mainCamera->getViewport())->_getOriginalSceneCompositor();
if (co)
{
CompositionTechnique *ct = co->getTechnique();
if (ct)
{
CompositionTargetPass *ctp = ct->getOutputTargetPass();
if (ctp)
{
CompositionPass *p = ctp->getPass(0);
if (p)
{
p->setClearColour(fade_color);
}
}
}
}
}
}
//-----------------------------------------------------------------------
void CompositorChain::createOriginalScene()
{
/// Create "default" compositor
/** Compositor that is used to implicitly represent the original
render in the chain. This is an identity compositor with only an output pass:
compositor Ogre/Scene
{
technique
{
target_output
{
pass clear
{
/// Clear frame
}
pass render_scene
{
visibility_mask FFFFFFFF
render_queues SKIES_EARLY SKIES_LATE
}
}
}
};
*/
mOriginalSceneScheme = mViewport->getMaterialScheme();
String compName = "Ogre/Scene/" + mOriginalSceneScheme;
CompositorPtr scene = CompositorManager::getSingleton().getByName(compName, ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
if (scene.isNull())
{
scene = CompositorManager::getSingleton().create(compName, ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
CompositionTechnique *t = scene->createTechnique();
t->setSchemeName(StringUtil::BLANK);
CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setVisibilityMask(0xFFFFFFFF);
{
CompositionPass *pass = tp->createPass();
pass->setType(CompositionPass::PT_CLEAR);
}
{
CompositionPass *pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERSCENE);
/// Render everything, including skies
pass->setFirstRenderQueue(RENDER_QUEUE_BACKGROUND);
pass->setLastRenderQueue(RENDER_QUEUE_SKIES_LATE);
}
/// Create base "original scene" compositor
scene = CompositorManager::getSingleton().load(compName,
ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
}
mOriginalScene = OGRE_NEW CompositorInstance(scene->getSupportedTechnique(), this);
}
//-----------------------------------------------------------------------
void CompositorManager::initialise(void)
{
/// Create "default" compositor
/** Compositor that is used to implicitly represent the original
render in the chain. This is an identity compositor with only an output pass:
compositor Ogre/Scene
{
technique
{
target_output
{
pass clear
{
/// Clear frame
}
pass render_scene
{
visibility_mask FFFFFFFF
render_queues SKIES_EARLY SKIES_LATE
}
}
}
};
*/
CompositorPtr scene = create("Ogre/Scene", ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
CompositionTechnique *t = scene->createTechnique();
CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setVisibilityMask(0xFFFFFFFF);
{
CompositionPass *pass = tp->createPass();
pass->setType(CompositionPass::PT_CLEAR);
}
{
CompositionPass *pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERSCENE);
/// Render everything, including skies
pass->setFirstRenderQueue(RENDER_QUEUE_SKIES_EARLY);
pass->setLastRenderQueue(RENDER_QUEUE_SKIES_LATE);
}
}
void _init(void)
{
CompositorPtr compositor = CompositorManager::getSingleton().create(
_theType(), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
CompositionTechnique *t;
CompositionTechnique::TextureDefinition *td;
CompositionTargetPass *tp;
CompositionPass *pass;
t = compositor->createTechnique();
td = t->createTextureDefinition("scene");
td->width.viewport = 1;
td->height.viewport = 1;
td->format = PF_X8R8G8B8;
td = t->createTextureDefinition("heat");
td->width.viewport = 0.5;
td->height.viewport = 0.5;
td->format = PF_X8R8G8B8;
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
tp->setOutputName("heat");
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/HeatVision/LightToHeat");
pass->setInput(0, "scene");
pass->setIdentifier(0xDEADBADE);
tp = t->getOutputTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/HeatVision/Blur");
pass->setInput(0, "heat");
}
//-------------------------------------------------------------------------------------
void BaseApp::recreateCompositor()
{
CompositorManager& cmp = CompositorManager::getSingleton();
if (!pSet->all_effects) // disable compositor
{
refreshCompositor();
return;
}
// add when needed
if (!ResourceGroupManager::getSingleton().resourceGroupExists("Effects"))
{
std::string sPath = PATHMANAGER::Data() + "/compositor";
mRoot->addResourceLocation(sPath, "FileSystem", "Effects");
mRoot->addResourceLocation(sPath + "/gbuffer", "FileSystem", "Effects");
mRoot->addResourceLocation(sPath + "/bloom", "FileSystem", "Effects");
mRoot->addResourceLocation(sPath + "/hdr", "FileSystem", "Effects");
mRoot->addResourceLocation(sPath + "/motionblur", "FileSystem", "Effects");
//mRoot->addResourceLocation(sPath + "/camblur", "FileSystem", "Effects");
mRoot->addResourceLocation(sPath + "/ssao", "FileSystem", "Effects");
mRoot->addResourceLocation(sPath + "/softparticles", "FileSystem", "Effects");
mRoot->addResourceLocation(sPath + "/dof", "FileSystem", "Effects");
mRoot->addResourceLocation(sPath + "/godrays", "FileSystem", "Effects");
mRoot->addResourceLocation(sPath + "/filmgrain", "FileSystem", "Effects");
ResourceGroupManager::getSingleton().initialiseResourceGroup("Effects");
}
// hdr has to be first in the compositor queue
if (!mHDRLogic)
{
mHDRLogic = new HDRLogic;
cmp.registerCompositorLogic("HDR", mHDRLogic);
mHDRLogic->setApp(this);
}
if (!mSSAOLogic)
{
mSSAOLogic = new SSAOLogic();
mSSAOLogic->setApp(this);
//if(MaterialGenerator::MRTSupported())
if (1)
CompositorManager::getSingleton().registerCompositorLogic("ssao", mSSAOLogic);
else
cmp.registerCompositorLogic("ssaoNoMRT", mSSAOLogic);
}
if (!mGodRaysLogic)
{
mGodRaysLogic = new GodRaysLogic();
mGodRaysLogic->setApp(this);
cmp.registerCompositorLogic("GodRays", mGodRaysLogic);
}
if (!mSoftParticlesLogic)
{
mSoftParticlesLogic = new SoftParticlesLogic();
mSoftParticlesLogic->setApp(this);
cmp.registerCompositorLogic("SoftParticles", mSoftParticlesLogic);
}
if (!mDepthOfFieldLogic)
{
mDepthOfFieldLogic = new DepthOfFieldLogic();
mDepthOfFieldLogic->setApp(this);
cmp.registerCompositorLogic("DepthOfField", mDepthOfFieldLogic);
}
if (!mFilmGrainLogic)
{
mFilmGrainLogic = new FilmGrainLogic();
mFilmGrainLogic->setApp(this);
cmp.registerCompositorLogic("FilmGrain", mFilmGrainLogic);
}
if (!mGBufferLogic)
{
mGBufferLogic = new GBufferLogic();
mGBufferLogic->setApp(this);
cmp.registerCompositorLogic("GBuffer", mGBufferLogic);
}
if (cmp.getByName("Motion Blur").isNull())
{
// Motion blur has to be created in code
CompositorPtr comp3 = cmp.create(
"Motion Blur", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
CompositionTechnique *t = comp3->createTechnique();
t->setCompositorLogicName("Motion Blur");
{
CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 0;
def->height = 0;
def->formatList.push_back(PF_R8G8B8);
}
{
CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("sum");
def->width = 0;
def->height = 0;
def->formatList.push_back(PF_R8G8B8);
}
{
CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 0;
def->height = 0;
def->formatList.push_back(PF_R8G8B8);
}
/// Render scene
{
CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Initialisation pass for sum texture
{
CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("sum");
tp->setOnlyInitial(true);
}
/// Do the motion blur
{
CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{ CompositionPass *pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Combine");
pass->setIdentifier(120);
pass->setInput(0, "scene");
pass->setInput(1, "sum");
}
}
/// Copy back sum texture
{
CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
tp->setOutputName("sum");
{ CompositionPass *pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Copyback");
pass->setInput(0, "temp");
}
}
/// Display result
{
CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
{ CompositionPass *pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/MotionBlur");
pass->setInput(0, "sum");
}
}
}
if (!mMotionBlurLogic)
{
mMotionBlurLogic = new MotionBlurLogic(this);
cmp.registerCompositorLogic("Motion Blur", mMotionBlurLogic);
}
/*if (!mCameraBlurLogic)
{
mCameraBlurLogic = new CameraBlurLogic(this);
cmp.registerCompositorLogic("CamBlur", mCameraBlurLogic);
}*/
for (std::list<Viewport*>::iterator it=mSplitMgr->mViewports.begin(); it!=mSplitMgr->mViewports.end(); ++it)
{
// remove old comp. first
cmp.removeCompositorChain( (*it ));
//if (MaterialGenerator::MRTSupported())
if (1)
{
cmp.addCompositor((*it), "gbuffer");
}
cmp.addCompositor((*it), "gbufferNoMRT");
cmp.addCompositor((*it), "HDRNoMRT");
//if (MaterialGenerator::MRTSupported())
if (1)
{
cmp.addCompositor((*it), "ssao");
cmp.addCompositor((*it), "SoftParticles");
cmp.addCompositor((*it), "DepthOfField");
cmp.addCompositor((*it), "gbufferFinalizer");
cmp.addCompositor((*it), "HDR");
}
else
{
cmp.addCompositor((*it), "ssaoNoMRT");
}
cmp.addCompositor((*it), "GodRays");
cmp.addCompositor((*it), "Bloom");
//cmp.addCompositor((*it), "CamBlur");
cmp.addCompositor((*it), "Motion Blur");
//cmp.addCompositor((*it), "FXAA");
cmp.addCompositor((*it), "FilmGrain");
cmp.addCompositor((*it), "gbufferUIRender");
}
refreshCompositor();
}
//-----------------------------------------------------------------------
void CompositorChain::createOriginalScene()
{
/// Create "default" compositor
/** Compositor that is used to implicitly represent the original
render in the chain. This is an identity compositor with only an output pass:
compositor Ogre/Scene
{
technique
{
target_output
{
pass clear
{
/// Clear frame
}
pass render_scene
{
visibility_mask FFFFFFFF
render_queues SKIES_EARLY SKIES_LATE
}
}
}
};
*/
// If two viewports use the same scheme but differ in settings like visibility masks, shadows, etc we don't
// want compositors to share their technique. Otherwise both compositors will have to recompile every time they
// render. Thus we generate a unique compositor per viewport.
String compName("Ogre/Scene/");
compName += StringConverter::toString((intptr_t)mViewport);
mOriginalSceneScheme = mViewport->getMaterialScheme();
CompositorPtr scene = CompositorManager::getSingleton().getByName(compName, ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
if (scene.isNull())
{
scene = CompositorManager::getSingleton().create(compName, ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
CompositionTechnique *t = scene->createTechnique();
t->setSchemeName(StringUtil::BLANK);
CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setVisibilityMask(0xFFFFFFFF);
{
CompositionPass *pass = tp->createPass();
pass->setType(CompositionPass::PT_CLEAR);
}
{
CompositionPass *pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERSCENE);
/// Render everything, including skies
pass->setFirstRenderQueue(RENDER_QUEUE_BACKGROUND);
pass->setLastRenderQueue(RENDER_QUEUE_SKIES_LATE);
}
/// Create base "original scene" compositor
scene = CompositorManager::getSingleton().load(compName,
ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
}
mOriginalScene = OGRE_NEW CompositorInstance(scene->getSupportedTechnique(), this);
}
void _init(void)
{
CompositorPtr compositor = CompositorManager::getSingleton().create(
_theType(), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
CompositionTechnique *t;
CompositionTechnique::TextureDefinition *td;
CompositionTargetPass *tp;
CompositionPass *pass;
t = compositor->createTechnique();
td = t->createTextureDefinition("scene");
td->width.viewport = 1;
td->height.viewport = 1;
td->format = PF_X8R8G8B8;
td = t->createTextureDefinition("blur0");
td->width.viewport = 0.5;
td->height.viewport = 0.5;
td->format = PF_X8R8G8B8;
td = t->createTextureDefinition("blur1");
td->width.viewport = 0.5;
td->height.viewport = 0.5;
td->format = PF_X8R8G8B8;
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
tp->setOutputName("blur0");
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/Floodlighting/DownSample");
pass->setInput(0, "scene");
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
tp->setOutputName("blur1");
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/Floodlighting/BlurHorizontal");
pass->setInput(0, "blur0");
tp = t->createTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
tp->setOutputName("blur1");
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/Floodlighting/BlurVertical");
pass->setInput(0, "blur0");
tp = t->getOutputTargetPass();
tp->setInputMode(CompositionTargetPass::IM_NONE);
pass = tp->createPass();
pass->setType(CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/Floodlighting/Blend");
pass->setInput(0, "scene");
pass->setInput(1, "blur1");
pass->setIdentifier(0xDEADBADE);
mBlurAmount = 0.2f;
mShineAmount = 0.3f;
// receive default parameters from material script
if (!pass->getMaterial().isNull())
{
GpuProgramParametersSharedPtr parameters = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
#if OGRE_VERSION >= 0x010300
const GpuConstantDefinition* def;
def = parameters->_findNamedConstantDefinition("blur_amount");
if (def)
parameters->_readRawConstants(def->physicalIndex, 1, &mBlurAmount);
def = parameters->_findNamedConstantDefinition("shine_amount");
if (def)
parameters->_readRawConstants(def->physicalIndex, 1, &mShineAmount);
#else
GpuProgramParameters::RealConstantEntry* entry;
entry = parameters->getNamedRealConstantEntry("blur_amount");
if (entry && entry->isSet)
mBlurAmount = entry->val[0];
entry = parameters->getNamedRealConstantEntry("shine_amount");
if (entry && entry->isSet)
mShineAmount = entry->val[0];
#endif
}
}
//-----------------------------------------------------------------------
void Compositor::createGlobalTextures()
{
static size_t dummyCounter = 0;
if (mSupportedTechniques.empty())
return;
//To make sure that we are consistent, it is demanded that all composition
//techniques define the same set of global textures.
typedef std::set<String> StringSet;
StringSet globalTextureNames;
//Initialize global textures from first supported technique
CompositionTechnique* firstTechnique = mSupportedTechniques[0];
CompositionTechnique::TextureDefinitionIterator texDefIt =
firstTechnique->getTextureDefinitionIterator();
while (texDefIt.hasMoreElements())
{
CompositionTechnique::TextureDefinition* def = texDefIt.getNext();
if (def->scope == CompositionTechnique::TS_GLOBAL)
{
//Check that this is a legit global texture
if (!def->refCompName.empty())
{
OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
"Global compositor texture definition can not be a reference",
"Compositor::createGlobalTextures");
}
if (def->width == 0 || def->height == 0)
{
OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
"Global compositor texture definition must have absolute size",
"Compositor::createGlobalTextures");
}
if (def->pooled)
{
LogManager::getSingleton().logMessage(
"Pooling global compositor textures has no effect");
}
globalTextureNames.insert(def->name);
//TODO GSOC : Heavy copy-pasting from CompositorInstance. How to we solve it?
/// Make the tetxure
RenderTarget* rendTarget;
if (def->formatList.size() > 1)
{
String MRTbaseName = "c" + StringConverter::toString(dummyCounter++) +
"/" + mName + "/" + def->name;
MultiRenderTarget* mrt =
Root::getSingleton().getRenderSystem()->createMultiRenderTarget(MRTbaseName);
mGlobalMRTs[def->name] = mrt;
// create and bind individual surfaces
size_t atch = 0;
for (PixelFormatList::iterator p = def->formatList.begin();
p != def->formatList.end(); ++p, ++atch)
{
String texname = MRTbaseName + "/" + StringConverter::toString(atch);
TexturePtr tex;
tex = TextureManager::getSingleton().createManual(
texname,
ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME, TEX_TYPE_2D,
(uint)def->width, (uint)def->height, 0, *p, TU_RENDERTARGET, 0,
def->hwGammaWrite && !PixelUtil::isFloatingPoint(*p), def->fsaa);
RenderTexture* rt = tex->getBuffer()->getRenderTarget();
rt->setAutoUpdated(false);
mrt->bindSurface(atch, rt);
// Also add to local textures so we can look up
String mrtLocalName = getMRTTexLocalName(def->name, atch);
mGlobalTextures[mrtLocalName] = tex;
}
rendTarget = mrt;
}
else
{
String texName = "c" + StringConverter::toString(dummyCounter++) +
"/" + mName + "/" + def->name;
// space in the name mixup the cegui in the compositor demo
// this is an auto generated name - so no spaces can't hart us.
std::replace( texName.begin(), texName.end(), ' ', '_' );
TexturePtr tex;
tex = TextureManager::getSingleton().createManual(
texName,
ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME, TEX_TYPE_2D,
(uint)def->width, (uint)def->height, 0, def->formatList[0], TU_RENDERTARGET, 0,
def->hwGammaWrite && !PixelUtil::isFloatingPoint(def->formatList[0]), def->fsaa);
rendTarget = tex->getBuffer()->getRenderTarget();
mGlobalTextures[def->name] = tex;
}
//Set DepthBuffer pool for sharing
rendTarget->setDepthBufferPool( def->depthBufferId );
}
}
//Validate that all other supported techniques expose the same set of global textures.
for (size_t i=1; i<mSupportedTechniques.size(); i++)
{
CompositionTechnique* technique = mSupportedTechniques[i];
bool isConsistent = true;
size_t numGlobals = 0;
texDefIt = technique->getTextureDefinitionIterator();
while (texDefIt.hasMoreElements())
{
CompositionTechnique::TextureDefinition* texDef = texDefIt.getNext();
if (texDef->scope == CompositionTechnique::TS_GLOBAL)
{
if (globalTextureNames.find(texDef->name) == globalTextureNames.end())
{
isConsistent = false;
break;
}
numGlobals++;
}
}
if (numGlobals != globalTextureNames.size())
isConsistent = false;
if (!isConsistent)
{
OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
"Different composition techniques define different global textures",
"Compositor::createGlobalTextures");
}
}
}
