FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
45c7ca720c
OpenSceneGraph/include/osgViewer/ViewerEventHandlers
Robert Osfield 70e1c60819 Added sendPointerEvent and sendKeyEvent virtual methods to osg::Image to 
facilitate the subclassing of Image providing interactive behaviours so as
used in the vnc interactive VncImage class.

osgViewer::InteractiveImageHandler provides an event handler that convertes osgGA 
mouse and keyboard events into the coordinate frame of an image based on ray intersection with geometry in
the associated subgraph.

Changed the ordering of events processing in Viewer and CompositeViewer to allow
scene graph event handlers to take precidence over viewer event handlers and camera manipulators
2008-11-03 15:08:04 +00:00

390 lines
15 KiB
C++
Raw Blame History

/* -*-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 OSGVIEWER_VIEWEREVENTHANDLERS
#define OSGVIEWER_VIEWEREVENTHANDLERS 1
#include <osg/AnimationPath>
#include <osgText/Text>
#include <osgGA/GUIEventHandler>
#include <osgGA/AnimationPathManipulator>
#include <osgViewer/GraphicsWindow>
#include <osgViewer/Viewer>
#include <fstream>
namespace osgViewer {
/** Event handler for adding on screen help to Viewers.*/
class OSGVIEWER_EXPORT HelpHandler : public osgGA::GUIEventHandler
{
public:
HelpHandler(osg::ApplicationUsage* au=0);
void setApplicationUsage(osg::ApplicationUsage* au) { _applicationUsage = au; }
osg::ApplicationUsage* getApplicationUsage() { return _applicationUsage.get(); }
const osg::ApplicationUsage* getApplicationUsage() const { return _applicationUsage.get(); }
void setKeyEventTogglesOnScreenHelp(int key) { _keyEventTogglesOnScreenHelp = key; }
int getKeyEventTogglesOnScreenHelp() const { return _keyEventTogglesOnScreenHelp; }
void reset();
osg::Camera* getCamera() { return _camera.get(); }
const osg::Camera* getCamera() const { return _camera.get(); }
bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);
/** Get the keyboard and mouse usage of this manipulator.*/
virtual void getUsage(osg::ApplicationUsage& usage) const;
protected:
void setUpHUDCamera(osgViewer::ViewerBase* viewer);
void setUpScene(osgViewer::ViewerBase* viewer);
osg::ref_ptr<osg::ApplicationUsage> _applicationUsage;
int _keyEventTogglesOnScreenHelp;
bool _helpEnabled;
bool _initialized;
osg::ref_ptr<osg::Camera> _camera;
osg::ref_ptr<osg::Switch> _switch;
};
/** Event handler for adding on screen stats reporting to Viewers.*/
class OSGVIEWER_EXPORT StatsHandler : public osgGA::GUIEventHandler
{
public:
StatsHandler();
enum StatsType
{
NO_STATS = 0,
FRAME_RATE = 1,
VIEWER_STATS = 2,
CAMERA_SCENE_STATS = 3,
VIEWER_SCENE_STATS = 4,
LAST = 5
};
void setKeyEventTogglesOnScreenStats(int key) { _keyEventTogglesOnScreenStats = key; }
int getKeyEventTogglesOnScreenStats() const { return _keyEventTogglesOnScreenStats; }
void setKeyEventPrintsOutStats(int key) { _keyEventPrintsOutStats = key; }
int getKeyEventPrintsOutStats() const { return _keyEventPrintsOutStats; }
double getBlockMultiplier() const { return _blockMultiplier; }
void reset();
osg::Camera* getCamera() { return _camera.get(); }
const osg::Camera* getCamera() const { return _camera.get(); }
virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);
/** Get the keyboard and mouse usage of this manipulator.*/
virtual void getUsage(osg::ApplicationUsage& usage) const;
protected:
void setUpHUDCamera(osgViewer::ViewerBase* viewer);
osg::Geometry* createBackgroundRectangle(const osg::Vec3& pos, const float width, const float height, osg::Vec4& color);
osg::Geometry* createGeometry(const osg::Vec3& pos, float height, const osg::Vec4& colour, unsigned int numBlocks);
osg::Geometry* createFrameMarkers(const osg::Vec3& pos, float height, const osg::Vec4& colour, unsigned int numBlocks);
osg::Geometry* createTick(const osg::Vec3& pos, float height, const osg::Vec4& colour, unsigned int numTicks);
osg::Node* createCameraTimeStats(const std::string& font, osg::Vec3& pos, float startBlocks, bool acquireGPUStats, float characterSize, osg::Stats* viewerStats, osg::Camera* camera);
void setUpScene(osgViewer::ViewerBase* viewer);
void updateThreadingModelText();
int _keyEventTogglesOnScreenStats;
int _keyEventPrintsOutStats;
int _statsType;
bool _initialized;
osg::ref_ptr<osg::Camera> _camera;
osg::ref_ptr<osg::Switch> _switch;
ViewerBase::ThreadingModel _threadingModel;
osg::ref_ptr<osgText::Text> _threadingModelText;
unsigned int _frameRateChildNum;
unsigned int _viewerChildNum;
unsigned int _cameraSceneChildNum;
unsigned int _viewerSceneChildNum;
unsigned int _numBlocks;
double _blockMultiplier;
};
/** Event handler allowing to change the screen resolution (in windowed mode) and toggle between fullscreen and windowed mode. */
class OSGVIEWER_EXPORT WindowSizeHandler : public osgGA::GUIEventHandler
{
public:
WindowSizeHandler();
/** Get the keyboard and mouse usage of this manipulator.*/
virtual void getUsage(osg::ApplicationUsage &usage) const;
void setKeyEventToggleFullscreen(int key) { _keyEventToggleFullscreen = key; }
int getKeyEventToggleFullscreen() const { return _keyEventToggleFullscreen; }
void setToggleFullscreen(bool flag) { _toggleFullscreen = flag; }
bool getToggleFullscreen() const { return _toggleFullscreen; }
void setKeyEventWindowedResolutionUp(int key) { _keyEventWindowedResolutionUp = key; }
int getKeyEventWindowedResolutionUp() const { return _keyEventWindowedResolutionUp; }
void setKeyEventWindowedResolutionDown(int key) { _keyEventWindowedResolutionDown = key; }
int getKeyEventWindowedResolutionDown() const { return _keyEventWindowedResolutionUp; }
void setChangeWindowedResolution(bool flag) { _changeWindowedResolution = flag; }
bool getChangeWindowedResolution() const { return _changeWindowedResolution; }
virtual bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa);
protected:
void toggleFullscreen(osgViewer::GraphicsWindow *window);
void changeWindowedResolution(osgViewer::GraphicsWindow *window, bool increase);
unsigned int getNearestResolution(int screenWidth, int screenHeight, int width, int height) const;
int _keyEventToggleFullscreen;
bool _toggleFullscreen;
int _keyEventWindowedResolutionUp;
int _keyEventWindowedResolutionDown;
bool _changeWindowedResolution;
std::vector<osg::Vec2> _resolutionList;
int _currentResolutionIndex;
};
/** Event handler allowing to change the viewer threading model */
class OSGVIEWER_EXPORT ThreadingHandler : public osgGA::GUIEventHandler
{
public:
ThreadingHandler();
/** Get the keyboard and mouse usage of this manipulator.*/
virtual void getUsage(osg::ApplicationUsage &usage) const;
void setKeyEventChangeThreadingModel(int key) { _keyEventChangeThreadingModel = key; }
int getKeyEventChangeThreadingModel() const { return _keyEventChangeThreadingModel; }
void setChangeThreadingModel(bool flag) { _changeThreadingModel = flag; }
bool getChangeThreadingModel() const { return _changeThreadingModel; }
void setKeyEventChangeEndBarrierPosition(int key) { _keyEventChangeEndBarrierPosition = key; }
int getKeyEventChangeEndBarrierPosition() const { return _keyEventChangeEndBarrierPosition; }
void setChangeEndBarrierPosition(bool flag) { _changeEndBarrierPosition = flag; }
bool getChangeEndBarrierPosition() const { return _changeEndBarrierPosition; }
bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa);
protected:
int _keyEventChangeThreadingModel;
bool _changeThreadingModel;
int _keyEventChangeEndBarrierPosition;
bool _changeEndBarrierPosition;
osg::Timer_t _tickOrLastKeyPress;
bool _done;
};
/**
* Event handler allowing the user to record the animation "path" of a camera. In it's current
* implementation, this handler cannot guarantee the final view matrix is correct; it is
* conceivable that the matrix may be one frame off. Eh--not a big deal! :)
* TODO: Write the file as we go, not when it's all done.
* TODO: Create an osgviewer on-screen indication that animation is taking place.
*/
class OSGVIEWER_EXPORT RecordCameraPathHandler : public osgGA::GUIEventHandler
{
public:
RecordCameraPathHandler(const std::string &filename = "saved_animation.path");
void setKeyEventToggleRecord(int key) { _keyEventToggleRecord = key; }
int getKeyEventToggleRecord() const { return _keyEventToggleRecord; }
void setKeyEventTogglePlayback(int key) { _keyEventTogglePlayback = key; }
int getKeyEventTogglePlayback() const { return _keyEventTogglePlayback; }
void setAutoIncrementFilename( bool autoinc = true ) { _autoinc = autoinc?0:-1; }
virtual void getUsage(osg::ApplicationUsage &usage) const;
bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa);
protected:
std::string _filename;
int _autoinc;
std::ofstream _fout;
int _keyEventToggleRecord;
int _keyEventTogglePlayback;
bool _currentlyRecording;
bool _currentlyPlaying;
double _interval;
double _delta;
osg::Timer_t _animStartTime;
osg::Timer_t _lastFrameTime;
osg::ref_ptr<osg::AnimationPath> _animPath;
osg::ref_ptr<osgGA::AnimationPathManipulator> _animPathManipulator;
osg::ref_ptr<osgGA::MatrixManipulator> _oldManipulator;
};
/** Event handler for increase/decreasing LODScale.*/
class OSGVIEWER_EXPORT LODScaleHandler : public osgGA::GUIEventHandler
{
public:
LODScaleHandler();
void setKeyEventIncreaseLODScale(int key) { _keyEventIncreaseLODScale = key; }
int getKeyEventIncreaseLODScale() const { return _keyEventIncreaseLODScale; }
void setKeyEventDecreaseLODScale(int key) { _keyEventDecreaseLODScale = key; }
int getKeyEventDecreaseLODScale() const { return _keyEventDecreaseLODScale; }
bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);
/** Get the keyboard and mouse usage of this manipulator.*/
virtual void getUsage(osg::ApplicationUsage& usage) const;
protected:
int _keyEventIncreaseLODScale;
int _keyEventDecreaseLODScale;
};
/** Event handler that will capture the screen on key press. */
class OSGVIEWER_EXPORT ScreenCaptureHandler : public osgGA::GUIEventHandler
{
public:
/** Abstract base class for what to do when a screen capture happens. */
class CaptureOperation : public osg::Referenced
{
public:
virtual void operator()(const osg::Image& image, const unsigned int context_id) = 0;
};
/** Concrete implementation of a CaptureOperation that writes the screen capture to a file. */
class OSGVIEWER_EXPORT WriteToFile : public CaptureOperation
{
public:
enum SavePolicy
{
OVERWRITE,
SEQUENTIAL_NUMBER
// ... any others?
};
WriteToFile(const std::string& filename, const std::string& extension, SavePolicy savePolicy = OVERWRITE);
virtual void operator()(const osg::Image& image, const unsigned int context_id);
void setSavePolicy(SavePolicy savePolicy) { _savePolicy = savePolicy; }
SavePolicy getSavePolicy() const { return _savePolicy; }
protected:
const std::string _filename;
const std::string _extension;
SavePolicy _savePolicy;
std::vector<unsigned int> _contextSaveCounter;
};
ScreenCaptureHandler(CaptureOperation* defaultOperation = 0);
void setKeyEventTakeScreenShot(int key) { _keyEventTakeScreenShot = key; }
int getKeyEventTakeScreenShot() const { return _keyEventTakeScreenShot; }
void setCaptureOperation(CaptureOperation* operation);
CaptureOperation* getCaptureOperation() const;
// aa will point to an osgViewer::View, so we will take a screenshot
// of that view's graphics contexts.
bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);
/** Get the keyboard and mouse usage of this manipulator.*/
virtual void getUsage(osg::ApplicationUsage& usage) const;
protected:
int _keyEventTakeScreenShot;
// there could be a key to start taking screenshots every new frame
osg::ref_ptr<CaptureOperation> _operation;
osg::ref_ptr<osg::Camera::DrawCallback> _callback;
void addCallbackToViewer(osgViewer::ViewerBase& viewer);
};
/** InteractiveImage is an event handler that computes the mouse coordinates in an images coordinate frame
* and then passes keyboard and mouse events to it. This event handler is useful for vnc or browser
* surfaces in the 3D scene.*/
class OSGVIEWER_EXPORT InteractiveImageHandler : public osgGA::GUIEventHandler
{
public:
InteractiveImageHandler(osg::Image* image):
_image(image) {}
virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa, osg::Object*, osg::NodeVisitor* nv);
protected:
virtual ~InteractiveImageHandler() {}
bool mousePosition(osgViewer::View* view, osg::NodeVisitor* nv, const osgGA::GUIEventAdapter& ea, int& x, int &y) const;
osg::observer_ptr<osg::Image> _image;
};
}
#endif
Reference in New Issue View Git Blame Copy Permalink