152 lines
4.5 KiB
Plaintext
152 lines
4.5 KiB
Plaintext
//C++ header - Open Scene Graph Simulation - Copyright (C) 1998-2002 Robert Osfield
|
|
// Distributed under the terms of the GNU General Public License (GPL)
|
|
// as published by the Free Software Foundation.
|
|
//
|
|
// All software using osgSim must be GPL'd or excempted via the
|
|
// purchase of the Open Scene Graph Professional License (OSGPL)
|
|
// for further information contact robert@openscenegraph.com.
|
|
|
|
#ifndef OSGSIM_BLINKSQUENCE
|
|
#define OSGSIM_BLINKSQUENCE 1
|
|
|
|
#include <osgSim/Export>
|
|
|
|
#include <osg/Quat>
|
|
#include <osg/Vec3>
|
|
#include <osg/Vec4>
|
|
#include <osg/ref_ptr>
|
|
|
|
#include <vector>
|
|
|
|
namespace osgSim {
|
|
|
|
class OSGSIM_EXPORT BlinkSequence : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
/** sequence group which can be used to synchronize related blink sequences.*/
|
|
class OSGSIM_EXPORT SequenceGroup : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
SequenceGroup();
|
|
SequenceGroup(double baseTime);
|
|
|
|
double _baseTime;
|
|
};
|
|
|
|
|
|
BlinkSequence();
|
|
|
|
BlinkSequence(const BlinkSequence& bs);
|
|
|
|
|
|
/** add a pulse of specified color and duration to the BlinkSequence.*/
|
|
inline void addPulse(double length,const osg::Vec4& color);
|
|
|
|
/** get the total pulse period of the blink sequence, which is equal to the sum of all the pulse periods.*/
|
|
inline double getPulsePeriod() const { return _pulsePeriod; }
|
|
|
|
/** set the sequence group which can be used to synchronize related blink sequences.*/
|
|
inline void setSequenceGroup(SequenceGroup* sg) { _sequenceGroup = sg; }
|
|
|
|
/** get the non const sequence group.*/
|
|
inline SequenceGroup* getSequenceGroup() { return _sequenceGroup.get(); }
|
|
|
|
/** get the const sequence group.*/
|
|
inline const SequenceGroup* getSequenceGroup() const { return _sequenceGroup.get(); }
|
|
|
|
/** set the phase shift of the blink sequence, this would be used to shift a sequence within a sequence group.*/
|
|
inline void setPhaseShift(double ps) { _phaseShift = ps; }
|
|
|
|
/** get the pahse shift.*/
|
|
inline double getPhaseShift() const { return _phaseShift; }
|
|
|
|
|
|
|
|
/** compute the local time clamped to this BlinkSequences period, and accounting for the phase shift and sequence group.*/
|
|
inline double localTime(double time) const;
|
|
|
|
/** compute the color for the time interval sepecifed. Averages the colors if the length is greater than the current pulse.*/
|
|
inline osg::Vec4 color(double time,double length) const;
|
|
|
|
|
|
protected:
|
|
|
|
|
|
typedef std::pair<double,osg::Vec4> IntervalColor;
|
|
typedef std::vector<IntervalColor> PulseData;
|
|
|
|
double _pulsePeriod;
|
|
double _phaseShift;
|
|
PulseData _pulseData;
|
|
osg::ref_ptr<SequenceGroup> _sequenceGroup;
|
|
};
|
|
|
|
|
|
inline double BlinkSequence::localTime(double time) const
|
|
{
|
|
if (_sequenceGroup.valid()) time -= _sequenceGroup->_baseTime;
|
|
time -= _phaseShift;
|
|
return time - floor(time/_pulsePeriod)*_pulsePeriod;
|
|
}
|
|
|
|
inline void BlinkSequence::addPulse(double length,const osg::Vec4& color)
|
|
{
|
|
_pulseData.push_back(IntervalColor(length,color));
|
|
_pulsePeriod += length;
|
|
}
|
|
|
|
inline osg::Vec4 BlinkSequence::color(double time,double length) const
|
|
{
|
|
if (_pulseData.empty()) return osg::Vec4(1.0f,1.0f,1.0f,1.0f);
|
|
double lt = localTime(time);
|
|
PulseData::const_iterator itr = _pulseData.begin();
|
|
|
|
// find the first sample at this time point.
|
|
while (lt>itr->first)
|
|
{
|
|
lt -= itr->first;
|
|
++itr;
|
|
if (itr==_pulseData.end()) itr = _pulseData.begin();
|
|
}
|
|
|
|
// if time interval fits inside the current pulse
|
|
// then simply return this pulses color value.
|
|
if (lt+length<=itr->first)
|
|
{
|
|
return itr->second;
|
|
}
|
|
|
|
// time length exceeds the current pulse therefore
|
|
// we have to average out the pules to get the correct
|
|
// results...
|
|
|
|
// accumulate final part of the first active pulses.
|
|
osg::Vec4 color(itr->second*(itr->first-lt));
|
|
double len = length-(itr->first-lt);
|
|
++itr;
|
|
if (itr==_pulseData.end()) itr = _pulseData.begin();
|
|
|
|
// accumulate all the whole pluses pulses.
|
|
while (len>itr->first)
|
|
{
|
|
len -= itr->first;
|
|
color += itr->second*itr->first;
|
|
++itr;
|
|
if (itr==_pulseData.end()) itr = _pulseData.begin();
|
|
}
|
|
|
|
// add remaining part of the final pulse.
|
|
color += itr->second*len;
|
|
|
|
// normalise the time waited color.
|
|
color /= length;
|
|
|
|
return color;
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|