Logo ROOT   6.19/01
Reference Guide
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,
38  };
39 }
40 
42 {
47 };
48 
50 {
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 
83 {
84 protected:
85  // Fields
86  Bool_t ValidIndex(UInt_t index) const { return (index < 3); }
88 
89 public:
90  TGLVertex3();
93  TGLVertex3(const TGLVertex3 & other);
94  ~TGLVertex3();
95 
96  Bool_t operator == (const TGLVertex3 & rhs) const;
97  TGLVertex3 & operator = (const TGLVertex3 & rhs);
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 //______________________________________________________________________________
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 //______________________________________________________________________________
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 //______________________________________________________________________________
167 {
168  return TGLVertex3(-fVals[0], -fVals[1], -fVals[2]);
169 }
170 
171 //______________________________________________________________________________
173 {
174  fVals[0] *= f;
175  fVals[1] *= f;
176  fVals[2] *= f;
177  return *this;
178 }
179 
180 //______________________________________________________________________________
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 //______________________________________________________________________________
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;
251  TGLVector3(const Double_t *src);
252 
254  { fVals[0] = v[0]; fVals[1] = v[1]; fVals[2] = v[2]; return *this; }
255 
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 //______________________________________________________________________________
283 {
284  fVals[0] /= val;
285  fVals[1] /= val;
286  fVals[2] /= val;
287  return *this;
288 }
289 
290 //______________________________________________________________________________
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 //______________________________________________________________________________
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 //______________________________________________________________________________
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
528 
529  // Methods
530  void Normalise();
531 
532 public:
533  TGLPlane();
534  TGLPlane(const TGLPlane & other);
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);
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 
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();
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 
630  void SetTranslation(const TGLVertex3 & translation);
631 
632  void Translate(const TGLVector3 & vect);
633  void MoveLF(Int_t ai, Double_t amount);
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 
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 //______________________________________________________________________________
673 {
674  // Check for self-assignment
675  if (this != &rhs) {
676  Set(rhs.fVals);
677  }
678  return *this;
679 }
680 
681 //______________________________________________________________________________
683 {
684  /*if (!ValidIndex(index)) {
685  assert(kFALSE);
686  return fVals[0];
687  } else {*/
688  return fVals[index];
689  //}
690 }
691 
692 //______________________________________________________________________________
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 //______________________________________________________________________________
733 {
734  Double_t* C = fVals + 4*--b;
735  C[0] = x; C[1] = y; C[2] = z;
736 }
737 
738 //______________________________________________________________________________
740 {
741  Double_t* C = fVals + 4*--b;
742  C[0] = v[0]; C[1] = v[1]; C[2] = v[2];
743 }
744 
745 //______________________________________________________________________________
747 {
748  Double_t* C = fVals + 4*--b;
749  C[0] = x[0]; C[1] = x[1]; C[2] = x[2];
750 }
751 
752 //______________________________________________________________________________
754 {
755  return TGLVector3(&fVals[4*--b]);
756 }
757 
758 //______________________________________________________________________________
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:
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);
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 
835 {
836 protected:
841  TGLColor fSelection[5]; // Colors for shape-selection-levels
842 
843 public:
844  TGLColorSet();
845  TGLColorSet(const TGLColorSet& s);
846  ~TGLColorSet() = default;
847 
849 
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:
881  {
882  public:
884  virtual ~TColorLocker() { UnlockColor(); }
885 
886  ClassDef(TColorLocker,0); // Lock/unlock color in constructor/destructor.
887  };
888 
890  {
892  public:
895 
898 
899  ClassDef(TDrawQualityModifier,0); // Set/restore draw quality in constructor/destructor.
900  };
901 
903  {
905  public:
908 
911 
912  ClassDef(TDrawQualityScaler,0); // Multiply/restore draw quality in constructor/destructor.
913  };
914 
915 private:
918 
920 
925 
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
945 
946  // Some simple shape drawing utils
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);
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 
1061 {
1062 private:
1065 
1069 
1070  void SetState(Bool_t s);
1071 
1072 public:
1073  TGLCapabilitySwitch(Int_t what, Bool_t state);
1075 };
1076 
1078 {
1079 private:
1082 
1085 
1086 public:
1087  TGLCapabilityEnabler(Int_t what, Bool_t state);
1089 };
1090 
1092 {
1093  TGLFloatHolder(const TGLFloatHolder&); // Not implemented
1094  TGLFloatHolder& operator=(const TGLFloatHolder&); // Not implemented
1095 
1100 
1101 public:
1102  TGLFloatHolder(Int_t what, Float_t state, void (*foo)(Float_t));
1103  ~TGLFloatHolder();
1104 };
1105 
1107 private:
1109 
1110 public:
1111  TGLEnableGuard(Int_t cap);
1112  ~TGLEnableGuard();
1113 
1114 private:
1115  TGLEnableGuard(const TGLEnableGuard &);
1117 };
1118 
1120 private:
1122 
1123 public:
1124  TGLDisableGuard(Int_t cap);
1125  ~TGLDisableGuard();
1126 
1127 private:
1130 };
1131 
1133  std::vector<UChar_t> fBuffer;
1136 
1137 public:
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:
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:
1157  typedef typename std::vector<T>::size_type size_type;
1158 
1159 public:
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  }
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 
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:
1267  : fActive(kTRUE)
1268  {
1269  }
1271  : fActive(kTRUE)
1272  {
1273  rhs.fActive = kFALSE;
1274  }
1275 
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  }
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  }
1318  {
1319  if (IsActive())
1320  fFunc(fArg1, fArg2);
1321  }
1322 };
1323 
1324 template<class Func, class Arg>
1326 {
1327  return TOneArgGuard<Func, Arg>(f, a);
1328 }
1329 
1330 template<class Func, class Arg1, class Arg2>
1332 {
1333  return TTwoArgsGuard<Func, Arg1, Arg2>(f, a1, a2);
1334 }
1335 
1336 }//namespace Rgl.
1337 
1339 private:
1340  std::vector<UChar_t> fTexels;
1341  const std::vector<Double_t> *fContours;
1343  mutable UInt_t fTexture;
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 
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
Int_t fY
Definition: TGLUtil.h:424
static UInt_t fgDefaultDrawQuality
Definition: TGLUtil.h:916
const TGLColor & Outline() const
Definition: TGLUtil.h:858
Double_t DistanceTo(const TGLVertex3 &vertex) const
Distance from plane to vertex.
Definition: TGLUtil.cxx:493
static void DrawRing(const TGLVertex3 &center, const TGLVector3 &normal, Double_t radius, const UChar_t *rgba)
Draw ring, centered on &#39;center&#39;, lying on plane defined by &#39;center&#39; & &#39;normal&#39; of outer radius &#39;radiu...
Definition: TGLUtil.cxx:2433
std::vector< T >::size_type size_type
Definition: TGLUtil.h:1157
void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax, Double_t zScale, std::vector< Double_t > &zLevels)
Definition: TGLUtil.cxx:3821
void SetRowLen(Int_t len)
Definition: TGLUtil.h:1165
std::vector< UChar_t > fTexels
Definition: TGLUtil.h:1340
Int_t fMaxRow
Definition: TGLUtil.h:1156
Double_t & Y()
Definition: TGLUtil.h:121
Class encapsulating a set of colors used throughout standard rendering.
Definition: TGLUtil.h:834
static GLUtesselator * GetDrawTesselator3fv()
Returns a tesselator for direct drawing when using 3-vertices with single precision.
Definition: TGLUtil.cxx:1493
static UInt_t fgColorLockCount
Definition: TGLUtil.h:919
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)
Draw textured triangle.
Definition: TGLUtil.cxx:3837
void ReadColorBuffer(Int_t width, Int_t height)
Read color buffer.
Definition: TGLUtil.cxx:2803
void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3, const TGLVector3 &normal)
Draw quad face.
Definition: TGLUtil.cxx:2954
Abstract base camera class - concrete classes for orthographic and perspective cameras derive from it...
Definition: TGLCamera.h:43
static void Color(const TGLColor &color)
Set color from TGLColor.
Definition: TGLUtil.cxx:1692
TGLVertex3 operator*(Double_t f, const TGLVertex3 &v)
Definition: TGLUtil.h:134
TGLUtil(const TGLUtil &)
UChar_t * Arr()
Definition: TGLUtil.h:798
Wrapper class for various misc static functions - error checking, draw helpers etc.
Definition: TGLUtil.h:877
void SetTranslation(Double_t x, Double_t y, Double_t z)
Set matrix translation components x,y,z.
Definition: TGLUtil.cxx:777
void SetGreen(Int_t v)
Definition: TGLUtil.h:810
Int_t X() const
Definition: TGLUtil.h:445
void StdLightBackground()
Set defaults for light (white) background.
Definition: TGLUtil.cxx:1390
static void ColorTransparency(Color_t color_index, Char_t transparency=0)
Set color from color_index and ROOT-style transparency (default 0).
Definition: TGLUtil.cxx:1736
Int_t Right() const
Definition: TGLUtil.h:456
Double_t & Z()
Definition: TGLUtil.h:123
static const UChar_t fgYellow[4]
Definition: TGLUtil.h:1051
UChar_t GetAlpha() const
Definition: TGLUtil.h:804
Double_t Invert()
Invert the matrix, returns determinant.
Definition: TGLUtil.cxx:972
TLine * line
const Float_t gNullEmission[]
Definition: TGLUtil.cxx:2848
float Float_t
Definition: RtypesCore.h:53
const TGLVertex3 & operator+=(const TGLVector3 &val)
Definition: TGLUtil.h:275
static void DrawReferenceMarker(const TGLCamera &camera, const TGLVertex3 &pos, Float_t radius=3, const UChar_t *rgba=0)
Draw a sphere- marker on world-coordinate &#39;pos&#39; with pixel radius &#39;radius&#39;.
Definition: TGLUtil.cxx:2474
void SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z)
Definition: TGLUtil.h:732
const T * operator[](size_type ind) const
Definition: TGLUtil.h:1169
std::pair< Double_t, Double_t > Range_t
Definition: TGLUtil.h:1194
double T(double x)
Definition: ChebyshevPol.h:34
#define g(i)
Definition: RSha256.hxx:105
const TGLVector3 operator/(const TGLVector3 &vec, Double_t val)
Definition: TGLUtil.h:330
16 component (4x4) transform matrix - column MAJOR as per GL.
Definition: TGLUtil.h:596
Int_t & Y()
Definition: TGLUtil.h:448
void DrawQuadStripWithRadialGradientFill(unsigned nPoints, const Double_t *inner, const Double_t *innerRGBA, const Double_t *outer, const Double_t *outerRGBA)
TODO: is it possible to use GLdouble to avoid problems with Double_t/GLdouble if they are not the sam...
Definition: TGLUtil.cxx:3218
Class encapsulating color information in preferred GL format - an array of four unsigned bytes...
Definition: TGLUtil.h:783
static void DrawLine(const TGLLine3 &line, ELineHeadShape head, Double_t size, const UChar_t rgba[4])
Draw thick line (tube) defined by &#39;line&#39;, with head at end shape &#39;head&#39; - box/arrow/none, (head) size &#39;size&#39;, color &#39;rgba&#39;.
Definition: TGLUtil.cxx:2367
Bool_t fActive
Definition: TGLUtil.h:1262
TGLCapabilitySwitch & operator=(const TGLCapabilitySwitch &)
virtual ~TGLUtil()
Definition: TGLUtil.h:934
void Expand(Int_t x, Int_t y)
Expand the rect to encompass point (x,y)
Definition: TGLUtil.cxx:262
static void DrawSimpleAxes(const TGLCamera &camera, const TGLBoundingBox &bbox, Int_t axesType)
Draw simple xyz-axes for given bounding-box.
Definition: TGLUtil.cxx:2489
TGLMatrix & operator*=(const TGLMatrix &rhs)
Definition: TGLUtil.h:622
static void BeginAttLine(const TAttLine &aline, Char_t transp, Int_t pick_radius=0, Bool_t selection=kFALSE)
Setup drawing parameters according to passed TAttLine.
Definition: TGLUtil.cxx:2267
Int_t GetPaletteSize() const
Get. Palette. Size.
Definition: TGLUtil.cxx:4255
const TGLColor & Selection(Int_t i) const
Definition: TGLUtil.h:860
Double_t GetTexCoord(Double_t z) const
Get tex coordinate.
Definition: TGLUtil.cxx:4263
std::vector< TGLPlane >::const_iterator TGLPlaneSet_ci
Definition: TGLUtil.h:572
TGLEnableGuard & operator=(const TGLEnableGuard &)
void Fill(Double_t val)
Definition: TGLUtil.h:203
static void Color3fv(const Float_t *rgb)
Wrapper for glColor3fv.
Definition: TGLUtil.cxx:1798
static UInt_t GetDrawQuality()
static: get draw quality
Definition: TGLUtil.cxx:1600
TGLVector3 operator-(const TGLVertex3 &vertex1, const TGLVertex3 &vertex2)
Definition: TGLUtil.h:350
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)
Render markers as circular or square points.
Definition: TGLUtil.cxx:2015
static Float_t GetScreenScalingFactor()
Returns scaling factor between screen points and GL viewport pixels.
Definition: TGLUtil.cxx:1847
void TransformVertex(TGLVertex3 &vertex) const
Transform passed &#39;vertex&#39; by this matrix - converts local frame to parent.
Definition: TGLUtil.cxx:934
TGLRect()
Positive width/height.
Definition: TGLUtil.cxx:230
void Transpose3x3()
Transpose the top left 3x3 matrix component along major diagonal Supported as currently incompatibili...
Definition: TGLUtil.cxx:948
TGL2DArray()
Definition: TGLUtil.h:1160
ClassDefNV(TGLPlane, 0)
void StdDarkBackground()
Set defaults for dark (black) background.
Definition: TGLUtil.cxx:1373
void Set(const TGLVertex3 &start, const TGLVertex3 &end)
Set 3D line running from &#39;start&#39; to &#39;end&#39;.
Definition: TGLUtil.cxx:193
Double_t fVals[16]
Definition: TGLUtil.h:600
Basic string class.
Definition: TString.h:131
static const UChar_t fgGrey[4]
Definition: TGLUtil.h:1053
TGLVertex3 NearestOn(const TGLVertex3 &point) const
Return nearest point on plane.
Definition: TGLUtil.cxx:501
const Float_t gBlueEmission[]
Definition: TGLUtil.cxx:2844
#define f(i)
Definition: RSha256.hxx:104
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
Double_t & operator[](Int_t index)
Definition: TGLUtil.h:682
void SetRed(Int_t v)
Definition: TGLUtil.h:809
const TGLVertex3 & Start() const
Definition: TGLUtil.h:403
static void PointToViewport(Int_t &x, Int_t &y)
Convert from point/screen coordinates to GL viewport coordinates.
Definition: TGLUtil.cxx:1818
Int_t Y() const
Definition: TGLUtil.h:447
const UChar_t * GetColour(Double_t z) const
Get color.
Definition: TGLUtil.cxx:4292
~TGLColorSet()=default
Int_t fMaxPaletteSize
Definition: TGLUtil.h:1344
void DrawBoxWithGradientFill(Double_t y1, Double_t y2, Double_t x1, Double_t x2, const Double_t *rgba1, const Double_t *rgba2)
Definition: TGLUtil.cxx:3198
static void RenderPolyMarkers(const TAttMarker &marker, Char_t transp, Float_t *p, Int_t n, Int_t pick_radius=0, Bool_t selection=kFALSE, Bool_t sec_selection=kFALSE)
Render polymarkers at points specified by p-array.
Definition: TGLUtil.cxx:1975
void SetTransparency(Char_t transparency)
Set alpha from the transparency.
Definition: TGLUtil.cxx:1313
Double_t B() const
Definition: TGLUtil.h:553
TGLColor & Markup()
Definition: TGLUtil.h:853
TGLEnableGuard(Int_t cap)
TGLEnableGuard constructor.
Definition: TGLUtil.cxx:2748
Bool_t ValidIndex(UInt_t index) const
Definition: TGLUtil.h:603
Wrapper class for GLU quadric shape drawing object.
Definition: TGLQuadric.h:27
TGLColor fForeground
Definition: TGLUtil.h:838
Char_t GetTransparency() const
Returns transparency value.
Definition: TGLUtil.cxx:1228
TGLVector3 operator-() const
Definition: TGLUtil.h:291
Float_t fState
Definition: TGLUtil.h:1097
~TGLCapabilitySwitch()
Destructor - reset state if changed.
Definition: TGLUtil.cxx:2689
void Offset(Int_t dX, Int_t dY)
Definition: TGLUtil.h:486
void Set(Double_t x, Double_t y, Double_t z)
Definition: TGLUtil.h:209
TGLColor & operator=(const TGLColor &c)
Assignment operator.
Definition: TGLUtil.cxx:1205
Double_t Aspect() const
Definition: TGLUtil.h:499
void DrawAxes(Int_t frontPoint, const Int_t *viewport, const TGLVertex3 *box2D, const TGLPlotCoordinates *plotCoord, TAxis *xAxis, TAxis *yAxis, TAxis *zAxis)
Using front point, find, where to draw axes and which labels to use for them gVirtualX->SelectWindow(...
Definition: TGLUtil.cxx:3760
void RotateIP(TGLVector3 &v) const
Rotate vector in-place. Translation is not applied.
Definition: TGLUtil.cxx:1088
Int_t Longest() const
Definition: TGLUtil.h:493
Double_t fVals[4]
Definition: TGLUtil.h:527
TGLLevelPalette()
Ctor.
Definition: TGLUtil.cxx:4151
static const UChar_t fgRed[4]
Definition: TGLUtil.h:1048
TGLMatrix()
Construct default identity matrix:
Definition: TGLUtil.cxx:607
TGLVertex3()
Construct a default (0.0, 0.0, 0.0) vertex.
Definition: TGLUtil.cxx:54
void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3, const TGLVertex3 &v4)
Draw quad outline.
Definition: TGLUtil.cxx:2940
TGLVertex3 fVertex
Definition: TGLUtil.h:389
TGLPlane & operator=(const TGLPlane &src)
Assignment operator.
Definition: TGLUtil.cxx:390
Marker Attributes class.
Definition: TAttMarker.h:19
TGLVertex3 operator-() const
Definition: TGLUtil.h:166
double sqrt(double)
static const double x2[5]
Double_t x[n]
Definition: legend1.C:17
const Float_t gWhiteEmission[]
Definition: TGLUtil.cxx:2846
Int_t & Height()
Definition: TGLUtil.h:452
void Translate(const TGLVector3 &vect)
Shift matrix translation components by &#39;vect&#39; in parent frame.
Definition: TGLUtil.cxx:803
virtual ~TColorLocker()
Definition: TGLUtil.h:884
#define ClassDef(name, id)
Definition: Rtypes.h:326
const TGLVertex3 & operator-=(const TGLVector3 &val)
Definition: TGLUtil.h:267
Double_t D() const
Definition: TGLUtil.h:555
void Move3LF(Double_t x, Double_t y, Double_t z)
Translate in local frame along all base vectors simultaneously.
Definition: TGLUtil.cxx:823
void Set(const TGLVertex3 &origin, const TGLVector3 &zAxis, const TGLVector3 &xAxis=0)
Set matrix which when applied puts local origin at &#39;origin&#39; and the local Z axis in direction &#39;z&#39;...
Definition: TGLUtil.cxx:737
Rgl::Range_t fZRange
Definition: TGLUtil.h:1345
static void Color3ub(UChar_t r, UChar_t g, UChar_t b)
Wrapper for glColor3ub.
Definition: TGLUtil.cxx:1750
void SetState(Bool_t s)
Definition: TGLUtil.cxx:2697
TGLVector3 fVector
Start vertex of line.
Definition: TGLUtil.h:390
3 component (x/y/z) vertex class.
Definition: TGLUtil.h:82
~TGLCapabilityEnabler()
Destructor - reset state if changed.
Definition: TGLUtil.cxx:2720
TGLVertex3 & operator=(const TGLVertex3 &rhs)
Definition: TGLUtil.h:154
static void DrawSphere(const TGLVertex3 &position, Double_t radius, const UChar_t rgba[4])
Draw sphere, centered on vertex &#39;position&#39;, with radius &#39;radius&#39;, color &#39;rgba&#39;.
Definition: TGLUtil.cxx:2352
static GLUtesselator * GetDrawTesselator4dv()
Returns a tesselator for direct drawing when using 4-vertices with double precision.
Definition: TGLUtil.cxx:1556
static Float_t GetPointSizeScale()
Get global point-size scale.
Definition: TGLUtil.cxx:1878
static void Color4ub(UChar_t r, UChar_t g, UChar_t b, UChar_t a)
Wrapper for glColor4ub.
Definition: TGLUtil.cxx:1758
const UChar_t * CArr() const
Definition: TGLUtil.h:799
void RotateLF(Int_t i1, Int_t i2, Double_t amount)
Rotate in local frame.
Definition: TGLUtil.cxx:898
void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_t zMax, Double_t tMin, Double_t tMax)
In polar coordinates, box became trapezoid.
Definition: TGLUtil.cxx:3496
Rgl::EOverlap Overlap(const TGLRect &other) const
Return overlap result (kInside, kOutside, kPartial) of this rect with &#39;other&#39;.
Definition: TGLUtil.cxx:298
void RotatePF(Int_t i1, Int_t i2, Double_t amount)
Rotate in parent frame. Does optimised version of MultLeft.
Definition: TGLUtil.cxx:915
void EnableTexture(Int_t mode) const
Enable 1D texture.
Definition: TGLUtil.cxx:4227
ClassDefNV(TGLColorSet, 0)
TGLColor fSelection[5]
Definition: TGLUtil.h:841
Bool_t ValidIndex(UInt_t index) const
Definition: TGLUtil.h:86
static Int_t fgPickingRadius
Definition: TGLUtil.h:928
Int_t & Width()
Definition: TGLUtil.h:450
Viewport (pixel base) 2D rectangle class.
Definition: TGLUtil.h:420
std::vector< UChar_t > fBuffer
Definition: TGLUtil.h:1133
const TGLVertex3 End() const
Definition: TGLUtil.h:404
Double_t * Arr()
Definition: TGLUtil.h:664
3 component (x/y/z) vector class.
Definition: TGLUtil.h:246
std::vector< TGLPlane >::iterator TGLPlaneSet_i
Definition: TGLUtil.h:571
static constexpr double s
ClassDefNV(TGLLine3, 0)
TGLVector3 Multiply(const TGLVector3 &v, Double_t w=1) const
Multiply vector.
Definition: TGLUtil.cxx:1050
static UInt_t fgDrawQuality
Definition: TGLUtil.h:917
static Bool_t IsColorLocked()
Returns true if color lock-count is greater than 0.
Definition: TGLUtil.cxx:1684
static UInt_t LockColor()
Prevent further color changes.
Definition: TGLUtil.cxx:1664
static UInt_t UnlockColor()
Allow color changes.
Definition: TGLUtil.cxx:1672
UChar_t GetBlue() const
Definition: TGLUtil.h:803
TGLSelectionBuffer()
TGLSelectionBuffer constructor.
Definition: TGLUtil.cxx:2788
void SetIdentity()
Set matrix to identity.
Definition: TGLUtil.cxx:766
void Error(const char *location, const char *msgfmt,...)
void MultLeft(const TGLMatrix &lhs)
Multiply with matrix lhs on left.
Definition: TGLUtil.cxx:719
TGLColor fMarkup
Definition: TGLUtil.h:840
static void SetDefaultDrawQuality(UInt_t dq)
static: set default draw quality
Definition: TGLUtil.cxx:1632
short Color_t
Definition: RtypesCore.h:79
const Double_t * CArr() const
Definition: TGLUtil.h:562
Int_t ColorToObjectID(const UChar_t *color, Bool_t highColor)
Definition: TGLUtil.cxx:2918
REAL * vertex
Definition: triangle.c:512
const UChar_t * GetPixelColor(Int_t px, Int_t py) const
Get pixel color.
Definition: TGLUtil.cxx:2827
static void SetPointSizeScale(Float_t scale)
Set global point-size scale.
Definition: TGLUtil.cxx:1886
void SetContours(const std::vector< Double_t > *contours)
Clear :)
Definition: TGLUtil.cxx:4219
point * points
Definition: X3DBuffer.c:22
void ObjectIDToColor(Int_t objectID, Bool_t highColor)
Object id encoded as rgb triplet.
Definition: TGLUtil.cxx:2892
TGLVector3 GetTranslation() const
Return the translation component of matrix.
Definition: TGLUtil.cxx:795
void MultiplyIP(TGLVector3 &v, Double_t w=1) const
Multiply vector in-place.
Definition: TGLUtil.cxx:1076
static const UChar_t fgBlue[4]
Definition: TGLUtil.h:1050
const TGLColor & Markup() const
Definition: TGLUtil.h:859
Definition: TGLUtil.h:58
TGLColorSet & operator=(const TGLColorSet &s)
Assignment operator.
Definition: TGLUtil.cxx:1359
void Stop() const
Definition: TGLUtil.h:1282
static Float_t fgLineWidth
Definition: TGLUtil.h:922
void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax, Int_t fp)
Draws lego&#39;s bar as a 3d box.
Definition: TGLUtil.cxx:3008
static Float_t fgPointSizeScale
Definition: TGLUtil.h:923
Double_t Mag() const
Definition: TGLUtil.h:297
void DrawError(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax)
Definition: TGLUtil.cxx:3299
static void EndAttLine(Int_t pick_radius=0, Bool_t selection=kFALSE)
Restore previous line drawing state.
Definition: TGLUtil.cxx:2303
TGLFloatHolder(const TGLFloatHolder &)
Int_t Top() const
Definition: TGLUtil.h:457
static double C[]
Bool_t operator==(const TGLVertex3 &rhs) const
Definition: TGLUtil.h:148
TGuardBase & operator=(const TGuardBase &rhs)
static void SetLineWidthScale(Float_t scale)
Set global line-width scale.
Definition: TGLUtil.cxx:1902
ROOT::R::TRInterface & r
Definition: Object.C:4
void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3, const TGLVector3 &norm1, const TGLVector3 &norm2, const TGLVector3 &norm3)
Draws triangle face, each vertex has its own averaged normal.
Definition: TGLUtil.cxx:2984
Double_t * Arr()
Definition: TGLUtil.h:126
Class to manage histogram axis.
Definition: TAxis.h:30
EGLCoordType
Definition: TGLUtil.h:41
static void InitializeIfNeeded()
Initialize globals that require other libraries to be initialized.
Definition: TGLUtil.cxx:1577
void Dump() const
Output 16 matrix components to std::cout.
Definition: TGLUtil.cxx:1133
const Float_t gGreenEmission[]
Definition: TGLUtil.cxx:2843
const Float_t gRedEmission[]
Definition: TGLUtil.cxx:2842
static const UChar_t fgWhite[4]
Definition: TGLUtil.h:1052
static GLUtesselator * GetDrawTesselator4fv()
Returns a tesselator for direct drawing when using 4-vertices with single precision.
Definition: TGLUtil.cxx:1514
TOneArgGuard< Func, Arg > make_guard(Func f, Arg a)
Definition: TGLUtil.h:1325
auto * a
Definition: textangle.C:12
std::pair< Int_t, Int_t > BinRange_t
Definition: TGLUtil.h:1193
TGLFloatHolder & operator=(const TGLFloatHolder &)
TGLColorSet()
Constructor. Sets default for dark background.
Definition: TGLUtil.cxx:1338
TDrawQualityScaler(Float_t fac)
Definition: TGLUtil.h:906
TGLCapabilityEnabler & operator=(const TGLCapabilityEnabler &)
TGLVector3 Norm() const
Definition: TGLUtil.h:557
static void Color4f(Float_t r, Float_t g, Float_t b, Float_t a)
Wrapper for glColor4f.
Definition: TGLUtil.cxx:1790
Int_t CenterX() const
Definition: TGLUtil.h:453
Double_t A() const
Definition: TGLUtil.h:552
const Float_t gGrayEmission[]
Definition: TGLUtil.cxx:2847
Helper class for plot-painters holding information about axis ranges, numbers of bins and flags if ce...
const Double_t * CArr() const
Definition: TGLUtil.h:663
void Minimum(const TGLVertex3 &other)
Definition: TGLUtil.cxx:112
~TGLPlane()=default
unsigned int UInt_t
Definition: RtypesCore.h:42
static void DrawNumber(const TString &num, const TGLVertex3 &pos, Bool_t center=kFALSE)
Draw number in string &#39;num&#39; via internal 8x8-pixel bitmap on vertex &#39;pos&#39;.
Definition: TGLUtil.cxx:2629
Int_t & X()
Definition: TGLUtil.h:446
const TGLColor & Background() const
Definition: TGLUtil.h:856
~TGLLine3()=default
const TGLVector3 & Vector() const
Definition: TGLUtil.h:405
short Short_t
Definition: RtypesCore.h:35
Double_t C() const
Definition: TGLUtil.h:554
TGLUtil & operator=(const TGLUtil &)
UInt_t fTexture
Definition: TGLUtil.h:1343
static void Color4fv(const Float_t *rgba)
Wrapper for glColor4fv.
Definition: TGLUtil.cxx:1806
3D space, fixed length, line class, with direction / length &#39;vector&#39;, passing through point &#39;vertex&#39;...
Definition: TGLUtil.h:385
static Float_t PointSize()
Get the point-size, taking the global scaling into account.
Definition: TGLUtil.cxx:1930
void Dump() const
Output plane equation to std::out.
Definition: TGLUtil.cxx:417
~TGLDisableGuard()
TGLDisableGuard destructor.
Definition: TGLUtil.cxx:2774
TGLPlane()
Construct a default plane of x + y + z = 0.
Definition: TGLUtil.cxx:337
UChar_t GetGreen() const
Definition: TGLUtil.h:802
void DrawTransparentBox(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax, Int_t fp)
Draws lego&#39;s bar as a 3d box.
Definition: TGLUtil.cxx:3058
UChar_t GetRed() const
Definition: TGLUtil.h:801
TGLColor()
Default constructor. Color is initialized to black.
Definition: TGLUtil.cxx:1159
Bool_t fFlip
Definition: TGLUtil.h:1098
TGLColor fOutline
Definition: TGLUtil.h:839
Int_t Left() const
Definition: TGLUtil.h:455
ClassDefNV(TGLColor, 0)
#define h(i)
Definition: RSha256.hxx:106
Int_t Diagonal() const
Return the diagonal of the rectangle.
Definition: TGLUtil.cxx:287
TGLVector3 & operator=(const TGLVertex3 &v)
Definition: TGLUtil.h:253
Int_t Width() const
Definition: TGLUtil.h:449
static const UChar_t fgGreen[4]
Definition: TGLUtil.h:1049
const Bool_t kFALSE
Definition: RtypesCore.h:88
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
#define d(i)
Definition: RSha256.hxx:102
Int_t * CArr()
Definition: TGLUtil.h:443
Double_t Z() const
Definition: TGLUtil.h:122
static void Color3f(Float_t r, Float_t g, Float_t b)
Wrapper for glColor3f.
Definition: TGLUtil.cxx:1782
TGLColor fBackground
Definition: TGLUtil.h:837
Double_t Dot(const TGLVector3 &v1, const TGLVector3 &v2)
Definition: TGLUtil.h:316
static Float_t fgPointLineScalingFactor
Definition: TGLUtil.h:927
static const double x1[5]
auto * t1
Definition: textangle.C:20
std::vector< TGLPlane > TGLPlaneSet_t
Definition: TGLUtil.h:570
Double_t & operator[](Int_t index)
Definition: TGLUtil.h:181
static Float_t fgScreenScalingFactor
Definition: TGLUtil.h:926
double Double_t
Definition: RtypesCore.h:55
void SetCorner(Int_t x, Int_t y)
Definition: TGLUtil.h:479
void Negate()
Negate the plane.
Definition: TGLUtil.cxx:482
TGLCapabilitySwitch(const TGLCapabilitySwitch &)
ClassDefNV(TGLVertex3, 1)
void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t zMax, Double_t tMin, Double_t tMax)
In polar coordinates, box became trapezoid.
Definition: TGLUtil.cxx:3419
void Rotate(const TGLVertex3 &pivot, const TGLVector3 &axis, Double_t angle)
Update matrix so resulting transform has been rotated about &#39;pivot&#39; (in parent frame), round vector &#39;axis&#39;, through &#39;angle&#39; (radians) Equivalent to glRotate function, but with addition of translation and compounded on top of existing.
Definition: TGLUtil.cxx:871
int type
Definition: TGX11.cxx:120
TGLVertex3 operator+(const TGLVertex3 &vertex1, const TGLVector3 &vertex2)
Definition: TGLUtil.h:343
TGLDisableGuard & operator=(const TGLDisableGuard &)
Int_t Bottom() const
Definition: TGLUtil.h:458
Double_t y[n]
Definition: legend1.C:17
void MultRight(const TGLMatrix &rhs)
Multiply with matrix rhs on right.
Definition: TGLUtil.cxx:703
Color_t GetColorIndex() const
Returns color-index representing the color.
Definition: TGLUtil.cxx:1218
static void BeginExtendPickRegion(Float_t scale)
Definition: TGLUtil.cxx:1947
static void RenderPolyLine(const TAttLine &aline, Char_t transp, Float_t *p, Int_t n, Int_t pick_radius=0, Bool_t selection=kFALSE)
Render poly-line as specified by the p-array.
Definition: TGLUtil.cxx:2247
Short_t fIndex
Definition: TGLUtil.h:787
Bool_t IsScalingForRender() const
Return true if matrix is to be considered a scaling matrix for rendering.
Definition: TGLUtil.cxx:1112
Double_t fVals[3]
Definition: TGLUtil.h:87
const TGLColor & Foreground() const
Definition: TGLUtil.h:857
static void EndExtendPickRegion()
Definition: TGLUtil.cxx:1962
TGLColor & Background()
Definition: TGLUtil.h:850
TGLSelectionBuffer & operator=(const TGLSelectionBuffer &)
void DisableTexture() const
Disable 1D texture.
Definition: TGLUtil.cxx:4246
void Negate()
Definition: TGLUtil.h:140
void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, Bool_t color=kTRUE)
Definition: TGLUtil.cxx:3349
void DrawSphere(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax)
Cylinder for lego3.
Definition: TGLUtil.cxx:3276
EGLPlotType
Definition: TGLUtil.h:49
static Float_t GetPointLineScalingFactor()
Return extra scaling factor for points and lines.
Definition: TGLUtil.cxx:1858
static Int_t CheckError(const char *loc)
Check current GL error state, outputting details via ROOT Error method if one.
Definition: TGLUtil.cxx:1641
Concrete class describing an orientated (free) or axis aligned box of 8 vertices. ...
you should not use this method at all Int_t Int_t z
Definition: TRolke.cxx:630
void GetColor(Float_t v, Float_t vmin, Float_t vmax, Int_t type, Float_t *rgba)
This function creates color for parametric surface&#39;s vertex, using its &#39;u&#39; value. ...
Definition: TGLUtil.cxx:3878
const Double_t * CArr() const
Definition: TGLUtil.h:125
TTwoArgsGuard(Func f, Arg1 a1, Arg2 a2)
Definition: TGLUtil.h:1313
virtual ~TGLMatrix()
Destroy matrix object.
Definition: TGLUtil.cxx:696
char Char_t
Definition: RtypesCore.h:29
typedef void((*Func_t)())
TGLColor & Selection(Int_t i)
Definition: TGLUtil.h:854
static void ResetDrawQuality()
static: reset draw quality
Definition: TGLUtil.cxx:1616
Int_t fHeight
Definition: TGLUtil.h:425
Double_t * Arr()
Definition: TGLUtil.h:563
static Float_t GetLineWidthScale()
Returns global line-width scale.
Definition: TGLUtil.cxx:1894
TGLVector3()=default
TGLLine3(const TGLVertex3 &start, const TGLVertex3 &end)
Vector of line from fVertex.
Definition: TGLUtil.cxx:177
void Normalise()
Definition: TGLUtil.h:303
TGLVector3 & operator/=(Double_t val)
Definition: TGLUtil.h:282
~TGLEnableGuard()
TGLEnableGuard destructor.
Definition: TGLUtil.cxx:2757
TGLVertex3 & operator*=(Double_t f)
Definition: TGLUtil.h:172
TGLMatrix & operator=(const TGLMatrix &rhs)
Definition: TGLUtil.h:672
TGLDisableGuard(Int_t cap)
TGLDisableGuard constructor.
Definition: TGLUtil.cxx:2765
EOverlap
Definition: TGLUtil.h:33
Bool_t IsActive() const
Definition: TGLUtil.h:1276
static void RenderCrosses(const TAttMarker &marker, Float_t *p, Int_t n, Bool_t sec_selection=kFALSE)
Render markers as crosses.
Definition: TGLUtil.cxx:2135
TGLCapabilityEnabler(const TGLCapabilityEnabler &)
void SetBlue(Int_t v)
Definition: TGLUtil.h:811
Int_t CenterY() const
Definition: TGLUtil.h:454
static Float_t fgLineWidthScale
Definition: TGLUtil.h:924
static GLUtesselator * GetDrawTesselator3dv()
Returns a tesselator for direct drawing when using 3-vertices with double precision.
Definition: TGLUtil.cxx:1535
void Maximum(const TGLVertex3 &other)
Definition: TGLUtil.cxx:121
TGLColor & Outline()
Definition: TGLUtil.h:852
Int_t fRowLen
Definition: TGLUtil.h:1155
void(* fFoo)(Float_t)
Definition: TGLUtil.h:1099
virtual ~TGLSelectionBuffer()
TGLSelectionBuffer destructor.
Definition: TGLUtil.cxx:2796
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
void Scale(const TGLVector3 &scale)
Set matrix axis scales to &#39;scale&#39;.
Definition: TGLUtil.cxx:835
TGLLevelPalette & operator=(const TGLLevelPalette &)
static Int_t GetPickingRadius()
Returns picking radius.
Definition: TGLUtil.cxx:1866
#define c(i)
Definition: RSha256.hxx:101
static void SetDrawQuality(UInt_t dq)
static: set draw quality
Definition: TGLUtil.cxx:1608
void Draw() const
Draw line in current basic GL color.
Definition: TGLUtil.cxx:212
virtual ~TGLRect()
Destroy rect object.
Definition: TGLUtil.cxx:255
~TGLVertex3()
Destroy vertex object.
Definition: TGLUtil.cxx:86
static Float_t LineWidth()
Get the line-width, taking the global scaling into account.
Definition: TGLUtil.cxx:1938
void SetMaxRow(Int_t max)
Definition: TGLUtil.h:1161
unsigned char UChar_t
Definition: RtypesCore.h:34
TGLVector3 Cross(const TGLVector3 &v1, const TGLVector3 &v2)
Definition: TGLUtil.h:322
void DrawCylinder(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax)
Cylinder for lego3.
Definition: TGLUtil.cxx:3245
Int_t Height() const
Definition: TGLUtil.h:451
static Float_t fgPointSize
Definition: TGLUtil.h:921
void Normalise()
Normalise the plane.
Definition: TGLUtil.cxx:399
void Shift(TGLVector3 &shift)
Offset a vertex by vector &#39;shift&#39;.
Definition: TGLUtil.cxx:93
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)
Draws lego&#39;s bar as a 3d box LULULULU.
Definition: TGLUtil.cxx:3135
void SetColor(Int_t r, Int_t g, Int_t b, Int_t a=255)
Set color with Int_t values.
Definition: TGLUtil.cxx:1236
Int_t fWidth
Corner.
Definition: TGLUtil.h:425
Bool_t GeneratePalette(UInt_t paletteSize, const Rgl::Range_t &zRange, Bool_t checkSize=kTRUE)
Try to find colors for palette.
Definition: TGLUtil.cxx:4162
Double_t Y() const
Definition: TGLUtil.h:120
Double_t & X()
Definition: TGLUtil.h:119
static void ColorAlpha(const TGLColor &color, UChar_t alpha)
Set color from TGLColor and alpha value.
Definition: TGLUtil.cxx:1700
const Bool_t kTRUE
Definition: RtypesCore.h:87
Int_t fX
Definition: TGLUtil.h:424
3D plane class - of format Ax + By + Cz + D = 0
Definition: TGLUtil.h:523
const Float_t gOrangeEmission[]
Definition: TGLUtil.cxx:2845
TString AsString() const
Return string describing the color.
Definition: TGLUtil.cxx:1321
TGLColor & Foreground()
Definition: TGLUtil.h:851
UChar_t fRGBA[4]
Definition: TGLUtil.h:786
static void SetDrawColors(const UChar_t rgba[4])
Set basic draw colors from 4 component &#39;rgba&#39; Used by other TGLUtil drawing routines.
Definition: TGLUtil.cxx:2331
const Int_t n
Definition: legend1.C:16
Line Attributes class.
Definition: TAttLine.h:18
virtual ~TDrawQualityScaler()
Definition: TGLUtil.h:909
TGLVector3 GetScale() const
Get local axis scaling factors.
Definition: TGLUtil.cxx:1100
static void Color4ubv(const UChar_t *rgba)
Wrapper for glColor4ubv.
Definition: TGLUtil.cxx:1774
ClassDefNV(TGLVector3, 1)
ELineHeadShape
Definition: TGLUtil.h:947
EAxesType
Definition: TGLUtil.h:948
void MoveLF(Int_t ai, Double_t amount)
Translate in local frame.
Definition: TGLUtil.cxx:814
TGuardBase(const TGuardBase &rhs)
Definition: TGLUtil.h:1270
void SetAlpha(Int_t v)
Definition: TGLUtil.h:812
void Set(Int_t x, Int_t y, Int_t width, Int_t height)
Definition: TGLUtil.h:470
static void Color3ubv(const UChar_t *rgb)
Wrapper for glColor3ubv.
Definition: TGLUtil.cxx:1766
TOneArgGuard(Func f, Arg a)
Definition: TGLUtil.h:1294
static UInt_t GetDefaultDrawQuality()
static: get default draw quality
Definition: TGLUtil.cxx:1624
UInt_t fPaletteSize
Definition: TGLUtil.h:1342
TGLVector3 GetBaseVec(Int_t b) const
Definition: TGLUtil.h:753
void Set(const TGLPlane &other)
Assign from other.
Definition: TGLUtil.cxx:426
const std::vector< Double_t > * fContours
Definition: TGLUtil.h:1341
void Dump() const
Output vertex component values to std::cout.
Definition: TGLUtil.cxx:131
const Int_t * CArr() const
Definition: TGLUtil.h:442
std::pair< Bool_t, TGLLine3 > Intersection(const TGLPlane &p1, const TGLPlane &p2)
Find 3D line interestion of this plane with &#39;other&#39;.
Definition: TGLUtil.cxx:517
Double_t X() const
Definition: TGLUtil.h:118