// @(#)root/gl:$Id$
// Author:  Richard Maunder  25/05/2005

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TGLViewer
#define ROOT_TGLViewer

#include "TGLViewerBase.h"
#include "TGLRnrCtx.h"
#include "TGLSelectRecord.h"

#include "TVirtualViewer3D.h"
#include "TBuffer3D.h"

#include "TGLPerspectiveCamera.h"
#include "TGLOrthoCamera.h"
#include "TGLClip.h"

#include "TTimer.h"
#include "TPoint.h"

#include "TGEventHandler.h"

#include "GuiTypes.h"
#include "TQObject.h"

#include <vector>

class TGLSceneBase;
class TGLRedrawTimer;
class TGLViewerEditor;
class TGLWidget;
class TGLLightSet;
class TGLClipSet;
class TGLManipSet;
class TGLCameraOverlay;
class TGLContextIdentity;
class TGLAutoRotator;
class TTimer;
class TImage;

class TContextMenu;
class TGedEditor;
class TGLPShapeObj;

class TGLViewer : public TVirtualViewer3D,
                  public TGLViewerBase,
                  public TQObject

{
   friend class TGLOutput;
   friend class TGLEventHandler;
   friend class TGLAutoRotator;
public:

   enum ECameraType { kCameraPerspXOZ,  kCameraPerspYOZ,  kCameraPerspXOY,
                      kCameraOrthoXOY,  kCameraOrthoXOZ,  kCameraOrthoZOY,
                      kCameraOrthoXnOY, kCameraOrthoXnOZ, kCameraOrthoZnOY };

   enum ESecSelType { // When to do secondary-selection:
      kOnRequest,     // - on request - when Mod1 is pressed or logical-shape requests it;
      kOnKeyMod1      // - only when Mod1 is pressed.
   };

private:
   TGLViewer(const TGLViewer &);             // Not implemented
   TGLViewer & operator=(const TGLViewer &); // Not implemented

   void InitSecondaryObjects();

protected:
   // External handles
   TVirtualPad   *fPad;         //! external pad - remove replace with signal

   // GUI Handles
   TContextMenu  *fContextMenu; //!

   // Cameras
   // TODO: Put in vector and allow external creation
   TGLPerspectiveCamera fPerspectiveCameraXOZ; //!
   TGLPerspectiveCamera fPerspectiveCameraYOZ; //!
   TGLPerspectiveCamera fPerspectiveCameraXOY; //!
   TGLOrthoCamera       fOrthoXOYCamera;       //!
   TGLOrthoCamera       fOrthoXOZCamera;       //!
   TGLOrthoCamera       fOrthoZOYCamera;       //!
   TGLOrthoCamera       fOrthoXnOYCamera;      //!
   TGLOrthoCamera       fOrthoXnOZCamera;      //!
   TGLOrthoCamera       fOrthoZnOYCamera;      //!
   TGLCamera           *fCurrentCamera;        //!
   TGLAutoRotator      *fAutoRotator;          //!

   // Stereo
   Bool_t               fStereo;               //! use stereo rendering
   Bool_t               fStereoQuadBuf;        //! draw quad buffer or left/right stereo in left/right half of window
   Float_t              fStereoZeroParallax;   //! position of zero-parallax plane: 0 - near clipping plane, 1 - far clipping plane
   Float_t              fStereoEyeOffsetFac;   //!
   Float_t              fStereoFrustumAsymFac; //!

   // Lights
   TGLLightSet         *fLightSet;             //!
   // Clipping
   TGLClipSet          *fClipSet;              //!
   // Selected physical
   TGLSelectRecord      fCurrentSelRec;        //! select record in use as selected
   TGLSelectRecord      fSelRec;               //! select record from last select (should go to context)
   TGLSelectRecord      fSecSelRec;            //! select record from last secondary select (should go to context)
   TGLManipSet         *fSelectedPShapeRef;    //!
   // Overlay
   TGLOverlayElement   *fCurrentOvlElm;        //! current overlay element
   TGLOvlSelectRecord   fOvlSelRec;            //! select record from last overlay select

   TGEventHandler      *fEventHandler;         //! event handler
   TGedEditor          *fGedEditor;            //! GED editor
   TGLPShapeObj        *fPShapeWrap;

   // Mouse ineraction
public:
   enum EPushAction   { kPushStd,
                        kPushCamCenter, kPushAnnotate };
   enum EDragAction   { kDragNone,
                        kDragCameraRotate, kDragCameraTruck, kDragCameraDolly,
                        kDragOverlay };
protected:
   EPushAction          fPushAction;
   EDragAction          fDragAction;

   // Redraw timer
   TGLRedrawTimer      *fRedrawTimer;        //! timer for triggering redraws
   Float_t              fMaxSceneDrawTimeHQ; //! max time for scene rendering at high LOD (in ms)
   Float_t              fMaxSceneDrawTimeLQ; //! max time for scene rendering at high LOD (in ms)

   TGLRect        fViewport;       //! viewport - drawn area
   TGLColorSet    fDarkColorSet;   //! color-set with dark background
   TGLColorSet    fLightColorSet;  //! color-set with light background
   Float_t        fPointScale;     //! size scale for points
   Float_t        fLineScale;      //! width scale for lines
   Bool_t         fSmoothPoints;   //! smooth point edge rendering
   Bool_t         fSmoothLines;    //! smooth line edge rendering
   Int_t          fAxesType;       //! axes type
   Bool_t         fAxesDepthTest;  //! remove guides hidden-lines
   Bool_t         fReferenceOn;    //! reference marker on?
   TGLVertex3     fReferencePos;   //! reference position
   Bool_t         fDrawCameraCenter; //! reference marker on?
   TGLCameraOverlay  *fCameraOverlay; //! markup size of viewport in scene units

   Bool_t         fSmartRefresh;   //! cache logicals during scene rebuilds

   // Debug tracing (for scene rebuilds)
   Bool_t         fDebugMode;            //! debug mode (forced rebuild + draw scene/frustum/interest boxes)
   Bool_t         fIsPrinting;           //!
   TString        fPictureFileName;      //! default file-name for SavePicture()
   Float_t        fFader;                //! fade the view (0 - no fade/default, 1 - full fade/no rendering done)

   static TGLColorSet fgDefaultColorSet;                 //! a shared, default color-set
   static Bool_t      fgUseDefaultColorSetForNewViewers; //! name says it all


   ///////////////////////////////////////////////////////////////////////
   // Methods
   ///////////////////////////////////////////////////////////////////////

   virtual void SetupClipObject();

   // Drawing - can tidy up/remove lots when TGLManager added
   void InitGL();
   void PreDraw();
   void PostDraw();
   void FadeView(Float_t alpha);
   void MakeCurrent() const;
   void SwapBuffers() const;

   // Cameras
   void        SetViewport(Int_t x, Int_t y, Int_t width, Int_t height);
   void        SetViewport(const TGLRect& vp);
   void        SetupCameras(Bool_t reset);

protected:
   TGLWidget          *fGLWidget;
   Int_t               fGLDevice; //!for embedded gl viewer
   TGLContextIdentity *fGLCtxId;  //!for embedded gl viewer

   // Updata/camera-reset behaviour
   Bool_t           fIgnoreSizesOnUpdate;      // ignore sizes of bounding-boxes on update
   Bool_t           fResetCamerasOnUpdate;     // reposition camera on each update
   Bool_t           fResetCamerasOnNextUpdate; // reposition camera on next update

public:
   TGLViewer(TVirtualPad* pad, Int_t x, Int_t y, Int_t width, Int_t height);
   TGLViewer(TVirtualPad* pad);
   virtual ~TGLViewer();

   // TVirtualViewer3D interface ... mostly a facade

   // Forward to TGLScenePad
   virtual Bool_t CanLoopOnPrimitives() const { return kTRUE; }
   virtual void   PadPaint(TVirtualPad* pad);
   // Actually used by GL-in-pad
   virtual Int_t  DistancetoPrimitive(Int_t px, Int_t py);
   virtual void   ExecuteEvent(Int_t event, Int_t px, Int_t py);
   // Only implemented because they're abstract ... should throw an
   // exception or assert they are not called.
   virtual Bool_t PreferLocalFrame() const { return kTRUE; }
   virtual void   BeginScene() {}
   virtual Bool_t BuildingScene() const { return kFALSE; }
   virtual void   EndScene() {}
   virtual Int_t  AddObject(const TBuffer3D&, Bool_t* = 0) { return TBuffer3D::kNone; }
   virtual Int_t  AddObject(UInt_t, const TBuffer3D&, Bool_t* = 0) { return TBuffer3D::kNone; }
   virtual Bool_t OpenComposite(const TBuffer3D&, Bool_t* = 0) { return kFALSE; }
   virtual void   CloseComposite() {}
   virtual void   AddCompositeOp(UInt_t) {}

   virtual void   PrintObjects();
   virtual void   ResetCameras()                { SetupCameras(kTRUE); }
   virtual void   ResetCamerasAfterNextUpdate() { fResetCamerasOnNextUpdate = kTRUE; }

   TGLWidget* GetGLWidget() { return fGLWidget; }

   virtual void  CreateGLWidget()  {}
   virtual void  DestroyGLWidget() {}

   Int_t   GetDev()          const           { return fGLDevice; }
   Bool_t  GetSmartRefresh() const           { return fSmartRefresh; }
   void    SetSmartRefresh(Bool_t smart_ref) { fSmartRefresh = smart_ref; }

   TGLColorSet& RefDarkColorSet()  { return fDarkColorSet;  }
   TGLColorSet& RefLightColorSet() { return fLightColorSet; }
   TGLColorSet& ColorSet()         { return * fRnrCtx->GetBaseColorSet(); }
   void         UseDarkColorSet();
   void         UseLightColorSet();
   void         SwitchColorSet();

   void         UseDefaultColorSet(Bool_t x);
   Bool_t       IsUsingDefaultColorSet() const;
   Bool_t       IsColorSetDark() const;

   void         SetClearColor(Color_t col);

   static TGLColorSet& GetDefaultColorSet();
   static void         UseDefaultColorSetForNewViewers(Bool_t x);
   static Bool_t       IsUsingDefaultColorSetForNewViewers();

   const TGLRect& RefViewport()      const { return fViewport; }
   Int_t          ViewportDiagonal() const { return fViewport.Diagonal(); }

   Float_t GetPointScale()    const { return fPointScale; }
   Float_t GetLineScale()     const { return fLineScale; }
   void    SetPointScale(Float_t s) { fPointScale = s; }
   void    SetLineScale (Float_t s) { fLineScale  = s; }
   Bool_t  GetSmoothPoints()  const { return fSmoothPoints; }
   Bool_t  GetSmoothLines()   const { return fSmoothLines; }
   void    SetSmoothPoints(Bool_t s){ fSmoothPoints = s; }
   void    SetSmoothLines(Bool_t s) { fSmoothLines  = s; }

   TGLLightSet* GetLightSet() const { return fLightSet; }
   TGLClipSet * GetClipSet()  const { return fClipSet; }
   Bool_t GetClipAutoUpdate() const   { return fClipSet->GetAutoUpdate(); }
   void   SetClipAutoUpdate(Bool_t x) { fClipSet->SetAutoUpdate(x); }

   // External GUI component interface
   TGLCamera & CurrentCamera() const { return *fCurrentCamera; }
   TGLCamera & RefCamera(ECameraType camera);
   void SetCurrentCamera(ECameraType camera);
   void SetOrthoCamera(ECameraType camera, Double_t zoom, Double_t dolly,
                             Double_t center[3], Double_t hRotate, Double_t vRotate);
   void SetPerspectiveCamera(ECameraType camera, Double_t fov, Double_t dolly,
                             Double_t center[3], Double_t hRotate, Double_t vRotate);
   void ReinitializeCurrentCamera(const TGLVector3& hAxis, const TGLVector3& vAxis, Bool_t redraw=kTRUE);
   void GetGuideState(Int_t & axesType, Bool_t & axesDepthTest, Bool_t & referenceOn, Double_t* referencePos) const;
   void SetGuideState(Int_t axesType, Bool_t axesDepthTest, Bool_t referenceOn, const Double_t* referencePos);
   void SetDrawCameraCenter(Bool_t x);
   Bool_t GetDrawCameraCenter() { return fDrawCameraCenter; }
   void   PickCameraCenter()    { fPushAction = kPushCamCenter; RefreshPadEditor(this); }
   void   PickAnnotate()        { fPushAction = kPushAnnotate;  RefreshPadEditor(this); }
   TGLCameraOverlay* GetCameraOverlay() const { return fCameraOverlay; }
   void SetCameraOverlay(TGLCameraOverlay* m) { fCameraOverlay = m; }
   TGLAutoRotator* GetAutoRotator();
   void SetAutoRotator(TGLAutoRotator* ar);

   // Stereo
   Bool_t  GetStereo()               const { return fStereo; }
   Float_t GetStereoZeroParallax()   const { return fStereoZeroParallax;   }
   Float_t GetStereoEyeOffsetFac()   const { return fStereoEyeOffsetFac;   }
   Float_t GetStereoFrustumAsymFac() const { return fStereoFrustumAsymFac; }

   void SetStereo(Bool_t stereo, Bool_t quad_buf=kTRUE);
   void SetStereoZeroParallax(Float_t f)   { fStereoZeroParallax   = f; }
   void SetStereoEyeOffsetFac(Float_t f)   { fStereoEyeOffsetFac   = f; }
   void SetStereoFrustumAsymFac(Float_t f) { fStereoFrustumAsymFac = f; }

   // Push / drag action
   EPushAction GetPushAction() const { return fPushAction; }
   EDragAction GetDragAction() const { return fDragAction; }

   const TGLPhysicalShape * GetSelected() const;


   // Draw and selection

   // Scene rendering timeouts
   Float_t GetMaxSceneDrawTimeHQ() const    { return fMaxSceneDrawTimeHQ; }
   Float_t GetMaxSceneDrawTimeLQ() const    { return fMaxSceneDrawTimeLQ; }
   void    SetMaxSceneDrawTimeHQ(Float_t t) { fMaxSceneDrawTimeHQ = t; }
   void    SetMaxSceneDrawTimeLQ(Float_t t) { fMaxSceneDrawTimeLQ = t; }

   // Request methods post cross thread request via TROOT::ProcessLineFast().
   void RequestDraw(Short_t LOD = TGLRnrCtx::kLODMed); // Cross thread draw request
   virtual void PreRender();
   virtual void Render();
   virtual void PostRender();
   void DoDraw(Bool_t swap_buffers=kTRUE);
   void DoDrawMono(Bool_t swap_buffers);
   void DoDrawStereo(Bool_t swap_buffers);

   void DrawGuides();
   void DrawDebugInfo();

   Bool_t RequestSelect(Int_t x, Int_t y);          // Cross thread select request
   Bool_t DoSelect(Int_t x, Int_t y);               // First level selecton (shapes/objects).
   Bool_t RequestSecondarySelect(Int_t x, Int_t y); // Cross thread secondary select request
   Bool_t DoSecondarySelect(Int_t x, Int_t y);      // Second level selecton (inner structure).
   void   ApplySelection();

   Bool_t RequestOverlaySelect(Int_t x, Int_t y); // Cross thread select request
   Bool_t DoOverlaySelect(Int_t x, Int_t y);      // Window coords origin top left

   // Saving of screen image
   Bool_t SavePicture();
   Bool_t SavePicture(const TString &fileName);
   Bool_t SavePictureUsingBB (const TString &fileName);
   Bool_t SavePictureUsingFBO(const TString &fileName, Int_t w, Int_t h, Float_t pixel_object_scale=0);
   Bool_t SavePictureWidth (const TString &fileName, Int_t width, Bool_t pixel_object_scale=kTRUE);
   Bool_t SavePictureHeight(const TString &fileName, Int_t height, Bool_t pixel_object_scale=kTRUE);
   Bool_t SavePictureScale (const TString &fileName, Float_t scale, Bool_t pixel_object_scale=kTRUE);

   // Methods returning screen image
   TImage* GetPictureUsingBB();
   TImage* GetPictureUsingFBO(Int_t w, Int_t h,Float_t pixel_object_scale=0);

   const char*  GetPictureFileName() const { return fPictureFileName.Data(); }
   void         SetPictureFileName(const TString& f) { fPictureFileName = f; }
   Float_t      GetFader() const { return fFader; }
   void         SetFader(Float_t x) { fFader = x; }
   void         AutoFade(Float_t fade, Float_t time=1, Int_t steps=10);

   // Update/camera-reset
   void   UpdateScene(Bool_t redraw=kTRUE);
   Bool_t GetIgnoreSizesOnUpdate() const        { return fIgnoreSizesOnUpdate; }
   void   SetIgnoreSizesOnUpdate(Bool_t v)      { fIgnoreSizesOnUpdate = v; }
   void   ResetCurrentCamera();
   Bool_t GetResetCamerasOnUpdate() const       { return fResetCamerasOnUpdate; }
   void   SetResetCamerasOnUpdate(Bool_t v)     { fResetCamerasOnUpdate = v; }

   virtual void PostSceneBuildSetup(Bool_t resetCameras);

   virtual void Activated() { Emit("Activated()"); } // *SIGNAL*

   virtual void MouseIdle(TGLPhysicalShape*,UInt_t,UInt_t); // *SIGNAL*
   virtual void MouseOver(TGLPhysicalShape*); // *SIGNAL*
   virtual void MouseOver(TGLPhysicalShape*, UInt_t state); // *SIGNAL*
   virtual void MouseOver(TObject *obj, UInt_t state); // *SIGNAL*
   virtual void ReMouseOver(TObject *obj, UInt_t state); // *SIGNAL*
   virtual void UnMouseOver(TObject *obj, UInt_t state); // *SIGNAL*

   virtual void Clicked(TObject *obj); //*SIGNAL*
   virtual void Clicked(TObject *obj, UInt_t button, UInt_t state); //*SIGNAL*
   virtual void ReClicked(TObject *obj, UInt_t button, UInt_t state); //*SIGNAL*
   virtual void UnClicked(TObject *obj, UInt_t button, UInt_t state); //*SIGNAL*
   virtual void DoubleClicked() { Emit("DoubleClicked()"); } // *SIGNAL*

   TGEventHandler *GetEventHandler() const { return fEventHandler; }
   virtual void    SetEventHandler(TGEventHandler *handler);

   TGedEditor*  GetGedEditor() const { return fGedEditor; }
   virtual void SetGedEditor(TGedEditor* ed) { fGedEditor = ed; }

   virtual void SelectionChanged();
   virtual void OverlayDragFinished();
   virtual void RefreshPadEditor(TObject* obj=0);

   virtual void RemoveOverlayElement(TGLOverlayElement* el);

   TGLSelectRecord&    GetSelRec()    { return fSelRec; }
   TGLOvlSelectRecord& GetOvlSelRec() { return fOvlSelRec; }
   TGLOverlayElement*  GetCurrentOvlElm() const { return fCurrentOvlElm; }
   void                ClearCurrentOvlElm();

   ClassDef(TGLViewer,0) // Standard ROOT GL viewer.
};



