TGLOrthoCamera

class TGLOrthoCamera : public TGLCamera

    private:

      void Init()

    public:

                      TGLOrthoCamera(TGLOrthoCamera::EType type)
              virtual ~TGLOrthoCamera()
         virtual void Apply(const TGLBoundingBox& sceneBox, const TGLRect* pickRect = 0) const
       static TClass* Class()
                 void Configure(Double_t left, Double_t right, Double_t top, Double_t bottom)
       virtual Bool_t Dolly(Int_t delta, Bool_t mod1, Bool_t mod2)
      virtual TClass* IsA() const
         virtual void Reset()
       virtual Bool_t Rotate(Int_t xDelta, Int_t yDelta)
         virtual void Setup(const TGLBoundingBox& box)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)
       virtual Bool_t Truck(Int_t x, Int_t y, Int_t xDelta, Int_t yDelta)
       virtual Bool_t Zoom(Int_t delta, Bool_t mod1, Bool_t mod2)

Data Members

    private:

      TGLOrthoCamera::EType fType            !
                   Double_t fZoomMin         !
                   Double_t fZoomDefault     !
                   Double_t fZoomMax         !
             TGLBoundingBox fVolume          !
                   Double_t fZoom            !
                 TGLVector3 fTruck           !
                  TGLMatrix fMatrix          !
              static UInt_t fgZoomDeltaSens  

    public:

      static const TGLOrthoCamera::EType kXOY  
      static const TGLOrthoCamera::EType kXOZ  
      static const TGLOrthoCamera::EType kZOY  

Class Description

                                                                      
 TGLOrthoCamera                                                       
                                                                      
 Orthographic projection camera. Currently limited to three types     
 defined at construction time - kXOY, kXOZ, kZOY - where this refers  
 to the viewport plane axis - e.g. kXOY has X axis horizontal, Y      
 vertical - i.e. looking down Z axis with Y vertical.                 

 The plane types restriction could easily be removed to supported     
 arbitary ortho projections along any axis/orientation with free      
 rotations about them.                                                
                                                                      

 Construct orthographic camera with 'type' defining fixed view direction
 & orientation (in world frame):

 kXOY : X Horz. / Y Vert (looking towards +Z, Y up)
 kXOZ : X Horz. / Z Vert (looking towards +Y, Z up)
 kZOY : Z Horz. / Y Vert (looking towards +X, Y up)

 Destroy orthographic camera

 Setup camera limits suitible to view the world volume defined by 'box'
 and call Reset() to initialise camera.

 Reset the camera to defaults - trucking, zooming to reframe the world volume
 established in Setup(). Note: limits defined in Setup() are not adjusted.

 Dolly the camera - 'move camera along eye line, retaining lens focal length'.
 Arguments are:

 'delta' - mouse viewport delta (pixels) - +ive dolly in, -ive dolly out
 'mod1' / 'mod2' - sensitivity modifiers - see TGLCamera::AdjustAndClampVal()

 For an orthographic camera dollying and zooming are identical and both equate
 logically to a rescaling of the viewport limits - without center shift.
 There is no perspective foreshortening or lens 'focal length'.

 Returns kTRUE is redraw required (camera change), kFALSE otherwise.

 Zoom the camera - 'adjust lens focal length, retaining camera position'.
 Arguments are:

 'delta' - mouse viewport delta (pixels) - +ive zoom in, -ive zoom out
 'mod1' / 'mod2' - sensitivity modifiers - see TGLCamera::AdjustAndClampVal()

 For an orthographic camera dollying and zooming are identical and both equate
 logically to a rescaling of the viewport limits - without center shift.
 There is no perspective foreshortening or lens 'focal length'.

 Returns kTRUE is redraw required (camera change), kFALSE otherwise.

 Truck the camera - 'move camera parallel to film plane'. The film
 plane is defined by the EyePoint() / EyeDirection() pair. Define motion
 using center point (x/y) and delta (xDelta/yDelta) - the mouse motion.

 Returns kTRUE is redraw required (camera change), kFALSE otherwise.

 Note: Trucking is often mistakenly refered to as 'pan' or 'panning'.
 Panning is swivelling the camera on it's own axis - the eye point.

 Rotate the camera - 'swivel round the view volume center'.
 Ignored at present for orthographic cameras - have a fixed direction.
 Could let the user or external code create non-axis
 ortho projects by adjusting H/V rotations in future.

 Returns kTRUE is redraw required (camera change), kFALSE otherwise.

 Apply the camera to the current GL context, setting the viewport, projection
 and modelview matricies. After this verticies etc can be directly entered
 in the world frame. This also updates the cached frustum values, enabling
 all the projection, overlap tests etc defined in TGLCamera to be used.

 Arguments are:
 'box' - view volume box - ignored for ortho camera. Assumed to be same
 as one passed to Setup().
 'pickRect' - optional picking rect. If non-null, restrict drawing to this
 viewport rect.

 Configure the camera state

Inline Functions

               void Init()
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)