FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added bare bones osgGA::SimpleViewer class to help simplify OSG setup when embedding the OSG

Browse Source 
into existing GUI applications, and for one one a single camera, single window is required.
This commit is contained in:
Robert Osfield
2006-09-25 16:25:53 +00:00
parent 78444878c3
commit 5c0eb0b013
17 changed files with 552 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
examples/osgcluster/osgcluster.cpp
View File

@@ -300,9 +300,13 @@ class DataConverter
writeUInt(event.getEventType());
writeUInt(event.getKey());
writeUInt(event.getButton());
writeInt(event.getWindowX());
writeInt(event.getWindowY());
writeUInt(event.getWindowWidth());
writeUInt(event.getWindowHeight());
writeFloat(event.getXmin());
writeFloat(event.getXmax());
writeFloat(event.getYmin());
writeFloat(event.getXmax());
writeFloat(event.getYmax());
writeFloat(event.getX());
writeFloat(event.getY());
@@ -316,10 +320,16 @@ class DataConverter
event.setEventType((osgGA::GUIEventAdapter::EventType)readUInt());
event.setKey(readUInt());
event.setButton(readUInt());
event.setXmin(readFloat());
event.setXmax(readFloat());
event.setYmin(readFloat());
event.setYmax(readFloat());
int x = readInt();
int y = readInt();
int width = readUInt();
int height = readUInt();
event.setWindowRectangle(x,y,width,height);
float xmin = readFloat();
float ymin = readFloat();
float xmax = readFloat();
float ymax = readFloat();
event.setInputRange(xmin,ymin,xmax,ymax);
event.setX(readFloat());
event.setY(readFloat());
event.setButtonMask(readUInt());

2
examples/osgkeyboardmouse/GNUmakefile
View File

@@ -4,7 +4,7 @@ include $(TOPDIR)/Make/makedefs
CXXFILES =\
osgkeyboardmouse.cpp\
LIBS += -lProducer -losgFX -losgGA -losgDB -losgUtil -losg $(GL_LIBS) $(X_LIBS) $(OTHER_LIBS) -lOpenThreads
LIBS += -lProducer -losgFX -losgGA -losgDB -losgUtil -losg $(X_LIBS) $(OTHER_LIBS) -lOpenThreads
INSTFILES = \
$(CXXFILES)\

129
examples/osgkeyboardmouse/osgkeyboardmouse.cpp
View File

