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

Last change on this file since 1103 was 1103, checked in by garnier, 15 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.