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
22class TString;
23class TGLBoundingBox;
24class TGLCamera;
25
26class TAttMarker;
27class TAttLine;
28
29class GLUtesselator;
30
31namespace Rgl
32{
34 {
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
80class TGLVector3; // Forward declare for Shift()
81
83{
84protected:
85 // Fields
86 Bool_t ValidIndex(UInt_t index) const { return (index < 3); }
88
89public:
90 TGLVertex3();
93 TGLVertex3(const TGLVertex3 & other);
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//______________________________________________________________________________
141{
142 fVals[0] = -fVals[0];
143 fVals[1] = -fVals[1];
144 fVals[2] = -fVals[2];
145}
146
147//______________________________________________________________________________
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//______________________________________________________________________________
192inline 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//______________________________________________________________________________
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//______________________________________________________________________________
217inline 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//______________________________________________________________________________
225inline 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
246class TGLVector3 : public TGLVertex3
247{
248public:
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//______________________________________________________________________________
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//______________________________________________________________________________
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//______________________________________________________________________________
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//______________________________________________________________________________
316inline 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//______________________________________________________________________________
322inline 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//______________________________________________________________________________
330inline 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//______________________________________________________________________________
336inline 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
343inline 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
350inline 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
357inline 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
364inline 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
371inline 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
386{
387private:
388 // Fields
389 TGLVertex3 fVertex; //! Start vertex of line
390 TGLVector3 fVector; //! Vector of line from fVertex
391
392public:
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
421{
422private:
423 // Fields
424 Int_t fX, fY; //! Corner
425 Int_t fWidth, fHeight; //! Positive width/height
426
427public:
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//______________________________________________________________________________
470inline 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//______________________________________________________________________________
486inline void TGLRect::Offset(Int_t dX, Int_t dY)
487{
488 fX += dX;
489 fY += dY;
490}
491
492//______________________________________________________________________________
494{
495 return fWidth > fHeight ? fWidth : fHeight;
496}
497
498//______________________________________________________________________________
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
524{
525private:
526 // Fields
528
529 // Methods
530 void Normalise();
531
532public:
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
570typedef std::vector<TGLPlane> TGLPlaneSet_t;
571typedef std::vector<TGLPlane>::iterator TGLPlaneSet_i;
572typedef std::vector<TGLPlane>::const_iterator TGLPlaneSet_ci;
573
574// Some free functions for planes
575std::pair<Bool_t, TGLLine3> Intersection(const TGLPlane & p1, const TGLPlane & p2);
576std::pair<Bool_t, TGLVertex3> Intersection(const TGLPlane & p1, const TGLPlane & p2, const TGLPlane & p3);
577std::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{
598private:
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
605public:
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();
643
644 // Accesors
646 TGLVector3 GetScale() const;
648
650 void SetBaseVec(Int_t b, const TGLVector3& v);
651 void SetBaseVec(Int_t b, Double_t* x);
652
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//______________________________________________________________________________
704inline 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//______________________________________________________________________________
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
784{
785protected:
788
789public:
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);
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{
836protected:
841 TGLColor fSelection[5]; // Colors for shape-selection-levels
842
843public:
844 TGLColorSet();
845 TGLColorSet(const TGLColorSet& s);
846 ~TGLColorSet() = default;
847
849
852 TGLColor& Outline() { return fOutline; }
853 TGLColor& Markup() { return fMarkup; }
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
878{
879public:
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
915private:
918
920
925
929
930 TGLUtil(const TGLUtil&); // Not implemented.
931 TGLUtil& operator=(const TGLUtil&); // Not implemented.
932
933public:
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();
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{
1062private:
1065
1069
1070 void SetState(Bool_t s);
1071
1072public:
1075};
1076
1078{
1079private:
1082
1085
1086public:
1089};
1090
1092{
1093 TGLFloatHolder(const TGLFloatHolder&); // Not implemented
1094 TGLFloatHolder& operator=(const TGLFloatHolder&); // Not implemented
1095
1100
1101public:
1102 TGLFloatHolder(Int_t what, Float_t state, void (*foo)(Float_t));
1104};
1105
1107private:
1109
1110public:
1111 TGLEnableGuard(Int_t cap);
1113
1114private:
1117};
1118
1120private:
1122
1123public:
1126
1127private:
1130};
1131
1133 std::vector<UChar_t> fBuffer;
1136
1137public:
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
1145private:
1148
1149 ClassDef(TGLSelectionBuffer, 0); //Holds color buffer content for selection
1150};
1151
1152template<class T>
1153class TGL2DArray : public std::vector<T> {
1154private:
1157 typedef typename std::vector<T>::size_type size_type;
1158
1159public:
1162 {
1163 fMaxRow = max;
1164 }
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
1179class TGLPlotCoordinates;
1180class TGLQuadric;
1181class TAxis;
1182
1183namespace Rgl {
1184
1185extern const Float_t gRedEmission[];
1186extern const Float_t gGreenEmission[];
1187extern const Float_t gBlueEmission[];
1188extern const Float_t gOrangeEmission[];
1189extern const Float_t gWhiteEmission[];
1190extern const Float_t gGrayEmission[];
1191extern const Float_t gNullEmission[];
1192
1193typedef std::pair<Int_t, Int_t> BinRange_t;
1194typedef std::pair<Double_t, Double_t> Range_t;
1195
1196void ObjectIDToColor(Int_t objectID, Bool_t highColor);
1197Int_t ColorToObjectID(const UChar_t *color, Bool_t highColor);
1198void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2,
1199 const TGLVertex3 &v3, const TGLVertex3 &v4);
1200void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1,
1201 const TGLVertex3 &v2, const TGLVertex3 &v3,
1202 const TGLVector3 &normal);
1203void DrawQuadFilled(const Double_t *v0, const Double_t *v1,
1204 const Double_t *v2, const Double_t *v3,
1205 const Double_t *normal);
1206
1207void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2,
1208 const TGLVertex3 &v3, const TGLVector3 &norm1,
1209 const TGLVector3 &norm2, const TGLVector3 &norm3);
1210void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax,
1211 Double_t zMin, Double_t zMax, Int_t fp);
1212
1213void 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
1217void 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
1224void DrawQuadStripWithRadialGradientFill(unsigned nPoints, const Double_t *inner, const Double_t *innerRGBA,
1225 const Double_t *outer, const Double_t *outerRGBA);
1226
1227#ifndef __CINT__
1228void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t zMax,
1229 Double_t tMin, Double_t tMax);
1230void DrawTrapezoidTextured(const Double_t ver[][3], Double_t texMin, Double_t texMax);
1231void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_t zMax,
1232 Double_t tMin, Double_t tMax);
1233#endif
1234
1235void DrawCylinder(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
1236 Double_t yMax, Double_t zMin, Double_t zMax);
1237void DrawSphere(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
1238 Double_t yMax, Double_t zMin, Double_t zMax);
1239void DrawError(Double_t xMin, Double_t xMax, Double_t yMin,
1240 Double_t yMax, Double_t zMin, Double_t zMax);
1241
1242#ifndef __CINT__
1243void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, Bool_t color = kTRUE);
1244void DrawTrapezoid(const Double_t ver[][3]);
1245#endif
1246
1247void DrawAxes(Int_t frontPoint, const Int_t *viewport, const TGLVertex3 *box2D,
1248 const TGLPlotCoordinates *plotCoord, TAxis *xAxis, TAxis *yAxis,
1249 TAxis *zAxis);
1250void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax,
1251 Double_t zScale, std::vector<Double_t> &zLevels);
1252
1253void 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);
1256void 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);
1258void GetColor(Float_t v, Float_t vmin, Float_t vmax, Int_t type, Float_t *rgba);
1259
1261private:
1263
1265protected:
1267 : fActive(kTRUE)
1268 {
1269 }
1271 : fActive(kTRUE)
1272 {
1273 rhs.fActive = kFALSE;
1274 }
1275
1277 {
1278 return fActive;
1279 }
1280
1281public:
1282 void Stop()const
1283 {
1284 fActive = kFALSE;
1285 }
1286};
1287
1288template<class Func, class Arg>
1289class TOneArgGuard : public TGuardBase {
1290private:
1291 Func fFunc;
1292 Arg fArg;
1293public:
1294 TOneArgGuard(Func f, Arg a)
1295 : fFunc(f), fArg(a)
1296 {
1297 }
1299 {
1300 if (IsActive())
1301 fFunc(fArg);
1302 }
1303};
1304
1305template<class Func, class Arg1, class Arg2>
1307private:
1308 Func fFunc;
1309 Arg1 fArg1;
1310 Arg2 fArg2;
1311
1312public:
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
1324template<class Func, class Arg>
1326{
1327 return TOneArgGuard<Func, Arg>(f, a);
1328}
1329
1330template<class Func, class Arg1, class Arg2>
1332{
1333 return TTwoArgsGuard<Func, Arg1, Arg2>(f, a1, a2);
1334}
1335
1336}//namespace Rgl.
1337
1339private:
1340 std::vector<UChar_t> fTexels;
1341 const std::vector<Double_t> *fContours;
1346
1347 TGLLevelPalette(const TGLLevelPalette&); // Not implemented
1348 TGLLevelPalette& operator=(const TGLLevelPalette&); // Not implemented
1349
1350public:
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
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]
int Int_t
Definition: RtypesCore.h:43
unsigned char UChar_t
Definition: RtypesCore.h:36
char Char_t
Definition: RtypesCore.h:31
unsigned int UInt_t
Definition: RtypesCore.h:44
const Bool_t kFALSE
Definition: RtypesCore.h:90
bool Bool_t
Definition: RtypesCore.h:61
short Short_t
Definition: RtypesCore.h:37
double Double_t
Definition: RtypesCore.h:57
short Color_t
Definition: RtypesCore.h:81
float Float_t
Definition: RtypesCore.h:55
const Bool_t kTRUE
Definition: RtypesCore.h:89
#define ClassDef(name, id)
Definition: Rtypes.h:322
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
void Error(const char *location, const char *msgfmt,...)
const TGLVector3 operator/(const TGLVector3 &vec, Double_t val)
Definition: TGLUtil.h:330
TGLVertex3 operator+(const TGLVertex3 &vertex1, const TGLVector3 &vertex2)
Definition: TGLUtil.h:343
Double_t Dot(const TGLVector3 &v1, const TGLVector3 &v2)
Definition: TGLUtil.h:316
std::pair< Bool_t, TGLLine3 > Intersection(const TGLPlane &p1, const TGLPlane &p2)
Find 3D line interestion of this plane with 'other'.
Definition: TGLUtil.cxx:517
EGLCoordType
Definition: TGLUtil.h:42
@ kGLSpherical
Definition: TGLUtil.h:46
@ kGLCylindrical
Definition: TGLUtil.h:45
@ kGLPolar
Definition: TGLUtil.h:44
@ kGLCartesian
Definition: TGLUtil.h:43
TGLVector3 operator-(const TGLVertex3 &vertex1, const TGLVertex3 &vertex2)
Definition: TGLUtil.h:350
std::vector< TGLPlane > TGLPlaneSet_t
Definition: TGLUtil.h:570
EGLPlotType
Definition: TGLUtil.h:50
@ kGLBoxPlot
Definition: TGLUtil.h:53
@ kGLTH3Composition
Definition: TGLUtil.h:59
@ kGLLegoPlot
Definition: TGLUtil.h:51
@ kGLIsoPlot
Definition: TGLUtil.h:57
@ kGLVoxel
Definition: TGLUtil.h:60
@ kGLSurfacePlot
Definition: TGLUtil.h:52
@ kGL5D
Definition: TGLUtil.h:58
@ kGLParametricPlot
Definition: TGLUtil.h:56
@ kGLTF3Plot
Definition: TGLUtil.h:54
@ kGLStackPlot
Definition: TGLUtil.h:55
@ kGLDefaultPlot
Definition: TGLUtil.h:61
TGLVector3 Cross(const TGLVector3 &v1, const TGLVector3 &v2)
Definition: TGLUtil.h:322
TGLVertex3 operator*(Double_t f, const TGLVertex3 &v)
Definition: TGLUtil.h:134
std::vector< TGLPlane >::const_iterator TGLPlaneSet_ci
Definition: TGLUtil.h:572
std::vector< TGLPlane >::iterator TGLPlaneSet_i
Definition: TGLUtil.h:571
int type
Definition: TGX11.cxx:120
double sqrt(double)
typedef void((*Func_t)())
point * points
Definition: X3DBuffer.c:22
Bool_t IsActive() const
Definition: TGLUtil.h:1276
Bool_t fActive
Definition: TGLUtil.h:1262
void Stop() const
Definition: TGLUtil.h:1282
TGuardBase(const TGuardBase &rhs)
Definition: TGLUtil.h:1270
TGuardBase & operator=(const TGuardBase &rhs)
TOneArgGuard(Func f, Arg a)
Definition: TGLUtil.h:1294
TTwoArgsGuard(Func f, Arg1 a1, Arg2 a2)
Definition: TGLUtil.h:1313
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:1156
const T * operator[](size_type ind) const
Definition: TGLUtil.h:1169
std::vector< T >::size_type size_type
Definition: TGLUtil.h:1157
void SetRowLen(Int_t len)
Definition: TGLUtil.h:1165
void SetMaxRow(Int_t max)
Definition: TGLUtil.h:1161
Int_t fRowLen
Definition: TGLUtil.h:1155
TGL2DArray()
Definition: TGLUtil.h:1160
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:43
TGLCapabilityEnabler & operator=(const TGLCapabilityEnabler &)
~TGLCapabilityEnabler()
Destructor - reset state if changed.
Definition: TGLUtil.cxx:2720
TGLCapabilityEnabler(const TGLCapabilityEnabler &)
TGLCapabilitySwitch & operator=(const TGLCapabilitySwitch &)
TGLCapabilitySwitch(const TGLCapabilitySwitch &)
void SetState(Bool_t s)
Definition: TGLUtil.cxx:2697
~TGLCapabilitySwitch()
Destructor - reset state if changed.
Definition: TGLUtil.cxx:2689
Class encapsulating a set of colors used throughout standard rendering.
Definition: TGLUtil.h:835
TGLColor & Foreground()
Definition: TGLUtil.h:851
TGLColor & Markup()
Definition: TGLUtil.h:853
TGLColor fSelection[5]
Definition: TGLUtil.h:841
void StdLightBackground()
Set defaults for light (white) background.
Definition: TGLUtil.cxx:1390
const TGLColor & Markup() const
Definition: TGLUtil.h:859
ClassDefNV(TGLColorSet, 0)
TGLColor & Outline()
Definition: TGLUtil.h:852
TGLColor fMarkup
Definition: TGLUtil.h:840
~TGLColorSet()=default
TGLColor & Selection(Int_t i)
Definition: TGLUtil.h:854
const TGLColor & Foreground() const
Definition: TGLUtil.h:857
TGLColorSet & operator=(const TGLColorSet &s)
Assignment operator.
Definition: TGLUtil.cxx:1359
TGLColor fBackground
Definition: TGLUtil.h:837
TGLColor fOutline
Definition: TGLUtil.h:839
TGLColor & Background()
Definition: TGLUtil.h:850
const TGLColor & Outline() const
Definition: TGLUtil.h:858
const TGLColor & Selection(Int_t i) const
Definition: TGLUtil.h:860
void StdDarkBackground()
Set defaults for dark (black) background.
Definition: TGLUtil.cxx:1373
TGLColorSet()
Constructor. Sets default for dark background.
Definition: TGLUtil.cxx:1338
const TGLColor & Background() const
Definition: TGLUtil.h:856
TGLColor fForeground
Definition: TGLUtil.h:838
Class encapsulating color information in preferred GL format - an array of four unsigned bytes.
Definition: TGLUtil.h:784
void SetTransparency(Char_t transparency)
Set alpha from the transparency.
Definition: TGLUtil.cxx:1313
const UChar_t * CArr() const
Definition: TGLUtil.h:799
Char_t GetTransparency() const
Returns transparency value.
Definition: TGLUtil.cxx:1228
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
UChar_t GetAlpha() const
Definition: TGLUtil.h:804
UChar_t GetBlue() const
Definition: TGLUtil.h:803
void SetBlue(Int_t v)
Definition: TGLUtil.h:811
void SetGreen(Int_t v)
Definition: TGLUtil.h:810
UChar_t fRGBA[4]
Definition: TGLUtil.h:786
TGLColor()
Default constructor. Color is initialized to black.
Definition: TGLUtil.cxx:1159
ClassDefNV(TGLColor, 0)
UChar_t GetRed() const
Definition: TGLUtil.h:801
void SetAlpha(Int_t v)
Definition: TGLUtil.h:812
TString AsString() const
Return string describing the color.
Definition: TGLUtil.cxx:1321
TGLColor & operator=(const TGLColor &c)
Assignment operator.
Definition: TGLUtil.cxx:1205
UChar_t * Arr()
Definition: TGLUtil.h:798
void SetRed(Int_t v)
Definition: TGLUtil.h:809
UChar_t GetGreen() const
Definition: TGLUtil.h:802
Color_t GetColorIndex() const
Returns color-index representing the color.
Definition: TGLUtil.cxx:1218
Short_t fIndex
Definition: TGLUtil.h:787
~TGLDisableGuard()
TGLDisableGuard destructor.
Definition: TGLUtil.cxx:2774
TGLDisableGuard(Int_t cap)
TGLDisableGuard constructor.
Definition: TGLUtil.cxx:2765
TGLDisableGuard(const TGLDisableGuard &)
TGLDisableGuard & operator=(const TGLDisableGuard &)
~TGLEnableGuard()
TGLEnableGuard destructor.
Definition: TGLUtil.cxx:2757
TGLEnableGuard(Int_t cap)
TGLEnableGuard constructor.
Definition: TGLUtil.cxx:2748
TGLEnableGuard(const TGLEnableGuard &)
TGLEnableGuard & operator=(const TGLEnableGuard &)
Bool_t fFlip
Definition: TGLUtil.h:1098
void(* fFoo)(Float_t)
Definition: TGLUtil.h:1099
TGLFloatHolder & operator=(const TGLFloatHolder &)
TGLFloatHolder(const TGLFloatHolder &)
Float_t fState
Definition: TGLUtil.h:1097
const UChar_t * GetColour(Double_t z) const
Get color.
Definition: TGLUtil.cxx:4292
const std::vector< Double_t > * fContours
Definition: TGLUtil.h:1341
Int_t GetPaletteSize() const
Get. Palette. Size.
Definition: TGLUtil.cxx:4255
void SetContours(const std::vector< Double_t > *contours)
Clear :)
Definition: TGLUtil.cxx:4219
UInt_t fPaletteSize
Definition: TGLUtil.h:1342
TGLLevelPalette & operator=(const TGLLevelPalette &)
TGLLevelPalette()
Ctor.
Definition: TGLUtil.cxx:4151
std::vector< UChar_t > fTexels
Definition: TGLUtil.h:1340
void DisableTexture() const
Disable 1D texture.
Definition: TGLUtil.cxx:4246
TGLLevelPalette(const TGLLevelPalette &)
Double_t GetTexCoord(Double_t z) const
Get tex coordinate.
Definition: TGLUtil.cxx:4263
Rgl::Range_t fZRange
Definition: TGLUtil.h:1345
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
Int_t fMaxPaletteSize
Definition: TGLUtil.h:1344
UInt_t fTexture
Definition: TGLUtil.h:1343
void EnableTexture(Int_t mode) const
Enable 1D texture.
Definition: TGLUtil.cxx:4227
3D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex'.
Definition: TGLUtil.h:386
const TGLVector3 & Vector() const
Definition: TGLUtil.h:405
TGLLine3(const TGLVertex3 &start, const TGLVertex3 &end)
Vector of line from fVertex.
Definition: TGLUtil.cxx:177
const TGLVertex3 & Start() const
Definition: TGLUtil.h:403
const TGLVertex3 End() const
Definition: TGLUtil.h:404
void Draw() const
Draw line in current basic GL color.
Definition: TGLUtil.cxx:212
~TGLLine3()=default
ClassDefNV(TGLLine3, 0)
TGLVector3 fVector
Start vertex of line.
Definition: TGLUtil.h:390
TGLVertex3 fVertex
Definition: TGLUtil.h:389
void Set(const TGLVertex3 &start, const TGLVertex3 &end)
Set 3D line running from 'start' to 'end'.
Definition: TGLUtil.cxx:193
16 component (4x4) transform matrix - column MAJOR as per GL.
Definition: TGLUtil.h:597
void MultLeft(const TGLMatrix &lhs)
Multiply with matrix lhs on left.
Definition: TGLUtil.cxx:719
TGLVector3 Multiply(const TGLVector3 &v, Double_t w=1) const
Multiply vector.
Definition: TGLUtil.cxx:1050
TGLMatrix & operator=(const TGLMatrix &rhs)
Definition: TGLUtil.h:672
void Scale(const TGLVector3 &scale)
Set matrix axis scales to 'scale'.
Definition: TGLUtil.cxx:835
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:737
void RotateLF(Int_t i1, Int_t i2, Double_t amount)
Rotate in local frame.
Definition: TGLUtil.cxx:898
Double_t Invert()
Invert the matrix, returns determinant.
Definition: TGLUtil.cxx:972
void MoveLF(Int_t ai, Double_t amount)
Translate in local frame.
Definition: TGLUtil.cxx:814
void SetIdentity()
Set matrix to identity.
Definition: TGLUtil.cxx:766
Bool_t ValidIndex(UInt_t index) const
Definition: TGLUtil.h:603
void Transpose3x3()
Transpose the top left 3x3 matrix component along major diagonal Supported as currently incompatibili...
Definition: TGLUtil.cxx:948
Double_t * Arr()
Definition: TGLUtil.h:664
void RotatePF(Int_t i1, Int_t i2, Double_t amount)
Rotate in parent frame. Does optimised version of MultLeft.
Definition: TGLUtil.cxx:915
TGLMatrix & operator*=(const TGLMatrix &rhs)
Definition: TGLUtil.h:622
void SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z)
Definition: TGLUtil.h:732
TGLVector3 GetBaseVec(Int_t b) const
Definition: TGLUtil.h:753
void Move3LF(Double_t x, Double_t y, Double_t z)
Translate in local frame along all base vectors simultaneously.
Definition: TGLUtil.cxx:823
const Double_t * CArr() const
Definition: TGLUtil.h:663
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:871
virtual ~TGLMatrix()
Destroy matrix object.
Definition: TGLUtil.cxx:696
TGLVector3 GetTranslation() const
Return the translation component of matrix.
Definition: TGLUtil.cxx:795
Double_t & operator[](Int_t index)
Definition: TGLUtil.h:682
Double_t fVals[16]
Definition: TGLUtil.h:600
void RotateIP(TGLVector3 &v) const
Rotate vector in-place. Translation is not applied.
Definition: TGLUtil.cxx:1088
Bool_t IsScalingForRender() const
Return true if matrix is to be considered a scaling matrix for rendering.
Definition: TGLUtil.cxx:1112
void TransformVertex(TGLVertex3 &vertex) const
Transform passed 'vertex' by this matrix - converts local frame to parent.
Definition: TGLUtil.cxx:934
TGLVector3 GetScale() const
Get local axis scaling factors.
Definition: TGLUtil.cxx:1100
void MultRight(const TGLMatrix &rhs)
Multiply with matrix rhs on right.
Definition: TGLUtil.cxx:703
void SetTranslation(Double_t x, Double_t y, Double_t z)
Set matrix translation components x,y,z.
Definition: TGLUtil.cxx:777
void MultiplyIP(TGLVector3 &v, Double_t w=1) const
Multiply vector in-place.
Definition: TGLUtil.cxx:1076
void Translate(const TGLVector3 &vect)
Shift matrix translation components by 'vect' in parent frame.
Definition: TGLUtil.cxx:803
void Dump() const
Output 16 matrix components to std::cout.
Definition: TGLUtil.cxx:1133
TGLMatrix()
Construct default identity matrix:
Definition: TGLUtil.cxx:607
3D plane class - of format Ax + By + Cz + D = 0
Definition: TGLUtil.h:524
ClassDefNV(TGLPlane, 0)
void Set(const TGLPlane &other)
Assign from other.
Definition: TGLUtil.cxx:426
Double_t B() const
Definition: TGLUtil.h:553
Double_t D() const
Definition: TGLUtil.h:555
void Negate()
Negate the plane.
Definition: TGLUtil.cxx:482
TGLVertex3 NearestOn(const TGLVertex3 &point) const
Return nearest point on plane.
Definition: TGLUtil.cxx:501
Double_t C() const
Definition: TGLUtil.h:554
TGLPlane & operator=(const TGLPlane &src)
Assignment operator.
Definition: TGLUtil.cxx:390
~TGLPlane()=default
Double_t A() const
Definition: TGLUtil.h:552
void Normalise()
Normalise the plane.
Definition: TGLUtil.cxx:399
const Double_t * CArr() const
Definition: TGLUtil.h:562
Double_t * Arr()
Definition: TGLUtil.h:563
TGLPlane()
Construct a default plane of x + y + z = 0.
Definition: TGLUtil.cxx:337
Double_t DistanceTo(const TGLVertex3 &vertex) const
Distance from plane to vertex.
Definition: TGLUtil.cxx:493
TGLVector3 Norm() const
Definition: TGLUtil.h:557
void Dump() const
Output plane equation to std::out.
Definition: TGLUtil.cxx:417
Double_t fVals[4]
Definition: TGLUtil.h:527
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:421
Int_t Right() const
Definition: TGLUtil.h:456
Int_t & X()
Definition: TGLUtil.h:446
Int_t Y() const
Definition: TGLUtil.h:447
Int_t fY
Definition: TGLUtil.h:424
Int_t fWidth
Corner.
Definition: TGLUtil.h:425
Int_t CenterY() const
Definition: TGLUtil.h:454
Int_t Left() const
Definition: TGLUtil.h:455
Int_t & Y()
Definition: TGLUtil.h:448
TGLRect()
Positive width/height.
Definition: TGLUtil.cxx:230
const Int_t * CArr() const
Definition: TGLUtil.h:442
Int_t Diagonal() const
Return the diagonal of the rectangle.
Definition: TGLUtil.cxx:287
Int_t Height() const
Definition: TGLUtil.h:451
Int_t Width() const
Definition: TGLUtil.h:449
Rgl::EOverlap Overlap(const TGLRect &other) const
Return overlap result (kInside, kOutside, kPartial) of this rect with 'other'.
Definition: TGLUtil.cxx:298
void Offset(Int_t dX, Int_t dY)
Definition: TGLUtil.h:486
void Set(Int_t x, Int_t y, Int_t width, Int_t height)
Definition: TGLUtil.h:470
Int_t CenterX() const
Definition: TGLUtil.h:453
Int_t Longest() const
Definition: TGLUtil.h:493
Int_t X() const
Definition: TGLUtil.h:445
Int_t Bottom() const
Definition: TGLUtil.h:458
virtual ~TGLRect()
Destroy rect object.
Definition: TGLUtil.cxx:255
Int_t Top() const
Definition: TGLUtil.h:457
Int_t & Height()
Definition: TGLUtil.h:452
Int_t fHeight
Definition: TGLUtil.h:425
Int_t * CArr()
Definition: TGLUtil.h:443
Int_t & Width()
Definition: TGLUtil.h:450
void Expand(Int_t x, Int_t y)
Expand the rect to encompass point (x,y)
Definition: TGLUtil.cxx:262
Int_t fX
Definition: TGLUtil.h:424
void SetCorner(Int_t x, Int_t y)
Definition: TGLUtil.h:479
Double_t Aspect() const
Definition: TGLUtil.h:499
TGLSelectionBuffer & operator=(const TGLSelectionBuffer &)
const UChar_t * GetPixelColor(Int_t px, Int_t py) const
Get pixel color.
Definition: TGLUtil.cxx:2827
void ReadColorBuffer(Int_t width, Int_t height)
Read color buffer.
Definition: TGLUtil.cxx:2803
TGLSelectionBuffer(const TGLSelectionBuffer &)
virtual ~TGLSelectionBuffer()
TGLSelectionBuffer destructor.
Definition: TGLUtil.cxx:2796
TGLSelectionBuffer()
TGLSelectionBuffer constructor.
Definition: TGLUtil.cxx:2788
std::vector< UChar_t > fBuffer
Definition: TGLUtil.h:1133
virtual ~TColorLocker()
Definition: TGLUtil.h:884
TDrawQualityScaler(Float_t fac)
Definition: TGLUtil.h:906
virtual ~TDrawQualityScaler()
Definition: TGLUtil.h:909
Wrapper class for various misc static functions - error checking, draw helpers etc.
Definition: TGLUtil.h:878
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:2352
static void Color4ubv(const UChar_t *rgba)
Wrapper for glColor4ubv.
Definition: TGLUtil.cxx:1774
static UInt_t GetDrawQuality()
static: get draw quality
Definition: TGLUtil.cxx:1600
static Int_t fgPickingRadius
Definition: TGLUtil.h:928
static const UChar_t fgWhite[4]
Definition: TGLUtil.h:1052
static UInt_t fgDefaultDrawQuality
Definition: TGLUtil.h:916
static void SetDrawQuality(UInt_t dq)
static: set draw quality
Definition: TGLUtil.cxx:1608
static Float_t GetPointSizeScale()
Get global point-size scale.
Definition: TGLUtil.cxx:1878
static void Color3f(Float_t r, Float_t g, Float_t b)
Wrapper for glColor3f.
Definition: TGLUtil.cxx:1782
static Float_t fgPointSize
Definition: TGLUtil.h:921
static Float_t fgLineWidth
Definition: TGLUtil.h:922
static Float_t fgScreenScalingFactor
Definition: TGLUtil.h:926
static void ResetDrawQuality()
static: reset draw quality
Definition: TGLUtil.cxx:1616
static Float_t fgPointSizeScale
Definition: TGLUtil.h:923
static Bool_t IsColorLocked()
Returns true if color lock-count is greater than 0.
Definition: TGLUtil.cxx:1684
static void Color3fv(const Float_t *rgb)
Wrapper for glColor3fv.
Definition: TGLUtil.cxx:1798
static void SetLineWidthScale(Float_t scale)
Set global line-width scale.
Definition: TGLUtil.cxx:1902
static UInt_t LockColor()
Prevent further color changes.
Definition: TGLUtil.cxx:1664
static void Color4f(Float_t r, Float_t g, Float_t b, Float_t a)
Wrapper for glColor4f.
Definition: TGLUtil.cxx:1790
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:2331
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
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
static const UChar_t fgRed[4]
Definition: TGLUtil.h:1048
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
static UInt_t GetDefaultDrawQuality()
static: get default draw quality
Definition: TGLUtil.cxx:1624
static void BeginExtendPickRegion(Float_t scale)
Definition: TGLUtil.cxx:1947
static void InitializeIfNeeded()
Initialize globals that require other libraries to be initialized.
Definition: TGLUtil.cxx:1577
ELineHeadShape
Definition: TGLUtil.h:947
@ kLineHeadNone
Definition: TGLUtil.h:947
@ kLineHeadBox
Definition: TGLUtil.h:947
@ kLineHeadArrow
Definition: TGLUtil.h:947
static Float_t GetLineWidthScale()
Returns global line-width scale.
Definition: TGLUtil.cxx:1894
static Float_t fgPointLineScalingFactor
Definition: TGLUtil.h:927
static UInt_t UnlockColor()
Allow color changes.
Definition: TGLUtil.cxx:1672
static void EndAttLine(Int_t pick_radius=0, Bool_t selection=kFALSE)
Restore previous line drawing state.
Definition: TGLUtil.cxx:2303
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:2367
static void Color(const TGLColor &color)
Set color from TGLColor.
Definition: TGLUtil.cxx:1692
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:2433
virtual ~TGLUtil()
Definition: TGLUtil.h:934
static void Color3ubv(const UChar_t *rgb)
Wrapper for glColor3ubv.
Definition: TGLUtil.cxx:1766
static Int_t CheckError(const char *loc)
Check current GL error state, outputting details via ROOT Error method if one.
Definition: TGLUtil.cxx:1641
static Float_t GetScreenScalingFactor()
Returns scaling factor between screen points and GL viewport pixels.
Definition: TGLUtil.cxx:1847
static void ColorAlpha(const TGLColor &color, UChar_t alpha)
Set color from TGLColor and alpha value.
Definition: TGLUtil.cxx:1700
static Int_t GetPickingRadius()
Returns picking radius.
Definition: TGLUtil.cxx:1866
static void SetPointSizeScale(Float_t scale)
Set global point-size scale.
Definition: TGLUtil.cxx:1886
static void Color4fv(const Float_t *rgba)
Wrapper for glColor4fv.
Definition: TGLUtil.cxx:1806
static void Color3ub(UChar_t r, UChar_t g, UChar_t b)
Wrapper for glColor3ub.
Definition: TGLUtil.cxx:1750
static UInt_t fgDrawQuality
Definition: TGLUtil.h:917
static GLUtesselator * GetDrawTesselator4dv()
Returns a tesselator for direct drawing when using 4-vertices with double precision.
Definition: TGLUtil.cxx:1556
static const UChar_t fgBlue[4]
Definition: TGLUtil.h:1050
static const UChar_t fgGrey[4]
Definition: TGLUtil.h:1053
EAxesType
Definition: TGLUtil.h:948
@ kAxesNone
Definition: TGLUtil.h:948
@ kAxesEdge
Definition: TGLUtil.h:948
@ kAxesOrigin
Definition: TGLUtil.h:948
static Float_t PointSize()
Get the point-size, taking the global scaling into account.
Definition: TGLUtil.cxx:1930
static void EndExtendPickRegion()
Definition: TGLUtil.cxx:1962
static GLUtesselator * GetDrawTesselator3dv()
Returns a tesselator for direct drawing when using 3-vertices with double precision.
Definition: TGLUtil.cxx:1535
static GLUtesselator * GetDrawTesselator4fv()
Returns a tesselator for direct drawing when using 4-vertices with single precision.
Definition: TGLUtil.cxx:1514
static const UChar_t fgGreen[4]
Definition: TGLUtil.h:1049
static UInt_t fgColorLockCount
Definition: TGLUtil.h:919
static GLUtesselator * GetDrawTesselator3fv()
Returns a tesselator for direct drawing when using 3-vertices with single precision.
Definition: TGLUtil.cxx:1493
TGLUtil(const TGLUtil &)
static void SetDefaultDrawQuality(UInt_t dq)
static: set default draw quality
Definition: TGLUtil.cxx:1632
static void PointToViewport(Int_t &x, Int_t &y)
Convert from point/screen coordinates to GL viewport coordinates.
Definition: TGLUtil.cxx:1818
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:2474
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:2629
static Float_t LineWidth()
Get the line-width, taking the global scaling into account.
Definition: TGLUtil.cxx:1938
static Float_t fgLineWidthScale
Definition: TGLUtil.h:924
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:1975
static void DrawSimpleAxes(const TGLCamera &camera, const TGLBoundingBox &bbox, Int_t axesType)
Draw simple xyz-axes for given bounding-box.
Definition: TGLUtil.cxx:2489
static const UChar_t fgYellow[4]
Definition: TGLUtil.h:1051
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 GetPointLineScalingFactor()
Return extra scaling factor for points and lines.
Definition: TGLUtil.cxx:1858
static void Color4ub(UChar_t r, UChar_t g, UChar_t b, UChar_t a)
Wrapper for glColor4ub.
Definition: TGLUtil.cxx:1758
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
3 component (x/y/z) vector class.
Definition: TGLUtil.h:247
Double_t Mag() const
Definition: TGLUtil.h:297
TGLVector3 & operator/=(Double_t val)
Definition: TGLUtil.h:282
ClassDefNV(TGLVector3, 1)
TGLVector3()=default
void Normalise()
Definition: TGLUtil.h:303
TGLVector3 & operator=(const TGLVertex3 &v)
Definition: TGLUtil.h:253
TGLVector3 operator-() const
Definition: TGLUtil.h:291
3 component (x/y/z) vertex class.
Definition: TGLUtil.h:83
void Dump() const
Output vertex component values to std::cout.
Definition: TGLUtil.cxx:131
void Minimum(const TGLVertex3 &other)
Definition: TGLUtil.cxx:112
Double_t X() const
Definition: TGLUtil.h:118
Double_t & Z()
Definition: TGLUtil.h:123
TGLVertex3 operator-() const
Definition: TGLUtil.h:166
Double_t Z() const
Definition: TGLUtil.h:122
ClassDefNV(TGLVertex3, 1)
Double_t fVals[3]
Definition: TGLUtil.h:87
Bool_t operator==(const TGLVertex3 &rhs) const
Definition: TGLUtil.h:148
Double_t * Arr()
Definition: TGLUtil.h:126
Double_t & operator[](Int_t index)
Definition: TGLUtil.h:181
Double_t & X()
Definition: TGLUtil.h:119
void Maximum(const TGLVertex3 &other)
Definition: TGLUtil.cxx:121
void Fill(Double_t val)
Definition: TGLUtil.h:203
void Set(Double_t x, Double_t y, Double_t z)
Definition: TGLUtil.h:209
TGLVertex3 & operator*=(Double_t f)
Definition: TGLUtil.h:172
const TGLVertex3 & operator+=(const TGLVector3 &val)
Definition: TGLUtil.h:275
void Negate()
Definition: TGLUtil.h:140
Double_t Y() const
Definition: TGLUtil.h:120
TGLVertex3 & operator=(const TGLVertex3 &rhs)
Definition: TGLUtil.h:154
TGLVertex3()
Construct a default (0.0, 0.0, 0.0) vertex.
Definition: TGLUtil.cxx:54
void Shift(TGLVector3 &shift)
Offset a vertex by vector 'shift'.
Definition: TGLUtil.cxx:93
const Double_t * CArr() const
Definition: TGLUtil.h:125
const TGLVertex3 & operator-=(const TGLVector3 &val)
Definition: TGLUtil.h:267
Bool_t ValidIndex(UInt_t index) const
Definition: TGLUtil.h:86
~TGLVertex3()
Destroy vertex object.
Definition: TGLUtil.cxx:86
Double_t & Y()
Definition: TGLUtil.h:121
Basic string class.
Definition: TString.h:131
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:3349
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 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
void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3, const TGLVector3 &normal)
Draw quad face.
Definition: TGLUtil.cxx:2954
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
const Float_t gNullEmission[]
Definition: TGLUtil.cxx:2848
void ObjectIDToColor(Int_t objectID, Bool_t highColor)
Object id encoded as rgb triplet.
Definition: TGLUtil.cxx:2892
const Float_t gBlueEmission[]
Definition: TGLUtil.cxx:2844
const Float_t gWhiteEmission[]
Definition: TGLUtil.cxx:2846
void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax, Double_t zScale, std::vector< Double_t > &zLevels)
Definition: TGLUtil.cxx:3821
std::pair< Int_t, Int_t > BinRange_t
Definition: TGLUtil.h:1193
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
const Float_t gGrayEmission[]
Definition: TGLUtil.cxx:2847
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:3878
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
void DrawError(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax)
Definition: TGLUtil.cxx:3299
const Float_t gRedEmission[]
Definition: TGLUtil.cxx:2842
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:3058
std::pair< Double_t, Double_t > Range_t
Definition: TGLUtil.h:1194
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:3008
const Float_t gGreenEmission[]
Definition: TGLUtil.cxx:2843
void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3, const TGLVertex3 &v4)
Draw quad outline.
Definition: TGLUtil.cxx:2940
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
EOverlap
Definition: TGLUtil.h:34
@ kInside
Definition: TGLUtil.h:35
@ kOutside
Definition: TGLUtil.h:37
@ kPartial
Definition: TGLUtil.h:36
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
TOneArgGuard< Func, Arg > make_guard(Func f, Arg a)
Definition: TGLUtil.h:1325
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:3135
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
const Float_t gOrangeEmission[]
Definition: TGLUtil.cxx:2845
Int_t ColorToObjectID(const UChar_t *color, Bool_t highColor)
Definition: TGLUtil.cxx:2918
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
static constexpr double s
static const char * what
Definition: stlLoader.cc:6
auto * a
Definition: textangle.C:12
auto * t1
Definition: textangle.C:20
REAL * vertex
Definition: triangle.c:512