source: trunk/source/visualization/OpenGL/src/G4OpenGLStoredSceneHandler.cc~@ 1357

Last change on this file since 1357 was 1350, checked in by garnier, 15 years ago

update to last version 4.9.4
File size: 16.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: G4OpenGLStoredSceneHandler.cc,v 1.46 2010/11/10 17:11:20 allison 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),
81fAddPrimitivePreambleNestingDepth (0),
82fTopPODL (0)
83{}
84
85G4OpenGLStoredSceneHandler::~G4OpenGLStoredSceneHandler ()
86{}
87
88void G4OpenGLStoredSceneHandler::AddPrimitivePreamble(const G4Visible& visible)
89{
90 // Track nesting depth to avoid recursive calls, for example, from a
91 // G4Polymarker that invokes a G4Circle...
92 fAddPrimitivePreambleNestingDepth++;
93 if (fAddPrimitivePreambleNestingDepth > 1) return;
94
95 // Because of our need to control colour of transients (display by
96 // time fading), display lists may only cover a single primitive.
97 // So display list setup is here.
98
99 if (fpViewer->GetViewParameters().IsPicking()) {
100 fPickMap[++fPickName] = 0;
101 }
102
103 const G4Colour& c = GetColour (visible);
104
105 if (fMemoryForDisplayLists) {
106 fDisplayListId = glGenLists (1);
107#ifdef G4DEBUG_VIS_OGL
108 printf("G4OpenGLStoredSceneHandler::AddPrimitivePreamble ->glGenList(1) : %d\n",fDisplayListId);
109#endif
110 if (glGetError() == GL_OUT_OF_MEMORY ||
111 fDisplayListId > fDisplayListLimit) {
112 G4cout <<
113 "********************* WARNING! ********************"
114 "\n* Display list limit reached in OpenGL."
115 "\n* Continuing drawing WITHOUT STORING. Scene only partially refreshable."
116 "\n* Current limit: " << fDisplayListLimit <<
117 ". Change with \"/vis/ogl/set/displayListLimit\"."
118 "\n***************************************************"
119 << G4endl;
120 fMemoryForDisplayLists = false;
121 }
122 }
123 if (fMemoryForDisplayLists) {
124 if (fReadyForTransients) {
125 TO to(fDisplayListId, *fpObjectTransformation);
126 to.fPickName = fPickName;
127 to.fColour = c;
128 const G4VisAttributes* pVA =
129 fpViewer->GetApplicableVisAttributes(visible.GetVisAttributes());
130 to.fStartTime = pVA->GetStartTime();
131 to.fEndTime = pVA->GetEndTime();
132 fTOList.push_back(to);
133 glDrawBuffer (GL_FRONT);
134 glPushMatrix();
135 G4OpenGLTransform3D oglt (*fpObjectTransformation);
136 glMultMatrixd (oglt.GetGLMatrix ());
137 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
138 glNewList (fDisplayListId, GL_COMPILE_AND_EXECUTE);
139 }
140 else {
141 PO po(fDisplayListId, *fpObjectTransformation);
142 po.fPickName = fPickName;
143 fPOList.push_back(po);
144 glNewList (fDisplayListId, GL_COMPILE);
145 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
146 }
147 } else {
148 glDrawBuffer (GL_FRONT);
149 glPushMatrix();
150 G4OpenGLTransform3D oglt (*fpObjectTransformation);
151 glMultMatrixd (oglt.GetGLMatrix ());
152 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
153 }
154
155 if (fProcessing2D) {
156 // Push current 3D world matrices and load identity to define screen
157 // coordinates...
158 glMatrixMode (GL_PROJECTION);
159 glPushMatrix();
160 glLoadIdentity();
161 glOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
162 glMatrixMode (GL_MODELVIEW);
163 glPushMatrix();
164 glLoadIdentity();
165 G4OpenGLTransform3D oglt (*fpObjectTransformation);
166 glMultMatrixd (oglt.GetGLMatrix ());
167 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
168 }
169}
170
171void G4OpenGLStoredSceneHandler::AddPrimitivePostamble()
172{
173 if (fProcessing2D) {
174 // Pop current 3D world matrices back again...
175 glMatrixMode (GL_PROJECTION);
176 glPopMatrix();
177 glMatrixMode (GL_MODELVIEW);
178 glPopMatrix();
179 }
180
181 // if ((glGetError() == GL_TABLE_TOO_LARGE) || (glGetError() == GL_OUT_OF_MEMORY)) { // Could close?
182 if (glGetError() == GL_OUT_OF_MEMORY) { // Could close?
183 G4cout <<
184 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
185 " display List for fTopPODL - try OpenGL Immediated mode."
186 << G4endl;
187 }
188 if (fMemoryForDisplayLists) {
189 glEndList();
190 if (glGetError() == GL_OUT_OF_MEMORY) { // Could close?
191 G4cout <<
192 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
193 " display List for fTopPODL - try OpenGL Immediated mode."
194 << G4endl;
195 }
196 }
197 if (fReadyForTransients || !fMemoryForDisplayLists) {
198 glPopMatrix();
199 glFlush ();
200 glDrawBuffer (GL_BACK);
201 }
202 fAddPrimitivePreambleNestingDepth--;
203}
204
205void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polyline& polyline)
206{
207#ifdef G4DEBUG_VIS_OGL
208 printf("G4OpenGLStoredSceneHandler::AddPrimitive polyline\n");
209#endif
210 AddPrimitivePreamble(polyline);
211 G4OpenGLSceneHandler::AddPrimitive(polyline);
212 AddPrimitivePostamble();
213}
214
215void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polymarker& polymarker)
216{
217#ifdef G4DEBUG_VIS_OGL
218 printf("G4OpenGLStoredSceneHandler::AddPrimitive polymarker\n");
219#endif
220 AddPrimitivePreamble(polymarker);
221 G4OpenGLSceneHandler::AddPrimitive(polymarker);
222 AddPrimitivePostamble();
223}
224
225void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Text& text)
226{
227 // Note: colour is still handled in
228 // G4OpenGLSceneHandler::AddPrimitive(const G4Text&), so it still
229 // gets into the display list
230#ifdef G4DEBUG_VIS_OGL
231 printf("G4OpenGLStoredSceneHandler::AddPrimitive Text\n");
232#endif
233 AddPrimitivePreamble(text);
234 G4OpenGLSceneHandler::AddPrimitive(text);
235 AddPrimitivePostamble();
236}
237
238void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Circle& circle)
239{
240#ifdef G4DEBUG_VIS_OGL
241 printf("G4OpenGLStoredSceneHandler::AddPrimitive circle\n");
242#endif
243 AddPrimitivePreamble(circle);
244 G4OpenGLSceneHandler::AddPrimitive(circle);
245 AddPrimitivePostamble();
246}
247
248void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Square& square)
249{
250#ifdef G4DEBUG_VIS_OGL
251 printf("G4OpenGLStoredSceneHandler::AddPrimitive square\n");
252#endif
253 AddPrimitivePreamble(square);
254 G4OpenGLSceneHandler::AddPrimitive(square);
255 AddPrimitivePostamble();
256}
257
258void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Scale& scale)
259{
260 // Let base class split into primitives.
261 G4OpenGLSceneHandler::AddPrimitive(scale);
262}
263
264void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polyhedron& polyhedron)
265{
266 // Note: colour is still handled in
267 // G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&), so it still
268 // gets into the display list
269#ifdef G4DEBUG_VIS_OGL
270 printf("G4OpenGLStoredSceneHandler::AddPrimitive polyhedron\n");
271#endif
272 AddPrimitivePreamble(polyhedron);
273 G4OpenGLSceneHandler::AddPrimitive(polyhedron);
274 AddPrimitivePostamble();
275}
276
277void G4OpenGLStoredSceneHandler::AddPrimitive (const G4NURBS& nurbs)
278{
279 // Note: colour is still handled in
280 // G4OpenGLSceneHandler::AddPrimitive(const G4NURBS&), so it still
281 // gets into the display list
282#ifdef G4DEBUG_VIS_OGL
283 printf("G4OpenGLStoredSceneHandler::AddPrimitive nurbs\n");
284#endif
285 AddPrimitivePreamble(nurbs);
286 G4OpenGLSceneHandler::AddPrimitive(nurbs);
287 AddPrimitivePostamble();
288}
289
290void G4OpenGLStoredSceneHandler::BeginPrimitives
291(const G4Transform3D& objectTransformation)
292{
293 G4OpenGLSceneHandler::BeginPrimitives (objectTransformation);
294
295 // Display list setup moved to AddPrimitivePreamble. See notes there.
296}
297
298void G4OpenGLStoredSceneHandler::EndPrimitives ()
299{
300 G4OpenGLSceneHandler::EndPrimitives ();
301}
302
303void G4OpenGLStoredSceneHandler::BeginPrimitives2D
304(const G4Transform3D& objectTransformation)
305{
306 G4OpenGLSceneHandler::BeginPrimitives2D(objectTransformation);
307}
308
309void G4OpenGLStoredSceneHandler::EndPrimitives2D ()
310{
311 G4OpenGLSceneHandler::EndPrimitives2D ();
312}
313
314void G4OpenGLStoredSceneHandler::BeginModeling () {
315 G4VSceneHandler::BeginModeling();
316 ClearStore(); // ...and all that goes with it.
317 /* Debug...
318 fDisplayListId = glGenLists (1);
319 G4cout << "OGL::fDisplayListId (start): " << fDisplayListId << G4endl;
320 */
321}
322
323void G4OpenGLStoredSceneHandler::EndModeling () {
324 // Make a List which calls the other lists.
325 fTopPODL = glGenLists (1);
326#ifdef G4DEBUG_VIS_OGL
327 printf("G4OpenGLStoredSceneHandler::EndModeling ->glGenList(1) : %d\n",fTopPODL);
328#endif
329 if (glGetError() == GL_OUT_OF_MEMORY) { // Could pre-allocate?
330 G4cout <<
331 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
332 " display List for fTopPODL - try OpenGL Immediated mode."
333 << G4endl;
334 } else {
335 glNewList (fTopPODL, GL_COMPILE_AND_EXECUTE); {
336 for (size_t i = 0; i < fPOList.size (); i++) {
337 glPushMatrix();
338 G4OpenGLTransform3D oglt (fPOList[i].fTransform);
339 glMultMatrixd (oglt.GetGLMatrix ());
340 if (fpViewer->GetViewParameters().IsPicking())
341 glLoadName(fPOList[i].fPickName);
342 glCallList (fPOList[i].fDisplayListId);
343 glPopMatrix();
344 }
345 }
346 glEndList ();
347 if (glGetError() == GL_OUT_OF_MEMORY) { // Could close?
348 G4cout <<
349 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
350 " display List for fTopPODL - try OpenGL Immediated mode."
351 << G4endl;
352 }
353 }
354
355 G4VSceneHandler::EndModeling ();
356
357 /* Debug...
358 fDisplayListId = glGenLists (1);
359 G4cout << "OGL::fDisplayListId (end): " << fDisplayListId << G4endl;
360 */
361}
362
363void G4OpenGLStoredSceneHandler::ClearStore () {
364
365 //G4cout << "G4OpenGLStoredSceneHandler::ClearStore" << G4endl;
366
367 G4VSceneHandler::ClearStore (); // Sets need kernel visit, etc.
368
369 // Delete OpenGL permanent display lists.
370 for (size_t i = 0; i < fPOList.size (); i++)
371 glDeleteLists (fPOList[i].fDisplayListId, 1);
372 if (fTopPODL) glDeleteLists (fTopPODL, 1);
373 fTopPODL = 0;
374
375 // Clear other lists, dictionary, etc.
376 fPOList.clear ();
377 fSolidMap.clear ();
378 ClearAndDestroyAtts();
379
380 // ...and clear transient store...
381 for (size_t i = 0; i < fTOList.size (); i++)
382 glDeleteLists(fTOList[i].fDisplayListId, 1);
383 fTOList.clear ();
384
385 fMemoryForDisplayLists = true;
386}
387
388void G4OpenGLStoredSceneHandler::ClearTransientStore () {
389
390 //G4cout << "G4OpenGLStoredSceneHandler::ClearTransientStore" << G4endl;
391
392 G4VSceneHandler::ClearTransientStore ();
393
394 // Delete OpenGL transient display lists and Transient Objects themselves.
395 for (size_t i = 0; i < fTOList.size (); i++)
396 glDeleteLists(fTOList[i].fDisplayListId, 1);
397 fTOList.clear ();
398
399 fMemoryForDisplayLists = true;
400
401 // Make sure screen corresponds to graphical database...
402 if (fpViewer) {
403 fpViewer -> SetView ();
404 fpViewer -> ClearView ();
405 fpViewer -> DrawView ();
406 }
407}
408
409void G4OpenGLStoredSceneHandler::RequestPrimitives (const G4VSolid& solid)
410{
411 if (fReadyForTransients) {
412 // Always draw transient solids, e.g., hits represented as solids.
413 // (As we have no control over the order of drawing of transient
414 // objects, we cannot do anything about transparent ones, as
415 // below, so always draw them.)
416 G4VSceneHandler::RequestPrimitives (solid);
417 return;
418 }
419
420 // For non-transient (run-duration) objects, ensure transparent
421 // objects are drawn last. The problem of
422 // blending/transparency/alpha is quite a tricky one - see History
423 // of opengl-V07-01-01/2/3.
424 // Get vis attributes - pick up defaults if none.
425 const G4VisAttributes* pVA =
426 fpViewer -> GetApplicableVisAttributes(fpVisAttribs);
427 const G4Colour& c = pVA -> GetColour ();
428 G4double opacity = c.GetAlpha ();
429
430 if (!fSecondPass) {
431 G4bool transparency_enabled = true;
432 G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
433 if (pViewer) transparency_enabled = pViewer->transparency_enabled;
434 if (transparency_enabled && opacity < 1.) {
435 // On first pass, transparent objects are not drawn, but flag is set...
436 fSecondPassRequested = true;
437 return;
438 }
439 }
440
441 // On second pass, opaque objects are not drwan...
442 if (fSecondPass && opacity >= 1.) return;
443
444 G4PhysicalVolumeModel* pPVModel =
445 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
446
447 if (pPVModel) {
448 // If part of the geometry hierarchy, i.e., from a
449 // G4PhysicalVolumeModel, check if a display list already exists for
450 // this solid, re-use it if possible. We could be smarter, and
451 // recognise repeated branches of the geometry hierarchy, for
452 // example. But this algorithm should be secure, I think...
453 const G4VSolid* pSolid = &solid;
454 EAxis axis = kRho;
455 G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
456 if (pCurrentPV -> IsReplicated ()) {
457 G4int nReplicas;
458 G4double width;
459 G4double offset;
460 G4bool consuming;
461 pCurrentPV->GetReplicationData(axis,nReplicas,width,offset,consuming);
462 }
463 // Provided it is not parametrised (because if so, the
464 // solid's parameters might have been changed)...
465 if (!(pCurrentPV -> IsParameterised ()) &&
466 // Provided it is not replicated radially (because if so, the
467 // solid's parameters will have been changed)...
468 !(pCurrentPV -> IsReplicated () && axis == kRho) &&
469 // ...and if the solid has already been rendered...
470 (fSolidMap.find (pSolid) != fSolidMap.end ())) {
471 fDisplayListId = fSolidMap [pSolid];
472 PO po(fDisplayListId,*fpObjectTransformation);
473 if (fpViewer->GetViewParameters().IsPicking()) {
474 G4AttHolder* holder = new G4AttHolder;
475 // Load G4Atts from G4VisAttributes, if any...
476 const G4VisAttributes* va = pPVModel->GetCurrentLV()->GetVisAttributes();
477 if (va) {
478 const std::map<G4String,G4AttDef>* vaDefs = va->GetAttDefs();
479 if (vaDefs) holder->AddAtts(va->CreateAttValues(), vaDefs);
480 }
481 // Load G4Atts from G4PhysicalVolumeModel...
482 const std::map<G4String,G4AttDef>* defs = pPVModel->GetAttDefs();
483 if (defs) holder->AddAtts(pPVModel->CreateCurrentAttValues(), defs);
484 fPickMap[++fPickName] = holder;
485 po.fPickName = fPickName;
486 }
487 fPOList.push_back(po);
488 }
489 else {
490 G4VSceneHandler::RequestPrimitives (solid);
491 fSolidMap [pSolid] = fDisplayListId;
492 }
493 return;
494 }
495
496 // Otherwise invoke base class method...
497 G4VSceneHandler::RequestPrimitives (solid);
498}
499
500G4int G4OpenGLStoredSceneHandler::fSceneIdCount = 0;
501
502G4int G4OpenGLStoredSceneHandler::fDisplayListId = 0;
503G4bool G4OpenGLStoredSceneHandler::fMemoryForDisplayLists = true;
504G4int G4OpenGLStoredSceneHandler::fDisplayListLimit = 50000;
505
506#endif
Note: See TracBrowser for help on using the repository browser.