root/OpenSceneGraph/trunk/include/osg/AnimationPath @ 8768

Revision 8768, 11.2 kB (checked in by robert, 6 years ago)

From Erik van Dekker,

"I made several modifications:


  • The cause of my errors was that my OSG source directory path contains spaces. To fix this issue I wrapped all paths with quotes, as stated in doxygen documentation.


  • I also received some warning messages about deprecated doxygen settings, which I fixed by updating the doxygen file, i.e. running \u2018doxygen \u2013u doxygen.cmake\u2018. By running this command deprecated doxygen options are removed, some option comments have changed and quite some options have been added (I kept their default settings unless mentioned).


  • I was surprised to find that the doxygen OUTPUT_DIRECTORY was set to \u201c${OpenSceneGraph_SOURCE_DIR}/doc\u201d, which does not seem appropriate for out of source builds; I changed this to \u201c${OpenSceneGraph_BINARY_DIR}/doc\u201d. (On the other hand, maybe a cmake selectable option should be given to the user?)


  • Fixed two warnings I received about unexpected end-of-list-markers in \u2018osg\AnimationPath? and \u2018osgUtil\CullVisitor? due to excess trailing points in comments.


  • Fixed a warning in osgWidget\StyleInterface? due to an #include directive (strangely) placed inside a namespace.


  • Fixed a warning in osg\Camera due to the META_Object macro that confused doxygen. Adding a semi-colon fixed this.


  • Removed auto_Mainpage from the INCLUDE option, because I am positive that this file does not belong there; It never generated useful documentation anyway.


  • I added the OSG version number environment variable to the PROJECT_NUMBER option so that the version number is now shown on the main page of generated documentation (e.g. index.html).


  • Changed option FULL_PATH_NAMES to YES, but made sure STRIP_FROM_PATH stripped the absolute path until the include dir. This fixed an issue that created mangled names for identical filenames in different directories. E.g. osg/Export and osgDB/Export are now correctly named.


  • Changed option SHOW_DIRECTORIES to yes, which is a case of preference I guess.

