ROOT logo
// @(#)root/gl:$Id: TGLUtil.h 30815 2009-10-20 13:49:22Z rdm $
// 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_TGLUtil
#define ROOT_TGLUtil

#ifndef ROOT_Rtypes
#include "Rtypes.h"
#endif
#ifndef ROOT_TError
#include "TError.h"
#endif

class TString;
class TGLBoundingBox;
class TGLCamera;

class TAttMarker;
class TAttLine;

class GLUtesselator;

#include <vector>
#include <cmath>
#include <cassert>

// TODO:Find a better place for these enums - TGLEnum.h?
// Whole GL viewer should be moved into own namespace
// probably
enum EPosition
{
   kInFront = 0,
   kBehind
};

enum EOverlap
{
   kInside = 0,
   kPartial,
   kOutside
};

enum EClipType
{
   kClipNone = 0,
   kClipPlane,
   kClipBox
};

enum EManipType
{
   kManipTrans = 0,
   kManipScale,
   kManipRotate
};

enum EGLCoordType {
   kGLCartesian,
   kGLPolar,
   kGLCylindrical,
   kGLSpherical
};

enum EGLPlotType {
   kGLLegoPlot,
   kGLSurfacePlot,
   kGLBoxPlot,
   kGLTF3Plot,
   kGLStackPlot,
   kGLParametricPlot,
   kGLIsoPlot,
   kGL5D,
   kGLTH3Composition,
   kGLDefaultPlot
};


// TODO: Split these into own h/cxx files - too long now!

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLVertex3                                                           //
//                                                                      //
// 3 component (x/y/z) vertex class                                     //
//                                                                      //
// This is part of collection of utility classes for GL in TGLUtil.h/cxx//
// These provide const and non-const accessors Arr() / CArr() to a GL   //
// compatible internal field - so can be used directly with OpenGL C API//
// calls. They are not intended to be fully featured just provide       //
// minimum required.                                                    //
//////////////////////////////////////////////////////////////////////////

class TGLVector3; // Forward declare for Shift()

class TGLVertex3
{
protected:
   // Fields
   Bool_t ValidIndex(UInt_t index) const { return (index < 3); }
   Double_t fVals[3];

public:
   TGLVertex3();
   TGLVertex3(Double_t x, Double_t y, Double_t z);
   TGLVertex3(Double_t* v);
   TGLVertex3(const TGLVertex3 & other);
   virtual ~TGLVertex3();

   Bool_t       operator == (const TGLVertex3 & rhs) const;
   TGLVertex3 & operator =  (const TGLVertex3 & rhs);
   TGLVertex3 & operator *= (Double_t f);
   TGLVertex3   operator -  () const;
   const TGLVertex3 & operator -= (const TGLVector3 & val);
   const TGLVertex3 & operator += (const TGLVector3 & val);

   // Manipulators
   void Fill(Double_t val);
   void Set(Double_t x, Double_t y, Double_t z);
   void Set(const Double_t* xyz);
   void Set(const TGLVertex3 & other);
   void Shift(TGLVector3 & shift);
   void Shift(Double_t xDelta, Double_t yDelta, Double_t zDelta);
   void Negate();

   void Minimum(const TGLVertex3 & other);
   void Maximum(const TGLVertex3 & other);

   // Accessors
         Double_t & operator [] (Int_t index);
   const Double_t & operator [] (Int_t index) const;
   Double_t   X() const { return fVals[0]; }
   Double_t & X()       { return fVals[0]; }
   Double_t   Y() const { return fVals[1]; }
   Double_t & Y()       { return fVals[1]; }
   Double_t   Z() const { return fVals[2]; }
   Double_t & Z()       { return fVals[2]; }

   const Double_t * CArr() const { return fVals; }
   Double_t *       Arr()        { return fVals; }

   void Dump() const;

   ClassDef(TGLVertex3,0); // GL 3 component vertex helper/wrapper class
};

//______________________________________________________________________________
inline TGLVertex3 operator*(Double_t f, const TGLVertex3& v)
{
   return TGLVertex3(f*v.X(), f*v.Y(), f*v.Z());
}

//______________________________________________________________________________
inline void TGLVertex3::Negate()
{
   fVals[0] = -fVals[0];
   fVals[1] = -fVals[1];
   fVals[2] = -fVals[2];
}

//______________________________________________________________________________
inline Bool_t TGLVertex3::operator == (const TGLVertex3 & rhs) const
{
   return (fVals[0] == rhs.fVals[0] && fVals[1] == rhs.fVals[1] && fVals[2] == rhs.fVals[2]);
}

//______________________________________________________________________________
inline TGLVertex3 & TGLVertex3::operator = (const TGLVertex3 & rhs)
{
   // Check for self-assignment
   if (this != &rhs) {
      Set(rhs);
   }
   return *this;
}

// operator -= & operator += inline needs to be defered until full TGLVector3 definition

//______________________________________________________________________________
inline TGLVertex3 TGLVertex3::operator - () const
{
   return TGLVertex3(-fVals[0], -fVals[1], -fVals[2]);
}

//______________________________________________________________________________
inline TGLVertex3& TGLVertex3::operator *= (Double_t f)
{
   fVals[0] *= f;
   fVals[1] *= f;
   fVals[2] *= f;
   return *this;
}

//______________________________________________________________________________
inline Double_t & TGLVertex3::operator [] (Int_t index)
{
   /*if (!ValidIndex(index)) {
      assert(kFALSE);
      return fVals[0];
   } else {*/
      return fVals[index];
   //}
}

//______________________________________________________________________________
inline const Double_t& TGLVertex3::operator [] (Int_t index) const
{
   /*if (!ValidIndex(index)) {
      assert(kFALSE);
      return fVals[0];
   } else {*/
      return fVals[index];
   //}
}

//______________________________________________________________________________
inline void TGLVertex3::Fill(Double_t val)
{
   Set(val,val,val);
}

//______________________________________________________________________________
inline void TGLVertex3::Set(Double_t x, Double_t y, Double_t z)
{
   fVals[0]=x;
   fVals[1]=y;
   fVals[2]=z;
}

//______________________________________________________________________________
inline void TGLVertex3::Set(const Double_t* xyz)
{
   fVals[0]=xyz[0];
   fVals[1]=xyz[1];
   fVals[2]=xyz[2];
}

//______________________________________________________________________________
inline void TGLVertex3::Set(const TGLVertex3 & other)
{
   fVals[0]=other.fVals[0];
   fVals[1]=other.fVals[1];
   fVals[2]=other.fVals[2];
}


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLVector3                                                           //
//                                                                      //
// 3 component (x/y/z) vector class                                     //
//                                                                      //
// This is part of collection of utility classes for GL in TGLUtil.h/cxx//
// These provide const and non-const accessors Arr() / CArr() to a GL   //
// compatible internal field - so can be used directly with OpenGL C API//
// calls. They are not intended to be fully featured just provide       //
// minimum required.                                                    //
//////////////////////////////////////////////////////////////////////////

class TGLVector3 : public TGLVertex3
{
public:
   TGLVector3();
   TGLVector3(Double_t x, Double_t y, Double_t z);
   TGLVector3(const Double_t *src);
   TGLVector3(const TGLVector3 & other);
   virtual ~TGLVector3();

   TGLVector3& operator = (const TGLVertex3& v)
   { fVals[0] = v[0]; fVals[1] = v[1]; fVals[2] = v[2]; return *this; }

   TGLVector3 & operator /= (Double_t val);
   TGLVector3   operator -  () const;

   Double_t Mag() const;
   void     Normalise();

   ClassDef(TGLVector3,0); // GL 3 component vector helper/wrapper class
};

// Inline for TGLVertex3 requiring full TGLVector definition
//______________________________________________________________________________
inline const TGLVertex3 & TGLVertex3::operator -= (const TGLVector3 & vec)
{
   fVals[0] -= vec[0]; fVals[1] -= vec[1]; fVals[2] -= vec[2];
   return *this;
}

// Inline for TGLVertex3 requiring full TGLVector definition
//______________________________________________________________________________
inline const TGLVertex3 & TGLVertex3::operator += (const TGLVector3 & vec)
{
   fVals[0] += vec[0]; fVals[1] += vec[1]; fVals[2] += vec[2];
   return *this;
}

//______________________________________________________________________________
inline TGLVector3 & TGLVector3::operator /= (Double_t val)
{
   fVals[0] /= val;
   fVals[1] /= val;
   fVals[2] /= val;
   return *this;
}

//______________________________________________________________________________
inline TGLVector3 TGLVector3::operator - () const
{
   return TGLVector3(-fVals[0], -fVals[1], -fVals[2]);
}

//______________________________________________________________________________
inline Double_t TGLVector3::Mag() const
{
   return std::sqrt(fVals[0]*fVals[0] + fVals[1]*fVals[1] + fVals[2]*fVals[2]);
}

//______________________________________________________________________________
inline void TGLVector3::Normalise()
{
   Double_t mag = Mag();
   if ( mag == 0.0 ) {
      Error("TGLVector3::Normalise", "vector has zero magnitude");
      return;
   }
   fVals[0] /= mag;
   fVals[1] /= mag;
   fVals[2] /= mag;
}

//______________________________________________________________________________
inline Double_t Dot(const TGLVector3 & v1, const TGLVector3 & v2)
{
   return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
}

//______________________________________________________________________________
inline TGLVector3 Cross(const TGLVector3 & v1, const TGLVector3 & v2)
{
    return TGLVector3(v1[1]*v2[2] - v2[1]*v1[2],
                      v1[2]*v2[0] - v2[2]*v1[0],
                      v1[0]*v2[1] - v2[0]*v1[1]);
}

//______________________________________________________________________________
inline const TGLVector3 operator / (const TGLVector3 & vec, Double_t val)
{
   return TGLVector3(vec[0] / val, vec[1] / val, vec[2] / val);
}

//______________________________________________________________________________
inline const TGLVector3 operator * (const TGLVector3 & vec, Double_t val)
{
   return TGLVector3(vec[0] * val, vec[1] * val, vec[2] * val);
}

//______________________________________________________________________________
// Vertex + Vector => Vertex
inline TGLVertex3 operator + (const TGLVertex3 & vertex1, const TGLVector3 & vertex2)
{
   return TGLVertex3(vertex1[0] + vertex2[0], vertex1[1] + vertex2[1], vertex1[2] + vertex2[2]);
}

//______________________________________________________________________________
// Vertex - Vertex => Vector
inline TGLVector3 operator - (const TGLVertex3 & vertex1, const TGLVertex3 & vertex2)
{
   return TGLVector3(vertex1[0] - vertex2[0], vertex1[1] - vertex2[1], vertex1[2] - vertex2[2]);
}

