Rely entirely on the configurable renderer and add more configuration options in...

diff --git a/src/Viewer/renderer.cxx b/src/Viewer/renderer.cxx
index 4884e157e7de3dc52340f3ff629bcc508dd562b5..ac156c820e0745cda755f31ec97621b078b226ac 100644 (file)
--- a/src/Viewer/renderer.cxx
+++ b/src/Viewer/renderer.cxx
@@ -528,8 +528,8 @@ FGRenderer::init( void )
     _useColorForDepth = fgGetBool( "/sim/rendering/rembrandt/use-color-for-depth", false );
     _depthInColor->set( _useColorForDepth );
 
-    _renderer         = fgGetString("/sim/rendering/rembrandt/renderer", "");
-    if (!_classicalRenderer && !_renderer.empty())
+    _renderer         = fgGetString("/sim/rendering/rembrandt/renderer", "default-pipeline");
+    if (!_classicalRenderer)
         _pipeline = makeRenderingPipeline(_renderer, 0);
     _scenery_loaded   = fgGetNode("/sim/sceneryloaded", true);
     _scenery_override = fgGetNode("/sim/sceneryloaded-override", true);
@@ -787,44 +787,12 @@ osg::Texture2D* buildDeferredBuffer(GLint internalFormat, GLenum sourceFormat, G
        return tex;
 }
 
-void buildDefaultDeferredBuffers( CameraInfo* info, int shadowMapSize, bool useColorForDepth )
-{
-    if (useColorForDepth) {
-        info->addBuffer("real-depth", buildDeferredBuffer( GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT, GL_FLOAT, osg::Texture::CLAMP_TO_BORDER) );
-        info->addBuffer("depth", buildDeferredBuffer( GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, osg::Texture::CLAMP_TO_BORDER) );
-    }
-    else {
-        info->addBuffer("depth", buildDeferredBuffer( GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT, GL_FLOAT, osg::Texture::CLAMP_TO_BORDER) );
-    }
-    info->addBuffer("normal", buildDeferredBuffer( GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, osg::Texture::CLAMP_TO_BORDER) );
-    info->addBuffer("diffuse", buildDeferredBuffer( GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, osg::Texture::CLAMP_TO_BORDER) );
-    info->addBuffer("spec-emis", buildDeferredBuffer( GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, osg::Texture::CLAMP_TO_BORDER) );
-    info->addBuffer("lighting", buildDeferredBuffer( GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, osg::Texture::CLAMP_TO_BORDER) );
-    info->addBuffer("shadow", buildDeferredBuffer( GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT, GL_FLOAT, osg::Texture::CLAMP_TO_BORDER, true), 0.0f );
-    info->getBuffer("shadow")->setTextureSize(shadowMapSize,shadowMapSize);
-}
-
 void attachBufferToCamera( CameraInfo* info, osg::Camera* camera, osg::Camera::BufferComponent c, const std::string& ck, const std::string& bk )
 {
     camera->attach( c, info->getBuffer(bk) );
     info->getRenderStageInfo(ck).buffers.insert( std::make_pair( c, bk ) );
 }
 
-osg::Camera* FGRenderer::buildDefaultDeferredGeometryCamera( CameraInfo* info, osg::GraphicsContext* gc )
-{
-    std::vector<ref_ptr<FGRenderingPipeline::Attachment> > attachments;
-    if (_useColorForDepth) {
-        attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::DEPTH_BUFFER, "real-depth") );
-        attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::COLOR_BUFFER3, "depth") );
-    } else {
-        attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::DEPTH_BUFFER, "depth") );
-    }
-    attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::COLOR_BUFFER0, "normal") );
-    attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::COLOR_BUFFER1, "diffuse") );
-    attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::COLOR_BUFFER2, "spec-emis") );
-    return buildDeferredGeometryCamera(info, gc, GEOMETRY_CAMERA, attachments);
-}
-
 void buildAttachments(CameraInfo* info, osg::Camera* camera, const std::string& name, const std::vector<ref_ptr<FGRenderingPipeline::Attachment> > &attachments) {
     BOOST_FOREACH(ref_ptr<FGRenderingPipeline::Attachment> attachment, attachments) {
         if (attachment->valid())
@@ -897,13 +865,6 @@ static osg::Camera* createShadowCascadeCamera( int no, int cascadeSize ) {
     return cascadeCam;
 }
 
-osg::Camera* FGRenderer::buildDefaultDeferredShadowCamera( CameraInfo* info, osg::GraphicsContext* gc )
-{
-    std::vector<ref_ptr<FGRenderingPipeline::Attachment> > attachments;
-    attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::DEPTH_BUFFER, "shadow") );
-    return buildDeferredShadowCamera(info, gc, SHADOW_CAMERA, attachments);
-}
-
 osg::Camera* FGRenderer::buildDeferredShadowCamera( CameraInfo* info, osg::GraphicsContext* gc, const std::string& name, const std::vector<ref_ptr<FGRenderingPipeline::Attachment> > &attachments )
 {
     osg::Camera* mainShadowCamera = new osg::Camera;
@@ -1111,18 +1072,6 @@ void FGRenderer::updateCascadeNumber(size_t num)
     _shadowNumber->set( (int)_numCascades );
 }
 
