TGLCamera

class TGLCamera

    private:

      TGLBoundingBox Frustum(Bool_t asBox = kTRUE) const
          TGLCamera& operator=(const TGLCamera&)

    protected:

      Bool_t AdjustAndClampVal(Double_t& val, Double_t min, Double_t max, Int_t screenShift, Int_t screenShiftRange, Bool_t mod1, Bool_t mod2) const
        void UpdateCache() const

    public:

                      virtual ~TGLCamera()
                 virtual void Apply(const TGLBoundingBox& sceneBox, const TGLRect* pickRect = 0) const
               static TClass* Class()
               virtual Bool_t Dolly(Int_t delta, Bool_t mod1, Bool_t mod2)
                         void DrawDebugAids() const
                   TGLVector3 EyeDirection() const
                   TGLVertex3 EyePoint() const
                   TGLVertex3 FrustumCenter() const
                     EOverlap FrustumOverlap(const TGLBoundingBox& box) const
              const TGLPlane& FrustumPlane(TGLCamera::EFrustumPlane plane) const
              virtual TClass* IsA() const
                       Bool_t OfInterest(const TGLBoundingBox& box) const
                 virtual void Reset()
                         void ResetInterest()
               virtual Bool_t Rotate(Int_t xDelta, Int_t yDelta)
                 virtual void Setup(const TGLBoundingBox& box)
                         void SetViewport(const TGLRect& viewport)
                 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)
                       Bool_t UpdateInterest(Bool_t force)
                   TGLVector3 ViewportDeltaToWorld(const TGLVertex3& worldRef, Double_t viewportXDelta, Double_t viewportYDelta) const
                     EOverlap ViewportOverlap(const TGLBoundingBox& box) const
      pair<Bool_t,TGLVertex3> ViewportPlaneIntersection(Double_t viewportX, Double_t viewportY, const TGLPlane& worldPlane) const
      pair<Bool_t,TGLVertex3> ViewportPlaneIntersection(const TPoint& viewport, const TGLPlane& worldPlane) const
                      TGLRect ViewportRect(const TGLBoundingBox& box, const TGLBoundingBox::EFace face) const
                      TGLRect ViewportRect(const TGLBoundingBox& box, const TGLBoundingBox::EFace* face = 0) const
                   TGLVertex3 ViewportToWorld(const TGLVertex3& viewportVertex) const
                     TGLLine3 ViewportToWorld(Double_t viewportX, Double_t viewportY) const
                     TGLLine3 ViewportToWorld(const TPoint& viewport) const
                         void WindowToViewport(Int_t&, Int_t& y) const
                         void WindowToViewport(TPoint& point) const
                         void WindowToViewport(TGLRect& rect) const
                         void WindowToViewport(TGLVertex3& vertex) const
                   TGLVector3 WorldDeltaToViewport(const TGLVertex3& worldRef, const TGLVector3& worldDelta) const
                   TGLVertex3 WorldToViewport(const TGLVertex3& worldVertex) const
               virtual Bool_t Zoom(Int_t delta, Bool_t mod1, Bool_t mod2)

Data Members

    private:

             TGLBoundingBox fPreviousInterestBox    ! previous interest box (DEBUG)
             TGLBoundingBox fInterestFrustum        ! frustum basis of current interest box - NOT a true BB! (DEBUG)
             TGLBoundingBox fInterestFrustumAsBox   ! frustum basis (as box) of current interest box (DEBUG)
      static const Double_t fgInterestBoxExpansion  ! expansion c.f. aligned current frustum box

    protected:

              Bool_t fCacheDirty        ! cached items dirty?
           TGLMatrix fProjM             ! projection matrix        (cached)
           TGLMatrix fModVM             ! modelView matrix         (cached)
           TGLMatrix fClipM             ! object space clip matrix (cached)
            TGLPlane fFrustumPlanes[6]  ! frustum planes           (cached)
             TGLRect fViewport          ! viewport (GL coords - origin bottom left)
      TGLBoundingBox fInterestBox       ! the interest box - created in UpdateInterest()
            Double_t fLargestSeen       ! largest box volume seen in OfInterest() - used when 

    public:

      static const TGLCamera::EFrustumPlane kNear              
      static const TGLCamera::EFrustumPlane kLeft              
      static const TGLCamera::EFrustumPlane kRight             
      static const TGLCamera::EFrustumPlane kTop               
      static const TGLCamera::EFrustumPlane kBottom            
      static const TGLCamera::EFrustumPlane kFar               
      static const TGLCamera::EFrustumPlane kPlanesPerFrustum  