//______________________________________________________________________________
// Vector + Vector => Vector
inline TGLVector3 operator + (const TGLVector3 & vector1, const TGLVector3 & vector2)
{
   return TGLVector3(vector1[0] + vector2[0], vector1[1] + vector2[1], vector1[2] + vector2[2]);
}

//______________________________________________________________________________
// Vector - Vector => Vector
inline TGLVector3 operator - (const TGLVector3 & vector1, const TGLVector3 & vector2)
{
   return TGLVector3(vector1[0] - vector2[0], vector1[1] - vector2[1], vector1[2] - vector2[2]);
}

//______________________________________________________________________________
// Dot-product
inline Double_t operator * (const TGLVector3 & a, const TGLVector3 & b)
{
   return a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLLine3                                                             //
//                                                                      //
// 3D space, fixed length, line class, with direction / length 'vector',//
// passing through point 'vertex'. Just wraps a TGLVector3 / TGLVertex3 //
// pair.                                                                //
//////////////////////////////////////////////////////////////////////////

class TGLLine3
{
private:
   // Fields
   TGLVertex3 fVertex; //! Start vertex of line
   TGLVector3 fVector; //! Vector of line from fVertex

public:
   TGLLine3(const TGLVertex3 & start, const TGLVertex3 & end);
   TGLLine3(const TGLVertex3 & start, const TGLVector3 & vector);
   virtual ~TGLLine3();

   void Set(const TGLVertex3 & start, const TGLVertex3 & end);
   void Set(const TGLVertex3 & start, const TGLVector3 & vector);

   // Bitwise copy constructor and = operator are fine

   // Accessors
   const TGLVertex3 & Start()  const { return fVertex; }
   const TGLVertex3   End()    const { return fVertex + fVector; }
   const TGLVector3 & Vector() const { return fVector; }

   // Debug
   void Draw() const;

   ClassDef(TGLLine3,0); // GL line wrapper class
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLRect                                                              //
//                                                                      //
// Viewport (pixel base) 2D rectangle class                             //
//////////////////////////////////////////////////////////////////////////

class TGLRect
{
private:
   // Fields
   Int_t    fX, fY;           //! Corner
   Int_t    fWidth, fHeight;  //! Positive width/height

public:
   TGLRect();
   TGLRect(Int_t x, Int_t y, Int_t width, Int_t height);
   TGLRect(Int_t x, Int_t y, UInt_t width, UInt_t height);
   virtual ~TGLRect();

   // Bitwise copy const & =op are ok at present

   // Manipulators
   void Set(Int_t x, Int_t y, Int_t width, Int_t height);
   void SetCorner(Int_t x, Int_t y);
   void Offset(Int_t dX, Int_t dY);
   void Expand(Int_t x, Int_t y);

   // Accessors
   const Int_t* CArr() const { return &fX; }
         Int_t* CArr()       { return &fX; }

   Int_t    X()       const { return fX; }
   Int_t &  X()             { return fX; }
   Int_t    Y()       const { return fY; }
   Int_t &  Y()             { return fY; }
   Int_t    Width()   const { return fWidth; }
   Int_t &  Width()         { return fWidth; }
   Int_t    Height()  const { return fHeight; }
   Int_t &  Height()        { return fHeight; }
   Int_t    CenterX() const { return fX + fWidth/2; }
   Int_t    CenterY() const { return fY + fHeight/2; }
   Int_t    Left()    const { return fX; }
   Int_t    Right()   const { return fX + fWidth; }
   Int_t    Top()     const { return fY; }
   Int_t    Bottom()  const { return fY + fHeight; }

   Int_t Diagonal() const;
   Int_t Longest() const;

   Double_t Aspect() const;
   EOverlap Overlap(const TGLRect & other) const;

   ClassDef(TGLRect,0); // GL rect helper/wrapper class
};

//______________________________________________________________________________
inline void TGLRect::Set(Int_t x, Int_t y, Int_t width, Int_t height)
{
   fX = x;
   fY = y;
   fWidth = width;
   fHeight = height;
}

//______________________________________________________________________________
inline void TGLRect::SetCorner(Int_t x, Int_t y)
{
   fX = x;
   fY = y;
}

//______________________________________________________________________________
inline void TGLRect::Offset(Int_t dX, Int_t dY)
{
   fX += dX;
   fY += dY;
}

//______________________________________________________________________________
inline void TGLRect::Expand(Int_t x, Int_t y)
{
   // Expand the rect to encompass point (x,y)
   Int_t delX = x - fX;
   Int_t delY = y - fY;

   if (delX>static_cast<Int_t>(fWidth)) {
      fWidth = delX;
   }
   if (delY>static_cast<Int_t>(fHeight)) {
      fHeight = delY;
   }

   if (delX<0) {
      fX = x;
      fWidth += -delX;
   }
   if (delY<0) {
      fY = y;
      fHeight += -delY;
   }
}

//______________________________________________________________________________
inline Int_t TGLRect::Diagonal() const
{
   const Double_t w = static_cast<Double_t>(fWidth);
   const Double_t h = static_cast<Double_t>(fHeight);
   return static_cast<Int_t>(std::sqrt(w*w + h*h));
}

//______________________________________________________________________________
inline Int_t TGLRect::Longest() const
{
   return fWidth > fHeight ? fWidth:fHeight;
}

//______________________________________________________________________________
inline Double_t TGLRect::Aspect() const
{
   // Return aspect ratio (width/height)
   if (fHeight == 0) {
      return 0.0;
   } else {
      return static_cast<Double_t>(fWidth) / static_cast<Double_t>(fHeight);
   }
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLPlane                                                             //
//                                                                      //
// 3D plane class - of format Ax + By + Cz + D = 0                      //
//                                                                      //
// This is part of collection of simple utility classes for GL only in  //
// TGLUtil.h/cxx. These provide const and non-const accessors Arr() &   //
// CArr() to a GL compatible internal field - so can be used directly   //
// with OpenGL C API calls - which TVector3 etc cannot (easily).        //
// They are not intended to be fully featured just provide minimum      //
// required.                                                            //
//////////////////////////////////////////////////////////////////////////

class TGLPlane
{
private:
   // Fields
   Double_t fVals[4];

   // Methods
   void Normalise();

public:
   TGLPlane();
   TGLPlane(const TGLPlane & other);
   TGLPlane(Double_t a, Double_t b, Double_t c, Double_t d);
   TGLPlane(Double_t eq[4]);
   TGLPlane(const TGLVector3 & norm, const TGLVertex3 & point);
   TGLPlane(const TGLVertex3 & p1, const TGLVertex3 & p2, const TGLVertex3 & p3);
   virtual ~TGLPlane();

   // Manipulators
   void Set(const TGLPlane & other);
   void Set(Double_t a, Double_t b, Double_t c, Double_t d);
   void Set(Double_t eq[4]);
   void Set(const TGLVector3 & norm, const TGLVertex3 & point);
   void Set(const TGLVertex3 & p1, const TGLVertex3 & p2, const TGLVertex3 & p3);
   void Negate();

   // Accessors
   Double_t A() const { return fVals[0]; }
   Double_t B() const { return fVals[1]; }
   Double_t C() const { return fVals[2]; }
   Double_t D() const { return fVals[3]; }

   TGLVector3 Norm() const { return TGLVector3( fVals[0], fVals[1], fVals[2]); }
   Double_t DistanceTo(const TGLVertex3 & vertex) const;
   TGLVertex3 NearestOn(const TGLVertex3 & point) const;

   // Internal data accessors - for GL API
   const Double_t * CArr() const { return fVals; }
   Double_t * Arr() { return fVals; }

   void Dump() const;

   ClassDef(TGLPlane,0); // GL plane helper/wrapper class
};

typedef std::vector<TGLPlane>                 TGLPlaneSet_t;
typedef std::vector<TGLPlane>::iterator       TGLPlaneSet_i;
typedef std::vector<TGLPlane>::const_iterator TGLPlaneSet_ci;

// Some free functions for planes
std::pair<Bool_t, TGLLine3>   Intersection(const TGLPlane & p1, const TGLPlane & p2);
std::pair<Bool_t, TGLVertex3> Intersection(const TGLPlane & p1, const TGLPlane & p2, const TGLPlane & p3);
std::pair<Bool_t, TGLVertex3> Intersection(const TGLPlane & plane, const TGLLine3 & line, Bool_t extend);


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLMatrix                                                            //
//                                                                      //
// 16 component (4x4) transform matrix - column MAJOR as per GL.        //
// Provides limited support for adjusting the translation, scale and    //
// rotation components.                                                 //
//                                                                      //
// This is part of collection of simple utility classes for GL only in  //
// TGLUtil.h/cxx. These provide const and non-const accessors Arr() &   //
// CArr() to a GL compatible internal field - so can be used directly   //
// with OpenGL C API calls - which TVector3 etc cannot (easily).        //
// They are not intended to be fully featured just provide minimum      //
// required.                                                            //
//////////////////////////////////////////////////////////////////////////

class TGLMatrix
{
private:
   // Fields
   Double_t fVals[16]; // Column MAJOR as per OGL

   // Methods
   Bool_t ValidIndex(UInt_t index) const { return (index < 16); }

public:
   TGLMatrix();
   TGLMatrix(Double_t x, Double_t y, Double_t z);
   TGLMatrix(const TGLVertex3 & translation);
   TGLMatrix(const TGLVertex3 & origin, const TGLVector3 & zAxis, const TGLVector3 & xAxis);
   TGLMatrix(const TGLVertex3 & origin, const TGLVector3 & zAxis);
   TGLMatrix(const Double_t vals[16]);
   TGLMatrix(const TGLMatrix & other);
   virtual ~TGLMatrix();

   // Operators
   TGLMatrix & operator =(const TGLMatrix & rhs);
   Double_t  & operator [] (Int_t index);
   Double_t    operator [] (Int_t index) const;

   void MultRight(const TGLMatrix & rhs);
   void MultLeft (const TGLMatrix & lhs);
   TGLMatrix & operator*=(const TGLMatrix & rhs) { MultRight(rhs); return *this; }

   // Manipulators
   void Set(const TGLVertex3 & origin, const TGLVector3 & zAxis, const TGLVector3 & xAxis = 0);
   void Set(const Double_t vals[16]);
   void SetIdentity();

   void SetTranslation(Double_t x, Double_t y, Double_t z);
   void SetTranslation(const TGLVertex3 & translation);

   void Translate(const TGLVector3 & vect);
   void MoveLF(Int_t ai, Double_t amount);
   void Move3LF(Double_t x, Double_t y, Double_t z);

   void Scale(const TGLVector3 & scale);
   void Rotate(const TGLVertex3 & pivot, const TGLVector3 & axis, Double_t angle);
   void RotateLF(Int_t i1, Int_t i2, Double_t amount);
   void RotatePF(Int_t i1, Int_t i2, Double_t amount);
   void TransformVertex(TGLVertex3 & vertex) const;
   void Transpose3x3();
   Double_t Invert();

   // Accesors
   TGLVector3  GetTranslation() const;
   TGLVector3  GetScale() const;

   void SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z);
   void SetBaseVec(Int_t b, const TGLVector3& v);
   void SetBaseVec(Int_t b, Double_t* x);

   TGLVector3 GetBaseVec(Int_t b) const;
   void       GetBaseVec(Int_t b, TGLVector3& v) const;
   void       GetBaseVec(Int_t b, Double_t* x) const;

   TGLVector3 Multiply(const TGLVector3& v, Double_t w=1) const;
   TGLVector3 Rotate(const TGLVector3& v) const;
   void       MultiplyIP(TGLVector3& v, Double_t w=1) const;
   void       RotateIP(TGLVector3& v) const;

   // Internal data accessors - for GL API
   const Double_t * CArr() const { return fVals; }
   Double_t * Arr() { return fVals; }

   void Dump() const;

   ClassDef(TGLMatrix,0); // GL matrix helper/wrapper class
};

//______________________________________________________________________________
inline TGLMatrix & TGLMatrix::operator =(const TGLMatrix & rhs)
{
   // Check for self-assignment
   if (this != &rhs) {
      Set(rhs.fVals);
   }
   return *this;
}

//______________________________________________________________________________
inline Double_t & TGLMatrix::operator [] (Int_t index)
{
   /*if (!ValidIndex(index)) {
      assert(kFALSE);
      return fVals[0];
   } else {*/
      return fVals[index];
   //}
}

//______________________________________________________________________________
inline Double_t TGLMatrix::operator [] (Int_t index) const
{
   /*if (!ValidIndex(index)) {
      assert(kFALSE);
      return fVals[0];
   } else {*/
      return fVals[index];
   //}
}

//______________________________________________________________________________
inline TGLMatrix operator * (const TGLMatrix & lhs, const TGLMatrix & rhs)
{
   TGLMatrix res;

   res[ 0] = rhs[ 0] * lhs[ 0] + rhs[ 1] * lhs[ 4] + rhs[ 2] * lhs[ 8] + rhs[ 3] * lhs[12];
   res[ 1] = rhs[ 0] * lhs[ 1] + rhs[ 1] * lhs[ 5] + rhs[ 2] * lhs[ 9] + rhs[ 3] * lhs[13];
   res[ 2] = rhs[ 0] * lhs[ 2] + rhs[ 1] * lhs[ 6] + rhs[ 2] * lhs[10] + rhs[ 3] * lhs[14];
   res[ 3] = rhs[ 0] * lhs[ 3] + rhs[ 1] * lhs[ 7] + rhs[ 2] * lhs[11] + rhs[ 3] * lhs[15];

   res[ 4] = rhs[ 4] * lhs[ 0] + rhs[ 5] * lhs[ 4] + rhs[ 6] * lhs[ 8] + rhs[ 7] * lhs[12];
   res[ 5] = rhs[ 4] * lhs[ 1] + rhs[ 5] * lhs[ 5] + rhs[ 6] * lhs[ 9] + rhs[ 7] * lhs[13];
   res[ 6] = rhs[ 4] * lhs[ 2] + rhs[ 5] * lhs[ 6] + rhs[ 6] * lhs[10] + rhs[ 7] * lhs[14];
   res[ 7] = rhs[ 4] * lhs[ 3] + rhs[ 5] * lhs[ 7] + rhs[ 6] * lhs[11] + rhs[ 7] * lhs[15];

   res[ 8] = rhs[ 8] * lhs[ 0] + rhs[ 9] * lhs[ 4] + rhs[10] * lhs[ 8] + rhs[11] * lhs[12];
   res[ 9] = rhs[ 8] * lhs[ 1] + rhs[ 9] * lhs[ 5] + rhs[10] * lhs[ 9] + rhs[11] * lhs[13];
   res[10] = rhs[ 8] * lhs[ 2] + rhs[ 9] * lhs[ 6] + rhs[10] * lhs[10] + rhs[11] * lhs[14];
   res[11] = rhs[ 8] * lhs[ 3] + rhs[ 9] * lhs[ 7] + rhs[10] * lhs[11] + rhs[11] * lhs[15];

   res[12] = rhs[12] * lhs[ 0] + rhs[13] * lhs[ 4] + rhs[14] * lhs[ 8] + rhs[15] * lhs[12];
   res[13] = rhs[12] * lhs[ 1] + rhs[13] * lhs[ 5] + rhs[14] * lhs[ 9] + rhs[15] * lhs[13];
   res[14] = rhs[12] * lhs[ 2] + rhs[13] * lhs[ 6] + rhs[14] * lhs[10] + rhs[15] * lhs[14];
   res[15] = rhs[12] * lhs[ 3] + rhs[13] * lhs[ 7] + rhs[14] * lhs[11] + rhs[15] * lhs[15];

   return res;
}

//______________________________________________________________________________
inline void TGLMatrix::SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z)
{
   Double_t* C = fVals + 4*--b;
   C[0] = x; C[1] = y; C[2] = z;
}

//______________________________________________________________________________
inline void TGLMatrix::SetBaseVec(Int_t b, const TGLVector3& v)
{
   Double_t* C = fVals + 4*--b;
   C[0] = v[0]; C[1] = v[1]; C[2] = v[2];
}

//______________________________________________________________________________
inline void TGLMatrix::SetBaseVec(Int_t b, Double_t* x)
{
   Double_t* C = fVals + 4*--b;
   C[0] = x[0]; C[1] = x[1]; C[2] = x[2];
}

//______________________________________________________________________________
inline TGLVector3 TGLMatrix::GetBaseVec(Int_t b) const
{
   return TGLVector3(&fVals[4*--b]);
}

//______________________________________________________________________________
inline void TGLMatrix::GetBaseVec(Int_t b, TGLVector3& v) const
{
   const Double_t* C = fVals + 4*--b;
   v[0] = C[0]; v[1] = C[1]; v[2] = C[2];
}

//______________________________________________________________________________
inline void TGLMatrix::GetBaseVec(Int_t b, Double_t* x) const
{
   const Double_t* C = fVals + 4*--b;
   x[0] = C[0], x[1] = C[1], x[2] = C[2];
}


//////////////////////////////////////////////////////////////////////////
//
// TGLColor
//
// Encapsulate color in preferred GL format - UChar_t RGBA array.
// Color index is also cached for easier interfacing with the
// traditional ROOT graphics.
//
//////////////////////////////////////////////////////////////////////////

class TGLColor
{
protected:
   UChar_t         fRGBA[4];
   mutable Short_t fIndex;

public:
   TGLColor();
   TGLColor(Int_t r, Int_t g, Int_t b, Int_t a=255);
   TGLColor(Float_t r, Float_t g, Float_t b, Float_t a=1);
   TGLColor(Color_t color_index, Char_t transparency=0);
   virtual ~TGLColor();

   TGLColor& operator=(const TGLColor& c);

   UChar_t*        Arr()       { return fRGBA; }
   const UChar_t* CArr() const { return fRGBA; }

   UChar_t GetRed()   const { return fRGBA[0]; }
   UChar_t GetGreen() const { return fRGBA[1]; }
   UChar_t GetBlue()  const { return fRGBA[2]; }
   UChar_t GetAlpha() const { return fRGBA[3]; }

   Color_t GetColorIndex()   const;
   Char_t  GetTransparency() const;

   void SetRed(Int_t v)   { fRGBA[0] = v; }
   void SetGreen(Int_t v) { fRGBA[1] = v; }
   void SetBlue(Int_t v)  { fRGBA[2] = v; }
   void SetAlpha(Int_t v) { fRGBA[3] = v; }

   void SetColor(Int_t r, Int_t g, Int_t b, Int_t a=255);
   void SetColor(Float_t r, Float_t g, Float_t b, Float_t a=1);
   void SetColor(Color_t color_index);
   void SetColor(Color_t color_index, Char_t transparency);
   void SetTransparency(Char_t transparency);

   TString AsString() const;

   ClassDef(TGLColor, 0); // Color in preferred GL format - RGBA.
};


//////////////////////////////////////////////////////////////////////////
//
// TGLColorSet
//
// A collection of colors used for OpenGL rendering.
//
//////////////////////////////////////////////////////////////////////////

class TGLColorSet
{
protected:
   TGLColor        fBackground;
   TGLColor        fForeground;
   TGLColor        fOutline;
   TGLColor        fMarkup;
   TGLColor        fSelection[5];   // Colors for shape-selection-levels

public:
   TGLColorSet();
   virtual ~TGLColorSet();

   TGLColorSet& operator=(const TGLColorSet& s);

   TGLColor& Background()       { return fBackground; }
   TGLColor& Foreground()       { return fForeground; }
   TGLColor& Outline()          { return fOutline; }
   TGLColor& Markup()           { return fMarkup;  }
   TGLColor& Selection(Int_t i) { return fSelection[i]; }

   const TGLColor& Background()       const { return fBackground; }
   const TGLColor& Foreground()       const { return fForeground; }
   const TGLColor& Outline()          const { return fOutline; }
   const TGLColor& Markup()           const { return fMarkup;  }
   const TGLColor& Selection(Int_t i) const { return fSelection[i]; }

   void StdDarkBackground();
   void StdLightBackground();

   ClassDef(TGLColorSet, 0); // Collection of colors used for GL rendering.
};

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLUtil                                                              //
//                                                                      //
// Wrapper class for various misc static functions - error checking,    //
// draw helpers etc.                                                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

class TGLUtil
{
public:
   class TColorLocker
   {
   public:
      TColorLocker()          { LockColor();   }
      virtual ~TColorLocker() { UnlockColor(); }

      ClassDef(TColorLocker,0); // Lock/unlock color in constructor/destructor.
   };

   class TDrawQualityModifier
   {
      Int_t fOldQuality;
   public:
      TDrawQualityModifier(Int_t dq) :
      fOldQuality(GetDrawQuality()) {SetDrawQuality(dq); }

      virtual ~TDrawQualityModifier()
      { SetDrawQuality(fOldQuality); }

      ClassDef(TDrawQualityModifier,0); // Set/restore draw quality in constructor/destructor.
   };

   class TDrawQualityScaler
   {
      Int_t fOldQuality;
   public:
      TDrawQualityScaler(Float_t fac) :
      fOldQuality(GetDrawQuality()) {SetDrawQuality((Int_t)(fac*fOldQuality)); }

      virtual ~TDrawQualityScaler()
      { SetDrawQuality(fOldQuality); }

      ClassDef(TDrawQualityScaler,0); // Multiply/restore draw quality in constructor/destructor.
   };

private:
   static UInt_t fgDefaultDrawQuality;
   static UInt_t fgDrawQuality;

   static UInt_t fgColorLockCount;

   static Float_t fgPointSize;
   static Float_t fgLineWidth;
   static Float_t fgPointSizeScale;
   static Float_t fgLineWidthScale;

   TGLUtil(const TGLUtil&);            // Not implemented.
   TGLUtil& operator=(const TGLUtil&); // Not implemented.

public:
   virtual ~TGLUtil() {}

   // Error checking
   static void   CheckError(const char * loc);

   // Polygon tesselator for direct drawing
   static GLUtesselator* GetDrawTesselator3fv();
   static GLUtesselator* GetDrawTesselator4fv();
   static GLUtesselator* GetDrawTesselator3dv();
   static GLUtesselator* GetDrawTesselator4dv();

   // Some simple shape drawing utils
   enum ELineHeadShape { kLineHeadNone, kLineHeadArrow, kLineHeadBox };
   enum EAxesType      { kAxesNone, kAxesEdge, kAxesOrigin };

   static UInt_t GetDrawQuality();
   static void   SetDrawQuality(UInt_t dq);
   static void   ResetDrawQuality();
   static UInt_t GetDefaultDrawQuality();
   static void   SetDefaultDrawQuality(UInt_t dq);

   static UInt_t LockColor();
   static UInt_t UnlockColor();
   static Bool_t IsColorLocked();

   static void Color(const TGLColor& color);
   static void Color(const TGLColor& color, UChar_t alpha);
   static void Color(const TGLColor& color, Float_t alpha);
   static void Color(Color_t color_index, Float_t alpha=1);
   static void ColorTransparency(Color_t color_index, Char_t transparency=0);
   static void Color3ub(UChar_t r, UChar_t g, UChar_t b);
   static void Color4ub(UChar_t r, UChar_t g, UChar_t b, UChar_t a);
   static void Color3ubv(const UChar_t* rgb);
   static void Color4ubv(const UChar_t* rgba);
   static void Color3f(Float_t r, Float_t g, Float_t b);
   static void Color4f(Float_t r, Float_t g, Float_t b, Float_t a);
   static void Color3fv(const Float_t* rgb);
   static void Color4fv(const Float_t* rgba);

   static Float_t GetPointSizeScale();
   static void    SetPointSizeScale(Float_t scale);
   static Float_t GetLineWidthScale();
   static void    SetLineWidthScale(Float_t scale);

   static void    PointSize(Float_t point_size);
   static void    LineWidth(Float_t line_width);

   static Float_t PointSize();
   static Float_t LineWidth();

   static void BeginExtendPickRegion(Float_t scale);
   static void EndExtendPickRegion();

   static void RenderPolyMarkers(const TAttMarker& marker, Float_t* p, Int_t n,
                                 Int_t pick_radius=0, Bool_t selection=kFALSE,
                                 Bool_t sec_selection=kFALSE);
   static void RenderPoints(const TAttMarker& marker, Float_t* p, Int_t n,
                            Int_t pick_radius=0, Bool_t selection=kFALSE,
                            Bool_t sec_selection=kFALSE);
   static void RenderCrosses(const TAttMarker& marker, Float_t* p, Int_t n,
                             Bool_t sec_selection=kFALSE);
   static void RenderPolyLine(const TAttLine& aline, Float_t* p, Int_t n,
                              Int_t pick_radius=0, Bool_t selection=kFALSE);

   static void BeginAttLine(const TAttLine& aline, Int_t pick_radius=0, Bool_t selection=kFALSE);
   static void EndAttLine(Int_t pick_radius=0, Bool_t selection=kFALSE);

   // TODO: These draw routines should take LOD hints
   static void SetDrawColors(const Float_t rgba[4]);
   static void DrawSphere(const TGLVertex3 & position, Double_t radius, const Float_t rgba[4]);
   static void DrawLine(const TGLLine3 & line, ELineHeadShape head, Double_t size, const Float_t rgba[4]);
   static void DrawLine(const TGLVertex3 & start, const TGLVector3 & vector, ELineHeadShape head,
                        Double_t size, const Float_t rgba[4]);
   static void DrawRing(const TGLVertex3 & center, const TGLVector3 & normal,
                        Double_t radius, const Float_t* rgba);

   static void DrawReferenceMarker(const TGLCamera  & camera,
                                   const TGLVertex3 & pos,
                                         Float_t      radius = 3,
                                   const Float_t    * rgba   = 0);
   static void DrawSimpleAxes(const TGLCamera      & camera,
                              const TGLBoundingBox & bbox,
                                    Int_t            axesType);
   static void DrawNumber(const TString    & num,
                          const TGLVertex3 & pos,
                                Bool_t       center = kFALSE);

   ClassDef(TGLUtil,0); // Wrapper class for misc GL pieces
};

/**************************************************************************/

class TGLCapabilitySwitch
{
private:
   TGLCapabilitySwitch(const TGLCapabilitySwitch &);
   TGLCapabilitySwitch &operator = (const TGLCapabilitySwitch &);

   Int_t    fWhat;
   Bool_t   fState;
   Bool_t   fFlip;

   void SetState(Bool_t s);

public:
   TGLCapabilitySwitch(Int_t what, Bool_t state);
   ~TGLCapabilitySwitch();
};

class TGLFloatHolder
{
   TGLFloatHolder(const TGLFloatHolder&);            // Not implemented
   TGLFloatHolder& operator=(const TGLFloatHolder&); // Not implemented

   Int_t    fWhat;
   Float_t  fState;
   Bool_t   fFlip;
   void   (*fFoo)(Float_t);

public:
   TGLFloatHolder(Int_t what, Float_t state, void (*foo)(Float_t));
   ~TGLFloatHolder();
};

class TGLEnableGuard {
private:
   Int_t fCap;

public:
   TGLEnableGuard(Int_t cap);
   ~TGLEnableGuard();

private:
   TGLEnableGuard(const TGLEnableGuard &);
   TGLEnableGuard &operator = (const TGLEnableGuard &);
};

class TGLDisableGuard {
private:
   Int_t fCap;

public:
   TGLDisableGuard(Int_t cap);
   ~TGLDisableGuard();

private:
   TGLDisableGuard(const TGLDisableGuard &);
   TGLDisableGuard &operator = (const TGLDisableGuard &);
};

class TGLSelectionBuffer {
   std::vector<UChar_t> fBuffer;
   Int_t                fWidth;
   Int_t                fHeight;

public:
   TGLSelectionBuffer();
   virtual ~TGLSelectionBuffer();

   void           ReadColorBuffer(Int_t width, Int_t height);
   void           ReadColorBuffer(Int_t x, Int_t y, Int_t width, Int_t height);
   const UChar_t *GetPixelColor(Int_t px, Int_t py)const;

private:
   TGLSelectionBuffer(const TGLSelectionBuffer &);
   TGLSelectionBuffer &operator = (const TGLSelectionBuffer &);

   ClassDef(TGLSelectionBuffer, 0); //Holds color buffer content for selection
};

template<class T>
class TGL2DArray : public std::vector<T> {
private:
   Int_t fRowLen;
   Int_t fMaxRow;
   typedef typename std::vector<T>::size_type size_type;

public:
   TGL2DArray() : fRowLen(0), fMaxRow(0){}
   void SetMaxRow(Int_t max)
   {
      fMaxRow = max;
   }
   void SetRowLen(Int_t len)
   {
      fRowLen = len;
   }
   const T *operator [] (size_type ind)const
   {
      return &std::vector<T>::operator [](ind * fRowLen);
   }
   T *operator [] (size_type ind)
   {
      return &std::vector<T>::operator [] (ind * fRowLen);
   }
};

class TGLPlotCoordinates;
class TGLQuadric;
class TAxis;

namespace Rgl {

   extern const Float_t gRedEmission[];
   extern const Float_t gGreenEmission[];
   extern const Float_t gBlueEmission[];
   extern const Float_t gOrangeEmission[];
   extern const Float_t gWhiteEmission[];
   extern const Float_t gGrayEmission[];
   extern const Float_t gNullEmission[];

   typedef std::pair<Int_t, Int_t> BinRange_t;
   typedef std::pair<Double_t, Double_t> Range_t;

   void ObjectIDToColor(Int_t objectID, Bool_t highColor);
   Int_t ColorToObjectID(const UChar_t *color, Bool_t highColor);
   void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2,
                        const TGLVertex3 &v3, const TGLVertex3 &v4);
   void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1,
                       const TGLVertex3 &v2, const TGLVertex3 &v3,
                       const TGLVector3 &normal);
   void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2,
                       const TGLVertex3 &v3, const TGLVector3 &norm1,
                       const TGLVector3 &norm2, const TGLVector3 &norm3);
   void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax,
                     Double_t zMin, Double_t zMax, Int_t fp);

   void DrawBoxFrontTextured(Double_t xMin, Double_t xMax, Double_t yMin,
                             Double_t yMax, Double_t zMin, Double_t zMax,
                             Double_t tMin, Double_t tMax, Int_t front);