-osg::Camera* FGRenderer::buildDefaultDeferredLightingCamera( CameraInfo* info, osg::GraphicsContext* gc )
-{
-    std::vector<ref_ptr<FGRenderingPipeline::Attachment> > attachments;
-    if (_useColorForDepth) {
-        attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::DEPTH_BUFFER, "real-depth") );
-    } else {
-        attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::DEPTH_BUFFER, "depth") );
-    }
-    attachments.push_back(new FGRenderingPipeline::Attachment(osg::Camera::COLOR_BUFFER0, "lighting") );
-    return buildDeferredLightingCamera( info, gc, LIGHTING_CAMERA, attachments );
-}
-
 osg::Camera* FGRenderer::buildDeferredLightingCamera( CameraInfo* info, osg::GraphicsContext* gc, const std::string& name, const std::vector<ref_ptr<FGRenderingPipeline::Attachment> > &attachments )
 {
     osg::Camera* camera = new osg::Camera;
@@ -1263,36 +1212,63 @@ osg::Camera* FGRenderer::buildDeferredLightingCamera( CameraInfo* info, osg::Gra
     return camera;
 }
 
+osg::Camera*
+FGRenderer::buildDeferredLightingCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const FGRenderingPipeline::Stage* stage )
+{
+    osg::Camera* camera = new osg::Camera;
+    info->addCamera(stage->name, camera );
+
+    camera->setCullCallback( new FGDeferredRenderingCameraCullCallback( stage->name, info ) );
+    camera->setAllowEventFocus(false);
+    camera->setGraphicsContext(gc);
+    camera->setViewport(new Viewport);
+    camera->setName(stage->name+"C");
+    camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
+    camera->setRenderOrder(osg::Camera::NESTED_RENDER, stage->orderNum);
+    camera->setRenderTargetImplementation( osg::Camera::FRAME_BUFFER_OBJECT );
+    camera->setViewport( new osg::Viewport );
+    buildAttachments(info, camera, stage->name, stage->attachments);
+    camera->setDrawBuffer(GL_FRONT);
+    camera->setReadBuffer(GL_FRONT);
+    camera->setClearColor( osg::Vec4( 0., 0., 0., 1. ) );
+    camera->setClearMask( GL_COLOR_BUFFER_BIT );
+    osg::StateSet* ss = camera->getOrCreateStateSet();
+    ss->setAttribute( new osg::Depth(osg::Depth::LESS, 0.0, 1.0, false) );
+    ss->addUniform( _depthInColor );
+
+    osg::Group* lightingGroup = new osg::Group;
+
+    BOOST_FOREACH( osg::ref_ptr<FGRenderingPipeline::Pass> pass, stage->passes ) {
+        ref_ptr<Node> node = buildPass(info, pass);
+        if (node.valid())
+            lightingGroup->addChild(node);
+    }
+
+    camera->addChild( lightingGroup );
+
+    return camera;
+}
+
 CameraInfo*
 FGRenderer::buildDeferredPipeline(CameraGroup* cgroup, unsigned flags, osg::Camera* camera,
                                     const osg::Matrix& view,
                                     const osg::Matrix& projection,
                                     osg::GraphicsContext* gc)
 {
-    if (_renderer.empty() || !_pipeline.valid())
-        return buildDefaultDeferredPipeline(cgroup, flags, camera, view, projection, gc);
     return buildCameraFromRenderingPipeline(_pipeline, cgroup, flags, camera, view, projection, gc);
 }
 
 osg::Camera* 
