    // @(#)root/base:$Name:  $:$Id: TVirtualGL.h,v 1.4 2002/02/23 15:50:36 rdm Exp $
    // Author: Valery Fine(fine@vxcern.cern.ch)   05/03/97

    /*************************************************************************
     * Copyright (C) 1995-2000, 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_TVirtualGL
    #define ROOT_TVirtualGL

    //////////////////////////////////////////////////////////////////////////
    //                                                                      //
    // TVirtualGL                                                           //
    //                                                                      //
    // The TVirtualGL class is an abstract base class defining the          //
    // OpenGL interface protocol. All interactions with OpenGL should be    //
    // done via the global pointer gVirtualGL. If the OpenGL library is     //
    // available this pointer is pointing to an instance of the TGLKernel   //
    // class which provides the actual interface to OpenGL. Using this      //
    // scheme of ABC we can use OpenGL in other parts of the framework      //
    // without having to link with the OpenGL library in case we don't      //
    // use the classes using OpenGL.                                        //
    //                                                                      //
    //////////////////////////////////////////////////////////////////////////

    #ifndef ROOT_Rtypes
    #include "Rtypes.h"
    #endif
    #ifndef ROOT_Gtypes
    #include "Gtypes.h"
    #endif

    class TVirtualGL;
    class TGLViewerImp;
    class TPadOpenGLView;
    class TVirtualPad;
    class TPoints3DABC;
    class TPadView3D;

    R__EXTERN TVirtualGL *gVirtualGL;

    #include "GLConstants.h"

    class TVirtualGL {

    protected:
       UInt_t       fColorIndx;     // Current color index;
       Bool_t       fRootLight;     // Whether the "ROOT" light will be used (otherwise OpenGL)
       Bool_t       fTrueColorMode; // Defines the whether the current hardware layer supports the true colors
       EG3D2GLmode  fFaceFlag;      // The current "face" definiton - clockwise/counterclockwise

       Float_t *Invert(Float_t *vector)
          { for (int i = 0; i < 3; i++) vector[i] = -vector[i]; return vector; }

    public:
       TVirtualGL();
       virtual ~TVirtualGL() { }

       virtual void AddRotation(Double_t *rotmatrix, Double_t *extraangles);
       virtual void BeginGLCmd(EG3D2GLmode mode);
       virtual void ClearColor(Int_t color);
       virtual void ClearGLColor(Float_t red, Float_t green, Float_t blue, Float_t alpha);
       virtual void ClearGL(UInt_t bufbits );
       virtual Int_t CreateGLLists(Int_t range);
       virtual TGLViewerImp *CreateGLViewerImp(TPadOpenGLView *c, const char *title, UInt_t width, UInt_t height);
       virtual TPadView3D *CreatePadGLView(TVirtualPad *c);
       virtual void DeleteGLLists(Int_t ilist, Int_t range);
       virtual void DisableGL(EG3D2GLmode mode);
       virtual void EnableGL(EG3D2GLmode mode);
       virtual void EndGLList() { }
       virtual void EndGLCmd() { }
       virtual void FlushGL() { }
       virtual void FrontGLFace(EG3D2GLmode faceflag);
       virtual void GetGL(EG3D2GLmode mode, UChar_t *params);
       virtual void GetGL(EG3D2GLmode mode, Double_t *params);
       virtual void GetGL(EG3D2GLmode mode, Float_t *params);
       virtual void GetGL(EG3D2GLmode mode, Int_t *params);
       virtual Int_t GetGLError() {return 0;}
               Bool_t GetRootLight() {return fRootLight;}
               Bool_t GetTrueColorMode() {return fTrueColorMode;}
       virtual void MultGLMatrix(Double_t *mat);
       virtual void NewGLList(UInt_t ilist=1, EG3D2GLmode mode=kCOMPILE);
       virtual void NewGLModelView(Int_t ilist);
       virtual void PaintGLPoints(Int_t n, Float_t *p, Option_t *option);
       virtual void PolygonGLMode(EG3D2GLmode face, EG3D2GLmode mode);
       virtual void PushGLMatrix() { }
       virtual void PopGLMatrix() { }
       virtual void RotateGL(Double_t angle, Double_t x, Double_t y, Double_t z);
       virtual void RotateGL(Double_t Theta, Double_t Phi, Double_t Psi);
       virtual void SetGLVertex(Float_t *vertex);
       virtual void SetGLColor(Float_t *rgb);
       virtual void SetGLColorIndex(Int_t color);
       virtual void SetGLLineWidth(Float_t width);
       virtual void SetGLPointSize(Float_t size);
       virtual void SetStack(Double_t *matrix=0);
       virtual void ShadeGLModel(EG3D2GLmode mode);

       virtual void TranslateGL(Double_t x, Double_t y, Double_t z);

       virtual void RunGLList(Int_t list);
       virtual void NewProjectionView(Double_t viewboxmin[], Double_t viewboxmax[], Bool_t perspective=kTRUE);
       virtual void NewModelView(Double_t *angles, Double_t *delta );
       virtual void PaintCone(Float_t *vertex, Int_t ndiv, Int_t nstacks);
       virtual void PaintPolyLine(Int_t n, Float_t *p, Option_t *option);
       virtual void PaintGLPointsObject(const TPoints3DABC *points, Option_t *option="");
       virtual void PaintBrik(Float_t vertex[24]);
       virtual void PaintXtru(Float_t *vertex, Int_t nxy, Int_t nz);

       virtual void SetRootLight(Bool_t flag=kTRUE) { fRootLight = flag; }
       virtual void SetLineAttr(Color_t color, Int_t width=1);
       virtual void UpdateMatrix(Double_t *translate=0, Double_t *rotate=0, Bool_t isreflection=kFALSE);

       void SetTrueColorMode(Bool_t flag=kTRUE) { fTrueColorMode = flag; }
    };

    //--- inlines ------------------------------------------------------------------
    inline void TVirtualGL::AddRotation(Double_t *,Double_t *) { }
    inline void TVirtualGL::BeginGLCmd(EG3D2GLmode) { }  // Begins the vertices of a primitive or a group of like primitives.
    inline void TVirtualGL::ClearColor(Int_t) { }
    inline void TVirtualGL::ClearGLColor(Float_t, Float_t, Float_t, Float_t) { }
    inline void TVirtualGL::ClearGL(UInt_t) { }
    inline Int_t TVirtualGL::CreateGLLists(Int_t) { return 0; }
    inline TGLViewerImp *TVirtualGL::CreateGLViewerImp(TPadOpenGLView *, const char *, UInt_t, UInt_t) { return 0; }
    inline TPadView3D *TVirtualGL::CreatePadGLView(TVirtualPad *) { return 0; }
    inline void TVirtualGL::DeleteGLLists(Int_t, Int_t) { }
    inline void TVirtualGL::DisableGL(EG3D2GLmode) { }
    inline void TVirtualGL::EnableGL(EG3D2GLmode) { }
    inline void TVirtualGL::FrontGLFace(EG3D2GLmode) { }
    inline void TVirtualGL::GetGL(EG3D2GLmode, UChar_t *) { }
    inline void TVirtualGL::GetGL(EG3D2GLmode, Double_t *) { }
    inline void TVirtualGL::GetGL(EG3D2GLmode, Float_t *) { }
    inline void TVirtualGL::GetGL(EG3D2GLmode, Int_t *) { }
    inline void TVirtualGL::MultGLMatrix(Double_t *) { }
    inline void TVirtualGL::NewGLList(UInt_t,EG3D2GLmode) { }
    inline void TVirtualGL::NewGLModelView(Int_t) { }
    inline void TVirtualGL::PaintGLPoints(Int_t, Float_t *, Option_t *) { }
    inline void TVirtualGL::PolygonGLMode(EG3D2GLmode , EG3D2GLmode) { }
    inline void TVirtualGL::RotateGL(Double_t, Double_t, Double_t, Double_t) { }
    inline void TVirtualGL::RotateGL(Double_t, Double_t, Double_t) { }
    inline void TVirtualGL::SetGLVertex(Float_t *) { }
    inline void TVirtualGL::SetGLColor(Float_t *) { }
    inline void TVirtualGL::SetGLColorIndex(Int_t) { }
    inline void TVirtualGL::SetGLLineWidth(Float_t) { }
    inline void TVirtualGL::SetGLPointSize(Float_t) { }
    inline void TVirtualGL::SetStack(Double_t *) { }
    inline void TVirtualGL::ShadeGLModel(EG3D2GLmode) { }
    inline void TVirtualGL::TranslateGL(Double_t, Double_t, Double_t) { }
    inline void TVirtualGL::RunGLList(Int_t) { }
    inline void TVirtualGL::NewProjectionView(Double_t [], Double_t [], Bool_t) { }
    inline void TVirtualGL::NewModelView(Double_t *, Double_t *) { }
    inline void TVirtualGL::PaintCone(Float_t *, Int_t, Int_t) { }
    inline void TVirtualGL::PaintPolyLine(Int_t, Float_t *, Option_t *) { }
    inline void TVirtualGL::PaintGLPointsObject(const TPoints3DABC *, Option_t *) { }
    inline void TVirtualGL::PaintBrik(Float_t [24]) { }
    inline void TVirtualGL::PaintXtru(Float_t *, Int_t, Int_t) { }
    inline void TVirtualGL::SetLineAttr(Color_t, Int_t) { }
    inline void TVirtualGL::UpdateMatrix(Double_t *, Double_t *, Bool_t) { }

    #endif