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

Last change on this file since 1349 was 1348, checked in by garnier, 15 years ago

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