GL Studio C++ Runtime API
gls_moving_eye.h
Go to the documentation of this file.
1 /*! \file
2  \brief The disti::GlsMovingEye class.
3 
4  \par Copyright Information
5 
6  Copyright (c) 2017 by The DiSTI Corporation.<br>
7  11301 Corporate Blvd; Suite 100<br>
8  Orlando, Florida 32817<br>
9  USA<br>
10  <br>
11  All rights reserved.<br>
12 
13  This Software contains proprietary trade secrets of DiSTI and may not be
14 reproduced, in whole or part, in any form, or by any means of electronic,
15 mechanical, or otherwise, without the written permission of DiSTI. Said
16 permission may be derived through the purchase of applicable DiSTI product
17 licenses which detail the distribution rights of this content and any
18 Derivative Works based on this or other copyrighted DiSTI Software.
19 
20  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
21 AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
22 PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
23 AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
24 IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
25 PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
26 
27  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
28 IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
29 INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
30 DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
31 INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
32 INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
33 OF SUCH DAMAGES. DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
34 EXCEED FIVE DOLLARS (US$5.00).
35 
36  The aforementioned terms and restrictions are governed by the laws of the
37 State of Florida and the United States of America.
38 
39 */
40 #ifndef INCLUDED_GLS_MOVING_EYE_H
41 #define INCLUDED_GLS_MOVING_EYE_H
42 
43 #include <cstddef>
44 #include <queue>
45 
46 #ifdef __VXWORKS__
47 # define va_list std::va_list
48 #endif
49 
50 #include "gls_cpp_lang_support.h"
51 #include "gls_eyepoint.h"
52 
53 /// Provides support for creating DLLs
54 #if( defined( GLSGEN_EXPORT_GLSMOVINGEYE ) || defined( GLSGEN_IMPORT_GLSMOVINGEYE ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
55  && defined( _MSC_VER )
56 # if defined( GLSGEN_EXPORT_GLSMOVINGEYE ) || defined( GLS_EXPORT_GENERATED )
57 # define GLSGEN_GLSMOVINGEYE_EXPORT __declspec( dllexport )
58 # else
59 # define GLSGEN_GLSMOVINGEYE_EXPORT __declspec( dllimport )
60 # endif
61 #else
62 # define GLSGEN_GLSMOVINGEYE_EXPORT
63 #endif
64 ///////////////////////////////////////////////////////////////////////////////
65 
66 #define LIB_BASE_NAME "gls_moving_eye"
67 #include "gls_auto_lib.h"
68 #undef LIB_BASE_NAME
69 
70 namespace disti
71 {
72 // SetValue enumerations
73 enum
74 {
75  GLS_MOVINGEYE_EMIT_EVENT = GLS_EYEPOINT_VIEW_VECTORS + 1,
76  GLS_MOVINGEYE_LOOK_AT_OBJECT,
77  GLS_MOVINGEYE_MAX_SPEED,
78  GLS_MOVINGEYE_MOVEMENT,
79  GLS_MOVINGEYE_ROUTE,
80  GLS_MOVINGEYE_DISABLE_HISTORY
81 };
82 
83 //------------------------------------------------------------------------
84 /**
85 * Runtime implementation of a GlsMovingEye
86 */
87 class GlsMovingEye : public GlsEyePoint
88 {
89 private:
90  GlsMovingEye& operator=( const GlsMovingEye& ) DISTI_SPECIAL_MEM_FUN_DELETE;
91  GlsMovingEye( const GlsMovingEye& ) DISTI_SPECIAL_MEM_FUN_DELETE;
92 
93 public:
94  DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
95  typedef GlsEyePoint _BaseClass;
96  typedef GlsEyePoint BaseClass;
97 
98  /// This specifies the type of route taken from one eyepoint to another.
100  {
101  CONSTANT = 0,
102  SINUSOIDAL = 1
103  };
104 
105  /// This specifies the type of route taken from one eyepoint to another.
106  enum Route_t
107  {
108  DIRECT = 0,
109  ARC = 1
110  };
111 
112  // Name of the event emitted when a move is completed
113  static const char* MOVE_COMPLETE_EVENT_NAME;
114 
115  //------------------------------------------------------------------------
116  /**
117  * Create a new GlsMovingEye.
118  */
120 
121  GLSGEN_GLSMOVINGEYE_EXPORT GlsMovingEye( const GlsMovingEye& that, const bool generateNames );
122 
123  //------------------------------------------------------------------------
124  /**
125  * GlsMovingEyeEditor destructor
126  */
128 
129  //------------------------------------------------------------------------
130  /**
131  * Returns true if the we're at the beginning of the history of movements.
132  */
133  bool AtStartOfHistory() const
134  {
135  return _historyPos == 0;
136  }
137 
138  //------------------------------------------------------------------------
139  /**
140  * Returns true if the we're at the end of the history of movements.
141  */
142  bool AtEndOfHistory() const
143  {
144  return _historyPos == _moveHistory.size() - 1;
145  }
146 
147  //------------------------------------------------------------------------
148  /**
149  * Aborts any move currently in progress.
150  */
152 
153  virtual GLSGEN_GLSMOVINGEYE_EXPORT void SetAvailableAttributes( unsigned int value );
154 
155  //------------------------------------------------------------------------
156  /* See base class */
157  virtual GLSGEN_GLSMOVINGEYE_EXPORT void Calculate( double time );
158 
159  //------------------------------------------------------------------------
160  /* See base class */
163  CloneObject( bool generateNames = false );
164 
165  //------------------------------------------------------------------------
166  /* See base class */
168 
169  //------------------------------------------------------------------------
170  /**
171  * Creates a new, blank GlsMovingEye object.
172  * \return DisplayObject type pointer to the new GlsMovingEye.
173  */
175 
176  //------------------------------------------------------------------------
177  /* See base class */
178  virtual GLSGEN_GLSMOVINGEYE_EXPORT void Draw();
179 
180  //------------------------------------------------------------------------
181  /**
182  * Returns whether or not an event is emitted upon completion of a
183  * commanded movement.
184  */
185  bool EmitEvent() const { return _emitEvent; }
186 
187  //------------------------------------------------------------------------
188  /**
189  * Sets whether or not an event is emitted upon completion of a
190  * commanded movement.
191  */
192  void EmitEvent( bool emitEvent );
193 
194  //------------------------------------------------------------------------
195  /**
196  * Returns whether or not an the move history is disabled.
197  */
198  bool DisableMoveHistory() const { return _disableMoveHistory; }
199 
200  //------------------------------------------------------------------------
201  /**
202  * Sets whether or not the move history is disabled.
203  */
204  void DisableMoveHistory( bool his );
205 
206  //------------------------------------------------------------------------
207  /* See base class */
209 
210 #ifndef GLES
211  //------------------------------------------------------------------------
212  /* See base class */
216  InterfaceListType* addToThisList = 0 );
217 
218  //------------------------------------------------------------------------
219  /* See base class */
221 #endif
222  //------------------------------------------------------------------------
223  /**
224  * \return The name of the object that the eyepoint should be always
225  * looking at.
226  * Lifetime is guaranteed to coincide with the GlsMovingEye's lifetime
227  * or until LookAtObject is changed.
228  */
229  const std::string& LookAtObject() const { return _lookAtObject; }
230 
231  //------------------------------------------------------------------------
232  /**
233  * Sets the name of the object that the eyepoint should be always
234  * looking at.
235  */
236  void LookAtObject( const std::string& name );
237 
238  //------------------------------------------------------------------------
239  /**
240  * Returns the maximum speed in logical units/second which will
241  * be used to achive the transition between eyepoints.
242  */
243  float MaxSpeed() const { return _maxSpeed; }
244 
245  //------------------------------------------------------------------------
246  /**
247  * Sets the maximum speed in logical units/second which will
248  * be used to achive the transition between eyepoints.
249  */
250  void MaxSpeed( float speed );
251 
252  //------------------------------------------------------------------------
253  /**
254  * Returns the type of movement algorithm to use when moving to another
255  * eyepoint.
256  */
257  Movement_t Movement() const { return _movement; }
258 
259  //------------------------------------------------------------------------
260  /**
261  * Sets the type of movement algorithm to use when moving to another
262  * eyepoint.
263  */
264  void Movement( Movement_t movementType );
265 
266  //------------------------------------------------------------------------
267  /**
268  * Moves this eyepoint to the previously set eyepoint. If a move is
269  * already in progress, it will be immediately stopped, and this move
270  * will start.
271  */
273 
274  //------------------------------------------------------------------------
275  /**
276  * Moves this eyepoint to the eyepoint which was last achieved from a
277  * MoveBack(). If a move is already in progress, it will be immediately
278  * stopped, and this move will start.
279  */
281 
282  //------------------------------------------------------------------------
283  /**
284  * Causes this eye to move from its current state to the state specified
285  * by the targetEye. It will take moveTime to get there. If a move is
286  * already in progress, it will be immediately stopped, and this move
287  * will start.
288  */
290  void MoveToEye( GlsEyePoint* eye, float moveTime = 2.0f );
291 
292  //------------------------------------------------------------------------
293  /**
294  * Causes the eye to move from its current state to each eyepoint in the
295  * specified group ending with the last eye in the group. If a move is
296  * already in progress, it will be immediately stopped, and this move
297  * will start.
298  */
300  void MoveToEye( Group* eyeGroup, float moveTime = 2.0f );
301 
302  //------------------------------------------------------------------------
303  /**
304  * Causes the specified eye to be added to the end of the list of eyes
305  * which should be moved through.
306  */
308  void MoveToEyeAdd( GlsEyePoint* eye, float moveTime = 2.0f );
309 
310  //------------------------------------------------------------------------
311  /**
312  * Causes the specified eyes to be added to the end of the list of eyes
313  * which should be moved through.
314  */
316  void MoveToEyeAdd( Group* eyeGroup, float moveTime = 2.0f );
317 
318  //------------------------------------------------------------------------
319  /**
320  * Causes this eye to move to the specified location in the scene without
321  * modifying the view direction or any other eye specific information.
322  */
324  void MoveToLocation( const Vector& location, float moveTime = 2.0f );
325 
326  //------------------------------------------------------------------------
327  /**
328  * Moves the eyepoint in view-relative coordinates by the specified amount,
329  * over the specified time. The units are in relative screen coordinates:
330  * X and Y are pixels, Z is 0->1. See WindowToLogical() or
331  * LogicalToWindow().
332  */
334  const Vector& moveAmount,
335  const Vector& rotation );
336 
337  //------------------------------------------------------------------------
338  /**
339  * Returns the type of route to use when moving to another eyepoint.
340  */
341  Route_t Route() const { return _route; }
342 
343  //------------------------------------------------------------------------
344  /**
345  * Sets the type of route to use when moving to another eyepoint.
346  */
347  void Route( Route_t routeType );
348 
349  //------------------------------------------------------------------------
350  /* See base class */
351  GLSGEN_GLSMOVINGEYE_EXPORT virtual void SetValue( int spec, va_list& args );
352 
353 protected:
354 #ifdef GLES
355  /** Set a single attribute from the GLO file.
356  * \param data The attribute to set and its associated data.
357  */
358  GLSGEN_GLSMOVINGEYE_EXPORT virtual void SetFromGloData( GlsGloFileAttribute& data );
359 #endif
360 
361  /// Type to store eyepoint state information.
362  struct EyeState_t
363  {
364  Vector location;
365  bool orthographic;
366  double FOV;
367  double otherFOV;
368  bool fovIsHorizontal;
369  double orthoSize;
370  double otherOrthoSize;
371  double farClip;
372  double nearClip;
373  FovConstraintType horizontalConstraint;
374  FovConstraintType verticalConstraint;
375  Vector viewVectors[ 3 ];
376 
377  /** Default constructor */
378  EyeState_t();
379 
380  /** Initialize EyeState_t using targetEye parameters.
381  * \param movingEye The GlsMovingEye that the state information is for (needed for coordinate conversions)
382  * \param targetEye The GlsEyePoint to move to
383  */
384  EyeState_t( GlsMovingEye* movingEye, GlsEyePoint* targetEye );
385 
386  inline Vector Direction()
387  {
388  /* Copied from GlsEyePoint::Direction() */
389  return viewVectors[ 2 ];
390  }
391  };
392 
393  /// Type to store eyepoint movement parameters.
394  struct MoveParms_t : public EyeState_t
395  {
396  bool addToHistory;
397  double time;
398  std::string qualifiedEyeName;
399 
400  MoveParms_t(
401  bool storeHistory,
402  double moveTime,
403  GlsMovingEye* movingEye,
404  GlsEyePoint* targetEye );
405  };
406 
407  /// Whether or not to emit an event when the move has completed.
409 
410  /// This is true when a move is occurring and the route segment being
411  /// moved along is the very first one in the queue. This is used during
412  /// sinusoidal movement to smoothly speed up when starting.
414 
415  /// Current position into the history list
416  std::size_t _historyPos;
417 
418  /// Flag to keep track of when the object gets initialized.
420 
421  /// Automatically adjust the view direction to point at the specified
422  /// targetObject. This is inactivated when the string is blank.
423  /// While this is active, the move methods will not control the view
424  /// direction. They can still control the position and other eye
425  /// information.
426  std::string _lookAtObject;
427 
428  /// The last up vector provided by the user or the move code.
429  /// Used by the 'look at' algorithm to orient the eyepoint
431 
432  /// The last up vector calculated by the lookAt algorithm.
434 
435  /// Stores a history of visited eyepoints for moving back and forth.
436  std::vector<MoveParms_t> _moveHistory;
437 
438  bool _disableMoveHistory;
439 
440  /// This specifies the maximum speed in logical units / second which will
441  /// be used to achive the transition. If the requested transition cannot
442  /// occur within the requested move time without exceeding the max speed,
443  /// the move time will be longer than requested. In other words, this
444  /// limit has priority over any requested moveTime. A MaxSpeed value of
445  /// < 0.0 means the speed limit is disabled.
446  float _maxSpeed;
447 
448  /// Type of movement algorithm to use when moving to another eyepoint.
450 
451  /// Contains movement parameters for each move that should be performed.
452  /// The last one contains the final eyepoint to stop at.
453  std::queue<MoveParms_t> _moveQ;
454 
455  /// Type of route to take when moving to another eyepoint.
457 
458  /// Stores this eyepoint's current state at the start of a move and is
459  /// used in calculating movement during each execution frame.
461 
462  /// Latest known simulation time.
463  double _simTime;
464 
465  /// Simulation time that a move starts.
466  double _startTime;
467 
468  /// This specifies the up direction and is used when interpolating
469  /// movement to keep the view oriented 'correctly'.
471 
472  /// This specifies a buffer area around _upVector and -_upVector which
473  /// the moving eye will try to avoid. Setting this to non-zero avoids
474  /// flipping problems when orientation passes through _upVector or -_upVector
475  /// during moves.
477 
478  //------------------------------------------------------------------------
479  /**
480  * Calculates the direction to the named object.
481  */
482  //------------------------------------------------------------------------
483  Vector DirectionToObj( const std::string& qualifiedObjName ) const;
484 
485  //------------------------------------------------------------------------
486  /**
487  * Extracts all eyepoint objects from the group hierarchy. The group
488  * can contain other groups and object types.
489  */
490  //------------------------------------------------------------------------
491  void ExtractEyepoints( Group* group, std::vector<GlsEyePoint*>& eyes );
492 
493  //------------------------------------------------------------------------
494  /**
495  * Called when the destination eyepoint is reached to perform actions
496  * necessary to complete the movement.
497  */
498  //------------------------------------------------------------------------
499  void FinishMoving();
500 
501  //------------------------------------------------------------------------
502  /**
503  * Initializes the movement history with the initial state of the eyepoint.
504  */
505  //------------------------------------------------------------------------
506  void Initialize();
507 
508  //------------------------------------------------------------------------
509  /**
510  * Returns an adjusted move time based on the maximum speed setting. If the
511  * speed of moving over distance in desiredTime is greater than the
512  * maximum speed setting, the move time will be lengthened.
513  *
514  * \param distance: distance in logical units that will be moved.
515  * \param desiredTime: time in which we wish to cover the specified
516  * distance.
517  */
518  //------------------------------------------------------------------------
519  float MoveTime( float distance, float desiredTime ) const;
520 
521  //------------------------------------------------------------------------
522  /**
523  * Calculates the distance over the entire route if moving between all
524  * eyepoints in the list.
525  */
526  //------------------------------------------------------------------------
527  float RouteDistance( std::vector<GlsEyePoint*>& eyes ) const;
528 
529  //------------------------------------------------------------------------
530  /**
531  * Queues the move using the passed in movement parameters and sets up
532  * the start time and starting state of the move.
533  */
534  //------------------------------------------------------------------------
535  void StartMoving( const MoveParms_t& moveParms );
536 
537  /// The editor class needs to access this class' privates. :)
538  friend class GlsMovingEyeEditor;
539 };
540 
541 //----------------------------------------------------------------------------
542 inline std::ostream& operator<<( std::ostream& outstr, GlsMovingEye::Movement_t m )
543 {
544  switch( m )
545  {
546  case GlsMovingEye::CONSTANT:
547  outstr << "CONSTANT";
548  break;
549  case GlsMovingEye::SINUSOIDAL:
550  outstr << "SINUSOIDAL";
551  break;
552  default:
553  outstr << "BAD_MOVEMENT";
554  };
555 
556  return outstr;
557 }
558 
559 //----------------------------------------------------------------------------
560 inline std::istream& operator>>( std::istream& instr, GlsMovingEye::Movement_t& m )
561 {
562  std::string str;
563  instr >> str;
564  if( str == "CONSTANT" )
565  {
566  m = GlsMovingEye::CONSTANT;
567  }
568  else if( str == "SINUSOIDAL" )
569  {
570  m = GlsMovingEye::SINUSOIDAL;
571  }
572  return instr;
573 }
574 
575 //----------------------------------------------------------------------------
576 inline std::ostream& operator<<( std::ostream& outstr, GlsMovingEye::Route_t r )
577 {
578  switch( r )
579  {
580  case GlsMovingEye::DIRECT:
581  outstr << "DIRECT";
582  break;
583  case GlsMovingEye::ARC:
584  outstr << "ARC";
585  break;
586  default:
587  outstr << "BAD_ROUTE";
588  };
589 
590  return outstr;
591 }
592 
593 //----------------------------------------------------------------------------
594 inline std::istream& operator>>( std::istream& instr, GlsMovingEye::Route_t& r )
595 {
596  std::string str;
597  instr >> str;
598  if( str == "DIRECT" )
599  {
600  r = GlsMovingEye::DIRECT;
601  }
602  else if( str == "ARC" )
603  {
604  r = GlsMovingEye::ARC;
605  }
606  return instr;
607 }
608 
609 } // namespace disti
610 #endif
Vector DirectionToObj(const std::string &qualifiedObjName) const
#define DISTI_DEPRECATED(msg)
Defines whether this compiler supports the C++14 deprecated attribute.
Definition: gls_cpp_lang_support.h:436
void MoveToEye(GlsEyePoint *eye, float moveTime=2.0f)
bool AtEndOfHistory() const
Definition: gls_moving_eye.h:142
Route_t Route() const
Definition: gls_moving_eye.h:341
virtual void GetCppInterfaceDescriptionFree(InterfaceListType *array)
float _bufferAngle
Definition: gls_moving_eye.h:476
virtual ~GlsMovingEye()
Definition: dynamic_array.h:66
Movement_t Movement() const
Definition: gls_moving_eye.h:257
void StartMoving(const MoveParms_t &moveParms)
Definition: display.h:98
bool AtStartOfHistory() const
Definition: gls_moving_eye.h:133
Vector _lookAtCalculatedUpVector
The last up vector calculated by the lookAt algorithm.
Definition: gls_moving_eye.h:433
virtual InterfaceListType * GetCppInterfaceDescription(InterfaceListType *addToThisList=0)
virtual void CopyProperties(DisplayObject *src)
Movement_t
This specifies the type of route taken from one eyepoint to another.
Definition: gls_moving_eye.h:99
void ExtractEyepoints(Group *group, std::vector< GlsEyePoint * > &eyes)
bool _firstSegment
Definition: gls_moving_eye.h:413
#define GLSGEN_GLSMOVINGEYE_EXPORT
Provides support for creating DLLs.
Definition: gls_moving_eye.h:62
virtual void SetAvailableAttributes(unsigned int value)
void MoveToEyeAdd(GlsEyePoint *eye, float moveTime=2.0f)
Definition: gls_glo_file.h:982
bool DisableMoveHistory() const
Definition: gls_moving_eye.h:198
std::ostream & operator<<(std::ostream &outstr, const AttributeName &name)
Defines the stream out operator.
bool EmitEvent() const
Definition: gls_moving_eye.h:185
Vector _upVector
Definition: gls_moving_eye.h:470
Type to store eyepoint state information.
Definition: gls_moving_eye.h:362
float RouteDistance(std::vector< GlsEyePoint * > &eyes) const
virtual void SetValue(int spec, va_list &args)
The disti::GlsEyePoint class. Implements eyepoints.
Route_t _route
Type of route to take when moving to another eyepoint.
Definition: gls_moving_eye.h:456
double _simTime
Latest known simulation time.
Definition: gls_moving_eye.h:463
Definition: gls_eyepoint.h:115
float _maxSpeed
Definition: gls_moving_eye.h:446
virtual void GenerateInstanceName()
void MoveToLocation(const Vector &location, float moveTime=2.0f)
void MoveRelative(const Vector &moveAmount, const Vector &rotation)
Route_t
This specifies the type of route taken from one eyepoint to another.
Definition: gls_moving_eye.h:106
std::queue< MoveParms_t > _moveQ
Definition: gls_moving_eye.h:453
virtual DisplayObject * CloneObject(bool generateNames=false)
double _startTime
Simulation time that a move starts.
Definition: gls_moving_eye.h:466
The gls_auto_lib.
std::vector< MoveParms_t > _moveHistory
Stores a history of visited eyepoints for moving back and forth.
Definition: gls_moving_eye.h:436
Definition: group.h:52
float MaxSpeed() const
Definition: gls_moving_eye.h:243
bool _emitEvent
Whether or not to emit an event when the move has completed.
Definition: gls_moving_eye.h:408
Vector _lookAtReferenceUpVector
Definition: gls_moving_eye.h:430
Definition: vertex.h:84
std::string _lookAtObject
Definition: gls_moving_eye.h:426
const std::string & LookAtObject() const
Definition: gls_moving_eye.h:229
Movement_t _movement
Type of movement algorithm to use when moving to another eyepoint.
Definition: gls_moving_eye.h:449
float MoveTime(float distance, float desiredTime) const
virtual void Draw()
std::size_t _historyPos
Current position into the history list.
Definition: gls_moving_eye.h:416
virtual void Calculate(double time)
static DisplayObject * CreateInstance()
Definition: gls_moving_eye.h:87
Macros and helper code to determine what subset of C++11/14/17 is available.
friend class GlsMovingEyeEditor
The editor class needs to access this class' privates. :)
Definition: gls_moving_eye.h:538
bool _initialized
Flag to keep track of when the object gets initialized.
Definition: gls_moving_eye.h:419
Definition: bmpimage.h:46
Type to store eyepoint movement parameters.
Definition: gls_moving_eye.h:394
EyeState_t _start
Definition: gls_moving_eye.h:460