Class Description

                                                                      
 TGLCamera                                                            
                                                                      
 Abstract base camera class - concrete classes for orthographic and   
 persepctive cameras derive from it. This class maintains values for  
 the current:                                                         
 i)   Viewport                                                        
 ii)  Projection, modelview and clip matricies - extracted from GL    
 iii) The 6 frustum planes                                            
 iv)  Expanded frustum interest box                                   
                                                                      
 It provides methods for various projection, overlap and intersection 
 tests for viewport and world locations, against the true frustum and 
 expanded interest box, and for extracting eye position and direction.
                                                                      
 It also defines the pure virtual manipulation interface methods the  
 concrete ortho and prespective classes must implement.               

 Base camera destructor

 Set viewport extents from passed 'viewport' rect

 Update internally cached frustum values

 Return the the current camera frustum. If asBox == kFALSE return
 a true frustum (truncated square based pyramid). If asBox == kTRUE
 return a true box, using the far clipping plane intersection projected
 back to the near plane.

 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Note: TGLBoundingBox is not really valid when filled with truncated pyramid
 - this is used as a visual debug aid only so ok.

 Return the camera eye point (vertex) in world space
 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Extract the camera eye direction (vector), running from EyePoint()
 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Find the center of the camera frustum from intersection of planes
 This method will work even with parallel left/right & top/bottom and
 infinite eye point of ortho cameras
 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Calcaulte overlap (kInside, kOutside, kPartial) of box with camera
 frustum
 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Calculate overlap (kInside, kOutside, kPartial) of box projection onto viewport
 (as rect) against the viewport rect
 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Calculate viewport rectangle which just contains projection of single 'face'
 of world frame bounding box 'box' onto the viewport. Note use other version
 of ViewportRect() if you want whole 'box' contained

 Calculate viewport rectangle which just contains projection of world frame
 bounding box 'box' onto the viewport. If face is null the rect contains
 the whole bounding box (8 vertices/6 faces). If face is non-null it indicates
 a box face, and the rect contains the single face (4 vertices). Note use
 other version of ViewportRect() if you wish to just pass a static EFace enum
 member (e.g. kFaceLowX)

 Note:
       i)   Rectangle is NOT clipped by viewport limits - so can result
            in rect with corners outside viewport - negative etc
       ii)  TGLRect provides int (pixel based) values - not subpxiel accurate
       iii) Camera must have valid frustum cache - call Apply() after last
            modifcation, before calling

 Convert a 3D world vertex to '3D' viewport (screen) one. The X()/Y()
 components of the viewport vertex are the horizontal/vertical pixel
 positions. The Z() component is the viewport depth value - for a
 default depth range this is 0.0 (at near clip plane) to 1.0 (at far
 clip plane). See OpenGL gluProject & glDepth documentation

 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Convert a 3D vector worldDelta (shift) about vertex worldRef to a viewport
 (screen) '3D' vector. The X()/Y() components of the vector are the horizontal 
 vertical pixel deltas. The Z() component is the viewport depth delta - for a
 default depth range between 0.0 (at near clip plane) to 1.0 (at far clip plane)
 See OpenGL gluProject & glDepth documentation

 Camera must have valid frustum cache - call Apply()

 Convert a '3D' viewport vertex to 3D world one. The X()/Y() components
 of viewportVertex are the horizontal/vertical pixel position.
 The Z() component is the viewport depth value - for a default depth range this
 is 0.0 (at near clip plane) to 1.0 (at far clip plane). Without Z() the viewport
 position corresponds to a line in 3D world space - see
    TGLLine3 TGLCamera::ViewportToWorld(Double_t viewportX, Double_t viewportY) const

 See also OpenGL gluUnProject & glDepth documentation

 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Convert a 2D viewport position to 3D world line - the projection of the
 viewport point into 3D space. Line runs from near to far camera clip planes
 (the minimum and maximum visible depth). See also
    TGLVertex3 TGLCamera::ViewportToWorld(const TGLVertex3 & viewportVertex) const
 for 3D viewport -> 3D world vertex conversions.
 See also OpenGL gluUnProject & glDepth documentation

 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Convert a 2D viewport position to 3D world line - the projection of the
 viewport point into 3D space. Line runs from near to far camera clip planes
 (the minimum and maximum visible depth). See also
    TGLVertex3 TGLCamera::ViewportToWorld(const TGLVertex3 & viewportVertex) const
 for 3D viewport -> 3D world vertex conversions.
 See also OpenGL gluUnProject & glDepth documentation

 Camera must have valid frustum cache - call Apply() after last modifcation, before using

 Apply a 2D viewport delta (shift) to the projection of worldRef onto viewport,
 returning the resultant world vector which equates to it. Useful for making
 3D world objects track mouse moves.

 Camera must have valid frustum cache - call Apply()

 Calculate if the an object defined by world frame bounding box
 is 'of interest' to the camera. This is defined as box:

 i) intersecting completely or partially (kInside/kPartial) with
 cameras interest box (fInterestBox)
 ii) having significant length OR volume ratio compared to this
 interest box

 If a box is 'of interest' returns kTRUE, kFALSE otherwise.
 See TGLCamera::UpdateInterest() for more details of camera interest box.

 Note: Length/volume ratios NOT dependent on the projected size of box
 at current camera configuration as we do not want continual changes.
 This is used when (re) populating the scene with objects from external
 client.

 TODO: Might be more logical to move this test out to client - and
 have accessor for fInterestBox instead?

 Update the internal interest box (fInterestBox) of the camera.
 The interest box is an orientated bounding box, calculated as
 an expanded container round the frustum. It is used to test if
 if object bounding boxes are of interest (should be accepted
 into viewer scene) for a camera - see TGLCamera::OfInterest()

 The interest box is updated if the frustum is no longer contained
 in the existing one, or a new one calculated on the current frustum
 differs significantly in volume (camera has been zoomed/dollyed
 sizable amount).

 If the interest box is updated we return kTRUE - kFALSE otherwise.

 Clear out the existing interest box

 Adjust a passed REFERENCE value 'val', based on screenShift delta.
 Two modifier flags ('mod1' / 'mod2' ) for sensitivity:

 mod1 = kFALSE, mod2 = kFALSE : normal sensitivity (screenShift/screenShiftRange)
 mod1 = kTRUE, mod2 = kFALSE : 0.1x sensitivity
 mod1 = kTRUE, mod2 = kTRUE : 0.01x sensitivity
 mod1 = kFALSE, mod2 = kTRUE : 10.0x sensitivity

 'val' is modified and clamped to 'min' / 'max' range.
 Return bool kTRUE if val actually changed.

 Used as common interaction function for adjusting zoom/dolly etc

 Draw out some debugging aids for the camera:

 i) The frustum used to create the current interest box (RED)
 ii) The same frustum as a squared off box (ORANGE)
 iii) The axis aligned version of the frustum used as interest box basis (YELLOW)
 iv) The current interest box (BLUE)

