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
}
}