Revision: 1636
http://rigsofrods.svn.sourceforge.net/rigsofrods/?rev=1636&view=rev
Author: rorthomas
Date: 2011-02-02 20:07:58 +0000 (Wed, 02 Feb 2011)
Log Message:
-----------
DOF-improvements
fixed heathaze ratio
improved caelum fog mode
Modified Paths:
--------------
trunk/source/main/Heathaze.cpp
trunk/source/main/RoRFrameListener.cpp
trunk/source/main/RoRFrameListener.h
trunk/source/main/SkyManager.cpp
trunk/source/main/dof/DepthOfFieldEffect.cpp
trunk/source/main/dof/DepthOfFieldEffect.h
trunk/source/main/dof/Lens.cpp
trunk/source/main/dof/Lens.h
Modified: trunk/source/main/Heathaze.cpp
===================================================================
--- trunk/source/main/Heathaze.cpp 2011-02-02 17:10:50 UTC (rev 1635)
+++ trunk/source/main/Heathaze.cpp 2011-02-02 20:07:58 UTC (rev 1636)
@@ -43,7 +43,7 @@
HeatHaze::HeatHaze(SceneManager *sceneMgr, RenderWindow *mWindow, Ogre::Camera
*cam) : mSceneMgr(sceneMgr), rttTex(0), listener(0)
{
- TexturePtr rttTexPtr =
TextureManager::getSingleton().createManual("heathaze_rtt",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, 512, 512, 0,
PF_R8G8B8, TU_RENDERTARGET, new ResourceBuffer());
+ TexturePtr rttTexPtr =
TextureManager::getSingleton().createManual("heathaze_rtt",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D,
cam->getViewport()->getWidth(), cam->getViewport()->getHeight(), 0, PF_R8G8B8,
TU_RENDERTARGET, new ResourceBuffer());
rttTex = rttTexPtr->getBuffer()->getRenderTarget();
{
/*
Modified: trunk/source/main/RoRFrameListener.cpp
===================================================================
--- trunk/source/main/RoRFrameListener.cpp 2011-02-02 17:10:50 UTC (rev
1635)
+++ trunk/source/main/RoRFrameListener.cpp 2011-02-02 20:07:58 UTC (rev
1636)
@@ -2613,11 +2613,13 @@
{
// change to fixed free camera: that is working like
fixed cam
cameramode = CAMERA_FREE_FIXED;
+ if(mDOF) mDOF->setFocusMode(DOFManager::Auto);
LogManager::getSingleton().logMessage("switching to
fixed free camera mode");
if(ow) ow->flashMessage(_L("fixed free camera"));
} else if(cameramode == CAMERA_FREE_FIXED)
{
cameramode = CAMERA_FREE;
+ if(mDOF) mDOF->setFocusMode(DOFManager::Auto);
LogManager::getSingleton().logMessage("switching to
free camera mode from fixed mode");
if(ow) ow->flashMessage(_L("free camera"));
}
@@ -2629,12 +2631,14 @@
if(cameramode == CAMERA_FREE || cameramode == CAMERA_FREE_FIXED)
{
// change back to normal camera
+ if(mDOF) mDOF->setFocusMode(DOFManager::Manual);
cameramode = storedcameramode;
LogManager::getSingleton().logMessage("exiting free
camera mode");
if(ow) ow->flashMessage(_L("normal camera"));
} else if(cameramode != CAMERA_FREE && cameramode !=
CAMERA_FREE_FIXED )
{
// enter free camera mode
+ if(mDOF) mDOF->setFocusMode(DOFManager::Auto);
storedcameramode = cameramode;
cameramode = CAMERA_FREE;
LogManager::getSingleton().logMessage("entering free
camera mode");
@@ -5308,11 +5312,12 @@
bool useDOF = (SETTINGS.getSetting("DOF") == "Yes");
if(useDOF)
{
- mDOF = new DepthOfFieldEffect(mCamera->getViewport());
+ mDOF = new DOFManager(mSceneMgr, mCamera->getViewport(), mRoot,
mCamera);
mDOF->setEnabled(true);
}
+
if (SETTINGS.getSetting("Glow") == "Yes")
{
CompositorManager::getSingleton().addCompositor(mCamera->getViewport(), "Glow");
@@ -6763,6 +6768,7 @@
if(changeCamMode)
mCamera->setFOVy(Degree(80));
collisions->forcecam=false;
+ if(mDOF) mDOF->setFocusMode(DOFManager::Auto);
}
else
{
@@ -6778,6 +6784,7 @@
camIdealPosition=camDist/2.0*Vector3(sin(angle+camRotX.valueRadians())*cos(camRotY.valueRadians()),sin(camRotY.valueRadians()),cos(angle+camRotX.valueRadians())*cos(camRotY.valueRadians()));
+ float real_camdist = camIdealPosition.length();
camIdealPosition=camIdealPosition+person->getPosition();
Vector3
newposition=(camIdealPosition+10.0*mCamera->getPosition())/11.0;
@@ -6794,6 +6801,14 @@
mCamera->setFOVy(Degree(60));
lastPosition=person->getPosition();
+
+ if(mDOF)
+ {
+ mDOF->setFocusMode(DOFManager::Manual);
+ mDOF->setFocus(real_camdist);
+ mDOF->setLensFOV(Degree(60));
+ }
+
//lastangle=angle;
}
}
@@ -6815,7 +6830,17 @@
}
mCamera->setPosition(Vector3(px+50.0, h+1.7, pz+50.0));
mCamera->lookAt(person->getPosition());
-
mCamera->setFOVy(Radian(atan2(20.0f,(mCamera->getPosition()-person->getPosition()).length())));
+ float real_camDist =
(mCamera->getPosition()-person->getPosition()).length();
+ Radian fov = Radian(atan2(20.0f,real_camDist));
+ mCamera->setFOVy(fov);
+
+ if(mDOF)
+ {
+ mDOF->setFocusMode(DOFManager::Manual);
+ mDOF->setFocus(real_camDist);
+ mDOF->setLensFOV(fov);
+ }
+
}
else if (cameramode==CAMERA_INT)
{
@@ -6832,6 +6857,12 @@
camRotX=pushcamRotX;
camRotY=pushcamRotY;
}
+ if(mDOF)
+ {
+ mDOF->setFocusMode(DOFManager::Auto);
+ mDOF->setLensFOV(Degree(75));
+ }
+
}
}
else
@@ -6859,6 +6890,12 @@
if(changeCamMode)
mCamera->setFOVy(Degree(80));
collisions->forcecam=false;
+
+ if(mDOF)
+ {
+ mDOF->setFocusMode(DOFManager::Auto);
+ mDOF->setLensFOV(Degree(80));
+ }
}
else
{
@@ -6881,6 +6918,7 @@
camIdealPosition=camDist*Vector3(sin(angle+camRotX.valueRadians())*cos(camRotY.valueRadians()),sin(camRotY.valueRadians()),cos(angle+camRotX.valueRadians())*cos(camRotY.valueRadians()));
}
+ float cam_realdist = camIdealPosition.length();
camIdealPosition=camIdealPosition+trucks[current_truck]->getPosition();
Vector3
oldposition=mCamera->getPosition()+trucks[current_truck]->nodes[0].Velocity*trucks[current_truck]->ttdt;
float
ratio=1.0/(trucks[current_truck]->tdt*4.0);
@@ -6900,6 +6938,15 @@
mCamera->setFOVy(Degree(60));
lastPosition=trucks[current_truck]->getPosition();
+
+ if(mDOF)
+ {
+ mDOF->setFocusMode(DOFManager::Manual);
+ mDOF->setFocus(cam_realdist);
+ mDOF->setLensFOV(Degree(60));
+ }
+
+
//lastangle=angle;
}
}
@@ -6929,7 +6976,16 @@
mCamera->setPosition(newposition);
}
mCamera->lookAt(trucks[current_truck]->getPosition());
-
mCamera->setFOVy(Radian(atan2(100.0f,(mCamera->getPosition()-trucks[current_truck]->getPosition()).length())));
+ float real_camDist =
(mCamera->getPosition()-trucks[current_truck]->getPosition()).length();
+ Radian fov = Radian(atan2(100.0f,real_camDist));
+ mCamera->setFOVy(fov);
+ if(mDOF)
+ {
+ mDOF->setFocusMode(DOFManager::Manual);
+ mDOF->setFocus(real_camDist);
+ mDOF->setLensFOV(fov);
+ }
+
}
else
{
@@ -6941,7 +6997,15 @@
h=w->getHeightWaves(Vector3(px+50.0,0,pz+50.0));
mCamera->setPosition(Vector3(px+50.0, h+1.7,
pz+50.0));
mCamera->lookAt(trucks[current_truck]->getPosition());
-
mCamera->setFOVy(Radian(atan2(20.0f,(mCamera->getPosition()-trucks[current_truck]->getPosition()).length())));
+ float real_camDist =
(mCamera->getPosition()-trucks[current_truck]->getPosition()).length();
+ Radian fov = Radian(atan2(20.0f,real_camDist));
+ mCamera->setFOVy(fov);
+ if(mDOF)
+ {
+ mDOF->setFocusMode(DOFManager::Manual);
+ mDOF->setFocus(real_camDist);
+ mDOF->setLensFOV(fov);
+ }
}
}
if (cameramode==CAMERA_INT)
@@ -7017,6 +7081,14 @@
trucks[current_truck]->prepareInside(false);
if(ow) ow->showDashboardOverlays(true,
trucks[current_truck]->driveable);
}
+
+ if(mDOF)
+ {
+ mDOF->setFocusMode(DOFManager::Manual);
+ mDOF->setFocus(2);
+ mDOF->setLensFOV(Degree(90));
+ }
+
}
}
Modified: trunk/source/main/RoRFrameListener.h
===================================================================
--- trunk/source/main/RoRFrameListener.h 2011-02-02 17:10:50 UTC (rev
1635)
+++ trunk/source/main/RoRFrameListener.h 2011-02-02 20:07:58 UTC (rev
1636)
@@ -185,7 +185,7 @@
} animated_object_t;
class RoRFrameListener;
-class DepthOfFieldEffect;
+class DOFManager;
class SelectorWindow;
@@ -222,7 +222,7 @@
std::map< std::string, Ogre::SceneNode *> loadedObjects;
- DepthOfFieldEffect *mDOF;
+ DOFManager *mDOF;
int mouseX;
int mouseY;
int shaderSchemeMode;
Modified: trunk/source/main/SkyManager.cpp
===================================================================
--- trunk/source/main/SkyManager.cpp 2011-02-02 17:10:50 UTC (rev 1635)
+++ trunk/source/main/SkyManager.cpp 2011-02-02 20:07:58 UTC (rev 1636)
@@ -22,6 +22,8 @@
#include "SkyManager.h"
+#include "Settings.h"
+
#include "Ogre.h"
#include "Caelum.h"
@@ -84,6 +86,11 @@
mCaelumSystem->getMoon()->getMainLight()->setCastShadows(false);
}
+ if (SETTINGS.getSetting("Fog") != "Yes")
+ {
+
mCaelumSystem->setSceneFogDensityMultiplier(0.000000000001);
+ }
+
mCaelumSystem->setEnsureSingleShadowSource(true);
mCaelumSystem->setEnsureSingleLightSource(true);
Modified: trunk/source/main/dof/DepthOfFieldEffect.cpp
===================================================================
--- trunk/source/main/dof/DepthOfFieldEffect.cpp 2011-02-02 17:10:50 UTC
(rev 1635)
+++ trunk/source/main/dof/DepthOfFieldEffect.cpp 2011-02-02 20:07:58 UTC
(rev 1636)
@@ -1,25 +1,34 @@
-// "Depth of Field" demo for Ogre
+// "Depth of Field" demo for Ogre
// Copyright (C) 2006 Christian Lindequist Larsen
//
// This code is in the public domain. You may do whatever you want with it.
-// changed by tdev, 02/02/2011
-
#include "DepthOfFieldEffect.h"
+#include <Ogre.h>
+#include "Lens.h"
using namespace Ogre;
const int DepthOfFieldEffect::BLUR_DIVISOR = 5;
-int DepthOfFieldEffect::DoF_ID = 0;
-DepthOfFieldEffect::DepthOfFieldEffect(Viewport* viewport)
- : mViewport(viewport)
- , mNearDepth(10.0)
+DepthOfFieldEffect::DepthOfFieldEffect(Ogre::Viewport *v, Ogre::Camera *cam) :
+ mNearDepth(10.0)
, mFocalDepth(100.0)
, mFarDepth(190.0)
, mFarBlurCutoff(1.0)
+ , mViewport(v)
+ , mCamera(cam)
{
- DoF_ID++;
+ mWidth = mViewport->getActualWidth();
+ mHeight = mViewport->getActualHeight();
+
+ mCompositor = NULL;
+ mDepthTechnique = NULL;
+ mDepthTarget = NULL;
+ mDepthViewport = NULL;
+ mDepthTexture.setNull();
+ mDepthMaterial.setNull();
+
createDepthRenderTexture();
addCompositor();
}
@@ -55,60 +64,73 @@
void DepthOfFieldEffect::createDepthRenderTexture()
{
// Create the depth render texture
- TexturePtr depthTexture = TextureManager::getSingleton().createManual(
- "DoF_Depth" + StringConverter::toString(DoF_ID),
- ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
- TEX_TYPE_2D, mViewport->getActualWidth(),
mViewport->getActualHeight(),
+ mDepthTexture = TextureManager::getSingleton().createManual(
+ "DoF_Depth",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
+ TEX_TYPE_2D, mWidth, mHeight,
0, PF_L8, TU_RENDERTARGET);
// Get its render target and add a viewport to it
- RenderTexture* depthTarget =
depthTexture->getBuffer()->getRenderTarget();
- Viewport* depthViewport =
depthTarget->addViewport(mViewport->getCamera());
+ mDepthTarget = mDepthTexture->getBuffer()->getRenderTarget();
+ mDepthViewport = mDepthTarget->addViewport(mCamera);
// Register 'this' as a render target listener
- depthTarget->addListener(this);
+ mDepthTarget->addListener(this);
// Get the technique to use when rendering the depth render texture
mDepthMaterial = MaterialManager::getSingleton().getByName("DoF_Depth");
mDepthMaterial->load(); // needs to be loaded manually
mDepthTechnique = mDepthMaterial->getBestTechnique();
-
- try {
- // Create a custom render queue invocation sequence for the
depth render texture
- RenderQueueInvocationSequence* invocationSequence =
-
Root::getSingleton().createRenderQueueInvocationSequence("DoF_Depth");
- // Add a render queue invocation to the sequence, and disable
shadows for it
- RenderQueueInvocation* invocation =
invocationSequence->add(RENDER_QUEUE_MAIN, "main");
- invocation->setSuppressShadows(true);
- }
- catch(Exception e)
- {
- // do nothing, RenderQueueInvocationSequence already created
- }
+ // Create a custom render queue invocation sequence for the depth
render texture
+ RenderQueueInvocationSequence* invocationSequence =
Root::getSingleton().createRenderQueueInvocationSequence("DoF_Depth");
+ // Add a render queue invocation to the sequence, and disable shadows
for it
+ /*
+ RenderQueueInvocation* invocation =
invocationSequence->add(RENDER_QUEUE_MAIN, "main");
+ invocation->setSuppressShadows(true);
+ //invocation->setSuppressRenderStateChanges(true);
+
invocation->setSolidsOrganisation(QueuedRenderableCollection::OM_SORT_ASCENDING);
// Set the render queue invocation sequence for the depth render
texture viewport
- depthViewport->setRenderQueueInvocationSequenceName("DoF_Depth");
+ mDepthViewport->setRenderQueueInvocationSequenceName("DoF_Depth");
+ */
+
+ mDepthViewport->setShadowsEnabled(false);
+
+
+ //re-set texture "DoF_Depth"
+ MaterialPtr p =
MaterialManager::getSingleton().getByName("DoF_DepthOfField");
+ p->load();
+
p->getBestTechnique()->getPass(0)->getTextureUnitState("depth")->setTextureName("DoF_Depth");
+ p->unload();
}
void DepthOfFieldEffect::destroyDepthRenderTexture()
{
- // TODO
+ mDepthViewport->setRenderQueueInvocationSequenceName("");
+ Root::getSingleton().destroyRenderQueueInvocationSequence("DoF_Depth");
+
+ mDepthMaterial->unload();
+
+ mDepthTarget->removeAllListeners();
+ mDepthTarget->removeAllViewports();
+ //TextureManager::getSingleton().unload("DoF_Depth");
+ TextureManager::getSingleton().remove("DoF_Depth");
}
void DepthOfFieldEffect::addCompositor()
{
- // Add the compositor to the viewport
- mCompositor = CompositorManager::getSingleton().addCompositor(
- mViewport, "DoF_Compositor" +
StringConverter::toString(DoF_ID));
+ mCompositor =
CompositorManager::getSingleton().addCompositor(mViewport,
"DoF_Compositor_test");
+ mCompositor->addListener(this);
- // Register 'this' as a listener
- mCompositor->addListener(this);
+ mCompositor->setEnabled(true);
}
void DepthOfFieldEffect::removeCompositor()
{
- // TODO
+ mCompositor->setEnabled(false);
+
+ mCompositor->removeListener(this);
+ CompositorManager::getSingleton().removeCompositor(mViewport,
"DoF_Compositor_test");
}
void DepthOfFieldEffect::notifyMaterialSetup(uint32 passId, MaterialPtr&
material)
@@ -117,42 +139,39 @@
{
case BlurPass:
{
- Vector3 pixelSize = Vector3(
- 1.0f / (mViewport->getActualWidth() /
BLUR_DIVISOR),
- 1.0f / (mViewport->getActualHeight() /
BLUR_DIVISOR),
- 1.0);
+ //float pixelSize[2] = {
+ // 1.0f / (mViewport->getActualWidth() /
BLUR_DIVISOR),
+ // 1.0f / (mViewport->getActualHeight() /
BLUR_DIVISOR)};
// Adjust fragment program parameters
- GpuProgramParametersSharedPtr fragParams =
-
material->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
-
+ Ogre::Vector3 ps = Ogre::Vector3(1.0f / (mWidth /
BLUR_DIVISOR),1.0f / (mHeight / BLUR_DIVISOR), 1.0f);
+ float pixelSize[3] = { ps.x, ps.y, ps.z };
+ GpuProgramParametersSharedPtr fragParams =
material->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
if((!fragParams.isNull())&&(fragParams->_findNamedConstantDefinition("pixelSize")))
- fragParams->setNamedConstant("pixelSize",
pixelSize );
+ fragParams->setNamedConstant("pixelSize",
pixelSize, 1, 3);
break;
}
case OutputPass:
{
- Vector3 pixelSizeScene = Vector3(
- 1.0f / (mViewport->getActualWidth()),
- 1.0f / (mViewport->getActualHeight()),
- 1.0);
+ float pixelSizeScene[3] = {
+ 1.0f / mWidth,
+ 1.0f / mHeight,
+ 0};
- Vector3 pixelSizeBlur = Vector3(
- 1.0f / (mViewport->getActualWidth() /
BLUR_DIVISOR),
- 1.0f / (mViewport->getActualHeight() /
BLUR_DIVISOR),
- 1.0);
+ float pixelSizeBlur[3] = {
+ 1.0f / (mWidth / BLUR_DIVISOR),
+ 1.0f / (mHeight / BLUR_DIVISOR),
+ 0};
// Adjust fragment program parameters
GpuProgramParametersSharedPtr fragParams =
material->getBestTechnique()->getPass(0)->getFragmentProgramParameters();
-
if((!fragParams.isNull())&&(fragParams->_findNamedConstantDefinition("pixelSizeScene")))
- fragParams->setNamedConstant("pixelSizeScene",
pixelSizeScene );
-
+ fragParams->setNamedConstant("pixelSizeScene",
pixelSizeScene,1,3);
if((!fragParams.isNull())&&(fragParams->_findNamedConstantDefinition("pixelSizeBlur")))
- fragParams->setNamedConstant("pixelSizeBlur",
pixelSizeBlur );
+ fragParams->setNamedConstant("pixelSizeBlur",
pixelSizeBlur,1,3);
break;
}
@@ -161,22 +180,15 @@
void DepthOfFieldEffect::preViewportUpdate(const
Ogre::RenderTargetViewportEvent& evt)
{
- Vector4 dofParams(mNearDepth, mFocalDepth, mFarDepth, mFarBlurCutoff);
+ float dofParams[4] = {mNearDepth, mFocalDepth, mFarDepth,
mFarBlurCutoff};
+
// Adjust fragment program parameters for depth pass
GpuProgramParametersSharedPtr fragParams =
mDepthTechnique->getPass(0)->getFragmentProgramParameters();
-
if((!fragParams.isNull())&&(fragParams->_findNamedConstantDefinition("dofParams")))
- fragParams->setNamedConstant("dofParams", dofParams);
+ fragParams->setNamedConstant("dofParams", dofParams,1,4);
- /*
- fragParams->setNamedConstant("pixelSizeScene", pixelSizeScene,
sizeof(pixelSizeScene)/sizeof(pixelSizeScene[0]), 1.0f);
- fragParams->setNamedConstant("pixelSizeBlur", pixelSizeBlur,
sizeof(pixelSizeBlur)/sizeof(pixelSizeBlur[0]), 1.0f);
- fragParams->setNamedConstant("dofParams", dofParams,
sizeof(dofParams)/sizeof(dofParams[0]), 1.0f);
- fragParams->setNamedConstant("pixelSize",
pixelSize,sizeof(pixelSize)/sizeof(pixelSize[0]), 1.0f);
- */
-
// Add 'this' as a RenderableListener to replace the technique for all
renderables
RenderQueue* queue =
evt.source->getCamera()->getSceneManager()->getRenderQueue();
queue->setRenderableListener(this);
@@ -189,10 +201,227 @@
queue->setRenderableListener(0);
}
-bool DepthOfFieldEffect::renderableQueued(Renderable* rend, uint8 groupID,
- ushort priority, Technique** ppTech,
RenderQueue* pQueue)
+bool DepthOfFieldEffect::renderableQueued(Ogre::Renderable* rend, Ogre::uint8
groupID,
+ Ogre::ushort priority, Ogre::Technique**
ppTech, Ogre::RenderQueue* pQueue)
{
// Replace the technique of all renderables
*ppTech = mDepthTechnique;
return true;
}
+
+/////////////////////////////////////////////////////////////////////////////////////
+DOFManager::DOFManager(Ogre::SceneManager *m, Ogre::Viewport *mViewport,
Ogre::Root *root, Ogre::Camera *cam) : mRoot(root), mCamera(cam), mSceneMgr(m)
+{
+ mFocusMode = Manual;
+ mAutoSpeed = 30;
+ mAutoTime = 0.5f;
+ targetFocalDistance = 5;
+
+ mDepthOfFieldEffect = new DepthOfFieldEffect(mViewport, mCamera);
+ mLens = new Lens(mCamera->getFOVy(), 1);
+ mLens->setFocalDistance(5);
+ //mLens->setFStop(10);
+// mDepthOfFieldEffect->setEnabled(false);
+ mRoot->addFrameListener(this);
+
+ mRaySceneQuery = mSceneMgr->createRayQuery(Ogre::Ray());
+ mRaySceneQuery->setSortByDistance(true);
+ //mRaySceneQuery->setQueryMask(queryMask);
+
+ debugNode = 0;
+ bool debug = true;
+ if(debug)
+ {
+ MaterialPtr material =
MaterialManager::getSingleton().getByName("DoF_DepthDebug");
+
material->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName("DoF_Depth");
+ Overlay* overlay =
OverlayManager::getSingleton().getByName("DoF_DepthDebugOverlay");
+ overlay->show();
+
+ debugNode =
mSceneMgr->getRootSceneNode()->createChildSceneNode();
+ Entity *ent = mSceneMgr->createEntity("sphere.mesh");
+ debugNode->attachObject(ent);
+ debugNode->setScale(0.001, 0.001, 0.001);
+ }
+}
+
+DOFManager::~DOFManager()
+{
+ cleanup();
+}
+
+void DOFManager::cleanup()
+{
+ mRoot->removeFrameListener(this);
+
+ delete mLens;
+ mLens = NULL;
+
+ delete mDepthOfFieldEffect;
+ mDepthOfFieldEffect = NULL;
+}
+
+void DOFManager::setAutoSpeed(float f)
+{
+ mAutoSpeed = f;
+}
+
+void DOFManager::setEnabled(bool enabled)
+{
+ mDepthOfFieldEffect->setEnabled(enabled);
+ /*
+ // crashes for some reason
+ if(enabled && !mDepthOfFieldEffect->getEnabled())
+ {
+ // turn on
+ mDepthOfFieldEffect->setEnabled(true);
+ mRoot->addFrameListener(this);
+ } else if(!enabled && mDepthOfFieldEffect->getEnabled())
+ {
+ // turn off
+ mDepthOfFieldEffect->setEnabled(false);
+ mRoot->removeFrameListener(this);
+ }
+ */
+}
+
+bool DOFManager::getEnabled()
+{
+ return mDepthOfFieldEffect->getEnabled();
+}
+
+void DOFManager::zoomView(float delta)
+{
+ Real fieldOfView = mLens->getFieldOfView().valueRadians();
+ fieldOfView += delta;
+ fieldOfView = std::max<Real>(0.1, std::min<Real>(fieldOfView, 2.0));
+ mLens->setFieldOfView(Radian(fieldOfView));
+ mCamera->setFOVy(Radian(fieldOfView));
+}
+
+void DOFManager::Aperture(float delta)
+{
+ if (mFocusMode == Pinhole)
+ return;
+ Real fStop = mLens->getFStop();
+ fStop += delta;
+ fStop = std::max<Real>(0.5, std::min<Real>(fStop, 12.0));
+ mLens->setFStop(fStop);
+}
+
+void DOFManager::moveFocus(float delta)
+{
+ mLens->setFocalDistance(mLens->getFocalDistance() + delta);
+}
+
+void DOFManager::setZoom(float f)
+{
+ Real fieldOfView = Degree(Real(f)).valueRadians();
+ fieldOfView = std::max<Real>(0.1, std::min<Real>(fieldOfView, 2.0));
+ mLens->setFieldOfView(Radian(fieldOfView));
+ mCamera->setFOVy(Radian(fieldOfView));
+}
+
+void DOFManager::setLensFOV(Radian fov)
+{
+ mLens->setFieldOfView(fov);
+}
+
+void DOFManager::setAperture(float f)
+{
+ if (mFocusMode == Pinhole)
+ return;
+ Real fStop = f;
+ fStop = std::max<Real>(0.5, std::min<Real>(fStop, 12.0));
+ mLens->setFStop(fStop);
+}
+
+void DOFManager::setFocus(float f)
+{
+ mLens->setFocalDistance(f);
+}
+
+bool DOFManager::frameStarted(const FrameEvent& evt)
+{
+ Camera *camera = mCamera;
+ // Focusing
+ switch (mFocusMode)
+ {
+ case Auto:
+ {
+ // TODO: Replace with accurate ray/triangle collision
detection
+ Real currentFocalDistance = mLens->getFocalDistance();
+
+ // TODO: Continous AF / triggered
+ mAutoTime -= evt.timeSinceLastFrame;
+ if(mAutoTime <= 0.0f)
+ {
+ mAutoTime = 0.5f;
+
+ targetFocalDistance = currentFocalDistance;
+
+ // Ryan Booker's (eyevee99) ray scene query
auto focus
+ Ray focusRay;
+
focusRay.setOrigin(camera->getDerivedPosition());
+
focusRay.setDirection(camera->getDerivedDirection());
+ Vector3 v;
+ Vector3 vn;
+
+ mRaySceneQuery->setRay(focusRay);
+ Ogre::RaySceneQueryResult &qryResult =
mRaySceneQuery->execute();
+ for (Ogre::RaySceneQueryResult::iterator it =
qryResult.begin();it != qryResult.end(); it++)
+ {
+ if(it->worldFragment)
+ {
+ if(debugNode)
debugNode->setPosition(it->worldFragment->singleIntersection +
Vector3(0.5,0,0));
+ targetFocalDistance =
(mCamera->getPosition() - it->worldFragment->singleIntersection).length();
+ break;
+ } else
+ {
+ /*
+ // this wont work since we
would need to go down to the polygon level :(
+ if(debugNode)
debugNode->setPosition(focusRay.getPoint(it->distance));
+ targetFocalDistance =
it->distance;
+ break;
+ */
+ }
+
+ }
+ }
+
+ // Slowly adjust the focal distance (emulate auto focus
motor)
+ if (currentFocalDistance < targetFocalDistance)
+ {
+ mLens->setFocalDistance(
+ std::min<Real>(currentFocalDistance +
mAutoSpeed * evt.timeSinceLastFrame, targetFocalDistance));
+ }
+ else if (currentFocalDistance > targetFocalDistance)
+ {
+ mLens->setFocalDistance(
+ std::max<Real>(currentFocalDistance -
mAutoSpeed * evt.timeSinceLastFrame, targetFocalDistance));
+ }
+
+ break;
+ }
+
+ case Manual:
+ //we set the values elsewhere
+ break;
+ }
+
+ // Update Depth of Field effect
+ if (mFocusMode != Pinhole)
+ {
+ mDepthOfFieldEffect->setEnabled(true);
+
+ // Calculate and set depth of field using lens
+ float nearDepth, focalDepth, farDepth;
+ mLens->recalculateDepthOfField(nearDepth, focalDepth, farDepth);
+ mDepthOfFieldEffect->setFocalDepths(nearDepth, focalDepth,
farDepth);
+ }
+ else
+ {
+ mDepthOfFieldEffect->setEnabled(false);
+ }
+
+ return true;
+}
Modified: trunk/source/main/dof/DepthOfFieldEffect.h
===================================================================
--- trunk/source/main/dof/DepthOfFieldEffect.h 2011-02-02 17:10:50 UTC (rev
1635)
+++ trunk/source/main/dof/DepthOfFieldEffect.h 2011-02-02 20:07:58 UTC (rev
1636)
@@ -1,4 +1,4 @@
-// "Depth of Field" demo for Ogre
+// "Depth of Field" demo for Ogre
// Copyright (C) 2006 Christian Lindequist Larsen
//
// This code is in the public domain. You may do whatever you want with it.
@@ -6,16 +6,20 @@
#ifndef __DepthOfFieldEffect_H__
#define __DepthOfFieldEffect_H__
-#include "RoRPrerequisites.h"
-#include <Ogre.h>
-#include <OgreCompositorInstance.h>
+#include "OgrePrerequisites.h"
+#include "OgreCompositorInstance.h"
+#include "OgreRenderTargetListener.h"
+#include "OgreFrameListener.h"
+#include "OgreRenderQueue.h"
+class Lens;
+
class DepthOfFieldEffect : public Ogre::CompositorInstance::Listener,
public
Ogre::RenderTargetListener,
public
Ogre::RenderQueue::RenderableListener
{
public:
- DepthOfFieldEffect(Ogre::Viewport* viewport);
+ DepthOfFieldEffect(Ogre::Viewport *mViewport, Ogre::Camera *cam);
~DepthOfFieldEffect();
float getNearDepth() const {return mNearDepth; }
@@ -28,8 +32,21 @@
void setEnabled(bool value);
private:
+ // Implementation of Ogre::CompositorInstance::Listener
+ virtual void notifyMaterialSetup(Ogre::uint32 passId,
Ogre::MaterialPtr& material);
+
+ // Implementation of Ogre::RenderTargetListener
+ virtual void preViewportUpdate(const Ogre::RenderTargetViewportEvent&
evt);
+ virtual void postViewportUpdate(const Ogre::RenderTargetViewportEvent&
evt);
+
+ // Implementation of Ogre::RenderQueue::RenderableListener
+ virtual bool renderableQueued(Ogre::Renderable* rend, Ogre::uint8
groupID,
+ Ogre::ushort priority, Ogre::Technique**
ppTech, Ogre::RenderQueue* pQueue);
+
+ int mWidth;
+ int mHeight;
+
static const int BLUR_DIVISOR;
- static int DoF_ID;
enum PassId
{
@@ -37,10 +54,15 @@
OutputPass
};
- Ogre::Viewport* mViewport;
+ Ogre::Viewport* mDepthViewport;
+ Ogre::RenderTexture* mDepthTarget;
+ Ogre::TexturePtr mDepthTexture;
Ogre::MaterialPtr mDepthMaterial;
Ogre::Technique* mDepthTechnique;
Ogre::CompositorInstance* mCompositor;
+ Ogre::Viewport *mViewport;
+ Ogre::Camera *mCamera;
+
float mNearDepth;
float mFocalDepth;
float mFarDepth;
@@ -48,19 +70,50 @@
void createDepthRenderTexture();
void destroyDepthRenderTexture();
+// void createCompositor();
+// void destroyCompositor();
void addCompositor();
void removeCompositor();
+};
- // Implementation of Ogre::CompositorInstance::Listener
- virtual void notifyMaterialSetup(Ogre::uint32 passId,
Ogre::MaterialPtr& material);
+class DOFManager : public Ogre::FrameListener
+{
+public:
+ DOFManager(Ogre::SceneManager *m, Ogre::Viewport *v, Ogre::Root *r,
Ogre::Camera *cam);
+ ~DOFManager();
- // Implementation of Ogre::RenderTargetListener
- virtual void preViewportUpdate(const Ogre::RenderTargetViewportEvent&
evt);
- virtual void postViewportUpdate(const Ogre::RenderTargetViewportEvent&
evt);
- // Implementation of Ogre::RenderQueue::RenderableListener
- virtual bool renderableQueued(Ogre::Renderable* rend, Ogre::uint8
groupID,
- Ogre::ushort priority, Ogre::Technique**
ppTech, Ogre::RenderQueue* pQueue);
+ void setEnabled(bool enabled);
+ bool getEnabled();
+
+ // controls
+ enum FocusMode {Auto, Manual, Pinhole};
+ void setFocusMode(int mode) {mFocusMode = (FocusMode)mode;}
+ void setAutoSpeed(float f);
+ void zoomView(float delta);
+ void Aperture(float delta);
+ void moveFocus(float delta);
+ void setZoom(float f);
+ void setLensFOV(Ogre::Radian fov);
+ void setAperture(float f);
+ void setFocus(float f);
+
+protected:
+ virtual bool frameStarted(const Ogre::FrameEvent& evt);
+
+ Ogre::Root *mRoot;
+ Ogre::Camera *mCamera;
+ Ogre::RaySceneQuery *mRaySceneQuery;
+ Ogre::SceneManager *mSceneMgr;
+
+ void cleanup();
+ DepthOfFieldEffect* mDepthOfFieldEffect;
+ Lens* mLens;
+ FocusMode mFocusMode;
+ float mAutoSpeed;
+ float mAutoTime;
+ Ogre::Real targetFocalDistance;
+ Ogre::SceneNode *debugNode;
};
#endif // __DepthOfFieldEffect_H__
Modified: trunk/source/main/dof/Lens.cpp
===================================================================
--- trunk/source/main/dof/Lens.cpp 2011-02-02 17:10:50 UTC (rev 1635)
+++ trunk/source/main/dof/Lens.cpp 2011-02-02 20:07:58 UTC (rev 1636)
@@ -1,4 +1,4 @@
-// "Depth of Field" demo for Ogre
+// "Depth of Field" demo for Ogre
// Copyright (C) 2006 Christian Lindequist Larsen
//
// This code is in the public domain. You may do whatever you want with it.
@@ -6,6 +6,7 @@
// Author: Ryan Booker (eyevee99)
#include "Lens.h"
+#include "Ogre.h"
using namespace Ogre;
Modified: trunk/source/main/dof/Lens.h
===================================================================
--- trunk/source/main/dof/Lens.h 2011-02-02 17:10:50 UTC (rev 1635)
+++ trunk/source/main/dof/Lens.h 2011-02-02 20:07:58 UTC (rev 1636)
@@ -1,4 +1,4 @@
-// "Depth of Field" demo for Ogre
+// "Depth of Field" demo for Ogre
// Copyright (C) 2006 Christian Lindequist Larsen
//
// This code is in the public domain. You may do whatever you want with it.
@@ -8,8 +8,8 @@
#ifndef __Lens_H__
#define __Lens_H__
-#include "RoRPrerequisites.h"
-#include <Ogre.h>
+#include "OgrePrerequisites.h"
+#include "OgreMath.h"
class Lens {
public:
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
------------------------------------------------------------------------------
Special Offer-- Download ArcSight Logger for FREE (a $49 USD value)!
Finally, a world-class log management solution at an even better price-free!
Download using promo code Free_Logger_4_Dev2Dev. Offer expires
February 28th, so secure your free ArcSight Logger TODAY!
http://p.sf.net/sfu/arcsight-sfd2d
_______________________________________________
Rigsofrods-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/rigsofrods-devel
