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"); } } }