Inline Functions

                     TGLCamera& operator=(const TGLCamera&)
                           void Setup(const TGLBoundingBox& box)
                           void Reset()
                         Bool_t Dolly(Int_t delta, Bool_t mod1, Bool_t mod2)
                         Bool_t Zoom(Int_t delta, Bool_t mod1, Bool_t mod2)
                         Bool_t Truck(Int_t x, Int_t y, Int_t xDelta, Int_t yDelta)
                         Bool_t Rotate(Int_t xDelta, Int_t yDelta)
                           void Apply(const TGLBoundingBox& sceneBox, const TGLRect* pickRect = 0) const
                const TGLPlane& FrustumPlane(TGLCamera::EFrustumPlane plane) const
        pair<Bool_t,TGLVertex3> ViewportPlaneIntersection(Double_t viewportX, Double_t viewportY, const TGLPlane& worldPlane) const
        pair<Bool_t,TGLVertex3> ViewportPlaneIntersection(const TPoint& viewport, const TGLPlane& worldPlane) const
                           void WindowToViewport(Int_t&, Int_t& y) const
                           void WindowToViewport(TPoint& point) const
                           void WindowToViewport(TGLRect& rect) const
                           void WindowToViewport(TGLVertex3& vertex) const
                        TClass* Class()
                        TClass* IsA() const
                           void ShowMembers(TMemberInspector& insp, char* parent)
                           void Streamer(TBuffer& b)
                           void StreamerNVirtual(TBuffer& b)