Logo ROOT  
Reference Guide
TGLClip.cxx
Go to the documentation of this file.
1 // @(#)root/gl:$Id$
2 // Author: Richard Maunder 16/09/2005
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2005, 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 #include "TGLClip.h"
13 #include "TGLIncludes.h"
14 #include "TGLRnrCtx.h"
15 #include "TGLManipSet.h"
16 
17 #include "TGLFaceSet.h"
18 #include "TBuffer3D.h"
19 #include "TBuffer3DTypes.h"
20 
21 namespace
22 {
23 
24 class TGLClipPlaneLogical : public TGLLogicalShape
25 {
26 protected:
27  virtual void DirectDraw(TGLRnrCtx & rnrCtx) const
28  {
29  glBegin(rnrCtx.IsDrawPassFilled() ? GL_QUADS : GL_LINE_LOOP);
30  glNormal3d (0.0, 0.0, 1.0);
31  glVertex3dv(fBoundingBox[4].CArr());
32  glVertex3dv(fBoundingBox[7].CArr());
33  glVertex3dv(fBoundingBox[6].CArr());
34  glVertex3dv(fBoundingBox[5].CArr());
35  glEnd();
36  }
37 
38 public:
39  TGLClipPlaneLogical() : TGLLogicalShape() { fDLCache = kFALSE; }
40  virtual ~TGLClipPlaneLogical() {}
41 
42  void Resize(Double_t ext)
43  {
44  fBoundingBox.SetAligned(TGLVertex3(-ext, -ext, 0),
45  TGLVertex3( ext, ext, 0));
47  }
48 
49 };
50 
51 
52 class TGLClipBoxLogical : public TGLLogicalShape
53 {
54 protected:
55  virtual void DirectDraw(TGLRnrCtx & rnrCtx) const
56  {
57  glEnable(GL_NORMALIZE);
58  fBoundingBox.Draw(rnrCtx.IsDrawPassFilled());
59  glDisable(GL_NORMALIZE);
60  }
61 
62 public:
63  TGLClipBoxLogical() : TGLLogicalShape() { fDLCache = kFALSE; }
64  virtual ~TGLClipBoxLogical() {}
65 
66  void Resize(const TGLVertex3 & lowVertex, const TGLVertex3 & highVertex)
67  {
68  fBoundingBox.SetAligned(lowVertex, highVertex);
70  }
71 };
72 
73 }
74 
75 
76 /** \class TGLClip
77 \ingroup opengl
78 Abstract clipping shape - derives from TGLPhysicalShape
79 Adds clip mode (inside/outside) and pure virtual method to
80 approximate shape as set of planes. This plane set is used to perform
81 interactive clipping using OpenGL clip planes.
82 */
83 
85 
86 ////////////////////////////////////////////////////////////////////////////////
87 /// Construct a stand-alone physical clipping object.
88 
89 TGLClip::TGLClip(const TGLLogicalShape & logical, const TGLMatrix & transform, const float color[4]) :
90  TGLPhysicalShape(0, logical, transform, kTRUE, color),
91  fMode (kInside),
92  fTimeStamp (1),
93  fValid (kFALSE)
94 {
95  logical.StrongRef(kTRUE);
96 }
97 
98 ////////////////////////////////////////////////////////////////////////////////
99 /// Destroy clip object.
100 
102 {
103 }
104 
105 ////////////////////////////////////////////////////////////////////////////////
106 /// Setup the clipping object with two vectors.
107 /// The interpretation of the two is different for plane and box
108 /// clipping objects.
109 
111 {
112  Warning("TGLClip::Setup", "Called on base-class -- should be re-implemented in derived class.");
113 
114 }
115 
116 ////////////////////////////////////////////////////////////////////////////////
117 /// Draw out clipping object with blending and back + front filling.
118 /// Some clip objects are single face which we want to see both sides of.
119 
120 void TGLClip::Draw(TGLRnrCtx & rnrCtx) const
121 {
122  glDepthMask(GL_FALSE);
123  glEnable(GL_BLEND);
124  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
125  glDisable(GL_CULL_FACE);
126  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
127 
128  TGLPhysicalShape::Draw(rnrCtx);
129 
130  glPolygonMode(GL_FRONT, GL_FILL);
131  glEnable(GL_CULL_FACE);
132  glDisable(GL_BLEND);
133  glDepthMask(GL_TRUE);
134 }
135 
136 /** \class TGLClipPlane
137 \ingroup opengl
138 Concrete clip plane object. This can be translated in all directions
139 rotated about the Y/Z local axes (the in-plane axes). It cannot be
140 scaled.
141 */
142 
144 
145 const float TGLClipPlane::fgColor[4] = { 1.0, 0.6, 0.2, 0.5 };
146 
147 ////////////////////////////////////////////////////////////////////////////////
148 /// Construct a clip plane object, based on supplied 'plane', with
149 /// initial manipulation pivot at 'center', with drawn extents (in
150 /// local x/y axes) of 'extents'
151 ///
152 /// Plane can have center pivot translated in all directions, and
153 /// rotated round center in X/Y axes , the in-plane axes. It cannot
154 /// be scaled
155 ///
156 /// Note theoretically a plane is of course infinite - however we
157 /// want to draw the object in viewer - so we fake it with a single
158 /// GL face (polygon) - extents defines the width/depth of this -
159 /// should be several times scene extents - see Setup().
160 
162  TGLClip(* new TGLClipPlaneLogical, TGLMatrix(), fgColor)
163 {
165 
166  TGLPlane plane(0.0, -1.0, 0.0, 0.0);
167  Set(plane);
168  fValid = kFALSE;
169 }
170 
171 ////////////////////////////////////////////////////////////////////////////////
172 /// Destroy clip plane object
173 
175 {
176 }
177 
178 ////////////////////////////////////////////////////////////////////////////////
179 /// Setup the clip object for scene encompassed by bbox.
180 
182 {
183  Double_t extents = bbox.Extents().Mag();
184  TGLClipPlaneLogical* cpl = (TGLClipPlaneLogical*) GetLogical();
185  cpl->Resize(extents);
186  if (!fValid) {
187  SetTransform(TGLMatrix(bbox.Center(), BoundingBox().GetNearPlane().Norm()));
188  }
189  IncTimeStamp();
190  fValid = kTRUE;
191 }
192 
193 ////////////////////////////////////////////////////////////////////////////////
194 /// Setup the clipping plane by point and normal.
195 /// Length of the normal determines the size of the plane drawn in
196 /// GL viewer. The normal points into the direction of visible half-plane.
197 ///
198 /// This only makes sense if you disable auto-update of the
199 /// clip-object:
200 ///
201 /// gl_viewer->SetClipAutoUpdate(kFALSE).
202 ///
203 /// After calling this also call gl_viewer->RefreshPadEditor(gl_viewer)
204 /// and gl_viewer->RequestDraw().
205 
206 void TGLClipPlane::Setup(const TGLVector3& point, const TGLVector3& normal)
207 {
208  TGLVector3 n(normal);
209  Double_t extents = n.Mag();
210  if (extents > 0)
211  {
212  n /= extents;
213  TGLClipPlaneLogical* cpl = (TGLClipPlaneLogical*) GetLogical();
214  cpl->Resize(extents);
215  SetTransform(TGLMatrix(point, n));
216 
217  IncTimeStamp();
218  fValid = kTRUE;
219  }
220  else
221  {
222  Warning("TGLClipPlane::Setup", "Normal with zero length passed.");
223  }
224 }
225 
226 ////////////////////////////////////////////////////////////////////////////////
227 /// Update clip plane object to follow passed 'plane' equation. Center pivot
228 /// is shifted to nearest point on new plane.
229 
230 void TGLClipPlane::Set(const TGLPlane& plane)
231 {
232  TGLVertex3 oldCenter = BoundingBox().Center();
233  TGLVertex3 newCenter = plane.NearestOn(oldCenter);
234  SetTransform(TGLMatrix(newCenter, plane.Norm()));
235  IncTimeStamp();
236  fValid = kTRUE;
237 }
238 
239 ////////////////////////////////////////////////////////////////////////////////
240 /// Return set of planes (actually a single one) describing this clip plane.
241 
243 {
244  set.resize(1);
245  set[0] = BoundingBox().GetNearPlane();
246  set[0].Negate();
247 }
248 
249 /** \class TGLClipBox
250 \ingroup opengl
251 Concrete clip box object. Can be translated, rotated and scaled in
252 all (xyz) axes. By default inside of the box is clipped away.
253 */
254 
256 
257 const float TGLClipBox::fgColor[4] = { 1.0, 0.6, 0.2, 0.3 };
258 
259 ////////////////////////////////////////////////////////////////////////////////
260 /// Construct an (initially) axis aligned clip pbox object, extents
261 /// 'halfLengths', centered on 'center' vertex.
262 /// Box can be translated, rotated and scaled in all (xyz) local axes.
263 
265  TGLClip(* new TGLClipBoxLogical, TGLMatrix(), fgColor)
266 {
267 }
268 
269 ////////////////////////////////////////////////////////////////////////////////
270 /// Destroy clip box object.
271 
273 {
274 }
275 
276 ////////////////////////////////////////////////////////////////////////////////
277 /// Setup the clip object for scene encompassed by bbox.
278 
280 {
281  TGLVector3 halfLengths = bbox.Extents() * 0.2501;
282  TGLVertex3 center = bbox.Center() + halfLengths;
283 
284  TGLClipBoxLogical* cbl = (TGLClipBoxLogical*) GetLogical();
285  cbl->Resize(center - halfLengths, center + halfLengths);
286 
287  IncTimeStamp();
288  fValid = kTRUE;
289 }
290 
291 ////////////////////////////////////////////////////////////////////////////////
292 /// Setup the clip box with min/max points directly.
293 ///
294 /// This only makes sense if you disable auto-update of the
295 /// clip-object:
296 ///
297 /// gl_viewer->SetClipAutoUpdate(kFALSE).
298 ///
299 /// After calling this also call gl_viewer->RefreshPadEditor(gl_viewer)
300 /// and gl_viewer->RequestDraw().
301 
302 void TGLClipBox::Setup(const TGLVector3& min_point, const TGLVector3& max_point)
303 {
304  TGLClipBoxLogical* cbl = (TGLClipBoxLogical*) GetLogical();
305  cbl->Resize(min_point, max_point);
306 
307  IncTimeStamp();
308  fValid = kTRUE;
309 }
310 
311 ////////////////////////////////////////////////////////////////////////////////
312 /// Return set of 6 planes describing faces of the box but invert them
313 /// so that they point inside of box.
314 
316 {
317  BoundingBox().PlaneSet(set);
318  TGLPlaneSet_i i = set.begin();
319  while (i != set.end()) {
320  i->Negate();
321  ++i;
322  }
323 }
324 
325 
326 /** \class TGLClipSet
327 \ingroup opengl
328 A collection of concrete TGLClip objects to be selected from.
329 */
330 
332 
333 ////////////////////////////////////////////////////////////////////////////////
334 /// Constructor.
335 
337  TGLOverlayElement(kViewer),
338  fClipPlane (new TGLClipPlane),
339  fClipBox (new TGLClipBox),
340  fCurrentClip (0),
341  fAutoUpdate (kTRUE),
342  fShowClip (kFALSE),
343  fShowManip (kFALSE),
344  fManip (new TGLManipSet)
345 {
346 }
347 
348 ////////////////////////////////////////////////////////////////////////////////
349 /// Destructor.
350 
352 {
353  delete fClipPlane;
354  delete fClipBox;
355  delete fManip;
356 }
357 
358 ////////////////////////////////////////////////////////////////////////////////
359 /// Mouse has entered this element.
360 /// Forward to ManipSet.
361 
363 {
364  return fManip->MouseEnter(selRec);
365 }
366 
368 {
369  // A new overlay hit is about to be processed.
370  // Forward to ManipSet.
371 
372  return fManip->MouseStillInside(selRec);
373 }
374 
375 ////////////////////////////////////////////////////////////////////////////////
376 /// Handle overlay event.
377 /// Forward to ManipSet.
378 
380  Event_t* event)
381 {
382  return fManip->Handle(rnrCtx, selRec, event);
383 }
384 
385 ////////////////////////////////////////////////////////////////////////////////
386 /// Mouse has left the element.
387 /// Forward to ManipSet.
388 
390 {
391  return fManip->MouseLeave();
392 }
393 
394 ////////////////////////////////////////////////////////////////////////////////
395 /// Render clip-shape and manipulator.
396 
398 {
399  if (!fCurrentClip) return;
400 
403  if (fShowClip && ! rnrCtx.Selection())
404  {
405  fCurrentClip->Draw(rnrCtx);
406  }
407  if (fShowManip)
408  {
409  fManip->Render(rnrCtx);
410  }
411 }
412 
413 ////////////////////////////////////////////////////////////////////////////////
414 /// Forward request to fill the plane-set to the current clip.
415 
417 {
418  if (fCurrentClip)
419  fCurrentClip->PlaneSet(set);
420 }
421 
422 ////////////////////////////////////////////////////////////////////////////////
423 /// Setup clipping objects for given scene bounding box.
424 
426 {
427  fLastBBox = sceneBBox;
428  fClipPlane->Setup(sceneBBox);
429  fClipBox ->Setup(sceneBBox);
430 }
431 
432 ////////////////////////////////////////////////////////////////////////////////
433 /// Setup current clipping object for given scene bounding box.
434 
436 {
437  fLastBBox = sceneBBox;
438  if (fCurrentClip)
439  fCurrentClip->Setup(sceneBBox);
440 }
441 
442 ////////////////////////////////////////////////////////////////////////////////
443 /// Setup current clipping object for given scene bounding box.
444 
446 {
447  fLastBBox = sceneBBox;
448  if (fCurrentClip && ! fCurrentClip->IsValid())
449  fCurrentClip->Setup(sceneBBox);
450 }
451 
452 ////////////////////////////////////////////////////////////////////////////////
453 /// Invalidate clip objects.
454 
456 {
458  fClipBox ->Invalidate();
459 }
460 
461 ////////////////////////////////////////////////////////////////////////////////
462 /// Invalidate current clip object.
463 
465 {
466  if (fCurrentClip)
468 }
469 
470 ////////////////////////////////////////////////////////////////////////////////
471 /// Get state of clip object 'type' into data vector:
472 ///
473 /// 'type' requested - 'data' contents returned
474 /// kClipPlane 4 components - A,B,C,D - of plane eq : Ax+By+CZ+D = 0
475 /// kBoxPlane 6 components - Box Center X/Y/Z - Box Extents X/Y/Z
476 
478 {
479  switch (type)
480  {
481  case TGLClip::kClipNone:
482  break;
483 
484  case TGLClip::kClipPlane:
485  {
486  if (!fClipPlane->IsValid())
488  TGLPlaneSet_t planes;
489  fClipPlane->PlaneSet(planes);
490  data[0] = planes[0].A();
491  data[1] = planes[0].B();
492  data[2] = planes[0].C();
493  data[3] = planes[0].D();
494  break;
495  }
496  case TGLClip::kClipBox:
497  {
498  if (!fClipBox->IsValid())
500  const TGLBoundingBox & box = fClipBox->BoundingBox();
501  TGLVector3 ext = box.Extents();
502  data[0] = box.Center().X();
503  data[1] = box.Center().Y();
504  data[2] = box.Center().Z();
505  data[3] = box.Extents().X();
506  data[4] = box.Extents().Y();
507  data[5] = box.Extents().Z();
508  break;
509  }
510  default:
511  Error("TGLClipSet::GetClipState", "invalid clip type '%d'.", type);
512  break;
513  }
514 }
515 
516 ////////////////////////////////////////////////////////////////////////////////
517 /// Set state of clip object 'type' into data vector:
518 ///
519 /// 'type' specified 'data' contents interpretation
520 /// kClipNone ignored
521 /// kClipPlane 4 components - A,B,C,D - of plane eq : Ax+By+CZ+D = 0
522 /// kBoxPlane 6 components - Box Center X/Y/Z - Box Extents X/Y/Z
523 
525 {
526  switch (type) {
527  case TGLClip::kClipNone: {
528  break;
529  }
530  case TGLClip::kClipPlane: {
531  TGLPlane newPlane(-data[0], -data[1], -data[2], -data[3]);
532  fClipPlane->Set(newPlane);
533  break;
534  }
535  case TGLClip::kClipBox: {
536  //TODO: Pull these inside TGLPhysicalShape
537  // Update clip box center
538  const TGLBoundingBox & currentBox = fClipBox->BoundingBox();
539  TGLVector3 shift(data[0] - currentBox.Center().X(),
540  data[1] - currentBox.Center().Y(),
541  data[2] - currentBox.Center().Z());
542  fClipBox->Translate(shift);
543  // Update clip box extents
544 
545  TGLVector3 currentScale = fClipBox->GetScale();
546  TGLVector3 newScale(data[3] / currentBox.Extents().X() * currentScale.X(),
547  data[4] / currentBox.Extents().Y() * currentScale.Y(),
548  data[5] / currentBox.Extents().Z() * currentScale.Z());
549 
550  fClipBox->Scale(newScale);
551  break;
552  }
553  }
554 }
555 
556 ////////////////////////////////////////////////////////////////////////////////
557 /// Get current type active in viewer - returns one of kClipNone
558 /// kClipPlane or kClipBox.
559 
561 {
563  if (fCurrentClip == 0) {
565  } else if (fCurrentClip == fClipPlane) {
567  } else if (fCurrentClip == fClipBox) {
569  } else {
570  Error("TGLClipSet::GetClipType" , "Unknown clip type");
572  }
573  return type;
574 }
575 
576 ////////////////////////////////////////////////////////////////////////////////
577 /// Set current clip active in viewer - 'type' is one of kClipNone
578 /// kClipPlane or kClipBox.
579 
581 {
582  switch (type) {
583  case TGLClip::kClipNone: {
584  fCurrentClip = 0;
585  break;
586  }
587  case TGLClip::kClipPlane: {
589  break;
590  }
591  case TGLClip::kClipBox: {
593  break;
594  }
595  default: {
596  Error("TGLClipSet::SetClipType" , "Unknown clip type");
597  break;
598  }
599  }
601 }
TGLVertex3::Y
Double_t Y() const
Definition: TGLUtil.h:121
TGLClipPlane::PlaneSet
virtual void PlaneSet(TGLPlaneSet_t &set) const
Return set of planes (actually a single one) describing this clip plane.
Definition: TGLClip.cxx:242
n
const Int_t n
Definition: legend1.C:16
TGLManipSet::SetPShape
virtual void SetPShape(TGLPhysicalShape *shape)
Set phys-shape, override of virtual from TGLPShapeRef.
Definition: TGLManipSet.cxx:63
TGLClipSet::SetupCurrentClip
void SetupCurrentClip(const TGLBoundingBox &sceneBBox)
Setup current clipping object for given scene bounding box.
Definition: TGLClip.cxx:435
TGLClipSet::MouseEnter
virtual Bool_t MouseEnter(TGLOvlSelectRecord &selRec)
Mouse has entered this element.
Definition: TGLClip.cxx:362
TGLClipSet::GetClipState
void GetClipState(TGLClip::EType type, Double_t data[6]) const
Get state of clip object 'type' into data vector:
Definition: TGLClip.cxx:477
TGLClipSet::InvalidateCurrentClip
void InvalidateCurrentClip()
Invalidate current clip object.
Definition: TGLClip.cxx:464
TGLClipSet::TGLClipSet
TGLClipSet()
Constructor.
Definition: TGLClip.cxx:336
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TGLClipSet::fCurrentClip
TGLClip * fCurrentClip
Definition: TGLClip.h:148
TGLClip::~TGLClip
virtual ~TGLClip()
Destroy clip object.
Definition: TGLClip.cxx:101
TGLOverlayElement
An overlay element.
Definition: TGLOverlay.h:23
Warning
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition: TError.cxx:231
TGLPlane::Negate
void Negate()
Negate the plane.
Definition: TGLUtil.cxx:481
TGLClipBox::~TGLClipBox
virtual ~TGLClipBox()
Destroy clip box object.
Definition: TGLClip.cxx:272
TGLClipSet::fManip
TGLManipSet * fManip
Definition: TGLClip.h:153
TGLClipSet::Handle
virtual Bool_t Handle(TGLRnrCtx &rnrCtx, TGLOvlSelectRecord &selRec, Event_t *event)
Handle overlay event.
Definition: TGLClip.cxx:379
TGLClipPlane::TGLClipPlane
TGLClipPlane()
Fixed color of clip plane.
Definition: TGLClip.cxx:161
TGLClipSet
A collection of concrete TGLClip objects to be selected from.
Definition: TGLClip.h:140
TGLRnrCtx::kLODHigh
@ kLODHigh
Definition: TGLRnrCtx.h:67
TGLClipPlane::Setup
virtual void Setup(const TGLBoundingBox &bbox)
Setup the clip object for scene encompassed by bbox.
Definition: TGLClip.cxx:181
TGLClip::fValid
Bool_t fValid
Definition: TGLClip.h:49
TGLClipSet::GetClipType
TGLClip::EType GetClipType() const
Get current type active in viewer - returns one of kClipNone kClipPlane or kClipBox.
Definition: TGLClip.cxx:560
TGLManipSet::MouseLeave
virtual void MouseLeave()
Mouse has left the element.
Definition: TGLManipSet.cxx:141
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TGLOvlSelectRecord
Selection record for overlay objects.
Definition: TGLSelectRecord.h:140
TGLManipSet
Combine all available manipulators in a collection.
Definition: TGLManipSet.h:22
TGLBoundingBox::Extents
TGLVector3 Extents() const
Definition: TGLBoundingBox.h:165
TGLClip::kClipBox
@ kClipBox
Definition: TGLClip.h:43
TGLClipSet::~TGLClipSet
virtual ~TGLClipSet()
Destructor.
Definition: TGLClip.cxx:351
TGLClipSet::MouseLeave
virtual void MouseLeave()
Mouse has left the element.
Definition: TGLClip.cxx:389
TGLClipPlane::~TGLClipPlane
virtual ~TGLClipPlane()
Destroy clip plane object.
Definition: TGLClip.cxx:174
TGLLogicalShape::UpdateBoundingBoxesOfPhysicals
void UpdateBoundingBoxesOfPhysicals()
Update bounding-boxed of all dependent physicals.
Definition: TGLLogicalShape.cxx:246
TGLClipBox::TGLClipBox
TGLClipBox()
Fixed color of clip box.
Definition: TGLClip.cxx:264
TGLVertex3::X
Double_t X() const
Definition: TGLUtil.h:119
TGLClipSet::SetClipState
void SetClipState(TGLClip::EType type, const Double_t data[6])
Set state of clip object 'type' into data vector:
Definition: TGLClip.cxx:524
box
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition: fillpatterns.C:1
TGLClipSet::Render
virtual void Render(TGLRnrCtx &rnrCtx)
Render clip-shape and manipulator.
Definition: TGLClip.cxx:397
TGLClipSet::fClipBox
TGLClipBox * fClipBox
Definition: TGLClip.h:147
TGLBoundingBox::Center
TGLVertex3 Center() const
Definition: TGLBoundingBox.h:174
TGLClipSet::SetupCurrentClipIfInvalid
void SetupCurrentClipIfInvalid(const TGLBoundingBox &sceneBBox)
Setup current clipping object for given scene bounding box.
Definition: TGLClip.cxx:445
TGLPlaneSet_i
std::vector< TGLPlane >::iterator TGLPlaneSet_i
Definition: TGLUtil.h:572
TGLBoundingBox::GetNearPlane
TGLPlane GetNearPlane() const
Return the near-plane.
Definition: TGLBoundingBox.cxx:440
TGLMatrix
16 component (4x4) transform matrix - column MAJOR as per GL.
Definition: TGLUtil.h:598
TGLClip::IncTimeStamp
void IncTimeStamp()
Definition: TGLClip.h:64
TGLClipBox::fgColor
static const float fgColor[4]
Definition: TGLClip.h:116
TGLPhysicalShape::kTranslateAll
@ kTranslateAll
Definition: TGLPhysicalShape.h:44
TGLPhysicalShape::kRotateY
@ kRotateY
Definition: TGLPhysicalShape.h:50
TGLPhysicalShape::Scale
void Scale(const TGLVector3 &scale)
Definition: TGLPhysicalShape.h:185
TGLClipPlane::fgColor
static const float fgColor[4]
Definition: TGLClip.h:88
TGLBoundingBox
Concrete class describing an orientated (free) or axis aligned box of 8 vertices.
Definition: TGLBoundingBox.h:33
TGLClip::TGLClip
TGLClip(const TGLLogicalShape &logical, const TGLMatrix &transform, const float color[4])
Construct a stand-alone physical clipping object.
Definition: TGLClip.cxx:89
bool
TGLRnrCtx::IsDrawPassFilled
Bool_t IsDrawPassFilled() const
Returns true if current render-pass uses filled polygon style.
Definition: TGLRnrCtx.cxx:151
TGLBoundingBox::PlaneSet
void PlaneSet(TGLPlaneSet_t &planeSet) const
Fill out supplied plane set vector with TGLPlane objects representing six faces of box.
Definition: TGLBoundingBox.cxx:413
TGLPhysicalShape::Draw
virtual void Draw(TGLRnrCtx &rnrCtx) const
Draw physical shape, using LOD flags, potential from display list cache.
Definition: TGLPhysicalShape.cxx:338
TGLRnrCtx.h
TGLClip::Draw
virtual void Draw(TGLRnrCtx &rnrCtx) const
Draw out clipping object with blending and back + front filling.
Definition: TGLClip.cxx:120
TGLOverlayElement::MouseStillInside
virtual Bool_t MouseStillInside(TGLOvlSelectRecord &selRec)
Definition: TGLOverlay.cxx:30
TGLPlane
3D plane class - of format Ax + By + Cz + D = 0
Definition: TGLUtil.h:525
TGLClip::Invalidate
void Invalidate()
Definition: TGLClip.h:67
GL_FALSE
#define GL_FALSE
Definition: GL_glu.h:261
TGLClipSet::fShowManip
Bool_t fShowManip
Definition: TGLClip.h:152
TGLManipSet::Handle
virtual Bool_t Handle(TGLRnrCtx &rnrCtx, TGLOvlSelectRecord &selRec, Event_t *event)
Handle overlay event.
Definition: TGLManipSet.cxx:86
TGLVector3
3 component (x/y/z) vector class.
Definition: TGLUtil.h:248
TGLManipSet.h
TGLClip::Setup
virtual void Setup(const TGLBoundingBox &bbox)=0
GL_TRUE
#define GL_TRUE
Definition: GL_glu.h:262
TGLClipSet::SetClipType
void SetClipType(TGLClip::EType type)
Set current clip active in viewer - 'type' is one of kClipNone kClipPlane or kClipBox.
Definition: TGLClip.cxx:580
TBuffer3D.h
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
TGLVertex3::Z
Double_t Z() const
Definition: TGLUtil.h:123
TGLManipSet::MouseEnter
virtual Bool_t MouseEnter(TGLOvlSelectRecord &selRec)
Mouse has entered this element.
Definition: TGLManipSet.cxx:74
TGLPhysicalShape::GetScale
TGLVector3 GetScale() const
Definition: TGLPhysicalShape.h:141
TBuffer3DTypes.h
TGLRnrCtx::Selection
Bool_t Selection() const
Definition: TGLRnrCtx.h:222
TGLClip::IsValid
Bool_t IsValid() const
Definition: TGLClip.h:66
TGLClipBox::PlaneSet
virtual void PlaneSet(TGLPlaneSet_t &set) const
Return set of 6 planes describing faces of the box but invert them so that they point inside of box.
Definition: TGLClip.cxx:315
TGLPhysicalShape::GetLogical
const TGLLogicalShape * GetLogical() const
Definition: TGLPhysicalShape.h:96
TGLClip::EType
EType
Definition: TGLClip.h:40
TGLClipPlane::Set
void Set(const TGLPlane &plane)
Update clip plane object to follow passed 'plane' equation.
Definition: TGLClip.cxx:230
TGLVector3::Mag
Double_t Mag() const
Definition: TGLUtil.h:298
TGLRnrCtx::SetShapeLOD
void SetShapeLOD(Short_t LOD)
Definition: TGLRnrCtx.h:178
TGLPlaneSet_t
std::vector< TGLPlane > TGLPlaneSet_t
Definition: TGLUtil.h:571
TGLClipSet::FillPlaneSet
void FillPlaneSet(TGLPlaneSet_t &set) const
Forward request to fill the plane-set to the current clip.
Definition: TGLClip.cxx:416
TGLFaceSet.h
TGLLogicalShape::StrongRef
void StrongRef(Bool_t strong) const
Definition: TGLLogicalShape.h:76
TGLClipPlane
Concrete clip plane object.
Definition: TGLClip.h:86
TGLClip::PlaneSet
virtual void PlaneSet(TGLPlaneSet_t &set) const =0
TGLPhysicalShape::SetManip
void SetManip(EManip manip)
Definition: TGLPhysicalShape.h:101
Rgl::kInside
@ kInside
Definition: TGLUtil.h:36
TGLClip
Abstract clipping shape - derives from TGLPhysicalShape Adds clip mode (inside/outside) and pure virt...
Definition: TGLClip.h:32
TGLClipSet::fLastBBox
TGLBoundingBox fLastBBox
Definition: TGLClip.h:155
TGLPhysicalShape::Translate
void Translate(const TGLVector3 &vect)
Definition: TGLPhysicalShape.h:177
Double_t
double Double_t
Definition: RtypesCore.h:59
TGLPhysicalShape::BoundingBox
const TGLBoundingBox & BoundingBox() const
Definition: TGLPhysicalShape.h:88
TGLClip::kClipNone
@ kClipNone
Definition: TGLClip.h:41
TGLClipBox::Setup
virtual void Setup(const TGLBoundingBox &bbox)
Setup the clip object for scene encompassed by bbox.
Definition: TGLClip.cxx:279
TGLClip.h
TGLClipBox
Concrete clip box object.
Definition: TGLClip.h:114
TGLManipSet::Render
virtual void Render(TGLRnrCtx &rnrCtx)
Render the manipulator and bounding-box.
Definition: TGLManipSet.cxx:151
Event_t
Definition: GuiTypes.h:173
TGLRnrCtx::kPassFill
@ kPassFill
Definition: TGLRnrCtx.h:55
TGLLogicalShape
Abstract logical shape - a GL 'drawable' - base for all shapes - faceset sphere etc.
Definition: TGLLogicalShape.h:30
TGLPhysicalShape
Concrete physical shape - a GL drawable.
Definition: TGLPhysicalShape.h:32
GL_LINE_LOOP
#define GL_LINE_LOOP
Definition: GL_glu.h:285
TGLRnrCtx::SetDrawPass
void SetDrawPass(Short_t dpass)
Definition: TGLRnrCtx.h:205
TGLClipSet::fClipPlane
TGLClipPlane * fClipPlane
Definition: TGLClip.h:146
TGLPhysicalShape::EManip
EManip
Definition: TGLPhysicalShape.h:41
TGLClipSet::MouseStillInside
virtual Bool_t MouseStillInside(TGLOvlSelectRecord &selRec)
Definition: TGLClip.cxx:367
type
int type
Definition: TGX11.cxx:121
TGLClipSet::SetupClips
void SetupClips(const TGLBoundingBox &sceneBBox)
Setup clipping objects for given scene bounding box.
Definition: TGLClip.cxx:425
TGLLogicalShape::DirectDraw
virtual void DirectDraw(TGLRnrCtx &rnrCtx) const =0
TGLVertex3
3 component (x/y/z) vertex class.
Definition: TGLUtil.h:84
TGLPlane::NearestOn
TGLVertex3 NearestOn(const TGLVertex3 &point) const
Return nearest point on plane.
Definition: TGLUtil.cxx:500
TGLPlane::Norm
TGLVector3 Norm() const
Definition: TGLUtil.h:558
TGLClipSet::InvalidateClips
void InvalidateClips()
Invalidate clip objects.
Definition: TGLClip.cxx:455
TGLRnrCtx
The TGLRnrCtx class aggregates data for a given redering context as needed by various parts of the RO...
Definition: TGLRnrCtx.h:41
TGLClipSet::fShowClip
Bool_t fShowClip
Definition: TGLClip.h:151
TGLPhysicalShape::SetTransform
void SetTransform(const TGLMatrix &transform)
Definition: TGLPhysicalShape.h:153
TGLPhysicalShape::kRotateX
@ kRotateX
Definition: TGLPhysicalShape.h:49
Error
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:187
TGLClip::kClipPlane
@ kClipPlane
Definition: TGLClip.h:42
GL_QUADS
#define GL_QUADS
Definition: GL_glu.h:290