-FGRenderer::buildDeferredFullscreenCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const FGRenderingPipeline::Stage* stage )
+FGRenderer::buildDeferredFullscreenCamera( flightgear::CameraInfo* info, const FGRenderingPipeline::Pass* pass )
 {
     osg::Camera* camera = new osg::Camera;
-    info->addCamera(stage->name, camera, stage->scaleFactor, true);
 
-    camera->setCullCallback( new FGDeferredRenderingCameraCullCallback(stage->name, info, stage->needsDuDv) );
+    camera->setClearMask( 0 );
     camera->setAllowEventFocus(false);
-    camera->setGraphicsContext(gc);
-    camera->setViewport(new Viewport);
-    camera->setName(stage->name+"C");
+    camera->setName(pass->name+"C");
     camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
-    camera->setRenderOrder(osg::Camera::NESTED_RENDER, stage->orderNum);
-    camera->setRenderTargetImplementation( osg::Camera::FRAME_BUFFER_OBJECT );
-    buildAttachments(info, camera, stage->name, stage->attachments);
-    camera->setDrawBuffer(GL_FRONT);
-    camera->setReadBuffer(GL_FRONT);
-    camera->setClearColor( osg::Vec4( 1., 1., 1., 1. ) );
-    camera->setClearMask( GL_COLOR_BUFFER_BIT );
+    camera->setRenderOrder(osg::Camera::NESTED_RENDER, pass->orderNum);
+    camera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
     camera->setViewMatrix(osg::Matrix::identity());
     camera->setProjectionMatrixAsOrtho2D(-1,1,-1,1);
 
@@ -1302,10 +1278,6 @@ FGRenderer::buildDeferredFullscreenCamera( flightgear::CameraInfo* info, osg::Gr
     ss->addUniform( info->viewInverse );
     ss->addUniform( info->view );
     ss->addUniform( info->bufferSize );
-    if (stage->needsDuDv) {
-        ss->addUniform( info->du );
-        ss->addUniform( info->dv );
-    }
     ss->addUniform( _ambientFactor );
     ss->addUniform( _sunDiffuse );
     ss->addUniform( _sunSpecular );
@@ -1313,16 +1285,19 @@ FGRenderer::buildDeferredFullscreenCamera( flightgear::CameraInfo* info, osg::Gr
     ss->addUniform( _planes );
     ss->addUniform( _shadowNumber );
     ss->addUniform( _shadowDistances );
+    ss->addUniform( _fogColor );
+    ss->addUniform( _fogDensity );
+    ss->addUniform( _planes );
 
     osg::Geometry* g = osg::createTexturedQuadGeometry( osg::Vec3(-1.,-1.,0.), osg::Vec3(2.,0.,0.), osg::Vec3(0.,2.,0.) );
     g->setUseDisplayList(false);
     simgear::EffectGeode* eg = new simgear::EffectGeode;
-    simgear::Effect* effect = simgear::makeEffect(stage->effect, true);
+    simgear::Effect* effect = simgear::makeEffect(pass->effect, true);
     if (effect) {
         eg->setEffect( effect );
     }
 
-    eg->setName(stage->name+"Quad");
+    eg->setName(pass->name+"Quad");
     eg->setCullingActive(false);
     eg->addDrawable(g);
     camera->addChild(eg);
@@ -1330,6 +1305,33 @@ FGRenderer::buildDeferredFullscreenCamera( flightgear::CameraInfo* info, osg::Gr
     return camera;
 }
 
+osg::Camera* 
+FGRenderer::buildDeferredFullscreenCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const FGRenderingPipeline::Stage* stage )
+{
+    osg::Camera* camera = buildDeferredFullscreenCamera(info, static_cast<const FGRenderingPipeline::Pass*>(stage));
+    info->addCamera(stage->name, camera, stage->scaleFactor, true);
+
+    camera->setCullCallback( new FGDeferredRenderingCameraCullCallback(stage->name, info, stage->needsDuDv) );
+    camera->setGraphicsContext(gc);
+    camera->setViewport(new Viewport);
+    camera->setRenderTargetImplementation( osg::Camera::FRAME_BUFFER_OBJECT );
+    buildAttachments(info, camera, stage->name, stage->attachments);
+    camera->setDrawBuffer(GL_FRONT);
+    camera->setReadBuffer(GL_FRONT);
+    camera->setClearColor( osg::Vec4( 1., 1., 1., 1. ) );
+    camera->setClearMask( GL_COLOR_BUFFER_BIT );
+    camera->setViewMatrix(osg::Matrix::identity());
+    camera->setProjectionMatrixAsOrtho2D(-1,1,-1,1);
+
+    osg::StateSet* ss = camera->getOrCreateStateSet();
+    if (stage->needsDuDv) {
+        ss->addUniform( info->du );
+        ss->addUniform( info->dv );
+    }
+
+    return camera;
+}
+
 void
 FGRenderer::buildDeferredDisplayCamera( osg::Camera* camera, flightgear::CameraInfo* info, const std::string& name, osg::GraphicsContext* gc )
 {
@@ -1356,51 +1358,12 @@ FGRenderer::buildDeferredDisplayCamera( osg::Camera* camera, flightgear::CameraI
     ss->addUniform( _depthInColor );
 }
 
-CameraInfo*
-FGRenderer::buildDefaultDeferredPipeline(CameraGroup* cgroup, unsigned flags, osg::Camera* camera,
-                                    const osg::Matrix& view,
-                                    const osg::Matrix& projection,
-                                    osg::GraphicsContext* gc)
-{
-    CameraInfo* info = new CameraInfo(flags);
-    buildDefaultDeferredBuffers(info, _shadowMapSize, _useColorForDepth);
-
-    osg::Camera* geometryCamera = buildDefaultDeferredGeometryCamera( info, gc );
-    cgroup->getViewer()->addSlave(geometryCamera, false);
-    installCullVisitor(geometryCamera);
-    int slaveIndex = cgroup->getViewer()->getNumSlaves() - 1;
-    info->getRenderStageInfo(GEOMETRY_CAMERA).slaveIndex = slaveIndex;
-    
-    Camera* shadowCamera = buildDefaultDeferredShadowCamera( info, gc );
-    cgroup->getViewer()->addSlave(shadowCamera, false);
-    installCullVisitor(shadowCamera);
-    slaveIndex = cgroup->getViewer()->getNumSlaves() - 1;
-    info->getRenderStageInfo(SHADOW_CAMERA).slaveIndex = slaveIndex;
-
-    osg::Camera* lightingCamera = buildDefaultDeferredLightingCamera( info, gc );
-    cgroup->getViewer()->addSlave(lightingCamera, false);
-    installCullVisitor(lightingCamera);
-    slaveIndex = cgroup->getViewer()->getNumSlaves() - 1;
-    info->getRenderStageInfo(LIGHTING_CAMERA).slaveIndex = slaveIndex;
-
-    buildDeferredDisplayCamera( camera, info, DISPLAY_CAMERA, gc );
-
-    cgroup->getViewer()->addSlave(camera, false);
-    installCullVisitor(camera);
-    slaveIndex = cgroup->getViewer()->getNumSlaves() - 1;
-    info->addCamera( DISPLAY_CAMERA, camera, slaveIndex, true );
-    camera->setRenderOrder(Camera::POST_RENDER, 99); //FIXME
-    cgroup->addCamera(info);
-    return info;
-}
-
-void FGRenderer::buildStage(FGRenderingPipeline* rpipe, CameraInfo* info,
-                                        FGRenderingPipeline::Stage* stage,
-                                        CameraGroup* cgroup,
-                                        osg::Camera* mainCamera,
-                                        const osg::Matrix& view,
-                                        const osg::Matrix& projection,
-                                        osg::GraphicsContext* gc)
+void
+FGRenderer::buildStage(CameraInfo* info,
+                        FGRenderingPipeline::Stage* stage,
+                        CameraGroup* cgroup,
+                        osg::Camera* mainCamera,
+                        osg::GraphicsContext* gc)
 {
     if (!stage->valid())
         return;
@@ -1408,8 +1371,10 @@ void FGRenderer::buildStage(FGRenderingPipeline* rpipe, CameraInfo* info,
     ref_ptr<Camera> camera;
     if (stage->type == "geometry")
         camera = buildDeferredGeometryCamera(info, gc, stage->name, stage->attachments);
-    else if (stage->type == "lighting")
+    else if (stage->type == "lighting-builtin")
         camera = buildDeferredLightingCamera(info, gc, stage->name, stage->attachments);
+    else if (stage->type == "lighting")
+        camera = buildDeferredLightingCamera(info, gc, stage);
     else if (stage->type == "shadow")
         camera = buildDeferredShadowCamera(info, gc, stage->name, stage->attachments);
     else if (stage->type == "fullscreen")
@@ -1428,7 +1393,58 @@ void FGRenderer::buildStage(FGRenderingPipeline* rpipe, CameraInfo* info,
     info->getRenderStageInfo(stage->name).slaveIndex = slaveIndex;
 }
 
-void FGRenderer::buildBuffers(FGRenderingPipeline* rpipe, CameraInfo* info)
+osg::Node*
+FGRenderer::buildLightingSkyCloudsPass(FGRenderingPipeline::Pass* pass)
+{
+    Group* group = new Group;
+    group->addChild( _sky->getPreRoot() );
+    group->addChild( _sky->getCloudRoot() );
+    return group;
+}
+
+osg::Node*
+FGRenderer::buildLightingLightsPass(CameraInfo* info, FGRenderingPipeline::Pass* pass)
+{
+    osg::Camera* lightCam = new osg::Camera;
+    StateSet* ss = lightCam->getOrCreateStateSet();
+    ss->addUniform( _planes );
+    ss->addUniform( info->bufferSize );
+    lightCam->setName( "LightCamera" );
+    lightCam->setClearMask(0);
+    lightCam->setAllowEventFocus(false);
+    lightCam->setReferenceFrame(osg::Transform::RELATIVE_RF);
+    lightCam->setRenderOrder(osg::Camera::NESTED_RENDER,pass->orderNum);
+    lightCam->setViewMatrix(osg::Matrix::identity());
+    lightCam->setProjectionMatrix(osg::Matrix::identity());
+    lightCam->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
+    lightCam->setCullMask( simgear::MODELLIGHT_BIT );
+    lightCam->setInheritanceMask( osg::CullSettings::ALL_VARIABLES & ~osg::CullSettings::CULL_MASK );
+    lightCam->addChild( mDeferredRealRoot.get() );
+
+    return lightCam;
+}
+
+osg::Node*
+FGRenderer::buildPass(CameraInfo* info, FGRenderingPipeline::Pass* pass)
+{
+    if (!pass->valid())
+        return 0;
+
+    ref_ptr<Node> node;
+    if (pass->type == "sky-clouds")
+        node = buildLightingSkyCloudsPass(pass);
+    else if (pass->type == "fullscreen")
+        node = buildDeferredFullscreenCamera(info, pass);
+    else if (pass->type == "lights")
+        node = buildLightingLightsPass(info, pass);
+    else
+        throw sg_exception("Pass type is not supported");
+
+    return node.release();
+}
+
+void
+FGRenderer::buildBuffers(FGRenderingPipeline* rpipe, CameraInfo* info)
 {
     for (size_t i = 0; i < rpipe->buffers.size(); ++i) {
         osg::ref_ptr<FGRenderingPipeline::Buffer> buffer = rpipe->buffers[i];
@@ -1455,7 +1471,7 @@ CameraInfo* FGRenderer::buildCameraFromRenderingPipeline(FGRenderingPipeline* rp
     
     for (size_t i = 0; i < rpipe->stages.size(); ++i) {
         osg::ref_ptr<FGRenderingPipeline::Stage> stage = rpipe->stages[i];
-        buildStage(rpipe, info, stage, cgroup, camera, view, projection, gc);
+        buildStage(info, stage, cgroup, camera, gc);
     }
 
     cgroup->addCamera(info);

diff --git a/src/Viewer/renderer.hxx b/src/Viewer/renderer.hxx
index 817a1b66b0fef8333b14eb39235d974a15a6ba57..e9770fb3525f493e7c75a6152d6811cb0300b60a 100644 (file)
--- a/src/Viewer/renderer.hxx
+++ b/src/Viewer/renderer.hxx
@@ -108,17 +108,6 @@ public:
        flightgear::CameraInfo* buildDeferredPipeline(flightgear::CameraGroup* cgroup, unsigned flags, osg::Camera* camera,
                                    const osg::Matrix& view, const osg::Matrix& projection, osg::GraphicsContext* gc);
 
-       /**
-        */
-       flightgear::CameraInfo* buildDefaultDeferredPipeline(flightgear::CameraGroup* cgroup, unsigned flags, osg::Camera* camera,
-                                   const osg::Matrix& view, const osg::Matrix& projection, osg::GraphicsContext* gc);
-
-    osg::Camera* buildDeferredGeometryCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const std::string& name, const FGRenderingPipeline::AttachmentList& attachments );
-    osg::Camera* buildDeferredShadowCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const std::string& name, const FGRenderingPipeline::AttachmentList& attachments );
-    osg::Camera* buildDeferredLightingCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const std::string& name, const FGRenderingPipeline::AttachmentList& attachments );
-    osg::Camera* buildDeferredFullscreenCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const FGRenderingPipeline::Stage* stage );
-    void buildDeferredDisplayCamera( osg::Camera* camera, flightgear::CameraInfo* info, const std::string& name, osg::GraphicsContext* gc );
-
     void updateShadowCamera(const flightgear::CameraInfo* info, const osg::Vec3d& position);
     void updateShadowMapSize(int mapSize);
     void enableShadows(bool enabled);
@@ -153,15 +142,22 @@ protected:
     float _cascadeFar[4];
     bool _useColorForDepth;
 
-    osg::Camera* buildDefaultDeferredGeometryCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc );
-    osg::Camera* buildDefaultDeferredShadowCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc );
-    osg::Camera* buildDefaultDeferredLightingCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc );
-
     flightgear::CameraInfo* buildCameraFromRenderingPipeline(FGRenderingPipeline* rpipe, flightgear::CameraGroup* cgroup, unsigned flags, osg::Camera* camera,
                                         const osg::Matrix& view, const osg::Matrix& projection, osg::GraphicsContext* gc);
 
     void buildBuffers(FGRenderingPipeline* rpipe, flightgear::CameraInfo* info);
-    void buildStage(FGRenderingPipeline* rpipe, flightgear::CameraInfo* info, FGRenderingPipeline::Stage* stage, flightgear::CameraGroup* cgroup, osg::Camera* mainCamera, const osg::Matrix& view, const osg::Matrix& projection, osg::GraphicsContext* gc);
+    void buildStage(flightgear::CameraInfo* info, FGRenderingPipeline::Stage* stage, flightgear::CameraGroup* cgroup, osg::Camera* mainCamera, osg::GraphicsContext* gc);
+    osg::Node* buildPass(flightgear::CameraInfo* info, FGRenderingPipeline::Pass* pass);
+    osg::Node* buildLightingSkyCloudsPass(FGRenderingPipeline::Pass* pass);
+    osg::Node* buildLightingLightsPass(flightgear::CameraInfo* info, FGRenderingPipeline::Pass* pass);
+
+    osg::Camera* buildDeferredGeometryCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const std::string& name, const FGRenderingPipeline::AttachmentList& attachments );
+    osg::Camera* buildDeferredShadowCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const std::string& name, const FGRenderingPipeline::AttachmentList& attachments );
+    osg::Camera* buildDeferredLightingCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const std::string& name, const FGRenderingPipeline::AttachmentList& attachments );
+    osg::Camera* buildDeferredLightingCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const FGRenderingPipeline::Stage* stage );
+    osg::Camera* buildDeferredFullscreenCamera( flightgear::CameraInfo* info, osg::GraphicsContext* gc, const FGRenderingPipeline::Stage* stage );
+    osg::Camera* buildDeferredFullscreenCamera( flightgear::CameraInfo* info, const FGRenderingPipeline::Pass* pass );
+    void buildDeferredDisplayCamera( osg::Camera* camera, flightgear::CameraInfo* info, const std::string& name, osg::GraphicsContext* gc );
 
     void updateShadowCascade(const flightgear::CameraInfo* info, osg::Camera* camera, osg::Group* grp, int idx, double left, double right, double bottom, double top, double zNear, double f1, double f2);
     osg::Vec3 getSunDirection() const;

