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

Last change on this file since 947 was 946, checked in by garnier, 17 years ago

en OGLIX ca marche...
  • Property svn:mime-type set to text/cpp
File size: 18.3 KB
RevLine 
[529]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//
[915]27// $Id: G4OpenGLStoredSceneHandler.cc,v 1.40 2009/02/04 16:48:41 lgarnier Exp $
[877]28// GEANT4 tag $Name: $
[529]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"
[593]48#include "G4LogicalVolume.hh"
[529]49#include "G4Polyline.hh"
50#include "G4Polymarker.hh"
[593]51#include "G4Text.hh"
[529]52#include "G4Circle.hh"
53#include "G4Square.hh"
[593]54#include "G4Polyhedron.hh"
55#include "G4AttHolder.hh"
[914]56#include "G4OpenGLTransform3D.hh"
57#include "G4OpenGLViewer.hh"
[529]58
[790]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):
[529]80G4OpenGLSceneHandler (system, fSceneIdCount++, name),
81fMemoryForDisplayLists (true),
82fAddPrimitivePreambleNestingDepth (0),
[936]83fTopPODL (0),
84fLastPolymarker(),
[938]85fLastPolymarkers(),
86nbDoublons(0)
[529]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
[593]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.
[529]102
[593]103 if (fpViewer->GetViewParameters().IsPicking()) {
104 fPickMap[++fPickName] = 0;
105 }
[529]106
[593]107 const G4Colour& c = GetColour (visible);
[529]108
[593]109 if (fMemoryForDisplayLists) {
110 fDisplayListId = glGenLists (1);
[866]111 if (glGetError() == GL_OUT_OF_MEMORY) { // Could pre-allocate?
[593]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 }
[529]145 } else {
[593]146 glDrawBuffer (GL_FRONT);
147 glPushMatrix();
148 G4OpenGLTransform3D oglt (*fpObjectTransformation);
149 glMultMatrixd (oglt.GetGLMatrix ());
[529]150 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
151 }
[593]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();
[789]159 glOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
[593]160 glMatrixMode (GL_MODELVIEW);
161 glPushMatrix();
162 glLoadIdentity();
[688]163 G4OpenGLTransform3D oglt (*fpObjectTransformation);
164 glMultMatrixd (oglt.GetGLMatrix ());
165 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
[593]166 }
[529]167}
168
169void G4OpenGLStoredSceneHandler::AddPrimitivePostamble()
170{
[593]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
[877]179 // if ((glGetError() == GL_TABLE_TOO_LARGE) || (glGetError() == GL_OUT_OF_MEMORY)) { // Could close?
180 if (glGetError() == GL_OUT_OF_MEMORY) { // Could close?
[866]181 G4cout <<
182 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
183 " display List for fTopPODL - try OpenGL Immediated mode."
184 << G4endl;
185 }
[593]186 if (fMemoryForDisplayLists) {
187 glEndList();
[866]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 }
[593]194 }
195 if (fReadyForTransients || !fMemoryForDisplayLists) {
196 glPopMatrix();
197 glFlush ();
198 glDrawBuffer (GL_BACK);
199 }
[529]200 fAddPrimitivePreambleNestingDepth--;
201}
202
203void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polyline& polyline)
204{
205 AddPrimitivePreamble(polyline);
206 G4OpenGLSceneHandler::AddPrimitive(polyline);
207 AddPrimitivePostamble();
208}
209
[593]210void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polymarker& polymarker)
211{
[936]212
[938]213 std::vector< G4Polymarker > poly;
[936]214 // 40,83 N03 lancement
215 // 289,69 10Gev supp doublons + bitmap 21 frame en 10 sec
216 // 343,45 10Gev full polymarker + bitmap 15 frame en 10 sec
217 // 351,67 10Gev full polymarker - bitmap 31 frame en 10 sec
[938]218 // 257,90 10Gev supp doublons MAX - bitmap 42 frame en 10 sec 45757 markers et 16243 enleves
[936]219 // Check
220 int reste = polymarker.size();
[938]221 bool res = false;
222 if (fLastPolymarkers.size() > 0 ) {
[942]223
[945]224 // Loop new point to check
[936]225 for (unsigned int b=0; b< polymarker.size();b++) {
[945]226 // printf("check %d/%d\n",b,polymarker.size());
[938]227 res= false;
[945]228
229 // Look for stored point list
[938]230 for (unsigned int a=0; a< fLastPolymarkers.size() ;a++) {
[945]231 // printf("against vect %d/%d\n",a,fLastPolymarker.size());
[942]232 std::vector < G4Polymarker > storedPoly = fLastPolymarkers[a];
233 int size= storedPoly.size()-1;
[945]234
235 // Look for point
236 for (int aPoly=0; aPoly< size ;aPoly++) {
237 // printf("against poly %d/%d\n",aPoly,storedPoly.size());
[942]238 if (( storedPoly[size-aPoly].GetPosition().x() == polymarker[b].x()) &&
239 ( storedPoly[size-aPoly].GetPosition().y() == polymarker[b].y()) &&
240 ( storedPoly[size-aPoly].GetPosition().z() == polymarker[b].z())) {
241 reste --;
242 res= true;
243 nbDoublons++;
[945]244 // 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());
[942]245 }
[938]246 }
[936]247 }
[938]248 // Add
249 if (!res) {
250 G4Polymarker tmp;
251 tmp.SetPosition(polymarker[b]);
[942]252 poly.push_back(tmp);
[938]253 }
[936]254 }
[938]255 } else {
256 for (unsigned int b=0; b< polymarker.size();b++) {
257 G4Polymarker tmp;
258 tmp.SetPosition(polymarker[b]);
259 poly.push_back(tmp);
260 }
[936]261 }
[942]262 fLastPolymarkers.push_back(poly);
[936]263#define TEST_MARKER 1
264#ifdef TEST_MARKER
265 // if it is already done
[938]266 if (poly.size() == 1 ) {
267 // if (polymarker.size() >0) {
268 // if (( fLastPolymarker.GetPosition().x() == polymarker[0].x()) &&
269 // ( fLastPolymarker.GetPosition().y() == polymarker[0].y()) &&
270 // ( fLastPolymarker.GetPosition().z() == polymarker[0].z())) {
271 // if (fpViewer->GetViewParameters().IsPicking()) {
272 // glLoadName(++fPickName);
273 // fPickMap[fPickName] = 0;
274 // }
275 // printf("G4OpenGLStoredSceneHandler::AddPrimitive SUPPR ----------- point %f %f %f\n",polymarker[0].x(),polymarker[0].y(),polymarker[0].z());
276 const G4Colour& c = GetColour (polymarker);
277 glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
278 G4OpenGLSceneHandler::AddPrimitive(poly[0]);
279 // fLastPolymarker.SetPosition(polymarker[poly]);
280 return;
[936]281 }
282#endif
[946]283 printf("G4OpenGLStoredSceneHandler::AddPrimitive new marker list\n");
[593]284 AddPrimitivePreamble(polymarker);
285 G4OpenGLSceneHandler::AddPrimitive(polymarker);
286 AddPrimitivePostamble();
[938]287// fLastPolymarker.SetPosition(polymarker[polymarker.size()-1]);
[593]288}
289
290void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Text& text)
291{
292 // Note: colour is still handled in
293 // G4OpenGLSceneHandler::AddPrimitive(const G4Text&), so it still
294 // gets into the display list
295 AddPrimitivePreamble(text);
296 G4OpenGLSceneHandler::AddPrimitive(text);
297 AddPrimitivePostamble();
298}
299
[529]300void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Circle& circle)
301{
302 AddPrimitivePreamble(circle);
303 G4OpenGLSceneHandler::AddPrimitive(circle);
304 AddPrimitivePostamble();
305}
306
307void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Square& square)
308{
309 AddPrimitivePreamble(square);
310 G4OpenGLSceneHandler::AddPrimitive(square);
311 AddPrimitivePostamble();
312}
313
[593]314void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Scale& scale)
[529]315{
[593]316 // Let base class split into primitives.
317 G4OpenGLSceneHandler::AddPrimitive(scale);
318}
319
320void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polyhedron& polyhedron)
321{
322 // Note: colour is still handled in
323 // G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&), so it still
324 // gets into the display list
325 AddPrimitivePreamble(polyhedron);
326 G4OpenGLSceneHandler::AddPrimitive(polyhedron);
[529]327 AddPrimitivePostamble();
328}
329
[593]330void G4OpenGLStoredSceneHandler::AddPrimitive (const G4NURBS& nurbs)
331{
332 // Note: colour is still handled in
333 // G4OpenGLSceneHandler::AddPrimitive(const G4NURBS&), so it still
334 // gets into the display list
335 AddPrimitivePreamble(nurbs);
336 G4OpenGLSceneHandler::AddPrimitive(nurbs);
337 AddPrimitivePostamble();
338}
339
[529]340void G4OpenGLStoredSceneHandler::BeginPrimitives
[593]341(const G4Transform3D& objectTransformation)
342{
343 G4OpenGLSceneHandler::BeginPrimitives (objectTransformation);
[529]344
[593]345 // Display list setup moved to AddPrimitivePreamble. See notes there.
[529]346}
347
[593]348void G4OpenGLStoredSceneHandler::EndPrimitives ()
349{
350 G4OpenGLSceneHandler::EndPrimitives ();
[529]351}
352
[688]353void G4OpenGLStoredSceneHandler::BeginPrimitives2D
354(const G4Transform3D& objectTransformation)
[529]355{
[688]356 G4OpenGLSceneHandler::BeginPrimitives2D(objectTransformation);
[529]357}
358
359void G4OpenGLStoredSceneHandler::EndPrimitives2D ()
360{
[593]361 G4OpenGLSceneHandler::EndPrimitives2D ();
[529]362}
363
364void G4OpenGLStoredSceneHandler::BeginModeling () {
365 G4VSceneHandler::BeginModeling();
366 ClearStore(); // ...and all that goes with it.
367 /* Debug...
368 fDisplayListId = glGenLists (1);
369 G4cout << "OGL::fDisplayListId (start): " << fDisplayListId << G4endl;
370 */
371}
372
373void G4OpenGLStoredSceneHandler::EndModeling () {
374 // Make a List which calls the other lists.
[936]375 printf("G4OpenGLStoredSceneHandler::EndModeling Cree une nouvelle liste+++++++++++++++++++++++++++\n");
[529]376 fTopPODL = glGenLists (1);
[866]377 if (glGetError() == GL_OUT_OF_MEMORY) { // Could pre-allocate?
[529]378 G4cout <<
379 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
380 " display List for fTopPODL - try OpenGL Immediated mode."
381 << G4endl;
[593]382 } else {
[529]383 glNewList (fTopPODL, GL_COMPILE_AND_EXECUTE); {
384 for (size_t i = 0; i < fPOList.size (); i++) {
385 glPushMatrix();
386 G4OpenGLTransform3D oglt (fPOList[i].fTransform);
387 glMultMatrixd (oglt.GetGLMatrix ());
[593]388 if (fpViewer->GetViewParameters().IsPicking())
389 glLoadName(fPOList[i].fPickName);
[529]390 glCallList (fPOList[i].fDisplayListId);
391 glPopMatrix();
392 }
393 }
394 glEndList ();
[866]395 if (glGetError() == GL_OUT_OF_MEMORY) { // Could close?
396 G4cout <<
397 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
398 " display List for fTopPODL - try OpenGL Immediated mode."
399 << G4endl;
400 }
[529]401 }
402
403 G4VSceneHandler::EndModeling ();
404
405 /* Debug...
406 fDisplayListId = glGenLists (1);
407 G4cout << "OGL::fDisplayListId (end): " << fDisplayListId << G4endl;
408 */
409}
410
411void G4OpenGLStoredSceneHandler::ClearStore () {
412
413 G4VSceneHandler::ClearStore (); // Sets need kernel visit, etc.
414
415 // Delete OpenGL permanent display lists.
416 for (size_t i = 0; i < fPOList.size (); i++)
417 glDeleteLists (fPOList[i].fDisplayListId, 1);
418 if (fTopPODL) glDeleteLists (fTopPODL, 1);
419 fTopPODL = 0;
420
421 // Clear other lists, dictionary, etc.
422 fPOList.clear ();
423 fSolidMap.clear ();
[593]424 ClearAndDestroyAtts();
[529]425
426 // ...and clear transient store...
427 for (size_t i = 0; i < fTOList.size (); i++)
428 glDeleteLists(fTOList[i].fDisplayListId, 1);
429 fTOList.clear ();
430}
431
432void G4OpenGLStoredSceneHandler::ClearTransientStore () {
433
434 G4VSceneHandler::ClearTransientStore ();
435
436 // Delete OpenGL transient display lists and Transient Objects themselves.
437 for (size_t i = 0; i < fTOList.size (); i++)
438 glDeleteLists(fTOList[i].fDisplayListId, 1);
439 fTOList.clear ();
440
441 // Make sure screen corresponds to graphical database...
442 if (fpViewer) {
443 fpViewer -> SetView ();
444 fpViewer -> ClearView ();
445 fpViewer -> DrawView ();
446 }
447}
448
449void G4OpenGLStoredSceneHandler::RequestPrimitives (const G4VSolid& solid)
450{
451 if (fReadyForTransients) {
452 // Always draw transient solids, e.g., hits represented as solids.
453 // (As we have no control over the order of drawing of transient
454 // objects, we cannot do anything about transparent ones, as
455 // below, so always draw them.)
456 G4VSceneHandler::RequestPrimitives (solid);
457 return;
458 }
459
460 // For non-transient (run-duration) objects, ensure transparent
461 // objects are drawn last. The problem of
462 // blending/transparency/alpha is quite a tricky one - see History
463 // of opengl-V07-01-01/2/3.
464 // Get vis attributes - pick up defaults if none.
465 const G4VisAttributes* pVA =
466 fpViewer -> GetApplicableVisAttributes(fpVisAttribs);
467 const G4Colour& c = pVA -> GetColour ();
468 G4double opacity = c.GetAlpha ();
469
470 if (!fSecondPass) {
471 G4bool transparency_enabled = true;
472 G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
473 if (pViewer) transparency_enabled = pViewer->transparency_enabled;
474 if (transparency_enabled && opacity < 1.) {
475 // On first pass, transparent objects are not drawn, but flag is set...
476 fSecondPassRequested = true;
477 return;
478 }
479 }
480
481 // On second pass, opaque objects are not drwan...
482 if (fSecondPass && opacity >= 1.) return;
483
484 G4PhysicalVolumeModel* pPVModel =
485 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
486
487 if (pPVModel) {
488 // If part of the geometry hierarchy, i.e., from a
489 // G4PhysicalVolumeModel, check if a display list already exists for
490 // this solid, re-use it if possible. We could be smarter, and
491 // recognise repeated branches of the geometry hierarchy, for
492 // example. But this algorithm should be secure, I think...
493 const G4VSolid* pSolid = &solid;
494 EAxis axis = kRho;
495 G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
496 if (pCurrentPV -> IsReplicated ()) {
497 G4int nReplicas;
498 G4double width;
499 G4double offset;
500 G4bool consuming;
501 pCurrentPV->GetReplicationData(axis,nReplicas,width,offset,consuming);
502 }
503 // Provided it is not parametrised (because if so, the
504 // solid's parameters might have been changed)...
505 if (!(pCurrentPV -> IsParameterised ()) &&
506 // Provided it is not replicated radially (because if so, the
507 // solid's parameters will have been changed)...
508 !(pCurrentPV -> IsReplicated () && axis == kRho) &&
509 // ...and if the solid has already been rendered...
510 (fSolidMap.find (pSolid) != fSolidMap.end ())) {
511 fDisplayListId = fSolidMap [pSolid];
[593]512 PO po(fDisplayListId,*fpObjectTransformation);
513 if (fpViewer->GetViewParameters().IsPicking()) {
514 G4AttHolder* holder = new G4AttHolder;
515 // Load G4Atts from G4VisAttributes, if any...
516 const G4VisAttributes* va = pPVModel->GetCurrentLV()->GetVisAttributes();
517 if (va) {
518 const std::map<G4String,G4AttDef>* vaDefs = va->GetAttDefs();
519 if (vaDefs) holder->AddAtts(va->CreateAttValues(), vaDefs);
520 }
521 // Load G4Atts from G4PhysicalVolumeModel...
522 const std::map<G4String,G4AttDef>* defs = pPVModel->GetAttDefs();
523 if (defs) holder->AddAtts(pPVModel->CreateCurrentAttValues(), defs);
524 fPickMap[++fPickName] = holder;
525 po.fPickName = fPickName;
526 }
527 fPOList.push_back(po);
[529]528 }
529 else {
530 G4VSceneHandler::RequestPrimitives (solid);
531 fSolidMap [pSolid] = fDisplayListId;
532 }
533 return;
534 }
535
536 // Otherwise invoke base class method...
537 G4VSceneHandler::RequestPrimitives (solid);
538}
539
540G4int G4OpenGLStoredSceneHandler::fSceneIdCount = 0;
541
542#endif
Note: See TracBrowser for help on using the repository browser.