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