#ifndef __CINT__
   void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t zMax,
                              Double_t tMin, Double_t tMax);
   void DrawTrapezoidTextured(const Double_t ver[][3], Double_t texMin, Double_t texMax);
   void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_t zMax,
                               Double_t tMin, Double_t tMax);
#endif

   void DrawCylinder(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
                     Double_t yMax, Double_t zMin, Double_t zMax);
   void DrawSphere(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
                   Double_t yMax, Double_t zMin, Double_t zMax);
   void DrawError(Double_t xMin, Double_t xMax, Double_t yMin,
                  Double_t yMax, Double_t zMin, Double_t zMax);

#ifndef __CINT__
   void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, Bool_t color = kTRUE);
   void DrawTrapezoid(const Double_t ver[][3]);
#endif

   void DrawAxes(Int_t frontPoint, const Int_t *viewport, const TGLVertex3 *box2D,
                 const TGLPlotCoordinates *plotCoord, TAxis *xAxis, TAxis *yAxis,
                 TAxis *zAxis);
   void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax,
                   Double_t zScale, std::vector<Double_t> &zLevels);

   void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3,
                         Double_t t1, Double_t t2, Double_t t3, const TGLVector3 &norm1,
                         const TGLVector3 &norm2, const TGLVector3 &norm3);
   void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3,
                         Double_t t1, Double_t t2, Double_t t3, Double_t z, const TGLVector3 &planeNormal);
   void GetColor(Float_t v, Float_t vmin, Float_t vmax, Int_t type, Float_t *rgba);

   class TGuardBase {
   private:
      mutable Bool_t fActive;

      TGuardBase &operator = (const TGuardBase &rhs);
   protected:
      TGuardBase()
         : fActive(kTRUE)
      {
      }
      TGuardBase(const TGuardBase &rhs)
         : fActive(kTRUE)
      {
         rhs.fActive = kFALSE;
      }

      Bool_t IsActive()const
      {
         return fActive;
      }

   public:
      void Stop()const
      {
         fActive = kFALSE;
      }
   };

   template<class Func, class Arg>
   class TOneArgGuard : public TGuardBase {
   private:
      Func fFunc;
      Arg  fArg;
   public:
      TOneArgGuard(Func f, Arg a)
         : fFunc(f), fArg(a)
      {
      }
      ~TOneArgGuard()
      {
         if (IsActive())
            fFunc(fArg);
      }
   };

   template<class Func, class Arg1, class Arg2>
   class TTwoArgsGuard : public TGuardBase {
   private:
      Func fFunc;
      Arg1 fArg1;
      Arg2 fArg2;

   public:
      TTwoArgsGuard(Func f, Arg1 a1, Arg2 a2)
         : fFunc(f), fArg1(a1), fArg2(a2)
      {
      }
      ~TTwoArgsGuard()
      {
         if (IsActive())
            fFunc(fArg1, fArg2);
      }
   };

   template<class Func, class Arg>
   TOneArgGuard<Func, Arg> make_guard(Func f, Arg a)
   {
      return TOneArgGuard<Func, Arg>(f, a);
   }

   template<class Func, class Arg1, class Arg2>
   TTwoArgsGuard<Func, Arg1, Arg2> make_guard(Func f, Arg1 a1, Arg2 a2)
   {
      return TTwoArgsGuard<Func, Arg1, Arg2>(f, a1, a2);
   }
}

