33 #ifdef G4VIS_BUILD_OPENGL_DRIVER
54 G4int G4OpenGLStoredSceneHandler::fSceneIdCount = 0;
56 G4int G4OpenGLStoredSceneHandler::fDisplayListId = 0;
57 G4bool G4OpenGLStoredSceneHandler::fMemoryForDisplayLists =
true;
58 G4int G4OpenGLStoredSceneHandler::fDisplayListLimit = 50000;
60 G4OpenGLStoredSceneHandler::PO::PO():
64 fMarkerOrPolyline(false)
67 G4OpenGLStoredSceneHandler::PO::PO(
const G4OpenGLStoredSceneHandler::PO& po):
68 fDisplayListId(po.fDisplayListId),
69 fTransform(po.fTransform),
70 fPickName(po.fPickName),
72 fpG4TextPlus(po.fpG4TextPlus? new G4TextPlus(*po.fpG4TextPlus): 0),
73 fMarkerOrPolyline(po.fMarkerOrPolyline)
81 fMarkerOrPolyline(false)
84 G4OpenGLStoredSceneHandler::PO::~PO()
89 G4OpenGLStoredSceneHandler::PO& G4OpenGLStoredSceneHandler::PO::operator=
90 (
const G4OpenGLStoredSceneHandler::PO& rhs)
92 if (&rhs ==
this)
return *
this;
93 fDisplayListId = rhs.fDisplayListId;
94 fTransform = rhs.fTransform;
95 fPickName = rhs.fPickName;
96 fColour = rhs.fColour;
97 fpG4TextPlus = rhs.fpG4TextPlus?
new G4TextPlus(*rhs.fpG4TextPlus): 0;
98 fMarkerOrPolyline = rhs.fMarkerOrPolyline;
102 G4OpenGLStoredSceneHandler::TO::TO():
108 fMarkerOrPolyline(false)
111 G4OpenGLStoredSceneHandler::TO::TO(
const G4OpenGLStoredSceneHandler::TO& to):
112 fDisplayListId(to.fDisplayListId),
113 fTransform(to.fTransform),
114 fPickName(to.fPickName),
115 fStartTime(to.fStartTime),
116 fEndTime(to.fEndTime),
118 fpG4TextPlus(to.fpG4TextPlus? new G4TextPlus(*to.fpG4TextPlus): 0),
119 fMarkerOrPolyline(to.fMarkerOrPolyline)
129 fMarkerOrPolyline(false)
132 G4OpenGLStoredSceneHandler::TO::~TO()
137 G4OpenGLStoredSceneHandler::TO& G4OpenGLStoredSceneHandler::TO::operator=
138 (
const G4OpenGLStoredSceneHandler::TO& rhs)
140 if (&rhs ==
this)
return *
this;
141 fDisplayListId = rhs.fDisplayListId;
142 fTransform = rhs.fTransform;
143 fPickName = rhs.fPickName;
144 fStartTime = rhs.fStartTime;
145 fEndTime = rhs.fEndTime;
146 fColour = rhs.fColour;
147 fpG4TextPlus = rhs.fpG4TextPlus?
new G4TextPlus(*rhs.fpG4TextPlus): 0;
148 fMarkerOrPolyline = rhs.fMarkerOrPolyline;
152 G4OpenGLStoredSceneHandler::G4OpenGLStoredSceneHandler
155 G4OpenGLSceneHandler (system, fSceneIdCount++, name),
159 G4OpenGLStoredSceneHandler::~G4OpenGLStoredSceneHandler ()
162 void G4OpenGLStoredSceneHandler::BeginPrimitives
165 G4OpenGLSceneHandler::BeginPrimitives (objectTransformation);
166 if (fReadyForTransients) glDrawBuffer (GL_FRONT);
170 void G4OpenGLStoredSceneHandler::EndPrimitives ()
174 glDrawBuffer (GL_BACK);
175 G4OpenGLSceneHandler::EndPrimitives ();
178 void G4OpenGLStoredSceneHandler::BeginPrimitives2D
181 G4OpenGLSceneHandler::BeginPrimitives2D(objectTransformation);
182 if (fReadyForTransients) glDrawBuffer (GL_FRONT);
185 void G4OpenGLStoredSceneHandler::EndPrimitives2D ()
189 glDrawBuffer (GL_BACK);
190 G4OpenGLSceneHandler::EndPrimitives2D ();
193 G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreamble(
const G4VMarker& visible)
195 return AddPrimitivePreambleInternal(visible,
true,
false);
197 G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreamble(
const G4Polyline& visible)
199 return AddPrimitivePreambleInternal(visible,
false,
true);
203 return AddPrimitivePreambleInternal(visible,
false,
false);
206 G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(
const G4Visible& visible,
bool isMarker,
bool isPolyline)
209 fpVisAttribs = fpViewer->GetApplicableVisAttributes(visible.
GetVisAttributes());
213 G4bool transparency_enabled =
true;
214 G4bool isMarkerNotHidden =
true;
215 G4OpenGLViewer* pViewer =
dynamic_cast<G4OpenGLViewer*
>(fpViewer);
217 transparency_enabled = pViewer->transparency_enabled;
218 isMarkerNotHidden = pViewer->fVP.IsMarkerNotHidden();
221 G4bool isTransparent = opacity < 1.;
222 G4bool isMarkerOrPolyline = isMarker || isPolyline;
223 G4bool treatAsTransparent = transparency_enabled && isTransparent;
224 G4bool treatAsNotHidden = isMarkerNotHidden && isMarkerOrPolyline;
226 if (fProcessing2D) glDisable (GL_DEPTH_TEST);
228 if (isMarkerOrPolyline && isMarkerNotHidden)
229 glDisable (GL_DEPTH_TEST);
230 else {glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);}
233 if (fThreePassCapable) {
238 if (!(fSecondPassForTransparency || fThirdPassForNonHiddenMarkers)) {
240 if (treatAsTransparent) {
241 fSecondPassForTransparencyRequested =
true;
243 if (treatAsNotHidden) {
244 fThirdPassForNonHiddenMarkersRequested =
true;
247 if (treatAsTransparent || treatAsNotHidden) {
253 if (fSecondPassForTransparency) {
254 if (!treatAsTransparent) {
260 if (fThirdPassForNonHiddenMarkers) {
261 if (!treatAsNotHidden) {
270 if (fpViewer->GetViewParameters().IsPicking()) {
272 glLoadName(++fPickName);
274 LoadAtts(visible, holder);
275 fPickMap[fPickName] = holder;
282 if (fpViewer->GetViewParameters().GetVisAttributesModifiers().size())
284 goto end_of_display_list_reuse_test;
292 goto end_of_display_list_reuse_test;
301 goto end_of_display_list_reuse_test;
305 goto end_of_display_list_reuse_test;
309 if (pCurrentPV -> IsReplicated ()) {
318 if (!(pCurrentPV -> IsParameterised ()) &&
321 !(pCurrentPV -> IsReplicated () && axis ==
kRho) &&
323 (fSolidMap.find (pSolid) != fSolidMap.end ())) {
324 fDisplayListId = fSolidMap [pSolid];
325 PO po(fDisplayListId,fObjectTransformation);
326 if (isPicking) po.fPickName = fPickName;
328 po.fMarkerOrPolyline = isMarkerOrPolyline;
329 fPOList.push_back(po);
338 end_of_display_list_reuse_test:
344 if (fMemoryForDisplayLists) {
345 fDisplayListId = glGenLists (1);
346 if (glGetError() == GL_OUT_OF_MEMORY ||
347 fDisplayListId > fDisplayListLimit) {
349 "********************* WARNING! ********************"
350 "\n* Display list limit reached in OpenGL."
351 "\n* Continuing drawing WITHOUT STORING. Scene only partially refreshable."
352 "\n* Current limit: " << fDisplayListLimit <<
353 ". Change with \"/vis/ogl/set/displayListLimit\"."
354 "\n***************************************************"
356 fMemoryForDisplayLists =
false;
360 if (pSolid) fSolidMap [pSolid] = fDisplayListId;
362 if (fMemoryForDisplayLists) {
363 if (fReadyForTransients) {
364 TO to(fDisplayListId, fObjectTransformation);
365 if (isPicking) to.fPickName = fPickName;
367 to.fStartTime = fpVisAttribs->GetStartTime();
368 to.fEndTime = fpVisAttribs->GetEndTime();
369 to.fMarkerOrPolyline = isMarkerOrPolyline;
370 fTOList.push_back(to);
377 G4OpenGLTransform3D oglt (fObjectTransformation);
378 glMultMatrixd (oglt.GetGLMatrix ());
379 if (transparency_enabled) {
384 (
void) ExtraTOProcessing(visible, fTOList.size() - 1);
388 glNewList (fDisplayListId, GL_COMPILE_AND_EXECUTE);
390 PO po(fDisplayListId, fObjectTransformation);
391 if (isPicking) po.fPickName = fPickName;
393 po.fMarkerOrPolyline = isMarkerOrPolyline;
394 fPOList.push_back(po);
400 if (transparency_enabled) {
405 G4bool usesGLCommands = ExtraPOProcessing(visible, fPOList.size() - 1);
415 if (!usesGLCommands)
return false;
416 glNewList (fDisplayListId, GL_COMPILE);
419 glDrawBuffer (GL_FRONT);
421 G4OpenGLTransform3D oglt (fObjectTransformation);
422 glMultMatrixd (oglt.GetGLMatrix ());
423 if (transparency_enabled) {
433 glMatrixMode (GL_PROJECTION);
437 pViewer->g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
439 glMatrixMode (GL_MODELVIEW);
442 G4OpenGLTransform3D oglt (fObjectTransformation);
443 glMultMatrixd (oglt.GetGLMatrix ());
444 glDisable (GL_LIGHTING);
446 glEnable (GL_LIGHTING);
452 void G4OpenGLStoredSceneHandler::AddPrimitivePostamble()
456 glMatrixMode (GL_PROJECTION);
458 glMatrixMode (GL_MODELVIEW);
463 if (glGetError() == GL_OUT_OF_MEMORY) {
465 "ERROR: G4OpenGLStoredSceneHandler::AddPrimitivePostamble: Failure"
466 " to allocate display List for fTopPODL - try OpenGL Immediated mode."
469 if (fMemoryForDisplayLists) {
471 if (glGetError() == GL_OUT_OF_MEMORY) {
473 "ERROR: G4OpenGLStoredSceneHandler::AddPrimitivePostamble: Failure"
474 " to allocate display List for fTopPODL - try OpenGL Immediated mode."
478 if (fReadyForTransients || !fMemoryForDisplayLists) {
483 void G4OpenGLStoredSceneHandler::AddPrimitive (
const G4Polyline& polyline)
485 G4bool furtherprocessing = AddPrimitivePreamble(polyline);
486 if (furtherprocessing) {
487 G4OpenGLSceneHandler::AddPrimitive(polyline);
488 AddPrimitivePostamble();
492 void G4OpenGLStoredSceneHandler::AddPrimitive (
const G4Polymarker& polymarker)
494 G4bool furtherprocessing = AddPrimitivePreamble(polymarker);
495 if (furtherprocessing) {
496 G4OpenGLSceneHandler::AddPrimitive(polymarker);
497 AddPrimitivePostamble();
501 void G4OpenGLStoredSceneHandler::AddPrimitive (
const G4Text& text)
506 G4bool furtherprocessing = AddPrimitivePreamble(text);
507 if (furtherprocessing) {
508 G4OpenGLSceneHandler::AddPrimitive(text);
509 AddPrimitivePostamble();
513 void G4OpenGLStoredSceneHandler::AddPrimitive (
const G4Circle& circle)
515 G4bool furtherprocessing = AddPrimitivePreamble(circle);
516 if (furtherprocessing) {
517 G4OpenGLSceneHandler::AddPrimitive(circle);
518 AddPrimitivePostamble();
522 void G4OpenGLStoredSceneHandler::AddPrimitive (
const G4Square& square)
524 G4bool furtherprocessing = AddPrimitivePreamble(square);
525 if (furtherprocessing) {
526 G4OpenGLSceneHandler::AddPrimitive(square);
527 AddPrimitivePostamble();
531 void G4OpenGLStoredSceneHandler::AddPrimitive (
const G4Scale& scale)
534 G4OpenGLSceneHandler::AddPrimitive(scale);
537 void G4OpenGLStoredSceneHandler::AddPrimitive (
const G4Polyhedron& polyhedron)
542 G4bool furtherprocessing = AddPrimitivePreamble(polyhedron);
543 if (furtherprocessing) {
544 G4OpenGLSceneHandler::AddPrimitive(polyhedron);
545 AddPrimitivePostamble();
549 void G4OpenGLStoredSceneHandler::BeginModeling () {
557 void G4OpenGLStoredSceneHandler::EndModeling () {
559 fTopPODL = glGenLists (1);
560 if (glGetError() == GL_OUT_OF_MEMORY) {
562 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
563 " display List for fTopPODL - try OpenGL Immediated mode."
567 glNewList (fTopPODL, GL_COMPILE); {
568 for (
size_t i = 0; i < fPOList.size (); i++) {
570 G4OpenGLTransform3D oglt (fPOList[i].fTransform);
571 glMultMatrixd (oglt.GetGLMatrix ());
572 if (fpViewer->GetViewParameters().IsPicking())
573 glLoadName(fPOList[i].fPickName);
574 glCallList (fPOList[i].fDisplayListId);
580 if (glGetError() == GL_OUT_OF_MEMORY) {
582 "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
583 " display List for fTopPODL - try OpenGL Immediated mode."
591 void G4OpenGLStoredSceneHandler::ClearStore () {
598 for (
size_t i = 0; i < fPOList.size (); i++)
599 glDeleteLists (fPOList[i].fDisplayListId, 1);
600 if (fTopPODL) glDeleteLists (fTopPODL, 1);
606 ClearAndDestroyAtts();
609 for (
size_t i = 0; i < fTOList.size (); i++)
610 glDeleteLists(fTOList[i].fDisplayListId, 1);
613 fMemoryForDisplayLists =
true;
616 void G4OpenGLStoredSceneHandler::ClearTransientStore ()
621 for (
size_t i = 0; i < fTOList.size (); i++)
622 glDeleteLists(fTOList[i].fDisplayListId, 1);
625 fMemoryForDisplayLists =
true;
629 fpViewer -> SetView ();
630 fpViewer -> ClearView ();
631 fpViewer -> DrawView ();
virtual void ClearStore()
G4double GetAlpha() const
virtual void BeginModeling()
G4VSolid * GetSolid() const
const G4VisAttributes * GetVisAttributes() const
G4GLOB_DLL std::ostream G4cout
G4double GetGreen() const
virtual void EndModeling()
G4LogicalVolume * GetLogicalVolume() const
virtual void GetReplicationData(EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const =0
G4VPhysicalVolume * GetCurrentPV() const
typedef void(XMLCALL *XML_ElementDeclHandler)(void *userData
G4GLOB_DLL std::ostream G4cerr