Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TGLUtil.h
Go to the documentation of this file.
1 // @(#)root/gl:$Id$
2 // Author: Richard Maunder 25/05/2005
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TGLUtil
13 #define ROOT_TGLUtil
14 
15 #include "Rtypes.h"
16 #include "TError.h"
17 
18 #include <vector>
19 #include <cmath>
20 #include <cassert>
21 
22 class TString;
23 class TGLBoundingBox;
24 class TGLCamera;
25 
26 class TAttMarker;
27 class TAttLine;
28 
29 class GLUtesselator;
30 
31 namespace Rgl
32 {
33  enum EOverlap
34  {
35  kInside = 0,
36  kPartial,
37  kOutside
38  };
39 }
40 
41 enum EGLCoordType
42 {
43  kGLCartesian,
44  kGLPolar,
45  kGLCylindrical,
46  kGLSpherical
47 };
48 
49 enum EGLPlotType
50 {
51  kGLLegoPlot,
52  kGLSurfacePlot,
53  kGLBoxPlot,
54  kGLTF3Plot,
55  kGLStackPlot,
56  kGLParametricPlot,
57  kGLIsoPlot,
58  kGL5D,
59  kGLTH3Composition,
60  kGLVoxel,
61  kGLDefaultPlot
62 };
63 
64 
65 // TODO: Split these into own h/cxx files - too long now!
66 
67 //////////////////////////////////////////////////////////////////////////
68 // //
69 // TGLVertex3 //
70 // //
71 // 3 component (x/y/z) vertex class //
72 // //
73 // This is part of collection of utility classes for GL in TGLUtil.h/cxx//
74 // These provide const and non-const accessors Arr() / CArr() to a GL //
75 // compatible internal field - so can be used directly with OpenGL C API//
76 // calls. They are not intended to be fully featured just provide //
77 // minimum required. //
78 //////////////////////////////////////////////////////////////////////////
79 
80 class TGLVector3; // Forward declare for Shift()
81 
82 class TGLVertex3
83 {
84 protected:
85  // Fields
86  Bool_t ValidIndex(UInt_t index) const { return (index < 3); }
87  Double_t fVals[3];
88 
89 public:
90  TGLVertex3();
91  TGLVertex3(Double_t x, Double_t y, Double_t z);
92  TGLVertex3(Double_t* v);
93  TGLVertex3(const TGLVertex3 & other);
94  ~TGLVertex3();
95 
96  Bool_t operator == (const TGLVertex3 & rhs) const;
97  TGLVertex3 & operator = (const TGLVertex3 & rhs);
98  TGLVertex3 & operator *= (Double_t f);
99  TGLVertex3 operator - () const;
100  const TGLVertex3 & operator -= (const TGLVector3 & val);
101  const TGLVertex3 & operator += (const TGLVector3 & val);
102 
103  // Manipulators
104  void Fill(Double_t val);
105  void Set(Double_t x, Double_t y, Double_t z);
106  void Set(const Double_t* xyz);
107  void Set(const TGLVertex3 & other);
108  void Shift(TGLVector3 & shift);
109  void Shift(Double_t xDelta, Double_t yDelta, Double_t zDelta);
110  void Negate();
111 
112  void Minimum(const TGLVertex3 & other);
113  void Maximum(const TGLVertex3 & other);
114 
115  // Accessors
116  Double_t & operator [] (Int_t index);
117  const Double_t & operator [] (Int_t index) const;
118  Double_t X() const { return fVals[0]; }
119  Double_t & X() { return fVals[0]; }
120  Double_t Y() const { return fVals[1]; }
121  Double_t & Y() { return fVals[1]; }
122  Double_t Z() const { return fVals[2]; }
123  Double_t & Z() { return fVals[2]; }
124 
125  const Double_t * CArr() const { return fVals; }
126  Double_t * Arr() { return fVals; }
127 
128  void Dump() const;
129 
130  ClassDefNV(TGLVertex3,1); // GL 3 component vertex helper/wrapper class
131 };
132 
133 //______________________________________________________________________________
134 inline TGLVertex3 operator*(Double_t f, const TGLVertex3& v)
135 {
136  return TGLVertex3(f*v.X(), f*v.Y(), f*v.Z());
137 }
138 
139 //______________________________________________________________________________
140 inline void TGLVertex3::Negate()
141 {
142  fVals[0] = -fVals[0];
143  fVals[1] = -fVals[1];
144  fVals[2] = -fVals[2];
145 }
146 
147 //______________________________________________________________________________
148 inline Bool_t TGLVertex3::operator == (const TGLVertex3 & rhs) const
149 {
150  return (fVals[0] == rhs.fVals[0] && fVals[1] == rhs.fVals[1] && fVals[2] == rhs.fVals[2]);
151 }
152 
153 //______________________________________________________________________________
154 inline TGLVertex3 & TGLVertex3::operator = (const TGLVertex3 & rhs)
155 {
156  // Check for self-assignment
157  if (this != &rhs) {
158  Set(rhs);
159  }
160  return *this;
161 }
162 
163 // operator -= & operator += inline needs to be defered until full TGLVector3 definition
164 
165 //______________________________________________________________________________
166 inline TGLVertex3 TGLVertex3::operator - () const
167 {
168  return TGLVertex3(-fVals[0], -fVals[1], -fVals[2]);
169 }
170 
171 //______________________________________________________________________________
172 inline TGLVertex3& TGLVertex3::operator *= (Double_t f)
173 {
174  fVals[0] *= f;
175  fVals[1] *= f;
176  fVals[2] *= f;
177  return *this;
178 }
179 
180 //______________________________________________________________________________
181 inline Double_t & TGLVertex3::operator [] (Int_t index)
182 {
183  /*if (!ValidIndex(index)) {
184  assert(kFALSE);
185  return fVals[0];
186  } else {*/
187  return fVals[index];
188  //}
189 }
190 
191 //______________________________________________________________________________
192 inline const Double_t& TGLVertex3::operator [] (Int_t index) const
193 {
194  /*if (!ValidIndex(index)) {
195  assert(kFALSE);
196  return fVals[0];
197  } else {*/
198  return fVals[index];
199  //}
200 }
201 
202 //______________________________________________________________________________
203 inline void TGLVertex3::Fill(Double_t val)
204 {
205  Set(val,val,val);
206 }
207 
208 //______________________________________________________________________________
209 inline void TGLVertex3::Set(Double_t x, Double_t y, Double_t z)
210 {
211  fVals[0]=x;
212  fVals[1]=y;
213  fVals[2]=z;
214 }
215 
216 //______________________________________________________________________________
217 inline void TGLVertex3::Set(const Double_t* xyz)
218 {
219  fVals[0]=xyz[0];
220  fVals[1]=xyz[1];
221  fVals[2]=xyz[2];
222 }
223 
224 //______________________________________________________________________________
225 inline void TGLVertex3::Set(const TGLVertex3 & other)
226 {
227  fVals[0]=other.fVals[0];
228  fVals[1]=other.fVals[1];
229  fVals[2]=other.fVals[2];
230 }
231 
232 
233 //////////////////////////////////////////////////////////////////////////
234 // //
235 // TGLVector3 //
236 // //
237 // 3 component (x/y/z) vector class //
238 // //
239 // This is part of collection of utility classes for GL in TGLUtil.h/cxx//
240 // These provide const and non-const accessors Arr() / CArr() to a GL //
241 // compatible internal field - so can be used directly with OpenGL C API//
242 // calls. They are not intended to be fully featured just provide //
243 // minimum required. //
244 //////////////////////////////////////////////////////////////////////////
245 
246 class TGLVector3 : public TGLVertex3
247 {
248 public:
249  TGLVector3() = default;
250  TGLVector3(Double_t x, Double_t y, Double_t z);
251  TGLVector3(const Double_t *src);
252 
253  TGLVector3& operator = (const TGLVertex3& v)
254  { fVals[0] = v[0]; fVals[1] = v[1]; fVals[2] = v[2]; return *this; }
255 
256  TGLVector3 & operator /= (Double_t val);
257  TGLVector3 operator - () const;
258 
259  Double_t Mag() const;
260  void Normalise();
261 
262  ClassDefNV(TGLVector3,1); // GL 3 component vector helper/wrapper class
263 };
264 
265 // Inline for TGLVertex3 requiring full TGLVector definition
266 //______________________________________________________________________________
267 inline const TGLVertex3 & TGLVertex3::operator -= (const TGLVector3 & vec)
268 {
269  fVals[0] -= vec[0]; fVals[1] -= vec[1]; fVals[2] -= vec[2];
270  return *this;
271 }
272 
273 // Inline for TGLVertex3 requiring full TGLVector definition
274 //______________________________________________________________________________
275 inline const TGLVertex3 & TGLVertex3::operator += (const TGLVector3 & vec)
276 {
277  fVals[0] += vec[0]; fVals[1] += vec[1]; fVals[2] += vec[2];
278  return *this;
279 }
280 
281 //______________________________________________________________________________
282 inline TGLVector3 & TGLVector3::operator /= (Double_t val)
283 {
284  fVals[0] /= val;
285  fVals[1] /= val;
286  fVals[2] /= val;
287  return *this;
288 }
289 
290 //______________________________________________________________________________
291 inline TGLVector3 TGLVector3::operator - () const
292 {
293  return TGLVector3(-fVals[0], -fVals[1], -fVals[2]);
294 }
295 
296 //______________________________________________________________________________
297 inline Double_t TGLVector3::Mag() const
298 {
299  return std::sqrt(fVals[0]*fVals[0] + fVals[1]*fVals[1] + fVals[2]*fVals[2]);
300 }
301 
302 //______________________________________________________________________________
303 inline void TGLVector3::Normalise()
304 {
305  Double_t mag = Mag();
306  if ( mag == 0.0 ) {
307  Error("TGLVector3::Normalise", "vector has zero magnitude");
308  return;
309  }
310  fVals[0] /= mag;
311  fVals[1] /= mag;
312  fVals[2] /= mag;
313 }
314 
315 //______________________________________________________________________________
316 inline Double_t Dot(const TGLVector3 & v1, const TGLVector3 & v2)
317 {
318  return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
319 }
320 
321 //______________________________________________________________________________
322 inline TGLVector3 Cross(const TGLVector3 & v1, const TGLVector3 & v2)
323 {
324  return TGLVector3(v1[1]*v2[2] - v2[1]*v1[2],
325  v1[2]*v2[0] - v2[2]*v1[0],
326  v1[0]*v2[1] - v2[0]*v1[1]);
327 }
328 
329 //______________________________________________________________________________
330 inline const TGLVector3 operator / (const TGLVector3 & vec, Double_t val)
331 {
332  return TGLVector3(vec[0] / val, vec[1] / val, vec[2] / val);
333 }
334 
335 //______________________________________________________________________________
336 inline const TGLVector3 operator * (const TGLVector3 & vec, Double_t val)
337 {
338  return TGLVector3(vec[0] * val, vec[1] * val, vec[2] * val);
339 }
340 
341 //______________________________________________________________________________
342 // Vertex + Vector => Vertex
343 inline TGLVertex3 operator + (const TGLVertex3 & vertex1, const TGLVector3 & vertex2)
344 {
345  return TGLVertex3(vertex1[0] + vertex2[0], vertex1[1] + vertex2[1], vertex1[2] + vertex2[2]);
346 }
347 
348 //______________________________________________________________________________
349 // Vertex - Vertex => Vector
350 inline TGLVector3 operator - (const TGLVertex3 & vertex1, const TGLVertex3 & vertex2)
351 {
352  return TGLVector3(vertex1[0] - vertex2[0], vertex1[1] - vertex2[1], vertex1[2] - vertex2[2]);
353 }
354 
355 //______________________________________________________________________________
356 // Vector + Vector => Vector
357 inline TGLVector3 operator + (const TGLVector3 & vector1, const TGLVector3 & vector2)
358 {
359  return TGLVector3(vector1[0] + vector2[0], vector1[1] + vector2[1], vector1[2] + vector2[2]);
360 }
361 
362 //______________________________________________________________________________
363 // Vector - Vector => Vector
364 inline TGLVector3 operator - (const TGLVector3 & vector1, const TGLVector3 & vector2)
365 {
366  return TGLVector3(vector1[0] - vector2[0], vector1[1] - vector2[1], vector1[2] - vector2[2]);
367 }
368 
369 //______________________________________________________________________________
370 // Dot-product
371 inline Double_t operator * (const TGLVector3 & a, const TGLVector3 & b)
372 {
373  return a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
374 }
375 
376 //////////////////////////////////////////////////////////////////////////
377 // //
378 // TGLLine3 //
379 // //
380 // 3D space, fixed length, line class, with direction / length 'vector',//
381 // passing through point 'vertex'. Just wraps a TGLVector3 / TGLVertex3 //
382 // pair. //
383 //////////////////////////////////////////////////////////////////////////
384 
385 class TGLLine3
386 {
387 private:
388  // Fields
389  TGLVertex3 fVertex; //! Start vertex of line
390  TGLVector3 fVector; //! Vector of line from fVertex
391 
392 public:
393  TGLLine3(const TGLVertex3 & start, const TGLVertex3 & end);
394  TGLLine3(const TGLVertex3 & start, const TGLVector3 & vector);
395  ~TGLLine3() = default;
396 
397  void Set(const TGLVertex3 & start, const TGLVertex3 & end);
398  void Set(const TGLVertex3 & start, const TGLVector3 & vector);
399 
400  // Bitwise copy constructor and = operator are fine
401 
402  // Accessors
403  const TGLVertex3 & Start() const { return fVertex; }
404  const TGLVertex3 End() const { return fVertex + fVector; }
405  const TGLVector3 & Vector() const { return fVector; }
406 
407  // Debug
408  void Draw() const;
409 
410  ClassDefNV(TGLLine3,0); // GL line wrapper class
411 };
412 
413 //////////////////////////////////////////////////////////////////////////
414 // //
415 // TGLRect //
416 // //
417 // Viewport (pixel base) 2D rectangle class //
418 //////////////////////////////////////////////////////////////////////////
419 
420 class TGLRect
421 {
422 private:
423  // Fields
424  Int_t fX, fY; //! Corner
425  Int_t fWidth, fHeight; //! Positive width/height
426 
427 public:
428  TGLRect();
429  TGLRect(Int_t x, Int_t y, Int_t width, Int_t height);
430  TGLRect(Int_t x, Int_t y, UInt_t width, UInt_t height);
431  virtual ~TGLRect();
432 
433  // Bitwise copy const & =op are ok at present
434 
435  // Manipulators
436  void Set(Int_t x, Int_t y, Int_t width, Int_t height);
437  void SetCorner(Int_t x, Int_t y);
438  void Offset(Int_t dX, Int_t dY);
439  void Expand(Int_t x, Int_t y);
440 
441  // Accessors
442  const Int_t* CArr() const { return &fX; }
443  Int_t* CArr() { return &fX; }
444 
445  Int_t X() const { return fX; }
446  Int_t & X() { return fX; }
447  Int_t Y() const { return fY; }
448  Int_t & Y() { return fY; }
449  Int_t Width() const { return fWidth; }
450  Int_t & Width() { return fWidth; }
451  Int_t Height() const { return fHeight; }
452  Int_t & Height() { return fHeight; }
453  Int_t CenterX() const { return fX + fWidth/2; }
454  Int_t CenterY() const { return fY + fHeight/2; }
455  Int_t Left() const { return fX; }
456  Int_t Right() const { return fX + fWidth; }
457  Int_t Top() const { return fY; }
458  Int_t Bottom() const { return fY + fHeight; }
459 
460  Int_t Diagonal() const;
461  Int_t Longest() const;
462 
463  Double_t Aspect() const;
464  Rgl::EOverlap Overlap(const TGLRect & other) const;
465 
466  ClassDef(TGLRect,0); // GL rect helper/wrapper class
467 };
468 
469 //______________________________________________________________________________
470 inline void TGLRect::Set(Int_t x, Int_t y, Int_t width, Int_t height)
471 {
472  fX = x;
473  fY = y;
474  fWidth = width;
475  fHeight = height;
476 }
477 
478 //______________________________________________________________________________
479 inline void TGLRect::SetCorner(Int_t x, Int_t y)
480 {
481  fX = x;
482  fY = y;
483 }
484 
485 //______________________________________________________________________________
486 inline void TGLRect::Offset(Int_t dX, Int_t dY)
487 {
488  fX += dX;
489  fY += dY;
490 }
491 
492 //______________________________________________________________________________
493 inline Int_t TGLRect::Longest() const
494 {
495  return fWidth > fHeight ? fWidth : fHeight;
496 }
497 
498 //______________________________________________________________________________
499 inline Double_t TGLRect::Aspect() const
500 {
501  // Return aspect ratio (width/height)
502  if (fHeight == 0) {
503  return 0.0;
504  } else {
505  return static_cast<Double_t>(fWidth) / static_cast<Double_t>(fHeight);
506  }
507 }
508 
509 //////////////////////////////////////////////////////////////////////////
510 // //
511 // TGLPlane //
512 // //
513 // 3D plane class - of format Ax + By + Cz + D = 0 //
514 // //
515 // This is part of collection of simple utility classes for GL only in //
516 // TGLUtil.h/cxx. These provide const and non-const accessors Arr() & //
517 // CArr() to a GL compatible internal field - so can be used directly //
518 // with OpenGL C API calls - which TVector3 etc cannot (easily). //
519 // They are not intended to be fully featured just provide minimum //
520 // required. //
521 //////////////////////////////////////////////////////////////////////////
522 
523 class TGLPlane
524 {
525 private:
526  // Fields
527  Double_t fVals[4];
528 
529  // Methods
530  void Normalise();
531 
532 public:
533  TGLPlane();
534  TGLPlane(const TGLPlane & other);
535  TGLPlane(Double_t a, Double_t b, Double_t c, Double_t d);
536  TGLPlane(Double_t eq[4]);
537  TGLPlane(const TGLVector3 & norm, const TGLVertex3 & point);
538  TGLPlane(const TGLVertex3 & p1, const TGLVertex3 & p2, const TGLVertex3 & p3);
539  ~TGLPlane() = default;
540 
541  TGLPlane &operator=(const TGLPlane &src);
542 
543  // Manipulators
544  void Set(const TGLPlane & other);
545  void Set(Double_t a, Double_t b, Double_t c, Double_t d);
546  void Set(Double_t eq[4]);
547  void Set(const TGLVector3 & norm, const TGLVertex3 & point);
548  void Set(const TGLVertex3 & p1, const TGLVertex3 & p2, const TGLVertex3 & p3);
549  void Negate();
550 
551  // Accessors
552  Double_t A() const { return fVals[0]; }
553  Double_t B() const { return fVals[1]; }
554  Double_t C() const { return fVals[2]; }
555  Double_t D() const { return fVals[3]; }
556 
557  TGLVector3 Norm() const { return TGLVector3( fVals[0], fVals[1], fVals[2]); }
558  Double_t DistanceTo(const TGLVertex3 & vertex) const;
559  TGLVertex3 NearestOn(const TGLVertex3 & point) const;
560 
561  // Internal data accessors - for GL API
562  const Double_t * CArr() const { return fVals; }
563  Double_t * Arr() { return fVals; }
564 
565  void Dump() const;
566 
567  ClassDefNV(TGLPlane,0); // GL plane helper/wrapper class
568 };
569 
570 typedef std::vector<TGLPlane> TGLPlaneSet_t;
571 typedef std::vector<TGLPlane>::iterator TGLPlaneSet_i;
572 typedef std::vector<TGLPlane>::const_iterator TGLPlaneSet_ci;
573 
574 // Some free functions for planes
575 std::pair<Bool_t, TGLLine3> Intersection(const TGLPlane & p1, const TGLPlane & p2);
576 std::pair<Bool_t, TGLVertex3> Intersection(const TGLPlane & p1, const TGLPlane & p2, const TGLPlane & p3);
577 std::pair<Bool_t, TGLVertex3> Intersection(const TGLPlane & plane, const TGLLine3 & line, Bool_t extend);
578 
579 
580 //////////////////////////////////////////////////////////////////////////
581 // //
582 // TGLMatrix //
583 // //
584 // 16 component (4x4) transform matrix - column MAJOR as per GL. //
585 // Provides limited support for adjusting the translation, scale and //
586 // rotation components. //
587 // //
588 // This is part of collection of simple utility classes for GL only in //
589 // TGLUtil.h/cxx. These provide const and non-const accessors Arr() & //
590 // CArr() to a GL compatible internal field - so can be used directly //
591 // with OpenGL C API calls - which TVector3 etc cannot (easily). //
592 // They are not intended to be fully featured just provide minimum //
593 // required. //
594 //////////////////////////////////////////////////////////////////////////
595 
596 class TGLMatrix
597 {
598 private:
599  // Fields
600  Double_t fVals[16]; // Column MAJOR as per OGL
601 
602  // Methods
603  Bool_t ValidIndex(UInt_t index) const { return (index < 16); }
604 
605 public:
606  TGLMatrix();
607  TGLMatrix(Double_t x, Double_t y, Double_t z);
608  TGLMatrix(const TGLVertex3 & translation);
609  TGLMatrix(const TGLVertex3 & origin, const TGLVector3 & zAxis, const TGLVector3 & xAxis);
610  TGLMatrix(const TGLVertex3 & origin, const TGLVector3 & zAxis);
611  TGLMatrix(const Double_t vals[16]);
612  TGLMatrix(const TGLMatrix & other);
613  virtual ~TGLMatrix();
614 
615  // Operators
616  TGLMatrix & operator =(const TGLMatrix & rhs);
617  Double_t & operator [] (Int_t index);
618  Double_t operator [] (Int_t index) const;
619 
620  void MultRight(const TGLMatrix & rhs);
621  void MultLeft (const TGLMatrix & lhs);
622  TGLMatrix & operator*=(const TGLMatrix & rhs) { MultRight(rhs); return *this; }
623 
624  // Manipulators
625  void Set(const TGLVertex3 & origin, const TGLVector3 & zAxis, const TGLVector3 & xAxis = 0);
626  void Set(const Double_t vals[16]);
627  void SetIdentity();
628 
629  void SetTranslation(Double_t x, Double_t y, Double_t z);
630  void SetTranslation(const TGLVertex3 & translation);
631 
632  void Translate(const TGLVector3 & vect);
633  void MoveLF(Int_t ai, Double_t amount);
634  void Move3LF(Double_t x, Double_t y, Double_t z);
635 
636  void Scale(const TGLVector3 & scale);
637  void Rotate(const TGLVertex3 & pivot, const TGLVector3 & axis, Double_t angle);
638  void RotateLF(Int_t i1, Int_t i2, Double_t amount);
639  void RotatePF(Int_t i1, Int_t i2, Double_t amount);
640  void TransformVertex(TGLVertex3 & vertex) const;
641  void Transpose3x3();
642  Double_t Invert();
643 
644  // Accesors
645  TGLVector3 GetTranslation() const;
646  TGLVector3 GetScale() const;
647  Bool_t IsScalingForRender() const;
648 
649  void SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z);
650  void SetBaseVec(Int_t b, const TGLVector3& v);
651  void SetBaseVec(Int_t b, Double_t* x);
652 
653  TGLVector3 GetBaseVec(Int_t b) const;
654  void GetBaseVec(Int_t b, TGLVector3& v) const;
655  void GetBaseVec(Int_t b, Double_t* x) const;
656 
657  TGLVector3 Multiply(const TGLVector3& v, Double_t w=1) const;
658  TGLVector3 Rotate(const TGLVector3& v) const;
659  void MultiplyIP(TGLVector3& v, Double_t w=1) const;
660  void RotateIP(TGLVector3& v) const;
661 
662  // Internal data accessors - for GL API
663  const Double_t * CArr() const { return fVals; }
664  Double_t * Arr() { return fVals; }
665 
666  void Dump() const;
667 
668  ClassDef(TGLMatrix,1); // GL matrix helper/wrapper class
669 };
670 
671 //______________________________________________________________________________
672 inline TGLMatrix & TGLMatrix::operator =(const TGLMatrix & rhs)
673 {
674  // Check for self-assignment
675  if (this != &rhs) {
676  Set(rhs.fVals);
677  }
678  return *this;
679 }
680 
681 //______________________________________________________________________________
682 inline Double_t & TGLMatrix::operator [] (Int_t index)
683 {
684  /*if (!ValidIndex(index)) {
685  assert(kFALSE);
686  return fVals[0];
687  } else {*/
688  return fVals[index];
689  //}
690 }
691 
692 //______________________________________________________________________________
693 inline Double_t TGLMatrix::operator [] (Int_t index) const
694 {
695  /*if (!ValidIndex(index)) {
696  assert(kFALSE);
697  return fVals[0];
698  } else {*/
699  return fVals[index];
700  //}
701 }
702 
703 //______________________________________________________________________________
704 inline TGLMatrix operator * (const TGLMatrix & lhs, const TGLMatrix & rhs)
705 {
706  TGLMatrix res;
707 
708  res[ 0] = rhs[ 0] * lhs[ 0] + rhs[ 1] * lhs[ 4] + rhs[ 2] * lhs[ 8] + rhs[ 3] * lhs[12];
709  res[ 1] = rhs[ 0] * lhs[ 1] + rhs[ 1] * lhs[ 5] + rhs[ 2] * lhs[ 9] + rhs[ 3] * lhs[13];
710  res[ 2] = rhs[ 0] * lhs[ 2] + rhs[ 1] * lhs[ 6] + rhs[ 2] * lhs[10] + rhs[ 3] * lhs[14];
711  res[ 3] = rhs[ 0] * lhs[ 3] + rhs[ 1] * lhs[ 7] + rhs[ 2] * lhs[11] + rhs[ 3] * lhs[15];
712 
713  res[ 4] = rhs[ 4] * lhs[ 0] + rhs[ 5] * lhs[ 4] + rhs[ 6] * lhs[ 8] + rhs[ 7] * lhs[12];
714  res[ 5] = rhs[ 4] * lhs[ 1] + rhs[ 5] * lhs[ 5] + rhs[ 6] * lhs[ 9] + rhs[ 7] * lhs[13];
715  res[ 6] = rhs[ 4] * lhs[ 2] + rhs[ 5] * lhs[ 6] + rhs[ 6] * lhs[10] + rhs[ 7] * lhs[14];
716  res[ 7] = rhs[ 4] * lhs[ 3] + rhs[ 5] * lhs[ 7] + rhs[ 6] * lhs[11] + rhs[ 7] * lhs[15];
717 
718  res[ 8] = rhs[ 8] * lhs[ 0] + rhs[ 9] * lhs[ 4] + rhs[10] * lhs[ 8] + rhs[11] * lhs[12];
719  res[ 9] = rhs[ 8] * lhs[ 1] + rhs[ 9] * lhs[ 5] + rhs[10] * lhs[ 9] + rhs[11] * lhs[13];
720  res[10] = rhs[ 8] * lhs[ 2] + rhs[ 9] * lhs[ 6] + rhs[10] * lhs[10] + rhs[11] * lhs[14];
721  res[11] = rhs[ 8] * lhs[ 3] + rhs[ 9] * lhs[ 7] + rhs[10] * lhs[11] + rhs[11] * lhs[15];
722 
723  res[12] = rhs[12] * lhs[ 0] + rhs[13] * lhs[ 4] + rhs[14] * lhs[ 8] + rhs[15] * lhs[12];
724  res[13] = rhs[12] * lhs[ 1] + rhs[13] * lhs[ 5] + rhs[14] * lhs[ 9] + rhs[15] * lhs[13];
725  res[14] = rhs[12] * lhs[ 2] + rhs[13] * lhs[ 6] + rhs[14] * lhs[10] + rhs[15] * lhs[14];
726  res[15] = rhs[12] * lhs[ 3] + rhs[13] * lhs[ 7] + rhs[14] * lhs[11] + rhs[15] * lhs[15];
727 
728  return res;
729 }
730 
731 //______________________________________________________________________________
732 inline void TGLMatrix::SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z)
733 {
734  Double_t* C = fVals + 4*--b;
735  C[0] = x; C[1] = y; C[2] = z;
736 }
737 
738 //______________________________________________________________________________
739 inline void TGLMatrix::SetBaseVec(Int_t b, const TGLVector3& v)
740 {
741  Double_t* C = fVals + 4*--b;
742  C[0] = v[0]; C[1] = v[1]; C[2] = v[2];
743 }
744 
745 //______________________________________________________________________________
746 inline void TGLMatrix::SetBaseVec(Int_t b, Double_t* x)
747 {
748  Double_t* C = fVals + 4*--b;
749  C[0] = x[0]; C[1] = x[1]; C[2] = x[2];
750 }
751 
752 //______________________________________________________________________________
753 inline TGLVector3 TGLMatrix::GetBaseVec(Int_t b) const
754 {
755  return TGLVector3(&fVals[4*--b]);
756 }
757 
758 //______________________________________________________________________________
759 inline void TGLMatrix::GetBaseVec(Int_t b, TGLVector3& v) const
760 {
761  const Double_t* C = fVals + 4*--b;
762  v[0] = C[0]; v[1] = C[1]; v[2] = C[2];
763 }
764 
765 //______________________________________________________________________________
766 inline void TGLMatrix::GetBaseVec(Int_t b, Double_t* x) const
767 {
768  const Double_t* C = fVals + 4*--b;
769  x[0] = C[0], x[1] = C[1], x[2] = C[2];
770 }
771 
772 
773 //////////////////////////////////////////////////////////////////////////
774 //
775 // TGLColor
776 //
777 // Encapsulate color in preferred GL format - UChar_t RGBA array.
778 // Color index is also cached for easier interfacing with the
779 // traditional ROOT graphics.
780 //
781 //////////////////////////////////////////////////////////////////////////
782 
783 class TGLColor
784 {
785 protected:
786  UChar_t fRGBA[4];
787  mutable Short_t fIndex;
788 
789 public:
790  TGLColor();
791  TGLColor(Int_t r, Int_t g, Int_t b, Int_t a=255);
792  TGLColor(Float_t r, Float_t g, Float_t b, Float_t a=1);
793  TGLColor(Color_t color_index, Char_t transparency=0);
794  TGLColor(const TGLColor& c);
795 
796  TGLColor& operator=(const TGLColor& c);
797 
798  UChar_t* Arr() { return fRGBA; }
799  const UChar_t* CArr() const { return fRGBA; }
800 
801  UChar_t GetRed() const { return fRGBA[0]; }
802  UChar_t GetGreen() const { return fRGBA[1]; }
803  UChar_t GetBlue() const { return fRGBA[2]; }
804  UChar_t GetAlpha() const { return fRGBA[3]; }
805 
806  Color_t GetColorIndex() const;
807  Char_t GetTransparency() const;
808 
809  void SetRed(Int_t v) { fRGBA[0] = v; }
810  void SetGreen(Int_t v) { fRGBA[1] = v; }
811  void SetBlue(Int_t v) { fRGBA[2] = v; }
812  void SetAlpha(Int_t v) { fRGBA[3] = v; }
813 
814  void SetColor(Int_t r, Int_t g, Int_t b, Int_t a=255);
815  void SetColor(Float_t r, Float_t g, Float_t b, Float_t a=1);
816  void SetColor(Color_t color_index);
817  void SetColor(Color_t color_index, Char_t transparency);
818  void SetTransparency(Char_t transparency);
819 
820  TString AsString() const;
821 
822  ClassDefNV(TGLColor, 0); // Color in preferred GL format - RGBA.
823 };
824 
825 
826 //////////////////////////////////////////////////////////////////////////
827 //
828 // TGLColorSet
829 //
830 // A collection of colors used for OpenGL rendering.
831 //
832 //////////////////////////////////////////////////////////////////////////
833 
834 class TGLColorSet
835 {
836 protected:
837  TGLColor fBackground;
838  TGLColor fForeground;
839  TGLColor fOutline;
840  TGLColor fMarkup;
841  TGLColor fSelection[5]; // Colors for shape-selection-levels
842 
843 public:
844  TGLColorSet();
845  TGLColorSet(const TGLColorSet& s);
846  ~TGLColorSet() = default;
847 
848  TGLColorSet& operator=(const TGLColorSet& s);
849 
850  TGLColor& Background() { return fBackground; }
851  TGLColor& Foreground() { return fForeground; }
852  TGLColor& Outline() { return fOutline; }
853  TGLColor& Markup() { return fMarkup; }
854  TGLColor& Selection(Int_t i) { return fSelection[i]; }
855 
856  const TGLColor& Background() const { return fBackground; }
857  const TGLColor& Foreground() const { return fForeground; }
858  const TGLColor& Outline() const { return fOutline; }
859  const TGLColor& Markup() const { return fMarkup; }
860  const TGLColor& Selection(Int_t i) const { return fSelection[i]; }
861 
862  void StdDarkBackground();
863  void StdLightBackground();
864 
865  ClassDefNV(TGLColorSet, 0); // Collection of colors used for GL rendering.
866 };
867 
868 //////////////////////////////////////////////////////////////////////////
869 // //
870 // TGLUtil //
871 // //
872 // Wrapper class for various misc static functions - error checking, //
873 // draw helpers etc. //
874 // //
875 //////////////////////////////////////////////////////////////////////////
876 
877 class TGLUtil
878 {
879 public:
880  class TColorLocker
881  {
882  public:
883  TColorLocker() { LockColor(); }
884  virtual ~TColorLocker() { UnlockColor(); }
885 
886  ClassDef(TColorLocker,0); // Lock/unlock color in constructor/destructor.
887  };
888 
889  class TDrawQualityModifier
890  {
891  Int_t fOldQuality;
892  public:
893  TDrawQualityModifier(Int_t dq) :
894  fOldQuality(GetDrawQuality()) {SetDrawQuality(dq); }
895 
896  virtual ~TDrawQualityModifier()
897  { SetDrawQuality(fOldQuality); }
898 
899  ClassDef(TDrawQualityModifier,0); // Set/restore draw quality in constructor/destructor.
900  };
901 
902  class TDrawQualityScaler
903  {
904  Int_t fOldQuality;
905  public:
906  TDrawQualityScaler(Float_t fac) :
907  fOldQuality(GetDrawQuality()) {SetDrawQuality((Int_t)(fac*fOldQuality)); }
908 
909  virtual ~TDrawQualityScaler()
910  { SetDrawQuality(fOldQuality); }
911 
912  ClassDef(TDrawQualityScaler,0); // Multiply/restore draw quality in constructor/destructor.
913  };
914 
915 private:
916  static UInt_t fgDefaultDrawQuality;
917  static UInt_t fgDrawQuality;
918 
919  static UInt_t fgColorLockCount;
920 
921  static Float_t fgPointSize;
922  static Float_t fgLineWidth;
923  static Float_t fgPointSizeScale;
924  static Float_t fgLineWidthScale;
925 
926  static Float_t fgScreenScalingFactor;
927  static Float_t fgPointLineScalingFactor;
928  static Int_t fgPickingRadius;
929 
930  TGLUtil(const TGLUtil&); // Not implemented.
931  TGLUtil& operator=(const TGLUtil&); // Not implemented.
932 
933 public:
934  virtual ~TGLUtil() {}
935  static void InitializeIfNeeded();
936 
937  // Error checking
938  static Int_t CheckError(const char * loc);
939 
940  // Polygon tesselator for direct drawing
941  static GLUtesselator* GetDrawTesselator3fv();
942  static GLUtesselator* GetDrawTesselator4fv();
943  static GLUtesselator* GetDrawTesselator3dv();
944  static GLUtesselator* GetDrawTesselator4dv();
945 
946  // Some simple shape drawing utils
947  enum ELineHeadShape { kLineHeadNone, kLineHeadArrow, kLineHeadBox };
948  enum EAxesType { kAxesNone, kAxesEdge, kAxesOrigin };
949 
950  static UInt_t GetDrawQuality();
951  static void SetDrawQuality(UInt_t dq);
952  static void ResetDrawQuality();
953  static UInt_t GetDefaultDrawQuality();
954  static void SetDefaultDrawQuality(UInt_t dq);
955 
956  static UInt_t LockColor();
957  static UInt_t UnlockColor();
958  static Bool_t IsColorLocked();
959 
960  static void Color(const TGLColor& color);
961  static void ColorAlpha(const TGLColor& color, UChar_t alpha);
962  static void ColorAlpha(const TGLColor& color, Float_t alpha);
963  static void ColorAlpha(Color_t color_index, Float_t alpha=1);
964  static void ColorTransparency(Color_t color_index, Char_t transparency=0);
965  static void Color3ub(UChar_t r, UChar_t g, UChar_t b);
966  static void Color4ub(UChar_t r, UChar_t g, UChar_t b, UChar_t a);
967  static void Color3ubv(const UChar_t* rgb);
968  static void Color4ubv(const UChar_t* rgba);
969  static void Color3f(Float_t r, Float_t g, Float_t b);
970  static void Color4f(Float_t r, Float_t g, Float_t b, Float_t a);
971  static void Color3fv(const Float_t* rgb);
972  static void Color4fv(const Float_t* rgba);
973 
974  // Coordinate conversion and extra scaling (needed for osx retina)
975  static void PointToViewport(Int_t& x, Int_t& y);
976  static void PointToViewport(Int_t& x, Int_t& y, Int_t& w, Int_t& h);
977  static Float_t GetScreenScalingFactor();
978  static Float_t GetPointLineScalingFactor();
979  static Int_t GetPickingRadius();
980 
981  static Float_t GetPointSizeScale();
982  static void SetPointSizeScale(Float_t scale);
983  static Float_t GetLineWidthScale();
984  static void SetLineWidthScale(Float_t scale);
985 
986  static void PointSize(Float_t point_size);
987  static void LineWidth(Float_t line_width);
988 
989  static Float_t PointSize();
990  static Float_t LineWidth();
991 
992  static void BeginExtendPickRegion(Float_t scale);
993  static void EndExtendPickRegion();
994 
995  static void RenderPolyMarkers(const TAttMarker& marker, Char_t transp,
996  Float_t* p, Int_t n,
997  Int_t pick_radius=0, Bool_t selection=kFALSE,
998  Bool_t sec_selection=kFALSE);
999 
1000  static void RenderPolyMarkers(const TAttMarker &marker, const std::vector<Double_t> &points,
1001  Double_t dX, Double_t dY, Double_t dZ);
1002 
1003  static void RenderPoints(const TAttMarker& marker,
1004  Float_t* p, Int_t n,
1005  Int_t pick_radius=0, Bool_t selection=kFALSE,
1006  Bool_t sec_selection=kFALSE);
1007 
1008  static void RenderPoints(const TAttMarker& marker,
1009  const std::vector<Double_t> &points);
1010 
1011  static void RenderCrosses(const TAttMarker& marker,
1012  Float_t* p, Int_t n,
1013  Bool_t sec_selection=kFALSE);
1014 
1015  static void RenderCrosses(const TAttMarker& marker,
1016  const std::vector<Double_t> &points,
1017  Double_t dX, Double_t dY, Double_t dZ);
1018 
1019  static void RenderPolyLine(const TAttLine& aline, Char_t transp,
1020  Float_t* p, Int_t n,
1021  Int_t pick_radius=0, Bool_t selection=kFALSE);
1022 
1023  static void BeginAttLine(const TAttLine& aline, Char_t transp,
1024  Int_t pick_radius=0, Bool_t selection=kFALSE);
1025  static void EndAttLine(Int_t pick_radius=0, Bool_t selection=kFALSE);
1026 
1027  // TODO: These draw routines should take LOD hints
1028  static void SetDrawColors(const UChar_t rgba[4]);
1029  static void DrawSphere(const TGLVertex3 & position, Double_t radius, const UChar_t rgba[4]);
1030  static void DrawLine(const TGLLine3 & line, ELineHeadShape head, Double_t size, const UChar_t rgba[4]);
1031  static void DrawLine(const TGLVertex3 & start, const TGLVector3 & vector, ELineHeadShape head,
1032  Double_t size, const UChar_t rgba[4]);
1033  static void DrawRing(const TGLVertex3 & center, const TGLVector3 & normal,
1034  Double_t radius, const UChar_t* rgba);
1035 
1036  static void DrawReferenceMarker(const TGLCamera & camera,
1037  const TGLVertex3 & pos,
1038  Float_t radius = 3,
1039  const UChar_t * rgba = 0);
1040  static void DrawSimpleAxes(const TGLCamera & camera,
1041  const TGLBoundingBox & bbox,
1042  Int_t axesType);
1043  static void DrawNumber(const TString & num,
1044  const TGLVertex3 & pos,
1045  Bool_t center = kFALSE);
1046 
1047  // Frequently used colors.
1048  static const UChar_t fgRed[4];
1049  static const UChar_t fgGreen[4];
1050  static const UChar_t fgBlue[4];
1051  static const UChar_t fgYellow[4];
1052  static const UChar_t fgWhite[4];
1053  static const UChar_t fgGrey[4];
1054 
1055  ClassDef(TGLUtil,0); // Wrapper class for misc GL pieces
1056 };
1057 
1058 /**************************************************************************/
1059 
1060 class TGLCapabilitySwitch
1061 {
1062 private:
1063  TGLCapabilitySwitch(const TGLCapabilitySwitch &);
1064  TGLCapabilitySwitch &operator = (const TGLCapabilitySwitch &);
1065 
1066  Int_t fWhat;
1067  Bool_t fState;
1068  Bool_t fFlip;
1069 
1070  void SetState(Bool_t s);
1071 
1072 public:
1073  TGLCapabilitySwitch(Int_t what, Bool_t state);
1074  ~TGLCapabilitySwitch();
1075 };
1076 
1077 class TGLCapabilityEnabler
1078 {
1079 private:
1080  TGLCapabilityEnabler(const TGLCapabilityEnabler &);
1081  TGLCapabilityEnabler &operator = (const TGLCapabilityEnabler &);
1082 
1083  Int_t fWhat;
1084  Bool_t fFlip;
1085 
1086 public:
1087  TGLCapabilityEnabler(Int_t what, Bool_t state);
1088  ~TGLCapabilityEnabler();
1089 };
1090 
1091 class TGLFloatHolder
1092 {
1093  TGLFloatHolder(const TGLFloatHolder&); // Not implemented
1094  TGLFloatHolder& operator=(const TGLFloatHolder&); // Not implemented
1095 
1096  Int_t fWhat;
1097  Float_t fState;
1098  Bool_t fFlip;
1099  void (*fFoo)(Float_t);
1100 
1101 public:
1102  TGLFloatHolder(Int_t what, Float_t state, void (*foo)(Float_t));
1103  ~TGLFloatHolder();
1104 };
1105 
1106 class TGLEnableGuard {
1107 private:
1108  Int_t fCap;
1109 
1110 public:
1111  TGLEnableGuard(Int_t cap);
1112  ~TGLEnableGuard();
1113 
1114 private:
1115  TGLEnableGuard(const TGLEnableGuard &);
1116  TGLEnableGuard &operator = (const TGLEnableGuard &);
1117 };
1118 
1119 class TGLDisableGuard {
1120 private:
1121  Int_t fCap;
1122 
1123 public:
1124  TGLDisableGuard(Int_t cap);
1125  ~TGLDisableGuard();
1126 
1127 private:
1128  TGLDisableGuard(const TGLDisableGuard &);
1129  TGLDisableGuard &operator = (const TGLDisableGuard &);
1130 };
1131 
1132 class TGLSelectionBuffer {
1133  std::vector<UChar_t> fBuffer;
1134  Int_t fWidth;
1135  Int_t fHeight;
1136 
1137 public:
1138  TGLSelectionBuffer();
1139  virtual ~TGLSelectionBuffer();
1140 
1141  void ReadColorBuffer(Int_t width, Int_t height);
1142  void ReadColorBuffer(Int_t x, Int_t y, Int_t width, Int_t height);
1143  const UChar_t *GetPixelColor(Int_t px, Int_t py)const;
1144 
1145 private:
1146  TGLSelectionBuffer(const TGLSelectionBuffer &);
1147  TGLSelectionBuffer &operator = (const TGLSelectionBuffer &);
1148 
1149  ClassDef(TGLSelectionBuffer, 0); //Holds color buffer content for selection
1150 };
1151 
1152 template<class T>
1153 class TGL2DArray : public std::vector<T> {
1154 private:
1155  Int_t fRowLen;
1156  Int_t fMaxRow;
1157  typedef typename std::vector<T>::size_type size_type;
1158 
1159 public:
1160  TGL2DArray() : fRowLen(0), fMaxRow(0){}
1161  void SetMaxRow(Int_t max)
1162  {
1163  fMaxRow = max;
1164  }
1165  void SetRowLen(Int_t len)
1166  {
1167  fRowLen = len;
1168  }
1169  const T *operator [] (size_type ind)const
1170  {
1171  return &std::vector<T>::operator [](ind * fRowLen);
1172  }
1173  T *operator [] (size_type ind)
1174  {
1175  return &std::vector<T>::operator [] (ind * fRowLen);
1176  }
1177 };
1178 
1179 class TGLPlotCoordinates;
1180 class TGLQuadric;
1181 class TAxis;
1182 
1183 namespace Rgl {
1184 
1185 extern const Float_t gRedEmission[];
1186 extern const Float_t gGreenEmission[];
1187 extern const Float_t gBlueEmission[];
1188 extern const Float_t gOrangeEmission[];
1189 extern const Float_t gWhiteEmission[];
1190 extern const Float_t gGrayEmission[];
1191 extern const Float_t gNullEmission[];
1192 
1193 typedef std::pair<Int_t, Int_t> BinRange_t;
1194 typedef std::pair<Double_t, Double_t> Range_t;
1195 
1196 void ObjectIDToColor(Int_t objectID, Bool_t highColor);
1197 Int_t ColorToObjectID(const UChar_t *color, Bool_t highColor);
1198 void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2,
1199  const TGLVertex3 &v3, const TGLVertex3 &v4);
1200 void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1,
1201  const TGLVertex3 &v2, const TGLVertex3 &v3,
1202  const TGLVector3 &normal);
1203 void DrawQuadFilled(const Double_t *v0, const Double_t *v1,
1204  const Double_t *v2, const Double_t *v3,
1205  const Double_t *normal);
1206 
1207 void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2,
1208  const TGLVertex3 &v3, const TGLVector3 &norm1,
1209  const TGLVector3 &norm2, const TGLVector3 &norm3);
1210 void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax,
1211  Double_t zMin, Double_t zMax, Int_t fp);
1212 
1213 void DrawTransparentBox(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax,
1214  Double_t zMin, Double_t zMax, Int_t fp);
1215 
1216 
1217 void DrawBoxFrontTextured(Double_t xMin, Double_t xMax, Double_t yMin,
1218  Double_t yMax, Double_t zMin, Double_t zMax,
1219  Double_t tMin, Double_t tMax, Int_t front);
1220 
1221 void DrawBoxWithGradientFill(Double_t y1, Double_t y2, Double_t x1, Double_t x2,
1222  const Double_t *rgba1, const Double_t *rgba2);
1223 
1224 void DrawQuadStripWithRadialGradientFill(unsigned nPoints, const Double_t *inner, const Double_t *innerRGBA,
1225  const Double_t *outer, const Double_t *outerRGBA);
1226 
1227 #ifndef __CINT__
1228 void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t zMax,
1229  Double_t tMin, Double_t tMax);
1230 void DrawTrapezoidTextured(const Double_t ver[][3], Double_t texMin, Double_t texMax);
1231 void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_t zMax,
1232  Double_t tMin, Double_t tMax);
1233 #endif
1234 
1235 void DrawCylinder(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
1236  Double_t yMax, Double_t zMin, Double_t zMax);
1237 void DrawSphere(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
1238  Double_t yMax, Double_t zMin, Double_t zMax);
1239 void DrawError(Double_t xMin, Double_t xMax, Double_t yMin,
1240  Double_t yMax, Double_t zMin, Double_t zMax);
1241 
1242 #ifndef __CINT__
1243 void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, Bool_t color = kTRUE);
1244 void DrawTrapezoid(const Double_t ver[][3]);
1245 #endif
1246 
1247 void DrawAxes(Int_t frontPoint, const Int_t *viewport, const TGLVertex3 *box2D,
1248  const TGLPlotCoordinates *plotCoord, TAxis *xAxis, TAxis *yAxis,
1249  TAxis *zAxis);
1250 void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax,
1251  Double_t zScale, std::vector<Double_t> &zLevels);
1252 
1253 void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3,
1254  Double_t t1, Double_t t2, Double_t t3, const TGLVector3 &norm1,
1255  const TGLVector3 &norm2, const TGLVector3 &norm3);
1256 void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3,
1257  Double_t t1, Double_t t2, Double_t t3, Double_t z, const TGLVector3 &planeNormal);
1258 void GetColor(Float_t v, Float_t vmin, Float_t vmax, Int_t type, Float_t *rgba);
1259 
1260 class TGuardBase {
1261 private:
1262  mutable Bool_t fActive;
1263 
1264  TGuardBase &operator = (const TGuardBase &rhs);
1265 protected:
1266  TGuardBase()
1267  : fActive(kTRUE)
1268  {
1269  }
1270  TGuardBase(const TGuardBase &rhs)
1271  : fActive(kTRUE)
1272  {
1273  rhs.fActive = kFALSE;
1274  }
1275 
1276  Bool_t IsActive()const
1277  {
1278  return fActive;
1279  }
1280 
1281 public:
1282  void Stop()const
1283  {
1284  fActive = kFALSE;
1285  }
1286 };
1287 
1288 template<class Func, class Arg>
1289 class TOneArgGuard : public TGuardBase {
1290 private:
1291  Func fFunc;
1292  Arg fArg;
1293 public:
1294  TOneArgGuard(Func f, Arg a)
1295  : fFunc(f), fArg(a)
1296  {
1297  }
1298  ~TOneArgGuard()
1299  {
1300  if (IsActive())
1301  fFunc(fArg);
1302  }
1303 };
1304 
1305 template<class Func, class Arg1, class Arg2>
1306 class TTwoArgsGuard : public TGuardBase {
1307 private:
1308  Func fFunc;
1309  Arg1 fArg1;
1310  Arg2 fArg2;
1311 
1312 public:
1313  TTwoArgsGuard(Func f, Arg1 a1, Arg2 a2)
1314  : fFunc(f), fArg1(a1), fArg2(a2)
1315  {
1316  }
1317  ~TTwoArgsGuard()
1318  {
1319  if (IsActive())
1320  fFunc(fArg1, fArg2);
1321  }
1322 };
1323 
1324 template<class Func, class Arg>
1325 TOneArgGuard<Func, Arg> make_guard(Func f, Arg a)
1326 {
1327  return TOneArgGuard<Func, Arg>(f, a);
1328 }
1329 
1330 template<class Func, class Arg1, class Arg2>
1331 TTwoArgsGuard<Func, Arg1, Arg2> make_guard(Func f, Arg1 a1, Arg2 a2)
1332 {
1333  return TTwoArgsGuard<Func, Arg1, Arg2>(f, a1, a2);
1334 }
1335 
1336 }//namespace Rgl.
1337 
1338 class TGLLevelPalette {
1339 private:
1340  std::vector<UChar_t> fTexels;
1341  const std::vector<Double_t> *fContours;
1342  UInt_t fPaletteSize;
1343  mutable UInt_t fTexture;
1344  Int_t fMaxPaletteSize;
1345  Rgl::Range_t fZRange;
1346 
1347  TGLLevelPalette(const TGLLevelPalette&); // Not implemented
1348  TGLLevelPalette& operator=(const TGLLevelPalette&); // Not implemented
1349 
1350 public:
1351  TGLLevelPalette();
1352 
1353  Bool_t GeneratePalette(UInt_t paletteSize, const Rgl::Range_t &zRange, Bool_t checkSize = kTRUE);
1354 
1355  void SetContours(const std::vector<Double_t> *contours);
1356 
1357  void EnableTexture(Int_t mode)const;
1358  void DisableTexture()const;
1359 
1360  Int_t GetPaletteSize()const;
1361 
1362  Double_t GetTexCoord(Double_t z)const;
1363 
1364  const UChar_t *GetColour(Double_t z)const;
1365  const UChar_t *GetColour(Int_t ind)const;
1366 };
1367 
1368 #endif // ROOT_TGLUtil