source: trunk/source/visualization/OpenGL/src/G4OpenGLSceneHandler.cc@ 1239

Last change on this file since 1239 was 1238, checked in by garnier, 16 years ago

otpimisations
  • Property svn:mime-type set to text/cpp
File size: 26.9 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4OpenGLSceneHandler.cc,v 1.56 2009/10/21 15:18:43 allison Exp $
28// GEANT4 tag $Name: $
29//
30//
31// Andrew Walkden 27th March 1996
32// OpenGL stored scene - creates OpenGL display lists.
33// OpenGL immediate scene - draws immediately to buffer
34// (saving space on server).
35
36#ifdef G4VIS_BUILD_OPENGL_DRIVER
37
38// Included here - problems with HP compiler if not before other includes?
39#include "G4NURBS.hh"
40
41// Here follows a special for Mesa, the OpenGL emulator. Does not affect
42// other OpenGL's, as far as I'm aware. John Allison 18/9/96.
43#define CENTERLINE_CLPP /* CenterLine C++ workaround: */
44// Also seems to be required for HP's CC and AIX xlC, at least.
45
46#include "G4OpenGLSceneHandler.hh"
47#include "G4OpenGLViewer.hh"
48#include "G4OpenGLFontBaseStore.hh"
49#include "G4OpenGLTransform3D.hh"
50#include "G4Point3D.hh"
51#include "G4Normal3D.hh"
52#include "G4Transform3D.hh"
53#include "G4Polyline.hh"
54#include "G4Polymarker.hh"
55#include "G4Text.hh"
56#include "G4Circle.hh"
57#include "G4Square.hh"
58#include "G4VMarker.hh"
59#include "G4Polyhedron.hh"
60#include "G4VisAttributes.hh"
61#include "G4PhysicalVolumeModel.hh"
62#include "G4VPhysicalVolume.hh"
63#include "G4LogicalVolume.hh"
64#include "G4VSolid.hh"
65#include "G4Scene.hh"
66#include "G4VisExtent.hh"
67#include "G4AttHolder.hh"
68
69G4OpenGLSceneHandler::G4OpenGLSceneHandler (G4VGraphicsSystem& system,
70 G4int id,
71 const G4String& name):
72 G4VSceneHandler (system, id, name),
73 fPickName(0),
74 fProcessing2D (false),
75 fProcessingPolymarker(false)
76{}
77
78G4OpenGLSceneHandler::~G4OpenGLSceneHandler ()
79{
80 ClearStore ();
81}
82
83const GLubyte G4OpenGLSceneHandler::fStippleMaskHashed [128] = {
84 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
85 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
86 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
87 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
88 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
89 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
90 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
91 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
92 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
93 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
94 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
95 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
96 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
97 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
98 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
99 0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
100};
101
102void G4OpenGLSceneHandler::ClearAndDestroyAtts()
103{
104 std::map<GLuint, G4AttHolder*>::iterator i;
105 for (i = fPickMap.begin(); i != fPickMap.end(); ++i) delete i->second;
106 fPickMap.clear();
107}
108
109void G4OpenGLSceneHandler::PreAddSolid
110(const G4Transform3D& objectTransformation,
111 const G4VisAttributes& visAttribs)
112{
113 G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
114}
115
116void G4OpenGLSceneHandler::BeginPrimitives
117(const G4Transform3D& objectTransformation)
118{
119 G4VSceneHandler::BeginPrimitives (objectTransformation);
120}
121
122void G4OpenGLSceneHandler::EndPrimitives ()
123{
124 G4VSceneHandler::EndPrimitives ();
125}
126
127void G4OpenGLSceneHandler::BeginPrimitives2D
128(const G4Transform3D& objectTransformation)
129{
130 G4VSceneHandler::BeginPrimitives2D (objectTransformation);
131 fProcessing2D = true;
132}
133
134void G4OpenGLSceneHandler::EndPrimitives2D ()
135{
136 fProcessing2D = false;
137 G4VSceneHandler::EndPrimitives2D ();
138}
139
140const G4Polyhedron* G4OpenGLSceneHandler::CreateSectionPolyhedron ()
141{
142 // Clipping done in G4OpenGLViewer::SetView.
143 return 0;
144
145 // But...OpenGL no longer seems to reconstruct clipped edges, so,
146 // when the BooleanProcessor is up to it, abandon this and use
147 // generic clipping in G4VSceneHandler::CreateSectionPolyhedron...
148 // return G4VSceneHandler::CreateSectionPolyhedron();
149}
150
151const G4Polyhedron* G4OpenGLSceneHandler::CreateCutawayPolyhedron ()
152{
153 // Cutaway done in G4OpenGLViewer::SetView.
154 return 0;
155
156 // But...if not, when the BooleanProcessor is up to it...
157 // return G4VSceneHandler::CreateCutawayPolyhedron();
158}
159
160void G4OpenGLSceneHandler::AddPrimitive (const G4Polyline& line)
161{
162 G4int nPoints = line.size ();
163 if (nPoints <= 0) return;
164
165 // Loads G4Atts for picking...
166 if (fpViewer->GetViewParameters().IsPicking()) {
167 G4AttHolder* holder = new G4AttHolder;
168 LoadAtts(line, holder);
169 fPickMap[fPickName] = holder;
170 }
171
172 // Note: colour treated in sub-class.
173
174 if (fpViewer -> GetViewParameters ().IsMarkerNotHidden ())
175 glDisable (GL_DEPTH_TEST);
176 else {glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LESS);}
177
178 glDisable (GL_LIGHTING);
179
180 // Get vis attributes - pick up defaults if none.
181 const G4VisAttributes* pVA =
182 fpViewer -> GetApplicableVisAttributes (line.GetVisAttributes ());
183
184 G4double lineWidth = GetLineWidth(pVA);
185 glLineWidth(lineWidth);
186
187 glBegin (GL_LINE_STRIP);
188 for (G4int iPoint = 0; iPoint < nPoints; iPoint++) {
189 G4double x, y, z;
190 x = line[iPoint].x();
191 y = line[iPoint].y();
192 z = line[iPoint].z();
193 glVertex3d (x, y, z);
194 }
195 glEnd ();
196}
197
198void G4OpenGLSceneHandler::AddPrimitive (const G4Polymarker& polymarker)
199{
200#ifdef G4DEBUG_VIS_OGL
201// printf("G4OpenGLSceneHandler::AddPrimitive polymarker");
202#endif
203 G4int nPoints = polymarker.size ();
204 if (nPoints <= 0) return;
205
206 fProcessingPolymarker = true;
207
208 // Loads G4Atts for picking...
209 if (fpViewer->GetViewParameters().IsPicking()) {
210 G4AttHolder* holder = new G4AttHolder;
211 LoadAtts(polymarker, holder);
212 fPickMap[fPickName] = holder;
213 }
214
215 switch (polymarker.GetMarkerType()) {
216 default:
217 case G4Polymarker::dots:
218 {
219#ifdef G4DEBUG_VIS_OGL
220// printf(" dots ");
221#endif
222 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
223 G4Circle dot (polymarker);
224 dot.SetPosition (polymarker[iPoint]);
225 dot.SetWorldSize (0.);
226 dot.SetScreenSize (0.1); // Very small circle.
227 G4OpenGLSceneHandler::AddPrimitive (dot);
228 }
229 }
230 break;
231 case G4Polymarker::circles:
232 {
233#ifdef G4DEBUG_VIS_OGL
234// printf(" circle ");
235#endif
236 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
237 G4Circle circle (polymarker);
238 circle.SetPosition (polymarker[iPoint]);
239 G4OpenGLSceneHandler::AddPrimitive (circle);
240 }
241 }
242 break;
243 case G4Polymarker::squares:
244 {
245#ifdef G4DEBUG_VIS_OGL
246// printf(" square ");
247#endif
248 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
249 G4Square square (polymarker);
250 square.SetPosition (polymarker[iPoint]);
251 G4OpenGLSceneHandler::AddPrimitive (square);
252 }
253 }
254 break;
255 }
256
257#ifdef G4DEBUG_VIS_OGL
258// printf(" \n");
259#endif
260 fProcessingPolymarker = false;
261}
262
263void G4OpenGLSceneHandler::AddPrimitive (const G4Text& text) {
264
265 // Loads G4Atts for picking...
266 if (fpViewer->GetViewParameters().IsPicking()) {
267 G4AttHolder* holder = new G4AttHolder;
268 LoadAtts(text, holder);
269 fPickMap[fPickName] = holder;
270 }
271
272 const G4Colour& c = GetTextColour (text); // Picks up default if none.
273 MarkerSizeType sizeType;
274 G4double size = GetMarkerSize (text, sizeType);
275 G4ThreeVector position (text.GetPosition ());
276 G4String textString = text.GetText();
277
278 G4int font_base = G4OpenGLFontBaseStore::GetFontBase(fpViewer,size);
279 if (font_base < 0) {
280 static G4int callCount = 0;
281 ++callCount;
282 if (callCount <= 10 || callCount%100 == 0) {
283 G4cout <<
284 "G4OpenGLSceneHandler::AddPrimitive (const G4Text&) call count "
285 << callCount <<
286 "\n No fonts available."
287 "\n Called with text \""
288 << text.GetText ()
289 << "\"\n at " << position
290 << ", size " << size
291 << ", offsets " << text.GetXOffset () << ", " << text.GetYOffset ()
292 << ", type " << G4int(sizeType)
293 << ", colour " << c
294 << G4endl;
295 }
296 return;
297 }
298 const char* textCString = textString.c_str();
299 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
300 glDisable (GL_DEPTH_TEST);
301 glDisable (GL_LIGHTING);
302
303 glRasterPos3d(position.x(),position.y(),position.z());
304 // No action on offset or layout at present.
305 glPushAttrib(GL_LIST_BIT);
306 glListBase(font_base);
307 glCallLists(strlen(textCString), GL_UNSIGNED_BYTE, (GLubyte *)textCString);
308 glPopAttrib();
309}
310
311void G4OpenGLSceneHandler::AddPrimitive (const G4Circle& circle) {
312 glEnable (GL_POINT_SMOOTH);
313 AddCircleSquare (circle, G4OpenGLBitMapStore::circle);
314}
315
316void G4OpenGLSceneHandler::AddPrimitive (const G4Square& square) {
317 glDisable (GL_POINT_SMOOTH);
318 AddCircleSquare (square, G4OpenGLBitMapStore::square);
319}
320
321void G4OpenGLSceneHandler::AddCircleSquare
322(const G4VMarker& marker,
323 G4OpenGLBitMapStore::Shape shape) {
324
325 if (!fProcessingPolymarker) { // Polymarker has already loaded atts.
326 // Loads G4Atts for picking...
327 if (fpViewer->GetViewParameters().IsPicking()) {
328 G4AttHolder* holder = new G4AttHolder;
329 LoadAtts(marker, holder);
330 fPickMap[fPickName] = holder;
331 }
332 }
333
334 // Note: colour treated in sub-class.
335
336 if (fpViewer -> GetViewParameters ().IsMarkerNotHidden ()) {
337#ifdef G4DEBUG_VIS_OGL
338 // printf("+");
339#endif
340 glDisable (GL_DEPTH_TEST);
341 } else {
342#ifdef G4DEBUG_VIS_OGL
343 // printf("-");
344#endif
345 glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LESS);}
346
347 glDisable (GL_LIGHTING);
348
349 // Get vis attributes - pick up defaults if none.
350 const G4VisAttributes* pVA =
351 fpViewer -> GetApplicableVisAttributes (marker.GetVisAttributes ());
352
353 G4double lineWidth = GetLineWidth(pVA);
354 glLineWidth(lineWidth);
355
356 G4VMarker::FillStyle style = marker.GetFillStyle();
357
358 G4bool filled = false;
359 static G4bool hashedWarned = false;
360
361 switch (style) {
362 case G4VMarker::noFill:
363 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
364 filled = false;
365 break;
366
367 case G4VMarker::hashed:
368 if (!hashedWarned) {
369 G4cout << "Hashed fill style in G4OpenGLSceneHandler."
370 << "\n Not implemented. Using G4VMarker::filled."
371 << G4endl;
372 hashedWarned = true;
373 }
374 // Maybe use
375 //glPolygonStipple (fStippleMaskHashed);
376 // Drop through to filled...
377
378 case G4VMarker::filled:
379 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
380 filled = true;
381 break;
382
383 }
384
385 // A few useful quantities...
386 G4Point3D centre = marker.GetPosition();
387 MarkerSizeType sizeType;
388 G4double size = GetMarkerSize(marker, sizeType);
389
390
391 // Draw...
392 if (sizeType == world) { // Size specified in world coordinates.
393
394 DrawXYPolygon (shape, size, centre, pVA);
395
396 } else { // Size specified in screen (window) coordinates.
397 glPointSize (size);
398 glBegin (GL_POINTS);
399 glVertex3f(centre.x(),centre.y(),centre.z());
400 glEnd();
401 //Antialiasing
402 glEnable (GL_POINT_SMOOTH);
403 //Transparency
404 glEnable(GL_BLEND);
405 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
406
407 // L. GARNIER 1 March 2009
408 // Old method, we draw a bitmap instead of a GL_POINT.
409 // I remove it because it cost in term of computing performances
410 // and gl2ps can't draw bitmaps
411
412 // glRasterPos3d(centre.x(),centre.y(),centre.z());
413 // const GLubyte* marker =
414 // G4OpenGLBitMapStore::GetBitMap(shape, size, filled);
415 // glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
416 // glBitmap(GLsizei(size), GLsizei(size), size/2., size/2., 0., 0., marker);
417 }
418}
419
420void G4OpenGLSceneHandler::DrawXYPolygon
421(G4OpenGLBitMapStore::Shape shape,
422 G4double size,
423 const G4Point3D& centre,
424 const G4VisAttributes* pApplicableVisAtts)
425{
426 G4int nSides;
427 G4double startPhi;
428 if (shape == G4OpenGLBitMapStore::circle) {
429 nSides = GetNoOfSides(pApplicableVisAtts);
430 startPhi = 0.;
431 } else {
432 nSides = 4;
433 startPhi = -pi / 4.;
434 }
435
436 const G4Vector3D& viewpointDirection =
437 fpViewer -> GetViewParameters().GetViewpointDirection();
438 const G4Vector3D& up = fpViewer->GetViewParameters().GetUpVector();
439 const G4double dPhi = twopi / nSides;
440 const G4double radius = size / 2.;
441 G4Vector3D start = radius * (up.cross(viewpointDirection)).unit();
442 G4double phi;
443 G4int i;
444
445 glBegin (GL_POLYGON);
446 for (i = 0, phi = startPhi; i < nSides; i++, phi += dPhi) {
447 G4Vector3D r = start; r.rotate(phi, viewpointDirection);
448 G4Vector3D p = centre + r;
449 glVertex3d (p.x(), p.y(), p.z());
450 }
451 glEnd ();
452}
453
454void G4OpenGLSceneHandler::AddPrimitive (const G4Scale& scale)
455{
456 G4VSceneHandler::AddPrimitive(scale);
457}
458
459//Method for handling G4Polyhedron objects for drawing solids.
460void G4OpenGLSceneHandler::AddPrimitive (const G4Polyhedron& polyhedron) {
461
462 // Assume all facets are planar convex quadrilaterals.
463 // Draw each facet individually
464
465 if (polyhedron.GetNoFacets() == 0) return;
466
467 // Loads G4Atts for picking...
468 if (fpViewer->GetViewParameters().IsPicking()) {
469 G4AttHolder* holder = new G4AttHolder;
470 LoadAtts(polyhedron, holder);
471 fPickMap[fPickName] = holder;
472 }
473
474 // Get vis attributes - pick up defaults if none.
475 const G4VisAttributes* pVA =
476 fpViewer -> GetApplicableVisAttributes (polyhedron.GetVisAttributes ());
477
478 // Get view parameters that the user can force through the vis
479 // attributes, thereby over-riding the current view parameter.
480 G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (pVA);
481
482 //Get colour, etc...
483 G4bool transparency_enabled = true;
484 G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
485 if (pViewer) transparency_enabled = pViewer->transparency_enabled;
486 const G4Colour& c = pVA->GetColour();
487 GLfloat materialColour [4];
488 materialColour [0] = c.GetRed ();
489 materialColour [1] = c.GetGreen ();
490 materialColour [2] = c.GetBlue ();
491 if (transparency_enabled) {
492 materialColour [3] = c.GetAlpha ();
493 } else {
494 materialColour [3] = 1.;
495 }
496
497 G4double lineWidth = GetLineWidth(pVA);
498 glLineWidth(lineWidth);
499
500 GLfloat clear_colour[4];
501 glGetFloatv (GL_COLOR_CLEAR_VALUE, clear_colour);
502
503 G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pVA);
504
505 G4bool clipping = pViewer->fVP.IsSection() || pViewer->fVP.IsCutaway();
506
507 // Lighting disabled unless otherwise requested
508 glDisable (GL_LIGHTING);
509
510 switch (drawing_style) {
511 case (G4ViewParameters::hlhsr):
512 // Set up as for hidden line removal but paint polygon faces later...
513 case (G4ViewParameters::hlr):
514 glEnable (GL_STENCIL_TEST);
515 // The stencil buffer is cleared in G4OpenGLViewer::ClearView.
516 // The procedure below leaves it clear.
517 glStencilFunc (GL_ALWAYS, 0, 1);
518 glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT);
519 glEnable (GL_DEPTH_TEST);
520 glDepthFunc (GL_LEQUAL);
521 if (materialColour[3] < 1.) {
522 // Transparent...
523 glDisable (GL_CULL_FACE);
524 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
525 } else {
526 // Opaque...
527 if (clipping) {
528 glDisable (GL_CULL_FACE);
529 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
530 } else {
531 glEnable (GL_CULL_FACE);
532 glCullFace (GL_BACK);
533 glPolygonMode (GL_FRONT, GL_LINE);
534 }
535 }
536 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
537 break;
538 case (G4ViewParameters::hsr):
539 glEnable (GL_DEPTH_TEST);
540 glDepthFunc (GL_LEQUAL);
541 if (materialColour[3] < 1.) {
542 // Transparent...
543 glDepthMask (0); // Make depth buffer read-only.
544 glDisable (GL_CULL_FACE);
545 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
546 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, materialColour);
547 } else {
548 // Opaque...
549 glDepthMask (1); // Make depth buffer writable (default).
550 if (clipping) {
551 glDisable (GL_CULL_FACE);
552 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
553 } else {
554 glEnable (GL_CULL_FACE);
555 glCullFace (GL_BACK);
556 glPolygonMode (GL_FRONT, GL_FILL);
557 }
558 glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, materialColour);
559 }
560 if (!fProcessing2D) glEnable (GL_LIGHTING);
561 break;
562 case (G4ViewParameters::wireframe):
563 default:
564 glEnable (GL_DEPTH_TEST);
565 glDepthFunc (GL_LEQUAL); //??? was GL_ALWAYS
566 glDisable (GL_CULL_FACE);
567 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
568 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
569 break;
570 }
571
572 //Loop through all the facets...
573 glBegin (GL_QUADS);
574 G4bool notLastFace;
575 do {
576
577 //First, find vertices, edgeflags and normals and note "not last facet"...
578 G4Point3D vertex[4];
579 G4int edgeFlag[4];
580 G4Normal3D normals[4];
581 G4int n;
582 notLastFace = polyhedron.GetNextFacet(n, vertex, edgeFlag, normals);
583
584 //Loop through the four edges of each G4Facet...
585 G4int edgeCount = 0;
586 for(edgeCount = 0; edgeCount < n; ++edgeCount) {
587 // Check to see if edge is visible or not...
588 if (isAuxEdgeVisible) {
589 edgeFlag[edgeCount] = 1;
590 }
591 if (edgeFlag[edgeCount] > 0) {
592 glEdgeFlag (GL_TRUE);
593 } else {
594 glEdgeFlag (GL_FALSE);
595 }
596 glNormal3d (normals[edgeCount].x(),
597 normals[edgeCount].y(),
598 normals[edgeCount].z());
599 glVertex3d (vertex[edgeCount].x(),
600 vertex[edgeCount].y(),
601 vertex[edgeCount].z());
602 }
603 // HepPolyhedron produces triangles too; in that case add an extra
604 // vertex identical to first...
605 if (n == 3) {
606 edgeCount = 3;
607 normals[edgeCount] = normals[0];
608 vertex[edgeCount] = vertex[0];
609 edgeFlag[edgeCount] = -1;
610 glEdgeFlag (GL_FALSE);
611 glNormal3d (normals[edgeCount].x(),
612 normals[edgeCount].y(),
613 normals[edgeCount].z());
614 glVertex3d (vertex[edgeCount].x(),
615 vertex[edgeCount].y(),
616 vertex[edgeCount].z());
617 }
618 // Trap situation where number of edges is > 4...
619 if (n > 4) {
620 G4cerr <<
621 "G4OpenGLSceneHandler::AddPrimitive(G4Polyhedron): WARNING";
622 G4PhysicalVolumeModel* pPVModel =
623 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
624 if (pPVModel) {
625 G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
626 G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
627 G4cerr <<
628 "\n Volume " << pCurrentPV->GetName() <<
629 ", Solid " << pCurrentLV->GetSolid()->GetName() <<
630 " (" << pCurrentLV->GetSolid()->GetEntityType();
631 }
632 G4cerr<<
633 "\n G4Polyhedron facet with " << n << " edges" << G4endl;
634 }
635
636 // Do it all over again (twice) for hlr...
637 if (drawing_style == G4ViewParameters::hlr ||
638 drawing_style == G4ViewParameters::hlhsr) {
639
640 glEnd (); // Placed here to balance glBegin above, allowing GL
641 // state changes below, then glBegin again. Avoids
642 // having glBegin/End pairs *inside* loop in the more
643 // usual case of no hidden line removal.
644
645 // Lighting disabled unless otherwise requested
646 glDisable (GL_LIGHTING);
647
648 // Draw through stencil...
649 glStencilFunc (GL_EQUAL, 0, 1);
650 glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
651 if (drawing_style == G4ViewParameters::hlhsr) {
652 if (!fProcessing2D) glEnable (GL_LIGHTING);
653 }
654 glEnable (GL_DEPTH_TEST);
655 glDepthFunc (GL_LEQUAL);
656 if (materialColour[3] < 1.) {
657 // Transparent...
658 glDepthMask (0); // Make depth buffer read-only.
659 glDisable (GL_CULL_FACE);
660 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
661 } else {
662 // Opaque...
663 glDepthMask (1); // Make depth buffer writable (default).
664 if (clipping) {
665 glDisable (GL_CULL_FACE);
666 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
667 } else {
668 glEnable (GL_CULL_FACE);
669 glCullFace (GL_BACK);
670 glPolygonMode (GL_FRONT, GL_FILL);
671 }
672 }
673 GLfloat* painting_colour;
674 if (drawing_style == G4ViewParameters::hlr) {
675 if (materialColour[3] < 1.) {
676 // Transparent - don't paint...
677 goto end_of_drawing_through_stencil;
678 }
679 painting_colour = clear_colour;
680 } else { // drawing_style == G4ViewParameters::hlhsr
681 painting_colour = materialColour;
682 }
683 if (materialColour[3] < 1.) {
684 // Transparent...
685 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, painting_colour);
686 } else {
687 // Opaque...
688 glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, painting_colour);
689 }
690 glColor4fv (painting_colour);
691 glBegin (GL_QUADS);
692 for (int edgeCount = 0; edgeCount < 4; ++edgeCount) {
693 if (edgeFlag[edgeCount] > 0) {
694 glEdgeFlag (GL_TRUE);
695 } else {
696 glEdgeFlag (GL_FALSE);
697 }
698 glNormal3d (normals[edgeCount].x(),
699 normals[edgeCount].y(),
700 normals[edgeCount].z());
701 glVertex3d (vertex[edgeCount].x(),
702 vertex[edgeCount].y(),
703 vertex[edgeCount].z());
704 }
705 glEnd ();
706 end_of_drawing_through_stencil:
707
708 // and once more to reset the stencil bits...
709 glStencilFunc (GL_ALWAYS, 0, 1);
710 glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT);
711 glDepthFunc (GL_LEQUAL); // to make sure line gets drawn.
712 if (materialColour[3] < 1.) {
713 // Transparent...
714 glDisable (GL_CULL_FACE);
715 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
716 } else {
717 // Opaque...
718 if (clipping) {
719 glDisable (GL_CULL_FACE);
720 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
721 } else {
722 glEnable (GL_CULL_FACE);
723 glCullFace (GL_BACK);
724 glPolygonMode (GL_FRONT, GL_LINE);
725 }
726 }
727 glDisable (GL_LIGHTING);
728 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
729 glBegin (GL_QUADS);
730 for (int edgeCount = 0; edgeCount < 4; ++edgeCount) {
731 if (edgeFlag[edgeCount] > 0) {
732 glEdgeFlag (GL_TRUE);
733 } else {
734 glEdgeFlag (GL_FALSE);
735 }
736 glNormal3d (normals[edgeCount].x(),
737 normals[edgeCount].y(),
738 normals[edgeCount].z());
739 glVertex3d (vertex[edgeCount].x(),
740 vertex[edgeCount].y(),
741 vertex[edgeCount].z());
742 }
743 glEnd ();
744 glDepthFunc (GL_LEQUAL); // Revert for next facet.
745 glBegin (GL_QUADS); // Ready for next facet. GL
746 // says it ignores incomplete
747 // quadrilaterals, so final empty
748 // glBegin/End sequence should be OK.
749 }
750 } while (notLastFace);
751
752 glEnd ();
753 glDisable (GL_STENCIL_TEST); // Revert to default for next primitive.
754 glDepthMask (1); // Revert to default for next primitive.
755 glDisable (GL_LIGHTING); // Revert to default for next primitive.
756}
757
758//Method for handling G4NURBS objects for drawing solids.
759//Knots and Ctrl Pnts MUST be arrays of GLfloats.
760void G4OpenGLSceneHandler::AddPrimitive (const G4NURBS& nurb) {
761
762 // Loads G4Atts for picking...
763 if (fpViewer->GetViewParameters().IsPicking()) {
764 G4AttHolder* holder = new G4AttHolder;
765 LoadAtts(nurb, holder);
766 fPickMap[fPickName] = holder;
767 }
768
769 GLUnurbsObj *gl_nurb;
770 gl_nurb = gluNewNurbsRenderer ();
771
772 GLfloat *u_knot_array, *u_knot_array_ptr;
773 u_knot_array = u_knot_array_ptr = new GLfloat [nurb.GetnbrKnots(G4NURBS::U)];
774 G4NURBS::KnotsIterator u_iterator (nurb, G4NURBS::U);
775 while (u_iterator.pick (u_knot_array_ptr++)){}
776
777 GLfloat *v_knot_array, *v_knot_array_ptr;
778 v_knot_array = v_knot_array_ptr = new GLfloat [nurb.GetnbrKnots(G4NURBS::V)];
779 G4NURBS::KnotsIterator v_iterator (nurb, G4NURBS::V);
780 while (v_iterator.pick (v_knot_array_ptr++)){}
781
782 GLfloat *ctrl_pnt_array, *ctrl_pnt_array_ptr;
783 ctrl_pnt_array = ctrl_pnt_array_ptr =
784 new GLfloat [nurb.GettotalnbrCtrlPts () * G4NURBS::NofC];
785 G4NURBS::CtrlPtsCoordsIterator c_p_iterator (nurb);
786 while (c_p_iterator.pick (ctrl_pnt_array_ptr++)){}
787
788 // Get vis attributes - pick up defaults if none.
789 const G4VisAttributes* pVA =
790 fpViewer -> GetApplicableVisAttributes (nurb.GetVisAttributes ());
791
792 // Get view parameters that the user can force through the vis
793 // attributes, thereby over-riding the current view parameter.
794 G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (pVA);
795 //G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pVA);
796
797 //Get colour, etc..
798 const G4Colour& c = pVA -> GetColour ();
799
800 switch (drawing_style) {
801
802 case (G4ViewParameters::hlhsr):
803 // G4cout << "Hidden line removal not implememented in G4OpenGL.\n"
804 // << "Using hidden surface removal." << G4endl;
805 case (G4ViewParameters::hsr):
806 {
807 if (!fProcessing2D) glEnable (GL_LIGHTING);
808 glEnable (GL_DEPTH_TEST);
809 glEnable (GL_AUTO_NORMAL);
810 glEnable (GL_NORMALIZE);
811 gluNurbsProperty (gl_nurb, GLU_DISPLAY_MODE, GLU_FILL);
812 gluNurbsProperty (gl_nurb, GLU_SAMPLING_TOLERANCE, 50.0);
813 GLfloat materialColour [4];
814 materialColour [0] = c.GetRed ();
815 materialColour [1] = c.GetGreen ();
816 materialColour [2] = c.GetBlue ();
817 materialColour [3] = 1.0; // = c.GetAlpha () for transparency -
818 // but see complication in
819 // AddPrimitive(const G4Polyhedron&).
820 glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, materialColour);
821 break;
822 }
823 case (G4ViewParameters::hlr):
824 // G4cout << "Hidden line removal not implememented in G4OpenGL.\n"
825 // << "Using wireframe." << G4endl;
826 case (G4ViewParameters::wireframe):
827 default:
828 glDisable (GL_LIGHTING);
829// glDisable (GL_DEPTH_TEST);
830 glEnable (GL_DEPTH_TEST);
831 glDisable (GL_AUTO_NORMAL);
832 glDisable (GL_NORMALIZE);
833 gluNurbsProperty (gl_nurb, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);
834 gluNurbsProperty (gl_nurb, GLU_SAMPLING_TOLERANCE, 50.0);
835 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
836 break;
837 }
838
839 gluBeginSurface (gl_nurb);
840 G4int u_stride = 4;
841 G4int v_stride = nurb.GetnbrCtrlPts(G4NURBS::U) * 4;
842
843 gluNurbsSurface (gl_nurb,
844 nurb.GetnbrKnots (G4NURBS::U), (GLfloat*)u_knot_array,
845 nurb.GetnbrKnots (G4NURBS::V), (GLfloat*)v_knot_array,
846 u_stride,
847 v_stride,
848 ctrl_pnt_array,
849 nurb.GetUorder (),
850 nurb.GetVorder (),
851 GL_MAP2_VERTEX_4);
852
853 gluEndSurface (gl_nurb);
854
855 delete [] u_knot_array; // These should be allocated with smart allocators
856 delete [] v_knot_array; // to avoid memory explosion.
857 delete [] ctrl_pnt_array;
858
859 gluDeleteNurbsRenderer (gl_nurb);
860}
861
862void G4OpenGLSceneHandler::AddCompound(const G4VTrajectory& traj) {
863 G4VSceneHandler::AddCompound(traj); // For now.
864}
865
866void G4OpenGLSceneHandler::AddCompound(const G4VHit& hit) {
867 G4VSceneHandler::AddCompound(hit); // For now.
868}
869
870void G4OpenGLSceneHandler::AddCompound(const G4THitsMap<G4double>& hits) {
871 G4VSceneHandler::AddCompound(hits); // For now.
872}
873
874#endif
Note: See TracBrowser for help on using the repository browser.