diff --git a/src/Viewer/renderingpipeline.cxx b/src/Viewer/renderingpipeline.cxx
index 1dc3043d6c49da4c28ee824e9d8f9674dc150597..da9cd09a377ca2c026048241cd26ef73c29f96b8 100644 (file)
--- a/src/Viewer/renderingpipeline.cxx
+++ b/src/Viewer/renderingpipeline.cxx
@@ -92,6 +92,7 @@ FGRenderingPipeline::Conditionable::parseCondition(SGPropertyNode* prop)
     if (!predProp) {
         setAlwaysValid(true);
     } else {
+        setAlwaysValid(false);
         try {
             flightgear::PipelinePredParser parser;
             SGExpressionb* validExp = dynamic_cast<SGExpressionb*>(parser.read(predProp->getChild(0)));
@@ -257,11 +258,11 @@ simgear::effect::EffectNameValue<osg::Camera::BufferComponent> componentsInit[]
 };
 simgear::effect::EffectPropertyMap<osg::Camera::BufferComponent> components(componentsInit);
 
-FGRenderingPipeline::Stage::Stage(SGPropertyNode* prop)
+FGRenderingPipeline::Pass::Pass(SGPropertyNode* prop)
 {
     SGPropertyNode_ptr nameProp = prop->getChild("name");
     if (!nameProp.valid()) {
-        throw sg_exception("Stage name is mandatory");
+        throw sg_exception("Pass name is mandatory");
     }
     name = nameProp->getStringValue();
     SGPropertyNode_ptr typeProp = prop->getChild("type");
@@ -273,6 +274,12 @@ FGRenderingPipeline::Stage::Stage(SGPropertyNode* prop)
 
     orderNum = prop->getIntValue("order-num", -1);
     effect = prop->getStringValue("effect", "");
+
+    parseCondition(prop);
+}
+
+FGRenderingPipeline::Stage::Stage(SGPropertyNode* prop) : Pass(prop)
+{
     needsDuDv = prop->getBoolValue("needs-du-dv", false);
     scaleFactor = prop->getFloatValue("scale-factor", 1.f);
 
@@ -281,7 +288,10 @@ FGRenderingPipeline::Stage::Stage(SGPropertyNode* prop)
         this->attachments.push_back(new FGRenderingPipeline::Attachment(attachments[i]));
     }
 
-    parseCondition(prop);
+    std::vector<SGPropertyNode_ptr> passes = prop->getChildren("pass");
+    for (int i = 0; i < (int)passes.size(); ++i) {
+        this->passes.push_back(new FGRenderingPipeline::Pass(passes[i]));
+    }
 }
 
 FGRenderingPipeline::Attachment::Attachment(SGPropertyNode* prop)