"

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
2 *
3 * This library is open source and may be redistributed and/or modified under 
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12*/
13
14#ifndef OSG_ANIMATIONPATH
15#define OSG_ANIMATIONPATH 1
16
17#include <map>
18#include <istream>
19#include <float.h>
20
21#include <osg/Matrixf>
22#include <osg/Matrixd>
23#include <osg/Quat>
24#include <osg/NodeCallback>
25
26namespace osg {
27
28/** AnimationPath encapsulates a time varying transformation pathway. Can be
29  * used for updating camera position and model object position.
30  * AnimationPathCallback can be attached directly to Transform nodes to
31  * move subgraphs around the scene.
32*/
33class OSG_EXPORT AnimationPath : public virtual osg::Object
34{
35    public:
36   
37        AnimationPath():_loopMode(LOOP) {}
38
39        AnimationPath(const AnimationPath& ap, const CopyOp& copyop=CopyOp::SHALLOW_COPY):
40            Object(ap,copyop),
41            _timeControlPointMap(ap._timeControlPointMap),
42            _loopMode(ap._loopMode) {}
43
44        META_Object(osg,AnimationPath);
45
46        class ControlPoint
47        {
48        public:
49            ControlPoint():
50                _scale(1.0,1.0,1.0) {}
51
52            ControlPoint(const osg::Vec3d& position):
53                _position(position),
54                _rotation(),
55                _scale(1.0,1.0,1.0) {}
56
57            ControlPoint(const osg::Vec3d& position, const osg::Quat& rotation):
58                _position(position),
59                _rotation(rotation),
60                _scale(1.0,1.0,1.0) {}
61
62            ControlPoint(const osg::Vec3d& position, const osg::Quat& rotation, const osg::Vec3d& scale):
63                _position(position),
64                _rotation(rotation),
65                _scale(scale) {}
66       
67            void setPosition(const osg::Vec3d& position) { _position = position; }
68            const osg::Vec3d& getPosition() const { return _position; }
69
70            void setRotation(const osg::Quat& rotation) { _rotation = rotation; }
71            const osg::Quat& getRotation() const { return _rotation; }
72
73            void setScale(const osg::Vec3d& scale) { _scale = scale; }
74            const osg::Vec3d& getScale() const { return _scale; }
75
76            inline void interpolate(float ratio,const ControlPoint& first, const ControlPoint& second)
77            {
78                float one_minus_ratio = 1.0f-ratio;
79                _position = first._position*one_minus_ratio + second._position*ratio;
80                _rotation.slerp(ratio,first._rotation,second._rotation);
81                _scale = first._scale*one_minus_ratio + second._scale*ratio;
82            }
83           
84            inline void interpolate(double ratio,const ControlPoint& first, const ControlPoint& second)
85            {
86                double one_minus_ratio = 1.0f-ratio;
87                _position = first._position*one_minus_ratio + second._position*ratio;
88                _rotation.slerp(ratio,first._rotation,second._rotation);
89                _scale = first._scale*one_minus_ratio + second._scale*ratio;
90            }
91
92            inline void getMatrix(Matrixf& matrix) const
93            {
94                matrix.makeScale(_scale);
95                matrix.postMult(osg::Matrixf::rotate(_rotation));
96                matrix.postMult(osg::Matrixf::translate(_position));
97            }
98
99            inline void getMatrix(Matrixd& matrix) const
100            {
101                matrix.makeScale(_scale);
102                matrix.postMult(osg::Matrixd::rotate(_rotation));
103                matrix.postMult(osg::Matrixd::translate(_position));
104            }
105
106            inline void getInverse(Matrixf& matrix) const
107            {
108                matrix.makeScale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z());
109                matrix.preMult(osg::Matrixf::rotate(_rotation.inverse()));
110                matrix.preMult(osg::Matrixf::translate(-_position));
111            }
112
113            inline void getInverse(Matrixd& matrix) const
114            {
115                matrix.makeScale(1.0/_scale.x(),1.0/_scale.y(),1.0/_scale.z());
116                matrix.preMult(osg::Matrixd::rotate(_rotation.inverse()));
117                matrix.preMult(osg::Matrixd::translate(-_position));
118            }
119
120        protected:
121
122            osg::Vec3d _position;
123            osg::Quat _rotation;
124            osg::Vec3d _scale;
125
126        };
127       
128
129        /** Given a specific time, return the transformation matrix for a point. */
130        bool getMatrix(double time,Matrixf& matrix) const
131        {
132            ControlPoint cp;
133            if (!getInterpolatedControlPoint(time,cp)) return false;
134            cp.getMatrix(matrix);
135            return true;
136        }
137
138        /** Given a specific time, return the transformation matrix for a point. */
139        bool getMatrix(double time,Matrixd& matrix) const
140        {
141            ControlPoint cp;
142            if (!getInterpolatedControlPoint(time,cp)) return false;
143            cp.getMatrix(matrix);
144            return true;
145        }
146
147        /** Given a specific time, return the inverse transformation matrix for a point. */
148        bool getInverse(double time,Matrixf& matrix) const
149        {
150            ControlPoint cp;
151            if (!getInterpolatedControlPoint(time,cp)) return false;
152            cp.getInverse(matrix);
153            return true;
154        }
155       
156        bool getInverse(double time,Matrixd& matrix) const
157        {
158            ControlPoint cp;
159            if (!getInterpolatedControlPoint(time,cp)) return false;
160            cp.getInverse(matrix);
161            return true;
162        }
163
164        /** Given a specific time, return the local ControlPoint frame for a point. */
165        virtual bool getInterpolatedControlPoint(double time,ControlPoint& controlPoint) const;
166       
167        /** Insert a control point into the AnimationPath.*/
168        void insert(double time,const ControlPoint& controlPoint);
169       
170        double getFirstTime() const { if (!_timeControlPointMap.empty()) return _timeControlPointMap.begin()->first; else return 0.0;}
171        double getLastTime() const { if (!_timeControlPointMap.empty()) return _timeControlPointMap.rbegin()->first; else return 0.0;}
172        double getPeriod() const { return getLastTime()-getFirstTime();}
173       
174        enum LoopMode
175        {
176            SWING,
177            LOOP,
178            NO_LOOPING
179        };
180       
181        void setLoopMode(LoopMode lm) { _loopMode = lm; }
182       
183        LoopMode getLoopMode() const { return _loopMode; }
184
185
186        typedef std::map<double,ControlPoint> TimeControlPointMap;
187       
188        void setTimeControlPointMap(TimeControlPointMap& tcpm) { _timeControlPointMap=tcpm; }
189
190        TimeControlPointMap& getTimeControlPointMap() { return _timeControlPointMap; }
191       
192        const TimeControlPointMap& getTimeControlPointMap() const { return _timeControlPointMap; }
193       
194        bool empty() const { return _timeControlPointMap.empty(); }
195       
196        void clear() { _timeControlPointMap.clear(); }
197
198        /** Read the animation path from a flat ASCII file stream. */
199        void read(std::istream& in);
200
201        /** Write the animation path to a flat ASCII file stream. */
202        void write(std::ostream& out) const;
203
204        /** Write the control point to a flat ASCII file stream. */
205        void write(TimeControlPointMap::const_iterator itr, std::ostream& out) const;
206
207    protected:
208   
209        virtual ~AnimationPath() {}
210
211        TimeControlPointMap _timeControlPointMap;
212        LoopMode            _loopMode;
213
214};
215
216
217class OSG_EXPORT AnimationPathCallback : public NodeCallback
218{
219    public:
220
221        AnimationPathCallback():
222            _pivotPoint(0.0,0.0,0.0),
223            _useInverseMatrix(false),
224            _timeOffset(0.0),
225            _timeMultiplier(1.0),
226            _firstTime(DBL_MAX),
227            _latestTime(0.0),
228            _pause(false),
229            _pauseTime(0.0) {}
230
231        AnimationPathCallback(const AnimationPathCallback& apc,const CopyOp& copyop):
232            NodeCallback(apc,copyop),
233            _animationPath(apc._animationPath),
234            _pivotPoint(apc._pivotPoint),
235            _useInverseMatrix(apc._useInverseMatrix),
236            _timeOffset(apc._timeOffset),
237            _timeMultiplier(apc._timeMultiplier),
238            _firstTime(apc._firstTime),
239            _latestTime(apc._latestTime),
240            _pause(apc._pause),
241            _pauseTime(apc._pauseTime) {}
242
243       
244        META_Object(osg,AnimationPathCallback);
245
246        /** Construct an AnimationPathCallback with a specified animation path.*/
247        AnimationPathCallback(AnimationPath* ap,double timeOffset=0.0,double timeMultiplier=1.0):
248            _animationPath(ap),
249            _pivotPoint(0.0,0.0,0.0),
250            _useInverseMatrix(false),
251            _timeOffset(timeOffset),
252            _timeMultiplier(timeMultiplier),
253            _firstTime(DBL_MAX),
254            _latestTime(0.0),
255            _pause(false),
256            _pauseTime(0.0) {}
257
258        /** Construct an AnimationPathCallback and automatical create an animation path to produce a rotation about a point.*/
259        AnimationPathCallback(const osg::Vec3d& pivot,const osg::Vec3d& axis,float angularVelocity);
260 
261           
262        void setAnimationPath(AnimationPath* path) { _animationPath = path; }
263        AnimationPath* getAnimationPath() { return _animationPath.get(); }
264        const AnimationPath* getAnimationPath() const { return _animationPath.get(); }
265
266        inline void setPivotPoint(const Vec3d& pivot) { _pivotPoint = pivot; }
267        inline const Vec3d& getPivotPoint() const { return _pivotPoint; }
268
269        void setUseInverseMatrix(bool useInverseMatrix) { _useInverseMatrix = useInverseMatrix; }
270        bool getUseInverseMatrix() const { return _useInverseMatrix; }
271
272        void setTimeOffset(double offset) { _timeOffset = offset; }
273        double getTimeOffset() const { return _timeOffset; }
274       
275        void setTimeMultiplier(double multiplier) { _timeMultiplier = multiplier; }
276        double getTimeMultiplier() const { return _timeMultiplier; }
277
278
279        void reset();
280
281        void setPause(bool pause);
282        bool getPause() const { return _pause; }
283
284        /** Get the animation time that is used to specify the position along
285          * the AnimationPath. Animation time is computed from the formula:
286          *   ((_latestTime-_firstTime)-_timeOffset)*_timeMultiplier.*/
287        double getAnimationTime() const;
288
289        /** Implements the callback. */
290        virtual void operator()(Node* node, NodeVisitor* nv);
291       
292        void update(osg::Node& node);
293
294    public:
295
296        ref_ptr<AnimationPath>  _animationPath;
297        osg::Vec3d              _pivotPoint;
298        bool                    _useInverseMatrix;
299        double                  _timeOffset;
300        double                  _timeMultiplier;
301        double                  _firstTime;
302        double                  _latestTime;
303        bool                    _pause;
304        double                  _pauseTime;
305
306    protected:
307   
308        ~AnimationPathCallback(){}
309
310};
311
312}
313
314#endif
Note: See TracBrowser for help on using the browser.