]> git.uio.no Git - u/mrichter/AliRoot.git/blame - EVE/Reve/QuadSetGL.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Added inner struct VoidCPlex::iterator; increase constness.
[u/mrichter/AliRoot.git] / EVE / Reve / QuadSetGL.cxx
CommitLineData
5a5a1232 1// $Header$
2
3#include "QuadSetGL.h"
8be1b0cc 4#include <Reve/FrameBoxGL.h>
5a5a1232 5
6#include <TGLDrawFlags.h>
7
8#include <GL/gl.h>
9#include <GL/glu.h>
10
11using namespace Reve;
12
13//______________________________________________________________________
3aa97c5d 14// OldQuadSetGL
5a5a1232 15//
16
3aa97c5d 17ClassImp(OldQuadSetGL)
5a5a1232 18
19/**************************************************************************/
20
3aa97c5d 21OldQuadSetGL::OldQuadSetGL() : TGLObject()
5a5a1232 22{
23 // fCached = false; // Disable DL.
24}
25
3aa97c5d 26OldQuadSetGL::~OldQuadSetGL()
5a5a1232 27{}
28
29/**************************************************************************/
30
3aa97c5d 31Bool_t OldQuadSetGL::SetModel(TObject* obj)
5a5a1232 32{
3aa97c5d 33 return SetModelCheckClass(obj, Reve::OldQuadSet::Class());
5a5a1232 34}
35
3aa97c5d 36void OldQuadSetGL::SetBBox()
5a5a1232 37{
3aa97c5d 38 SetAxisAlignedBBox(((OldQuadSet*)fExternalObj)->AssertBBox());
5a5a1232 39}
40
41/**************************************************************************/
42
3aa97c5d 43void OldQuadSetGL::DirectDraw(const TGLDrawFlags & ) const
5a5a1232 44{
3aa97c5d 45 // printf("OldQuadSetGLRenderer::DirectDraw Style %d, LOD %d\n", flags.Style(), flags.LOD());
5a5a1232 46
3aa97c5d 47 OldQuadSet& Q = * (OldQuadSet*) fExternalObj;
5a5a1232 48
49 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);
50
51 glDisable(GL_LIGHTING);
52 glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
53 glEnable(GL_COLOR_MATERIAL);
54 glPolygonMode(GL_FRONT, GL_LINE);
55 glPolygonMode(GL_BACK, GL_LINE);
56 glDisable(GL_CULL_FACE);
57
58 Float_t c[4]; glGetFloatv(GL_CURRENT_COLOR, c);
59 // UChar_t alpha = (UChar_t)(255*c[3]);
60
61 glBegin(GL_QUADS);
62 for(std::vector<Quad>::iterator q=Q.fQuads.begin(); q!=Q.fQuads.end(); ++q) {
63 UChar_t* c = (UChar_t*) &q->color;
64 //glColor4ub(c[0], c[1], c[2], (c[3]*alpha) >> 8);
65 glColor3ub(c[0], c[1], c[2]);
66 glVertex3fv(q->vertices);
67 glVertex3fv(q->vertices + 3);
68 glVertex3fv(q->vertices + 6);
69 glVertex3fv(q->vertices + 9);
70 }
71 glEnd();
72
73 glPopAttrib();
74}
8be1b0cc 75
76
77/**************************************************************************/
78/**************************************************************************/
79/**************************************************************************/
80/**************************************************************************/
81
82//______________________________________________________________________
83// QuadSetGL
84//
85
86ClassImp(QuadSetGL)
87
88/**************************************************************************/
89
90 QuadSetGL::QuadSetGL() : TGLObject(), fM(0)
91{
92 // fCached = false; // Disable DL.
93}
94
95QuadSetGL::~QuadSetGL()
96{}
97
98/**************************************************************************/
99
100Bool_t QuadSetGL::SetModel(TObject* obj)
101{
102 Bool_t ok = SetModelCheckClass(obj, Reve::QuadSet::Class());
103 fM = ok ? dynamic_cast<Reve::QuadSet*>(obj) : 0;
104 return ok;
105}
106
107void QuadSetGL::SetBBox()
108{
109 SetAxisAlignedBBox(fM->AssertBBox());
110}
111
112/**************************************************************************/
113
114inline Bool_t QuadSetGL::SetupColor(const QuadSet::QuadBase& q) const
115{
116 if (fM->fValueIsColor)
117 {
118 glColor4ubv((UChar_t*) & q.fValue);
975a1f61 119 return kTRUE;
8be1b0cc 120 }
121 else
122 {
975a1f61 123 UChar_t c[4];
124 Bool_t visible = fM->fPalette->ColorFromValue(q.fValue, fM->fDefaultValue, c);
125 if (visible)
126 glColor4ubv(c);
127 return visible;
8be1b0cc 128 }
8be1b0cc 129}
130
131/**************************************************************************/
132
133void QuadSetGL::DirectDraw(const TGLDrawFlags & flags) const
134{
135 static const Exc_t eH("QuadSetGL::DirectDraw ");
136
137 // printf("QuadSetGLRenderer::DirectDraw Style %d, LOD %d\n", flags.Style(), flags.LOD());
138
139 QuadSet& mQ = * fM;
44eb96d2 140
141 if (mQ.fFrame != 0)
142 FrameBoxGL::Render(mQ.fFrame);
143
8be1b0cc 144 if (mQ.fPlex.Size() == 0)
145 return;
146 if ( ! mQ.fValueIsColor && mQ.fPalette == 0)
147 {
20358789 148 mQ.AssertPalette();
8be1b0cc 149 }
150
8be1b0cc 151 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);
152 glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
153 glEnable(GL_COLOR_MATERIAL);
154 glDisable(GL_CULL_FACE);
155
156 if (mQ.fRenderMode == QuadSet::RM_Fill)
8be1b0cc 157 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
8be1b0cc 158 else if (mQ.fRenderMode == QuadSet::RM_Line)
8be1b0cc 159 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
8be1b0cc 160
20358789 161 if (mQ.fDisableLigting) glDisable(GL_LIGHTING);
162
96c51586 163 if (mQ.fQuadType < QuadSet::QT_Rectangle_End) RenderQuads(flags);
164 else if (mQ.fQuadType < QuadSet::QT_Line_End) RenderLines(flags);
165 else if (mQ.fQuadType < QuadSet::QT_Hexagon_End) RenderHexagons(flags);
20358789 166
8be1b0cc 167 glPopAttrib();
168
169}
170
171
172void QuadSetGL::RenderQuads(const TGLDrawFlags &) const
173{
174 static const Exc_t eH("QuadSetGL::RenderQuads ");
175
176 QuadSet& mQ = * fM;
177
178 if (mQ.fRenderMode != QuadSet::RM_Line)
179 {
180
181 if (mQ.fQuadType == QuadSet::QT_FreeQuad)
182 glEnable(GL_NORMALIZE);
183 else
184 glNormal3f(0, 0, 1);
185
186 glBegin(GL_QUADS);
187 for (Int_t c=0; c<mQ.fPlex.VecSize(); ++c)
188 {
189 QuadSet::QuadBase* qbp = (QuadSet::QuadBase*) mQ.fPlex.Chunk(c);
190 Int_t n = mQ.fPlex.NAtoms(c);
191
192 switch (mQ.fQuadType)
193 {
194
195 case QuadSet::QT_FreeQuad:
196 {
20358789 197 QuadSet::QFreeQuad* qp = (QuadSet::QFreeQuad*) qbp;
8be1b0cc 198 Float_t e1[3], e2[3], normal[3];
199 while (n--) {
cecf8d18 200 if (SetupColor(*qp))
201 {
202 Float_t* p = qp->fVertices;
203 e1[0] = p[3] - p[0]; e1[1] = p[4] - p[1]; e1[2] = p[5] - p[2];
204 e2[0] = p[6] - p[0]; e2[1] = p[7] - p[1]; e2[2] = p[8] - p[2];
205 TMath::Cross(e1, e2, normal);
206 glNormal3fv(normal);
207 glVertex3fv(p);
208 glVertex3fv(p + 3);
209 glVertex3fv(p + 6);
210 glVertex3fv(p + 9);
211 }
8be1b0cc 212 ++qp;
213 }
214 break;
215 }
216
20358789 217 case QuadSet::QT_RectangleXY:
8be1b0cc 218 {
20358789 219 QuadSet::QRect* qp = (QuadSet::QRect*) qbp;
8be1b0cc 220 while (n--) {
20358789 221 QuadSet::QRect& q = * qp;
cecf8d18 222 if (SetupColor(q))
223 {
224 glVertex3f(q.fX, q.fY, q.fZ);
225 glVertex3f(q.fX + q.fW, q.fY, q.fZ);
226 glVertex3f(q.fX + q.fW, q.fY + q.fH, q.fZ);
227 glVertex3f(q.fX, q.fY + q.fH, q.fZ);
228 }
8be1b0cc 229 ++qp;
230 }
231 break;
232 }
233
20358789 234 case QuadSet::QT_RectangleXYFixedDim:
8be1b0cc 235 {
20358789 236 QuadSet::QRectFixDim* qp = (QuadSet::QRectFixDim*) qbp;
8be1b0cc 237 const Float_t& w = mQ.fDefWidth;
238 const Float_t& h = mQ.fDefHeight;
239 while (n--) {
20358789 240 QuadSet::QRectFixDim& q = * qp;
cecf8d18 241 if (SetupColor(q))
242 {
243 glVertex3f(q.fX, q.fY, q.fZ);
244 glVertex3f(q.fX + w, q.fY, q.fZ);
245 glVertex3f(q.fX + w, q.fY + h, q.fZ);
246 glVertex3f(q.fX, q.fY + h, q.fZ);
247 }
8be1b0cc 248 ++qp;
249 }
250 break;
251 }
252
20358789 253 case QuadSet::QT_RectangleXYFixedZ:
8be1b0cc 254 {
20358789 255 QuadSet::QRectFixC* qp = (QuadSet::QRectFixC*) qbp;
8be1b0cc 256 const Float_t& z = mQ.fDefCoord;
257 while (n--) {
20358789 258 QuadSet::QRectFixC& q = * qp;
cecf8d18 259 if (SetupColor(q))
260 {
261 glVertex3f(q.fX, q.fY, z);
262 glVertex3f(q.fX + q.fW, q.fY, z);
263 glVertex3f(q.fX + q.fW, q.fY + q.fH, z);
264 glVertex3f(q.fX, q.fY + q.fH, z);
265 }
8be1b0cc 266 ++qp;
267 }
268 break;
269 }
270
20358789 271 case QuadSet::QT_RectangleXZFixedY:
8be1b0cc 272 {
20358789 273 QuadSet::QRectFixC* qp = (QuadSet::QRectFixC*) qbp;
8be1b0cc 274 const Float_t& z = mQ.fDefCoord;
275 while (n--) {
20358789 276 QuadSet::QRectFixC& q = * qp;
cecf8d18 277 if (SetupColor(q))
278 {
279 glVertex3f(q.fX, z, q.fY);
280 glVertex3f(q.fX + q.fW, z, q.fY);
281 glVertex3f(q.fX + q.fW, z, q.fY + q.fH);
282 glVertex3f(q.fX, z, q.fY + q.fH);
283 }
8be1b0cc 284 ++qp;
285 }
286 break;
287 }
288
20358789 289 case QuadSet::QT_RectangleXYFixedDimZ:
8be1b0cc 290 {
20358789 291 QuadSet::QRectFixDimC* qp = (QuadSet::QRectFixDimC*) qbp;
8be1b0cc 292 const Float_t& z = mQ.fDefCoord;
293 const Float_t& w = mQ.fDefWidth;
294 const Float_t& h = mQ.fDefHeight;
295 while (n--) {
20358789 296 QuadSet::QRectFixDimC& q = * qp;
cecf8d18 297 if (SetupColor(q))
298 {
299 glVertex3f(q.fX, q.fY, z);
300 glVertex3f(q.fX + w, q.fY, z);
301 glVertex3f(q.fX + w, q.fY + h, z);
302 glVertex3f(q.fX, q.fY + h, z);
303 }
8be1b0cc 304 ++qp;
305 }
306 break;
307 }
308
20358789 309 case QuadSet::QT_RectangleXZFixedDimY:
8be1b0cc 310 {
20358789 311 QuadSet::QRectFixDimC* qp = (QuadSet::QRectFixDimC*) qbp;
8be1b0cc 312 const Float_t& z = mQ.fDefCoord;
313 const Float_t& w = mQ.fDefWidth;
314 const Float_t& h = mQ.fDefHeight;
315 while (n--) {
20358789 316 QuadSet::QRectFixDimC& q = * qp;
cecf8d18 317 if (SetupColor(q))
318 {
319 glVertex3f(q.fX, z, q.fY);
320 glVertex3f(q.fX + w, z, q.fY);
321 glVertex3f(q.fX + w, z, q.fY + h);
322 glVertex3f(q.fX, z, q.fY + h);
323 }
8be1b0cc 324 ++qp;
325 }
326 break;
327 }
328
329 default:
330 throw(eH + "unsupported quad-type.");
331
332 } // end switch quad-type
333
334 } // end for chunk
335 glEnd();
336
337 }
338 else
339 {
340
341 for (Int_t c=0; c<mQ.fPlex.VecSize(); ++c)
342 {
343 QuadSet::QuadBase* qbp = (QuadSet::QuadBase*) mQ.fPlex.Chunk(c);
344 Int_t n = mQ.fPlex.NAtoms(c);
345
346 switch (mQ.fQuadType)
347 {
348
349 case QuadSet::QT_FreeQuad:
350 {
20358789 351 QuadSet::QFreeQuad* qp = (QuadSet::QFreeQuad*) qbp;
8be1b0cc 352 while (n--) {
cecf8d18 353 if (SetupColor(*qp))
354 {
355 SetupColor(*qp);
356 Float_t* p = qp->fVertices;
357 glBegin(GL_LINE_LOOP);
358 glVertex3fv(p);
359 glVertex3fv(p + 3);
360 glVertex3fv(p + 6);
361 glVertex3fv(p + 9);
362 glEnd();
363 }
8be1b0cc 364 ++qp;
365 }
366 break;
367 }
368
20358789 369 case QuadSet::QT_RectangleXY:
8be1b0cc 370 {
20358789 371 QuadSet::QRect* qp = (QuadSet::QRect*) qbp;
8be1b0cc 372 while (n--) {
20358789 373 QuadSet::QRect& q = * qp;
cecf8d18 374 if (SetupColor(q))
375 {
376 glBegin(GL_LINE_LOOP);
377 glVertex3f(q.fX, q.fY, q.fZ);
378 glVertex3f(q.fX + q.fW, q.fY, q.fZ);
379 glVertex3f(q.fX + q.fW, q.fY + q.fH, q.fZ);
380 glVertex3f(q.fX, q.fY + q.fH, q.fZ);
381 glEnd();
382 }
8be1b0cc 383 ++qp;
384 }
385 break;
386 }
387
20358789 388 case QuadSet::QT_RectangleXYFixedDim:
8be1b0cc 389 {
20358789 390 QuadSet::QRectFixDim* qp = (QuadSet::QRectFixDim*) qbp;
8be1b0cc 391 const Float_t& w = mQ.fDefWidth;
392 const Float_t& h = mQ.fDefHeight;
393 while (n--) {
20358789 394 QuadSet::QRectFixDim& q = * qp;
cecf8d18 395 if (SetupColor(q))
396 {
397 glBegin(GL_LINE_LOOP);
398 glVertex3f(q.fX, q.fY, q.fZ);
399 glVertex3f(q.fX + w, q.fY, q.fZ);
400 glVertex3f(q.fX + w, q.fY + h, q.fZ);
401 glVertex3f(q.fX, q.fY + h, q.fZ);
402 glEnd();
403 }
8be1b0cc 404 ++qp;
405 }
406 break;
407 }
408
20358789 409 case QuadSet::QT_RectangleXYFixedZ:
8be1b0cc 410 {
20358789 411 QuadSet::QRectFixC* qp = (QuadSet::QRectFixC*) qbp;
8be1b0cc 412 const Float_t& z = mQ.fDefCoord;
413 while (n--) {
20358789 414 QuadSet::QRectFixC& q = * qp;
cecf8d18 415 if (SetupColor(q))
416 {
417 glBegin(GL_LINE_LOOP);
418 glVertex3f(q.fX, q.fY, z);
419 glVertex3f(q.fX + q.fW, q.fY, z);
420 glVertex3f(q.fX + q.fW, q.fY + q.fH, z);
421 glVertex3f(q.fX, q.fY + q.fH, z);
422 glEnd();
423 }
8be1b0cc 424 ++qp;
425 }
426 break;
427 }
428
20358789 429 case QuadSet::QT_RectangleXZFixedY:
8be1b0cc 430 {
20358789 431 QuadSet::QRectFixC* qp = (QuadSet::QRectFixC*) qbp;
8be1b0cc 432 const Float_t& z = mQ.fDefCoord;
433 while (n--) {
20358789 434 QuadSet::QRectFixC& q = * qp;
cecf8d18 435 if (SetupColor(q))
436 {
437 glBegin(GL_LINE_LOOP);
438 glVertex3f(q.fX, z, q.fY);
439 glVertex3f(q.fX + q.fW, z, q.fY);
440 glVertex3f(q.fX + q.fW, z, q.fY + q.fH);
441 glVertex3f(q.fX, z, q.fY + q.fH);
442 glEnd();
443 }
8be1b0cc 444 ++qp;
445 }
446 break;
447 }
448
20358789 449 case QuadSet::QT_RectangleXYFixedDimZ:
8be1b0cc 450 {
20358789 451 QuadSet::QRectFixDimC* qp = (QuadSet::QRectFixDimC*) qbp;
8be1b0cc 452 const Float_t& z = mQ.fDefCoord;
453 const Float_t& w = mQ.fDefWidth;
454 const Float_t& h = mQ.fDefHeight;
455 while (n--) {
20358789 456 QuadSet::QRectFixDimC& q = * qp;
cecf8d18 457 if (SetupColor(q))
458 {
459 glBegin(GL_LINE_LOOP);
460 glVertex3f(q.fX, q.fY, z);
461 glVertex3f(q.fX + w, q.fY, z);
462 glVertex3f(q.fX + w, q.fY + h, z);
463 glVertex3f(q.fX, q.fY + h, z);
464 glEnd();
465 }
8be1b0cc 466 ++qp;
467 }
468 break;
469 }
470
20358789 471 case QuadSet::QT_RectangleXZFixedDimY:
8be1b0cc 472 {
20358789 473 QuadSet::QRectFixDimC* qp = (QuadSet::QRectFixDimC*) qbp;
8be1b0cc 474 const Float_t& z = mQ.fDefCoord;
475 const Float_t& w = mQ.fDefWidth;
476 const Float_t& h = mQ.fDefHeight;
477 while (n--) {
20358789 478 QuadSet::QRectFixDimC& q = * qp;
cecf8d18 479 if (SetupColor(q))
480 {
481 glBegin(GL_LINE_LOOP);
482 glVertex3f(q.fX, z, q.fY);
483 glVertex3f(q.fX + w, z, q.fY);
484 glVertex3f(q.fX + w, z, q.fY + h);
485 glVertex3f(q.fX, z, q.fY + h);
486 glEnd();
487 }
8be1b0cc 488 ++qp;
489 }
490 break;
491 }
492
493 default:
494 throw(eH + "unsupported quad-type.");
495
496 } // end switch quad-type
497
498 } // end for chunk
499
500 } // end else of RenderMode
501}
502
503
504void QuadSetGL::RenderLines(const TGLDrawFlags &) const
505{
506 static const Exc_t eH("QuadSetGL::RenderLines ");
507
508 QuadSet& mQ = * fM;
509
510 for (Int_t c=0; c<mQ.fPlex.VecSize(); ++c)
511 {
512 QuadSet::QuadBase* qbp = (QuadSet::QuadBase*) mQ.fPlex.Chunk(c);
513 Int_t n = mQ.fPlex.NAtoms(c);
514
515 switch (mQ.fQuadType)
516 {
517
20358789 518 case QuadSet::QT_LineXYFixedZ:
8be1b0cc 519 {
20358789 520 QuadSet::QLineFixC* qp = (QuadSet::QLineFixC*) qbp;
8be1b0cc 521 const Float_t& z = mQ.fDefCoord;
522 glBegin(GL_LINES);
523 while (n--) {
20358789 524 QuadSet::QLineFixC& q = * qp;
cecf8d18 525 if (SetupColor(q))
526 {
527 glVertex3f(q.fX, q.fY, z);
528 glVertex3f(q.fX + q.fDx, q.fY + q.fDy, z);
529 }
8be1b0cc 530 ++qp;
531 }
532 glEnd();
533 break;
534 }
535
20358789 536 case QuadSet::QT_LineXZFixedY:
8be1b0cc 537 {
20358789 538 QuadSet::QLineFixC* qp = (QuadSet::QLineFixC*) qbp;
8be1b0cc 539 const Float_t& z = mQ.fDefCoord;
540 glBegin(GL_LINES);
541 while (n--) {
20358789 542 QuadSet::QLineFixC& q = * qp;
cecf8d18 543 if (SetupColor(q))
544 {
545 glVertex3f(q.fX, z, q.fY);
546 glVertex3f(q.fX + q.fDx, z, q.fY + q.fDy);
547 }
8be1b0cc 548 ++qp;
549 }
550 glEnd();
551 break;
552 }
553
554 default:
555 throw(eH + "unsupported quad-type.");
556
557 }
558 }
559}
96c51586 560
561void QuadSetGL::RenderHexagons(const TGLDrawFlags &) const
562{
563 static const Exc_t eH("QuadSetGL::RenderHexagons ");
564
565 const Float_t sqr3hf = 0.5*TMath::Sqrt(3);
566
567 QuadSet& mQ = * fM;
568
569 if (mQ.fRenderMode != QuadSet::RM_Line)
570 {
571
572 glNormal3f(0, 0, 1);
573
574 for (Int_t c=0; c<mQ.fPlex.VecSize(); ++c)
575 {
576 QuadSet::QuadBase* qbp = (QuadSet::QuadBase*) mQ.fPlex.Chunk(c);
577 Int_t n = mQ.fPlex.NAtoms(c);
578
579 switch (mQ.fQuadType)
580 {
581
582 case QuadSet::QT_HexagonXY:
583 {
584 QuadSet::QHex* qp = (QuadSet::QHex*) qbp;
585 while (n--) {
586 QuadSet::QHex& q = * qp;
587 if (SetupColor(q))
588 {
589 const Float_t rh = q.fR * 0.5;
590 const Float_t rs = q.fR * sqr3hf;
591 glBegin(GL_POLYGON);
592 glVertex3f( q.fR + q.fX, q.fY, q.fZ);
593 glVertex3f( rh + q.fX, rs + q.fY, q.fZ);
594 glVertex3f( -rh + q.fX, rs + q.fY, q.fZ);
595 glVertex3f(-q.fR + q.fX, q.fY, q.fZ);
596 glVertex3f( -rh + q.fX, -rs + q.fY, q.fZ);
597 glVertex3f( rh + q.fX, -rs + q.fY, q.fZ);
598 glEnd();
599 }
600 ++qp;
601 }
602 break;
603 }
604
605 case QuadSet::QT_HexagonYX:
606 {
607 QuadSet::QHex* qp = (QuadSet::QHex*) qbp;
608 while (n--) {
609 QuadSet::QHex& q = * qp;
610 if (SetupColor(q))
611 {
612 const Float_t rh = q.fR * 0.5;
613 const Float_t rs = q.fR * sqr3hf;
614 glBegin(GL_POLYGON);
615 glVertex3f( rs + q.fX, rh + q.fY, q.fZ);
616 glVertex3f( q.fX, q.fR + q.fY, q.fZ);
617 glVertex3f(-rs + q.fX, rh + q.fY, q.fZ);
618 glVertex3f(-rs + q.fX, -rh + q.fY, q.fZ);
619 glVertex3f( q.fX, -q.fR + q.fY, q.fZ);
620 glVertex3f( rs + q.fX, -rh + q.fY, q.fZ);
621 glEnd();
622 }
623 ++qp;
624 }
625 break;
626 }
627
628 default:
629 throw(eH + "unsupported quad-type.");
630
631 } // end switch quad-type
632
633 } // end for chunk
634
635 }
636 else
637 {
638
639 for (Int_t c=0; c<mQ.fPlex.VecSize(); ++c)
640 {
641 QuadSet::QuadBase* qbp = (QuadSet::QuadBase*) mQ.fPlex.Chunk(c);
642 Int_t n = mQ.fPlex.NAtoms(c);
643
644 switch (mQ.fQuadType)
645 {
646
647 case QuadSet::QT_HexagonXY:
648 {
649 QuadSet::QHex* qp = (QuadSet::QHex*) qbp;
650 while (n--) {
651 QuadSet::QHex& q = * qp;
652 if (SetupColor(q))
653 {
654 const Float_t rh = q.fR * 0.5;
655 const Float_t rs = q.fR * sqr3hf;
656 glBegin(GL_LINE_LOOP);
657 glVertex3f( q.fR + q.fX, q.fY, q.fZ);
658 glVertex3f( rh + q.fX, rs + q.fY, q.fZ);
659 glVertex3f( -rh + q.fX, rs + q.fY, q.fZ);
660 glVertex3f(-q.fR + q.fX, q.fY, q.fZ);
661 glVertex3f( -rh + q.fX, -rs + q.fY, q.fZ);
662 glVertex3f( rh + q.fX, -rs + q.fY, q.fZ);
663 glEnd();
664 }
665 ++qp;
666 }
667 break;
668 }
669
670 case QuadSet::QT_HexagonYX:
671 {
672 QuadSet::QHex* qp = (QuadSet::QHex*) qbp;
673 while (n--) {
674 QuadSet::QHex& q = * qp;
675 if (SetupColor(q))
676 {
677 const Float_t rh = q.fR * 0.5;
678 const Float_t rs = q.fR * sqr3hf;
679 glBegin(GL_LINE_LOOP);
680 glVertex3f( rs + q.fX, rh + q.fY, q.fZ);
681 glVertex3f( q.fX, q.fR + q.fY, q.fZ);
682 glVertex3f(-rs + q.fX, rh + q.fY, q.fZ);
683 glVertex3f(-rs + q.fX, -rh + q.fY, q.fZ);
684 glVertex3f( q.fX, -q.fR + q.fY, q.fZ);
685 glVertex3f( rs + q.fX, -rh + q.fY, q.fZ);
686 glEnd();
687 }
688 ++qp;
689 }
690 break;
691 }
692
693 default:
694 throw(eH + "unsupported quad-type.");
695
696 } // end switch quad-type
697
698 } // end for chunk
699
700 } // end else of RenderMode
701
702
703}