//-----------------------------------------------------------------------
void CompositorChain::_compile()
{
	clearCompiledState();

	bool compositorsEnabled = false;

	// force default scheme so materials for compositor quads will determined correctly
	MaterialManager& matMgr = MaterialManager::getSingleton();
	String prevMaterialScheme = matMgr.getActiveScheme();
	matMgr.setActiveScheme(MaterialManager::DEFAULT_SCHEME_NAME);
	
    /// Set previous CompositorInstance for each compositor in the list
    CompositorInstance *lastComposition = mOriginalScene;
	mOriginalScene->mPreviousInstance = 0;
	CompositionPass* pass = mOriginalScene->getTechnique()->getOutputTargetPass()->getPass(0);
	pass->setClearBuffers(mViewport->getClearBuffers());
	pass->setClearColour(mViewport->getBackgroundColour());
    for(Instances::iterator i=mInstances.begin(); i!=mInstances.end(); ++i)
    {
        if((*i)->getEnabled())
        {
			compositorsEnabled = true;
            (*i)->mPreviousInstance = lastComposition;
            lastComposition = (*i);
        }
    }
    

    /// Compile misc targets
    lastComposition->_compileTargetOperations(mCompiledState);
    
    /// Final target viewport (0)
	mOutputOperation.renderSystemOperations.clear();
    lastComposition->_compileOutputOperation(mOutputOperation);

	// Deal with viewport settings
	if (compositorsEnabled != mAnyCompositorsEnabled)
	{
		mAnyCompositorsEnabled = compositorsEnabled;
		if (mAnyCompositorsEnabled)
		{
			// Save old viewport clearing options
			mOldClearEveryFrameBuffers = mViewport->getClearBuffers();
			// Don't clear anything every frame since we have our own clear ops
			mViewport->setClearEveryFrame(false);
		}
		else
		{
			// Reset clearing options
			mViewport->setClearEveryFrame(mOldClearEveryFrameBuffers > 0, 
				mOldClearEveryFrameBuffers);
		}
	}

	// restore material scheme
	matMgr.setActiveScheme(prevMaterialScheme);

    
    mDirty = false;
}
Esempio n. 2
0
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::preViewportUpdate(const RenderTargetViewportEvent& evt)
{
	// Only set up if there is at least one compositor enabled, and it's this viewport
    if(evt.source != mViewport || !mAnyCompositorsEnabled)
        return;

	// set original scene details from viewport
	CompositionPass* pass = mOriginalScene->getTechnique()->getOutputTargetPass()->getPass(0);
	CompositionTargetPass* passParent = pass->getParent();
	if (pass->getClearBuffers() != mViewport->getClearBuffers() ||
		//pass->getClearColour() != mViewport->getBackgroundColour() ||
		//pass->getClearDepth() != mViewport->getDepthClear() ||
		passParent->getVisibilityMask() != mViewport->getVisibilityMask() ||
		passParent->getMaterialScheme() != mViewport->getMaterialScheme() ||
		passParent->getShadowsEnabled() != mViewport->getShadowsEnabled())
	{
		// recompile if viewport settings are different
		//pass->setClearBuffers(mViewport->getClearBuffers());
		//pass->setClearColour(mViewport->getBackgroundColour());
		//pass->setClearDepth(mViewport->getDepthClear());
		passParent->setVisibilityMask(mViewport->getVisibilityMask());
		passParent->setMaterialScheme(mViewport->getMaterialScheme());
		passParent->setShadowsEnabled(mViewport->getShadowsEnabled());
		_compile();
	}

	Camera *cam = mViewport->getCamera();
	if (cam)
	{
		/// Prepare for output operation
		preTargetOperation(mOutputOperation, mViewport, cam);
	}
}
//-----------------------------------------------------------------------
bool CompositionTargetPass::_isSupported(void)
{
    // A target pass is supported if all passes are supported

    PassIterator passi = getPassIterator();
    while (passi.hasMoreElements())
    {
        CompositionPass* pass = passi.getNext();
        if (!pass->_isSupported())
        {
            return false;
        }
    }

    return true;
}
Esempio n. 5
0
//---------------------------------------------------------------------
bool CompositorManager::isInputToOutputTarget(CompositorInstance* inst, const Ogre::String& localName)
{
    CompositionTargetPass* tp = inst->getTechnique()->getOutputTargetPass();
    CompositionTargetPass::PassIterator pit = tp->getPassIterator();

    while(pit.hasMoreElements())
    {
        CompositionPass* p = pit.getNext();
        for (size_t i = 0; i < p->getNumInputs(); ++i)
        {
            if (p->getInput(i).name == localName)
                return true;
        }
    }

    return false;

}
Esempio n. 6
0
//---------------------------------------------------------------------()
bool CompositorManager::isInputToOutputTarget(CompositorInstance* inst, TexturePtr tex)
{
    CompositionTargetPass* tp = inst->getTechnique()->getOutputTargetPass();
    CompositionTargetPass::PassIterator pit = tp->getPassIterator();

    while(pit.hasMoreElements())
    {
        CompositionPass* p = pit.getNext();
        for (size_t i = 0; i < p->getNumInputs(); ++i)
        {
            TexturePtr t = inst->getTextureInstance(p->getInput(i).name, 0);
            if (!t.isNull() && t.get() == tex.get())
                return true;
        }
    }

    return false;

}
void HDRCompositor::CalculateKey(void)
{
	CompositionTargetPass *tp;
	CompositionPass *pass;

	CreateTextureDef("Key",1,1,PF_FLOAT16_RGB);

	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Key");
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	if(m_AutoKeying)
	{
		pass->setMaterialName("AutoKey");
		pass->setInput(0,"Luminance");
	}
	else
	{
		pass->setIdentifier(MID_KEY);
		pass->setMaterialName("ManualKey");
//		GpuProgramParameters::RealConstantEntry* entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("Key");
//		if(entry)
//			entry->val[0] = m_Key;
	}
	
}
void HDRCompositor::RenderDownSample(void)
{
	CompositionTargetPass* tp;
	CompositionPass* pass;

	//Downscale4
	CreateTextureDef("scenedown4",m_VpWidth/4,m_VpHeight/4,PF_FLOAT16_RGB);

	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("scenedown4"); 
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("Down4");
	pass->setInput(0,"Scene",0);
	
	pass->setIdentifier(MID_DOWN);

//	GpuProgramParameters::RealConstantEntry* entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("rcpScreenSize");
//	entry->val[0] = 1.f/m_Window->getWidth();
//	entry->val[1] = 1.f/m_Window->getHeight();
}
//-----------------------------------------------------------------------
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);
}
Esempio n. 10
0
        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");
        }