@@ -17,8 +17,7 @@
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <osgGA/EventQueue>
#include <osgGA/EventVisitor>
#include <osgGA/SimpleViewer>
#include <osgGA/TrackballManipulator>
#include <osgGA/StateSetManipulator>
@@ -285,132 +284,50 @@ int main( int argc, char **argv )
// create the view of the scene.
osg::ref_ptr<osgUtil::SceneView> sceneView = new osgUtil::SceneView;
sceneView->setDefaults();
sceneView->setSceneData(loadedModel.get());
osgGA::SimpleViewer viewer;
viewer.setSceneData(loadedModel.get());
// create the event queue,
// create the event queue, note that Producer has the y axis increase upwards, like OpenGL, and contary to most Windowing toolkits, so
// we need to construct the event queue so that it knows about this convention.
osg::ref_ptr<osgGA::EventQueue> eventQueue = new osgGA::EventQueue(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS);
// set up a KeyboardMouse to manage the events comming in from the RenderSurface
osg::ref_ptr<Producer::KeyboardMouse> kbm = new Producer::KeyboardMouse(renderSurface.get());
// create a KeyboardMouseCallback to handle the mouse events within this applications
osg::ref_ptr<MyKeyboardMouseCallback> kbmcb = new MyKeyboardMouseCallback(eventQueue.get());
osg::ref_ptr<MyKeyboardMouseCallback> kbmcb = new MyKeyboardMouseCallback(viewer.getEventQueue());
// create a tracball manipulator to move the camera around in response to keyboard/mouse events
osg::ref_ptr<osgGA::TrackballManipulator> cameraManipulator = new osgGA::TrackballManipulator;
viewer.setCameraManipulator( new osgGA::TrackballManipulator );
// keep a list of event handlers to manipulate the application/scene with in response to keyboard/mouse events
typedef std::list< osg::ref_ptr<osgGA::GUIEventHandler> > EventHandlers;
EventHandlers eventHandlers;
osg::ref_ptr<osgGA::StateSetManipulator> statesetManipulator = new osgGA::StateSetManipulator;
statesetManipulator->setStateSet(sceneView->getGlobalStateSet());
eventHandlers.push_back(statesetManipulator.get());
eventHandlers.push_back(new PickHandler(sceneView.get()));
statesetManipulator->setStateSet(viewer.getSceneView()->getGlobalStateSet());
viewer.addEventHandler(statesetManipulator.get());
// add the pick handler
viewer.addEventHandler(new PickHandler(viewer.getSceneView()));
// create an event visitor to pass the events down to the scene graph nodes
osg::ref_ptr<osgGA::EventVisitor> eventVisitor = new osgGA::EventVisitor;
// set the window dimensions
viewer.getEventQueue()->getCurrentEventState()->setWindowRectangle(100,100,800,600);
// create an action adapter to allow event handlers to request actions from the GUI.
osg::ref_ptr<MyActionAdapter> actionAdapter = new MyActionAdapter;
// record the timer tick at the start of rendering.
osg::Timer_t start_tick = osg::Timer::instance()->tick();
unsigned int frameNum = 0;
eventQueue->setStartTick(start_tick);
// set the mouse input range (note WindowSize name in appropriate here so osgGA::GUIEventAdapter API really needs looking at, Robert Osfield, June 2006).
// set the mouse input range.
// Producer defaults to using non-dimensional units, so we pass this onto osgGA, most windowing toolkits use pixel coords so use the window size instead.
eventQueue->getCurrentEventState()->setWindowSize(-1.0, -1.0, 1.0, 1.0);
viewer.getEventQueue()->getCurrentEventState()->setInputRange(-1.0, -1.0, 1.0, 1.0);
// Producer has the y axis increase upwards, like OpenGL, and contary to most Windowing toolkits.
// we need to construct the event queue so that it knows about this convention.
viewer.getEventQueue()->getCurrentEventState()->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS);
// home the manipulator.
osg::ref_ptr<osgGA::GUIEventAdapter> dummyEvent = eventQueue->createEvent();
cameraManipulator->setNode(sceneView->getSceneData());
cameraManipulator->home(*dummyEvent, *actionAdapter);
viewer.init();
// main loop (note, window toolkits which take control over the main loop will require a window redraw callback containing the code below.)
while( renderSurface->isRealized() && !kbmcb->done())
{
// set up the frame stamp for current frame to record the current time and frame number so that animtion code can advance correctly
osg::FrameStamp* frameStamp = new osg::FrameStamp;
frameStamp->setReferenceTime(osg::Timer::instance()->delta_s(start_tick,osg::Timer::instance()->tick()));
frameStamp->setFrameNumber(frameNum++);
// pass frame stamp to the SceneView so that the update, cull and draw traversals all use the same FrameStamp
sceneView->setFrameStamp(frameStamp);
// update the window dimensions, in case the window has been resized.
viewer.getEventQueue()->windowResize(0,0,renderSurface->getWindowWidth(),renderSurface->getWindowHeight(), false);
// pass any keyboard mouse events onto the local keyboard mouse callback.
kbm->update( *kbmcb );
// create an event to signal the new frame.
eventQueue->frame(frameStamp->getReferenceTime());
// get the event since the last frame.
osgGA::EventQueue::Events events;
eventQueue->takeEvents(events);
if (eventVisitor.valid())
{
eventVisitor->setTraversalNumber(frameStamp->getFrameNumber());
}
// dispatch the events in order of arrival.
for(osgGA::EventQueue::Events::iterator event_itr = events.begin();
event_itr != events.end();
++event_itr)
{
bool handled = false;
if (eventVisitor.valid() && sceneView->getSceneData())
{
eventVisitor->reset();
eventVisitor->addEvent(event_itr->get());
sceneView->getSceneData()->accept(*eventVisitor);
if (eventVisitor->getEventHandled())
handled = true;
}
if (cameraManipulator.valid() && !handled)
{
/*handled =*/ cameraManipulator->handle(*(*event_itr), *actionAdapter);
}
for(EventHandlers::iterator handler_itr=eventHandlers.begin();
handler_itr!=eventHandlers.end() && !handled;
++handler_itr)
{
handled = (*handler_itr)->handle(*(*event_itr),*actionAdapter,0,0);
}
// osg::notify(osg::NOTICE)<<" Handled event "<<(*event_itr)->getTime()<<" "<< handled<<std::endl;
}
// update view matrices
if (cameraManipulator.valid())
{
sceneView->setViewMatrix(cameraManipulator->getInverseMatrix());
}
// update the viewport dimensions, incase the window has been resized.
sceneView->setViewport(0,0,renderSurface->getWindowWidth(),renderSurface->getWindowHeight());
// do the update traversal the scene graph - such as updating animations
sceneView->update();
// do the cull traversal, collect all objects in the view frustum into a sorted set of rendering bins
sceneView->cull();
// draw the rendering bins.
sceneView->draw();
viewer.frame();
// Swap Buffers
renderSurface->swapBuffers();

2
examples/osgsimple/GNUmakefile
View File

@@ -4,7 +4,7 @@ include $(TOPDIR)/Make/makedefs
CXXFILES =\
osgsimple.cpp\
LIBS += -lProducer -losgDB -losgUtil -losg $(GL_LIBS) $(X_LIBS) $(OTHER_LIBS) -lOpenThreads
LIBS += -lProducer -losgGA -losgDB -losgUtil -losg $(GL_LIBS) $(X_LIBS) $(OTHER_LIBS) -lOpenThreads
INSTFILES = \
$(CXXFILES)\

43
examples/osgsimple/osgsimple.cpp
View File

@@ -4,9 +4,10 @@
// graphics window, and OSG for rendering.
#include <Producer/RenderSurface>
#include <osg/Timer>
#include <osgUtil/SceneView>
#include <osgDB/ReadFile>
#include <osgGA/SimpleViewer>
int main( int argc, char **argv )
@@ -32,46 +33,26 @@ int main( int argc, char **argv )
renderSurface->useBorder(true);
renderSurface->realize();
// create the view of the scene.
osg::ref_ptr<osgUtil::SceneView> sceneView = new osgUtil::SceneView;
sceneView->setDefaults();
sceneView->setSceneData(loadedModel.get());
osgGA::SimpleViewer viewer;
viewer.setSceneData(loadedModel.get());
// initialize the view to look at the center of the scene graph
const osg::BoundingSphere& bs = loadedModel->getBound();
osg::Matrix viewMatrix;
viewMatrix.makeLookAt(bs.center()-osg::Vec3(0.0,2.0f*bs.radius(),0.0),bs.center(),osg::Vec3(0.0f,0.0f,1.0f));
// record the timer tick at the start of rendering.
osg::Timer_t start_tick = osg::Timer::instance()->tick();
unsigned int frameNum = 0;
// main loop (note, window toolkits which take control over the main loop will require a window redraw callback containing the code below.)
while( renderSurface->isRealized() )
{
// set up the frame stamp for current frame to record the current time and frame number so that animtion code can advance correctly
osg::ref_ptr<osg::FrameStamp> frameStamp = new osg::FrameStamp;
frameStamp->setReferenceTime(osg::Timer::instance()->delta_s(start_tick,osg::Timer::instance()->tick()));
frameStamp->setFrameNumber(frameNum++);
// pass frame stamp to the SceneView so that the update, cull and draw traversals all use the same FrameStamp
sceneView->setFrameStamp(frameStamp.get());
// update the viewport dimensions, incase the window has been resized.
sceneView->setViewport(0,0,renderSurface->getWindowWidth(),renderSurface->getWindowHeight());
// set the view
sceneView->setViewMatrix(viewMatrix);
{
// update the window dimensions, in case the window has been resized.
viewer.getEventQueue()->windowResize(0,0,renderSurface->getWindowWidth(),renderSurface->getWindowHeight());
// do the update traversal the scene graph - such as updating animations
sceneView->update();
// set the view
viewer.getCamera()->setViewMatrix(viewMatrix);
// do the cull traversal, collect all objects in the view frustum into a sorted set of rendering bins
sceneView->cull();
// draw the rendering bins.
sceneView->draw();
// advance the frame, handle events, update the scene and render it.
viewer.frame();
// Swap Buffers
renderSurface->swapBuffers();

2
include/osgGA/EventQueue
View File

@@ -52,7 +52,7 @@ class OSGGA_EXPORT EventQueue : public osg::Referenced
/** Method for adapting window resize event, placing this event on the back of the event queue. */
void windowResize(float Xmin, float Ymin, float Xmax, float Ymax);
void windowResize(int x, int y, unsigned int width, unsigned int height, bool updateMouseRange = true);
/** Method for adapting mouse scroll wheel events, placing this event on the back of the event queue. */
void mouseScroll(GUIEventAdapter::ScrollingMotion sm);

44
include/osgGA/GUIEventAdapter
View File

@@ -271,6 +271,23 @@ public:
/** deprecated function for getting time of event. */
double time() const { return _time; }
/** set window rectangle. */
void setWindowRectangle(int x, int y, unsigned int width, unsigned int height, bool updateMouseRange = true);
/** get window x origin.*/
int getWindowX() const { return _windowX; }
/** get window y origin.*/
int getWindowY() const { return _windowY; }
/** get window width.*/
unsigned int getWindowWidth() const { return _windowWidth; }
/** get window height.*/
unsigned int getWindowHeight() const { return _windowHeight; }
/** set key pressed. */
inline void setKey(int key) { _key = key; }
@@ -283,31 +300,20 @@ public:
/** button pressed/released, return -1 if inappropriate for this GUIEventAdapter.*/
int getButton() const { return _button; }
/** set window size. */
void setWindowSize(float Xmin, float Ymin, float Xmax, float Ymax);
/** set window minimum x. */
void setXmin(float x) { _Xmin = x; }
/** set mouse input range. */
void setInputRange(float Xmin, float Ymin, float Xmax, float Ymax);
/** get window minimum x. */
/** get mouse minimum x. */
float getXmin() const { return _Xmin; }
/** set window maximum x. */
void setXmax(float x) { _Xmax = x; }
/** get window maximum x. */
/** get mouse maximum x. */
float getXmax() const { return _Xmax; }
/** set window minimum y. */
void setYmin(float y) { _Ymin = y; }
/** get window minimum y. */
/** get mmouse minimum y. */
float getYmin() const { return _Ymin; }
/** set window maYimum y. */
void setYmax(float y) { _Ymax = y; }
/** get window maYimum y. */
/** get mouse maYimum y. */
float getYmax() const { return _Ymax; }
/** set current mouse x position.*/
@@ -388,6 +394,10 @@ public:
EventType _eventType;
double _time;
int _windowX;
int _windowY;
int _windowWidth;
int _windowHeight;
int _key;
int _button;
float _Xmin,_Xmax;

114
include/osgGA/SimpleViewer Normal file
View File

@@ -0,0 +1,114 @@
/* -*-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.
*/
#ifndef OSGGA_SimpleViewer
#define OSGGA_SimpleViewer 1
#include <osgGA/EventQueue>
#include <osgGA/EventVisitor>
#include <osgGA/MatrixManipulator>
#include <osgDB/DatabasePager>
#include <list>
namespace osgGA{
/** SimpleViewer provide a simple interface for setting up rendering of an scene graph, using a single camera view within a single window.*/
class OSGGA_EXPORT SimpleViewer : public osgGA::GUIActionAdapter
{
public:
SimpleViewer();
virtual ~SimpleViewer();
void setSceneData(osg::Node* node);
osg::Node* getSceneData();
const osg::Node* getSceneData() const;
osg::CameraNode* getCamera();
const osg::CameraNode* getCamera() const;
void setCameraManipulator(MatrixManipulator* manipulator);
MatrixManipulator* getCameraManipulator() { return _cameraManipulator.get(); }
const MatrixManipulator* getCameraManipulator() const { return _cameraManipulator.get(); }
typedef std::list< osg::ref_ptr<GUIEventHandler> > EventHandlers;
void addEventHandler(GUIEventHandler* eventHandler);
EventHandlers& getEventHandlers() { return _eventHandlers; }
const EventHandlers& getEventHandlers() const { return _eventHandlers; }
EventQueue* getEventQueue() { return _eventQueue.get(); }
const EventQueue* getEventQueue() const { return _eventQueue.get(); }
void setDatabasePager(osgDB::DatabasePager* dp);
osgDB::DatabasePager* getDatabasePager() { return _databasePager.get(); }
const osgDB::DatabasePager* getDatabasePager() const { return _databasePager.get(); }
/** Render a complete new frame.
* Calls frameAdvance(), frameEventTraversal(), frameUpateTraversal(), frameCullTraversal() and frameDrawTraversal().
* Note, no internal makeCurrent() is issued before, or swap buffers called after frame(), these operations are the responsibility of the calling code.*/
virtual void frame();
virtual void frameAdvance();
virtual void frameEventTraversal();
virtual void frameUpdateTraversal();
virtual void frameCullTraversal();
virtual void frameDrawTraversal();
/** Clean up all OpenGL objects associated with this viewer scenegraph. Note, must only be called from the graphics context associated with this viewer.*/
virtual void cleanup();
public:
// Override from GUIActionAdapter
virtual void requestRedraw() {}
// Override from GUIActionAdapter
virtual void requestContinuousUpdate(bool /*needed*/=true) {}
// Override from GUIActionAdapter
virtual void requestWarpPointer(float /*x*/,float /*y*/) {}
osgUtil::SceneView* getSceneView() { return _sceneView.get(); }
const osgUtil::SceneView* getSceneView() const { return _sceneView.get(); }
void init();
protected:
bool _firstFrame;
osg::Timer_t _startTick;
osg::ref_ptr<osg::FrameStamp> _frameStamp;
osg::ref_ptr<osgUtil::SceneView> _sceneView;
osg::ref_ptr<osgGA::EventQueue> _eventQueue;
osg::ref_ptr<osgGA::MatrixManipulator> _cameraManipulator;
EventHandlers _eventHandlers;
osg::ref_ptr<osgGA::EventVisitor> _eventVisitor;
osg::ref_ptr<osgDB::DatabasePager> _databasePager;
};
}
#endif

4
src/osgGA/EventQueue.cpp
View File

@@ -77,9 +77,9 @@ bool EventQueue::copyEvents(Events& events) const
}
void EventQueue::windowResize(float Xmin, float Ymin, float Xmax, float Ymax)
void EventQueue::windowResize(int x, int y, unsigned int width, unsigned int height, bool updateMouseRange)
{
_accumulateEventState->setWindowSize(Xmin, Ymin, Xmax, Ymax);
_accumulateEventState->setWindowRectangle(x, y, width, height, updateMouseRange);
GUIEventAdapter* event = new GUIEventAdapter(*_accumulateEventState);
event->setEventType(GUIEventAdapter::RESIZE);

1
src/osgGA/GNUmakefile
View File

@@ -16,6 +16,7 @@ CXXFILES = \
KeySwitchMatrixManipulator.cpp\
SetSceneViewVisitor.cpp\
StateSetManipulator.cpp\
SimpleViewer.cpp\
TerrainManipulator.cpp\
NodeTrackerManipulator.cpp\
TrackballManipulator.cpp\

24
src/osgGA/GUIEventAdapter.cpp
View File

@@ -18,6 +18,10 @@ using namespace osgGA;
GUIEventAdapter::GUIEventAdapter():
_eventType(NONE),
_time(0.0),
_windowX(0),
_windowY(0),
_windowWidth(1280),
_windowHeight(1024),
_key(0),
_button(0),
_Xmin(0.0),
@@ -40,6 +44,10 @@ GUIEventAdapter::GUIEventAdapter(const GUIEventAdapter& rhs):
osg::Referenced(),
_eventType(rhs._eventType),
_time(rhs._time),
_windowX(rhs._windowX),
_windowY(rhs._windowY),
_windowWidth(rhs._windowWidth),
_windowHeight(rhs._windowHeight),
_key(rhs._key),
_button(rhs._button),
_Xmin(rhs._Xmin),
@@ -62,7 +70,21 @@ GUIEventAdapter::~GUIEventAdapter()
{
}
void GUIEventAdapter::setWindowSize(float Xmin, float Ymin, float Xmax, float Ymax)
void GUIEventAdapter::setWindowRectangle(int x, int y, unsigned int width, unsigned int height, bool updateMouseRange)
{
_windowX = x;
_windowY = y;
_windowWidth = width;
_windowHeight = height;
if (updateMouseRange)
{
setInputRange(x, y, x+width, y+height);
}
}
void GUIEventAdapter::setInputRange(float Xmin, float Ymin, float Xmax, float Ymax)
{
_Xmin = Xmin;
_Ymin = Ymin;

235
src/osgGA/SimpleViewer.cpp Normal file
View File

@@ -0,0 +1,235 @@
/* -*-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 <osgGA/SimpleViewer>
#include <osgGA/TrackballManipulator>
using namespace osgGA;
SimpleViewer::SimpleViewer():
_firstFrame(true)
{
_sceneView = new osgUtil::SceneView;
_sceneView->setDefaults();
_sceneView->getState()->setContextID(osg::GraphicsContext::createNewContextID());
_startTick = osg::Timer::instance()->tick();
_frameStamp = new osg::FrameStamp;
_frameStamp->setFrameNumber(0);
_frameStamp->setReferenceTime(0);
_eventQueue = new osgGA::EventQueue;
_eventQueue->setStartTick(_startTick);
_eventVisitor = new osgGA::EventVisitor;
}
SimpleViewer::~SimpleViewer()
{
_sceneView->releaseAllGLObjects();
osg::GraphicsContext::decrementContextIDUsageCount(_sceneView->getState()->getContextID());
}
void SimpleViewer::setSceneData(osg::Node* node)
{
_sceneView->setSceneData(node);
if (_cameraManipulator.valid())
{
_cameraManipulator->setNode(node);
osg::ref_ptr<osgGA::GUIEventAdapter> dummyEvent = _eventQueue->createEvent();
_cameraManipulator->home(*dummyEvent, *this);
}
}
osg::Node* SimpleViewer::getSceneData()
{
return _sceneView->getSceneData();
}
const osg::Node* SimpleViewer::getSceneData() const
{
return _sceneView->getSceneData();
}
osg::CameraNode* SimpleViewer::getCamera()
{
return _sceneView->getCamera();
}
const osg::CameraNode* SimpleViewer::getCamera() const
{
return _sceneView->getCamera();
}
void SimpleViewer::setCameraManipulator(MatrixManipulator* manipulator)
{
if (_cameraManipulator == manipulator) return;
_cameraManipulator = manipulator;
if (_cameraManipulator.valid())
{
_cameraManipulator->setNode(_sceneView->getSceneData());
osg::ref_ptr<osgGA::GUIEventAdapter> dummyEvent = _eventQueue->createEvent();
_cameraManipulator->home(*dummyEvent, *this);
}
}
void SimpleViewer::addEventHandler(GUIEventHandler* eventHandler)
{
_eventHandlers.push_back(eventHandler);
}
void SimpleViewer::init()
{
osg::ref_ptr<osgGA::GUIEventAdapter> initEvent = _eventQueue->createEvent();
initEvent->setEventType(osgGA::GUIEventAdapter::FRAME);
_cameraManipulator->init(*initEvent, *this);
}
void SimpleViewer::frame()
{
if (_firstFrame)
{
init();
_firstFrame = false;
}
frameAdvance();
frameEventTraversal();
frameUpdateTraversal();
frameCullTraversal();
frameDrawTraversal();
}
void SimpleViewer::frameAdvance()
{
osg::Timer_t currentTick = osg::Timer::instance()->tick();
_frameStamp->setReferenceTime(osg::Timer::instance()->delta_s(_startTick,currentTick));
_frameStamp->setFrameNumber(_frameStamp->getFrameNumber()+1);
_sceneView->setFrameStamp(_frameStamp.get());
}
void SimpleViewer::frameEventTraversal()
{
_eventQueue->frame( _frameStamp->getReferenceTime() );
osgGA::EventQueue::Events events;
_eventQueue->takeEvents(events);
if (_eventVisitor.valid())
{
_eventVisitor->setTraversalNumber(_frameStamp->getFrameNumber());
}
for(osgGA::EventQueue::Events::iterator itr = events.begin();
itr != events.end();
++itr)
{
osgGA::GUIEventAdapter* event = itr->get();
bool handled = false;
if (_eventVisitor.valid())
{
_eventVisitor->reset();
_eventVisitor->addEvent( event );
getSceneData()->accept(*_eventVisitor);
if (_eventVisitor->getEventHandled()) handled = true;
}
if (_cameraManipulator.valid())
{
_cameraManipulator->handle( *event, *this );
}
for(EventHandlers::iterator hitr = _eventHandlers.begin();
hitr != _eventHandlers.end() && !handled;
++hitr)
{
handled = (*hitr)->handle( *event, *this, 0, 0);
}
}
}
void SimpleViewer::frameUpdateTraversal()
{
double previousAspectRatio = ( static_cast<double>(_sceneView->getViewport()->width())/
static_cast<double>(_sceneView->getViewport()->height()) );
// update the viewport
int width = _eventQueue->getCurrentEventState()->getWindowWidth();
int height = _eventQueue->getCurrentEventState()->getWindowHeight();
_sceneView->setViewport(0,0,width,height);
double newAspectRatio = ( static_cast<double>(_sceneView->getViewport()->width())/
static_cast<double>(_sceneView->getViewport()->height()) );
// if aspect ratio adjusted change the project matrix to suit.
if (previousAspectRatio != newAspectRatio)
{
osg::Matrixd& pm = _sceneView->getProjectionMatrix();
bool orthographicCamera = (pm(0,3)==0.0) && (pm(0,3)==0.0) && (pm(0,3)==0.0) && (pm(0,3)==1.0);
if (orthographicCamera)
{
double left, right, bottom, top, zNear, zFar;
_sceneView->getProjectionMatrixAsOrtho(left, right, bottom, top, zNear, zFar);
double mid = (right+left)*0.5;
double halfWidth = (right-left)*0.5;
left = mid - halfWidth * (newAspectRatio/previousAspectRatio);
right = mid + halfWidth * (newAspectRatio/previousAspectRatio);
_sceneView->setProjectionMatrixAsOrtho(left, right, bottom, top, zNear, zFar);
}
else
{
double left, right, bottom, top, zNear, zFar;
_sceneView->getProjectionMatrixAsFrustum(left, right, bottom, top, zNear, zFar);
double mid = (right+left)*0.5;
double halfWidth = (right-left)*0.5;
left = mid - halfWidth * (newAspectRatio/previousAspectRatio);
right = mid + halfWidth * (newAspectRatio/previousAspectRatio);
_sceneView->setProjectionMatrixAsFrustum(left, right, bottom, top, zNear, zFar);
}
}
if (_cameraManipulator.valid())
{
_sceneView->setViewMatrix(_cameraManipulator->getInverseMatrix());
}
_sceneView->update();
}
void SimpleViewer::frameCullTraversal()
{
_sceneView->cull();
}
void SimpleViewer::frameDrawTraversal()
{
_sceneView->draw();
}
void SimpleViewer::cleanup()
{
_sceneView->releaseAllGLObjects();
_sceneView->flushAllDeletedGLObjects();
}

11
src/osgProducer/KeyboardMouseCallback.cpp
View File

@@ -158,9 +158,7 @@ void KeyboardMouseCallback::updateWindowSize()
maxY = osg::maximum(maxY,ir.bottom()+ir.height());
}
// osg::notify(osg::NOTICE)<<"IA ea->setWindowSize("<<minX<<","<<minY<<","<<maxX<<","<<maxY<<")"<<std::endl;
ea->setWindowSize(minX,minY,maxX,maxY);
ea->setInputRange(minX,minY,maxX,maxY);
}
else if (rs)
{
@@ -175,7 +173,12 @@ void KeyboardMouseCallback::updateWindowSize()
// osg::notify(osg::NOTICE)<<"RS ea->setWindowSize("<<minX<<","<<minY<<","<<maxX<<","<<maxY<<")"<<std::endl;
ea->setWindowSize(minX,minY,maxX,maxY);
ea->setInputRange(minX,minY,maxX,maxY);
}
if (rs)
{
ea->setWindowRectangle(rs->getWindowOriginX(), rs->getWindowOriginY(), rs->getWindowWidth(),rs->getWindowHeight());
}
}

2
src/osgWrappers/osgGA/EventQueue.cpp
View File

@@ -32,7 +32,7 @@ BEGIN_OBJECT_REFLECTOR(osgGA::EventQueue)
I_Method1(bool, copyEvents, IN, osgGA::EventQueue::Events &, events);
I_Method1(void, appendEvents, IN, osgGA::EventQueue::Events &, events);
I_Method1(void, addEvent, IN, osgGA::GUIEventAdapter *, event);
I_Method4(void, windowResize, IN, float, Xmin, IN, float, Ymin, IN, float, Xmax, IN, float, Ymax);
I_MethodWithDefaults5(void, windowResize, IN, int, x, , IN, int, y, , IN, unsigned int, width, , IN, unsigned int, height, , IN, bool, updateMouseRange, true);
I_Method1(void, mouseScroll, IN, osgGA::GUIEventAdapter::ScrollingMotion, sm);
I_Method2(void, mouseScroll2D, IN, float, x, IN, float, y);
I_Method1(void, penPressure, IN, float, pressure);

1
src/osgWrappers/osgGA/GNUmakefile
View File

@@ -15,6 +15,7 @@ CXXFILES =\
MatrixManipulator.cpp\
NodeTrackerManipulator.cpp\
SetSceneViewVisitor.cpp\
SimpleViewer.cpp\
StateSetManipulator.cpp\
TerrainManipulator.cpp\
TrackballManipulator.cpp\

23
src/osgWrappers/osgGA/GUIEventAdapter.cpp
View File

@@ -215,18 +215,19 @@ BEGIN_OBJECT_REFLECTOR(osgGA::GUIEventAdapter)
I_Method1(void, setTime, IN, double, time);
I_Method0(double, getTime);
I_Method0(double, time);
I_MethodWithDefaults5(void, setWindowRectangle, IN, int, x, , IN, int, y, , IN, unsigned int, width, , IN, unsigned int, height, , IN, bool, updateMouseRange, true);
I_Method0(int, getWindowX);
I_Method0(int, getWindowY);
I_Method0(unsigned int, getWindowWidth);
I_Method0(unsigned int, getWindowHeight);
I_Method1(void, setKey, IN, int, key);
I_Method0(int, getKey);
I_Method1(void, setButton, IN, int, button);
I_Method0(int, getButton);
I_Method4(void, setWindowSize, IN, float, Xmin, IN, float, Ymin, IN, float, Xmax, IN, float, Ymax);
I_Method1(void, setXmin, IN, float, x);
I_Method4(void, setInputRange, IN, float, Xmin, IN, float, Ymin, IN, float, Xmax, IN, float, Ymax);
I_Method0(float, getXmin);
I_Method1(void, setXmax, IN, float, x);
I_Method0(float, getXmax);
I_Method1(void, setYmin, IN, float, y);
I_Method0(float, getYmin);
I_Method1(void, setYmax, IN, float, y);
I_Method0(float, getYmax);
I_Method1(void, setX, IN, float, x);
I_Method0(float, getX);
@@ -261,13 +262,17 @@ BEGIN_OBJECT_REFLECTOR(osgGA::GUIEventAdapter)
I_Property(osgGA::GUIEventAdapter::ScrollingMotion, ScrollingMotion);
I_Property(osgGA::GUIEventAdapter::TabletPointerType, TabletPointerType);
I_Property(double, Time);
I_ReadOnlyProperty(unsigned int, WindowHeight);
I_ReadOnlyProperty(unsigned int, WindowWidth);
I_ReadOnlyProperty(int, WindowX);
I_ReadOnlyProperty(int, WindowY);
I_Property(float, X);
I_Property(float, Xmax);
I_Property(float, Xmin);
I_ReadOnlyProperty(float, Xmax);
I_ReadOnlyProperty(float, Xmin);
I_ReadOnlyProperty(float, Xnormalized);
I_Property(float, Y);
I_Property(float, Ymax);
I_Property(float, Ymin);
I_ReadOnlyProperty(float, Ymax);
I_ReadOnlyProperty(float, Ymin);
I_ReadOnlyProperty(float, Ynormalized);
END_REFLECTOR

74
src/osgWrappers/osgGA/SimpleViewer.cpp Normal file
View File

@@ -0,0 +1,74 @@
// ***************************************************************************
//
// Generated automatically by genwrapper.
// Please DO NOT EDIT this file!
//
// ***************************************************************************
#include <osgIntrospection/ReflectionMacros>
#include <osgIntrospection/TypedMethodInfo>
#include <osgIntrospection/StaticMethodInfo>
#include <osgIntrospection/Attributes>
#include <osg/CameraNode>
#include <osg/Node>
#include <osgDB/DatabasePager>
#include <osgGA/EventQueue>
#include <osgGA/GUIEventHandler>
#include <osgGA/MatrixManipulator>
#include <osgGA/SimpleViewer>
#include <osgUtil/SceneView>
// Must undefine IN and OUT macros defined in Windows headers
#ifdef IN
#undef IN
#endif
#ifdef OUT
#undef OUT
#endif
TYPE_NAME_ALIAS(std::list< osg::ref_ptr< osgGA::GUIEventHandler > >, osgGA::SimpleViewer::EventHandlers);
BEGIN_OBJECT_REFLECTOR(osgGA::SimpleViewer)
I_BaseType(osgGA::GUIActionAdapter);
I_Constructor0();
I_Method1(void, setSceneData, IN, osg::Node *, node);
I_Method0(osg::Node *, getSceneData);
I_Method0(const osg::Node *, getSceneData);
I_Method0(osg::CameraNode *, getCamera);
I_Method0(const osg::CameraNode *, getCamera);
I_Method1(void, setCameraManipulator, IN, osgGA::MatrixManipulator *, manipulator);
I_Method0(osgGA::MatrixManipulator *, getCameraManipulator);
I_Method0(const osgGA::MatrixManipulator *, getCameraManipulator);
I_Method1(void, addEventHandler, IN, osgGA::GUIEventHandler *, eventHandler);
I_Method0(osgGA::SimpleViewer::EventHandlers &, getEventHandlers);
I_Method0(const osgGA::SimpleViewer::EventHandlers &, getEventHandlers);
I_Method0(osgGA::EventQueue *, getEventQueue);
I_Method0(const osgGA::EventQueue *, getEventQueue);
I_Method1(void, setDatabasePager, IN, osgDB::DatabasePager *, dp);
I_Method0(osgDB::DatabasePager *, getDatabasePager);
I_Method0(const osgDB::DatabasePager *, getDatabasePager);
I_Method0(void, frame);
I_Method0(void, frameAdvance);
I_Method0(void, frameEventTraversal);
I_Method0(void, frameUpdateTraversal);
I_Method0(void, frameCullTraversal);
I_Method0(void, frameDrawTraversal);
I_Method0(void, cleanup);
I_Method0(void, requestRedraw);
I_MethodWithDefaults1(void, requestContinuousUpdate, IN, bool, x, true);
I_Method2(void, requestWarpPointer, IN, float, x, IN, float, x);
I_Method0(osgUtil::SceneView *, getSceneView);
I_Method0(const osgUtil::SceneView *, getSceneView);
I_Method0(void, init);
I_ReadOnlyProperty(osg::CameraNode *, Camera);
I_Property(osgGA::MatrixManipulator *, CameraManipulator);
I_Property(osgDB::DatabasePager *, DatabasePager);
I_ReadOnlyProperty(osgGA::SimpleViewer::EventHandlers &, EventHandlers);
I_ReadOnlyProperty(osgGA::EventQueue *, EventQueue);
I_Property(osg::Node *, SceneData);
I_ReadOnlyProperty(osgUtil::SceneView *, SceneView);
END_REFLECTOR
STD_LIST_REFLECTOR(std::list< osg::ref_ptr< osgGA::GUIEventHandler > >);