class TGLLevelPalette {
private:
   std::vector<UChar_t>         fTexels;
   const std::vector<Double_t> *fContours;
   UInt_t                       fPaletteSize;
   mutable UInt_t               fTexture;
   Int_t                        fMaxPaletteSize;
   Rgl::Range_t                 fZRange;

   TGLLevelPalette(const TGLLevelPalette&);    // Not implemented
   TGLLevelPalette& operator=(const TGLLevelPalette&);  // Not implemented

public:
   TGLLevelPalette();

   Bool_t GeneratePalette(UInt_t paletteSize, const Rgl::Range_t &zRange, Bool_t checkSize = kTRUE);

   void   SetContours(const std::vector<Double_t> *contours);

   void   EnableTexture(Int_t mode)const;
   void   DisableTexture()const;

   Int_t  GetPaletteSize()const;

   Double_t       GetTexCoord(Double_t z)const;

   const UChar_t *GetColour(Double_t z)const;
   const UChar_t *GetColour(Int_t ind)const;
};

#endif // ROOT_TGLUtil
 TGLUtil.h:1
 TGLUtil.h:2
 TGLUtil.h:3
 TGLUtil.h:4
 TGLUtil.h:5
 TGLUtil.h:6
 TGLUtil.h:7
 TGLUtil.h:8
 TGLUtil.h:9
 TGLUtil.h:10
 TGLUtil.h:11
 TGLUtil.h:12
 TGLUtil.h:13
 TGLUtil.h:14
 TGLUtil.h:15
 TGLUtil.h:16
 TGLUtil.h:17
 TGLUtil.h:18
 TGLUtil.h:19
 TGLUtil.h:20
 TGLUtil.h:21
 TGLUtil.h:22
 TGLUtil.h:23
 TGLUtil.h:24
 TGLUtil.h:25
 TGLUtil.h:26
 TGLUtil.h:27
 TGLUtil.h:28
 TGLUtil.h:29
 TGLUtil.h:30
 TGLUtil.h:31
 TGLUtil.h:32
 TGLUtil.h:33
 TGLUtil.h:34
 TGLUtil.h:35
 TGLUtil.h:36
 TGLUtil.h:37
 TGLUtil.h:38
 TGLUtil.h:39
 TGLUtil.h:40
 TGLUtil.h:41
 TGLUtil.h:42
 TGLUtil.h:43
 TGLUtil.h:44
 TGLUtil.h:45
 TGLUtil.h:46
 TGLUtil.h:47
 TGLUtil.h:48
 TGLUtil.h:49
 TGLUtil.h:50
 TGLUtil.h:51
 TGLUtil.h:52
 TGLUtil.h:53
 TGLUtil.h:54
 TGLUtil.h:55
 TGLUtil.h:56
 TGLUtil.h:57
 TGLUtil.h:58
 TGLUtil.h:59
 TGLUtil.h:60
 TGLUtil.h:61
 TGLUtil.h:62
 TGLUtil.h:63
 TGLUtil.h:64
 TGLUtil.h:65
 TGLUtil.h:66
 TGLUtil.h:67
 TGLUtil.h:68
 TGLUtil.h:69
 TGLUtil.h:70
 TGLUtil.h:71
 TGLUtil.h:72
 TGLUtil.h:73
 TGLUtil.h:74
 TGLUtil.h:75
 TGLUtil.h:76
 TGLUtil.h:77
 TGLUtil.h:78
 TGLUtil.h:79
 TGLUtil.h:80
 TGLUtil.h:81
 TGLUtil.h:82
 TGLUtil.h:83
 TGLUtil.h:84
 TGLUtil.h:85
 TGLUtil.h:86
 TGLUtil.h:87
 TGLUtil.h:88
 TGLUtil.h:89
 TGLUtil.h:90
 TGLUtil.h:91
 TGLUtil.h:92
 TGLUtil.h:93
 TGLUtil.h:94
 TGLUtil.h:95
 TGLUtil.h:96
 TGLUtil.h:97
 TGLUtil.h:98
 TGLUtil.h:99
 TGLUtil.h:100
 TGLUtil.h:101
 TGLUtil.h:102
 TGLUtil.h:103
 TGLUtil.h:104
 TGLUtil.h:105
 TGLUtil.h:106
 TGLUtil.h:107
 TGLUtil.h:108
 TGLUtil.h:109
 TGLUtil.h:110
 TGLUtil.h:111
 TGLUtil.h:112
 TGLUtil.h:113
 TGLUtil.h:114
 TGLUtil.h:115
 TGLUtil.h:116
 TGLUtil.h:117
 TGLUtil.h:118
 TGLUtil.h:119
 TGLUtil.h:120
 TGLUtil.h:121
 TGLUtil.h:122
 TGLUtil.h:123
 TGLUtil.h:124
 TGLUtil.h:125
 TGLUtil.h:126
 TGLUtil.h:127
 TGLUtil.h:128
 TGLUtil.h:129
 TGLUtil.h:130
 TGLUtil.h:131
 TGLUtil.h:132
 TGLUtil.h:133
 TGLUtil.h:134
 TGLUtil.h:135
 TGLUtil.h:136
 TGLUtil.h:137
 TGLUtil.h:138
 TGLUtil.h:139
 TGLUtil.h:140
 TGLUtil.h:141
 TGLUtil.h:142
 TGLUtil.h:143
 TGLUtil.h:144
 TGLUtil.h:145
 TGLUtil.h:146
 TGLUtil.h:147
 TGLUtil.h:148
 TGLUtil.h:149
 TGLUtil.h:150
 TGLUtil.h:151
 TGLUtil.h:152
 TGLUtil.h:153
 TGLUtil.h:154
 TGLUtil.h:155
 TGLUtil.h:156
 TGLUtil.h:157
 TGLUtil.h:158
 TGLUtil.h:159
 TGLUtil.h:160
 TGLUtil.h:161
 TGLUtil.h:162
 TGLUtil.h:163
 TGLUtil.h:164
 TGLUtil.h:165
 TGLUtil.h:166
 TGLUtil.h:167
 TGLUtil.h:168
 TGLUtil.h:169
 TGLUtil.h:170
 TGLUtil.h:171
 TGLUtil.h:172
 TGLUtil.h:173
 TGLUtil.h:174
 TGLUtil.h:175
 TGLUtil.h:176
 TGLUtil.h:177
 TGLUtil.h:178
 TGLUtil.h:179
 TGLUtil.h:180
 TGLUtil.h:181
 TGLUtil.h:182
 TGLUtil.h:183
 TGLUtil.h:184
 TGLUtil.h:185
 TGLUtil.h:186
 TGLUtil.h:187
 TGLUtil.h:188
 TGLUtil.h:189
 TGLUtil.h:190
 TGLUtil.h:191
 TGLUtil.h:192
 TGLUtil.h:193
 TGLUtil.h:194
 TGLUtil.h:195
 TGLUtil.h:196
 TGLUtil.h:197
 TGLUtil.h:198
 TGLUtil.h:199
 TGLUtil.h:200
 TGLUtil.h:201
 TGLUtil.h:202
 TGLUtil.h:203
 TGLUtil.h:204
 TGLUtil.h:205
 TGLUtil.h:206
 TGLUtil.h:207
 TGLUtil.h:208
 TGLUtil.h:209
 TGLUtil.h:210
 TGLUtil.h:211
 TGLUtil.h:212
 TGLUtil.h:213
 TGLUtil.h:214
 TGLUtil.h:215
 TGLUtil.h:216
 TGLUtil.h:217
 TGLUtil.h:218
 TGLUtil.h:219
 TGLUtil.h:220
 TGLUtil.h:221
 TGLUtil.h:222
 TGLUtil.h:223
 TGLUtil.h:224
 TGLUtil.h:225
 TGLUtil.h:226
 TGLUtil.h:227
 TGLUtil.h:228
 TGLUtil.h:229
 TGLUtil.h:230
 TGLUtil.h:231
 TGLUtil.h:232
 TGLUtil.h:233
 TGLUtil.h:234
 TGLUtil.h:235
 TGLUtil.h:236
 TGLUtil.h:237
 TGLUtil.h:238
 TGLUtil.h:239
 TGLUtil.h:240
 TGLUtil.h:241
 TGLUtil.h:242
 TGLUtil.h:243
 TGLUtil.h:244
 TGLUtil.h:245
 TGLUtil.h:246
 TGLUtil.h:247
 TGLUtil.h:248
 TGLUtil.h:249
 TGLUtil.h:250
 TGLUtil.h:251
 TGLUtil.h:252
 TGLUtil.h:253
 TGLUtil.h:254
 TGLUtil.h:255
 TGLUtil.h:256
 TGLUtil.h:257
 TGLUtil.h:258
 TGLUtil.h:259
 TGLUtil.h:260
 TGLUtil.h:261
 TGLUtil.h:262
 TGLUtil.h:263
 TGLUtil.h:264
 TGLUtil.h:265
 TGLUtil.h:266
 TGLUtil.h:267
 TGLUtil.h:268
 TGLUtil.h:269
 TGLUtil.h:270
 TGLUtil.h:271
 TGLUtil.h:272
 TGLUtil.h:273
 TGLUtil.h:274
 TGLUtil.h:275
 TGLUtil.h:276
 TGLUtil.h:277
 TGLUtil.h:278
 TGLUtil.h:279
 TGLUtil.h:280
 TGLUtil.h:281
 TGLUtil.h:282
 TGLUtil.h:283
 TGLUtil.h:284
 TGLUtil.h:285
 TGLUtil.h:286
 TGLUtil.h:287
 TGLUtil.h:288
 TGLUtil.h:289
 TGLUtil.h:290
 TGLUtil.h:291
 TGLUtil.h:292
 TGLUtil.h:293
 TGLUtil.h:294
 TGLUtil.h:295
 TGLUtil.h:296
 TGLUtil.h:297
 TGLUtil.h:298
 TGLUtil.h:299
 TGLUtil.h:300
 TGLUtil.h:301
 TGLUtil.h:302
 TGLUtil.h:303
 TGLUtil.h:304
 TGLUtil.h:305
 TGLUtil.h:306
 TGLUtil.h:307
 TGLUtil.h:308
 TGLUtil.h:309
 TGLUtil.h:310
 TGLUtil.h:311
 TGLUtil.h:312
 TGLUtil.h:313
 TGLUtil.h:314
 TGLUtil.h:315
 TGLUtil.h:316
 TGLUtil.h:317
 TGLUtil.h:318
 TGLUtil.h:319
 TGLUtil.h:320
 TGLUtil.h:321
 TGLUtil.h:322
 TGLUtil.h:323
 TGLUtil.h:324
 TGLUtil.h:325
 TGLUtil.h:326
 TGLUtil.h:327
 TGLUtil.h:328
 TGLUtil.h:329
 TGLUtil.h:330
 TGLUtil.h:331
 TGLUtil.h:332
 TGLUtil.h:333
 TGLUtil.h:334
 TGLUtil.h:335
 TGLUtil.h:336
 TGLUtil.h:337
 TGLUtil.h:338
 TGLUtil.h:339
 TGLUtil.h:340
 TGLUtil.h:341
 TGLUtil.h:342
 TGLUtil.h:343
 TGLUtil.h:344
 TGLUtil.h:345
 TGLUtil.h:346
 TGLUtil.h:347
 TGLUtil.h:348
 TGLUtil.h:349
 TGLUtil.h:350
 TGLUtil.h:351
 TGLUtil.h:352
 TGLUtil.h:353
 TGLUtil.h:354
 TGLUtil.h:355
 TGLUtil.h:356
 TGLUtil.h:357
 TGLUtil.h:358
 TGLUtil.h:359
 TGLUtil.h:360
 TGLUtil.h:361
 TGLUtil.h:362
 TGLUtil.h:363
 TGLUtil.h:364
 TGLUtil.h:365
 TGLUtil.h:366
 TGLUtil.h:367
 TGLUtil.h:368
 TGLUtil.h:369
 TGLUtil.h:370
 TGLUtil.h:371
 TGLUtil.h:372
 TGLUtil.h:373
 TGLUtil.h:374
 TGLUtil.h:375
 TGLUtil.h:376
 TGLUtil.h:377
 TGLUtil.h:378
 TGLUtil.h:379
 TGLUtil.h:380
 TGLUtil.h:381
 TGLUtil.h:382
 TGLUtil.h:383
 TGLUtil.h:384
 TGLUtil.h:385
 TGLUtil.h:386
 TGLUtil.h:387
 TGLUtil.h:388
 TGLUtil.h:389
 TGLUtil.h:390
 TGLUtil.h:391
 TGLUtil.h:392
 TGLUtil.h:393
 TGLUtil.h:394
 TGLUtil.h:395
 TGLUtil.h:396
 TGLUtil.h:397
 TGLUtil.h:398
 TGLUtil.h:399
 TGLUtil.h:400
 TGLUtil.h:401
 TGLUtil.h:402
 TGLUtil.h:403
 TGLUtil.h:404
 TGLUtil.h:405
 TGLUtil.h:406
 TGLUtil.h:407
 TGLUtil.h:408
 TGLUtil.h:409
 TGLUtil.h:410
 TGLUtil.h:411
 TGLUtil.h:412
 TGLUtil.h:413
 TGLUtil.h:414
 TGLUtil.h:415
 TGLUtil.h:416
 TGLUtil.h:417
 TGLUtil.h:418
 TGLUtil.h:419
 TGLUtil.h:420
 TGLUtil.h:421
 TGLUtil.h:422
 TGLUtil.h:423
 TGLUtil.h:424
 TGLUtil.h:425
 TGLUtil.h:426
 TGLUtil.h:427
 TGLUtil.h:428
 TGLUtil.h:429
 TGLUtil.h:430
 TGLUtil.h:431
 TGLUtil.h:432
 TGLUtil.h:433
 TGLUtil.h:434
 TGLUtil.h:435
 TGLUtil.h:436
 TGLUtil.h:437
 TGLUtil.h:438
 TGLUtil.h:439
 TGLUtil.h:440
 TGLUtil.h:441
 TGLUtil.h:442
 TGLUtil.h:443
 TGLUtil.h:444
 TGLUtil.h:445
 TGLUtil.h:446
 TGLUtil.h:447
 TGLUtil.h:448
 TGLUtil.h:449
 TGLUtil.h:450
 TGLUtil.h:451
 TGLUtil.h:452
 TGLUtil.h:453
 TGLUtil.h:454
 TGLUtil.h:455
 TGLUtil.h:456
 TGLUtil.h:457
 TGLUtil.h:458
 TGLUtil.h:459
 TGLUtil.h:460
 TGLUtil.h:461
 TGLUtil.h:462
 TGLUtil.h:463
 TGLUtil.h:464
 TGLUtil.h:465
 TGLUtil.h:466
 TGLUtil.h:467
 TGLUtil.h:468
 TGLUtil.h:469
 TGLUtil.h:470
 TGLUtil.h:471
 TGLUtil.h:472
 TGLUtil.h:473
 TGLUtil.h:474
 TGLUtil.h:475
 TGLUtil.h:476
 TGLUtil.h:477
 TGLUtil.h:478
 TGLUtil.h:479
 TGLUtil.h:480
 TGLUtil.h:481
 TGLUtil.h:482
 TGLUtil.h:483
 TGLUtil.h:484
 TGLUtil.h:485
 TGLUtil.h:486
 TGLUtil.h:487
 TGLUtil.h:488
 TGLUtil.h:489
 TGLUtil.h:490
 TGLUtil.h:491
 TGLUtil.h:492
 TGLUtil.h:493
 TGLUtil.h:494
 TGLUtil.h:495
 TGLUtil.h:496
 TGLUtil.h:497
 TGLUtil.h:498
 TGLUtil.h:499
 TGLUtil.h:500
 TGLUtil.h:501
 TGLUtil.h:502
 TGLUtil.h:503
 TGLUtil.h:504
 TGLUtil.h:505
 TGLUtil.h:506
 TGLUtil.h:507
 TGLUtil.h:508
 TGLUtil.h:509
 TGLUtil.h:510
 TGLUtil.h:511
 TGLUtil.h:512
 TGLUtil.h:513
 TGLUtil.h:514
 TGLUtil.h:515
 TGLUtil.h:516
 TGLUtil.h:517
 TGLUtil.h:518
 TGLUtil.h:519
 TGLUtil.h:520
 TGLUtil.h:521
 TGLUtil.h:522
 TGLUtil.h:523
 TGLUtil.h:524
 TGLUtil.h:525
 TGLUtil.h:526
 TGLUtil.h:527
 TGLUtil.h:528
 TGLUtil.h:529
 TGLUtil.h:530
 TGLUtil.h:531
 TGLUtil.h:532
 TGLUtil.h:533
 TGLUtil.h:534
 TGLUtil.h:535
 TGLUtil.h:536
 TGLUtil.h:537
 TGLUtil.h:538
 TGLUtil.h:539
 TGLUtil.h:540
 TGLUtil.h:541
 TGLUtil.h:542
 TGLUtil.h:543
 TGLUtil.h:544
 TGLUtil.h:545
 TGLUtil.h:546
 TGLUtil.h:547
 TGLUtil.h:548
 TGLUtil.h:549
 TGLUtil.h:550
 TGLUtil.h:551
 TGLUtil.h:552
 TGLUtil.h:553
 TGLUtil.h:554
 TGLUtil.h:555
 TGLUtil.h:556
 TGLUtil.h:557
 TGLUtil.h:558
 TGLUtil.h:559
 TGLUtil.h:560
 TGLUtil.h:561
 TGLUtil.h:562
 TGLUtil.h:563
 TGLUtil.h:564
 TGLUtil.h:565
 TGLUtil.h:566
 TGLUtil.h:567
 TGLUtil.h:568
 TGLUtil.h:569
 TGLUtil.h:570
 TGLUtil.h:571
 TGLUtil.h:572
 TGLUtil.h:573
 TGLUtil.h:574
 TGLUtil.h:575
 TGLUtil.h:576
 TGLUtil.h:577
 TGLUtil.h:578
 TGLUtil.h:579
 TGLUtil.h:580
 TGLUtil.h:581
 TGLUtil.h:582
 TGLUtil.h:583
 TGLUtil.h:584
 TGLUtil.h:585
 TGLUtil.h:586
 TGLUtil.h:587
 TGLUtil.h:588
 TGLUtil.h:589
 TGLUtil.h:590
 TGLUtil.h:591
 TGLUtil.h:592
 TGLUtil.h:593
 TGLUtil.h:594
 TGLUtil.h:595
 TGLUtil.h:596
 TGLUtil.h:597
 TGLUtil.h:598
 TGLUtil.h:599
 TGLUtil.h:600
 TGLUtil.h:601
 TGLUtil.h:602
 TGLUtil.h:603
 TGLUtil.h:604
 TGLUtil.h:605
 TGLUtil.h:606
 TGLUtil.h:607
 TGLUtil.h:608
 TGLUtil.h:609
 TGLUtil.h:610
 TGLUtil.h:611
 TGLUtil.h:612
 TGLUtil.h:613
 TGLUtil.h:614
 TGLUtil.h:615
 TGLUtil.h:616
 TGLUtil.h:617
 TGLUtil.h:618
 TGLUtil.h:619
 TGLUtil.h:620
 TGLUtil.h:621
 TGLUtil.h:622
 TGLUtil.h:623
 TGLUtil.h:624
 TGLUtil.h:625
 TGLUtil.h:626
 TGLUtil.h:627
 TGLUtil.h:628
 TGLUtil.h:629
 TGLUtil.h:630
 TGLUtil.h:631
 TGLUtil.h:632
 TGLUtil.h:633
 TGLUtil.h:634
 TGLUtil.h:635
 TGLUtil.h:636
 TGLUtil.h:637
 TGLUtil.h:638
 TGLUtil.h:639
 TGLUtil.h:640
 TGLUtil.h:641
 TGLUtil.h:642
 TGLUtil.h:643
 TGLUtil.h:644
 TGLUtil.h:645
 TGLUtil.h:646
 TGLUtil.h:647
 TGLUtil.h:648
 TGLUtil.h:649
 TGLUtil.h:650
 TGLUtil.h:651
 TGLUtil.h:652
 TGLUtil.h:653
 TGLUtil.h:654
 TGLUtil.h:655
 TGLUtil.h:656
 TGLUtil.h:657
 TGLUtil.h:658
 TGLUtil.h:659
 TGLUtil.h:660
 TGLUtil.h:661
 TGLUtil.h:662
 TGLUtil.h:663
 TGLUtil.h:664
 TGLUtil.h:665
 TGLUtil.h:666
 TGLUtil.h:667
 TGLUtil.h:668
 TGLUtil.h:669
 TGLUtil.h:670
 TGLUtil.h:671
 TGLUtil.h:672
 TGLUtil.h:673
 TGLUtil.h:674
 TGLUtil.h:675
 TGLUtil.h:676
 TGLUtil.h:677
 TGLUtil.h:678
 TGLUtil.h:679
 TGLUtil.h:680
 TGLUtil.h:681
 TGLUtil.h:682
 TGLUtil.h:683
 TGLUtil.h:684
 TGLUtil.h:685
 TGLUtil.h:686
 TGLUtil.h:687
 TGLUtil.h:688
 TGLUtil.h:689
 TGLUtil.h:690
 TGLUtil.h:691
 TGLUtil.h:692
 TGLUtil.h:693
 TGLUtil.h:694
 TGLUtil.h:695
 TGLUtil.h:696
 TGLUtil.h:697
 TGLUtil.h:698
 TGLUtil.h:699
 TGLUtil.h:700
 TGLUtil.h:701
 TGLUtil.h:702
 TGLUtil.h:703
 TGLUtil.h:704
 TGLUtil.h:705
 TGLUtil.h:706
 TGLUtil.h:707
 TGLUtil.h:708
 TGLUtil.h:709
 TGLUtil.h:710
 TGLUtil.h:711
 TGLUtil.h:712
 TGLUtil.h:713
 TGLUtil.h:714
 TGLUtil.h:715
 TGLUtil.h:716
 TGLUtil.h:717
 TGLUtil.h:718
 TGLUtil.h:719
 TGLUtil.h:720
 TGLUtil.h:721
 TGLUtil.h:722
 TGLUtil.h:723
 TGLUtil.h:724
 TGLUtil.h:725
 TGLUtil.h:726
 TGLUtil.h:727
 TGLUtil.h:728
 TGLUtil.h:729
 TGLUtil.h:730
 TGLUtil.h:731
 TGLUtil.h:732
 TGLUtil.h:733
 TGLUtil.h:734
 TGLUtil.h:735
 TGLUtil.h:736
 TGLUtil.h:737
 TGLUtil.h:738
 TGLUtil.h:739
 TGLUtil.h:740
 TGLUtil.h:741
 TGLUtil.h:742
 TGLUtil.h:743
 TGLUtil.h:744
 TGLUtil.h:745
 TGLUtil.h:746
 TGLUtil.h:747
 TGLUtil.h:748
 TGLUtil.h:749
 TGLUtil.h:750
 TGLUtil.h:751
 TGLUtil.h:752
 TGLUtil.h:753
 TGLUtil.h:754
 TGLUtil.h:755
 TGLUtil.h:756
 TGLUtil.h:757
 TGLUtil.h:758
 TGLUtil.h:759
 TGLUtil.h:760
 TGLUtil.h:761
 TGLUtil.h:762
 TGLUtil.h:763
 TGLUtil.h:764
 TGLUtil.h:765
 TGLUtil.h:766
 TGLUtil.h:767
 TGLUtil.h:768
 TGLUtil.h:769
 TGLUtil.h:770
 TGLUtil.h:771
 TGLUtil.h:772
 TGLUtil.h:773
 TGLUtil.h:774
 TGLUtil.h:775
 TGLUtil.h:776
 TGLUtil.h:777
 TGLUtil.h:778
 TGLUtil.h:779
 TGLUtil.h:780
 TGLUtil.h:781
 TGLUtil.h:782
 TGLUtil.h:783
 TGLUtil.h:784
 TGLUtil.h:785
 TGLUtil.h:786
 TGLUtil.h:787
 TGLUtil.h:788
 TGLUtil.h:789
 TGLUtil.h:790
 TGLUtil.h:791
 TGLUtil.h:792
 TGLUtil.h:793
 TGLUtil.h:794
 TGLUtil.h:795
 TGLUtil.h:796
 TGLUtil.h:797
 TGLUtil.h:798
 TGLUtil.h:799
 TGLUtil.h:800
 TGLUtil.h:801
 TGLUtil.h:802
 TGLUtil.h:803
 TGLUtil.h:804
 TGLUtil.h:805
 TGLUtil.h:806
 TGLUtil.h:807
 TGLUtil.h:808
 TGLUtil.h:809
 TGLUtil.h:810
 TGLUtil.h:811
 TGLUtil.h:812
 TGLUtil.h:813
 TGLUtil.h:814
 TGLUtil.h:815
 TGLUtil.h:816
 TGLUtil.h:817
 TGLUtil.h:818
 TGLUtil.h:819
 TGLUtil.h:820
 TGLUtil.h:821
 TGLUtil.h:822
 TGLUtil.h:823
 TGLUtil.h:824
 TGLUtil.h:825
 TGLUtil.h:826
 TGLUtil.h:827
 TGLUtil.h:828
 TGLUtil.h:829
 TGLUtil.h:830
 TGLUtil.h:831
 TGLUtil.h:832
 TGLUtil.h:833
 TGLUtil.h:834
 TGLUtil.h:835
 TGLUtil.h:836
 TGLUtil.h:837
 TGLUtil.h:838
 TGLUtil.h:839
 TGLUtil.h:840
 TGLUtil.h:841
 TGLUtil.h:842
 TGLUtil.h:843
 TGLUtil.h:844
 TGLUtil.h:845
 TGLUtil.h:846
 TGLUtil.h:847
 TGLUtil.h:848
 TGLUtil.h:849
 TGLUtil.h:850
 TGLUtil.h:851
 TGLUtil.h:852
 TGLUtil.h:853
 TGLUtil.h:854
 TGLUtil.h:855
 TGLUtil.h:856
 TGLUtil.h:857
 TGLUtil.h:858
 TGLUtil.h:859
 TGLUtil.h:860
 TGLUtil.h:861
 TGLUtil.h:862
 TGLUtil.h:863
 TGLUtil.h:864
 TGLUtil.h:865
 TGLUtil.h:866
 TGLUtil.h:867
 TGLUtil.h:868
 TGLUtil.h:869
 TGLUtil.h:870
 TGLUtil.h:871
 TGLUtil.h:872
 TGLUtil.h:873
 TGLUtil.h:874
 TGLUtil.h:875
 TGLUtil.h:876
 TGLUtil.h:877
 TGLUtil.h:878
 TGLUtil.h:879
 TGLUtil.h:880
 TGLUtil.h:881
 TGLUtil.h:882
 TGLUtil.h:883
 TGLUtil.h:884
 TGLUtil.h:885
 TGLUtil.h:886
 TGLUtil.h:887
 TGLUtil.h:888
 TGLUtil.h:889
 TGLUtil.h:890
 TGLUtil.h:891
 TGLUtil.h:892
 TGLUtil.h:893
 TGLUtil.h:894
 TGLUtil.h:895
 TGLUtil.h:896
 TGLUtil.h:897
 TGLUtil.h:898
 TGLUtil.h:899
 TGLUtil.h:900
 TGLUtil.h:901
 TGLUtil.h:902
 TGLUtil.h:903
 TGLUtil.h:904
 TGLUtil.h:905
 TGLUtil.h:906
 TGLUtil.h:907
 TGLUtil.h:908
 TGLUtil.h:909
 TGLUtil.h:910
 TGLUtil.h:911
 TGLUtil.h:912
 TGLUtil.h:913
 TGLUtil.h:914
 TGLUtil.h:915
 TGLUtil.h:916
 TGLUtil.h:917
 TGLUtil.h:918
 TGLUtil.h:919
 TGLUtil.h:920
 TGLUtil.h:921
 TGLUtil.h:922
 TGLUtil.h:923
 TGLUtil.h:924
 TGLUtil.h:925
 TGLUtil.h:926
 TGLUtil.h:927
 TGLUtil.h:928
 TGLUtil.h:929
 TGLUtil.h:930
 TGLUtil.h:931
 TGLUtil.h:932
 TGLUtil.h:933
 TGLUtil.h:934
 TGLUtil.h:935
 TGLUtil.h:936
 TGLUtil.h:937
 TGLUtil.h:938
 TGLUtil.h:939
 TGLUtil.h:940
 TGLUtil.h:941
 TGLUtil.h:942
 TGLUtil.h:943
 TGLUtil.h:944
 TGLUtil.h:945
 TGLUtil.h:946
 TGLUtil.h:947
 TGLUtil.h:948
 TGLUtil.h:949
 TGLUtil.h:950
 TGLUtil.h:951
 TGLUtil.h:952
 TGLUtil.h:953
 TGLUtil.h:954
 TGLUtil.h:955
 TGLUtil.h:956
 TGLUtil.h:957
 TGLUtil.h:958
 TGLUtil.h:959
 TGLUtil.h:960
 TGLUtil.h:961
 TGLUtil.h:962
 TGLUtil.h:963
 TGLUtil.h:964
 TGLUtil.h:965
 TGLUtil.h:966
 TGLUtil.h:967
 TGLUtil.h:968
 TGLUtil.h:969
 TGLUtil.h:970
 TGLUtil.h:971
 TGLUtil.h:972
 TGLUtil.h:973
 TGLUtil.h:974
 TGLUtil.h:975
 TGLUtil.h:976
 TGLUtil.h:977
 TGLUtil.h:978
 TGLUtil.h:979
 TGLUtil.h:980
 TGLUtil.h:981
 TGLUtil.h:982
 TGLUtil.h:983
 TGLUtil.h:984
 TGLUtil.h:985
 TGLUtil.h:986
 TGLUtil.h:987
 TGLUtil.h:988
 TGLUtil.h:989
 TGLUtil.h:990
 TGLUtil.h:991
 TGLUtil.h:992
 TGLUtil.h:993
 TGLUtil.h:994
 TGLUtil.h:995
 TGLUtil.h:996
 TGLUtil.h:997
 TGLUtil.h:998
 TGLUtil.h:999
 TGLUtil.h:1000
 TGLUtil.h:1001
 TGLUtil.h:1002
 TGLUtil.h:1003
 TGLUtil.h:1004
 TGLUtil.h:1005
 TGLUtil.h:1006
 TGLUtil.h:1007
 TGLUtil.h:1008
 TGLUtil.h:1009
 TGLUtil.h:1010
 TGLUtil.h:1011
 TGLUtil.h:1012
 TGLUtil.h:1013
 TGLUtil.h:1014
 TGLUtil.h:1015
 TGLUtil.h:1016
 TGLUtil.h:1017
 TGLUtil.h:1018
 TGLUtil.h:1019
 TGLUtil.h:1020
 TGLUtil.h:1021
 TGLUtil.h:1022
 TGLUtil.h:1023
 TGLUtil.h:1024
 TGLUtil.h:1025
 TGLUtil.h:1026
 TGLUtil.h:1027
 TGLUtil.h:1028
 TGLUtil.h:1029
 TGLUtil.h:1030
 TGLUtil.h:1031
 TGLUtil.h:1032
 TGLUtil.h:1033
 TGLUtil.h:1034
 TGLUtil.h:1035
 TGLUtil.h:1036
 TGLUtil.h:1037
 TGLUtil.h:1038
 TGLUtil.h:1039
 TGLUtil.h:1040
 TGLUtil.h:1041
 TGLUtil.h:1042
 TGLUtil.h:1043
 TGLUtil.h:1044
 TGLUtil.h:1045
 TGLUtil.h:1046
 TGLUtil.h:1047
 TGLUtil.h:1048
 TGLUtil.h:1049
 TGLUtil.h:1050
 TGLUtil.h:1051
 TGLUtil.h:1052
 TGLUtil.h:1053
 TGLUtil.h:1054
 TGLUtil.h:1055
 TGLUtil.h:1056
 TGLUtil.h:1057
 TGLUtil.h:1058
 TGLUtil.h:1059
 TGLUtil.h:1060
 TGLUtil.h:1061
 TGLUtil.h:1062
 TGLUtil.h:1063
 TGLUtil.h:1064
 TGLUtil.h:1065
 TGLUtil.h:1066
 TGLUtil.h:1067
 TGLUtil.h:1068
 TGLUtil.h:1069
 TGLUtil.h:1070
 TGLUtil.h:1071
 TGLUtil.h:1072
 TGLUtil.h:1073
 TGLUtil.h:1074
 TGLUtil.h:1075
 TGLUtil.h:1076
 TGLUtil.h:1077
 TGLUtil.h:1078
 TGLUtil.h:1079
 TGLUtil.h:1080
 TGLUtil.h:1081
 TGLUtil.h:1082
 TGLUtil.h:1083
 TGLUtil.h:1084
 TGLUtil.h:1085
 TGLUtil.h:1086
 TGLUtil.h:1087
 TGLUtil.h:1088
 TGLUtil.h:1089
 TGLUtil.h:1090
 TGLUtil.h:1091
 TGLUtil.h:1092
 TGLUtil.h:1093
 TGLUtil.h:1094
 TGLUtil.h:1095
 TGLUtil.h:1096
 TGLUtil.h:1097
 TGLUtil.h:1098
 TGLUtil.h:1099
 TGLUtil.h:1100
 TGLUtil.h:1101
 TGLUtil.h:1102
 TGLUtil.h:1103
 TGLUtil.h:1104
 TGLUtil.h:1105
 TGLUtil.h:1106
 TGLUtil.h:1107
 TGLUtil.h:1108
 TGLUtil.h:1109
 TGLUtil.h:1110
 TGLUtil.h:1111
 TGLUtil.h:1112
 TGLUtil.h:1113
 TGLUtil.h:1114
 TGLUtil.h:1115
 TGLUtil.h:1116
 TGLUtil.h:1117
 TGLUtil.h:1118
 TGLUtil.h:1119
 TGLUtil.h:1120
 TGLUtil.h:1121
 TGLUtil.h:1122
 TGLUtil.h:1123
 TGLUtil.h:1124
 TGLUtil.h:1125
 TGLUtil.h:1126
 TGLUtil.h:1127
 TGLUtil.h:1128
 TGLUtil.h:1129
 TGLUtil.h:1130
 TGLUtil.h:1131
 TGLUtil.h:1132
 TGLUtil.h:1133
 TGLUtil.h:1134
 TGLUtil.h:1135
 TGLUtil.h:1136
 TGLUtil.h:1137
 TGLUtil.h:1138
 TGLUtil.h:1139
 TGLUtil.h:1140
 TGLUtil.h:1141
 TGLUtil.h:1142
 TGLUtil.h:1143
 TGLUtil.h:1144
 TGLUtil.h:1145
 TGLUtil.h:1146
 TGLUtil.h:1147
 TGLUtil.h:1148
 TGLUtil.h:1149
 TGLUtil.h:1150
 TGLUtil.h:1151
 TGLUtil.h:1152
 TGLUtil.h:1153
 TGLUtil.h:1154
 TGLUtil.h:1155
 TGLUtil.h:1156
 TGLUtil.h:1157
 TGLUtil.h:1158
 TGLUtil.h:1159
 TGLUtil.h:1160
 TGLUtil.h:1161
 TGLUtil.h:1162
 TGLUtil.h:1163
 TGLUtil.h:1164
 TGLUtil.h:1165
 TGLUtil.h:1166
 TGLUtil.h:1167
 TGLUtil.h:1168
 TGLUtil.h:1169
 TGLUtil.h:1170
 TGLUtil.h:1171
 TGLUtil.h:1172
 TGLUtil.h:1173
 TGLUtil.h:1174
 TGLUtil.h:1175
 TGLUtil.h:1176
 TGLUtil.h:1177
 TGLUtil.h:1178
 TGLUtil.h:1179
 TGLUtil.h:1180
 TGLUtil.h:1181
 TGLUtil.h:1182
 TGLUtil.h:1183
 TGLUtil.h:1184
 TGLUtil.h:1185
 TGLUtil.h:1186
 TGLUtil.h:1187
 TGLUtil.h:1188
 TGLUtil.h:1189
 TGLUtil.h:1190
 TGLUtil.h:1191
 TGLUtil.h:1192
 TGLUtil.h:1193
 TGLUtil.h:1194
 TGLUtil.h:1195
 TGLUtil.h:1196
 TGLUtil.h:1197
 TGLUtil.h:1198
 TGLUtil.h:1199
 TGLUtil.h:1200
 TGLUtil.h:1201
 TGLUtil.h:1202
 TGLUtil.h:1203
 TGLUtil.h:1204
 TGLUtil.h:1205
 TGLUtil.h:1206
 TGLUtil.h:1207
 TGLUtil.h:1208
 TGLUtil.h:1209
 TGLUtil.h:1210
 TGLUtil.h:1211
 TGLUtil.h:1212
 TGLUtil.h:1213
 TGLUtil.h:1214
 TGLUtil.h:1215
 TGLUtil.h:1216
 TGLUtil.h:1217
 TGLUtil.h:1218
 TGLUtil.h:1219
 TGLUtil.h:1220
 TGLUtil.h:1221
 TGLUtil.h:1222
 TGLUtil.h:1223
 TGLUtil.h:1224
 TGLUtil.h:1225
 TGLUtil.h:1226
 TGLUtil.h:1227
 TGLUtil.h:1228
 TGLUtil.h:1229
 TGLUtil.h:1230
 TGLUtil.h:1231
 TGLUtil.h:1232
 TGLUtil.h:1233
 TGLUtil.h:1234
 TGLUtil.h:1235
 TGLUtil.h:1236
 TGLUtil.h:1237
 TGLUtil.h:1238
 TGLUtil.h:1239
 TGLUtil.h:1240
 TGLUtil.h:1241
 TGLUtil.h:1242
 TGLUtil.h:1243
 TGLUtil.h:1244
 TGLUtil.h:1245
 TGLUtil.h:1246
 TGLUtil.h:1247
 TGLUtil.h:1248
 TGLUtil.h:1249
 TGLUtil.h:1250
 TGLUtil.h:1251
 TGLUtil.h:1252
 TGLUtil.h:1253
 TGLUtil.h:1254
 TGLUtil.h:1255
 TGLUtil.h:1256
 TGLUtil.h:1257
 TGLUtil.h:1258
 TGLUtil.h:1259
 TGLUtil.h:1260
 TGLUtil.h:1261
 TGLUtil.h:1262
 TGLUtil.h:1263
 TGLUtil.h:1264
 TGLUtil.h:1265
 TGLUtil.h:1266
 TGLUtil.h:1267
 TGLUtil.h:1268
 TGLUtil.h:1269
 TGLUtil.h:1270
 TGLUtil.h:1271
 TGLUtil.h:1272
 TGLUtil.h:1273
 TGLUtil.h:1274
 TGLUtil.h:1275
 TGLUtil.h:1276
 TGLUtil.h:1277
 TGLUtil.h:1278
 TGLUtil.h:1279
 TGLUtil.h:1280
 TGLUtil.h:1281
 TGLUtil.h:1282
 TGLUtil.h:1283
 TGLUtil.h:1284
 TGLUtil.h:1285
 TGLUtil.h:1286
 TGLUtil.h:1287
 TGLUtil.h:1288
 TGLUtil.h:1289
 TGLUtil.h:1290
 TGLUtil.h:1291
 TGLUtil.h:1292
 TGLUtil.h:1293
 TGLUtil.h:1294
 TGLUtil.h:1295
 TGLUtil.h:1296
 TGLUtil.h:1297
 TGLUtil.h:1298
 TGLUtil.h:1299
 TGLUtil.h:1300
 TGLUtil.h:1301
 TGLUtil.h:1302
 TGLUtil.h:1303
 TGLUtil.h:1304
 TGLUtil.h:1305
 TGLUtil.h:1306
 TGLUtil.h:1307
 TGLUtil.h:1308
 TGLUtil.h:1309
 TGLUtil.h:1310
 TGLUtil.h:1311
 TGLUtil.h:1312
 TGLUtil.h:1313
 TGLUtil.h:1314
 TGLUtil.h:1315
 TGLUtil.h:1316
 TGLUtil.h:1317
 TGLUtil.h:1318
 TGLUtil.h:1319
 TGLUtil.h:1320
 TGLUtil.h:1321
 TGLUtil.h:1322
 TGLUtil.h:1323
 TGLUtil.h:1324
 TGLUtil.h:1325
 TGLUtil.h:1326
 TGLUtil.h:1327
 TGLUtil.h:1328
 TGLUtil.h:1329
 TGLUtil.h:1330
 TGLUtil.h:1331
 TGLUtil.h:1332
 TGLUtil.h:1333
 TGLUtil.h:1334
 TGLUtil.h:1335
 TGLUtil.h:1336
 TGLUtil.h:1337
 TGLUtil.h:1338
 TGLUtil.h:1339
 TGLUtil.h:1340
 TGLUtil.h:1341
 TGLUtil.h:1342
 TGLUtil.h:1343
 TGLUtil.h:1344
 TGLUtil.h:1345
 TGLUtil.h:1346
 TGLUtil.h:1347
 TGLUtil.h:1348
 TGLUtil.h:1349
 TGLUtil.h:1350
 TGLUtil.h:1351
 TGLUtil.h:1352