// TODO: Find a better place/way to do this
class TGLRedrawTimer : public TTimer
{
private:
   TGLViewer & fViewer;
   Short_t     fRedrawLOD;
   Bool_t      fPending;
public:
   TGLRedrawTimer(TGLViewer & viewer) :
      fViewer(viewer), fRedrawLOD(TGLRnrCtx::kLODHigh), fPending(kFALSE) {}
   ~TGLRedrawTimer() {}
   void RequestDraw(Int_t milliSec, Short_t redrawLOD)
   {
      if (fPending) TurnOff(); else fPending = kTRUE;
      if (redrawLOD < fRedrawLOD) fRedrawLOD = redrawLOD;
      TTimer::Start(milliSec, kTRUE);
   }
   Bool_t IsPending() const { return fPending; }
   virtual void Stop()
   {
      if (fPending) { TurnOff(); fPending = kFALSE; }
   }
   Bool_t Notify()
   {
      TurnOff();
      fPending = kFALSE;
      fViewer.RequestDraw(fRedrawLOD);
      fRedrawLOD = TGLRnrCtx::kLODHigh;
      return kTRUE;
   }
};

class TGLFaderHelper {
private:
   TGLFaderHelper(const TGLFaderHelper&); // Not implemented
   TGLFaderHelper& operator=(const TGLFaderHelper&); // Not implemented

public:
   TGLViewer *fViewer;
   Float_t    fFadeTarget;
   Float_t    fTime;
   Int_t      fNSteps;