Esempio n. 11
0
//-----------------------------------------------------------------------
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);
	}

}
Esempio n. 12
0
void HDRCompositor::FinalRendering(void)
{
	CompositionTargetPass *tp = m_HDRTechnique->getOutputTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	
	CompositionPass *pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);

	if(m_ToneMapper == TM_NONE || m_DebugRendertarget)
        pass->setMaterialName("CompositorCopyback");
	else if(m_ToneMapper == TM_LINEAR)
		pass->setMaterialName("HDRFinalLinear");
	else if(m_ToneMapper == TM_REINHARDS)
		pass->setMaterialName("HDRFinalReinh");
	else if(m_ToneMapper == TM_REINHARDSMOD)
		pass->setMaterialName("HDRFinalReinhMod");
	else if(m_ToneMapper == TM_LOG)
		pass->setMaterialName("HDRFinalLog");
	else if(m_ToneMapper == TM_ADAPTLOG)
		pass->setMaterialName("HDRFinalAdaptiveLog");
	else if(m_ToneMapper == TM_REINHARDLOCAL)
		pass->setMaterialName("HDRFinalReinhLocal");

	if(m_DebugRendertarget == 1)
		pass->setInput(0,"scenedown4");
	else if(m_DebugRendertarget == 2)
		pass->setInput(0,"Lumscale1");
	else if(m_DebugRendertarget == 3)
		pass->setInput(0,"Lumscale2");
	else if(m_DebugRendertarget == 4)
		pass->setInput(0,"Lumscale4");
	else if(m_DebugRendertarget == 5)
		pass->setInput(0,"scale0");
	else if(m_DebugRendertarget == 6)
		pass->setInput(0,"scale1");
	else if(m_DebugRendertarget == 7)
		pass->setInput(0,"scale2");
	else if(m_DebugRendertarget == 8)
		pass->setInput(0,"scale6");
	/*else if(m_DebugRendertarget == 2)
		pass->setInput(0,"Lum64");
	else if(m_DebugRendertarget == 3)
		pass->setInput(0,"Lum16");
	else if(m_DebugRendertarget == 4)
		pass->setInput(0,"Lum4");
	else if(m_DebugRendertarget == 5)
		pass->setInput(0,"Luminance");
	else if(m_DebugRendertarget == 6)
		pass->setInput(0,"Bright");
	else if(m_DebugRendertarget == 7)
		pass->setInput(0,"Glare");
	else if(m_DebugRendertarget == 8)
		pass->setInput(0,"Star");*/
	else
	{
		pass->setInput(0,"Scene",0);

		if(m_ToneMapper != TM_NONE)
		{
			if(m_ToneMapper == TM_REINHARDLOCAL)
			{
				pass->setInput(0, "Lumscale1");

				pass->setInput(1,"Key");

				if(m_GlareType != GT_NONE)
					pass->setInput(2,"Glare");
				if(m_StarType != GT_NONE)
					pass->setInput(3,"Star");

				pass->setInput(4, "LocalAdaptMap");
			}
			else
			{
				if(m_LumAdaption)
					pass->setInput(1, "AdaptedLum");
				else
					pass->setInput(1, "Luminance");
				pass->setInput(2, "Key");
			}
		}

		if(m_ToneMapper != TM_REINHARDLOCAL)
		{
			if(m_GlareType != GT_NONE)
				pass->setInput(3,"Glare");

			if(m_StarType != GT_NONE)
				pass->setInput(4,"Star");
		}
	}

	pass->setIdentifier(MID_FINAL);
}
Esempio n. 13
0
//---------------------------------------------------------------------
void CompositorInstance::deriveTextureRenderTargetOptions(
	const String& texname, bool *hwGammaWrite, uint *fsaa)
{
	// search for passes on this texture def that either include a render_scene
	// or use input previous
	bool renderingScene = false;

	CompositionTechnique::TargetPassIterator it = mTechnique->getTargetPassIterator();
	while (it.hasMoreElements())
	{
		CompositionTargetPass* tp = it.getNext();
		if (tp->getOutputName() == texname)
		{
			if (tp->getInputMode() == CompositionTargetPass::IM_PREVIOUS)
			{
				// this may be rendering the scene implicitly
				// Can't check mPreviousInstance against mChain->_getOriginalSceneCompositor()
				// at this time, so check the position
				CompositorChain::InstanceIterator instit = mChain->getCompositors();
				renderingScene = true;
				while(instit.hasMoreElements())
				{
					CompositorInstance* inst = instit.getNext();
					if (inst == this)
						break;
					else if (inst->getEnabled())
					{
						// nope, we have another compositor before us, this will
						// be doing the AA
						renderingScene = false;
					}
				}
				if (renderingScene)
					break;
			}
			else
			{
				// look for a render_scene pass
				CompositionTargetPass::PassIterator pit = tp->getPassIterator();
				while(pit.hasMoreElements())
				{
					CompositionPass* pass = pit.getNext();
					if (pass->getType() == CompositionPass::PT_RENDERSCENE)
					{
						renderingScene = true;
						break;
					}
				}
			}

		}
	}

	if (renderingScene)
	{
		// Ok, inherit settings from target
		RenderTarget* target = mChain->getViewport()->getTarget();
		*hwGammaWrite = target->isHardwareGammaEnabled();
		*fsaa = target->getFSAA();
	}
	else
	{
		*hwGammaWrite = false;
		*fsaa = 0;
	}

}
Esempio n. 14
0
//-------------------------------------------------------------------------------------
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
            }
        }
