bool MainCamera::validateCompositionTargetPass(Ogre::CompositionTargetPass& compositionPass)
{
Ogre::CompositionTargetPass::PassIterator compPassIter = compositionPass.getPassIterator();
while (compPassIter.hasMoreElements()) {
Ogre::CompositionPass* compositorPass = compPassIter.getNext();
compositorPass->getMaterial()->load();
Ogre::Material::TechniqueIterator techIter = compositorPass->getMaterial()->getSupportedTechniqueIterator();
while (techIter.hasMoreElements()) {
Ogre::Technique::PassIterator _passIter = techIter.getNext()->getPassIterator();
while (_passIter.hasMoreElements()) {
Ogre::Pass* pass = _passIter.getNext();
//Also disallow camera polygon mode overide. This is because if it's turned on,
//and the camera is switched to polygon mode, the end result will be one single
//large polygon being shown. This is not what we want.
pass->setPolygonModeOverrideable(false);
if (pass->hasFragmentProgram()) {
if (pass->getFragmentProgram()->hasCompileError()) {
return false;
}
}
}
}
}
return true;
}
KBOOL Kylin::EffectFade::Initialize()
{
Ogre::CompositorPtr spCompositor = Ogre::CompositorManager::getSingleton().create(
m_sName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
Ogre::CompositionTechnique *t;
Ogre::CompositionTechnique::TextureDefinition *td;
Ogre::CompositionTargetPass *tp;
Ogre::CompositionPass *pass;
t = spCompositor->createTechnique();
td = t->createTextureDefinition("scene");
td->width = 1;
td->height = 1;
td->formatList.push_back(Ogre::PF_X8R8G8B8);
tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("PostFilters/Fade");
pass->setInput(0, "scene");
pass->setIdentifier(0xDEADBADE);
// receive default parameters from material script
m_fColourAmount = 0;
m_fGrayAmount = 1;
if (!pass->getMaterial().isNull())
{
Ogre::GpuProgramParametersSharedPtr parameters = pass->getMaterial()->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
/*#if OGRE_VERSION >= 0x010300*/
const Ogre::GpuConstantDefinition* def;
def = parameters->_findNamedConstantDefinition("colour_amount");
if (def)
parameters->_readRawConstants(def->physicalIndex, 1, &m_fColourAmount);
def = parameters->_findNamedConstantDefinition("gray_amount");
if (def)
parameters->_readRawConstants(def->physicalIndex, 1, &m_fGrayAmount);
// #else
// GpuProgramParameters::RealConstantEntry* entry;
//
// entry = parameters->getNamedRealConstantEntry("colour_amount");
// if (entry && entry->isSet)
// m_fColourAmount = entry->val[0];
//
// entry = parameters->getNamedRealConstantEntry("gray_amount");
// if (entry && entry->isSet)
// m_fGrayAmount = entry->val[0];
// #endif
}
KBOOL bRet = EffectCompositor::Initialize();
if (bRet)
m_pCompositor->addListener(this);
return bRet;
}
bool gkOgreCompositorHelper::createHeatVisionCompositor()
{
#if GK_USE_COMPOSITOR_HEAT_VISION
using namespace Ogre;
/// Heat vision effect
try
{
Ogre::CompositorPtr comp4 = Ogre::CompositorManager::getSingleton().create(
GK_COMPOSITOR_HEAT_VISION, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
Ogre::CompositionTechnique *t = comp4->createTechnique();
t->setCompositorLogicName(GK_COMPOSITOR_HEAT_VISION);
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 256;
def->height = 256;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 256;
def->height = 256;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
/// Render scene
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Light to heat pass
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setIdentifier(0xDEADBABE); /// Identify pass for use in listener
pass->setMaterialName("Fury/HeatVision/LightToHeat");
pass->setInput(0, "scene");
}
}
/// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Fury/HeatVision/Blur");
pass->setInput(0, "temp");
}
}
}
catch (Exception &e)
{
gkPrintf("[CMP] FAILED %s", e.getFullDescription().c_str());
return false;
}
return true;
#else
return false;
#endif
}
bool gkOgreCompositorHelper::createMotionBlurCompositor()
{
using namespace Ogre;
try
{
CompositorPtr comp3 = Ogre::CompositorManager::getSingleton().create(
GK_COMPOSITOR_MOTION_BLUR, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
Ogre::CompositionTechnique *t = comp3->createTechnique();
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("sum");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
/// Render scene
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Initialisation pass for sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("sum");
tp->setOnlyInitial(true);
}
/// Do the motion blur
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Combine");
pass->setInput(0, "scene");
pass->setInput(1, "sum");
}
}
/// Copy back sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("sum");
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Copyback");
pass->setInput(0, "temp");
}
}
/// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/MotionBlur");
pass->setInput(0, "sum");
}
}
}
catch (Exception &e)
{
gkPrintf("[CMP] FAILED %s", e.getFullDescription().c_str());
return false;
}
return true;
}
void GameState::createRenderScene()
{
//获取场景管理器
mSceneMgr = GlobalManager::mSharedSceneMgr;
//获取主摄像机
mCamera = GlobalManager::mShareCamera;
CompositorManager::getSingleton().addCompositor(mCamera->getViewport(), "Glow");
CompositorManager::getSingleton().setCompositorEnabled(mCamera->getViewport(), "Glow", true);
GlowMaterialListener *gml = new GlowMaterialListener();
Ogre::MaterialManager::getSingleton().addListener(gml);
//Ogre::Light * pSunLight = mSceneMgr->createLight("SunLight");
//pSunLight->setType(Light::LT_POINT);
//pSunLight->setPosition(Ogre::Vector3(660, 10, 660));
//pSunLight->setDiffuseColour(ColourValue::Black);
//pSunLight->setCastShadows(false);
//mSceneMgr->setSkyBox(true, "Ogre/Compositor/VolumetricSunLight/FakeSky");
//Ogre::Viewport * pViewport = mCamera->getViewport();
//Ogre::CompositorInstance * pEffectInstance = Ogre::CompositorManager::getSingleton().addCompositor(pViewport, "VolumetricSunLights", -1);
//Ogre::CompositorManager::getSingleton().setCompositorEnabled(pViewport, "VolumetricSunLights", true);
//mEffectListener = new VolumetricSunLightFrameListener(mSceneMgr, mCamera, mWindow->getViewport(0));
//pEffectInstance->addListener(mEffectListener);
/// Motion blur effect
Ogre::CompositorPtr comp3 = Ogre::CompositorManager::getSingleton().create(
"MotionBlur", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
{
Ogre::CompositionTechnique *t = comp3->createTechnique();
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("sum");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
/// Render scene
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Initialisation pass for sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("sum");
tp->setOnlyInitial(true);
}
/// Do the motion blur
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Combine");
pass->setInput(0, "scene");
pass->setInput(1, "sum");
}
}
/// Copy back sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("sum");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Copyback");
pass->setInput(0, "temp");
}
}
/// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/MotionBlur");
pass->setInput(0, "sum");
}
}
}
Ogre::CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0), "MotionBlur");
Ogre::CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0), "MotionBlur", true);
}
void SceneSetup::createMotionBlurCompositor (void)
{
// Motion blur effect
Ogre::CompositorPtr comp3 = Ogre::CompositorManager::getSingleton().create(
"MotionBlur", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
{
Ogre::CompositionTechnique *t = comp3->createTechnique();
t->setCompositorLogicName("MotionBlur");
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("sum");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
// Render scene texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
// Initialisation pass for sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("sum");
tp->setOnlyInitial(true);
}
// Do the motion blur, accepting listener injection
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Combine");
pass->setInput(0, "scene");
pass->setInput(1, "sum");
pass->setIdentifier(700);
}
}
// Copy back sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("sum");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Copyback");
pass->setInput(0, "temp");
}
}
// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/MotionBlur");
pass->setInput(0, "sum");
}
}
}
}
void TerrainManager::initMotionBlur()
{
// Motion blur effect taken from Ogre 1.8 Compositor demos
Ogre::CompositorPtr comp3 = Ogre::CompositorManager::getSingleton().create("MotionBlur", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
{
Ogre::CompositionTechnique *t = comp3->createTechnique();
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("sum");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
/// Render scene
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Initialisation pass for sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("sum");
tp->setOnlyInitial(true);
}
/// Do the motion blur
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Combine");
pass->setInput(0, "scene");
pass->setInput(1, "sum");
}
}
/// Copy back sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("sum");
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Copyback");
pass->setInput(0, "temp");
}
}
/// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/MotionBlur");
pass->setInput(0, "sum");
}
}
}
Ogre::CompositorManager::getSingleton().addCompositor(gEnv->mainCamera->getViewport(),"MotionBlur");
Ogre::CompositorManager::getSingleton().setCompositorEnabled(gEnv->mainCamera->getViewport(), "MotionBlur", true);
}
void darkMainSinglePlayer::enter()
{
//ustvarimo Motion Blur
engine = irrklang::createIrrKlangDevice();
engine2 = irrklang::createIrrKlangDevice();
engine->play2D("media/darkMedia/Sounds/park_1.wav", true);
Ogre::CompositorPtr comp3 = Ogre::CompositorManager::getSingleton().create(
"Motion Blur", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
{
Ogre::CompositionTechnique *t = comp3->createTechnique();
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("sum");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
/// Render scene
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Initialisation pass for sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("sum");
tp->setOnlyInitial(true);
}
/// Do the motion blur
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Combine");
pass->setInput(0, "scene");
pass->setInput(1, "sum");
}
}
/// Copy back sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("sum");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Copyback");
pass->setInput(0, "temp");
}
}
/// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/MotionBlur");
pass->setInput(0, "sum");
}
}
}
Ogre::CompositorManager& compMgr = Ogre::CompositorManager::getSingleton();
//dodamo kompositorje
static bool firstTime = true;
if (firstTime)
{
compMgr.registerCompositorLogic("HDR", new HDRLogic);
firstTime = false;
}
//Sporocilo za Log
OgreFramework::getSingletonPtr()->m_pLog->logMessage("Entering SinglePlayer...");
//Teren Manager
m_pSceneMgr = OgreFramework::getSingletonPtr()->m_pRoot->createSceneManager("TerrainSceneManager");
//izbrisemo kurzor in razno
OgreFramework::getSingletonPtr()->m_pTrayMgr->hideBackdrop();
OgreFramework::getSingletonPtr()->m_pTrayMgr->hideCursor();
//Dodamo kamero
m_pCamera = m_pSceneMgr->createCamera("GameCamera");
m_pCamera->setPosition(Ogre::Vector3(0, 0, 0));
m_pCamera->setNearClipDistance(5);
m_pCamera->setAspectRatio(Real(OgreFramework::getSingletonPtr()->m_pViewport->getActualWidth())/Real(OgreFramework::getSingletonPtr()->m_pViewport->getActualHeight()));
OgreFramework::getSingletonPtr()->m_pViewport->setCamera(m_pCamera);
//Dolocimo kaksno obliko bo nas svet imel
m_pSceneMgr->setWorldGeometry("darkPlayerWorld1.cfg");
mCollisionTools = new MOC::CollisionTools(m_pSceneMgr);
//Dodamo Kompositor Efekte
Ogre::CompositorManager::getSingleton().addCompositor(m_pCamera->getViewport(), "Bloom", -1);
Ogre::CompositorManager::getSingleton().setCompositorEnabled(m_pCamera->getViewport(), "Bloom", true);
Ogre::CompositorManager::getSingleton().addCompositor(m_pCamera->getViewport(), "B&W",-1);
Ogre::CompositorManager::getSingleton().setCompositorEnabled(m_pCamera->getViewport(), "B&W", false);
Ogre::CompositorManager::getSingleton().addCompositor(m_pCamera->getViewport(), "Motion Blur",-1);
Ogre::CompositorManager::getSingleton().setCompositorEnabled(m_pCamera->getViewport(), "Motion Blur", false);
//Dobimo informacije o igralcu
playerInfo();
buildGUI();
createScene();
}
//-----------------------------------------------------------------------------------
/// Create the hard coded postfilter effects
void CompositorDemo::createEffects(void)
{
// Bloom compositor is loaded from script but here is the hard coded equivalent
// CompositorPtr comp = CompositorManager::getSingleton().create(
// "Bloom", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
// );
// {
// CompositionTechnique *t = comp->createTechnique();
// {
// CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("rt0");
// def->width = 128;
// def->height = 128;
// def->format = PF_A8R8G8B8;
// }
// {
// CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("rt1");
// def->width = 128;
// def->height = 128;
// def->format = PF_A8R8G8B8;
// }
// {
// CompositionTargetPass *tp = t->createTargetPass();
// tp->setInputMode(CompositionTargetPass::IM_PREVIOUS);
// tp->setOutputName("rt1");
// }
// {
// CompositionTargetPass *tp = t->createTargetPass();
// tp->setInputMode(CompositionTargetPass::IM_NONE);
// tp->setOutputName("rt0");
// CompositionPass *pass = tp->createPass();
// pass->setType(CompositionPass::PT_RENDERQUAD);
// pass->setMaterialName("Ogre/Compositor/Blur0");
// pass->setInput(0, "rt1");
// }
// {
// CompositionTargetPass *tp = t->createTargetPass();
// tp->setInputMode(CompositionTargetPass::IM_NONE);
// tp->setOutputName("rt1");
// CompositionPass *pass = tp->createPass();
// pass->setType(CompositionPass::PT_RENDERQUAD);
// pass->setMaterialName("Ogre/Compositor/Blur1");
// pass->setInput(0, "rt0");
// }
// {
// CompositionTargetPass *tp = t->getOutputTargetPass();
// tp->setInputMode(CompositionTargetPass::IM_PREVIOUS);
// { CompositionPass *pass = tp->createPass();
// pass->setType(CompositionPass::PT_RENDERQUAD);
// pass->setMaterialName("Ogre/Compositor/BloomBlend");
// pass->setInput(0, "rt1");
// }
// }
// }
// Glass compositor is loaded from script but here is the hard coded equivalent
/// Glass effect
// CompositorPtr comp2 = CompositorManager::getSingleton().create(
// "Glass", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
// );
// {
// CompositionTechnique *t = comp2->createTechnique();
// {
// CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("rt0");
// def->width = 0;
// def->height = 0;
// def->format = PF_R8G8B8;
// }
// {
// CompositionTargetPass *tp = t->createTargetPass();
// tp->setInputMode(CompositionTargetPass::IM_PREVIOUS);
// tp->setOutputName("rt0");
// }
// {
// CompositionTargetPass *tp = t->getOutputTargetPass();
// tp->setInputMode(CompositionTargetPass::IM_NONE);
// { CompositionPass *pass = tp->createPass();
// pass->setType(CompositionPass::PT_RENDERQUAD);
// pass->setMaterialName("Ogre/Compositor/GlassPass");
// pass->setInput(0, "rt0");
// }
// }
// }
/// Motion blur effect
Ogre::CompositorPtr comp3 = Ogre::CompositorManager::getSingleton().create(
"Motion Blur", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
{
Ogre::CompositionTechnique *t = comp3->createTechnique();
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("sum");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
/// Render scene
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Initialisation pass for sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("sum");
tp->setOnlyInitial(true);
}
/// Do the motion blur
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Combine");
pass->setInput(0, "scene");
pass->setInput(1, "sum");
}
}
/// Copy back sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("sum");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Copyback");
pass->setInput(0, "temp");
}
}
/// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/MotionBlur");
pass->setInput(0, "sum");
}
}
}
/// Heat vision effect
Ogre::CompositorPtr comp4 = Ogre::CompositorManager::getSingleton().create(
"Heat Vision", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
{
Ogre::CompositionTechnique *t = comp4->createTechnique();
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 256;
def->height = 256;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 256;
def->height = 256;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
/// Render scene
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Light to heat pass
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setIdentifier(0xDEADBABE); /// Identify pass for use in listener
pass->setMaterialName("Fury/HeatVision/LightToHeat");
pass->setInput(0, "scene");
}
}
/// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Fury/HeatVision/Blur");
pass->setInput(0, "temp");
}
}
}
}
void CompositorChapter::CreateEffects()
{
/// Motion blur effect
Ogre::CompositorPtr comp3 = Ogre::CompositorManager::getSingleton().create(
"Motion Blur", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
{
Ogre::CompositionTechnique *t = comp3->createTechnique();
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("sum");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 0;
def->height = 0;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
/// Render scene
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Initialisation pass for sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("sum");
tp->setOnlyInitial(true);
}
/// Do the motion blur
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Combine");
pass->setInput(0, "scene");
pass->setInput(1, "sum");
}
}
/// Copy back sum texture
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("sum");
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/Copyback");
pass->setInput(0, "temp");
}
}
/// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{ Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Ogre/Compositor/MotionBlur");
pass->setInput(0, "sum");
}
}
}
/// Heat vision effect
Ogre::CompositorPtr comp4 = Ogre::CompositorManager::getSingleton().create(
"Heat Vision", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME
);
{
Ogre::CompositionTechnique *t = comp4->createTechnique();
t->setCompositorLogicName("HeatVision");
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("scene");
def->width = 256;
def->height = 256;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
{
Ogre::CompositionTechnique::TextureDefinition *def = t->createTextureDefinition("temp");
def->width = 256;
def->height = 256;
def->formatList.push_back(Ogre::PF_R8G8B8);
}
/// Render scene
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
tp->setOutputName("scene");
}
/// Light to heat pass
{
Ogre::CompositionTargetPass *tp = t->createTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
tp->setOutputName("temp");
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setIdentifier(0xDEADBABE); /// Identify pass for use in listener
pass->setMaterialName("Fury/HeatVision/LightToHeat");
pass->setInput(0, "scene");
}
}
/// Display result
{
Ogre::CompositionTargetPass *tp = t->getOutputTargetPass();
tp->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
{
Ogre::CompositionPass *pass = tp->createPass();
pass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
pass->setMaterialName("Fury/HeatVision/Blur");
pass->setInput(0, "temp");
}
}
}
}
