Thanks John, changes all look good. I change the scope of the if(resetPosition) so it encompassed the creation of the dummEvent as there was no need to create this unless it was used in the home(..) call. Cheers, Robert. p.s. I was wondering if you were "Jan Peciva" as of previous submission but I'm I wasn't 100% sure ;-)
On Mon, Jan 18, 2010 at 5:35 PM, PCJohn <[email protected]> wrote: > Dear Robert, > > I am sending one more improvement (separately from Inventor plugin). > I found very useful to have a control whether osgView::setCameraManipulator > does or does not reset camera to home position. > > I extended method signature as follows: > void setCameraManipulator(osgGA::MatrixManipulator* manipulator, bool > resetPosition = true); > > keeping the current usage intact (default parameter), while enabling user to > disable the position reset. That can be useful in the situation when > manipulator position was already loaded, for example from a file (user > specification), or defined any other way, while we do not want to be reset > to home position. Other usability is usage of two manipulators in a modeling > program (orbiting around the model, walking on the model) and changing > between them while we want to preserve the position of a camera in the > change. Games may benefit from it as well when we change from user-defined > helicopter manipulator to soldier manipulator because the user escaped the > helicopter. The camera will change manipulator but the position is expected > to be kept in the transition (provided that user makes the state transition > between the two manipulators himself). > > Please, let me know, if the improvement is ok. It is the small change but I > found it very useful and no straightforward workaround. > John > > > BTW: I am using OSG 2.8.2 for both submissions. > > /* -*-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_VIEW > #define OSGVIEWER_VIEW 1 > > #include <osg/View> > > #include <osgUtil/PolytopeIntersector> > #include <osgUtil/LineSegmentIntersector> > #include <osgUtil/UpdateVisitor> > #include <osgUtil/SceneView> > > #include <osgGA/MatrixManipulator> > #include <osgGA/EventVisitor> > #include <osgGA/EventQueue> > > #include <osgViewer/Scene> > #include <osgViewer/ViewerBase> > > namespace osgViewer { > > /** View holds a single view on a scene, this view may be composed of one or > more slave cameras.*/ > class OSGVIEWER_EXPORT View : public osg::View, public > osgGA::GUIActionAdapter > { > public: > > View(); > > View(const osgViewer::View& view, const osg::CopyOp& > copyop=osg::CopyOp::SHALLOW_COPY); > > META_Object(osgViewer,View); > > /** Provide a mechanism for getting the osg::View associated from the > GUIActionAdapter. > * One would use this to case view to osgViewer::View(er) if > supported by the subclass.*/ > virtual osg::View* asView() { return this; } > > /** Provide a mechanism for getting the viewer object from this > osgViewer::View. > * In the case of a osgViewer::Viewer the ViewerBase will > effectively point to this object as Viewer subclasses from View. > * In the case of a osgViewer::CompsoiteViewer the ViewerBase will > point to the CompositeViewer that owns this View. */ > ViewerBase* getViewerBase() { return _viewerBase.get(); } > > /** Take all the settings, Camera and Slaves from the passed in view, > leaving it empty. */ > virtual void take(osg::View& rhs); > > virtual void setStartTick(osg::Timer_t tick); > osg::Timer_t getStartTick() const { return _startTick; } > > Scene* getScene() { return _scene.get(); } > const Scene* getScene() const { return _scene.get(); } > > /** Set the scene graph that the View will use.*/ > virtual void setSceneData(osg::Node* node); > > /** Get the View's scene graph.*/ > osg::Node* getSceneData() { return _scene.valid() ? > _scene->getSceneData() : 0; } > > /** Get the const View's scene graph.*/ > const osg::Node* getSceneData() const { return _scene.valid() ? > _scene->getSceneData() : 0; } > > > /** Set the View's database pager.*/ > void setDatabasePager(osgDB::DatabasePager* dp); > > /** Get the View's database pager.*/ > osgDB::DatabasePager* getDatabasePager(); > > /** Get the const View's database pager.*/ > const osgDB::DatabasePager* getDatabasePager() const; > > > /** Set the View's image pager.*/ > void setImagePager(osgDB::ImagePager* ip); > > /** Get the View's image pager.*/ > osgDB::ImagePager* getImagePager(); > > /** Get the const View's image pager.*/ > const osgDB::ImagePager* getImagePager() const; > > > /* Set the EventQueue that View uses to integrate external non window > related events.*/ > void setEventQueue(osgGA::EventQueue* eventQueue) { _eventQueue = > eventQueue; } > > /* Get the View's EventQueue.*/ > osgGA::EventQueue* getEventQueue() { return _eventQueue.get(); } > > /* Get the const View's EventQueue.*/ > const osgGA::EventQueue* getEventQueue() const { return > _eventQueue.get(); } > > /** Set the CameraManipulator that moves the View's master Camera > position in response to events. > * The parameter resetPosition determines whether manipulator is set > to its home position.*/ > void setCameraManipulator(osgGA::MatrixManipulator* manipulator, bool > resetPosition = true); > > /** Get the View's CameraManipulator.*/ > osgGA::MatrixManipulator* getCameraManipulator() { return > _cameraManipulator.get(); } > > /** Get the const View's CameraManipulator.*/ > const osgGA::MatrixManipulator* getCameraManipulator() const { return > _cameraManipulator.get(); } > > /** Set the view to the CameraManipulator's home position, if non is > attached home() is does nothing. > * Note, to set the home position use > getCamaraManipulator()->setHomePosition(...). */ > void home(); > > > typedef std::list< osg::ref_ptr<osgGA::GUIEventHandler> > > EventHandlers; > > /** Add an EventHandler that adds handling of events to the View.*/ > void addEventHandler(osgGA::GUIEventHandler* eventHandler); > > /** Get the View's list of EventHandlers.*/ > EventHandlers& getEventHandlers() { return _eventHandlers; } > > /** Get the const View's list of EventHandlers.*/ > const EventHandlers& getEventHandlers() const { return > _eventHandlers; } > > > /** Set the NodePath to any active CoordinateSystemNode present in > the Scene. > * The CoordinateSystemNode path is used to help applications and > CamaraManipualtors handle geocentric coordinates systems, > * such as known which way is the local up at any position on the a > whole earth. */ > void setCoordinateSystemNodePath(const osg::NodePath& nodePath); > > /** Get the NodePath to any active CoordinateSystemNode present in > the Scene.*/ > osg::NodePath getCoordinateSystemNodePath() const; > > /** Compute the NodePath to any active CoordinateSystemNode present > in the Scene.*/ > void computeActiveCoordinateSystemNodePath(); > > > /** Set the DisplaySettings object associated with this view.*/ > void setDisplaySettings(osg::DisplaySettings* ds) { _displaySettings > = ds; } > > /** Set the DisplaySettings object associated with this view.*/ > osg::DisplaySettings* getDisplaySettings() { return > _displaySettings.get(); } > > /** Set the DisplaySettings object associated with this view.*/ > const osg::DisplaySettings* getDisplaySettings() const { return > _displaySettings.get(); } > > /** Set the FusionDistanceMode and Value. Note, is used only when > working in stereo.*/ > void setFusionDistance(osgUtil::SceneView::FusionDistanceMode > mode,float value=1.0f) > { > _fusionDistanceMode = mode; > _fusionDistanceValue = value; > } > > /** Get the FusionDistanceMode.*/ > osgUtil::SceneView::FusionDistanceMode getFusionDistanceMode() const > { return _fusionDistanceMode; } > > /** Get the FusionDistanceValue. Note, only used for > USE_FUSION_DISTANCE_VALUE & PROPORTIONAL_TO_SCREEN_DISTANCE modes.*/ > float getFusionDistanceValue() const { return _fusionDistanceValue; } > > > /** Convenience method for creating slave Cameras and associated > GraphicsWindows across all screens.*/ > void setUpViewAcrossAllScreens(); > > /** Convenience method for a single camera on a single window.*/ > void setUpViewInWindow(int x, int y, int width, int height, unsigned > int screenNum=0); > > /** Convenience method for a single camera associated with a single > full screen GraphicsWindow.*/ > void setUpViewOnSingleScreen(unsigned int screenNum=0); > > > /** Convenience method for spherical display using 6 slave cameras > rendering the 6 sides of a cube map, and 7th camera doing distortion > correction to present on a spherical display.*/ > void setUpViewFor3DSphericalDisplay(double radius=1.0, double > collar=0.45, unsigned int screenNum=0, osg::Image* intensityMap=0, const > osg::Matrixd& projectorMatrix = osg::Matrixd()); > > /** Convenience method for spherical display by rendering main scene > to as panoramic 2:1 texture and then doing distortion correction to present > onto a spherical display.*/ > void setUpViewForPanoramicSphericalDisplay(double radius=1.0, double > collar=0.45, unsigned int screenNum=0, osg::Image* intensityMap=0, const > osg::Matrixd& projectorMatrix = osg::Matrixd()); > > /** Convenience method for autostereoscopic Philips WoWvx display.*/ > void setUpViewForWoWVxDisplay(unsigned int screenNum, unsigned char > wow_content, unsigned char wow_factor, unsigned char wow_offset, float > wow_disparity_Zd, float wow_disparity_vz, float wow_disparity_M, float > wow_disparity_C); > > > /** Return true if this view contains a specified camera.*/ > bool containsCamera(const osg::Camera* camera) const; > > /** Get the camera which contains the pointer position x,y specified > master cameras window/eye coords. > * Also passes back the local window coords for the graphics context > associated with the camera passed back. */ > const osg::Camera* getCameraContainingPosition(float x, float y, > float& local_x, float& local_y) const; > > /** Compute intersections between a ray through the specified master > cameras window/eye coords and a specified node. > * Note, when a master cameras has slaves and no viewport itself its > coordinate frame will be in clip space i.e. -1,-1 to 1,1, > * while if its has a viewport the coordintates will be relative to > its viewport dimensions. > * Mouse events handled by the view will automatically be attached > into the master camera window/clip coords so can be passed > * directly on to the computeIntersections method. */ > bool computeIntersections(float x,float y, > osgUtil::LineSegmentIntersector::Intersections& > intersections,osg::Node::NodeMask traversalMask = 0xffffffff); > > /** Compute intersections between a ray through the specified master > cameras window/eye coords and a specified nodePath's subgraph. */ > bool computeIntersections(float x,float y, const osg::NodePath& > nodePath, osgUtil::LineSegmentIntersector::Intersections& > intersections,osg::Node::NodeMask traversalMask = 0xffffffff); > > > virtual void requestRedraw(); > virtual void requestContinuousUpdate(bool needed=true); > virtual void requestWarpPointer(float x,float y); > > public: > > void assignSceneDataToCameras(); > void init(); > > protected: > > friend class CompositeViewer; > > virtual ~View(); > > virtual osg::GraphicsOperation* createRenderer(osg::Camera* camera); > > osg::observer_ptr<ViewerBase> _viewerBase; > > > osg::Timer_t _startTick; > > osg::ref_ptr<osgViewer::Scene> _scene; > osg::ref_ptr<osgGA::EventQueue> _eventQueue; > osg::ref_ptr<osgGA::MatrixManipulator> _cameraManipulator; > EventHandlers _eventHandlers; > > typedef std::vector< osg::observer_ptr<osg::Node> > > ObserverNodePath; > ObserverNodePath _coordinateSystemNodePath; > > osg::ref_ptr<osg::DisplaySettings> _displaySettings; > osgUtil::SceneView::FusionDistanceMode _fusionDistanceMode; > float _fusionDistanceValue; > }; > > } > > #endif > > _______________________________________________ > osg-submissions mailing list > [email protected] > http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org > > _______________________________________________ osg-submissions mailing list [email protected] http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