Esempio n. 16
0
void HDRCompositor::BrightPass(void)
{		
	CompositionTargetPass* tp;
	CompositionPass* pass;

	//first do brightpass
	CreateTextureDef("Bright",m_VpWidth/4,m_VpHeight/4,PF_A8R8G8B8);
	
	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Bright"); 
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("BrightPass");
	pass->setInput(0,"scenedown4");
	pass->setInput(1,"Luminance");
	pass->setInput(2,"Key");

	pass->setIdentifier(MID_BRIGHT);

	/*GpuProgramParameters::RealConstantEntry* entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("g_fMiddleGray");
	if(entry)
		entry->val[0] = m_Key;*/

	//downsamples of bright for glare and/or star
	/*if(m_GlareType != GT_NONE || m_StarType != ST_NONE)
	{
		CreateTextureDef("Bright2",m_Window->getWidth()/8,m_Window->getHeight()/8,PF_A8R8G8B8);
		//CreateTextureDef("Bright4",m_Window->getWidth()/16,m_Window->getHeight()/16,PF_A8R8G8B8);
		//CreateTextureDef("Bright8",m_Window->getWidth()/32,m_Window->getHeight()/32,PF_A8R8G8B8);

		//birght/2
		tp = m_HDRTechnique->createTargetPass();
		tp->setInputMode(CompositionTargetPass::IM_NONE);
		tp->setOutputName("Bright2");
		pass = tp->createPass();
		pass->setType(CompositionPass::PT_RENDERQUAD);
		pass->setMaterialName("BrightDown_1");
		pass->setInput(0,"Bright");

		entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("rcpScreenSize");
		if(entry)
		{
			entry->val[0] = 4.f/m_Window->getWidth();
			entry->val[1] = 4.f/m_Window->getHeight();
		}

		//birght/4
		//tp = m_HDRTechnique->createTargetPass();
		//tp->setInputMode(CompositionTargetPass::IM_NONE);
		//tp->setOutputName("Bright4");
		//pass = tp->createPass();
		//pass->setType(CompositionPass::PT_RENDERQUAD);
		//pass->setMaterialName("BrightDown_2");
		//pass->setInput(0,"Bright2");

		//entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("rcpScreenSize");
		//if(entry)
		//{
		//	entry->val[0] = 8.f/m_Window->getWidth();
		//	entry->val[1] = 8.f/m_Window->getHeight();
		//}

		//birght/8
		//tp = m_HDRTechnique->createTargetPass();
		//tp->setInputMode(CompositionTargetPass::IM_NONE);
		//tp->setOutputName("Bright8");
		//pass = tp->createPass();
		//pass->setType(CompositionPass::PT_RENDERQUAD);
		//pass->setMaterialName("BrightDown_3");
		//pass->setInput(0,"Bright4");

		//entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("rcpScreenSize");
		//if(entry)
		//{
		//	entry->val[0] = 16.f/m_Window->getWidth();
		//	entry->val[1] = 16.f/m_Window->getHeight();
		//}
	}*/
}
Esempio n. 17
0
//-----------------------------------------------------------------------
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);
}
Esempio n. 18
0
void CompositorInstance::collectPasses(TargetOperation &finalState, CompositionTargetPass *target)
{
	/// Here, passes are converted into render target operations
    Pass *targetpass;
    Technique *srctech;
	MaterialPtr mat, srcmat;
	
    CompositionTargetPass::PassIterator it = target->getPassIterator();
    while(it.hasMoreElements())
    {
        CompositionPass *pass = it.getNext();
        switch(pass->getType())
        {
        case CompositionPass::PT_CLEAR:
			queueRenderSystemOp(finalState, new RSClearOperation(
				pass->getClearBuffers(),
				pass->getClearColour(),
				pass->getClearDepth(),
				pass->getClearStencil()
				));
            break;
		case CompositionPass::PT_STENCIL:
			queueRenderSystemOp(finalState, new RSStencilOperation(
				pass->getStencilCheck(),pass->getStencilFunc(), pass->getStencilRefValue(),
				pass->getStencilMask(), pass->getStencilFailOp(), pass->getStencilDepthFailOp(),
				pass->getStencilPassOp(), pass->getStencilTwoSidedOperation()
				));
            break;
        case CompositionPass::PT_RENDERSCENE:
			if(pass->getFirstRenderQueue() < finalState.currentQueueGroupID)
			{
				/// Mismatch -- warn user
				/// XXX We could support repeating the last queue, with some effort
				LogManager::getSingleton().logMessage("Warning in compilation of Compositor "
					+mCompositor->getName()+": Attempt to render queue "+
					StringConverter::toString(pass->getFirstRenderQueue())+" before "+
					StringConverter::toString(finalState.currentQueueGroupID));
			}
			/// Add render queues
			for(int x=pass->getFirstRenderQueue(); x<=pass->getLastRenderQueue(); ++x)
			{
				assert(x>=0);
				finalState.renderQueues.set(x);
			}
			finalState.currentQueueGroupID = pass->getLastRenderQueue()+1;
			finalState.findVisibleObjects = true;
			finalState.materialScheme = target->getMaterialScheme();

            break;
        case CompositionPass::PT_RENDERQUAD:
            srcmat = pass->getMaterial();
			if(srcmat.isNull())
            {
                /// No material -- warn user
				LogManager::getSingleton().logMessage("Warning in compilation of Compositor "
					+mCompositor->getName()+": No material defined for composition pass");
                break;
            }
			srcmat->compile();
			if(srcmat->getNumSupportedTechniques()==0)  
			{
				/// No supported techniques -- warn user
				LogManager::getSingleton().logMessage("Warning in compilation of Compositor "
					+mCompositor->getName()+": material "+srcmat->getName()+" has no supported techniques");
                break;
			}
			srctech = srcmat->getBestTechnique(0);
			/// Create local material
			MaterialPtr mat = createLocalMaterial();
			/// Copy and adapt passes from source material
			Technique::PassIterator i = srctech->getPassIterator();
			while(i.hasMoreElements())
			{
				Pass *srcpass = i.getNext();
				/// Create new target pass
				targetpass = mat->getTechnique(0)->createPass();
				(*targetpass) = (*srcpass);
				/// Set up inputs
				for(size_t x=0; x<pass->getNumInputs(); ++x)
				{
					String inp = pass->getInput(x);
					if(!inp.empty())
					{
						if(x < targetpass->getNumTextureUnitStates())
						{
							targetpass->getTextureUnitState((ushort)x)->setTextureName(getSourceForTex(inp));
						} 
						else
						{
							/// Texture unit not there
							LogManager::getSingleton().logMessage("Warning in compilation of Compositor "
								+mCompositor->getName()+": material "+srcmat->getName()+" texture unit "
								+StringConverter::toString(x)+" out of bounds");
						}
					}
				}
			}
			queueRenderSystemOp(finalState, new RSQuadOperation(this,pass->getIdentifier(),mat));
            break;
        }
    }
}
Esempio n. 19
0
void HDRCompositor::BuildStar(void)
{
	if(m_StarType == ST_PLUS)
	{
		CompositionTargetPass *tp;
		CompositionPass *pass;

		String strDstH, strDstV;
		String strSrcH = "Bright";
		String strSrcV = "Bright";

		for(int i=0; i<m_StarPasses; i++)
		{
			String strDstH = "StarH";
			String strDstV = "StarV";
			
			if(i < m_StarPasses-1 )
			{
				strDstH += StringConverter::toString(i);
				strDstV += StringConverter::toString(i);
			}
						
			CreateTextureDef(strDstH,m_VpWidth/4,m_VpHeight/4,PF_A8R8G8B8);
					
			tp = m_HDRTechnique->createTargetPass();
			tp->setInputMode(CompositionTargetPass::IM_NONE);
			tp->setOutputName(strDstH);
		
			pass = tp->createPass();
			pass->setType(CompositionPass::PT_RENDERQUAD);
			pass->setMaterialName("GaussBlur");
			pass->setInput(0,strSrcH);
			pass->setIdentifier(MID_STARH);

			strSrcH = strDstH;

			CreateTextureDef(strDstV,m_VpWidth/4,m_VpHeight/4,PF_A8R8G8B8);

			tp = m_HDRTechnique->createTargetPass();
			tp->setInputMode(CompositionTargetPass::IM_NONE);
			tp->setOutputName(strDstV);
		
			pass = tp->createPass();
			pass->setType(CompositionPass::PT_RENDERQUAD);
			pass->setMaterialName("GaussBlur");
			pass->setInput(0,strSrcV);
			pass->setIdentifier(MID_STARV);

			strSrcV = strDstV;
		}

		CreateTextureDef("Star",m_VpWidth/4,m_VpHeight/4,PF_A8R8G8B8);

		//merge horizontal and vertical blur
		tp = m_HDRTechnique->createTargetPass();
		tp->setInputMode(CompositionTargetPass::IM_NONE);
		tp->setOutputName("Star");
		
		pass = tp->createPass();
		pass->setType(CompositionPass::PT_RENDERQUAD);
		pass->setMaterialName("Merge2");
		pass->setInput(0,"StarH");
		pass->setInput(1,"StarV");
	}
}
Esempio n. 20
0
void HDRCompositor::BuildGlare(void)
{
	if(m_GlareType == GT_BLUR)
	{
		CompositionTargetPass *tp;
		CompositionPass *pass;

		String strDst;
		String strSrc = "Bright";

		for(int i=0; i<m_GlarePasses; i++)
		{
			String strDst = "Glare";
			
			if(i < m_GlarePasses-1 )
				strDst += StringConverter::toString(i);
						
			CreateTextureDef(strDst,m_VpWidth/4,m_VpHeight/4,PF_A8R8G8B8);
		
			tp = m_HDRTechnique->createTargetPass();
			tp->setInputMode(CompositionTargetPass::IM_NONE);
			tp->setOutputName(strDst);
		
			pass = tp->createPass();
			pass->setType(CompositionPass::PT_RENDERQUAD);
			pass->setMaterialName("GaussBlur");
			pass->setInput(0,strSrc);
			pass->setIdentifier(MID_GAUSSBLUR);

			strSrc = strDst;
		}

		//entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("rcpScreenSize");
		//if(entry)
		//{
		//	entry->val[0] = 32.f/m_Window->getWidth();
		//	entry->val[1] = 32.f/m_Window->getHeight();
		//}

		/*pass = tp->createPass();
		pass->setType(CompositionPass::PT_RENDERQUAD);
		pass->setMaterialName("GaussBlur_2");
		pass->setInput(0,"Glare");
		pass->setInput(1,"Bright2");

		entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("rcpScreenSize");
		if(entry)
		{
			entry->val[0] = 8.f/m_Window->getWidth();
			entry->val[1] = 8.f/m_Window->getHeight();
		}

		pass = tp->createPass();
		pass->setType(CompositionPass::PT_RENDERQUAD);
		pass->setMaterialName("GaussBlur_3");
		pass->setInput(0,"Glare");
		pass->setInput(1,"Bright4");

		entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("rcpScreenSize");
		if(entry)
		{
			entry->val[0] = 16.f/m_Window->getWidth();
			entry->val[1] = 16.f/m_Window->getHeight();
		}

		pass = tp->createPass();
		pass->setType(CompositionPass::PT_RENDERQUAD);
		pass->setMaterialName("GaussBlur_4");
		pass->setInput(0,"Glare");
		pass->setInput(1,"Bright2");
		
		entry = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->getNamedRealConstantEntry("rcpScreenSize");
		if(entry)
		{
			entry->val[0] = 32.f/m_Window->getWidth();
			entry->val[1] = 32.f/m_Window->getHeight();
		}*/
	}
}
Esempio n. 21
0
void HDRCompositor::BuildScales(void)
{
	CompositionTargetPass *tp;
	CompositionPass *pass;

	//first build luminacepass scales

	CreateTextureDef("Lumscale1",m_VpWidth,m_VpHeight,PF_FLOAT16_RGB);
	CreateTextureDef("Lumscale2",m_VpWidth/2,m_VpHeight/2,PF_FLOAT16_RGB);
	CreateTextureDef("Lumscale4",m_VpWidth/4,m_VpHeight/4,PF_FLOAT16_RGB);
	CreateTextureDef("Lumscale8",m_VpWidth/8,m_VpHeight/8,PF_FLOAT16_RGB);

	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Lumscale1"); 
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("LuminanceScale");
	pass->setInput(0,"Scene",0);
	if(m_LumAdaption)
		pass->setInput(1, "AdaptedLum");
	else
		pass->setInput(1, "Luminance");
	pass->setInput(2, "Key");
	
	pass->setIdentifier(MID_LUMSCALE1);

	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Lumscale2"); 
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("Down2");
	pass->setInput(0,"Lumscale1");
	
	pass->setIdentifier(MID_LUMSCALE2);

	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Lumscale4"); 
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("Down2");
	pass->setInput(0,"Lumscale2");
	
	pass->setIdentifier(MID_LUMSCALE4);

	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Lumscale8"); 
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("Down2");
	pass->setInput(0,"Lumscale4");
	
	pass->setIdentifier(MID_LUMSCALE8);

	//filter downsampled scenes, each filter scale is 1.6 times larger
	//starting with:
	float s = 1.f / 2.f / sqrt(2.f);
	//sample scales 1, 2, 2, 4, 4, 8, 8 and build a total of 7 scales
	
	for(int i = 0; i < m_Scales; i++)
	{
		String strScale = "scale";
		strScale += StringConverter::toString(i+1);

		int scaleSize = (1 << ((i + 1) / 2));

		String strLumScale = "Lumscale";
		strLumScale += StringConverter::toString(scaleSize);

		CreateTextureDef(strScale, m_VpWidth/scaleSize, m_VpHeight/scaleSize, PF_FLOAT16_RGB);

		tp = m_HDRTechnique->createTargetPass();
		tp->setInputMode(CompositionTargetPass::IM_NONE);
		tp->setOutputName(strScale);
	
		pass = tp->createPass();
		pass->setType(CompositionPass::PT_RENDERQUAD);
		pass->setMaterialName("GaussBlur");
		pass->setInput(0,strLumScale);
		pass->setIdentifier(MID_SCALE + i);
	}

	//build local adapt map
	CreateTextureDef("LocalAdaptMap", m_VpWidth, m_VpHeight, PF_FLOAT16_RGB);

	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("LocalAdaptMap"); 
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("BuildLocalAdaptMap");
	pass->setInput(0,"Key");
	pass->setInput(1,"scale1");
	pass->setInput(2,"scale2");
	pass->setInput(3,"scale3");
	pass->setInput(4,"scale4");
	pass->setInput(5,"scale5");
	pass->setInput(6,"scale6");
	pass->setInput(7,"scale7");
	
	pass->setIdentifier(MID_BUILDLOCAL);
}
Esempio n. 22
0
void HDRCompositor::CalculateLuminance(void)
{
	CreateTextureDef("Lum64",64,64,PF_FLOAT16_R);
	CreateTextureDef("Lum16",16,16,PF_FLOAT16_R);
	CreateTextureDef("Lum4",4,4,PF_FLOAT16_R);
	CreateTextureDef("Luminance",1,1,PF_FLOAT16_R);

	CompositionTargetPass *tp;
	CompositionPass *pass;

	//intial to 64
	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Lum64");

	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("LuminanceInitial");
	pass->setInput(0,"scenedown4");

	//down to 16
	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Lum16");

	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("Luminance1");
	pass->setInput(0,"Lum64");
		
	//down to 4	
	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Lum4");
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	pass->setMaterialName("Luminance2");
	pass->setInput(0,"Lum64");
	
	//final to 1
	tp = m_HDRTechnique->createTargetPass();
	tp->setInputMode(CompositionTargetPass::IM_NONE);
	tp->setOutputName("Luminance");
	
	pass = tp->createPass();
	pass->setType(CompositionPass::PT_RENDERQUAD);
	//if(m_ToneMapper != TM_ADAPTLOG)
		pass->setMaterialName("LuminanceFinalAvg");
	//else
	//	pass->setMaterialName("LuminanceFinalMax");
	pass->setInput(0,"Lum4");

	if(m_LumAdaption)
	{
		CreateTextureDef("AdaptedLumLast",1,1,PF_FLOAT16_R);

		tp = m_HDRTechnique->createTargetPass();
		tp->setInputMode(CompositionTargetPass::IM_NONE);
		tp->setOutputName("AdaptedLumLast");
					
		pass = tp->createPass();
		pass->setType(CompositionPass::PT_RENDERQUAD);
		pass->setMaterialName("CopyHDR");
		pass->setInput(0,"AdaptedLum");

		CreateTextureDef("AdaptedLum",1,1,PF_FLOAT16_R);

		tp = m_HDRTechnique->createTargetPass();
		tp->setInputMode(CompositionTargetPass::IM_NONE);
		tp->setOutputName("AdaptedLum");
					
		pass = tp->createPass();
		pass->setType(CompositionPass::PT_RENDERQUAD);
		pass->setMaterialName("AdaptLuminance");
		pass->setInput(0,"Luminance");
		pass->setInput(1,"AdaptedLumLast");//old
		pass->setIdentifier(MID_ADAPT);
	}
}