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

Last change on this file since 1167 was 1160, checked in by garnier, 16 years ago

mise en place de Vis dans UI
  • Property svn:mime-type set to text/cpp
File size: 26.5 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 G4int nPoints = polymarker.size ();
201 if (nPoints <= 0) return;
202
203 fProcessingPolymarker = true;
204
205 // Loads G4Atts for picking...
206 if (fpViewer->GetViewParameters().IsPicking()) {
207 G4AttHolder* holder = new G4AttHolder;
208 LoadAtts(polymarker, holder);
209 fPickMap[fPickName] = holder;
210 }
211
212 switch (polymarker.GetMarkerType()) {
213 default:
214 case G4Polymarker::dots:
215 {
216 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
217 G4Circle dot (polymarker);
218 dot.SetPosition (polymarker[iPoint]);
219 dot.SetWorldSize (0.);
220 dot.SetScreenSize (0.1); // Very small circle.
221 G4OpenGLSceneHandler::AddPrimitive (dot);
222 }
223 }
224 break;
225 case G4Polymarker::circles:
226 {
227 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
228 G4Circle circle (polymarker);
229 circle.SetPosition (polymarker[iPoint]);
230 G4OpenGLSceneHandler::AddPrimitive (circle);
231 }
232 }
233 break;
234 case G4Polymarker::squares:
235 {
236 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
237 G4Square square (polymarker);
238 square.SetPosition (polymarker[iPoint]);
239 G4OpenGLSceneHandler::AddPrimitive (square);
240 }
241 }
242 break;
243 }
244
245 fProcessingPolymarker = false;
246}
247
248void G4OpenGLSceneHandler::AddPrimitive (const G4Text& text) {
249
250 // Loads G4Atts for picking...
251 if (fpViewer->GetViewParameters().IsPicking()) {
252 G4AttHolder* holder = new G4AttHolder;
253 LoadAtts(text, holder);
254 fPickMap[fPickName] = holder;
255 }
256
257 const G4Colour& c = GetTextColour (text); // Picks up default if none.
258 MarkerSizeType sizeType;
259 G4double size = GetMarkerSize (text, sizeType);
260 G4ThreeVector position (text.GetPosition ());
261 G4String textString = text.GetText();
262
263 G4int font_base = G4OpenGLFontBaseStore::GetFontBase(fpViewer,size);
264 if (font_base < 0) {
265 static G4int callCount = 0;
266 ++callCount;
267 if (callCount <= 10 || callCount%100 == 0) {
268 G4cout <<
269 "G4OpenGLSceneHandler::AddPrimitive (const G4Text&) call count "
270 << callCount <<
271 "\n No fonts available."
272 "\n Called with text \""
273 << text.GetText ()
274 << "\"\n at " << position
275 << ", size " << size
276 << ", offsets " << text.GetXOffset () << ", " << text.GetYOffset ()
277 << ", type " << G4int(sizeType)
278 << ", colour " << c
279 << G4endl;
280 }
281 return;
282 }
283 const char* textCString = textString.c_str();
284 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
285 glDisable (GL_DEPTH_TEST);
286 glDisable (GL_LIGHTING);
287
288 glRasterPos3d(position.x(),position.y(),position.z());
289 // No action on offset or layout at present.
290 glPushAttrib(GL_LIST_BIT);
291 glListBase(font_base);
292 glCallLists(strlen(textCString), GL_UNSIGNED_BYTE, (GLubyte *)textCString);
293 glPopAttrib();
294}
295
296void G4OpenGLSceneHandler::AddPrimitive (const G4Circle& circle) {
297 glEnable (GL_POINT_SMOOTH);
298 AddCircleSquare (circle, G4OpenGLBitMapStore::circle);
299}
300
301void G4OpenGLSceneHandler::AddPrimitive (const G4Square& square) {
302 glDisable (GL_POINT_SMOOTH);
303 AddCircleSquare (square, G4OpenGLBitMapStore::square);
304}
305
306void G4OpenGLSceneHandler::AddCircleSquare
307(const G4VMarker& marker,
308 G4OpenGLBitMapStore::Shape shape) {
309
310 if (!fProcessingPolymarker) { // Polymarker has already loaded atts.
311 // Loads G4Atts for picking...
312 if (fpViewer->GetViewParameters().IsPicking()) {
313 G4AttHolder* holder = new G4AttHolder;
314 LoadAtts(marker, holder);
315 fPickMap[fPickName] = holder;
316 }
317 }
318
319 // Note: colour treated in sub-class.
320
321 if (fpViewer -> GetViewParameters ().IsMarkerNotHidden ())
322 glDisable (GL_DEPTH_TEST);
323 else {glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LESS);}
324
325 glDisable (GL_LIGHTING);
326
327 // Get vis attributes - pick up defaults if none.
328 const G4VisAttributes* pVA =
329 fpViewer -> GetApplicableVisAttributes (marker.GetVisAttributes ());
330
331 G4double lineWidth = GetLineWidth(pVA);
332 glLineWidth(lineWidth);
333
334 G4VMarker::FillStyle style = marker.GetFillStyle();
335
336 G4bool filled = false;
337 static G4bool hashedWarned = false;
338
339 switch (style) {
340 case G4VMarker::noFill:
341 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
342 filled = false;
343 break;
344
345 case G4VMarker::hashed:
346 if (!hashedWarned) {
347 G4cout << "Hashed fill style in G4OpenGLSceneHandler."
348 << "\n Not implemented. Using G4VMarker::filled."
349 << G4endl;
350 hashedWarned = true;
351 }
352 // Maybe use
353 //glPolygonStipple (fStippleMaskHashed);
354 // Drop through to filled...
355
356 case G4VMarker::filled:
357 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
358 filled = true;
359 break;
360
361 }
362
363 // A few useful quantities...
364 G4Point3D centre = marker.GetPosition();
365 MarkerSizeType sizeType;
366 G4double size = GetMarkerSize(marker, sizeType);
367
368 // Draw...
369 if (sizeType == world) { // Size specified in world coordinates.
370
371 DrawXYPolygon (shape, size, centre, pVA);
372
373 } else { // Size specified in screen (window) coordinates.
374 glPointSize (size);
375 glBegin (GL_POINTS);
376 glVertex3f(centre.x(),centre.y(),centre.z());
377 glEnd();
378 //Antialiasing
379 glEnable (GL_POINT_SMOOTH);
380 //Transparency
381 glEnable(GL_BLEND);
382 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
383
384 // L. GARNIER 1 March 2009
385 // Old method, we draw a bitmap instead of a GL_POINT.
386 // I remove it because it cost in term of computing performances
387 // and gl2ps can't draw bitmaps
388
389 // glRasterPos3d(centre.x(),centre.y(),centre.z());
390 // const GLubyte* marker =
391 // G4OpenGLBitMapStore::GetBitMap(shape, size, filled);
392 // glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
393 // glBitmap(GLsizei(size), GLsizei(size), size/2., size/2., 0., 0., marker);
394 }
395}
396
397void G4OpenGLSceneHandler::DrawXYPolygon
398(G4OpenGLBitMapStore::Shape shape,
399 G4double size,
400 const G4Point3D& centre,
401 const G4VisAttributes* pApplicableVisAtts)
402{
403 G4int nSides;
404 G4double startPhi;
405 if (shape == G4OpenGLBitMapStore::circle) {
406 nSides = GetNoOfSides(pApplicableVisAtts);
407 startPhi = 0.;
408 } else {
409 nSides = 4;
410 startPhi = -pi / 4.;
411 }
412
413 const G4Vector3D& viewpointDirection =
414 fpViewer -> GetViewParameters().GetViewpointDirection();
415 const G4Vector3D& up = fpViewer->GetViewParameters().GetUpVector();
416 const G4double dPhi = twopi / nSides;
417 const G4double radius = size / 2.;
418 G4Vector3D start = radius * (up.cross(viewpointDirection)).unit();
419 G4double phi;
420 G4int i;
421
422 glBegin (GL_POLYGON);
423 for (i = 0, phi = startPhi; i < nSides; i++, phi += dPhi) {
424 G4Vector3D r = start; r.rotate(phi, viewpointDirection);
425 G4Vector3D p = centre + r;
426 glVertex3d (p.x(), p.y(), p.z());
427 }
428 glEnd ();
429}
430
431void G4OpenGLSceneHandler::AddPrimitive (const G4Scale& scale)
432{
433 G4VSceneHandler::AddPrimitive(scale);
434}
435
436//Method for handling G4Polyhedron objects for drawing solids.
437void G4OpenGLSceneHandler::AddPrimitive (const G4Polyhedron& polyhedron) {
438
439 // Assume all facets are planar convex quadrilaterals.
440 // Draw each facet individually
441
442 if (polyhedron.GetNoFacets() == 0) return;
443
444 // Loads G4Atts for picking...
445 if (fpViewer->GetViewParameters().IsPicking()) {
446 G4AttHolder* holder = new G4AttHolder;
447 LoadAtts(polyhedron, holder);
448 fPickMap[fPickName] = holder;
449 }
450
451 // Get vis attributes - pick up defaults if none.
452 const G4VisAttributes* pVA =
453 fpViewer -> GetApplicableVisAttributes (polyhedron.GetVisAttributes ());
454
455 // Get view parameters that the user can force through the vis
456 // attributes, thereby over-riding the current view parameter.
457 G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (pVA);
458
459 //Get colour, etc...
460 G4bool transparency_enabled = true;
461 G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
462 if (pViewer) transparency_enabled = pViewer->transparency_enabled;
463 const G4Colour& c = pVA->GetColour();
464 GLfloat materialColour [4];
465 materialColour [0] = c.GetRed ();
466 materialColour [1] = c.GetGreen ();
467 materialColour [2] = c.GetBlue ();
468 if (transparency_enabled) {
469 materialColour [3] = c.GetAlpha ();
470 } else {
471 materialColour [3] = 1.;
472 }
473
474 G4double lineWidth = GetLineWidth(pVA);
475 glLineWidth(lineWidth);
476
477 GLfloat clear_colour[4];
478 glGetFloatv (GL_COLOR_CLEAR_VALUE, clear_colour);
479
480 G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pVA);
481
482 G4bool clipping = pViewer->fVP.IsSection() || pViewer->fVP.IsCutaway();
483
484 // Lighting disabled unless otherwise requested
485 glDisable (GL_LIGHTING);
486
487 switch (drawing_style) {
488 case (G4ViewParameters::hlhsr):
489 // Set up as for hidden line removal but paint polygon faces later...
490 case (G4ViewParameters::hlr):
491 glEnable (GL_STENCIL_TEST);
492 // The stencil buffer is cleared in G4OpenGLViewer::ClearView.
493 // The procedure below leaves it clear.
494 glStencilFunc (GL_ALWAYS, 0, 1);
495 glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT);
496 glEnable (GL_DEPTH_TEST);
497 glDepthFunc (GL_LEQUAL);
498 if (materialColour[3] < 1.) {
499 // Transparent...
500 glDisable (GL_CULL_FACE);
501 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
502 } else {
503 // Opaque...
504 if (clipping) {
505 glDisable (GL_CULL_FACE);
506 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
507 } else {
508 glEnable (GL_CULL_FACE);
509 glCullFace (GL_BACK);
510 glPolygonMode (GL_FRONT, GL_LINE);
511 }
512 }
513 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
514 break;
515 case (G4ViewParameters::hsr):
516 glEnable (GL_DEPTH_TEST);
517 glDepthFunc (GL_LEQUAL);
518 if (materialColour[3] < 1.) {
519 // Transparent...
520 glDepthMask (0); // Make depth buffer read-only.
521 glDisable (GL_CULL_FACE);
522 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
523 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, materialColour);
524 } else {
525 // Opaque...
526 glDepthMask (1); // Make depth buffer writable (default).
527 if (clipping) {
528 glDisable (GL_CULL_FACE);
529 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
530 } else {
531 glEnable (GL_CULL_FACE);
532 glCullFace (GL_BACK);
533 glPolygonMode (GL_FRONT, GL_FILL);
534 }
535 glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, materialColour);
536 }
537 if (!fProcessing2D) glEnable (GL_LIGHTING);
538 break;
539 case (G4ViewParameters::wireframe):
540 default:
541 glEnable (GL_DEPTH_TEST);
542 glDepthFunc (GL_LEQUAL); //??? was GL_ALWAYS
543 glDisable (GL_CULL_FACE);
544 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
545 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
546 break;
547 }
548
549 //Loop through all the facets...
550 glBegin (GL_QUADS);
551 G4bool notLastFace;
552 do {
553
554 //First, find vertices, edgeflags and normals and note "not last facet"...
555 G4Point3D vertex[4];
556 G4int edgeFlag[4];
557 G4Normal3D normals[4];
558 G4int n;
559 notLastFace = polyhedron.GetNextFacet(n, vertex, edgeFlag, normals);
560
561 //Loop through the four edges of each G4Facet...
562 G4int edgeCount = 0;
563 for(edgeCount = 0; edgeCount < n; ++edgeCount) {
564 // Check to see if edge is visible or not...
565 if (isAuxEdgeVisible) {
566 edgeFlag[edgeCount] = 1;
567 }
568 if (edgeFlag[edgeCount] > 0) {
569 glEdgeFlag (GL_TRUE);
570 } else {
571 glEdgeFlag (GL_FALSE);
572 }
573 glNormal3d (normals[edgeCount].x(),
574 normals[edgeCount].y(),
575 normals[edgeCount].z());
576 glVertex3d (vertex[edgeCount].x(),
577 vertex[edgeCount].y(),
578 vertex[edgeCount].z());
579 }
580 // HepPolyhedron produces triangles too; in that case add an extra
581 // vertex identical to first...
582 if (n == 3) {
583 edgeCount = 3;
584 normals[edgeCount] = normals[0];
585 vertex[edgeCount] = vertex[0];
586 edgeFlag[edgeCount] = -1;
587 glEdgeFlag (GL_FALSE);
588 glNormal3d (normals[edgeCount].x(),
589 normals[edgeCount].y(),
590 normals[edgeCount].z());
591 glVertex3d (vertex[edgeCount].x(),
592 vertex[edgeCount].y(),
593 vertex[edgeCount].z());
594 }
595 // Trap situation where number of edges is > 4...
596 if (n > 4) {
597 G4cerr <<
598 "G4OpenGLSceneHandler::AddPrimitive(G4Polyhedron): WARNING";
599 G4PhysicalVolumeModel* pPVModel =
600 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
601 if (pPVModel) {
602 G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
603 G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
604 G4cerr <<
605 "\n Volume " << pCurrentPV->GetName() <<
606 ", Solid " << pCurrentLV->GetSolid()->GetName() <<
607 " (" << pCurrentLV->GetSolid()->GetEntityType();
608 }
609 G4cerr<<
610 "\n G4Polyhedron facet with " << n << " edges" << G4endl;
611 }
612
613 // Do it all over again (twice) for hlr...
614 if (drawing_style == G4ViewParameters::hlr ||
615 drawing_style == G4ViewParameters::hlhsr) {
616
617 glEnd (); // Placed here to balance glBegin above, allowing GL
618 // state changes below, then glBegin again. Avoids
619 // having glBegin/End pairs *inside* loop in the more
620 // usual case of no hidden line removal.
621
622 // Lighting disabled unless otherwise requested
623 glDisable (GL_LIGHTING);
624
625 // Draw through stencil...
626 glStencilFunc (GL_EQUAL, 0, 1);
627 glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
628 if (drawing_style == G4ViewParameters::hlhsr) {
629 if (!fProcessing2D) glEnable (GL_LIGHTING);
630 }
631 glEnable (GL_DEPTH_TEST);
632 glDepthFunc (GL_LEQUAL);
633 if (materialColour[3] < 1.) {
634 // Transparent...
635 glDepthMask (0); // Make depth buffer read-only.
636 glDisable (GL_CULL_FACE);
637 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
638 } else {
639 // Opaque...
640 glDepthMask (1); // Make depth buffer writable (default).
641 if (clipping) {
642 glDisable (GL_CULL_FACE);
643 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
644 } else {
645 glEnable (GL_CULL_FACE);
646 glCullFace (GL_BACK);
647 glPolygonMode (GL_FRONT, GL_FILL);
648 }
649 }
650 GLfloat* painting_colour;
651 if (drawing_style == G4ViewParameters::hlr) {
652 if (materialColour[3] < 1.) {
653 // Transparent - don't paint...
654 goto end_of_drawing_through_stencil;
655 }
656 painting_colour = clear_colour;
657 } else { // drawing_style == G4ViewParameters::hlhsr
658 painting_colour = materialColour;
659 }
660 if (materialColour[3] < 1.) {
661 // Transparent...
662 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, painting_colour);
663 } else {
664 // Opaque...
665 glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, painting_colour);
666 }
667 glColor4fv (painting_colour);
668 glBegin (GL_QUADS);
669 for (int edgeCount = 0; edgeCount < 4; ++edgeCount) {
670 if (edgeFlag[edgeCount] > 0) {
671 glEdgeFlag (GL_TRUE);
672 } else {
673 glEdgeFlag (GL_FALSE);
674 }
675 glNormal3d (normals[edgeCount].x(),
676 normals[edgeCount].y(),
677 normals[edgeCount].z());
678 glVertex3d (vertex[edgeCount].x(),
679 vertex[edgeCount].y(),
680 vertex[edgeCount].z());
681 }
682 glEnd ();
683 end_of_drawing_through_stencil:
684
685 // and once more to reset the stencil bits...
686 glStencilFunc (GL_ALWAYS, 0, 1);
687 glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT);
688 glDepthFunc (GL_LEQUAL); // to make sure line gets drawn.
689 if (materialColour[3] < 1.) {
690 // Transparent...
691 glDisable (GL_CULL_FACE);
692 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
693 } else {
694 // Opaque...
695 if (clipping) {
696 glDisable (GL_CULL_FACE);
697 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
698 } else {
699 glEnable (GL_CULL_FACE);
700 glCullFace (GL_BACK);
701 glPolygonMode (GL_FRONT, GL_LINE);
702 }
703 }
704 glDisable (GL_LIGHTING);
705 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
706 glBegin (GL_QUADS);
707 for (int edgeCount = 0; edgeCount < 4; ++edgeCount) {
708 if (edgeFlag[edgeCount] > 0) {
709 glEdgeFlag (GL_TRUE);
710 } else {
711 glEdgeFlag (GL_FALSE);
712 }
713 glNormal3d (normals[edgeCount].x(),
714 normals[edgeCount].y(),
715 normals[edgeCount].z());
716 glVertex3d (vertex[edgeCount].x(),
717 vertex[edgeCount].y(),
718 vertex[edgeCount].z());
719 }
720 glEnd ();
721 glDepthFunc (GL_LEQUAL); // Revert for next facet.
722 glBegin (GL_QUADS); // Ready for next facet. GL
723 // says it ignores incomplete
724 // quadrilaterals, so final empty
725 // glBegin/End sequence should be OK.
726 }
727 } while (notLastFace);
728
729 glEnd ();
730 glDisable (GL_STENCIL_TEST); // Revert to default for next primitive.
731 glDepthMask (1); // Revert to default for next primitive.
732 glDisable (GL_LIGHTING); // Revert to default for next primitive.
733}
734
735//Method for handling G4NURBS objects for drawing solids.
736//Knots and Ctrl Pnts MUST be arrays of GLfloats.
737void G4OpenGLSceneHandler::AddPrimitive (const G4NURBS& nurb) {
738
739 // Loads G4Atts for picking...
740 if (fpViewer->GetViewParameters().IsPicking()) {
741 G4AttHolder* holder = new G4AttHolder;
742 LoadAtts(nurb, holder);
743 fPickMap[fPickName] = holder;
744 }
745
746 GLUnurbsObj *gl_nurb;
747 gl_nurb = gluNewNurbsRenderer ();
748
749 GLfloat *u_knot_array, *u_knot_array_ptr;
750 u_knot_array = u_knot_array_ptr = new GLfloat [nurb.GetnbrKnots(G4NURBS::U)];
751 G4NURBS::KnotsIterator u_iterator (nurb, G4NURBS::U);
752 while (u_iterator.pick (u_knot_array_ptr++)){}
753
754 GLfloat *v_knot_array, *v_knot_array_ptr;
755 v_knot_array = v_knot_array_ptr = new GLfloat [nurb.GetnbrKnots(G4NURBS::V)];
756 G4NURBS::KnotsIterator v_iterator (nurb, G4NURBS::V);
757 while (v_iterator.pick (v_knot_array_ptr++)){}
758
759 GLfloat *ctrl_pnt_array, *ctrl_pnt_array_ptr;
760 ctrl_pnt_array = ctrl_pnt_array_ptr =
761 new GLfloat [nurb.GettotalnbrCtrlPts () * G4NURBS::NofC];
762 G4NURBS::CtrlPtsCoordsIterator c_p_iterator (nurb);
763 while (c_p_iterator.pick (ctrl_pnt_array_ptr++)){}
764
765 // Get vis attributes - pick up defaults if none.
766 const G4VisAttributes* pVA =
767 fpViewer -> GetApplicableVisAttributes (nurb.GetVisAttributes ());
768
769 // Get view parameters that the user can force through the vis
770 // attributes, thereby over-riding the current view parameter.
771 G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (pVA);
772 //G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pVA);
773
774 //Get colour, etc..
775 const G4Colour& c = pVA -> GetColour ();
776
777 switch (drawing_style) {
778
779 case (G4ViewParameters::hlhsr):
780 // G4cout << "Hidden line removal not implememented in G4OpenGL.\n"
781 // << "Using hidden surface removal." << G4endl;
782 case (G4ViewParameters::hsr):
783 {
784 if (!fProcessing2D) glEnable (GL_LIGHTING);
785 glEnable (GL_DEPTH_TEST);
786 glEnable (GL_AUTO_NORMAL);
787 glEnable (GL_NORMALIZE);
788 gluNurbsProperty (gl_nurb, GLU_DISPLAY_MODE, GLU_FILL);
789 gluNurbsProperty (gl_nurb, GLU_SAMPLING_TOLERANCE, 50.0);
790 GLfloat materialColour [4];
791 materialColour [0] = c.GetRed ();
792 materialColour [1] = c.GetGreen ();
793 materialColour [2] = c.GetBlue ();
794 materialColour [3] = 1.0; // = c.GetAlpha () for transparency -
795 // but see complication in
796 // AddPrimitive(const G4Polyhedron&).
797 glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, materialColour);
798 break;
799 }
800 case (G4ViewParameters::hlr):
801 // G4cout << "Hidden line removal not implememented in G4OpenGL.\n"
802 // << "Using wireframe." << G4endl;
803 case (G4ViewParameters::wireframe):
804 default:
805 glDisable (GL_LIGHTING);
806// glDisable (GL_DEPTH_TEST);
807 glEnable (GL_DEPTH_TEST);
808 glDisable (GL_AUTO_NORMAL);
809 glDisable (GL_NORMALIZE);
810 gluNurbsProperty (gl_nurb, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);
811 gluNurbsProperty (gl_nurb, GLU_SAMPLING_TOLERANCE, 50.0);
812 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
813 break;
814 }
815
816 gluBeginSurface (gl_nurb);
817 G4int u_stride = 4;
818 G4int v_stride = nurb.GetnbrCtrlPts(G4NURBS::U) * 4;
819
820 gluNurbsSurface (gl_nurb,
821 nurb.GetnbrKnots (G4NURBS::U), (GLfloat*)u_knot_array,
822 nurb.GetnbrKnots (G4NURBS::V), (GLfloat*)v_knot_array,
823 u_stride,
824 v_stride,
825 ctrl_pnt_array,
826 nurb.GetUorder (),
827 nurb.GetVorder (),
828 GL_MAP2_VERTEX_4);
829
830 gluEndSurface (gl_nurb);
831
832 delete [] u_knot_array; // These should be allocated with smart allocators
833 delete [] v_knot_array; // to avoid memory explosion.
834 delete [] ctrl_pnt_array;
835
836 gluDeleteNurbsRenderer (gl_nurb);
837}
838
839void G4OpenGLSceneHandler::AddCompound(const G4VTrajectory& traj) {
840 G4VSceneHandler::AddCompound(traj); // For now.
841}
842
843void G4OpenGLSceneHandler::AddCompound(const G4VHit& hit) {
844 G4VSceneHandler::AddCompound(hit); // For now.
845}
846
847void G4OpenGLSceneHandler::AddCompound(const G4THitsMap<G4double>& hits) {
848 G4VSceneHandler::AddCompound(hits); // For now.
849}
850
851#endif
Note: See TracBrowser for help on using the repository browser.