Added a concrete osg::DeleteHandler implementation which provides support for

retain objects for several frames before deleting them.  Also added RenderStageCache
into CullVistor.cpp that is used for handling RTT osg::Camera's that are being
used in double buffered SceneView usage.

src/osg/DeleteHandler.cpp

@@ -0,0 +1,126 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
+ *
+ * This library is open source and may be redistributed and/or modified under  
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * OpenSceneGraph Public License for more details.
+*/
+#include <osg/DeleteHandler>
+#include <osg/Notify>
+
+namespace osg
+{
+
+// specialzed smart pointer, used to get round auto_ptr<>'s lack of the destructor reseting itself to 0.
+struct DeleteHandlerPointer
+{
+    DeleteHandlerPointer():
+        _ptr(0) {}
+
+    DeleteHandlerPointer(DeleteHandler* ptr):
+        _ptr(ptr) {}
+
+    ~DeleteHandlerPointer()
+    {
+        delete _ptr;
+        _ptr = 0;
+    }
+
+    inline DeleteHandlerPointer& operator = (DeleteHandler* ptr)
+    {
+        if (_ptr==ptr) return *this;
+        delete _ptr;
+        _ptr = ptr;
+        return *this;
+    }
+
+    void reset(DeleteHandler* ptr)
+    {
+        if (_ptr==ptr) return;
+        delete _ptr;
+        _ptr = ptr;
+    }
+
+    inline DeleteHandler& operator*()  { return *_ptr; }
+
+    inline const DeleteHandler& operator*() const { return *_ptr; }
+
+    inline DeleteHandler* operator->() { return _ptr; }
+
+    inline const DeleteHandler* operator->() const   { return _ptr; }
+
+    DeleteHandler* get() { return _ptr; }
+
+    const DeleteHandler* get() const { return _ptr; }
+
+    DeleteHandler* _ptr;
+};
+
+
+DeleteHandler::DeleteHandler(int numberOfFramesToRetainObjects):
+    _numFramesToRetainObjects(numberOfFramesToRetainObjects)
+{
+}
+
+void DeleteHandler::flush()
+{
+    typedef std::list<const osg::Referenced*> DeletionList;
+    DeletionList deletionList;
+
+    {
+        // gather all the objects to delete whilst holding the mutex to the _objectsToDelete
+        // list, but delete the objects outside this scoped lock so that if any objects deleted
+        // unref their children then no deadlock happens.
+        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
+        int frameNumberToClearTo = _currentFrameNumber - _numFramesToRetainObjects;
+
+        ObjectsToDeleteList::iterator itr;
+        for(itr = _objectsToDelete.begin();
+            itr != _objectsToDelete.end();
+            ++itr)
+        {
+            if (itr->first > frameNumberToClearTo) break;
+
+            deletionList.push_back(itr->second);
+
+            itr->second = 0;            
+        }
+
+        _objectsToDelete.erase( _objectsToDelete.begin(), itr);
+    }
+
+    for(DeletionList::iterator ditr = deletionList.begin();
+        ditr != deletionList.end();
+        ++ditr)
+    {
+        doDelete(*ditr);
+    }
+
+}
+
+void DeleteHandler::flushAll()
+{
+    int temp = _numFramesToRetainObjects;
+    _numFramesToRetainObjects = 0;
+
+    flush();
+
+    _numFramesToRetainObjects = temp;
+}
+
+void DeleteHandler::requestDelete(const osg::Referenced* object)
+{
+    if (_numFramesToRetainObjects==0) doDelete(object);
+    else
+    {
+        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
+        _objectsToDelete.push_back(FrameNumberObjectPair(_currentFrameNumber,object));
+    }
+}
+
+}; // end of namespace osg

src/osg/GNUmakefile

@@ -33,6 +33,7 @@ CXXFILES =\
 	CullingSet.cpp\
 	CullSettings.cpp\
 	CullStack.cpp\
+	DeleteHandler.cpp\
 	Depth.cpp\
 	DisplaySettings.cpp\
 	Drawable.cpp\

src/osg/Referenced.cpp

@@ -22,6 +22,8 @@
 #include <OpenThreads/ScopedLock>
 #include <OpenThreads/Mutex>
 
+#include <osg/DeleteHandler>
+
 #ifndef OSG_JAVA_BUILD       
 
 namespace osg
@@ -177,43 +179,7 @@ void Referenced::setThreadSafeRefUnref(bool threadSafe)
     }
 }
 
-/*
-void Referenced::ref() const
-{ 
-    if (_refMutex)
-    {
-        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(*_refMutex); 
-        ++_refCount;
-    }
-    else
-    {
-        ++_refCount;
-    }
 
-}
-
-void Referenced::unref() const
-{
-    bool needDelete = false;
-    if (_refMutex)
-    {
-        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(*_refMutex); 
-        --_refCount;
-        needDelete = _refCount<=0;
-    }
-    else
-    {
-        --_refCount;
-        needDelete = _refCount<=0;
-    }
-    
-    if (needDelete)
-    {
-        if (getDeleteHandler()) getDeleteHandler()->requestDelete(this);
-        else delete this;
-    }
-}
-*/
 void Referenced::unref_nodelete() const
 {
     if (_refMutex)
@@ -257,6 +223,11 @@ void Referenced::removeObserver(Observer* observer)
     }
 }
 
+void Referenced::deletUsingDeleteHandler() const
+{
+    getDeleteHandler()->requestDelete(this);
+}
+
 }; // end of namespace osg
 
 #endif //OSG_JAVA_BUILD        

src/osgProducer/Viewer.cpp

@@ -1,6 +1,7 @@
 #include <osg/LightSource>
 #include <osg/ApplicationUsage>
 #include <osg/AlphaFunc>
