source: trunk/source/visualization/VRML/src/G4VRML2SceneHandlerFunc.icc

Last change on this file was 1347, checked in by garnier, 15 years ago

geant4 tag 9.4
File size: 19.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: G4VRML2SceneHandlerFunc.icc,v 1.21 2010/11/11 00:14:50 akimura Exp $
28// GEANT4 tag $Name: geant4-09-04-ref-00 $
29//
30// G4VRML2SceneHandlerFunc.icc
31// Satoshi Tanaka & Yasuhide Sawada
32
33//#define DEBUG_SCENE_FUNC
34
35#include "G4VisManager.hh"
36
37void G4VRML2SCENEHANDLER::AddSolid(const G4Trd& trd)
38{
39#if defined DEBUG_SCENE_FUNC
40 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
41 G4cout << "***** AddSolid trd" << "\n" ;
42#endif
43 VRMLBeginModeling () ;
44 G4VSceneHandler::AddSolid(trd);
45}
46
47void G4VRML2SCENEHANDLER::AddSolid(const G4Trap& trap)
48{
49#if defined DEBUG_SCENE_FUNC
50 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
51 G4cout << "***** AddSolid trap" << "\n" ;
52#endif
53 VRMLBeginModeling () ;
54 G4VSceneHandler::AddSolid(trap);
55}
56
57void G4VRML2SCENEHANDLER::AddSolid(const G4Para& para)
58{
59#if defined DEBUG_SCENE_FUNC
60 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
61 G4cout << "***** AddSolid para" << "\n" ;
62#endif
63 VRMLBeginModeling () ;
64 G4VSceneHandler::AddSolid(para);
65}
66
67void G4VRML2SCENEHANDLER::AddSolid(const G4Torus& torus )
68{
69#if defined DEBUG_SCENE_FUNC
70 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
71 G4cout << "***** AddSolid torus" << "\n" ;
72#endif
73 VRMLBeginModeling () ;
74 G4VSceneHandler::AddSolid(torus);
75}
76
77
78void G4VRML2SCENEHANDLER::AddSolid(const G4VSolid& vsolid)
79{
80#if defined DEBUG_SCENE_FUNC
81 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
82 G4cout << "***** AddSolid vsolid" << "\n" ;
83#endif
84 VRMLBeginModeling () ;
85 G4VSceneHandler::AddSolid(vsolid);
86}
87
88void G4VRML2SCENEHANDLER::AddSolid(const G4Tubs& tubs)
89{
90#if defined DEBUG_SCENE_FUNC
91 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
92 G4cout << "***** AddSolid tubs" << "\n" ;
93#endif
94 VRMLBeginModeling () ;
95 G4VSceneHandler::AddSolid(tubs) ;
96
97}
98
99
100void G4VRML2SCENEHANDLER::AddSolid(const G4Cons& cons)
101{
102#if defined DEBUG_SCENE_FUNC
103 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
104 G4cout << "***** AddSolid cons" << "\n" ;
105#endif
106 VRMLBeginModeling () ;
107 G4VSceneHandler::AddSolid(cons) ;
108}
109
110void G4VRML2SCENEHANDLER::AddSolid(const G4Box& box)
111{
112#if defined DEBUG_SCENE_FUNC
113 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
114 G4cout << "***** AddSolid box" << "\n" ;
115#endif
116 VRMLBeginModeling () ;
117 G4VSceneHandler::AddSolid(box) ;
118}
119
120
121void G4VRML2SCENEHANDLER::AddSolid(const G4Sphere& sphere)
122{
123#if defined DEBUG_SCENE_FUNC
124 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
125 G4cout << "***** AddSolid sphere" << "\n" ;
126#endif
127 VRMLBeginModeling () ;
128 G4VSceneHandler::AddSolid(sphere) ;
129}
130
131void G4VRML2SCENEHANDLER::AddPrimitive(const G4Polyline& polyline)
132{
133#if defined DEBUG_SCENE_FUNC
134 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
135 G4cout << "***** AddPrimitive polyline" << "\n" ;
136#endif
137
138 VRMLBeginModeling () ;
139
140 // VRML codes are generated below
141
142 fDest << "#---------- POLYLINE" << "\n";
143 fDest << "Shape {" << "\n";
144
145 SendLineColor ( polyline.GetVisAttributes() );
146
147 fDest << "\t" << "geometry IndexedLineSet {" << "\n";
148
149 fDest << "\t\t" << "coord Coordinate {" << "\n";
150 fDest << "\t\t\t" << "point [" << "\n";
151 G4int e, i;
152 for (i = 0, e = polyline.size(); e; i++, e--) {
153
154 G4Point3D point = polyline[i];
155 point.transform( *fpObjectTransformation );
156
157 fDest << "\t\t\t\t";
158 fDest << point.x() << " ";
159 fDest << point.y() << " ";
160 fDest << point.z() << "," << "\n";
161
162 } // for
163
164 fDest << "\t\t\t" << "]" << "\n"; // point
165 fDest << "\t\t" << "}" << "\n"; // coord
166
167 fDest << "\t\t" << "coordIndex [";
168 for (i = 0, e = polyline.size(); e; i++, e--) {
169 if (i % 10 == 0)
170 fDest << "\n" << "\t\t\t";
171 fDest << i << ", ";
172 }
173 fDest << "-1" << "\n";
174 fDest << "\t\t" << "]" << "\n"; // coordIndex
175 fDest << "\t" << "}" << "\n"; // geometry IndexedLineSet
176
177 fDest << "}" << "\n"; // Shape
178}
179
180
181void G4VRML2SCENEHANDLER::AddPrimitive(const G4Polyhedron& polyhedron)
182{
183#if defined DEBUG_SCENE_FUNC
184 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
185 G4cout << "***** AddPrimitive(G4Polyhedron)" << "\n";
186#endif
187
188 if (polyhedron.GetNoFacets() == 0) return;
189
190 VRMLBeginModeling () ;
191
192 // Transparency checking: If completely transparent, skip drawing
193 if ( GetPVTransparency() > 0.99 ) { return ; }
194
195 // Current Model
196 const G4VModel* pv_model = GetModel();
197 G4String pv_name = "No model";
198 if (pv_model) pv_name = pv_model->GetCurrentTag() ;
199
200 // VRML codes are generated below
201
202 fDest << "#---------- SOLID: " << pv_name << "\n";
203
204 if ( IsPVPickable() ) {
205
206 fDest << "Anchor {" << "\n";
207 fDest << " description " << "\"" << pv_name << "\"" << "\n";
208 fDest << " url \"\" " << "\n";
209 fDest << " children [" << "\n";
210 }
211
212 fDest << "\t"; fDest << "Shape {" << "\n";
213
214 SendMaterialNode();
215
216 fDest << "\t\t" << "geometry IndexedFaceSet {" << "\n";
217
218 fDest << "\t\t\t" << "coord Coordinate {" << "\n";
219 fDest << "\t\t\t\t" << "point [" << "\n";
220 G4int i, j;
221 for (i = 1, j = polyhedron.GetNoVertices(); j; j--, i++) {
222 G4Point3D point = polyhedron.GetVertex(i);
223
224 point.transform( *fpObjectTransformation );
225
226 fDest << "\t\t\t\t\t";
227 fDest << point.x() << " ";
228 fDest << point.y() << " ";
229 fDest << point.z() << "," << "\n";
230 }
231 fDest << "\t\t\t\t" << "]" << "\n"; // point
232 fDest << "\t\t\t" << "}" << "\n"; // coord
233
234 fDest << "\t\t\t" << "coordIndex [" << "\n";
235
236 // facet loop
237 G4int f;
238 for (f = polyhedron.GetNoFacets(); f; f--) {
239
240 // edge loop
241 G4bool notLastEdge;
242 G4int index = -1, edgeFlag = 1;
243 fDest << "\t\t\t\t";
244 do {
245 notLastEdge = polyhedron.GetNextVertexIndex(index, edgeFlag);
246 fDest << index - 1 << ", ";
247 } while (notLastEdge);
248 fDest << "-1," << "\n";
249 }
250 fDest << "\t\t\t" << "]" << "\n"; // coordIndex
251
252 fDest << "\t\t\t" << "solid FALSE" << "\n"; // draw backfaces
253
254 fDest << "\t\t" << "}" << "\n"; // IndexFaceSet
255 fDest << "\t" << "}" << "\n"; // Shape
256
257 if ( IsPVPickable() ) {
258 fDest << " ]" << "\n"; // children
259 fDest << "}" << "\n"; // Anchor
260 }
261
262}
263
264
265void G4VRML2SCENEHANDLER::AddPrimitive(const G4NURBS&)
266{
267#if defined DEBUG_SCENE_FUNC
268 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
269 G4cout << "***** AddPrimitive nurbs" << "\n" ;
270#endif
271 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
272 G4cout << "G4VRML2File::AddPrimitive(G4NURBS&): not implemented. " << "\n" ;
273
274 VRMLBeginModeling () ;
275}
276
277void G4VRML2SCENEHANDLER::AddPrimitive( const G4Text& )
278{
279#if defined DEBUG_SCENE_FUNC
280 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
281 G4cout << "***** AddPrimitive text" << "\n" ;
282#endif
283 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
284 G4cout <<
285 "***** void G4VRML2SCENEHANDLER::AddPrimitive( const G4Text& text )"
286 " not implemented yet."
287 << "\n";
288
289 VRMLBeginModeling () ;
290
291}
292
293void G4VRML2SCENEHANDLER::AddPrimitive( const G4Circle& circle )
294{
295#if defined DEBUG_SCENE_FUNC
296 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
297 G4cout << "***** AddPrimitive circle" << "\n" ;
298#endif
299 VRMLBeginModeling () ;
300
301 // Information
302// const char* info = NULL ;
303 const char* info = circle.GetInfo() ;
304
305 // Position and half size of circle
306 G4double X, Y, Z ; GetMarkerWorldPosition( circle, &X, &Y, &Z ) ;
307 G4double radius = GetMarkerHalfSize ( circle );
308
309 // VRML codes are generated below
310 fDest << "#---------- 3D MARKER (Circle)" << "\n";
311 fDest << "Anchor {" << "\n";
312
313 if( circle.GetInfo().isNull() ) {
314 fDest << " description " << "\"(" << X << " " ;
315 fDest << Y << " " ;
316 fDest << Z << ")\"" << "\n";
317 } else {
318 fDest << " description " << "\"" << info << "\"" << "\n";
319 }
320
321
322 fDest << " url \"\" " << "\n";
323
324 fDest << " children [" << "\n";
325
326 fDest << " Transform {" << "\n";
327
328 fDest << " translation ";
329 fDest << X << " " << Y << " " << Z << "\n";
330
331 fDest << " children [" << "\n";
332
333 fDest << "\t" << "Shape {" << "\n";
334
335 SendMarkerColor( circle );
336
337 // send shape with size
338 fDest << "\t\t" << "geometry Sphere {" << "\n";
339 fDest << "\t\t\t" << "radius " << radius << "\n";
340 fDest << "\t\t" << "}" << "\n";
341
342 fDest << "\t" << "}" << "\n"; // Shape
343
344 fDest << " ]" << "\n"; // children
345 fDest << " }" << "\n"; // Transform
346
347 fDest << " ]" << "\n"; // children
348 fDest << "}" << "\n"; // Anchor
349
350}
351
352void G4VRML2SCENEHANDLER::AddPrimitive(const G4Square& square)
353{
354#if defined DEBUG_SCENE_FUNC
355 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
356 G4cout << "***** AddPrimitive square" << "\n" ;
357#endif
358
359 VRMLBeginModeling () ;
360
361 // Information
362// const char* info = NULL ;
363 const char* info = square.GetInfo() ;
364
365 // Position and size of square
366 G4double X, Y, Z ; GetMarkerWorldPosition ( square, &X, &Y, &Z ) ;
367 G4double radius = GetMarkerHalfSize ( square );
368 G4double diameter = 2.0 * radius ;
369
370 // VRML codes are generated below
371 fDest << "#---------- 3D MARKER (Square)" << "\n";
372 fDest << "Anchor {" << "\n";
373
374 if( square.GetInfo().isNull() ) {
375 fDest << " description " << "\"(" << X << " " ;
376 fDest << Y << " " ;
377 fDest << Z << ")\"" << "\n";
378 } else {
379 fDest << " description " << "\"" << info << "\"" << "\n";
380 }
381
382 fDest << " url \"\" " << "\n";
383
384 fDest << " children [" << "\n";
385
386 fDest << " Transform {" << "\n";
387
388 fDest << " translation ";
389 fDest << X << " " << Y << " " << Z << "\n";
390
391 fDest << " children [" << "\n";
392
393 fDest << "\t" << "Shape {" << "\n";
394
395 SendMarkerColor( square );
396
397 // send shape with size
398 fDest << "\t\t" << "geometry Box {" << "\n";
399 fDest << "\t\t\t" << "size " << diameter << " " ;
400 fDest << diameter << " " ;
401 fDest << diameter << "\n" ;
402 fDest << "\t\t" << "}" << "\n";
403
404 fDest << "\t" << "}" << "\n"; // Shape
405
406 fDest << " ]" << "\n"; // children
407 fDest << " }" << "\n"; // Transform
408
409 fDest << " ]" << "\n"; // children
410 fDest << "}" << "\n"; // Anchor
411
412}
413
414void G4VRML2SCENEHANDLER::BeginModeling()
415{
416#if defined DEBUG_SCENE_FUNC
417 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
418 G4cout << "***** BeginModeling" << "\n" ;
419#endif
420 G4VSceneHandler::BeginModeling();
421
422}
423
424void G4VRML2SCENEHANDLER::EndModeling()
425{
426#if defined DEBUG_SCENE_FUNC
427 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
428 G4cout << "***** EndModeling " << "\n" ;
429#endif
430 G4VSceneHandler::EndModeling();
431}
432
433void G4VRML2SCENEHANDLER::BeginPrimitives(const G4Transform3D& objectTransformation)
434{
435 G4VSceneHandler::BeginPrimitives (objectTransformation);
436 fpObjectTransformation = &objectTransformation;
437#if defined DEBUG_SCENE_FUNC
438 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
439 G4cout << "***** BeginPrimitives " << "\n" ;
440#endif
441 VRMLBeginModeling();
442}
443
444void G4VRML2SCENEHANDLER::EndPrimitives()
445{
446#if defined DEBUG_SCENE_FUNC
447 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
448 G4cout << "***** EndPrimitives " << "\n" ;
449#endif
450 G4VSceneHandler::EndPrimitives();
451}
452
453void G4VRML2SCENEHANDLER::SendMaterialNode( const G4VisAttributes* pVA )
454{
455 // Initialization of drawing parameters
456 G4bool flagWF = false ;
457 G4double TRANSPARENCY = GetPVTransparency() ;
458
459 // Wireframe or not
460 const G4ViewParameters& cur_view_param = fpViewer -> GetViewParameters ();
461 if (pVA->IsForceDrawingStyle() &&
462 (pVA->GetForcedDrawingStyle() == G4VisAttributes::wireframe))
463 {
464 // wireframe style is assigned to this object
465 flagWF = true ;
466
467 } else if ( cur_view_param.GetDrawingStyle() == G4ViewParameters::wireframe )
468 {
469 // current viewing style is wireframe
470 flagWF = true ;
471 }
472
473 // VRML codes are generated below
474 if (!pVA) {
475
476 // Error recovery: Use default values of VRML browser
477 fDest << "\t\t" ;
478 fDest << "appearance Appearance { material Material {} }";
479 fDest << "\n";
480
481 } else {
482
483 const G4Color& color = pVA->GetColor();
484
485 fDest << "\t\t" << "appearance Appearance {" << "\n";
486 fDest << "\t\t\t" << "material Material {" << "\n";
487
488 // diffuse color
489 fDest << "\t\t\t\t" << "diffuseColor ";
490 fDest << color.GetRed() << " " ;
491 fDest << color.GetGreen() << " " ;
492 fDest << color.GetBlue() << "\n";
493
494 // emmisive color
495 // fDest << "\t\t\t\t" << "emissiveColor ";
496 // fDest << color.GetRed() << " " ;
497 // fDest << color.GetGreen() << " " ;
498 //fDest << color.GetBlue() << "\n";
499 //
500
501 // wireframe is expressed as transparency
502 if ( flagWF )
503 {
504 fDest << "\t\t\t\t" << "transparency " << TRANSPARENCY << "\n";
505 }
506
507 fDest << "\t\t\t" << "}" << "\n"; // material
508 fDest << "\t\t" << "}" << "\n"; // appearance
509 }
510
511}
512
513
514void G4VRML2SCENEHANDLER::SendMaterialNode()
515{
516 SendMaterialNode
517 ( fpViewer->GetApplicableVisAttributes (fpVisAttribs) );
518}
519
520
521void G4VRML2SCENEHANDLER::VRMLBeginModeling()
522{
523 if (!IS_CONNECTED ) {
524#if defined DEBUG_SCENE_FUNC
525 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
526 G4cout << "***** VRMLBeginModeling (started)" << "\n" ;
527#endif
528 this->connectPort();
529 fDest << "#VRML V2.0 utf8" << "\n";
530 fDest << "# Generated by VRML 2.0 driver of GEANT4\n" << "\n";
531 }
532}
533
534void G4VRML2SCENEHANDLER::VRMLEndModeling()
535{
536 if ( IS_CONNECTED ) {
537#if defined DEBUG_SCENE_FUNC
538 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
539 G4cout << "***** VRMLEndModeling (started)" << "\n" ;
540#endif
541 fDest << "#End of file." << "\n";
542 this->closePort();
543 }
544}
545
546void G4VRML2SCENEHANDLER::SendMarkerColor ( const G4VMarker& mark )
547{
548 const G4Color& color = GetColor( mark );
549
550 fDest << "\t\t" << "appearance Appearance {" << "\n";
551 fDest << "\t\t\t" << "material Material {" << "\n";
552 fDest << "\t\t\t\t" << "diffuseColor ";
553 fDest << color.GetRed() << " " ;
554 fDest << color.GetGreen() << " " ;
555 fDest << color.GetBlue() << "\n";
556 fDest << "\t\t\t\t" << "emissiveColor ";
557 fDest << color.GetRed() << " " ;
558 fDest << color.GetGreen() << " " ;
559 fDest << color.GetBlue() << "\n";
560 fDest << "\t\t\t" << "}" << "\n"; // material
561 fDest << "\t\t" << "}" << "\n"; // appearance
562
563}
564
565void
566G4VRML2SCENEHANDLER::SendMarkerWorldPosition ( const G4VMarker& mark )
567{
568 G4Point3D point = mark.GetPosition();
569
570 point.transform( *fpObjectTransformation );
571
572 fDest << " translation ";
573 fDest << point.x() << " " << point.y() << " " << point.z() << "\n";
574
575}
576
577void G4VRML2SCENEHANDLER::GetMarkerWorldPosition ( const G4VMarker& mark ,
578 double* pX ,
579 double* pY ,
580 double* pZ )
581{
582 G4Point3D point = mark.GetPosition();
583
584 point.transform( *fpObjectTransformation );
585
586 *pX = point.x() ;
587 *pY = point.y() ;
588 *pZ = point.z() ;
589}
590
591G4double G4VRML2SCENEHANDLER::GetMarkerHalfSize ( const G4VMarker& mark )
592{
593 //----- return value ( marker radius in 3d units)
594 G4double size = 1.0 ; // initialization
595
596 //----- parameters to calculate 3d size from 2d size
597 const double HALF_SCREEN_SIZE_2D = 300.0 ; // pixels
598 double zoom_factor = fpViewer->GetViewParameters().GetZoomFactor() ;
599 if ( zoom_factor <= 0.0 ) { zoom_factor = 1.0 ; }
600 double extent_radius_3d = GetScene()->GetExtent().GetExtentRadius() ;
601 if ( extent_radius_3d <= 0.0 ) { extent_radius_3d = 1.0 ; }
602
603 //----- get marker radius in 3D units
604 if ( mark.GetWorldSize() > 0.0 ) {
605
606 // get mark radius in 3D units
607 size = 0.5 * mark.GetWorldSize() ;
608
609 } else if ( mark.GetScreenSize() > 0.0 ) {
610
611 // local
612 double mark_radius_2d = 0.5 * mark.GetScreenSize() ;
613
614 // get mark radius in 3D units
615 size \
616 = extent_radius_3d * ( mark_radius_2d / HALF_SCREEN_SIZE_2D );
617 size *= zoom_factor ;
618
619 } else {
620 // local
621 double mark_radius_2d \
622 = fpViewer->GetViewParameters().GetDefaultMarker().GetScreenSize();
623 mark_radius_2d *= 0.1 ; // Magic number?
624
625 // get mark radius in 3D units
626 size \
627 = extent_radius_3d * ( mark_radius_2d / HALF_SCREEN_SIZE_2D );
628 size *= zoom_factor ;
629 }
630
631 //----- global rescaling
632 size *= fpViewer->GetViewParameters().GetGlobalMarkerScale();
633
634 //----- return size
635 return size ;
636
637}
638
639void G4VRML2SCENEHANDLER::SendLineColor ( const G4VisAttributes* pVA )
640{
641 const G4Color& color = pVA->GetColor();
642
643
644 fDest << "\t" << "appearance Appearance {" << "\n";
645 fDest << "\t\t" << "material Material {" << "\n";
646 fDest << "\t\t\t" << "diffuseColor ";
647 fDest << color.GetRed() << " " ;
648 fDest << color.GetGreen() << " " ;
649 fDest << color.GetBlue() << "\n";
650 fDest << "\t\t\t" << "emissiveColor ";
651 fDest << color.GetRed() << " " ;
652 fDest << color.GetGreen() << " " ;
653 fDest << color.GetBlue() << "\n";
654 fDest << "\t\t" << "}" << "\n"; // material
655 fDest << "\t" << "}" << "\n"; // appearance
656}
657
658G4double G4VRML2SCENEHANDLER::SetPVTransparency ()
659{
660
661 G4double TRANSPARENCY = 0.7 ; // initialization
662
663 if( getenv( "G4VRML_TRANSPARENCY" ) != NULL ) {
664
665 // get a value from the env value
666 sscanf( getenv("G4VRML_TRANSPARENCY"), "%lg", &TRANSPARENCY ) ;
667
668 // truncation
669 TRANSPARENCY = std::fabs ( TRANSPARENCY ) ;
670 if ( TRANSPARENCY > 1.0 ) { TRANSPARENCY = 1.0 ; }
671 }
672
673 fPVTransparency = TRANSPARENCY ;
674
675 return fPVTransparency ;
676}
677
678
679void G4VRML2SCENEHANDLER::ClearTransientStore()
680{
681 G4VSceneHandler::ClearTransientStore ();
682 // This is typically called after an update and before drawing hits
683 // of the next event. To simulate the clearing of "transients"
684 // (hits, etc.) the detector is redrawn...
685 if (fpViewer) {
686 fpViewer -> SetView ();
687 fpViewer -> ClearView ();
688 fpViewer -> DrawView ();
689 }
690}
691
692
693// End of file.
Note: See TracBrowser for help on using the repository browser.