Category

Development Platform
Home > SourceCode/Document > Graph program > OpenGL program > View Code
timelinephase.h
Package: celestia-1.6.0.tar.gz　[view]
Upload User: center1979
Upload Date: 2022-07-26
Package Size: 50633k
Code Size: 3k
Category:

OpenGL program

Development Platform:

Visual C++

timelinephase.h：Code Content
  1. // timelinephase.h
  2. //
  3. // Object timeline phase
  4. //
  5. // Copyright (C) 2008, the Celestia Development Team
  6. // Initial version by Chris Laurel, claurel@gmail.com
  7. //
  8. // This program is free software; you can redistribute it and/or
  9. // modify it under the terms of the GNU General Public License
  10. // as published by the Free Software Foundation; either version 2
  11. // of the License, or (at your option) any later version.
  13. #ifndef _CELENGINE_TIMELINEPHASE_H_
  14. #define _CELENGINE_TIMELINEPHASE_H_
  16. class ReferenceFrame;
  17. class Orbit;
  18. class RotationModel;
  19. class FrameTree;
  20. class Universe;
  21. class Body;
  24. class TimelinePhase
  25. {
  26. public:
  27.     int addRef() const;
  28.     int release() const;
  30.     Body* body() const
  31.     {
  32.         return m_body;
  33.     }
  35.     double startTime() const
  36.     {
  37.         return m_startTime;
  38.     }
  40.     double endTime() const
  41.     {
  42.         return m_endTime;
  43.     }
  45.     ReferenceFrame* orbitFrame() const
  46.     {
  47.         return m_orbitFrame;
  48.     }
  50.     Orbit* orbit() const
  51.     {
  52.         return m_orbit;
  53.     }
  55.     ReferenceFrame* bodyFrame() const
  56.     {
  57.         return m_bodyFrame;
  58.     }
  60.     RotationModel* rotationModel() const
  61.     {
  62.         return m_rotationModel;
  63.     }
  65.     /*! Get the frame tree that contains this phase (always the tree associated
  66.      *  with the center of the orbit frame.)
  67.      */
  68.     FrameTree* getFrameTree() const
  69.     {
  70.         return m_owner;
  71.     }
  73.     /*! Check whether the specified time t lies within this phase. True if
  74.      *  startTime <= t < endTime
  75.      */
  76.     bool includes(double t) const
  77.     {
  78.         return m_startTime <= t && t < m_endTime;
  79.     }
  81.     static TimelinePhase* CreateTimelinePhase(Universe& universe,
  82.                                               Body* body,
  83.                                               double startTime,
  84.                                               double endTime,
  85.                                               ReferenceFrame& orbitFrame,
  86.                                               Orbit& orbit,
  87.                                               ReferenceFrame& bodyFrame,
  88.                                               RotationModel& rotationModel);
  90. private:
  91.     // Private constructor; phases can only created with the
  92.     // createTimelinePhase factory method.
  93.     TimelinePhase(Body* _body,
  94.                   double _startTime,
  95.                   double _endTime,
  96.                   ReferenceFrame* _orbitFrame,
  97.                   Orbit* _orbit,
  98.                   ReferenceFrame* _bodyFrame,
  99.                   RotationModel* _rotationModel,
  100.                   FrameTree* _owner);
  102.     // Private copy constructor and assignment operator; should never be used.
  103.     TimelinePhase(const TimelinePhase& phase);
  104.     TimelinePhase& operator=(const TimelinePhase& phase);
  106.     // TimelinePhases are refCounted; use release() instead.
  107.     ~TimelinePhase();
  109. private:
  110.     Body* m_body;
  112.     double m_startTime;
  113.     double m_endTime;
  115.     ReferenceFrame* m_orbitFrame;
  116.     Orbit* m_orbit;
  117.     ReferenceFrame* m_bodyFrame;
  118.     RotationModel* m_rotationModel;
  120.     FrameTree* m_owner;
  122.     mutable int refCount;
  123. };
  125. #endif // _CELENGINE_TIMELINEPHASE_H_