diff --git a/src/Viewer/renderingpipeline.hxx b/src/Viewer/renderingpipeline.hxx
index e05037e38ef4b81c8397aaaf32c0e39f5f15aa7a..9f165bd15b303ebdc9a9899f625bcf5bfc1c9f83 100644 (file)
--- a/src/Viewer/renderingpipeline.hxx
+++ b/src/Viewer/renderingpipeline.hxx
@@ -28,7 +28,7 @@ class FGRenderingPipeline : public osg::Referenced {
 public:
     class Conditionable : public osg::Referenced {
     public:
-        Conditionable() : _alwaysValid(false) {}
+        Conditionable() : _alwaysValid(true) {}
         void parseCondition(SGPropertyNode* prop);
         bool getAlwaysValid() const { return _alwaysValid; }
         void setAlwaysValid(bool val) { _alwaysValid = val; }
@@ -59,6 +59,8 @@ public:
 
         std::string name;
         std::string type;
+        int orderNum;
+        std::string effect;
     };
 
     struct Attachment : public Conditionable {
@@ -70,13 +72,9 @@ public:
     };
     typedef std::vector<osg::ref_ptr<Attachment> > AttachmentList;
 
-    struct Stage : public Conditionable {
+    struct Stage : public Pass {
         Stage(SGPropertyNode* prop);
 
-        std::string name;
-        std::string type;
-        int orderNum;
-        std::string effect;
         bool needsDuDv;
         float scaleFactor;