Logo ROOT  
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#include <utility>
22
23class TString;
24class TGLBoundingBox;
25class TGLCamera;
26
27class TAttMarker;
28class TAttLine;
29
30class GLUtesselator;
31
32namespace Rgl
33{
35 {
39 };
40}
41
43{
48};
49
51{
63};
64
65
66// TODO: Split these into own h/cxx files - too long now!
67
68//////////////////////////////////////////////////////////////////////////
69// //
70// TGLVertex3 //
71// //
72// 3 component (x/y/z) vertex class //
73// //
74// This is part of collection of utility classes for GL in TGLUtil.h/cxx//
75// These provide const and non-const accessors Arr() / CArr() to a GL //
76// compatible internal field - so can be used directly with OpenGL C API//
77// calls. They are not intended to be fully featured just provide //
78// minimum required. //
79//////////////////////////////////////////////////////////////////////////
80
81class TGLVector3; // Forward declare for Shift()
82
84{
85protected:
86 // Fields
87 Bool_t ValidIndex(UInt_t index) const { return (index < 3); }
89
90public:
91 TGLVertex3();
94 TGLVertex3(const TGLVertex3 & other);
96
97 Bool_t operator == (const TGLVertex3 & rhs) const;
98 TGLVertex3 & operator = (const TGLVertex3 & rhs);
100 TGLVertex3 operator - () const;
101 const TGLVertex3 & operator -= (const TGLVector3 & val);
102 const TGLVertex3 & operator += (const TGLVector3 & val);
103
104 // Manipulators
105 void Fill(Double_t val);
106 void Set(Double_t x, Double_t y, Double_t z);
107 void Set(const Double_t* xyz);
108 void Set(const TGLVertex3 & other);
109 void Shift(TGLVector3 & shift);
110 void Shift(Double_t xDelta, Double_t yDelta, Double_t zDelta);
111 void Negate();
112
113 void Minimum(const TGLVertex3 & other);
114 void Maximum(const TGLVertex3 & other);
115
116 // Accessors
117 Double_t & operator [] (Int_t index);
118 const Double_t & operator [] (Int_t index) const;
119 Double_t X() const { return fVals[0]; }
120 Double_t & X() { return fVals[0]; }
121 Double_t Y() const { return fVals[1]; }
122 Double_t & Y() { return fVals[1]; }
123 Double_t Z() const { return fVals[2]; }
124 Double_t & Z() { return fVals[2]; }
125
126 const Double_t * CArr() const { return fVals; }
127 Double_t * Arr() { return fVals; }
128
129 void Dump() const;
130
131 ClassDefNV(TGLVertex3,1); // GL 3 component vertex helper/wrapper class
132};
133
134//______________________________________________________________________________
136{
137 return TGLVertex3(f*v.X(), f*v.Y(), f*v.Z());
138}
139
140//______________________________________________________________________________
142{
143 fVals[0] = -fVals[0];
144 fVals[1] = -fVals[1];
145 fVals[2] = -fVals[2];
146}
147
148//______________________________________________________________________________
150{
151 return (fVals[0] == rhs.fVals[0] && fVals[1] == rhs.fVals[1] && fVals[2] == rhs.fVals[2]);
152}
153
154//______________________________________________________________________________
156{
157 // Check for self-assignment
158 if (this != &rhs) {
159 Set(rhs);
160 }
161 return *this;
162}
163
164// operator -= & operator += inline needs to be defered until full TGLVector3 definition
165
166//______________________________________________________________________________
168{
169 return TGLVertex3(-fVals[0], -fVals[1], -fVals[2]);
170}
171
172//______________________________________________________________________________
174{
175 fVals[0] *= f;
176 fVals[1] *= f;
177 fVals[2] *= f;
178 return *this;
179}
180
181//______________________________________________________________________________
183{
184 /*if (!ValidIndex(index)) {
185 assert(kFALSE);
186 return fVals[0];
187 } else {*/
188 return fVals[index];
189 //}
190}
191
192//______________________________________________________________________________
193inline const Double_t& TGLVertex3::operator [] (Int_t index) const
194{
195 /*if (!ValidIndex(index)) {
196 assert(kFALSE);
197 return fVals[0];
198 } else {*/
199 return fVals[index];
200 //}
201}
202
203//______________________________________________________________________________
205{
206 Set(val,val,val);
207}
208
209//______________________________________________________________________________
211{
212 fVals[0]=x;
213 fVals[1]=y;
214 fVals[2]=z;
215}
216
217//______________________________________________________________________________
218inline void TGLVertex3::Set(const Double_t* xyz)
219{
220 fVals[0]=xyz[0];
221 fVals[1]=xyz[1];
222 fVals[2]=xyz[2];
223}
224
225//______________________________________________________________________________
226inline void TGLVertex3::Set(const TGLVertex3 & other)
227{
228 fVals[0]=other.fVals[0];
229 fVals[1]=other.fVals[1];
230 fVals[2]=other.fVals[2];
231}
232
233
234//////////////////////////////////////////////////////////////////////////
235// //
236// TGLVector3 //
237// //
238// 3 component (x/y/z) vector class //
239// //
240// This is part of collection of utility classes for GL in TGLUtil.h/cxx//
241// These provide const and non-const accessors Arr() / CArr() to a GL //
242// compatible internal field - so can be used directly with OpenGL C API//
243// calls. They are not intended to be fully featured just provide //
244// minimum required. //
245//////////////////////////////////////////////////////////////////////////
246
247class TGLVector3 : public TGLVertex3
248{
249public:
250 TGLVector3() = default;
252 TGLVector3(const Double_t *src);
253
255 { fVals[0] = v[0]; fVals[1] = v[1]; fVals[2] = v[2]; return *this; }
256
258 TGLVector3 operator - () const;
259
260 Double_t Mag() const;
261 void Normalise();
262
263 ClassDefNV(TGLVector3,1); // GL 3 component vector helper/wrapper class
264};
265
266// Inline for TGLVertex3 requiring full TGLVector definition
267//______________________________________________________________________________
269{
270 fVals[0] -= vec[0]; fVals[1] -= vec[1]; fVals[2] -= vec[2];
271 return *this;
272}
273
274// Inline for TGLVertex3 requiring full TGLVector definition
275//______________________________________________________________________________
277{
278 fVals[0] += vec[0]; fVals[1] += vec[1]; fVals[2] += vec[2];
279 return *this;
280}
281
282//______________________________________________________________________________
284{
285 fVals[0] /= val;
286 fVals[1] /= val;
287 fVals[2] /= val;
288 return *this;
289}
290
291//______________________________________________________________________________
293{
294 return TGLVector3(-fVals[0], -fVals[1], -fVals[2]);
295}
296
297//______________________________________________________________________________
299{
300 return std::sqrt(fVals[0]*fVals[0] + fVals[1]*fVals[1] + fVals[2]*fVals[2]);
301}
302
303//______________________________________________________________________________
305{
306 Double_t mag = Mag();
307 if ( mag == 0.0 ) {
308 Error("TGLVector3::Normalise", "vector has zero magnitude");
309 return;
310 }
311 fVals[0] /= mag;
312 fVals[1] /= mag;
313 fVals[2] /= mag;
314}
315
316//______________________________________________________________________________
317inline Double_t Dot(const TGLVector3 & v1, const TGLVector3 & v2)
318{
319 return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
320}
321
322//______________________________________________________________________________
323inline TGLVector3 Cross(const TGLVector3 & v1, const TGLVector3 & v2)
324{
325 return TGLVector3(v1[1]*v2[2] - v2[1]*v1[2],
326 v1[2]*v2[0] - v2[2]*v1[0],
327 v1[0]*v2[1] - v2[0]*v1[1]);
328}
329
330//______________________________________________________________________________
331inline const TGLVector3 operator / (const TGLVector3 & vec, Double_t val)
332{
333 return TGLVector3(vec[0] / val, vec[1] / val, vec[2] / val);
334}
335
336//______________________________________________________________________________
337inline const TGLVector3 operator * (const TGLVector3 & vec, Double_t val)
338{
339 return TGLVector3(vec[0] * val, vec[1] * val, vec[2] * val);
340}
341
342//______________________________________________________________________________
343// Vertex + Vector => Vertex
344inline TGLVertex3 operator + (const TGLVertex3 & vertex1, const TGLVector3 & vertex2)
345{
346 return TGLVertex3(vertex1[0] + vertex2[0], vertex1[1] + vertex2[1], vertex1[2] + vertex2[2]);
347}
348
349//______________________________________________________________________________
350// Vertex - Vertex => Vector
351inline TGLVector3 operator - (const TGLVertex3 & vertex1, const TGLVertex3 & vertex2)
352{
353 return TGLVector3(vertex1[0] - vertex2[0], vertex1[1] - vertex2[1], vertex1[2] - vertex2[2]);
354}
355
356//______________________________________________________________________________
357// Vector + Vector => Vector
358inline TGLVector3 operator + (const TGLVector3 & vector1, const TGLVector3 & vector2)
359{
360 return TGLVector3(vector1[0] + vector2[0], vector1[1] + vector2[1], vector1[2] + vector2[2]);
361}
362
363//______________________________________________________________________________
364// Vector - Vector => Vector
365inline TGLVector3 operator - (const TGLVector3 & vector1, const TGLVector3 & vector2)
366{
367 return TGLVector3(vector1[0] - vector2[0], vector1[1] - vector2[1], vector1[2] - vector2[2]);
368}
369
370//______________________________________________________________________________
371// Dot-product
372inline Double_t operator * (const TGLVector3 & a, const TGLVector3 & b)
373{
374 return a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
375}
376
377//////////////////////////////////////////////////////////////////////////
378// //
379// TGLLine3 //
380// //
381// 3D space, fixed length, line class, with direction / length 'vector',//
382// passing through point 'vertex'. Just wraps a TGLVector3 / TGLVertex3 //
383// pair. //
384//////////////////////////////////////////////////////////////////////////
385
387{
388private:
389 // Fields
390 TGLVertex3 fVertex; //! Start vertex of line
391 TGLVector3 fVector; //! Vector of line from fVertex
392
393public:
394 TGLLine3(const TGLVertex3 & start, const TGLVertex3 & end);
395 TGLLine3(const TGLVertex3 & start, const TGLVector3 & vector);
396 ~TGLLine3() = default;
397
398 void Set(const TGLVertex3 & start, const TGLVertex3 & end);
399 void Set(const TGLVertex3 & start, const TGLVector3 & vector);
400
401 // Bitwise copy constructor and = operator are fine
402
403 // Accessors
404 const TGLVertex3 & Start() const { return fVertex; }
405 const TGLVertex3 End() const { return fVertex + fVector; }
406 const TGLVector3 & Vector() const { return fVector; }
407
408 // Debug
409 void Draw() const;
410
411 ClassDefNV(TGLLine3,0); // GL line wrapper class
412};
413
414//////////////////////////////////////////////////////////////////////////
415// //
416// TGLRect //
417// //
418// Viewport (pixel base) 2D rectangle class //
419//////////////////////////////////////////////////////////////////////////
420
422{
423private:
424 // Fields
425 Int_t fX, fY; //! Corner
426 Int_t fWidth, fHeight; //! Positive width/height
427
428public:
429 TGLRect();
430 TGLRect(Int_t x, Int_t y, Int_t width, Int_t height);
431 TGLRect(Int_t x, Int_t y, UInt_t width, UInt_t height);
432 virtual ~TGLRect();
433
434 // Bitwise copy const & =op are ok at present
435
436 // Manipulators
437 void Set(Int_t x, Int_t y, Int_t width, Int_t height);
438 void SetCorner(Int_t x, Int_t y);
439 void Offset(Int_t dX, Int_t dY);
440 void Expand(Int_t x, Int_t y);
441
442 // Accessors
443 const Int_t* CArr() const { return &fX; }
444 Int_t* CArr() { return &fX; }
445
446 Int_t X() const { return fX; }
447 Int_t & X() { return fX; }
448 Int_t Y() const { return fY; }
449 Int_t & Y() { return fY; }
450 Int_t Width() const { return fWidth; }
451 Int_t & Width() { return fWidth; }
452 Int_t Height() const { return fHeight; }
453 Int_t & Height() { return fHeight; }
454 Int_t CenterX() const { return fX + fWidth/2; }
455 Int_t CenterY() const { return fY + fHeight/2; }
456 Int_t Left() const { return fX; }
457 Int_t Right() const { return fX + fWidth; }
458 Int_t Top() const { return fY; }
459 Int_t Bottom() const { return fY + fHeight; }
460
461 Int_t Diagonal() const;
462 Int_t Longest() const;
463
464 Double_t Aspect() const;
465 Rgl::EOverlap Overlap(const TGLRect & other) const;
466
467 ClassDef(TGLRect,0); // GL rect helper/wrapper class
468};
469
470//______________________________________________________________________________
471inline void TGLRect::Set(Int_t x, Int_t y, Int_t width, Int_t height)
472{
473 fX = x;
474 fY = y;
475 fWidth = width;
476 fHeight = height;
477}
478
479//______________________________________________________________________________
481{
482 fX = x;
483 fY = y;
484}
485
486//______________________________________________________________________________
487inline void TGLRect::Offset(Int_t dX, Int_t dY)
488{
489 fX += dX;
490 fY += dY;
491}
492
493//______________________________________________________________________________
495{
496 return fWidth > fHeight ? fWidth : fHeight;
497}
498
499//______________________________________________________________________________
501{
502 // Return aspect ratio (width/height)
503 if (fHeight == 0) {
504 return 0.0;
505 } else {
506 return static_cast<Double_t>(fWidth) / static_cast<Double_t>(fHeight);
507 }
508}
509
510//////////////////////////////////////////////////////////////////////////
511// //
512// TGLPlane //
513// //
514// 3D plane class - of format Ax + By + Cz + D = 0 //
515// //
516// This is part of collection of simple utility classes for GL only in //
517// TGLUtil.h/cxx. These provide const and non-const accessors Arr() & //
518// CArr() to a GL compatible internal field - so can be used directly //
519// with OpenGL C API calls - which TVector3 etc cannot (easily). //
520// They are not intended to be fully featured just provide minimum //
521// required. //
522//////////////////////////////////////////////////////////////////////////
523
525{
526private:
527 // Fields
529
530 // Methods
531 void Normalise();
532
533public:
534 TGLPlane();
535 TGLPlane(const TGLPlane & other);
537 TGLPlane(Double_t eq[4]);
538 TGLPlane(const TGLVector3 & norm, const TGLVertex3 & point);
539 TGLPlane(const TGLVertex3 & p1, const TGLVertex3 & p2, const TGLVertex3 & p3);
540 ~TGLPlane() = default;
541
542 TGLPlane &operator=(const TGLPlane &src);
543
544 // Manipulators
545 void Set(const TGLPlane & other);
547 void Set(Double_t eq[4]);
548 void Set(const TGLVector3 & norm, const TGLVertex3 & point);
549 void Set(const TGLVertex3 & p1, const TGLVertex3 & p2, const TGLVertex3 & p3);
550 void Negate();
551
552 // Accessors
553 Double_t A() const { return fVals[0]; }
554 Double_t B() const { return fVals[1]; }
555 Double_t C() const { return fVals[2]; }
556 Double_t D() const { return fVals[3]; }
557
558 TGLVector3 Norm() const { return TGLVector3( fVals[0], fVals[1], fVals[2]); }
559 Double_t DistanceTo(const TGLVertex3 & vertex) const;
560 TGLVertex3 NearestOn(const TGLVertex3 & point) const;
561
562 // Internal data accessors - for GL API
563 const Double_t * CArr() const { return fVals; }
564 Double_t * Arr() { return fVals; }
565
566 void Dump() const;
567
568 ClassDefNV(TGLPlane,0); // GL plane helper/wrapper class
569};
570
571typedef std::vector<TGLPlane> TGLPlaneSet_t;
572typedef std::vector<TGLPlane>::iterator TGLPlaneSet_i;
573typedef std::vector<TGLPlane>::const_iterator TGLPlaneSet_ci;
574
575// Some free functions for planes
576std::pair<Bool_t, TGLLine3> Intersection(const TGLPlane & p1, const TGLPlane & p2);
577std::pair<Bool_t, TGLVertex3> Intersection(const TGLPlane & p1, const TGLPlane & p2, const TGLPlane & p3);
578std::pair<Bool_t, TGLVertex3> Intersection(const TGLPlane & plane, const TGLLine3 & line, Bool_t extend);
579
580
581//////////////////////////////////////////////////////////////////////////
582// //
583// TGLMatrix //
584// //
585// 16 component (4x4) transform matrix - column MAJOR as per GL. //
586// Provides limited support for adjusting the translation, scale and //
587// rotation components. //
588// //
589// This is part of collection of simple utility classes for GL only in //
590// TGLUtil.h/cxx. These provide const and non-const accessors Arr() & //
591// CArr() to a GL compatible internal field - so can be used directly //
592// with OpenGL C API calls - which TVector3 etc cannot (easily). //
593// They are not intended to be fully featured just provide minimum //
594// required. //
595//////////////////////////////////////////////////////////////////////////
596
598{
599private:
600 // Fields
601 Double_t fVals[16]; // Column MAJOR as per OGL
602
603 // Methods
604 Bool_t ValidIndex(UInt_t index) const { return (index < 16); }
605
606public:
607 TGLMatrix();
609 TGLMatrix(const TGLVertex3 & translation);
610 TGLMatrix(const TGLVertex3 & origin, const TGLVector3 & zAxis, const TGLVector3 & xAxis);
611 TGLMatrix(const TGLVertex3 & origin, const TGLVector3 & zAxis);
612 TGLMatrix(const Double_t vals[16]);
613 TGLMatrix(const TGLMatrix & other);
614 virtual ~TGLMatrix();
615
616 // Operators
617 TGLMatrix & operator =(const TGLMatrix & rhs);
618 Double_t & operator [] (Int_t index);
619 Double_t operator [] (Int_t index) const;
620
621 void MultRight(const TGLMatrix & rhs);
622 void MultLeft (const TGLMatrix & lhs);
623 TGLMatrix & operator*=(const TGLMatrix & rhs) { MultRight(rhs); return *this; }
624
625 // Manipulators
626 void Set(const TGLVertex3 & origin, const TGLVector3 & zAxis, const TGLVector3 & xAxis = 0);
627 void Set(const Double_t vals[16]);
628 void SetIdentity();
629
631 void SetTranslation(const TGLVertex3 & translation);
632
633 void Translate(const TGLVector3 & vect);
634 void MoveLF(Int_t ai, Double_t amount);
636
637 void Scale(const TGLVector3 & scale);
638 void Rotate(const TGLVertex3 & pivot, const TGLVector3 & axis, Double_t angle);
639 void RotateLF(Int_t i1, Int_t i2, Double_t amount);
640 void RotatePF(Int_t i1, Int_t i2, Double_t amount);
641 void TransformVertex(TGLVertex3 & vertex) const;
642 void Transpose3x3();
644
645 // Accesors
647 TGLVector3 GetScale() const;
649
651 void SetBaseVec(Int_t b, const TGLVector3& v);
652 void SetBaseVec(Int_t b, Double_t* x);
653
655 void GetBaseVec(Int_t b, TGLVector3& v) const;
656 void GetBaseVec(Int_t b, Double_t* x) const;
657
658 TGLVector3 Multiply(const TGLVector3& v, Double_t w=1) const;
659 TGLVector3 Rotate(const TGLVector3& v) const;
660 void MultiplyIP(TGLVector3& v, Double_t w=1) const;
661 void RotateIP(TGLVector3& v) const;
662
663 // Internal data accessors - for GL API
664 const Double_t * CArr() const { return fVals; }
665 Double_t * Arr() { return fVals; }
666
667 void Dump() const;
668
669 ClassDef(TGLMatrix,1); // GL matrix helper/wrapper class
670};
671
672//______________________________________________________________________________
674{
675 // Check for self-assignment
676 if (this != &rhs) {
677 Set(rhs.fVals);
678 }
679 return *this;
680}
681
682//______________________________________________________________________________
684{
685 /*if (!ValidIndex(index)) {
686 assert(kFALSE);
687 return fVals[0];
688 } else {*/
689 return fVals[index];
690 //}
691}
692
693//______________________________________________________________________________
695{
696 /*if (!ValidIndex(index)) {
697 assert(kFALSE);
698 return fVals[0];
699 } else {*/
700 return fVals[index];
701 //}
702}
703
704//______________________________________________________________________________
705inline TGLMatrix operator * (const TGLMatrix & lhs, const TGLMatrix & rhs)
706{
707 TGLMatrix res;
708
709 res[ 0] = rhs[ 0] * lhs[ 0] + rhs[ 1] * lhs[ 4] + rhs[ 2] * lhs[ 8] + rhs[ 3] * lhs[12];
710 res[ 1] = rhs[ 0] * lhs[ 1] + rhs[ 1] * lhs[ 5] + rhs[ 2] * lhs[ 9] + rhs[ 3] * lhs[13];
711 res[ 2] = rhs[ 0] * lhs[ 2] + rhs[ 1] * lhs[ 6] + rhs[ 2] * lhs[10] + rhs[ 3] * lhs[14];
712 res[ 3] = rhs[ 0] * lhs[ 3] + rhs[ 1] * lhs[ 7] + rhs[ 2] * lhs[11] + rhs[ 3] * lhs[15];
713
714 res[ 4] = rhs[ 4] * lhs[ 0] + rhs[ 5] * lhs[ 4] + rhs[ 6] * lhs[ 8] + rhs[ 7] * lhs[12];
715 res[ 5] = rhs[ 4] * lhs[ 1] + rhs[ 5] * lhs[ 5] + rhs[ 6] * lhs[ 9] + rhs[ 7] * lhs[13];
716 res[ 6] = rhs[ 4] * lhs[ 2] + rhs[ 5] * lhs[ 6] + rhs[ 6] * lhs[10] + rhs[ 7] * lhs[14];
717 res[ 7] = rhs[ 4] * lhs[ 3] + rhs[ 5] * lhs[ 7] + rhs[ 6] * lhs[11] + rhs[ 7] * lhs[15];
718
719 res[ 8] = rhs[ 8] * lhs[ 0] + rhs[ 9] * lhs[ 4] + rhs[10] * lhs[ 8] + rhs[11] * lhs[12];
720 res[ 9] = rhs[ 8] * lhs[ 1] + rhs[ 9] * lhs[ 5] + rhs[10] * lhs[ 9] + rhs[11] * lhs[13];
721 res[10] = rhs[ 8] * lhs[ 2] + rhs[ 9] * lhs[ 6] + rhs[10] * lhs[10] + rhs[11] * lhs[14];
722 res[11] = rhs[ 8] * lhs[ 3] + rhs[ 9] * lhs[ 7] + rhs[10] * lhs[11] + rhs[11] * lhs[15];
723
724 res[12] = rhs[12] * lhs[ 0] + rhs[13] * lhs[ 4] + rhs[14] * lhs[ 8] + rhs[15] * lhs[12];
725 res[13] = rhs[12] * lhs[ 1] + rhs[13] * lhs[ 5] + rhs[14] * lhs[ 9] + rhs[15] * lhs[13];
726 res[14] = rhs[12] * lhs[ 2] + rhs[13] * lhs[ 6] + rhs[14] * lhs[10] + rhs[15] * lhs[14];
727 res[15] = rhs[12] * lhs[ 3] + rhs[13] * lhs[ 7] + rhs[14] * lhs[11] + rhs[15] * lhs[15];
728
729 return res;
730}
731
732//______________________________________________________________________________
734{
735 Double_t* C = fVals + 4*--b;
736 C[0] = x; C[1] = y; C[2] = z;
737}
738
739//______________________________________________________________________________
741{
742 Double_t* C = fVals + 4*--b;
743 C[0] = v[0]; C[1] = v[1]; C[2] = v[2];
744}
745
746//______________________________________________________________________________
748{
749 Double_t* C = fVals + 4*--b;
750 C[0] = x[0]; C[1] = x[1]; C[2] = x[2];
751}
752
753//______________________________________________________________________________
755{
756 return TGLVector3(&fVals[4*--b]);
757}
758
759//______________________________________________________________________________
761{
762 const Double_t* C = fVals + 4*--b;
763 v[0] = C[0]; v[1] = C[1]; v[2] = C[2];
764}
765
766//______________________________________________________________________________
768{
769 const Double_t* C = fVals + 4*--b;
770 x[0] = C[0], x[1] = C[1], x[2] = C[2];
771}
772
773
774//////////////////////////////////////////////////////////////////////////
775//
776// TGLColor
777//
778// Encapsulate color in preferred GL format - UChar_t RGBA array.
779// Color index is also cached for easier interfacing with the
780// traditional ROOT graphics.
781//
782//////////////////////////////////////////////////////////////////////////
783
785{
786protected:
789
790public:
791 TGLColor();
792 TGLColor(Int_t r, Int_t g, Int_t b, Int_t a=255);
794 TGLColor(Color_t color_index, Char_t transparency=0);
795 TGLColor(const TGLColor& c);
796
797 TGLColor& operator=(const TGLColor& c);
798
799 UChar_t* Arr() { return fRGBA; }
800 const UChar_t* CArr() const { return fRGBA; }
801
802 UChar_t GetRed() const { return fRGBA[0]; }
803 UChar_t GetGreen() const { return fRGBA[1]; }
804 UChar_t GetBlue() const { return fRGBA[2]; }
805 UChar_t GetAlpha() const { return fRGBA[3]; }
806
807 Color_t GetColorIndex() const;
808 Char_t GetTransparency() const;
809
810 void SetRed(Int_t v) { fRGBA[0] = v; }
811 void SetGreen(Int_t v) { fRGBA[1] = v; }
812 void SetBlue(Int_t v) { fRGBA[2] = v; }
813 void SetAlpha(Int_t v) { fRGBA[3] = v; }
814
815 void SetColor(Int_t r, Int_t g, Int_t b, Int_t a=255);
817 void SetColor(Color_t color_index);
818 void SetColor(Color_t color_index, Char_t transparency);
819 void SetTransparency(Char_t transparency);
820
821 TString AsString() const;
822
823 ClassDefNV(TGLColor, 0); // Color in preferred GL format - RGBA.
824};
825
826
827//////////////////////////////////////////////////////////////////////////
828//
829// TGLColorSet
830//
831// A collection of colors used for OpenGL rendering.
832//
833//////////////////////////////////////////////////////////////////////////
834
836{
837protected:
842 TGLColor fSelection[5]; // Colors for shape-selection-levels
843
844public:
845 TGLColorSet();
846 TGLColorSet(const TGLColorSet& s);
847 ~TGLColorSet() = default;
848
850
853 TGLColor& Outline() { return fOutline; }
854 TGLColor& Markup() { return fMarkup; }
856
857 const TGLColor& Background() const { return fBackground; }
858 const TGLColor& Foreground() const { return fForeground; }
859 const TGLColor& Outline() const { return fOutline; }
860 const TGLColor& Markup() const { return fMarkup; }
861 const TGLColor& Selection(Int_t i) const { return fSelection[i]; }
862
863 void StdDarkBackground();
864 void StdLightBackground();
865
866 ClassDefNV(TGLColorSet, 0); // Collection of colors used for GL rendering.
867};
868
869//////////////////////////////////////////////////////////////////////////
870// //
871// TGLUtil //
872// //
873// Wrapper class for various misc static functions - error checking, //
874// draw helpers etc. //
875// //
876//////////////////////////////////////////////////////////////////////////
877
879{
880public:
882 {
883 public:
885 virtual ~TColorLocker() { UnlockColor(); }
886
887 ClassDef(TColorLocker,0); // Lock/unlock color in constructor/destructor.
888 };
889
891 {
893 public:
896
899
900 ClassDef(TDrawQualityModifier,0); // Set/restore draw quality in constructor/destructor.
901 };
902
904 {
906 public:
909
912
913 ClassDef(TDrawQualityScaler,0); // Multiply/restore draw quality in constructor/destructor.
914 };
915
916private:
919
921
926
930
931 TGLUtil(const TGLUtil&); // Not implemented.
932 TGLUtil& operator=(const TGLUtil&); // Not implemented.
933
934public:
935 virtual ~TGLUtil() {}
936 static void InitializeIfNeeded();
937
938 // Error checking
939 static Int_t CheckError(const char * loc);
940
941 // Polygon tesselator for direct drawing
946
947 // Some simple shape drawing utils
950
951 static UInt_t GetDrawQuality();
952 static void SetDrawQuality(UInt_t dq);
953 static void ResetDrawQuality();
955 static void SetDefaultDrawQuality(UInt_t dq);
956
957 static UInt_t LockColor();
958 static UInt_t UnlockColor();
959 static Bool_t IsColorLocked();
960
961 static void Color(const TGLColor& color);
962 static void ColorAlpha(const TGLColor& color, UChar_t alpha);
963 static void ColorAlpha(const TGLColor& color, Float_t alpha);
964 static void ColorAlpha(Color_t color_index, Float_t alpha=1);
965 static void ColorTransparency(Color_t color_index, Char_t transparency=0);
966 static void Color3ub(UChar_t r, UChar_t g, UChar_t b);
967 static void Color4ub(UChar_t r, UChar_t g, UChar_t b, UChar_t a);
968 static void Color3ubv(const UChar_t* rgb);
969 static void Color4ubv(const UChar_t* rgba);
970 static void Color3f(Float_t r, Float_t g, Float_t b);
971 static void Color4f(Float_t r, Float_t g, Float_t b, Float_t a);
972 static void Color3fv(const Float_t* rgb);
973 static void Color4fv(const Float_t* rgba);
974
975 // Coordinate conversion and extra scaling (needed for osx retina)
976 static void PointToViewport(Int_t& x, Int_t& y);
977 static void PointToViewport(Int_t& x, Int_t& y, Int_t& w, Int_t& h);
980 static Int_t GetPickingRadius();
981
982 static Float_t GetPointSizeScale();
983 static void SetPointSizeScale(Float_t scale);
984 static Float_t GetLineWidthScale();
985 static void SetLineWidthScale(Float_t scale);
986
987 static void PointSize(Float_t point_size);
988 static void LineWidth(Float_t line_width);
989
990 static Float_t PointSize();
991 static Float_t LineWidth();
992
993 static void BeginExtendPickRegion(Float_t scale);
994 static void EndExtendPickRegion();
995
996 static void RenderPolyMarkers(const TAttMarker& marker, Char_t transp,
997 Float_t* p, Int_t n,
998 Int_t pick_radius=0, Bool_t selection=kFALSE,
999 Bool_t sec_selection=kFALSE);
1000
1001 static void RenderPolyMarkers(const TAttMarker &marker, const std::vector<Double_t> &points,
1002 Double_t dX, Double_t dY, Double_t dZ);
1003
1004 static void RenderPoints(const TAttMarker& marker,
1005 Float_t* p, Int_t n,
1006 Int_t pick_radius=0, Bool_t selection=kFALSE,
1007 Bool_t sec_selection=kFALSE);
1008
1009 static void RenderPoints(const TAttMarker& marker,
1010 const std::vector<Double_t> &points);
1011
1012 static void RenderCrosses(const TAttMarker& marker,
1013 Float_t* p, Int_t n,
1014 Bool_t sec_selection=kFALSE);
1015
1016 static void RenderCrosses(const TAttMarker& marker,
1017 const std::vector<Double_t> &points,
1018 Double_t dX, Double_t dY, Double_t dZ);
1019
1020 static void RenderPolyLine(const TAttLine& aline, Char_t transp,
1021 Float_t* p, Int_t n,
1022 Int_t pick_radius=0, Bool_t selection=kFALSE);
1023
1024 static void BeginAttLine(const TAttLine& aline, Char_t transp,
1025 Int_t pick_radius=0, Bool_t selection=kFALSE);
1026 static void EndAttLine(Int_t pick_radius=0, Bool_t selection=kFALSE);
1027
1028 // TODO: These draw routines should take LOD hints
1029 static void SetDrawColors(const UChar_t rgba[4]);
1030 static void DrawSphere(const TGLVertex3 & position, Double_t radius, const UChar_t rgba[4]);
1031 static void DrawLine(const TGLLine3 & line, ELineHeadShape head, Double_t size, const UChar_t rgba[4]);
1032 static void DrawLine(const TGLVertex3 & start, const TGLVector3 & vector, ELineHeadShape head,
1033 Double_t size, const UChar_t rgba[4]);
1034 static void DrawRing(const TGLVertex3 & center, const TGLVector3 & normal,
1035 Double_t radius, const UChar_t* rgba);
1036
1037 static void DrawReferenceMarker(const TGLCamera & camera,
1038 const TGLVertex3 & pos,
1039 Float_t radius = 3,
1040 const UChar_t * rgba = 0);
1041 static void DrawSimpleAxes(const TGLCamera & camera,
1042 const TGLBoundingBox & bbox,
1043 Int_t axesType);
1044 static void DrawNumber(const TString & num,
1045 const TGLVertex3 & pos,
1046 Bool_t center = kFALSE);
1047
1048 // Frequently used colors.
1049 static const UChar_t fgRed[4];
1050 static const UChar_t fgGreen[4];
1051 static const UChar_t fgBlue[4];
1052 static const UChar_t fgYellow[4];
1053 static const UChar_t fgWhite[4];
1054 static const UChar_t fgGrey[4];
1055
1056 ClassDef(TGLUtil,0); // Wrapper class for misc GL pieces
1057};
1058
1059/**************************************************************************/
1060
1062{
1063private:
1066
1070
1071 void SetState(Bool_t s);
1072
1073public:
1076};
1077
1079{
1080private:
1083
1086
1087public:
1090};
1091
1093{
1094 TGLFloatHolder(const TGLFloatHolder&); // Not implemented
1095 TGLFloatHolder& operator=(const TGLFloatHolder&); // Not implemented
1096
1101
1102public:
1103 TGLFloatHolder(Int_t what, Float_t state, void (*foo)(Float_t));
1105};
1106
1108private:
1110
1111public:
1112 TGLEnableGuard(Int_t cap);
1114
1115private:
1118};
1119
1121private:
1123
1124public:
1127
1128private:
1131};
1132
1134 std::vector<UChar_t> fBuffer;
1137
1138public:
1140 virtual ~TGLSelectionBuffer();
1141
1142 void ReadColorBuffer(Int_t width, Int_t height);
1143 void ReadColorBuffer(Int_t x, Int_t y, Int_t width, Int_t height);
1144 const UChar_t *GetPixelColor(Int_t px, Int_t py)const;
1145
1146private:
1149
1150 ClassDef(TGLSelectionBuffer, 0); //Holds color buffer content for selection
1151};
1152
1153template<class T>
1154class TGL2DArray : public std::vector<T> {
1155private:
1158 typedef typename std::vector<T>::size_type size_type;
1159
1160public:
1163 {
1164 fMaxRow = max;
1165 }
1167 {
1168 fRowLen = len;
1169 }
1170 const T *operator [] (size_type ind)const
1171 {
1172 return &std::vector<T>::operator [](ind * fRowLen);
1173 }
1175 {
1176 return &std::vector<T>::operator [] (ind * fRowLen);
1177 }
1178};
1179
1180class TGLPlotCoordinates;
1181class TGLQuadric;
1182class TAxis;
1183
1184namespace Rgl {
1185
1186extern const Float_t gRedEmission[];
1187extern const Float_t gGreenEmission[];
1188extern const Float_t gBlueEmission[];
1189extern const Float_t gOrangeEmission[];
1190extern const Float_t gWhiteEmission[];
1191extern const Float_t gGrayEmission[];
1192extern const Float_t gNullEmission[];
1193
1194typedef std::pair<Int_t, Int_t> BinRange_t;
1195typedef std::pair<Double_t, Double_t> Range_t;
1196
1197void ObjectIDToColor(Int_t objectID, Bool_t highColor);
1198Int_t ColorToObjectID(const UChar_t *color, Bool_t highColor);
1199void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2,
1200 const TGLVertex3 &v3, const TGLVertex3 &v4);
1201void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1,
1202 const TGLVertex3 &v2, const TGLVertex3 &v3,
1203 const TGLVector3 &normal);
1204void DrawQuadFilled(const Double_t *v0, const Double_t *v1,
1205 const Double_t *v2, const Double_t *v3,
1206 const Double_t *normal);
1207
1208void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2,
1209 const TGLVertex3 &v3, const TGLVector3 &norm1,
1210 const TGLVector3 &norm2, const TGLVector3 &norm3);
1211void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax,
1212 Double_t zMin, Double_t zMax, Int_t fp);
1213
1214void DrawTransparentBox(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax,
1215 Double_t zMin, Double_t zMax, Int_t fp);
1216
1217
1218void DrawBoxFrontTextured(Double_t xMin, Double_t xMax, Double_t yMin,
1219 Double_t yMax, Double_t zMin, Double_t zMax,
1220 Double_t tMin, Double_t tMax, Int_t front);
1221
1223 const Double_t *rgba1, const Double_t *rgba2);
1224
1225void DrawQuadStripWithRadialGradientFill(unsigned nPoints, const Double_t *inner, const Double_t *innerRGBA,
1226 const Double_t *outer, const Double_t *outerRGBA);
1227
1228#ifndef __CINT__
1229void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t zMax,
1230 Double_t tMin, Double_t tMax);
1231void DrawTrapezoidTextured(const Double_t ver[][3], Double_t texMin, Double_t texMax);
1232void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_t zMax,
1233 Double_t tMin, Double_t tMax);
1234#endif
1235
1236void DrawCylinder(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
1237 Double_t yMax, Double_t zMin, Double_t zMax);
1238void DrawSphere(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
1239 Double_t yMax, Double_t zMin, Double_t zMax);
1240void DrawError(Double_t xMin, Double_t xMax, Double_t yMin,
1241 Double_t yMax, Double_t zMin, Double_t zMax);
1242
1243#ifndef __CINT__
1244void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, Bool_t color = kTRUE);
1245void DrawTrapezoid(const Double_t ver[][3]);
1246#endif
1247
1248void DrawAxes(Int_t frontPoint, const Int_t *viewport, const TGLVertex3 *box2D,
1249 const TGLPlotCoordinates *plotCoord, TAxis *xAxis, TAxis *yAxis,
1250 TAxis *zAxis);
1251void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax,
1252 Double_t zScale, std::vector<Double_t> &zLevels);
1253
1254void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3,
1255 Double_t t1, Double_t t2, Double_t t3, const TGLVector3 &norm1,
1256 const TGLVector3 &norm2, const TGLVector3 &norm3);
1257void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3,
1258 Double_t t1, Double_t t2, Double_t t3, Double_t z, const TGLVector3 &planeNormal);
1259void GetColor(Float_t v, Float_t vmin, Float_t vmax, Int_t type, Float_t *rgba);
1260
1262private:
1264
1266protected:
1268 : fActive(kTRUE)
1269 {
1270 }
1272 : fActive(kTRUE)
1273 {
1274 rhs.fActive = kFALSE;
1275 }
1276
1278 {
1279 return fActive;
1280 }
1281
1282public:
1283 void Stop()const
1284 {
1285 fActive = kFALSE;
1286 }
1287};
1288
1289template<class Func, class Arg>
1290class TOneArgGuard : public TGuardBase {
1291private:
1292 Func fFunc;
1293 Arg fArg;
1294public:
1295 TOneArgGuard(Func f, Arg a)
1296 : fFunc(f), fArg(a)
1297 {
1298 }
1300 {
1301 if (IsActive())
1302 fFunc(fArg);
1303 }
1304};
1305
1306template<class Func, class Arg1, class Arg2>
1308private:
1309 Func fFunc;
1310 Arg1 fArg1;
1311 Arg2 fArg2;
1312
1313public:
1314 TTwoArgsGuard(Func f, Arg1 a1, Arg2 a2)
1315 : fFunc(f), fArg1(a1), fArg2(a2)
1316 {
1317 }
1319 {
1320 if (IsActive())
1321 fFunc(fArg1, fArg2);
1322 }
1323};
1324
1325template<class Func, class Arg>
1327{
1328 return TOneArgGuard<Func, Arg>(f, a);
1329}
1330
1331template<class Func, class Arg1, class Arg2>
1333{
1334 return TTwoArgsGuard<Func, Arg1, Arg2>(f, a1, a2);
1335}
1336
1337}//namespace Rgl.
1338
1340private:
1341 std::vector<UChar_t> fTexels;
1342 const std::vector<Double_t> *fContours;
1347
1348 TGLLevelPalette(const TGLLevelPalette&); // Not implemented
1349 TGLLevelPalette& operator=(const TGLLevelPalette&); // Not implemented
1350
1351public:
1353
1354 Bool_t GeneratePalette(UInt_t paletteSize, const Rgl::Range_t &zRange, Bool_t checkSize = kTRUE);
1355
1356 void SetContours(const std::vector<Double_t> *contours);
1357
1358 void EnableTexture(Int_t mode)const;
1359 void DisableTexture()const;
1360
1361 Int_t GetPaletteSize()const;
1362
1364
1365 const UChar_t *GetColour(Double_t z)const;
1366 const UChar_t *GetColour(Int_t ind)const;
1367};
1368
1369#endif // ROOT_TGLUtil
typedef void(GLAPIENTRYP _GLUfuncptr)(void)
ROOT::R::TRInterface & r
Definition: Object.C:4
#define d(i)
Definition: RSha256.hxx:102
#define b(i)
Definition: RSha256.hxx:100
#define f(i)
Definition: RSha256.hxx:104
#define c(i)
Definition: RSha256.hxx:101
#define g(i)
Definition: RSha256.hxx:105
#define h(i)
Definition: RSha256.hxx:106
static const double x2[5]
static const double x1[5]
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
int Int_t
Definition: RtypesCore.h:45
unsigned char UChar_t
Definition: RtypesCore.h:38
char Char_t
Definition: RtypesCore.h:33
unsigned int UInt_t
Definition: RtypesCore.h:46
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
short Short_t
Definition: RtypesCore.h:39
double Double_t
Definition: RtypesCore.h:59
short Color_t
Definition: RtypesCore.h:92
float Float_t
Definition: RtypesCore.h:57
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassDef(name, id)
Definition: Rtypes.h:325
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:187
const TGLVector3 operator/(const TGLVector3 &vec, Double_t val)
Definition: TGLUtil.h:331
TGLVertex3 operator+(const TGLVertex3 &vertex1, const TGLVector3 &vertex2)
Definition: TGLUtil.h:344
Double_t Dot(const TGLVector3 &v1, const TGLVector3 &v2)
Definition: TGLUtil.h:317
std::pair< Bool_t, TGLLine3 > Intersection(const TGLPlane &p1, const TGLPlane &p2)
Find 3D line interestion of this plane with 'other'.
Definition: TGLUtil.cxx:516
EGLCoordType
Definition: TGLUtil.h:43
@ kGLSpherical
Definition: TGLUtil.h:47
@ kGLCylindrical
Definition: TGLUtil.h:46
@ kGLPolar
Definition: TGLUtil.h:45
@ kGLCartesian
Definition: TGLUtil.h:44
TGLVector3 operator-(const TGLVertex3 &vertex1, const TGLVertex3 &vertex2)
Definition: TGLUtil.h:351
std::vector< TGLPlane > TGLPlaneSet_t
Definition: TGLUtil.h:571
EGLPlotType
Definition: TGLUtil.h:51
@ kGLBoxPlot
Definition: TGLUtil.h:54
@ kGLTH3Composition
Definition: TGLUtil.h:60
@ kGLLegoPlot
Definition: TGLUtil.h:52
@ kGLIsoPlot
Definition: TGLUtil.h:58
@ kGLVoxel
Definition: TGLUtil.h:61
@ kGLSurfacePlot
Definition: TGLUtil.h:53
@ kGL5D
Definition: TGLUtil.h:59
@ kGLParametricPlot
Definition: TGLUtil.h:57
@ kGLTF3Plot
Definition: TGLUtil.h:55
@ kGLStackPlot
Definition: TGLUtil.h:56
@ kGLDefaultPlot
Definition: TGLUtil.h:62
TGLVector3 Cross(const TGLVector3 &v1, const TGLVector3 &v2)
Definition: TGLUtil.h:323
TGLVertex3 operator*(Double_t f, const TGLVertex3 &v)
Definition: TGLUtil.h:135
std::vector< TGLPlane >::const_iterator TGLPlaneSet_ci
Definition: TGLUtil.h:573
std::vector< TGLPlane >::iterator TGLPlaneSet_i
Definition: TGLUtil.h:572
int type
Definition: TGX11.cxx:121
double sqrt(double)
point * points
Definition: X3DBuffer.c:22
Bool_t IsActive() const
Definition: TGLUtil.h:1277
Bool_t fActive
Definition: TGLUtil.h:1263
void Stop() const
Definition: TGLUtil.h:1283
TGuardBase(const TGuardBase &rhs)
Definition: TGLUtil.h:1271
TGuardBase & operator=(const TGuardBase &rhs)
TOneArgGuard(Func f, Arg a)
Definition: TGLUtil.h:1295
TTwoArgsGuard(Func f, Arg1 a1, Arg2 a2)
Definition: TGLUtil.h:1314
Line Attributes class.
Definition: TAttLine.h:18
Marker Attributes class.
Definition: TAttMarker.h:19
Class to manage histogram axis.
Definition: TAxis.h:30
Int_t fMaxRow
Definition: TGLUtil.h:1157
const T * operator[](size_type ind) const
Definition: TGLUtil.h:1170
std::vector< T >::size_type size_type
Definition: TGLUtil.h:1158
void SetRowLen(Int_t len)
Definition: TGLUtil.h:1166
void SetMaxRow(Int_t max)
Definition: TGLUtil.h:1162
Int_t fRowLen
Definition: TGLUtil.h:1156
TGL2DArray()
Definition: TGLUtil.h:1161
Concrete class describing an orientated (free) or axis aligned box of 8 vertices.
Abstract base camera class - concrete classes for orthographic and perspective cameras derive from it...
Definition: TGLCamera.h:44
TGLCapabilityEnabler & operator=(const TGLCapabilityEnabler &)
~TGLCapabilityEnabler()
Destructor - reset state if changed.
Definition: TGLUtil.cxx:2719
TGLCapabilityEnabler(const TGLCapabilityEnabler &)
TGLCapabilitySwitch & operator=(const TGLCapabilitySwitch &)
TGLCapabilitySwitch(const TGLCapabilitySwitch &)
void SetState(Bool_t s)
Definition: TGLUtil.cxx:2696
~TGLCapabilitySwitch()
Destructor - reset state if changed.
Definition: TGLUtil.cxx:2688
Class encapsulating a set of colors used throughout standard rendering.
Definition: TGLUtil.h:836
TGLColor & Foreground()
Definition: TGLUtil.h:852
TGLColor & Markup()
Definition: TGLUtil.h:854
TGLColor fSelection[5]
Definition: TGLUtil.h:842
void StdLightBackground()
Set defaults for light (white) background.
Definition: TGLUtil.cxx:1389
const TGLColor & Markup() const
Definition: TGLUtil.h:860
ClassDefNV(TGLColorSet, 0)
TGLColor & Outline()
Definition: TGLUtil.h:853
TGLColor fMarkup
Definition: TGLUtil.h:841
~TGLColorSet()=default
TGLColor & Selection(Int_t i)
Definition: TGLUtil.h:855
const TGLColor & Foreground() const
Definition: TGLUtil.h:858
TGLColorSet & operator=(const TGLColorSet &s)
Assignment operator.
Definition: TGLUtil.cxx:1358
TGLColor fBackground
Definition: TGLUtil.h:838
TGLColor fOutline
Definition: TGLUtil.h:840
TGLColor & Background()
Definition: TGLUtil.h:851
const TGLColor & Outline() const
Definition: TGLUtil.h:859
const TGLColor & Selection(Int_t i) const
Definition: TGLUtil.h:861
void StdDarkBackground()
Set defaults for dark (black) background.
Definition: TGLUtil.cxx:1372
TGLColorSet()
Constructor. Sets default for dark background.
Definition: TGLUtil.cxx:1337
const TGLColor & Background() const
Definition: TGLUtil.h:857
TGLColor fForeground
Definition: TGLUtil.h:839
Class encapsulating color information in preferred GL format - an array of four unsigned bytes.
Definition: TGLUtil.h:785
void SetTransparency(Char_t transparency)
Set alpha from the transparency.
Definition: TGLUtil.cxx:1312
const UChar_t * CArr() const
Definition: TGLUtil.h:800
Char_t GetTransparency() const
Returns transparency value.
Definition: TGLUtil.cxx:1227
void SetColor(Int_t r, Int_t g, Int_t b, Int_t a=255)
Set color with Int_t values.
Definition: TGLUtil.cxx:1235
UChar_t GetAlpha() const
Definition: TGLUtil.h:805
UChar_t GetBlue() const
Definition: TGLUtil.h:804
void SetBlue(Int_t v)
Definition: TGLUtil.h:812
void SetGreen(Int_t v)
Definition: TGLUtil.h:811
UChar_t fRGBA[4]
Definition: TGLUtil.h:787
TGLColor()
Default constructor. Color is initialized to black.
Definition: TGLUtil.cxx:1158
ClassDefNV(TGLColor, 0)
UChar_t GetRed() const
Definition: TGLUtil.h:802
void SetAlpha(Int_t v)
Definition: TGLUtil.h:813
TString AsString() const
Return string describing the color.
Definition: TGLUtil.cxx:1320
TGLColor & operator=(const TGLColor &c)
Assignment operator.
Definition: TGLUtil.cxx:1204
UChar_t * Arr()
Definition: TGLUtil.h:799
void SetRed(Int_t v)
Definition: TGLUtil.h:810
UChar_t GetGreen() const
Definition: TGLUtil.h:803
Color_t GetColorIndex() const
Returns color-index representing the color.
Definition: TGLUtil.cxx:1217
Short_t fIndex
Definition: TGLUtil.h:788
~TGLDisableGuard()
TGLDisableGuard destructor.
Definition: TGLUtil.cxx:2773
TGLDisableGuard(Int_t cap)
TGLDisableGuard constructor.
Definition: TGLUtil.cxx:2764
TGLDisableGuard(const TGLDisableGuard &)
TGLDisableGuard & operator=(const TGLDisableGuard &)
~TGLEnableGuard()
TGLEnableGuard destructor.
Definition: TGLUtil.cxx:2756
TGLEnableGuard(Int_t cap)
TGLEnableGuard constructor.
Definition: TGLUtil.cxx:2747
TGLEnableGuard(const TGLEnableGuard &)
TGLEnableGuard & operator=(const TGLEnableGuard &)
Bool_t fFlip
Definition: TGLUtil.h:1099
void(* fFoo)(Float_t)
Definition: TGLUtil.h:1100
TGLFloatHolder & operator=(const TGLFloatHolder &)
TGLFloatHolder(const TGLFloatHolder &)
Float_t fState
Definition: TGLUtil.h:1098
const UChar_t * GetColour(Double_t z) const
Get color.
Definition: TGLUtil.cxx:4291
const std::vector< Double_t > * fContours
Definition: TGLUtil.h:1342
Int_t GetPaletteSize() const
Get. Palette. Size.
Definition: TGLUtil.cxx:4254
void SetContours(const std::vector< Double_t > *contours)
Clear :)
Definition: TGLUtil.cxx:4218
UInt_t fPaletteSize
Definition: TGLUtil.h:1343
TGLLevelPalette & operator=(const TGLLevelPalette &)
TGLLevelPalette()
Ctor.
Definition: TGLUtil.cxx:4150
std::vector< UChar_t > fTexels
Definition: TGLUtil.h:1341
void DisableTexture() const
Disable 1D texture.
Definition: TGLUtil.cxx:4245
TGLLevelPalette(const TGLLevelPalette &)
Double_t GetTexCoord(Double_t z) const
Get tex coordinate.
Definition: TGLUtil.cxx:4262
Rgl::Range_t fZRange
Definition: TGLUtil.h:1346
Bool_t GeneratePalette(UInt_t paletteSize, const Rgl::Range_t &zRange, Bool_t checkSize=kTRUE)
Try to find colors for palette.
Definition: TGLUtil.cxx:4161
Int_t fMaxPaletteSize
Definition: TGLUtil.h:1345
UInt_t fTexture
Definition: TGLUtil.h:1344
void EnableTexture(Int_t mode) const
Enable 1D texture.
Definition: TGLUtil.cxx:4226
3D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex'.
Definition: TGLUtil.h:387
const TGLVector3 & Vector() const
Definition: TGLUtil.h:406
TGLLine3(const TGLVertex3 &start, const TGLVertex3 &end)
Vector of line from fVertex.
Definition: TGLUtil.cxx:176
const TGLVertex3 & Start() const
Definition: TGLUtil.h:404
const TGLVertex3 End() const
Definition: TGLUtil.h:405
void Draw() const
Draw line in current basic GL color.
Definition: TGLUtil.cxx:211
~TGLLine3()=default
ClassDefNV(TGLLine3, 0)
TGLVector3 fVector
Start vertex of line.
Definition: TGLUtil.h:391
TGLVertex3 fVertex
Definition: TGLUtil.h:390
void Set(const TGLVertex3 &start, const TGLVertex3 &end)
Set 3D line running from 'start' to 'end'.
Definition: TGLUtil.cxx:192
16 component (4x4) transform matrix - column MAJOR as per GL.
Definition: TGLUtil.h:598
void MultLeft(const TGLMatrix &lhs)
Multiply with matrix lhs on left.
Definition: TGLUtil.cxx:718
TGLVector3 Multiply(const TGLVector3 &v, Double_t w=1) const
Multiply vector.
Definition: TGLUtil.cxx:1049
TGLMatrix & operator=(const TGLMatrix &rhs)
Definition: TGLUtil.h:673
void Scale(const TGLVector3 &scale)
Set matrix axis scales to 'scale'.
Definition: TGLUtil.cxx:834
void Set(const TGLVertex3 &origin, const TGLVector3 &zAxis, const TGLVector3 &xAxis=0)
Set matrix which when applied puts local origin at 'origin' and the local Z axis in direction 'z'.
Definition: TGLUtil.cxx:736
void RotateLF(Int_t i1, Int_t i2, Double_t amount)
Rotate in local frame.
Definition: TGLUtil.cxx:897
Double_t Invert()
Invert the matrix, returns determinant.
Definition: TGLUtil.cxx:971
void MoveLF(Int_t ai, Double_t amount)
Translate in local frame.
Definition: TGLUtil.cxx:813
void SetIdentity()
Set matrix to identity.
Definition: TGLUtil.cxx:765
Bool_t ValidIndex(UInt_t index) const
Definition: TGLUtil.h:604
void Transpose3x3()
Transpose the top left 3x3 matrix component along major diagonal Supported as currently incompatibili...
Definition: TGLUtil.cxx:947
Double_t * Arr()
Definition: TGLUtil.h:665
void RotatePF(Int_t i1, Int_t i2, Double_t amount)
Rotate in parent frame. Does optimised version of MultLeft.
Definition: TGLUtil.cxx:914
TGLMatrix & operator*=(const TGLMatrix &rhs)
Definition: TGLUtil.h:623
void SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z)
Definition: TGLUtil.h:733
TGLVector3 GetBaseVec(Int_t b) const
Definition: TGLUtil.h:754
void Move3LF(Double_t x, Double_t y, Double_t z)
Translate in local frame along all base vectors simultaneously.
Definition: TGLUtil.cxx:822
const Double_t * CArr() const
Definition: TGLUtil.h:664
void Rotate(const TGLVertex3 &pivot, const TGLVector3 &axis, Double_t angle)
Update matrix so resulting transform has been rotated about 'pivot' (in parent frame),...
Definition: TGLUtil.cxx:870
virtual ~TGLMatrix()
Destroy matrix object.
Definition: TGLUtil.cxx:695
TGLVector3 GetTranslation() const
Return the translation component of matrix.
Definition: TGLUtil.cxx:794
Double_t & operator[](Int_t index)
Definition: TGLUtil.h:683
Double_t fVals[16]
Definition: TGLUtil.h:601
void RotateIP(TGLVector3 &v) const
Rotate vector in-place. Translation is not applied.
Definition: TGLUtil.cxx:1087
Bool_t IsScalingForRender() const
Return true if matrix is to be considered a scaling matrix for rendering.
Definition: TGLUtil.cxx:1111
void TransformVertex(TGLVertex3 &vertex) const
Transform passed 'vertex' by this matrix - converts local frame to parent.
Definition: TGLUtil.cxx:933
TGLVector3 GetScale() const
Get local axis scaling factors.
Definition: TGLUtil.cxx:1099
void MultRight(const TGLMatrix &rhs)
Multiply with matrix rhs on right.
Definition: TGLUtil.cxx:702
void SetTranslation(Double_t x, Double_t y, Double_t z)
Set matrix translation components x,y,z.
Definition: TGLUtil.cxx:776
void MultiplyIP(TGLVector3 &v, Double_t w=1) const
Multiply vector in-place.
Definition: TGLUtil.cxx:1075
void Translate(const TGLVector3 &vect)
Shift matrix translation components by 'vect' in parent frame.
Definition: TGLUtil.cxx:802
void Dump() const
Output 16 matrix components to std::cout.
Definition: TGLUtil.cxx:1132
TGLMatrix()
Construct default identity matrix:
Definition: TGLUtil.cxx:606
3D plane class - of format Ax + By + Cz + D = 0
Definition: TGLUtil.h:525
ClassDefNV(TGLPlane, 0)
void Set(const TGLPlane &other)
Assign from other.
Definition: TGLUtil.cxx:425
Double_t B() const
Definition: TGLUtil.h:554
Double_t D() const
Definition: TGLUtil.h:556
void Negate()
Negate the plane.
Definition: TGLUtil.cxx:481
TGLVertex3 NearestOn(const TGLVertex3 &point) const
Return nearest point on plane.
Definition: TGLUtil.cxx:500
Double_t C() const
Definition: TGLUtil.h:555
TGLPlane & operator=(const TGLPlane &src)
Assignment operator.
Definition: TGLUtil.cxx:389
~TGLPlane()=default
Double_t A() const
Definition: TGLUtil.h:553
void Normalise()
Normalise the plane.
Definition: TGLUtil.cxx:398
const Double_t * CArr() const
Definition: TGLUtil.h:563
Double_t * Arr()
Definition: TGLUtil.h:564
TGLPlane()
Construct a default plane of x + y + z = 0.
Definition: TGLUtil.cxx:336
Double_t DistanceTo(const TGLVertex3 &vertex) const
Distance from plane to vertex.
Definition: TGLUtil.cxx:492
TGLVector3 Norm() const
Definition: TGLUtil.h:558
void Dump() const
Output plane equation to std::out.
Definition: TGLUtil.cxx:416
Double_t fVals[4]
Definition: TGLUtil.h:528
Helper class for plot-painters holding information about axis ranges, numbers of bins and flags if ce...
Wrapper class for GLU quadric shape drawing object.
Definition: TGLQuadric.h:28
Viewport (pixel base) 2D rectangle class.
Definition: TGLUtil.h:422
Int_t Right() const
Definition: TGLUtil.h:457
Int_t & X()
Definition: TGLUtil.h:447
Int_t Y() const
Definition: TGLUtil.h:448
Int_t fY
Definition: TGLUtil.h:425
Int_t fWidth
Corner.
Definition: TGLUtil.h:426
Int_t CenterY() const
Definition: TGLUtil.h:455
Int_t Left() const
Definition: TGLUtil.h:456
Int_t & Y()
Definition: TGLUtil.h:449
TGLRect()
Positive width/height.
Definition: TGLUtil.cxx:229
const Int_t * CArr() const
Definition: TGLUtil.h:443
Int_t Diagonal() const
Return the diagonal of the rectangle.
Definition: TGLUtil.cxx:286
Int_t Height() const
Definition: TGLUtil.h:452
Int_t Width() const
Definition: TGLUtil.h:450
Rgl::EOverlap Overlap(const TGLRect &other) const
Return overlap result (kInside, kOutside, kPartial) of this rect with 'other'.
Definition: TGLUtil.cxx:297
void Offset(Int_t dX, Int_t dY)
Definition: TGLUtil.h:487
void Set(Int_t x, Int_t y, Int_t width, Int_t height)
Definition: TGLUtil.h:471
Int_t CenterX() const
Definition: TGLUtil.h:454
Int_t Longest() const
Definition: TGLUtil.h:494
Int_t X() const
Definition: TGLUtil.h:446
Int_t Bottom() const
Definition: TGLUtil.h:459
virtual ~TGLRect()
Destroy rect object.
Definition: TGLUtil.cxx:254
Int_t Top() const
Definition: TGLUtil.h:458
Int_t & Height()
Definition: TGLUtil.h:453
Int_t fHeight
Definition: TGLUtil.h:426
Int_t * CArr()
Definition: TGLUtil.h:444
Int_t & Width()
Definition: TGLUtil.h:451
void Expand(Int_t x, Int_t y)
Expand the rect to encompass point (x,y)
Definition: TGLUtil.cxx:261
Int_t fX
Definition: TGLUtil.h:425
void SetCorner(Int_t x, Int_t y)
Definition: TGLUtil.h:480
Double_t Aspect() const
Definition: TGLUtil.h:500
TGLSelectionBuffer & operator=(const TGLSelectionBuffer &)
const UChar_t * GetPixelColor(Int_t px, Int_t py) const
Get pixel color.
Definition: TGLUtil.cxx:2826
void ReadColorBuffer(Int_t width, Int_t height)
Read color buffer.
Definition: TGLUtil.cxx:2802
TGLSelectionBuffer(const TGLSelectionBuffer &)
virtual ~TGLSelectionBuffer()
TGLSelectionBuffer destructor.
Definition: TGLUtil.cxx:2795
TGLSelectionBuffer()
TGLSelectionBuffer constructor.
Definition: TGLUtil.cxx:2787
std::vector< UChar_t > fBuffer
Definition: TGLUtil.h:1134
virtual ~TColorLocker()
Definition: TGLUtil.h:885
TDrawQualityScaler(Float_t fac)
Definition: TGLUtil.h:907
virtual ~TDrawQualityScaler()
Definition: TGLUtil.h:910
Wrapper class for various misc static functions - error checking, draw helpers etc.
Definition: TGLUtil.h:879
static void DrawSphere(const TGLVertex3 &position, Double_t radius, const UChar_t rgba[4])
Draw sphere, centered on vertex 'position', with radius 'radius', color 'rgba'.
Definition: TGLUtil.cxx:2351
static void Color4ubv(const UChar_t *rgba)
Wrapper for glColor4ubv.
Definition: TGLUtil.cxx:1773
static UInt_t GetDrawQuality()
static: get draw quality
Definition: TGLUtil.cxx:1599
static Int_t fgPickingRadius
Definition: TGLUtil.h:929
static const UChar_t fgWhite[4]
Definition: TGLUtil.h:1053
static UInt_t fgDefaultDrawQuality
Definition: TGLUtil.h:917
static void SetDrawQuality(UInt_t dq)
static: set draw quality
Definition: TGLUtil.cxx:1607
static Float_t GetPointSizeScale()
Get global point-size scale.
Definition: TGLUtil.cxx:1877
static void Color3f(Float_t r, Float_t g, Float_t b)
Wrapper for glColor3f.
Definition: TGLUtil.cxx:1781
static Float_t fgPointSize
Definition: TGLUtil.h:922
static Float_t fgLineWidth
Definition: TGLUtil.h:923
static Float_t fgScreenScalingFactor
Definition: TGLUtil.h:927
static void ResetDrawQuality()
static: reset draw quality
Definition: TGLUtil.cxx:1615
static Float_t fgPointSizeScale
Definition: TGLUtil.h:924
static Bool_t IsColorLocked()
Returns true if color lock-count is greater than 0.
Definition: TGLUtil.cxx:1683
static void Color3fv(const Float_t *rgb)
Wrapper for glColor3fv.
Definition: TGLUtil.cxx:1797
static void SetLineWidthScale(Float_t scale)
Set global line-width scale.
Definition: TGLUtil.cxx:1901
static UInt_t LockColor()
Prevent further color changes.
Definition: TGLUtil.cxx:1663
static void Color4f(Float_t r, Float_t g, Float_t b, Float_t a)
Wrapper for glColor4f.
Definition: TGLUtil.cxx:1789
static void SetDrawColors(const UChar_t rgba[4])
Set basic draw colors from 4 component 'rgba' Used by other TGLUtil drawing routines.
Definition: TGLUtil.cxx:2330
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:1735
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:2266
static const UChar_t fgRed[4]
Definition: TGLUtil.h:1049
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:2246
static UInt_t GetDefaultDrawQuality()
static: get default draw quality
Definition: TGLUtil.cxx:1623
static void BeginExtendPickRegion(Float_t scale)
Definition: TGLUtil.cxx:1946
static void InitializeIfNeeded()
Initialize globals that require other libraries to be initialized.
Definition: TGLUtil.cxx:1576
ELineHeadShape
Definition: TGLUtil.h:948
@ kLineHeadNone
Definition: TGLUtil.h:948
@ kLineHeadBox
Definition: TGLUtil.h:948
@ kLineHeadArrow
Definition: TGLUtil.h:948
static Float_t GetLineWidthScale()
Returns global line-width scale.
Definition: TGLUtil.cxx:1893
static Float_t fgPointLineScalingFactor
Definition: TGLUtil.h:928
static UInt_t UnlockColor()
Allow color changes.
Definition: TGLUtil.cxx:1671
static void EndAttLine(Int_t pick_radius=0, Bool_t selection=kFALSE)
Restore previous line drawing state.
Definition: TGLUtil.cxx:2302
static void DrawLine(const TGLLine3 &line, ELineHeadShape head, Double_t size, const UChar_t rgba[4])
Draw thick line (tube) defined by 'line', with head at end shape 'head' - box/arrow/none,...
Definition: TGLUtil.cxx:2366
static void Color(const TGLColor &color)
Set color from TGLColor.
Definition: TGLUtil.cxx:1691
static void DrawRing(const TGLVertex3 &center, const TGLVector3 &normal, Double_t radius, const UChar_t *rgba)
Draw ring, centered on 'center', lying on plane defined by 'center' & 'normal' of outer radius 'radiu...
Definition: TGLUtil.cxx:2432
virtual ~TGLUtil()
Definition: TGLUtil.h:935
static void Color3ubv(const UChar_t *rgb)
Wrapper for glColor3ubv.
Definition: TGLUtil.cxx:1765
static Int_t CheckError(const char *loc)
Check current GL error state, outputting details via ROOT Error method if one.
Definition: TGLUtil.cxx:1640
static Float_t GetScreenScalingFactor()
Returns scaling factor between screen points and GL viewport pixels.
Definition: TGLUtil.cxx:1846
static void ColorAlpha(const TGLColor &color, UChar_t alpha)
Set color from TGLColor and alpha value.
Definition: TGLUtil.cxx:1699
static Int_t GetPickingRadius()
Returns picking radius.
Definition: TGLUtil.cxx:1865
static void SetPointSizeScale(Float_t scale)
Set global point-size scale.
Definition: TGLUtil.cxx:1885
static void Color4fv(const Float_t *rgba)
Wrapper for glColor4fv.
Definition: TGLUtil.cxx:1805
static void Color3ub(UChar_t r, UChar_t g, UChar_t b)
Wrapper for glColor3ub.
Definition: TGLUtil.cxx:1749
static UInt_t fgDrawQuality
Definition: TGLUtil.h:918
static GLUtesselator * GetDrawTesselator4dv()
Returns a tesselator for direct drawing when using 4-vertices with double precision.
Definition: TGLUtil.cxx:1555
static const UChar_t fgBlue[4]
Definition: TGLUtil.h:1051
static const UChar_t fgGrey[4]
Definition: TGLUtil.h:1054
EAxesType
Definition: TGLUtil.h:949
@ kAxesNone
Definition: TGLUtil.h:949
@ kAxesEdge
Definition: TGLUtil.h:949
@ kAxesOrigin
Definition: TGLUtil.h:949
static Float_t PointSize()
Get the point-size, taking the global scaling into account.
Definition: TGLUtil.cxx:1929
static void EndExtendPickRegion()
Definition: TGLUtil.cxx:1961
static GLUtesselator * GetDrawTesselator3dv()
Returns a tesselator for direct drawing when using 3-vertices with double precision.
Definition: TGLUtil.cxx:1534
static GLUtesselator * GetDrawTesselator4fv()
Returns a tesselator for direct drawing when using 4-vertices with single precision.
Definition: TGLUtil.cxx:1513
static const UChar_t fgGreen[4]
Definition: TGLUtil.h:1050
static UInt_t fgColorLockCount
Definition: TGLUtil.h:920
static GLUtesselator * GetDrawTesselator3fv()
Returns a tesselator for direct drawing when using 3-vertices with single precision.
Definition: TGLUtil.cxx:1492
TGLUtil(const TGLUtil &)
static void SetDefaultDrawQuality(UInt_t dq)
static: set default draw quality
Definition: TGLUtil.cxx:1631
static void PointToViewport(Int_t &x, Int_t &y)
Convert from point/screen coordinates to GL viewport coordinates.
Definition: TGLUtil.cxx:1817
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 'pos' with pixel radius 'radius'.
Definition: TGLUtil.cxx:2473
static void DrawNumber(const TString &num, const TGLVertex3 &pos, Bool_t center=kFALSE)
Draw number in string 'num' via internal 8x8-pixel bitmap on vertex 'pos'.
Definition: TGLUtil.cxx:2628
static Float_t LineWidth()
Get the line-width, taking the global scaling into account.
Definition: TGLUtil.cxx:1937
static Float_t fgLineWidthScale
Definition: TGLUtil.h:925
TGLUtil & operator=(const TGLUtil &)
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:1974
static void DrawSimpleAxes(const TGLCamera &camera, const TGLBoundingBox &bbox, Int_t axesType)
Draw simple xyz-axes for given bounding-box.
Definition: TGLUtil.cxx:2488
static const UChar_t fgYellow[4]
Definition: TGLUtil.h:1052
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:2014
static Float_t GetPointLineScalingFactor()
Return extra scaling factor for points and lines.
Definition: TGLUtil.cxx:1857
static void Color4ub(UChar_t r, UChar_t g, UChar_t b, UChar_t a)
Wrapper for glColor4ub.
Definition: TGLUtil.cxx:1757
static void RenderCrosses(const TAttMarker &marker, Float_t *p, Int_t n, Bool_t sec_selection=kFALSE)
Render markers as crosses.
Definition: TGLUtil.cxx:2134
3 component (x/y/z) vector class.
Definition: TGLUtil.h:248
Double_t Mag() const
Definition: TGLUtil.h:298
TGLVector3 & operator/=(Double_t val)
Definition: TGLUtil.h:283
ClassDefNV(TGLVector3, 1)
TGLVector3()=default
void Normalise()
Definition: TGLUtil.h:304
TGLVector3 & operator=(const TGLVertex3 &v)
Definition: TGLUtil.h:254
TGLVector3 operator-() const
Definition: TGLUtil.h:292
3 component (x/y/z) vertex class.
Definition: TGLUtil.h:84
void Dump() const
Output vertex component values to std::cout.
Definition: TGLUtil.cxx:130
void Minimum(const TGLVertex3 &other)
Definition: TGLUtil.cxx:111
Double_t X() const
Definition: TGLUtil.h:119
Double_t & Z()
Definition: TGLUtil.h:124
TGLVertex3 operator-() const
Definition: TGLUtil.h:167
Double_t Z() const
Definition: TGLUtil.h:123
ClassDefNV(TGLVertex3, 1)
Double_t fVals[3]
Definition: TGLUtil.h:88
Bool_t operator==(const TGLVertex3 &rhs) const
Definition: TGLUtil.h:149
Double_t * Arr()
Definition: TGLUtil.h:127
Double_t & operator[](Int_t index)
Definition: TGLUtil.h:182
Double_t & X()
Definition: TGLUtil.h:120
void Maximum(const TGLVertex3 &other)
Definition: TGLUtil.cxx:120
void Fill(Double_t val)
Definition: TGLUtil.h:204
void Set(Double_t x, Double_t y, Double_t z)
Definition: TGLUtil.h:210
TGLVertex3 & operator*=(Double_t f)
Definition: TGLUtil.h:173
const TGLVertex3 & operator+=(const TGLVector3 &val)
Definition: TGLUtil.h:276
void Negate()
Definition: TGLUtil.h:141
Double_t Y() const
Definition: TGLUtil.h:121
TGLVertex3 & operator=(const TGLVertex3 &rhs)
Definition: TGLUtil.h:155
TGLVertex3()
Construct a default (0.0, 0.0, 0.0) vertex.
Definition: TGLUtil.cxx:53
void Shift(TGLVector3 &shift)
Offset a vertex by vector 'shift'.
Definition: TGLUtil.cxx:92
const Double_t * CArr() const
Definition: TGLUtil.h:126
const TGLVertex3 & operator-=(const TGLVector3 &val)
Definition: TGLUtil.h:268
Bool_t ValidIndex(UInt_t index) const
Definition: TGLUtil.h:87
~TGLVertex3()
Destroy vertex object.
Definition: TGLUtil.cxx:85
Double_t & Y()
Definition: TGLUtil.h:122
Basic string class.
Definition: TString.h:136
TLine * line
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
static double C[]
double T(double x)
Definition: ChebyshevPol.h:34
void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, Bool_t color=kTRUE)
Definition: TGLUtil.cxx:3348
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:3836
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:3217
void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3, const TGLVector3 &normal)
Draw quad face.
Definition: TGLUtil.cxx:2953
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:3418
const Float_t gNullEmission[]
Definition: TGLUtil.cxx:2847
void ObjectIDToColor(Int_t objectID, Bool_t highColor)
Object id encoded as rgb triplet.
Definition: TGLUtil.cxx:2891
const Float_t gBlueEmission[]
Definition: TGLUtil.cxx:2843
const Float_t gWhiteEmission[]
Definition: TGLUtil.cxx:2845
void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax, Double_t zScale, std::vector< Double_t > &zLevels)
Definition: TGLUtil.cxx:3820
std::pair< Int_t, Int_t > BinRange_t
Definition: TGLUtil.h:1194
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:3495
const Float_t gGrayEmission[]
Definition: TGLUtil.cxx:2846
void GetColor(Float_t v, Float_t vmin, Float_t vmax, Int_t type, Float_t *rgba)
This function creates color for parametric surface's vertex, using its 'u' value.
Definition: TGLUtil.cxx:3877
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:3244
void DrawError(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax)
Definition: TGLUtil.cxx:3298
const Float_t gRedEmission[]
Definition: TGLUtil.cxx:2841
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's bar as a 3d box.
Definition: TGLUtil.cxx:3057
std::pair< Double_t, Double_t > Range_t
Definition: TGLUtil.h:1195
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's bar as a 3d box.
Definition: TGLUtil.cxx:3007
const Float_t gGreenEmission[]
Definition: TGLUtil.cxx:2842
void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3, const TGLVertex3 &v4)
Draw quad outline.
Definition: TGLUtil.cxx:2939
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:3197
EOverlap
Definition: TGLUtil.h:35
@ kInside
Definition: TGLUtil.h:36
@ kOutside
Definition: TGLUtil.h:38
@ kPartial
Definition: TGLUtil.h:37
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:3275
TOneArgGuard< Func, Arg > make_guard(Func f, Arg a)
Definition: TGLUtil.h:1326
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's bar as a 3d box LULULULU.
Definition: TGLUtil.cxx:3134
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:2983
const Float_t gOrangeEmission[]
Definition: TGLUtil.cxx:2844
Int_t ColorToObjectID(const UChar_t *color, Bool_t highColor)
Definition: TGLUtil.cxx:2917
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:3759
static constexpr double s
static const char * what
Definition: stlLoader.cc:6
Definition: civetweb.c:2228
auto * a
Definition: textangle.C:12
auto * t1
Definition: textangle.C:20
REAL * vertex
Definition: triangle.c:513