+#include <osg/DeleteHandler>
 #include <osg/io_utils>
 
 #include <osgUtil/UpdateVisitor>
@@ -260,6 +261,12 @@ Viewer::Viewer(osg::ArgumentParser& arguments):
 
 Viewer::~Viewer()
 {
+    setSceneData(0);
+    
+    if (osg::Referenced::getDeleteHandler()) 
+    {
+        osg::Referenced::getDeleteHandler()->flushAll();
+    }
 }
 
 osg::NodePath Viewer::getCoordinateSystemNodePath() const

src/osgUtil/CullVisitor.cpp

@@ -1068,6 +1068,38 @@ void CullVisitor::apply(osg::ClearNode& node)
 
 }
 
+namespace osgUtil
+{
+
+class RenderStageCache : public osg::Object
+{
+    public:
+    
+        RenderStageCache() {}
+        RenderStageCache(const RenderStageCache&, const osg::CopyOp&) {}
+        
+        META_Object(osgUtil, RenderStageCache);
+        
+        void setRenderStage(CullVisitor* cv, RenderStage* rs)
+        {
+            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
+            _renderStageMap[cv] = rs;
+        }        
+
+        RenderStage* getRenderStage(osgUtil::CullVisitor* cv)
+        {
+            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
+            return _renderStageMap[cv].get();
+        }
+        
+        typedef std::map<CullVisitor*, osg::ref_ptr<RenderStage> > RenderStageMap;
+        
+        OpenThreads::Mutex  _mutex;
+        RenderStageMap      _renderStageMap;
+};
+
+}
+
 void CullVisitor::apply(osg::Camera& camera)
 {
     // push the node's state.
@@ -1136,12 +1168,21 @@ void CullVisitor::apply(osg::Camera& camera)
 
         // use render to texture stage.
         // create the render to texture stage.
-        osg::ref_ptr<osgUtil::RenderStage> rtts = dynamic_cast<osgUtil::RenderStage*>(camera.getRenderingCache(contextID));
+        osg::ref_ptr<osgUtil::RenderStageCache> rsCache = dynamic_cast<osgUtil::RenderStageCache*>(camera.getRenderingCache(contextID));
+        if (!rsCache)
+        {
+            rsCache = new osgUtil::RenderStageCache;
+            camera.setRenderingCache(contextID, rsCache.get());
+        }
+        
+        osg::ref_ptr<osgUtil::RenderStage> rtts = rsCache->getRenderStage(this);
         if (!rtts)
         {
             OpenThreads::ScopedLock<OpenThreads::Mutex> lock(*(camera.getDataChangeMutex()));
         
             rtts = new osgUtil::RenderStage;
+            rsCache->setRenderStage(this,rtts.get());
+
             rtts->setCamera(&camera);
 
             if (camera.getDrawBuffer() != GL_NONE)
@@ -1164,7 +1205,6 @@ void CullVisitor::apply(osg::Camera& camera)
                 rtts->setReadBuffer(previous_stage->getReadBuffer());
             }
 
-            camera.setRenderingCache(contextID, rtts.get());
         }
         else
         {

src/osgUtil/RenderBin.cpp

@@ -481,7 +481,7 @@ bool RenderBin::getStats(Statistics& stats) const
         ++dw_itr)
     {
         const RenderLeaf* rl = *dw_itr;
-        const Drawable* dw= rl->_drawable;
+        const Drawable* dw= rl->getDrawable();
         stats.addDrawable(); // number of geosets
         if (rl->_modelview.get())
         {
@@ -506,7 +506,7 @@ bool RenderBin::getStats(Statistics& stats) const
             ++dw_itr)
         {
             const RenderLeaf* rl = dw_itr->get();
-            const Drawable* dw= rl->_drawable;
+            const Drawable* dw= rl->getDrawable();
             stats.addDrawable(); // number of geosets
             if (rl->_modelview.get()) stats.addMatrix(); // number of matrices
             if (dw)

src/osgViewer/Viewer.cpp

@@ -12,6 +12,7 @@
 */
 
 #include <osg/GLExtensions>
+#include <osg/DeleteHandler>
 #include <osgUtil/GLObjectsVisitor>
 #include <osgGA/TrackballManipulator>
 #include <osgViewer/Viewer>
@@ -20,6 +21,7 @@
 
 using namespace osgViewer;
 
+
 class ViewerQuerySupport
 {
 public:
@@ -544,6 +546,8 @@ Viewer::Viewer():
     _eventVisitor->setActionAdapter(this);
     
     setStats(new osg::Stats("Viewer"));
+    
+    osg::Referenced::setDeleteHandler(new osg::DeleteHandler(2));
 }
 
 Viewer::~Viewer()
@@ -569,6 +573,11 @@ Viewer::~Viewer()
         (*citr)->close();
     }
 
+    if (osg::Referenced::getDeleteHandler())
+    {
+        osg::Referenced::getDeleteHandler()->setNumFramesToRetainObjects(0);
+        osg::Referenced::getDeleteHandler()->flushAll();
+    }
     //osg::notify(osg::NOTICE)<<"finish Viewer::~Viewer()"<<std::endl;
     
 }
@@ -1350,6 +1359,13 @@ void Viewer::advance(double simulationTime)
         // update current frames stats
         getStats()->setAttribute(_frameStamp->getFrameNumber(), "Reference time", _frameStamp->getReferenceTime());
     }
+
+    if (osg::Referenced::getDeleteHandler())
+    {
+        osg::Referenced::getDeleteHandler()->flush();
+        osg::Referenced::getDeleteHandler()->setFrameNumber(_frameStamp->getFrameNumber());
+    }
+
 }
 
 void Viewer::eventTraversal()