observer.h
上传用户:center1979
上传日期:2022-07-26
资源大小:50633k
文件大小:11k
源码类别:

OpenGL

开发平台:

Visual C++

  1. // observer.h
  2. //
  3. // Copyright (C) 2001, Chris Laurel <claurel@shatters.net>
  4. //
  5. // Because of the vastness of interstellar space, floats and doubles aren't
  6. // sufficient when we need to represent distances to millimeter accuracy.
  7. // BigFix is a high precision (128 bit) fixed point type used to represent
  8. // the position of an observer in space.  However, it's not practical to use
  9. // high-precision numbers for the positions of everything.  To get around
  10. // this problem, object positions are stored at two different scales--light
  11. // years for stars, and kilometers for objects within a star system.
  12. //
  13. // This program is free software; you can redistribute it and/or
  14. // modify it under the terms of the GNU General Public License
  15. // as published by the Free Software Foundation; either version 2
  16. // of the License, or (at your option) any later version.
  17. #ifndef _CELENGINE_OBSERVER_H_
  18. #define _CELENGINE_OBSERVER_H_
  19. #include <celengine/frame.h>
  20. class ObserverFrame
  21. {
  22. public:
  23.     enum CoordinateSystem
  24.     {
  25.         Universal       = 0,
  26.         Ecliptical      = 1,
  27.         Equatorial      = 2,
  28.         BodyFixed       = 3,
  29.         PhaseLock       = 5,
  30.         Chase           = 6,
  31.         
  32.         // Previous versions of PhaseLock and Chase used the
  33.         // spin axis of the reference object as a secondary
  34.         // vector for the coordinate system.
  35.         PhaseLock_Old   = 100,
  36.         Chase_Old       = 101,
  37.         
  38.         // ObserverLocal is not a real frame; it's an optional
  39.         // way to specify view vectors. Eventually, there will
  40.         // be some other way to accomplish this and ObserverLocal
  41.         // will go away.
  42.         ObserverLocal   = 200,
  43.         
  44.         Unknown         = 1000,
  45.     };
  46.     
  47.     ObserverFrame();
  48.     ObserverFrame(CoordinateSystem cs,
  49.                   const Selection& _refObject,
  50.                   const Selection& _targetObj = Selection());
  51.     ObserverFrame(const ObserverFrame&);
  52.     ObserverFrame(const ReferenceFrame& f);
  53.     
  54.     ~ObserverFrame();
  55.     
  56.     ObserverFrame& operator=(const ObserverFrame& f);
  57.     
  58.     CoordinateSystem getCoordinateSystem() const;
  59.     Selection getRefObject() const;
  60.     Selection getTargetObject() const;
  61.     
  62.     const ReferenceFrame* getFrame() const;
  63.     
  64.     UniversalCoord convertFromUniversal(const UniversalCoord& uc, double tjd) const;
  65.     UniversalCoord convertToUniversal(const UniversalCoord& uc, double tjd) const;
  66.     Quatd convertFromUniversal(const Quatd& q, double tjd) const;
  67.     Quatd convertToUniversal(const Quatd& q, double tjd) const;
  68.     
  69.     static UniversalCoord convert(const ObserverFrame* fromFrame,
  70.                                   const ObserverFrame* toFrame,
  71.                                   const UniversalCoord& uc,
  72.                                   double t);
  73.     static Quatd          convert(const ObserverFrame* fromFrame,
  74.                                   const ObserverFrame* toFrame,
  75.                                   const Quatd& q,
  76.                                   double t);
  77.     
  78. private:
  79.     ReferenceFrame* createFrame(CoordinateSystem _coordSys,
  80.                                 const Selection& _refObject,
  81.                                 const Selection& _targetObject);
  82.     
  83. private:
  84.     CoordinateSystem coordSys;
  85.     const ReferenceFrame* frame;
  86.     Selection targetObject;
  87. };
  88. /*! ObserverFrame is a wrapper class for ReferenceFrame which adds some
  89.  * annotation data. The goal is to place some restrictions on what reference
  90.  * frame can be set for an observer. General reference frames can be
  91.  * arbitrarily complex, with multiple levels of nesting. This makes it
  92.  * difficult to store them in a cel:// URL or display information about
  93.  * them for the user. The restricted set of reference frames wrapped by
  94.  * the ObserverFrame class does not suffer from such problems.
  95.  */
  96. class Observer
  97. {
  98. public:
  99.     Observer();
  100. Observer(const Observer& o);
  101. Observer& operator=(const Observer& o);
  102.         
  103.     UniversalCoord getPosition() const;
  104.     void          setPosition(const UniversalCoord&);
  105.     void          setPosition(const Point3d&);    
  106.     
  107.     Quatd         getOrientation() const;
  108.     Quatf         getOrientationf() const;
  109.     void          setOrientation(const Quatf&);
  110.     void          setOrientation(const Quatd&);
  111.     
  112.     Vec3d         getVelocity() const;
  113.     void          setVelocity(const Vec3d&);
  114.     Vec3d         getAngularVelocity() const;
  115.     void          setAngularVelocity(const Vec3d&);
  116.     
  117.     float          getFOV() const;
  118.     void           setFOV(float);
  119.     void           update(double dt, double timeScale);
  120.     Vec3f          getPickRay(float x, float y) const;
  121.     void orbit(const Selection&, Quatf q);
  122.     void rotate(Quatf q);
  123.     void changeOrbitDistance(const Selection&, float d);
  124.     void setTargetSpeed(float s);
  125.     float getTargetSpeed();
  126.     Selection getTrackedObject() const;
  127.     void setTrackedObject(const Selection&);
  128.     const std::string& getDisplayedSurface() const;
  129.     void setDisplayedSurface(const std::string&);
  130.     
  131.     uint32 getLocationFilter() const;
  132.     void setLocationFilter(uint32);
  133.     void gotoSelection(const Selection&,
  134.                        double gotoTime,
  135.                        Vec3f up,
  136.                        ObserverFrame::CoordinateSystem upFrame);
  137.     void gotoSelection(const Selection&,
  138.                        double gotoTime,
  139.                        double startInter,
  140.                        double endInter,
  141.                        Vec3f up,
  142.                        ObserverFrame::CoordinateSystem upFrame);
  143.     void gotoSelectionGC(const Selection&,
  144.                          double gotoTime,
  145.                          double startInter,
  146.                          double endInter,
  147.                          Vec3f up,
  148.                          ObserverFrame::CoordinateSystem upFrame);
  149.     void gotoSelection(const Selection&,
  150.                        double gotoTime,
  151.                        double distance,
  152.                        Vec3f up,
  153.                        ObserverFrame::CoordinateSystem upFrame);
  154.     void gotoSelectionLongLat(const Selection&,
  155.                               double gotoTime,
  156.                               double distance,
  157.                               float longitude, float latitude,
  158.                               Vec3f up);
  159.     void gotoLocation(const UniversalCoord& toPosition,
  160.                       const Quatd& toOrientation,
  161.                       double duration);
  162.     void getSelectionLongLat(const Selection&,
  163.                              double& distance,
  164.                              double& longitude,
  165.                              double& latitude);
  166.     void gotoSelectionGC(const Selection& selection,
  167.                          double gotoTime,
  168.                          double distance,
  169.                          Vec3f up,
  170.                          ObserverFrame::CoordinateSystem upFrame);
  171.     void gotoSurface(const Selection&, double duration);
  172.     void centerSelection(const Selection&, double centerTime = 0.5);
  173.     void centerSelectionCO(const Selection&, double centerTime = 0.5);
  174.     void follow(const Selection&);
  175.     void geosynchronousFollow(const Selection&);
  176.     void phaseLock(const Selection&);
  177.     void chase(const Selection&);
  178.     void cancelMotion();
  179.     void reverseOrientation();
  180.     void setFrame(ObserverFrame::CoordinateSystem cs, const Selection& refObj, const Selection& targetObj);
  181.     void setFrame(ObserverFrame::CoordinateSystem cs, const Selection& refObj);
  182.     void setFrame(const ObserverFrame& f);
  183.     const ObserverFrame* getFrame() const;
  184.     double getArrivalTime() const;
  185.     double getTime() const;
  186.     double getRealTime() const;
  187.     void setTime(double);
  188.     enum ObserverMode
  189.     {
  190.         Free                    = 0,
  191.         Travelling              = 1,
  192.     };
  193.     
  194.     ObserverMode getMode() const;
  195.     void setMode(ObserverMode);
  196.     enum TrajectoryType
  197.     {
  198.         Linear        = 0,
  199.         GreatCircle   = 1,
  200.         CircularOrbit = 2,          
  201.     };
  202.     struct JourneyParams
  203.     {
  204.         double duration;
  205.         double startTime;
  206.         UniversalCoord from;
  207.         UniversalCoord to;
  208.         Quatd initialOrientation;
  209.         Quatd finalOrientation;
  210.         double startInterpolation; // start of orientation interpolation phase [0-1]
  211.         double endInterpolation;   // end of orientation interpolation phase [0-1]
  212.         double expFactor;
  213.         double accelTime;
  214.         Quatd rotation1; // rotation on the CircularOrbit around centerObject
  215.         Selection centerObject;
  216.         
  217.         TrajectoryType traj;
  218.     };
  219.     void gotoJourney(const JourneyParams&);
  220.     // void setSimulation(Simulation* _sim) { sim = _sim; };
  221.  private:
  222.     void computeGotoParameters(const Selection& sel,
  223.                                JourneyParams& jparams,
  224.                                double gotoTime,
  225.                                double startInter,
  226.                                double endInter,
  227.                                Vec3d offset,
  228.                                ObserverFrame::CoordinateSystem offsetFrame,
  229.                                Vec3f up,
  230.                                ObserverFrame::CoordinateSystem upFrame);
  231.     void computeGotoParametersGC(const Selection& sel,
  232.                                  JourneyParams& jparams,
  233.                                  double gotoTime,
  234.                                  double startInter,
  235.                                  double endInter,
  236.                                  Vec3d offset,
  237.                                  ObserverFrame::CoordinateSystem offsetFrame,
  238.                                  Vec3f up,
  239.                                  ObserverFrame::CoordinateSystem upFrame,
  240.                                  const Selection& centerObj);
  241.     void computeCenterParameters(const Selection& sel,
  242.                                  JourneyParams& jparams,
  243.                                  double centerTime);
  244.     void computeCenterCOParameters(const Selection& sel,
  245.                                    JourneyParams& jparams,
  246.                                    double centerTime);
  247.     void updateUniversal();
  248.     void convertFrameCoordinates(const ObserverFrame* newFrame);
  249.     
  250.  private:
  251.     double         simTime;
  252.     // Position, orientation, and velocity in the observer's reference frame
  253.     UniversalCoord position;
  254.     Quatd          orientation;
  255.     Vec3d          velocity;
  256.     Vec3d          angularVelocity;
  257.     
  258.     // Position and orientation in universal coordinates, derived from the
  259.     // equivalent quantities in the observer reference frame.
  260.     UniversalCoord positionUniv;
  261.     Quatd          orientationUniv;
  262.     
  263.     ObserverFrame* frame;
  264.     
  265.     double         realTime;
  266.     double         targetSpeed;
  267.     Vec3d          targetVelocity;
  268.     Vec3d          initialVelocity;
  269.     double         beginAccelTime;
  270.     ObserverMode     observerMode;
  271.     JourneyParams    journey;    
  272.     Selection        trackObject;
  273.     Quatd trackingOrientation;   // orientation prior to selecting tracking
  274.     float fov;
  275.     bool reverseFlag;
  276.     uint32 locationFilter;
  277.     std::string displayedSurface;
  278. };
  279. #endif // _CELENGINE_OBSERVER_H_