Made a new osgproducer demo based on the new osgProducer::Viewer class.

Kept the old camera group version around for future reference.

src/Demos/osgproducer/Makefile

@@ -2,7 +2,8 @@ TOPDIR = ../../..
 include $(TOPDIR)/Make/makedefs 
 
 CXXFILES =\
-	osgproducer.cpp\
+	osgproducer_viewer.cpp\
+#	osgproducer_cameragroup.cpp\
 
 LIBS     += -losgProducer $(OSG_LIBS) $(GL_LIBS) $(X_LIBS) $(OTHER_LIBS) 
 

src/Demos/osgproducer/osgproducer_cameragroup.cpp

@@ -0,0 +1,220 @@
+//C++ source file - Open Producer - Copyright (C) 2002 Don Burns
+//Distributed under the terms of the GNU LIBRARY GENERAL PUBLIC LICENSE (LGPL)
+//as published by the Free Software Foundation.
+
+// Simple example of use of Producer::RenderSurface
+// The myGraphics class is a simple sample of how one would implement
+// graphics drawing with Producer::RenderSurface
+
+#include <stdio.h>
+
+#include <Producer/Camera>
+#include <Producer/CameraConfig>
+#include <Producer/InputArea>
+#include <Producer/KeyboardMouse>
+
+#include <osg/Timer>
+
+#include <osgUtil/Optimizer>
+#include <osgUtil/UpdateVisitor>
+
+#include <osgDB/ReadFile>
+
+#include <osgGA/TrackballManipulator>
+#include <osgGA/FlightManipulator>
+#include <osgGA/DriveManipulator>
+#include <osgGA/KeySwitchCameraManipulator>
+#include <osgGA/StateSetManipulator>
+
+#include <osgProducer/CameraGroup>
+#include <osgProducer/SceneHandler>
+#include <osgProducer/KeyboardMouseCallback>
+#include <osgProducer/ActionAdapter>
+
+#include <list>
+
+
+int main( int argc, char **argv )
+{
+
+    // threading model.
+    Producer::CameraGroup::ThreadingModel threadingModel = Producer::CameraGroup::SingleThreaded;
+    threadingModel = Producer::CameraGroup::ThreadPerCamera;
+
+    // configuration file.
+    std::string configFile;
+    //configFile = "twoWindows.cfg";
+
+    // set up the database files to read.
+    std::vector<std::string> filenameList;
+    if (argc>1) filenameList.push_back(argv[1]);
+    else filenameList.push_back("cow.osg");
+
+
+
+    // create the camera group.
+    osgProducer::CameraGroup *cg = configFile.empty() ?
+         (new osgProducer::CameraGroup()):
+         (new osgProducer::CameraGroup(configFile));
+
+    // set up the maximum number of graphics contexts, before loading the scene graph
+    // to ensure that texture objects and display buffers are configured to the correct size.
+    osg::DisplaySettings::instance()->setMaxNumberOfGraphicsContexts( cg->getNumberOfCameras() );
+
+
+    // read the scene.
+    osg::ref_ptr<osg::Node> loadedModel = osgDB::readNodeFiles(filenameList);
+    if (!loadedModel) return 1;
+
+    osgUtil::Optimizer optimizer;
+    optimizer.optimize(loadedModel.get());
+
+
+    // set up the keyboard and mouse handling.
+    Producer::InputArea *ia = cg->getCameraConfig()->getInputArea();
+    Producer::KeyboardMouse *kbm = ia ?
+                                   (new Producer::KeyboardMouse(ia)) : 
+                                   (new Producer::KeyboardMouse(cg->getCamera(0)->getRenderSurface()));
+
+    // set up the time and frame counter.
+    unsigned int frameNumber = 0;
+    osg::Timer timer;
+    osg::Timer_t start_tick = timer.tick();
+
+    // set the keyboard mouse callback to catch the events from the windows.
+    bool done = false;
+    osgProducer::KeyboardMouseCallback kbmcb(done);
+    kbmcb.setStartTick(start_tick);
+    
+    // register the callback with the keyboard mouse manger.
+    kbm->setCallback( &kbmcb );
+    //kbm->allowContinuousMouseMotionUpdate(true);
+    kbm->startThread();
+
+
+
+    // set the globa state
+    osg::ref_ptr<osg::StateSet> globalStateSet = new osg::StateSet;
+    globalStateSet->setGlobalDefaults();
+    cg->setGlobalStateSet(globalStateSet.get());
+    
+    
+    // add either a headlight or sun light to the scene.
+    osg::LightSource* lightsource = new osg::LightSource;
+    osg::Light* light = new osg::Light;
+    lightsource->setLight(light);
+    lightsource->setReferenceFrame(osg::LightSource::RELATIVE_TO_ABSOLUTE); // headlight.
+    lightsource->setLocalStateSetModes(osg::StateAttribute::ON);
+
+    lightsource->addChild(loadedModel.get());
+    
+    
+    // set the scene to render
+//    cg->setSceneData(scene.get());
+    cg->setSceneData(lightsource);
+
+    // set up the pthread stack size to large enough to run into problems.
+    cg->setStackSize( 20*1024*1024);
+
+    // create the windows and run the threads.
+    cg->realize(threadingModel);
+
+    osg::ref_ptr<osg::FrameStamp> frameStamp = cg->getFrameStamp();
+
+    osgUtil::UpdateVisitor update;
+    update.setFrameStamp(frameStamp.get());
+
+
+
+    // create a camera to use with the manipulators.
+    osg::ref_ptr<osg::Camera> old_style_osg_camera = new osg::Camera;
+
+    osg::ref_ptr<osgGA::KeySwitchCameraManipulator> keyswitchManipulator = new osgGA::KeySwitchCameraManipulator;
+    keyswitchManipulator->addNumberedCameraManipulator(new osgGA::TrackballManipulator);
+    keyswitchManipulator->addNumberedCameraManipulator(new osgGA::FlightManipulator);
+    keyswitchManipulator->addNumberedCameraManipulator(new osgGA::DriveManipulator);
+    
+    keyswitchManipulator->setCamera(old_style_osg_camera.get());
+    keyswitchManipulator->setNode(loadedModel.get());
+
+
+    osg::ref_ptr<osgGA::StateSetManipulator> statesetManipulator = new osgGA::StateSetManipulator;
+    statesetManipulator->setStateSet(globalStateSet.get());
+
+    // create an event handler list, we'll dispatch our event to these..
+    typedef std::list< osg::ref_ptr<osgGA::GUIEventHandler> > EventHandlerList;
+    EventHandlerList eventHandlerList;
+    eventHandlerList.push_back(keyswitchManipulator.get());
+    eventHandlerList.push_back(statesetManipulator.get());
+
+    // create a dummy action adapter right now.
+    osgProducer::ActionAdapter actionAdapter;
+
+    osg::ref_ptr<osgProducer::EventAdapter> init_event = new osgProducer::EventAdapter;
+    init_event->adaptFrame(0.0);
+    keyswitchManipulator->getCurrentCameraManipulator()->home(*init_event,actionAdapter);
+
+    double previous_time_since_start = 0.0f;
+    int number_frames_since_last_print = 0;
+    int number_of_frame_samples = 10;
+    bool printOutFrameStats=true;
+    while( !done )
+    {
+        // syncronize to screen refresh.
+        cg->sync();
+
+        // set the frame stamp for the new frame.
+        double time_since_start = timer.delta_s(start_tick,timer.tick());
+        frameStamp->setFrameNumber(frameNumber);
+        frameStamp->setReferenceTime(time_since_start);
+        
+        if (printOutFrameStats)
+        {
+            if (number_frames_since_last_print==number_of_frame_samples)
+            {
+                cout << "frame rate = "<< (double)number_of_frame_samples/(time_since_start-previous_time_since_start)<<endl;
+                previous_time_since_start = time_since_start;
+                number_frames_since_last_print = 0;
+            } else ++number_frames_since_last_print;
+        }
+        
+        // get the event since the last frame.
+        osgProducer::KeyboardMouseCallback::EventQueue queue;
+        kbmcb.getEventQueue(queue);
+        
+        // create an event to signal the new frame.
+        osg::ref_ptr<osgProducer::EventAdapter> frame_event = new osgProducer::EventAdapter;
+        frame_event->adaptFrame(frameStamp->getReferenceTime());
+        queue.push_back(frame_event);
+
+        // dispatch the events in order of arrival.
+        for(osgProducer::KeyboardMouseCallback::EventQueue::iterator event_itr=queue.begin();
+            event_itr!=queue.end();
+            ++event_itr)
+        {
+            bool handled = false;
+            for(EventHandlerList::iterator handler_itr=eventHandlerList.begin();
+                handler_itr!=eventHandlerList.end() && !handled;
+                ++handler_itr)
+            {   
+                handled = (*handler_itr)->handle(*(*event_itr),actionAdapter);
+            }
+        }
+
+        // update the scene by traversing it with the the update visitor which will
+        // call all node update callbacks and animations.
+        cg->getSceneData()->accept(update);
+
+
+        // update the main producer camera
+        cg->setView(old_style_osg_camera->getModelViewMatrix().ptr());
+         
+        // fire off the cull and draw traversals of the scene.
+        cg->frame();
+        
+        // increment the frame number ready for the next frame
+        ++frameNumber;
+    }
+    return 0;
+}
+