   TGLFaderHelper() :
      fViewer(0), fFadeTarget(0), fTime(0), fNSteps(0) {}
   TGLFaderHelper(TGLViewer* v, Float_t fade, Float_t time, Int_t steps) :
      fViewer(v),fFadeTarget(fade), fTime(time), fNSteps(steps) {}
   virtual ~TGLFaderHelper() {}

   void MakeFadeStep();

   ClassDef(TGLFaderHelper, 0);
};

#endif // ROOT_TGLViewer
 TGLViewer.h:1
 TGLViewer.h:2
 TGLViewer.h:3
 TGLViewer.h:4
 TGLViewer.h:5
 TGLViewer.h:6
 TGLViewer.h:7
 TGLViewer.h:8
 TGLViewer.h:9
 TGLViewer.h:10
 TGLViewer.h:11
 TGLViewer.h:12
 TGLViewer.h:13
 TGLViewer.h:14
 TGLViewer.h:15
 TGLViewer.h:16
 TGLViewer.h:17
 TGLViewer.h:18
 TGLViewer.h:19
 TGLViewer.h:20
 TGLViewer.h:21
 TGLViewer.h:22
 TGLViewer.h:23
 TGLViewer.h:24
 TGLViewer.h:25
 TGLViewer.h:26
 TGLViewer.h:27
 TGLViewer.h:28
 TGLViewer.h:29
 TGLViewer.h:30
 TGLViewer.h:31
 TGLViewer.h:32
 TGLViewer.h:33
 TGLViewer.h:34
 TGLViewer.h:35
 TGLViewer.h:36
 TGLViewer.h:37
 TGLViewer.h:38
 TGLViewer.h:39
 TGLViewer.h:40
 TGLViewer.h:41
 TGLViewer.h:42
 TGLViewer.h:43
 TGLViewer.h:44
 TGLViewer.h:45
 TGLViewer.h:46
 TGLViewer.h:47
 TGLViewer.h:48
 TGLViewer.h:49
 TGLViewer.h:50
 TGLViewer.h:51
 TGLViewer.h:52
 TGLViewer.h:53
 TGLViewer.h:54
 TGLViewer.h:55
 TGLViewer.h:56
 TGLViewer.h:57
 TGLViewer.h:58
 TGLViewer.h:59
 TGLViewer.h:60
 TGLViewer.h:61
 TGLViewer.h:62
 TGLViewer.h:63
 TGLViewer.h:64
 TGLViewer.h:65
 TGLViewer.h:66
 TGLViewer.h:67
 TGLViewer.h:68
 TGLViewer.h:69
 TGLViewer.h:70
 TGLViewer.h:71
 TGLViewer.h:72
 TGLViewer.h:73
 TGLViewer.h:74
 TGLViewer.h:75
 TGLViewer.h:76
 TGLViewer.h:77
 TGLViewer.h:78
 TGLViewer.h:79
 TGLViewer.h:80
 TGLViewer.h:81
 TGLViewer.h:82
 TGLViewer.h:83
 TGLViewer.h:84
 TGLViewer.h:85
 TGLViewer.h:86
 TGLViewer.h:87
 TGLViewer.h:88
 TGLViewer.h:89
 TGLViewer.h:90
 TGLViewer.h:91
 TGLViewer.h:92
 TGLViewer.h:93
 TGLViewer.h:94
 TGLViewer.h:95
 TGLViewer.h:96
 TGLViewer.h:97
 TGLViewer.h:98
 TGLViewer.h:99
 TGLViewer.h:100
 TGLViewer.h:101
 TGLViewer.h:102
 TGLViewer.h:103
 TGLViewer.h:104
 TGLViewer.h:105
 TGLViewer.h:106
 TGLViewer.h:107
 TGLViewer.h:108
 TGLViewer.h:109
 TGLViewer.h:110
 TGLViewer.h:111
 TGLViewer.h:112
 TGLViewer.h:113
 TGLViewer.h:114
 TGLViewer.h:115
 TGLViewer.h:116
 TGLViewer.h:117
 TGLViewer.h:118
 TGLViewer.h:119
 TGLViewer.h:120
 TGLViewer.h:121
 TGLViewer.h:122
 TGLViewer.h:123
 TGLViewer.h:124
 TGLViewer.h:125
 TGLViewer.h:126
 TGLViewer.h:127
 TGLViewer.h:128
 TGLViewer.h:129
 TGLViewer.h:130
 TGLViewer.h:131
 TGLViewer.h:132
 TGLViewer.h:133
 TGLViewer.h:134
 TGLViewer.h:135
 TGLViewer.h:136
 TGLViewer.h:137
 TGLViewer.h:138
 TGLViewer.h:139
 TGLViewer.h:140
 TGLViewer.h:141
 TGLViewer.h:142
 TGLViewer.h:143
 TGLViewer.h:144
 TGLViewer.h:145
 TGLViewer.h:146
 TGLViewer.h:147
 TGLViewer.h:148
 TGLViewer.h:149
 TGLViewer.h:150
 TGLViewer.h:151
 TGLViewer.h:152
 TGLViewer.h:153
 TGLViewer.h:154
 TGLViewer.h:155
 TGLViewer.h:156
 TGLViewer.h:157
 TGLViewer.h:158
 TGLViewer.h:159
 TGLViewer.h:160
 TGLViewer.h:161
 TGLViewer.h:162
 TGLViewer.h:163
 TGLViewer.h:164
 TGLViewer.h:165
 TGLViewer.h:166
 TGLViewer.h:167
 TGLViewer.h:168
 TGLViewer.h:169
 TGLViewer.h:170
 TGLViewer.h:171
 TGLViewer.h:172
 TGLViewer.h:173
 TGLViewer.h:174
 TGLViewer.h:175
 TGLViewer.h:176
 TGLViewer.h:177
 TGLViewer.h:178
 TGLViewer.h:179
 TGLViewer.h:180
 TGLViewer.h:181
 TGLViewer.h:182
 TGLViewer.h:183
 TGLViewer.h:184
 TGLViewer.h:185
 TGLViewer.h:186
 TGLViewer.h:187
 TGLViewer.h:188
 TGLViewer.h:189
 TGLViewer.h:190
 TGLViewer.h:191
 TGLViewer.h:192
 TGLViewer.h:193
 TGLViewer.h:194
 TGLViewer.h:195
 TGLViewer.h:196
 TGLViewer.h:197
 TGLViewer.h:198
 TGLViewer.h:199
 TGLViewer.h:200
 TGLViewer.h:201
 TGLViewer.h:202
 TGLViewer.h:203
 TGLViewer.h:204
 TGLViewer.h:205
 TGLViewer.h:206
 TGLViewer.h:207
 TGLViewer.h:208
 TGLViewer.h:209
 TGLViewer.h:210
 TGLViewer.h:211
 TGLViewer.h:212
 TGLViewer.h:213
 TGLViewer.h:214
 TGLViewer.h:215
 TGLViewer.h:216
 TGLViewer.h:217
 TGLViewer.h:218
 TGLViewer.h:219
 TGLViewer.h:220
 TGLViewer.h:221
 TGLViewer.h:222
 TGLViewer.h:223
 TGLViewer.h:224
 TGLViewer.h:225
 TGLViewer.h:226
 TGLViewer.h:227
 TGLViewer.h:228
 TGLViewer.h:229
 TGLViewer.h:230
 TGLViewer.h:231
 TGLViewer.h:232
 TGLViewer.h:233
 TGLViewer.h:234
 TGLViewer.h:235
 TGLViewer.h:236
 TGLViewer.h:237
 TGLViewer.h:238
 TGLViewer.h:239
 TGLViewer.h:240
 TGLViewer.h:241
 TGLViewer.h:242
 TGLViewer.h:243
 TGLViewer.h:244
 TGLViewer.h:245
 TGLViewer.h:246
 TGLViewer.h:247
 TGLViewer.h:248
 TGLViewer.h:249
 TGLViewer.h:250
 TGLViewer.h:251
 TGLViewer.h:252
 TGLViewer.h:253
 TGLViewer.h:254
 TGLViewer.h:255
 TGLViewer.h:256
 TGLViewer.h:257
 TGLViewer.h:258
 TGLViewer.h:259
 TGLViewer.h:260
 TGLViewer.h:261
 TGLViewer.h:262
 TGLViewer.h:263
 TGLViewer.h:264
 TGLViewer.h:265
 TGLViewer.h:266
 TGLViewer.h:267
 TGLViewer.h:268
 TGLViewer.h:269
 TGLViewer.h:270
 TGLViewer.h:271
 TGLViewer.h:272
 TGLViewer.h:273
 TGLViewer.h:274
 TGLViewer.h:275
 TGLViewer.h:276
 TGLViewer.h:277
 TGLViewer.h:278
 TGLViewer.h:279
 TGLViewer.h:280
 TGLViewer.h:281
 TGLViewer.h:282
 TGLViewer.h:283
 TGLViewer.h:284
 TGLViewer.h:285
 TGLViewer.h:286
 TGLViewer.h:287
 TGLViewer.h:288
 TGLViewer.h:289
 TGLViewer.h:290
 TGLViewer.h:291
 TGLViewer.h:292
 TGLViewer.h:293
 TGLViewer.h:294
 TGLViewer.h:295
 TGLViewer.h:296
 TGLViewer.h:297
 TGLViewer.h:298
 TGLViewer.h:299
 TGLViewer.h:300
 TGLViewer.h:301
 TGLViewer.h:302
 TGLViewer.h:303
 TGLViewer.h:304
 TGLViewer.h:305
 TGLViewer.h:306
 TGLViewer.h:307
 TGLViewer.h:308
 TGLViewer.h:309
 TGLViewer.h:310
 TGLViewer.h:311
 TGLViewer.h:312
 TGLViewer.h:313
 TGLViewer.h:314
 TGLViewer.h:315
 TGLViewer.h:316
 TGLViewer.h:317
 TGLViewer.h:318
 TGLViewer.h:319
 TGLViewer.h:320
 TGLViewer.h:321
 TGLViewer.h:322
 TGLViewer.h:323
 TGLViewer.h:324
 TGLViewer.h:325
 TGLViewer.h:326
 TGLViewer.h:327
 TGLViewer.h:328
 TGLViewer.h:329
 TGLViewer.h:330
 TGLViewer.h:331
 TGLViewer.h:332
 TGLViewer.h:333
 TGLViewer.h:334
 TGLViewer.h:335
 TGLViewer.h:336
 TGLViewer.h:337
 TGLViewer.h:338
 TGLViewer.h:339
 TGLViewer.h:340
 TGLViewer.h:341
 TGLViewer.h:342
 TGLViewer.h:343
 TGLViewer.h:344
 TGLViewer.h:345
 TGLViewer.h:346
 TGLViewer.h:347
 TGLViewer.h:348
 TGLViewer.h:349
 TGLViewer.h:350
 TGLViewer.h:351
 TGLViewer.h:352
 TGLViewer.h:353
 TGLViewer.h:354
 TGLViewer.h:355
 TGLViewer.h:356
 TGLViewer.h:357
 TGLViewer.h:358
 TGLViewer.h:359
 TGLViewer.h:360
 TGLViewer.h:361
 TGLViewer.h:362
 TGLViewer.h:363
 TGLViewer.h:364
 TGLViewer.h:365
 TGLViewer.h:366
 TGLViewer.h:367
 TGLViewer.h:368
 TGLViewer.h:369
 TGLViewer.h:370
 TGLViewer.h:371
 TGLViewer.h:372
 TGLViewer.h:373
 TGLViewer.h:374
 TGLViewer.h:375
 TGLViewer.h:376
 TGLViewer.h:377
 TGLViewer.h:378
 TGLViewer.h:379
 TGLViewer.h:380
 TGLViewer.h:381
 TGLViewer.h:382
 TGLViewer.h:383
 TGLViewer.h:384
 TGLViewer.h:385
 TGLViewer.h:386
 TGLViewer.h:387
 TGLViewer.h:388
 TGLViewer.h:389
 TGLViewer.h:390
 TGLViewer.h:391
 TGLViewer.h:392
 TGLViewer.h:393
 TGLViewer.h:394
 TGLViewer.h:395
 TGLViewer.h:396
 TGLViewer.h:397
 TGLViewer.h:398
 TGLViewer.h:399
 TGLViewer.h:400
 TGLViewer.h:401
 TGLViewer.h:402
 TGLViewer.h:403
 TGLViewer.h:404
 TGLViewer.h:405
 TGLViewer.h:406
 TGLViewer.h:407
 TGLViewer.h:408
 TGLViewer.h:409
 TGLViewer.h:410
 TGLViewer.h:411
 TGLViewer.h:412
 TGLViewer.h:413
 TGLViewer.h:414
 TGLViewer.h:415
 TGLViewer.h:416
 TGLViewer.h:417
 TGLViewer.h:418
 TGLViewer.h:419
 TGLViewer.h:420
 TGLViewer.h:421
 TGLViewer.h:422
 TGLViewer.h:423
 TGLViewer.h:424
 TGLViewer.h:425
 TGLViewer.h:426
 TGLViewer.h:427
 TGLViewer.h:428
 TGLViewer.h:429
 TGLViewer.h:430
 TGLViewer.h:431
 TGLViewer.h:432
 TGLViewer.h:433
 TGLViewer.h:434
 TGLViewer.h:435
 TGLViewer.h:436
 TGLViewer.h:437
 TGLViewer.h:438
 TGLViewer.h:439
 TGLViewer.h:440
 TGLViewer.h:441
 TGLViewer.h:442
 TGLViewer.h:443
 TGLViewer.h:444
 TGLViewer.h:445
 TGLViewer.h:446
 TGLViewer.h:447
 TGLViewer.h:448
 TGLViewer.h:449
 TGLViewer.h:450
 TGLViewer.h:451
 TGLViewer.h:452
 TGLViewer.h:453