void StereoController::TakeScreenshots(QString path, QString filename)
{
if (stereo_views_.count() == 0)
{
LogError("StereoController: Cannot take stereographic screenshots. Stereo not enabled!");
return;
}
// FIXME relies on that there is only one external window and
// its the right side window for stereographical stuff
QString leftname = filename.replace(".jpg", "_left.jpg");
QString rightname = filename.replace("_left.jpg", "_right.jpg");
Ogre::CompositorInstance* comp = stereo_views_["stereoview0"]->GetCompositor();
if (!comp)
{
LogError("StereoController: Wrong stereographic mode. No Compositor. Cannot take screenshots!");
return;
}
comp->getRenderTarget("Stereo/Left")->writeContentsToFile(path.toStdString() + leftname.toStdString());
comp->getRenderTarget("Stereo/Right")->writeContentsToFile(path.toStdString() + rightname.toStdString());
}
bool CompositionHandler::AddCompositor(const std::string &compositor, Ogre::Viewport *vp, int position)
{
bool succesfull = false;
if (c_manager_!=0 && vp != 0)
{
Ogre::CompositorInstance* comp = c_manager_->addCompositor(vp, compositor, position);
if(comp != 0)
{
if(compositor == "HDR" || compositor == "Strong HDR")
{
comp->addListener(&hdr_listener_);
hdr_listener_.notifyViewportSize(vp->getActualWidth(), vp->getActualHeight());
hdr_listener_.notifyCompositor(comp);
}
else if(compositor == "Gaussian Blur")
{
comp->addListener(&gaussian_listener_);
gaussian_listener_.notifyViewportSize(vp->getActualWidth(), vp->getActualHeight());
}
c_manager_->setCompositorEnabled(vp, compositor, true);
succesfull=true;
}
}
if (!succesfull)
::LogWarning("Failed to enable effect: " + compositor);
return succesfull;
}
void MainCamera::enableCompositor(const std::string& compositorName, bool enable)
{
if (enable) {
S_LOG_INFO("Enabling compositor '" << compositorName<< "'.");
} else {
S_LOG_INFO("Disabling compositor '" << compositorName<< "'.");
}
if (std::find(mLoadedCompositors.begin(), mLoadedCompositors.end(), compositorName) == mLoadedCompositors.end()) {
Ogre::CompositorInstance* compositor = Ogre::CompositorManager::getSingleton().addCompositor(mWindow.getViewport(0), compositorName);
if (compositor) {
bool hasErrors = false;
//There's a bug in Ogre which will causes a segfault during rendering if a compositor has an invalid shader.
//We therefore need to check for this here, and disable the shader if so is the case.
compositor->getCompositor()->load();
hasErrors = !validateCompositionTargetPass(*compositor->getTechnique()->getOutputTargetPass());
if (!hasErrors) {
Ogre::CompositionTechnique::TargetPassIterator targetPassIter = compositor->getTechnique()->getTargetPassIterator();
while (targetPassIter.hasMoreElements() && !hasErrors) {
hasErrors = !validateCompositionTargetPass(*targetPassIter.getNext());
}
}
if (hasErrors) {
S_LOG_FAILURE("Compositor "<< compositorName <<" has errors and will be disabled.");
Ogre::CompositorManager::getSingleton().removeCompositor(mWindow.getViewport(0), compositorName);
} else {
compositor->setEnabled(true);
mLoadedCompositors.push_back(compositorName);
}
}
} else {
Ogre::CompositorManager::getSingleton().setCompositorEnabled(mWindow.getViewport(0), compositorName, enable);
}
}
void Main::InitCompositor()
{
mSceneRenderCompositor = Ogre::CompositorManager::getSingleton().addCompositor(GetViewport(), "RenderHDRScene");
mSceneRenderCompositor->addListener(new VolumetricLightListener());
Ogre::CompositorManager::getSingleton().setCompositorEnabled(GetViewport(), "RenderHDRScene", true);
Ogre::CompositorInstance *hdrinstance = Ogre::CompositorManager::getSingleton().addCompositor(Main::Instance().GetViewport(), "DownsampleHDR1");
HDRListener *hdrListener = new HDRListener();
hdrinstance->addListener(hdrListener);
hdrListener->notifyViewportSize(mViewport->getActualWidth(), mViewport->getActualHeight());
hdrListener->notifyCompositor(hdrinstance);
Ogre::CompositorManager::getSingleton().setCompositorEnabled(GetViewport(), "DownsampleHDR1", true);
}
void PostEffect::AssignToViewport(Viewport& viewport)
{
#if defined ION_RENDERER_OGRE3D
Ogre::CompositorInstance* compositorInstance = Ogre::CompositorManager::getSingleton().addCompositor(viewport.GetOgreViewportInterface(), mName.c_str());
ion::debug::Assert(compositorInstance != NULL, "PostEffect::AssignToViewport() - Could not create compositor instance, did its materials load successfully?");
compositorInstance->setEnabled(true);
if(mOgreCompositorListener)
{
compositorInstance->addListener(mOgreCompositorListener);
}
#endif
}
void DeferredShadingSystem::logCurrentMode(void)
{
if (mActive==false)
{
Ogre::LogManager::getSingleton().logMessage("No Compositor Enabled!");
return;
}
Ogre::CompositorInstance* ci = mInstance[mCurrentMode];
assert(ci->getEnabled()==true);
Ogre::LogManager::getSingleton().logMessage("Current Mode: ");
Ogre::LogManager::getSingleton().logMessage(ci->getCompositor()->getName());
}
void CameraBlurListener::notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
if (pass_id == 999)
{
if(mApp->pGame->pause == false)
{
//acquire the texture flipping attribute in the first frame
if(compositorinstance)
{
mRequiresTextureFlipping = compositorinstance->getRenderTarget("previousscene")->requiresTextureFlipping();
compositorinstance=NULL;
}
// this is the camera you're using
#ifndef ROAD_EDITOR
Ogre::Camera *cam = mApp->mSplitMgr->mCameras.front();
#else
Ogre::Camera *cam = mApp->mCamera;
#endif
// get the pass
Ogre::Pass *pass = mat->getBestTechnique()->getPass(0);
Ogre::GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
const Ogre::RenderTarget::FrameStats& stats = mApp->getWindow()->getStatistics();
float m_lastFPS =stats.lastFPS;
Ogre::Matrix4 projectionMatrix = cam->getProjectionMatrix();
if (mRequiresTextureFlipping)
{
// Because we're not using setProjectionMatrix, this needs to be done here
// Invert transformed y
projectionMatrix[1][0] = -projectionMatrix[1][0];
projectionMatrix[1][1] = -projectionMatrix[1][1];
projectionMatrix[1][2] = -projectionMatrix[1][2];
projectionMatrix[1][3] = -projectionMatrix[1][3];
}
Ogre::Matrix4 iVP = (projectionMatrix * cam->getViewMatrix()).inverse();
if (params->_findNamedConstantDefinition("EPF_ViewProjectionInverseMatrix"))
params->setNamedConstant("EPF_ViewProjectionInverseMatrix", iVP);
if (params->_findNamedConstantDefinition("EPF_PreviousViewProjectionMatrix"))
params->setNamedConstant("EPF_PreviousViewProjectionMatrix", prevviewproj);
if (params->_findNamedConstantDefinition("intensity"))
params->setNamedConstant("intensity", mApp->pSet->motionblurintensity);
float interpolationFactor = m_lastFPS * 0.03f ; //* m_timeScale m_timeScale is a multiplier to control motion blur interactively
Ogre::Quaternion current_orientation = cam->getDerivedOrientation();
Ogre::Vector3 current_position = cam->getDerivedPosition();
Ogre::Quaternion estimatedOrientation = Ogre::Quaternion::Slerp(interpolationFactor, current_orientation, (m_pPreviousOrientation));
Ogre::Vector3 estimatedPosition = (1-interpolationFactor) * current_position + interpolationFactor * (m_pPreviousPosition);
Ogre::Matrix4 prev_viewMatrix = Ogre::Math::makeViewMatrix(estimatedPosition, estimatedOrientation);//.inverse().transpose();
// compute final matrix
prevviewproj = projectionMatrix * prev_viewMatrix;
// update position and orientation for next update time
m_pPreviousOrientation = current_orientation;
m_pPreviousPosition = current_position;
}
}
}
//---------------------------------------------------------------------
void CompositorDemo_FrameListener::updateDebugRTTWindow(void)
{
// Clear listbox
mDebugRTTListbox->resetList();
// Clear imagesets
mDebugRTTStaticImage->setProperty("Image", "");
for (ImageSetList::iterator isIt = mDebugRTTImageSets.begin();
isIt != mDebugRTTImageSets.end(); ++isIt)
{
CEGUI::ImagesetManager::getSingleton().destroyImageset(*isIt);
}
mDebugRTTImageSets.clear();
Ogre::set<Ogre::String>::type uniqueTextureNames;
// Add an entry for each render texture for all active compositors
Ogre::Viewport* vp = mMain->getRenderWindow()->getViewport(0);
Ogre::CompositorChain* chain = Ogre::CompositorManager::getSingleton().getCompositorChain(vp);
Ogre::CompositorChain::InstanceIterator it = chain->getCompositors();
while (it.hasMoreElements())
{
Ogre::CompositorInstance* inst = it.getNext();
if (inst->getEnabled())
{
Ogre::CompositionTechnique::TextureDefinitionIterator texIt =
inst->getTechnique()->getTextureDefinitionIterator();
while (texIt.hasMoreElements())
{
Ogre::CompositionTechnique::TextureDefinition* texDef = texIt.getNext();
// Get instance name of texture (NB only index 0 if MRTs for now)
const Ogre::String& instName = inst->getTextureInstanceName(texDef->name, 0);
// Create CEGUI texture from name of OGRE texture
CEGUI::Texture* tex = mMain->getGuiRenderer()->createTexture(instName.c_str());
// Create imageset
// Note that if we use shared textures in compositor, the same texture name
// will occur more than once, so we have to cater for this
if (uniqueTextureNames.find(instName) == uniqueTextureNames.end())
{
CEGUI::Imageset* imgSet =
CEGUI::ImagesetManager::getSingleton().createImageset(
instName.c_str(), tex);
mDebugRTTImageSets.push_back(imgSet);
imgSet->defineImage((CEGUI::utf8*)"RttImage",
CEGUI::Point(0.0f, 0.0f),
CEGUI::Size(tex->getWidth(), tex->getHeight()),
CEGUI::Point(0.0f,0.0f));
CEGUI::ListboxTextItem *item = new CEGUI::ListboxTextItem(texDef->name.c_str(), 0, imgSet);
item->setSelectionBrushImage("TaharezLook", "ListboxSelectionBrush");
item->setSelectionColours(CEGUI::colour(0,0,1));
mDebugRTTListbox->addItem(item);
uniqueTextureNames.insert(instName);
}
}
}
}
}
bool gkCompositorManager::setCompositorChain(gkCompositorOp op, const gkString& compositorName, gkViewport *viewport)
{
GK_ASSERT(viewport && viewport->getViewport());
bool found = false;
Ogre::Viewport *vp = viewport->getViewport();
int width = vp->getActualWidth(), height = vp->getActualHeight();
Ogre::CompositorChain *chain = Ogre::CompositorManager::getSingleton().getCompositorChain(vp); assert(chain);
for (size_t i = 0; i < chain->getNumCompositors(); i++)
{
Ogre::CompositorInstance *ci = chain->getCompositor(i); assert(ci);
bool match = (compositorName == ci->getCompositor()->getName());
if (op == GK_COMPOSITOR_OP_REPLACE)
ci->setEnabled(match);
else if
(op == GK_COMPOSITOR_OP_RESET) ci->setEnabled(false);
else if
(match) ci->setEnabled(op == GK_COMPOSITOR_OP_ADD);
if (!found && match) found = true;
}
if (op == GK_COMPOSITOR_OP_DEL || op == GK_COMPOSITOR_OP_RESET)
return true;
if (!compositorName.empty() && !found) //create new compositor
{
if (compositorName == GK_COMPOSITOR_HEAT_VISION && !m_heatVisionInited)
m_heatVisionInited = gkOgreCompositorHelper::createHeatVisionCompositor();
else if (compositorName == GK_COMPOSITOR_MOTION_BLUR && !m_motionBlurInited)
m_motionBlurInited = gkOgreCompositorHelper::createMotionBlurCompositor();
Ogre::CompositorManager& compMgr = Ogre::CompositorManager::getSingleton();
Ogre::CompositorInstance* instance = compMgr.addCompositor(vp, compositorName, 0);
if (instance)
{
if (compositorName == GK_COMPOSITOR_HALFTONE && !m_halftonInited)
m_halftonInited = gkOgreCompositorHelper::createHalftoneTexture();
else if (compositorName == GK_COMPOSITOR_DITHER && !m_ditherInited)
m_ditherInited = gkOgreCompositorHelper::createDitherTexture(width, height);
instance->setEnabled(true);
gkPrintf("[COMP] add new compositor: %s", compositorName.c_str());
return true;
}
else
{
gkPrintf("[COMP] %s - FAILED. check compositor name.", compositorName.c_str());
return false;
}
}
return false;
}
