| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 //
28 //
29 // Andrew Walkden 27th March 1996
30 // OpenGL stored scene - creates OpenGL displa
31 // OpenGL immediate scene - draws immediately
32 // (saving space on
33
34
35 # include "G4OpenGLSceneHandler.hh"
36 # include "G4OpenGLViewer.hh"
37 # include "G4OpenGLTransform3D.hh"
38 # include "G4Point3D.hh"
39 # include "G4Normal3D.hh"
40 # include "G4Transform3D.hh"
41 # include "G4Polyline.hh"
42 # include "G4Polymarker.hh"
43 # include "G4Text.hh"
44 # include "G4Circle.hh"
45 # include "G4Square.hh"
46 # include "G4VMarker.hh"
47 # include "G4Polyhedron.hh"
48 # include "G4VisAttributes.hh"
49 # include "G4PhysicalVolumeModel.hh"
50 # include "G4VPhysicalVolume.hh"
51 # include "G4LogicalVolume.hh"
52 # include "G4VSolid.hh"
53 # include "G4Scene.hh"
54 # include "G4VisExtent.hh"
55 # include "G4AttHolder.hh"
56 # include "G4PhysicalConstants.hh"
57 # include "G4RunManager.hh"
58 # include "G4Run.hh"
59 # include "G4RunManagerFactory.hh"
60 # include "G4Mesh.hh"
61 # include "G4PseudoScene.hh"
62 # include "G4VisManager.hh"
63
64 const GLubyte G4OpenGLSceneHandler::fStippleMa
65 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
66 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
67 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
68 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
69 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
70 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
71 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
72 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
73 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
74 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
75 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
76 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
77 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
78 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
79 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
80 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
81 };
82
83 G4OpenGLSceneHandler::G4OpenGLSceneHandler (G4
84 G4
85 co
86 G4VSceneHandler (system, id, name),
87 fPickName(0),
88 fThreePassCapable(false),
89 fSecondPassForTransparencyRequested(false),
90 fSecondPassForTransparency(false),
91 fThirdPassForNonHiddenMarkersRequested(false),
92 fThirdPassForNonHiddenMarkers(false),
93 fEdgeFlag(true)
94 {
95 }
96
97 G4OpenGLSceneHandler::~G4OpenGLSceneHandler ()
98 {
99 ClearStore ();
100 }
101
102 void G4OpenGLSceneHandler::ClearAndDestroyAtts
103 {
104 std::map<GLuint, G4AttHolder*>::iterator i;
105 for (i = fPickMap.begin(); i != fPickMap.end
106 fPickMap.clear();
107 }
108
109 G4int G4OpenGLSceneHandler::fEntitiesFlushInte
110 G4OpenGLSceneHandler::FlushAction
111 G4OpenGLSceneHandler::fFlushAction = G4OpenGLS
112
113 void G4OpenGLSceneHandler::ScaledFlush()
114 {
115 if (fReadyForTransients) {
116
117 // Drawing transients, e.g., trajectories.
118
119 if (!fpScene) {
120 // No scene - shouldn't happen
121 glFlush();
122 return;
123 }
124 // Get event from modeling parameters
125 if (!fpModel) {
126 // No model - shouldn't happen
127 glFlush();
128 return;
129 }
130 const G4ModelingParameters* modelingParame
131 fpModel->GetModelingParameters();
132 if (!modelingParameters) {
133 // No modeling parameters - shouldn't ha
134 glFlush();
135 return;
136 }
137 const G4Event* thisEvent = modelingParamet
138 if (!thisEvent) {
139 // No event, so not in event loop.
140 if (fFlushAction == endOfEvent) {
141 fFlushAction = endOfRun;
142 } else if (fFlushAction == NthEvent) {
143 fFlushAction = NthPrimitive;
144 }
145 }
146 G4RunManager* runMan = G4RunManagerFactory
147 if (!runMan) {
148 // No run manager - shouldn't happen
149 glFlush();
150 return;
151 }
152 const G4Run* thisRun = runMan->GetCurrentR
153 if (!thisRun) {
154 // No run, so not in event loop.
155 if (fFlushAction == endOfRun) {
156 fFlushAction = NthPrimitive;
157 } else if (fFlushAction == NthEvent) {
158 fFlushAction = NthPrimitive;
159 }
160 }
161
162 switch (fFlushAction) {
163 case endOfEvent:
164 // If "/vis/scene/endOfEventAction ref
165 // end of run anyway, so only scale if
166 if (!fpScene->GetRefreshAtEndOfEvent()
167 // But if "/vis/scene/endOfEventActi
168 // called until end of run, so we ha
169 // Get event from modeling parameter
170 G4int thisEventID = thisEvent->GetEv
171 static G4int lastEventID = 0;
172 if (thisEventID != lastEventID) {
173 glFlush();
174 lastEventID = thisEventID;
175 }
176 }
177 break;
178 case endOfRun:
179 // If "/vis/scene/endOfRunAction refre
180 // end of run anyway, so only scale if
181 if (!fpScene->GetRefreshAtEndOfRun())
182 // If "/vis/scene/endOfRunAction acc
183 // so we have to watch for a new run
184 G4int thisRunID = thisRun->GetRunID(
185 static G4int lastRunID = 0;
186 if (thisRunID != lastRunID) {
187 glFlush();
188 lastRunID = thisRunID;
189 }
190 }
191 break;
192 case eachPrimitive:
193 // This is equivalent to numeric with
194 fEntitiesFlushInterval = 1;
195 [[fallthrough]]; // Fall through to NthPrim
196 case NthPrimitive:
197 { // Encapsulate in scope {} brackets to
198 static G4int primitivesWaitingToBeFlus
199 primitivesWaitingToBeFlushed++;
200 if (primitivesWaitingToBeFlushed < fEn
201 glFlush();
202 primitivesWaitingToBeFlushed = 0;
203 break;
204 }
205 case NthEvent:
206 // If "/vis/scene/endOfEventAction ref
207 // end of event anyway, so only scale
208 if (!fpScene->GetRefreshAtEndOfEvent()
209 G4int thisEventID = thisEvent->GetEv
210 static G4int lastEventID = 0;
211 if (thisEventID != lastEventID) {
212 static G4int eventsWaitingToBeFlus
213 eventsWaitingToBeFlushed++;
214 if (eventsWaitingToBeFlushed < fEn
215 glFlush();
216 eventsWaitingToBeFlushed = 0;
217 lastEventID = thisEventID;
218 }
219 }
220 break;
221 case never:
222 break;
223 default:
224 break;
225 }
226
227 }
228
229 else
230
231 {
232
233 // For run duration model drawing (detecto
234 // Immediate mode: a huge speed up is obta
235 // Stored mode: no discernable difference
236 // back buffer and then swapped.
237 // So eachPrimitive and NthPrimitive make
238 // endOfRun are treated as "no action", i.
239 // as happens anyway, when drawing is comp
240
241 switch (fFlushAction) {
242 case endOfEvent:
243 break;
244 case endOfRun:
245 break;
246 case eachPrimitive:
247 // This is equivalent to NthPrimitive
248 fEntitiesFlushInterval = 1;
249 [[fallthrough]]; // Fall through to NthPrim
250 case NthPrimitive:
251 { // Encapsulate in scope {} brackets to
252 static G4int primitivesWaitingToBeFlus
253 primitivesWaitingToBeFlushed++;
254 if (primitivesWaitingToBeFlushed < fEn
255 glFlush();
256 primitivesWaitingToBeFlushed = 0;
257 break;
258 }
259 case NthEvent:
260 break;
261 case never:
262 break;
263 default:
264 break;
265 }
266
267 }
268 }
269
270 void G4OpenGLSceneHandler::ProcessScene()
271 {
272 fThreePassCapable = true;
273
274 G4VSceneHandler::ProcessScene();
275
276 // Repeat if required...
277 if (fSecondPassForTransparencyRequested) {
278 fSecondPassForTransparency = true;
279 G4VSceneHandler::ProcessScene();
280 fSecondPassForTransparency = false;
281 fSecondPassForTransparencyRequested = fals
282 }
283
284 // And again if required...
285 if (fThirdPassForNonHiddenMarkersRequested)
286 fThirdPassForNonHiddenMarkers = true;
287 G4VSceneHandler::ProcessScene();
288 fThirdPassForNonHiddenMarkers = false;
289 fThirdPassForNonHiddenMarkersRequested = f
290 }
291
292 fThreePassCapable = false;
293 }
294
295 void G4OpenGLSceneHandler::PreAddSolid
296 (const G4Transform3D& objectTransformation,
297 const G4VisAttributes& visAttribs)
298 {
299 G4VSceneHandler::PreAddSolid (objectTransfor
300 }
301
302 void G4OpenGLSceneHandler::BeginPrimitives
303 (const G4Transform3D& objectTransformation)
304 {
305 G4VSceneHandler::BeginPrimitives (objectTran
306 }
307
308 void G4OpenGLSceneHandler::EndPrimitives ()
309 {
310 G4VSceneHandler::EndPrimitives ();
311 }
312
313 void G4OpenGLSceneHandler::BeginPrimitives2D
314 (const G4Transform3D& objectTransformation)
315 {
316 G4VSceneHandler::BeginPrimitives2D (objectTr
317 }
318
319 void G4OpenGLSceneHandler::EndPrimitives2D ()
320 {
321 G4VSceneHandler::EndPrimitives2D ();
322 }
323
324 G4DisplacedSolid* G4OpenGLSceneHandler::Create
325 {
326 return G4VSceneHandler::CreateSectionSolid()
327 // If clipping done in G4OpenGLViewer::SetVi
328 // return 0;
329 // Note: if you change this, you must also c
330 // G4OpenGLStoredViewer::CompareForKernelVis
331 }
332
333 G4DisplacedSolid* G4OpenGLSceneHandler::Create
334 {
335 // return G4VSceneHandler::CreateCutawaySoli
336 // If cutaway done in G4OpenGLViewer::SetVie
337 return 0;
338 // Note: if you change this, you must also c
339 // G4OpenGLStoredViewer::CompareForKernelVis
340 }
341
342 void G4OpenGLSceneHandler::AddPrimitive (const
343 {
344 std::size_t nPoints = line.size ();
345 if (nPoints <= 0) return;
346
347 // Note: colour and depth test treated in su
348
349 glDisable (GL_LIGHTING);
350
351 G4double lineWidth = GetLineWidth(fpVisAttri
352 // Need access to method in G4OpenGLViewer.
353 // work with a virtual base class, so use dy
354 // test the outcome since viewer is guarante
355 // G4OpenGLViewer, but test it anyway to kee
356 G4OpenGLViewer* pGLViewer = dynamic_cast<G4O
357 if (pGLViewer) pGLViewer->ChangeLineWidth(li
358
359 fEdgeFlag = true;
360 glBegin (GL_LINE_STRIP);
361 // No ned glEdgeFlag for lines :
362 // Boundary and nonboundary edge flags on ve
363
364 // glEdgeFlag (GL_TRUE);
365 for (std::size_t iPoint = 0; iPoint < nPoint
366 G4double x, y, z;
367 x = line[iPoint].x();
368 y = line[iPoint].y();
369 z = line[iPoint].z();
370 glVertex3d (x, y, z);
371 }
372 glEnd ();
373 }
374
375 void G4OpenGLSceneHandler::AddPrimitive (const
376 {
377 if (polymarker.size() == 0) {
378 return;
379 }
380
381 // Note: colour and depth test treated in su
382
383 glDisable (GL_LIGHTING);
384
385 MarkerSizeType sizeType;
386 G4double size = GetMarkerSize(polymarker, si
387
388 // Need access to method in G4OpenGLViewer.
389 // work with a virtual base class, so use dy
390 // test the outcome since viewer is guarante
391 // G4OpenGLViewer, but test it anyway to kee
392 G4OpenGLViewer* pGLViewer = dynamic_cast<G4O
393 if (!pGLViewer) return;
394
395 if (sizeType == world) { // Size specified
396 G4double lineWidth = GetLineWidth(fpVisAtt
397 pGLViewer->ChangeLineWidth(lineWidth);
398
399 G4VMarker::FillStyle style = polymarker.Ge
400
401 // G4bool filled = false; Not actually us
402 static G4bool hashedWarned = false;
403
404 switch (style) {
405 case G4VMarker::noFill:
406 glPolygonMode (GL_FRONT_AND_BACK, GL_L
407 glEdgeFlag (GL_TRUE);
408 //filled = false;
409 break;
410 case G4VMarker::hashed:
411 if (!hashedWarned) {
412 G4cout << "Hashed fill style in G4Op
413 << "\n Not implemented. Using G4VM
414 << G4endl;
415 hashedWarned = true;
416 }
417 // Maybe use
418 //glPolygonStipple (fStippleMaskHashed
419 [[fallthrough]]; // Drop through to filled
420 case G4VMarker::filled:
421 glPolygonMode (GL_FRONT_AND_BACK, GL_F
422 //filled = true;
423 break;
424 }
425 }
426
427 // Draw...
428 if (sizeType == world) { // Size specified
429
430 G4int nSides;
431 G4double startPhi;
432 switch (polymarker.GetMarkerType()) {
433 default:
434 case G4Polymarker::dots:
435 size = 1.;
436 [[fallthrough]]; // Fall through to circles
437 case G4Polymarker::circles:
438 nSides = GetNoOfSides(fpVisAttribs);
439 startPhi = 0.;
440 break;
441 case G4Polymarker::squares:
442 nSides = 4;
443 startPhi = -pi / 4.;
444 break;
445 }
446
447 const G4Vector3D& viewpointDirection =
448 fpViewer -> GetViewParameters().GetViewp
449 const G4Vector3D& up = fpViewer->GetViewPa
450 const G4double dPhi = twopi / nSides;
451 const G4double radius = size / 2.;
452 G4Vector3D start = radius * (up.cross(view
453 G4double phi;
454 G4int i;
455 for (size_t iPoint = 0; iPoint < polymarke
456 fEdgeFlag = true;
457 glBegin (GL_POLYGON);
458 for (i = 0, phi = startPhi; i < nSides;
459 G4Vector3D r = start; r.rotate(phi, viewpoin
460 G4Vector3D p = polymarker[iPoint] + r;
461 glVertex3d (p.x(), p.y(), p.z());
462 }
463 glEnd ();
464 }
465
466 } else { // Size specified in screen (window
467
468 pGLViewer->ChangePointSize(size);
469
470 //Antialiasing only for circles
471 switch (polymarker.GetMarkerType()) {
472 default:
473 case G4Polymarker::dots:
474 case G4Polymarker::circles:
475 glEnable (GL_POINT_SMOOTH); break;
476 case G4Polymarker::squares:
477 glDisable (GL_POINT_SMOOTH); break;
478 }
479 glBegin (GL_POINTS);
480 for (size_t iPoint = 0; iPoint < polymarke
481 G4Point3D centre = polymarker[iPoint];
482 glVertex3d(centre.x(),centre.y(),centre.
483 }
484 glEnd();
485 }
486 }
487
488 void G4OpenGLSceneHandler::AddPrimitive (const
489 // Pass to specific viewer via virtual funct
490 G4OpenGLViewer* pGLViewer = dynamic_cast<G4O
491 if (pGLViewer) pGLViewer->DrawText(text);
492 }
493
494 void G4OpenGLSceneHandler::AddPrimitive (const
495 G4Polymarker oneCircle(circle);
496 oneCircle.push_back(circle.GetPosition());
497 oneCircle.SetMarkerType(G4Polymarker::circle
498 // Call this AddPrimitive to avoid re-doing
499 G4OpenGLSceneHandler::AddPrimitive(oneCircle
500 }
501
502 void G4OpenGLSceneHandler::AddPrimitive (const
503 G4Polymarker oneSquare(square);
504 oneSquare.push_back(square.GetPosition());
505 oneSquare.SetMarkerType(G4Polymarker::square
506 // Call this AddPrimitive to avoid re-doing
507 G4OpenGLSceneHandler::AddPrimitive(oneSquare
508 }
509
510 //Method for handling G4Polyhedron objects for
511 void G4OpenGLSceneHandler::AddPrimitive (const
512
513 // Assume all facets are planar convex quadr
514 // Draw each facet individually
515
516 if (polyhedron.GetNoFacets() == 0) return;
517
518 // Need access to data in G4OpenGLViewer. s
519 // with a virtual base class, so use dynamic
520 G4OpenGLViewer* pGLViewer = dynamic_cast<G4O
521 if (!pGLViewer) return;
522
523 // Get view parameters that the user can for
524 // attributes, thereby over-riding the curre
525 G4ViewParameters::DrawingStyle drawing_style
526
527 // Note that in stored mode, because this ca
528 // list, it is the colour _at the time of_
529 // even if the colour is changed, for examp
530 // window, current_colour does not change.
531 GLfloat* painting_colour;
532 GLfloat clear_colour[4];
533 GLfloat current_colour[4];
534 glGetFloatv (GL_CURRENT_COLOR, current_colou
535
536 G4bool isTransparent = false;
537 if (current_colour[3] < 1.) { // This objec
538 isTransparent = true;
539 }
540
541 if (drawing_style == G4ViewParameters::hlr)
542 // This is the colour used to paint surfac
543 glGetFloatv (GL_COLOR_CLEAR_VALUE, clear_c
544 painting_colour = clear_colour;
545 } else { // drawing_style == G4ViewParamete
546 painting_colour = current_colour;
547 }
548
549 G4double lineWidth = GetLineWidth(fpVisAttri
550 pGLViewer->ChangeLineWidth(lineWidth);
551
552 G4bool isAuxEdgeVisible = GetAuxEdgeVisible
553
554 G4bool clipping = pGLViewer->fVP.IsSection()
555
556 // Lighting disabled unless otherwise reques
557 glDisable (GL_LIGHTING);
558
559 switch (drawing_style) {
560 case (G4ViewParameters::hlhsr):
561 // Set up as for hidden line removal but p
562 case (G4ViewParameters::hlr):
563 glEnable (GL_STENCIL_TEST);
564 // The stencil buffer is cleared in G4Open
565 // The procedure below leaves it clear.
566 glStencilFunc (GL_ALWAYS, 0, 1);
567 glStencilOp (GL_INVERT, GL_INVERT, GL_INVE
568 glEnable (GL_DEPTH_TEST);
569 glDepthFunc (GL_LEQUAL);
570 if (isTransparent) {
571 // Transparent...
572 glColorMaterial(GL_FRONT_AND_BACK, GL_AM
573 glEnable(GL_COLOR_MATERIAL);
574 //glDisable (GL_CULL_FACE);
575 glPolygonMode (GL_FRONT_AND_BACK, GL_LIN
576 } else {
577 // Opaque...
578 if (clipping) {
579 glColorMaterial(GL_FRONT_AND_BACK, GL_
580 glEnable(GL_COLOR_MATERIAL);
581 //glDisable (GL_CULL_FACE);
582 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
583 } else {
584 glColorMaterial(GL_FRONT, GL_AMBIENT_A
585 glEnable(GL_COLOR_MATERIAL);
586 //glEnable (GL_CULL_FACE);
587 //glCullFace (GL_BACK);
588 glPolygonMode (GL_FRONT, GL_LINE);
589 }
590 }
591 break;
592 case (G4ViewParameters::hsr):
593 glEnable (GL_DEPTH_TEST);
594 glDepthFunc (GL_LEQUAL);
595 if (isTransparent) {
596 // Transparent...
597 glDepthMask (GL_FALSE); // Make depth b
598 glColorMaterial(GL_FRONT_AND_BACK, GL_AM
599 glEnable(GL_COLOR_MATERIAL);
600 //glDisable (GL_CULL_FACE);
601 glPolygonMode (GL_FRONT_AND_BACK, GL_FIL
602 } else {
603 // Opaque...
604 glDepthMask (GL_TRUE); // Make depth bu
605 if (clipping) {
606 glColorMaterial(GL_FRONT_AND_BACK, GL_
607 glEnable(GL_COLOR_MATERIAL);
608 //glDisable (GL_CULL_FACE);
609 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
610 } else {
611 glColorMaterial(GL_FRONT, GL_AMBIENT_A
612 glEnable(GL_COLOR_MATERIAL);
613 //glEnable (GL_CULL_FACE);
614 //glCullFace (GL_BACK);
615 glPolygonMode (GL_FRONT, GL_FILL);
616 }
617 }
618 if (!fProcessing2D) glEnable (GL_LIGHTING)
619 break;
620 case (G4ViewParameters::wireframe):
621 default:
622 glEnable (GL_DEPTH_TEST);
623 glDepthFunc (GL_LEQUAL); //??? was GL_A
624 //glDisable (GL_CULL_FACE);
625 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE)
626 break;
627 }
628
629 //Loop through all the facets...
630 fEdgeFlag = true;
631 glBegin (GL_QUADS);
632 glEdgeFlag (GL_TRUE);
633 G4bool notLastFace;
634 do {
635
636 //First, find vertices, edgeflags and norm
637 G4Point3D vertex[4];
638 G4int edgeFlag[4];
639 G4Normal3D normals[4];
640 G4int nEdges;
641 notLastFace = polyhedron.GetNextFacet(nEdg
642
643 //Loop through the four edges of each G4Fa
644 for(G4int edgeCount = 0; edgeCount < nEdge
645 // Check to see if edge is visible or no
646 if (isAuxEdgeVisible) {
647 edgeFlag[edgeCount] = 1;
648 }
649 if (edgeFlag[edgeCount] > 0) {
650 if (fEdgeFlag != true) {
651 glEdgeFlag (GL_TRUE);
652 fEdgeFlag = true;
653 }
654 } else {
655 if (fEdgeFlag != false) {
656 glEdgeFlag (GL_FALSE);
657 fEdgeFlag = false;
658 }
659 }
660 glNormal3d (normals[edgeCount].x(),
661 normals[edgeCount].y(),
662 normals[edgeCount].z());
663 glVertex3d (vertex[edgeCount].x(),
664 vertex[edgeCount].y(),
665 vertex[edgeCount].z());
666 }
667
668 // HepPolyhedron produces triangles too; i
669 // vertex identical to first...
670 if (nEdges == 3) {
671 G4int edgeCount = 3;
672 normals[edgeCount] = normals[0];
673 vertex[edgeCount] = vertex[0];
674 edgeFlag[edgeCount] = -1;
675 if (fEdgeFlag != false) {
676 glEdgeFlag (GL_FALSE);
677 fEdgeFlag = false;
678 }
679
680 glNormal3d (normals[edgeCount].x(),
681 normals[edgeCount].y(),
682 normals[edgeCount].z());
683 glVertex3d (vertex[edgeCount].x(),
684 vertex[edgeCount].y(),
685 vertex[edgeCount].z());
686 }
687 // Trap situation where number of edges is
688 if (nEdges > 4) {
689 G4cerr <<
690 "G4OpenGLSceneHandler::AddPrimitive(G4Polyhe
691 "\n G4Polyhedron facet with " << nEdges <<
692 }
693
694
695 // Do it all over again (twice) for hlr...
696 if (drawing_style == G4ViewParameters::hl
697 drawing_style == G4ViewParameters::hlhsr) {
698
699 glDisable(GL_COLOR_MATERIAL); // Revert
700 glEnd (); // Placed here to balance glB
701
702 // state changes below, then glBegin aga
703 // having glBegin/End pairs *inside* loop
704 // usual case of no hidden line removal.
705
706 // Lighting disabled unless otherwise re
707 glDisable (GL_LIGHTING);
708
709 // Draw through stencil...
710 glStencilFunc (GL_EQUAL, 0, 1);
711 glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
712 if (drawing_style == G4ViewParameters::h
713 if (!fProcessing2D) glEnable (GL_LIGHTING);
714 }
715 glEnable (GL_DEPTH_TEST);
716 glDepthFunc (GL_LEQUAL);
717 if (isTransparent) {
718 // Transparent...
719 glDepthMask (GL_FALSE); // Make depth buffe
720 //glDisable (GL_CULL_FACE);
721 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
722 } else {
723 // Opaque...
724 glDepthMask (GL_TRUE); // Make depth buffer
725 if (clipping) {
726 //glDisable (GL_CULL_FACE);
727 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL)
728 } else {
729 //glEnable (GL_CULL_FACE);
730 //glCullFace (GL_BACK);
731 glPolygonMode (GL_FRONT, GL_FILL);
732 }
733 }
734 if (drawing_style == G4ViewParameters::
735 if (isTransparent) {
736 // Transparent - don't paint...
737 goto end_of_drawing_through_stencil;
738 }
739 }
740 if (isTransparent) {
741 // Transparent...
742 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_
743 } else {
744 // Opaque...
745 glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFU
746 }
747 glColor4fv (painting_colour);
748 glBegin (GL_QUADS);
749 glEdgeFlag (GL_TRUE);
750 fEdgeFlag = true;
751
752 for (int edgeCount = 0; edgeCount < 4; +
753 if (edgeFlag[edgeCount] > 0) {
754 if (fEdgeFlag != true) {
755 glEdgeFlag (GL_TRUE);
756 fEdgeFlag = true;
757 }
758 } else {
759 if (fEdgeFlag != false) {
760 glEdgeFlag (GL_FALSE);
761 fEdgeFlag = false;
762 }
763 }
764 glNormal3d (normals[edgeCount].x(),
765 normals[edgeCount].y(),
766 normals[edgeCount].z());
767 glVertex3d (vertex[edgeCount].x(),
768 vertex[edgeCount].y(),
769 vertex[edgeCount].z());
770 }
771 glEnd ();
772 end_of_drawing_through_stencil:
773
774 // and once more to reset the stencil bi
775 glStencilFunc (GL_ALWAYS, 0, 1);
776 glStencilOp (GL_INVERT, GL_INVERT, GL_IN
777 glDepthFunc (GL_LEQUAL); // to make sur
778 if (isTransparent) {
779 // Transparent...
780 //glDisable (GL_CULL_FACE);
781 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
782 } else {
783 // Opaque...
784 if (clipping) {
785 //glDisable (GL_CULL_FACE);
786 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE)
787 } else {
788 //glEnable (GL_CULL_FACE);
789 //glCullFace (GL_BACK);
790 glPolygonMode (GL_FRONT, GL_LINE);
791 }
792 }
793 glDisable (GL_LIGHTING);
794 glColor4fv (current_colour);
795 fEdgeFlag = true;
796 glBegin (GL_QUADS);
797 glEdgeFlag (GL_TRUE);
798 fEdgeFlag = true;
799 for (int edgeCount = 0; edgeCount < 4; +
800 if (edgeFlag[edgeCount] > 0) {
801 if (fEdgeFlag != true) {
802 glEdgeFlag (GL_TRUE);
803 fEdgeFlag = true;
804 }
805 } else {
806 if (fEdgeFlag != false) {
807 glEdgeFlag (GL_FALSE);
808 fEdgeFlag = false;
809 }
810 }
811 glNormal3d (normals[edgeCount].x(),
812 normals[edgeCount].y(),
813 normals[edgeCount].z());
814 glVertex3d (vertex[edgeCount].x(),
815 vertex[edgeCount].y(),
816 vertex[edgeCount].z());
817 }
818 glEnd ();
819
820 glDepthFunc (GL_LEQUAL); // Revert for
821 fEdgeFlag = true;
822 glBegin (GL_QUADS); // Ready for ne
823 glEdgeFlag (GL_TRUE);
824 fEdgeFlag = true;
825 // says it ignores incomplete
826 // quadrilaterals, so final empty
827 // glBegin/End sequence should be OK.
828 }
829 } while (notLastFace);
830
831 glEnd ();
832 glDisable (GL_STENCIL_TEST); // Revert to d
833 glDepthMask (GL_TRUE); // Revert to d
834 glDisable (GL_LIGHTING); // Revert to d
835 }
836
837 void G4OpenGLSceneHandler::AddCompound(const G
838 G4VSceneHandler::AddCompound(traj); // For
839 }
840
841 void G4OpenGLSceneHandler::AddCompound(const G
842 G4VSceneHandler::AddCompound(hit); // For n
843 }
844
845 void G4OpenGLSceneHandler::AddCompound(const G
846 G4VSceneHandler::AddCompound(digi); // For
847 }
848
849 void G4OpenGLSceneHandler::AddCompound(const G
850 G4VSceneHandler::AddCompound(hits); // For
851 }
852
853 void G4OpenGLSceneHandler::AddCompound(const G
854 G4VSceneHandler::AddCompound(hits); // For
855 }
856
857 void G4OpenGLSceneHandler::AddCompound(const G
858 StandardSpecialMeshRendering(mesh);
859 }
860