source: trunk/source/visualization/OpenGL/src/G4OpenGLStoredSceneHandler.cc@ 1130

Last change on this file since 1130 was 1103, checked in by garnier, 16 years ago

modif mineure
  • Property svn:mime-type set to text/cpp
File size: 18.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: G4OpenGLStoredSceneHandler.cc,v 1.40 2009/02/04 16:48:41 lgarnier Exp $
28// GEANT4 tag $Name: $
29//
30//
31// Andrew Walkden 10th February 1997
32// OpenGL stored scene - creates OpenGL display lists.
33
34#ifdef G4VIS_BUILD_OPENGL_DRIVER
35
36// Included here - problems with HP compiler if not before other includes?
37#include "G4NURBS.hh"
38
39// Here follows a special for Mesa, the OpenGL emulator. Does not affect
40// other OpenGL's, as far as I'm aware. John Allison 18/9/96.
41#define CENTERLINE_CLPP /* CenterLine C++ workaround: */
42// Also seems to be required for HP's CC and AIX xlC, at least.
43
44#include "G4OpenGLStoredSceneHandler.hh"
45
46#include "G4PhysicalVolumeModel.hh"
47#include "G4VPhysicalVolume.hh"
48#include "G4LogicalVolume.hh"
49#include "G4Polyline.hh"
50#include "G4Polymarker.hh"
51#include "G4Text.hh"
52#include "G4Circle.hh"
53#include "G4Square.hh"
54#include "G4Polyhedron.hh"
55#include "G4AttHolder.hh"
56#include "G4OpenGLTransform3D.hh"
57#include "G4OpenGLViewer.hh"
58
59G4OpenGLStoredSceneHandler::PO::PO
60(G4int id,
61 const G4Transform3D& tr):
62 fDisplayListId(id),
63 fTransform(tr),
64 fPickName(0)
65{}
66
67G4OpenGLStoredSceneHandler::TO::TO
68(G4int id,
69 const G4Transform3D& tr):
70 fDisplayListId(id),
71 fTransform(tr),
72 fPickName(0),
73 fStartTime(-DBL_MAX),
74 fEndTime(DBL_MAX)
75{}
76
77G4OpenGLStoredSceneHandler::G4OpenGLStoredSceneHandler
78(G4VGraphicsSystem& system,
79 const G4String& name):
80G4OpenGLSceneHandler (system, fSceneIdCount++, name),
81fMemoryForDisplayLists (true),
82fAddPrimitivePreambleNestingDepth (0),
83fTopPODL (0),
84fLastPolymarker(),
85fLastPolymarkers(),
86nbDoublons(0)
87{}
88
89G4OpenGLStoredSceneHandler::~G4OpenGLStoredSceneHandler ()
90{}
91
92void G4OpenGLStoredSceneHandler::AddPrimitivePreamble(const G4Visible& visible)
93{
94 // Track nesting depth to avoid recursive calls, for example, from a
95 // G4Polymarker that invokes a G4Circle...
96 fAddPrimitivePreambleNestingDepth++;
97 if (fAddPrimitivePreambleNestingDepth > 1) return;
98
99 // Because of our need to control colour of transients (display by
100 // time fading), display lists may only cover a single primitive.
101 // So display list setup is here.
102
103 if (fpViewer->GetViewParameters().IsPicking()) {
104 fPickMap[++fPickName] = 0;
105 }
106
107 const G4Colour& c = GetColour (visible);
108
109 if (fMemoryForDisplayLists) {
110 fDisplayListId = glGenLists (1);
111 if (glGetError() == GL_OUT_OF_MEMORY) { // Could pre-allocate?
112 G4cout <<
113 "********************* WARNING! ********************"
114 "\nUnable to allocate any more display lists in OpenGL."
115 "\n Continuing drawing in IMMEDIATE MODE."
116 "\n***************************************************"
117 << G4endl;
118 fMemoryForDisplayLists = false;
119 }
120 }
121 if (fMemoryForDisplayLists) {
122 if (fReadyForTransients) {
123 TO to(fDisplayListId, *fpObjectTransformation);
124 to.fPickName = fPickName;
125 to.fColour = c;
126 const G4VisAttributes* pVA =
127 fpViewer->GetApplicableVisAttributes(visible.GetVisAttributes());
128 to.fStartTime = pVA->GetStartTime();
129 to.fEndTime = pVA->GetEndTime();
130 fTOList.push_back(to);
131 glDrawBuffer (GL_FRONT);
132 glPushMatrix();
133 G4OpenGLTransform3D oglt (*fpObjectTransformation);
134 glMultMatrixd (oglt.GetGLMatrix ());
135 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
136 glNewList (fDisplayListId, GL_COMPILE_AND_EXECUTE);
137 }
138 else {
139 PO po(fDisplayListId, *fpObjectTransformation);
140 po.fPickName = fPickName;
141 fPOList.push_back(po);
142 glNewList (fDisplayListId, GL_COMPILE);
143 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
144 }
145 } else {
146 glDrawBuffer (GL_FRONT);
147 glPushMatrix();
148 G4OpenGLTransform3D oglt (*fpObjectTransformation);
149 glMultMatrixd (oglt.GetGLMatrix ());
150 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
151 }
152
153 if (fProcessing2D) {
154 // Push current 3D world matrices and load identity to define screen
155 // coordinates...
156 glMatrixMode (GL_PROJECTION);
157 glPushMatrix();
158 glLoadIdentity();
159 glOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
160 glMatrixMode (GL_MODELVIEW);
161 glPushMatrix();
162 glLoadIdentity();
163 G4OpenGLTransform3D oglt (*fpObjectTransformation);
164 glMultMatrixd (oglt.GetGLMatrix ());
165 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
166 }
167}
168
169void G4OpenGLStoredSceneHandler::AddPrimitivePostamble()
170{
171 if (fProcessing2D) {
172 // Pop current 3D world matrices back again...
173 glMatrixMode (GL_PROJECTION);
174 glPopMatrix();
175 glMatrixMode (GL_MODELVIEW);
176 glPopMatrix();
177 }
178
179 // if ((glGetError() == GL_TABLE_TOO_LARGE) || (glGetError() == GL_OUT_OF_MEMORY)) { // Could close?
180 if (glGetError() == GL_OUT_OF_MEMORY) { // Could close?
181 G4cout <<
182 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
183 " display List for fTopPODL - try OpenGL Immediated mode."
184 << G4endl;
185 }
186 if (fMemoryForDisplayLists) {
187 glEndList();
188 if (glGetError() == GL_OUT_OF_MEMORY) { // Could close?
189 G4cout <<
190 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
191 " display List for fTopPODL - try OpenGL Immediated mode."
192 << G4endl;
193 }
194 }
195 if (fReadyForTransients || !fMemoryForDisplayLists) {
196 glPopMatrix();
197#ifdef G4DEBUG_VIS_OGL
198 // printf("G4OpenGLStoredSceneHandler::AddPrimitivePostamble glFlush\n");
199#endif
200 glFlush ();
201 glDrawBuffer (GL_BACK);
202 }
203 fAddPrimitivePreambleNestingDepth--;
204}
205
206void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polyline& polyline)
207{
208 AddPrimitivePreamble(polyline);
209 G4OpenGLSceneHandler::AddPrimitive(polyline);
210 AddPrimitivePostamble();
211}
212
213void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polymarker& polymarker)
214{
215
216#ifdef G4DEBUG_VIS_OGL
217 // printf("G4OpenGLStoredSceneHandler::AddPrimitive\n");
218#endif
219 std::vector< G4Polymarker > poly;
220 // 40,83 N03 lancement
221 // 289,69 10Gev supp doublons + bitmap 21 frame en 10 sec
222 // 343,45 10Gev full polymarker + bitmap 15 frame en 10 sec
223 // 351,67 10Gev full polymarker - bitmap 31 frame en 10 sec
224 // 257,90 10Gev supp doublons MAX - bitmap 42 frame en 10 sec 45757 markers et 16243 enleves
225 // Check
226 int reste = polymarker.size();
227 bool res = false;
228 if (fLastPolymarkers.size() > 0 ) {
229
230 // Loop new point to check
231 for (unsigned int b=0; b< polymarker.size();b++) {
232 // printf("check %d/%d\n",b,polymarker.size());
233 res= false;
234
235 // Look for stored point list
236 for (unsigned int a=0; a< fLastPolymarkers.size() ;a++) {
237 // printf("against vect %d/%d\n",a,fLastPolymarker.size());
238 std::vector < G4Polymarker > storedPoly = fLastPolymarkers[a];
239 int size= storedPoly.size()-1;
240
241 // Look for point
242 for (int aPoly=0; aPoly< size ;aPoly++) {
243 // printf("against poly %d/%d\n",aPoly,storedPoly.size());
244 if (( storedPoly[size-aPoly].GetPosition().x() == polymarker[b].x()) &&
245 ( storedPoly[size-aPoly].GetPosition().y() == polymarker[b].y()) &&
246 ( storedPoly[size-aPoly].GetPosition().z() == polymarker[b].z())) {
247 reste --;
248// res= true;
249 nbDoublons++;
250 // printf("G4OpenGLStoredSceneHandler::AddPrimitive PT %d/%d ALREADY FOUND TOT:%d. OLD pos %d/%d in %d PolyMarkerList STILL %d Marker in list. Point is %f %f %f\n",b,polymarker.size(), nbDoublons, aPoly,size,a ,reste,polymarker[b].x(),polymarker[b].y(),polymarker[b].z());
251 }
252 }
253 }
254 // Add
255 if (!res) {
256 G4Polymarker tmp;
257 tmp.SetPosition(polymarker[b]);
258 poly.push_back(tmp);
259 }
260 }
261 } else {
262 for (unsigned int b=0; b< polymarker.size();b++) {
263 G4Polymarker tmp;
264 tmp.SetPosition(polymarker[b]);
265 poly.push_back(tmp);
266 }
267 }
268 fLastPolymarkers.push_back(poly);
269#define TEST_MARKER 1
270#ifdef TEST_MARKER
271 // if it is already done
272 if (poly.size() == 1 ) {
273 // if (polymarker.size() >0) {
274 // if (( fLastPolymarker.GetPosition().x() == polymarker[0].x()) &&
275 // ( fLastPolymarker.GetPosition().y() == polymarker[0].y()) &&
276 // ( fLastPolymarker.GetPosition().z() == polymarker[0].z())) {
277 // if (fpViewer->GetViewParameters().IsPicking()) {
278 // glLoadName(++fPickName);
279 // fPickMap[fPickName] = 0;
280 // }
281 // printf("G4OpenGLStoredSceneHandler::AddPrimitive SUPPR ----------- point %f %f %f\n",polymarker[0].x(),polymarker[0].y(),polymarker[0].z());
282 const G4Colour& c = GetColour (polymarker);
283 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
284 G4OpenGLSceneHandler::AddPrimitive(poly[0]);
285 // fLastPolymarker.SetPosition(polymarker[poly]);
286 return;
287 }
288#endif
289#ifdef G4DEBUG_VIS_OGL
290 // printf("G4OpenGLStoredSceneHandler::AddPrimitive new marker list\n");
291#endif
292 AddPrimitivePreamble(polymarker);
293 G4OpenGLSceneHandler::AddPrimitive(polymarker);
294 AddPrimitivePostamble();
295// fLastPolymarker.SetPosition(polymarker[polymarker.size()-1]);
296}
297
298void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Text& text)
299{
300 // Note: colour is still handled in
301 // G4OpenGLSceneHandler::AddPrimitive(const G4Text&), so it still
302 // gets into the display list
303 AddPrimitivePreamble(text);
304 G4OpenGLSceneHandler::AddPrimitive(text);
305 AddPrimitivePostamble();
306}
307
308void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Circle& circle)
309{
310 AddPrimitivePreamble(circle);
311 G4OpenGLSceneHandler::AddPrimitive(circle);
312 AddPrimitivePostamble();
313}
314
315void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Square& square)
316{
317 AddPrimitivePreamble(square);
318 G4OpenGLSceneHandler::AddPrimitive(square);
319 AddPrimitivePostamble();
320}
321
322void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Scale& scale)
323{
324 // Let base class split into primitives.
325 G4OpenGLSceneHandler::AddPrimitive(scale);
326}
327
328void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polyhedron& polyhedron)
329{
330 // Note: colour is still handled in
331 // G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&), so it still
332 // gets into the display list
333 AddPrimitivePreamble(polyhedron);
334#ifdef G4DEBUG_VIS_OGL
335 printf("G4OpenGLStoredSceneHandler::AddPrimitive (poly?) :\n");
336#endif
337 G4OpenGLSceneHandler::AddPrimitive(polyhedron);
338 AddPrimitivePostamble();
339}
340
341void G4OpenGLStoredSceneHandler::AddPrimitive (const G4NURBS& nurbs)
342{
343 // Note: colour is still handled in
344 // G4OpenGLSceneHandler::AddPrimitive(const G4NURBS&), so it still
345 // gets into the display list
346 AddPrimitivePreamble(nurbs);
347 G4OpenGLSceneHandler::AddPrimitive(nurbs);
348 AddPrimitivePostamble();
349}
350
351void G4OpenGLStoredSceneHandler::BeginPrimitives
352(const G4Transform3D& objectTransformation)
353{
354 G4OpenGLSceneHandler::BeginPrimitives (objectTransformation);
355
356 // Display list setup moved to AddPrimitivePreamble. See notes there.
357}
358
359void G4OpenGLStoredSceneHandler::EndPrimitives ()
360{
361 G4OpenGLSceneHandler::EndPrimitives ();
362}
363
364void G4OpenGLStoredSceneHandler::BeginPrimitives2D
365(const G4Transform3D& objectTransformation)
366{
367 G4OpenGLSceneHandler::BeginPrimitives2D(objectTransformation);
368}
369
370void G4OpenGLStoredSceneHandler::EndPrimitives2D ()
371{
372 G4OpenGLSceneHandler::EndPrimitives2D ();
373}
374
375void G4OpenGLStoredSceneHandler::BeginModeling () {
376 G4VSceneHandler::BeginModeling();
377 ClearStore(); // ...and all that goes with it.
378 /* Debug...
379 fDisplayListId = glGenLists (1);
380 G4cout << "OGL::fDisplayListId (start): " << fDisplayListId << G4endl;
381 */
382}
383
384void G4OpenGLStoredSceneHandler::EndModeling () {
385 // Make a List which calls the other lists.
386#ifdef G4DEBUG_VIS_OGL
387 printf("G4OpenGLStoredSceneHandler::EndModeling Cree une nouvelle liste+++++++++++++++++++++++++++\n");
388#endif
389 fTopPODL = glGenLists (1);
390 if (glGetError() == GL_OUT_OF_MEMORY) { // Could pre-allocate?
391 G4cout <<
392 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
393 " display List for fTopPODL - try OpenGL Immediated mode."
394 << G4endl;
395 } else {
396 glNewList (fTopPODL, GL_COMPILE_AND_EXECUTE); {
397 for (size_t i = 0; i < fPOList.size (); i++) {
398 glPushMatrix();
399 G4OpenGLTransform3D oglt (fPOList[i].fTransform);
400 glMultMatrixd (oglt.GetGLMatrix ());
401 if (fpViewer->GetViewParameters().IsPicking())
402 glLoadName(fPOList[i].fPickName);
403 glCallList (fPOList[i].fDisplayListId);
404 glPopMatrix();
405 }
406 }
407 glEndList ();
408 if (glGetError() == GL_OUT_OF_MEMORY) { // Could close?
409 G4cout <<
410 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
411 " display List for fTopPODL - try OpenGL Immediated mode."
412 << G4endl;
413 }
414 }
415
416 G4VSceneHandler::EndModeling ();
417
418 /* Debug...
419 fDisplayListId = glGenLists (1);
420 G4cout << "OGL::fDisplayListId (end): " << fDisplayListId << G4endl;
421 */
422}
423
424void G4OpenGLStoredSceneHandler::ClearStore () {
425
426 G4VSceneHandler::ClearStore (); // Sets need kernel visit, etc.
427
428 // Delete OpenGL permanent display lists.
429 for (size_t i = 0; i < fPOList.size (); i++)
430 glDeleteLists (fPOList[i].fDisplayListId, 1);
431 if (fTopPODL) glDeleteLists (fTopPODL, 1);
432 fTopPODL = 0;
433
434 // Clear other lists, dictionary, etc.
435 fPOList.clear ();
436 fSolidMap.clear ();
437 ClearAndDestroyAtts();
438
439 // ...and clear transient store...
440 for (size_t i = 0; i < fTOList.size (); i++)
441 glDeleteLists(fTOList[i].fDisplayListId, 1);
442 fTOList.clear ();
443}
444
445void G4OpenGLStoredSceneHandler::ClearTransientStore () {
446
447 G4VSceneHandler::ClearTransientStore ();
448
449 // Delete OpenGL transient display lists and Transient Objects themselves.
450 for (size_t i = 0; i < fTOList.size (); i++)
451 glDeleteLists(fTOList[i].fDisplayListId, 1);
452 fTOList.clear ();
453
454 // Make sure screen corresponds to graphical database...
455 if (fpViewer) {
456#ifdef G4DEBUG_VIS_OGL
457 printf("G4OpenGLStoredSceneHandler::ClearTransientStore () BEGIN\n");
458#endif
459 fpViewer -> SetView ();
460 fpViewer -> ClearView ();
461 fpViewer -> DrawView ();
462#ifdef G4DEBUG_VIS_OGL
463 printf("G4OpenGLStoredSceneHandler::ClearTransientStore () END\n");
464#endif
465 }
466}
467
468void G4OpenGLStoredSceneHandler::RequestPrimitives (const G4VSolid& solid)
469{
470 if (fReadyForTransients) {
471 // Always draw transient solids, e.g., hits represented as solids.
472 // (As we have no control over the order of drawing of transient
473 // objects, we cannot do anything about transparent ones, as
474 // below, so always draw them.)
475 G4VSceneHandler::RequestPrimitives (solid);
476 return;
477 }
478
479 // For non-transient (run-duration) objects, ensure transparent
480 // objects are drawn last. The problem of
481 // blending/transparency/alpha is quite a tricky one - see History
482 // of opengl-V07-01-01/2/3.
483 // Get vis attributes - pick up defaults if none.
484 const G4VisAttributes* pVA =
485 fpViewer -> GetApplicableVisAttributes(fpVisAttribs);
486 const G4Colour& c = pVA -> GetColour ();
487 G4double opacity = c.GetAlpha ();
488
489 if (!fSecondPass) {
490 G4bool transparency_enabled = true;
491 G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
492 if (pViewer) transparency_enabled = pViewer->transparency_enabled;
493 if (transparency_enabled && opacity < 1.) {
494 // On first pass, transparent objects are not drawn, but flag is set...
495 fSecondPassRequested = true;
496 return;
497 }
498 }
499
500 // On second pass, opaque objects are not drwan...
501 if (fSecondPass && opacity >= 1.) return;
502
503 G4PhysicalVolumeModel* pPVModel =
504 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
505
506 if (pPVModel) {
507 // If part of the geometry hierarchy, i.e., from a
508 // G4PhysicalVolumeModel, check if a display list already exists for
509 // this solid, re-use it if possible. We could be smarter, and
510 // recognise repeated branches of the geometry hierarchy, for
511 // example. But this algorithm should be secure, I think...
512 const G4VSolid* pSolid = &solid;
513 EAxis axis = kRho;
514 G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
515 if (pCurrentPV -> IsReplicated ()) {
516 G4int nReplicas;
517 G4double width;
518 G4double offset;
519 G4bool consuming;
520 pCurrentPV->GetReplicationData(axis,nReplicas,width,offset,consuming);
521 }
522 // Provided it is not parametrised (because if so, the
523 // solid's parameters might have been changed)...
524 if (!(pCurrentPV -> IsParameterised ()) &&
525 // Provided it is not replicated radially (because if so, the
526 // solid's parameters will have been changed)...
527 !(pCurrentPV -> IsReplicated () && axis == kRho) &&
528 // ...and if the solid has already been rendered...
529 (fSolidMap.find (pSolid) != fSolidMap.end ())) {
530 fDisplayListId = fSolidMap [pSolid];
531 PO po(fDisplayListId,*fpObjectTransformation);
532 if (fpViewer->GetViewParameters().IsPicking()) {
533 G4AttHolder* holder = new G4AttHolder;
534 // Load G4Atts from G4VisAttributes, if any...
535 const G4VisAttributes* va = pPVModel->GetCurrentLV()->GetVisAttributes();
536 if (va) {
537 const std::map<G4String,G4AttDef>* vaDefs = va->GetAttDefs();
538 if (vaDefs) holder->AddAtts(va->CreateAttValues(), vaDefs);
539 }
540 // Load G4Atts from G4PhysicalVolumeModel...
541 const std::map<G4String,G4AttDef>* defs = pPVModel->GetAttDefs();
542 if (defs) holder->AddAtts(pPVModel->CreateCurrentAttValues(), defs);
543 fPickMap[++fPickName] = holder;
544 po.fPickName = fPickName;
545 }
546 fPOList.push_back(po);
547 }
548 else {
549 G4VSceneHandler::RequestPrimitives (solid);
550 fSolidMap [pSolid] = fDisplayListId;
551 }
552 return;
553 }
554
555 // Otherwise invoke base class method...
556 G4VSceneHandler::RequestPrimitives (solid);
557}
558
559G4int G4OpenGLStoredSceneHandler::fSceneIdCount = 0;
560
561#endif
Note: See TracBrowser for help on using the repository browser.