G4VRML1SceneHandlerFunc.icc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
// $Id$
//
// G4VRML1SceneHandlerFunc.icc
// Satoshi Tanaka & Yasuhide Sawada

#include <CLHEP/Units/SystemOfUnits.h>

#include "G4VisManager.hh"

//#define DEBUG_SCENE_FUNC

// MACRO
#define ADDTHIS_WITH_NAME(Solid)        \
        fCurrentDEF = #Solid "_" + Solid.GetName(); \
        RequestPrimitives(Solid); \
        fCurrentDEF = "";

// End of MACRO

void G4VRML1SCENEHANDLER::AddSolid(const G4Trd& trd)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddSolid trd" << "\n" ;
#endif
        VRMLBeginModeling () ;
        ADDTHIS_WITH_NAME(trd)
}

void G4VRML1SCENEHANDLER::AddSolid(const G4Trap& trap)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddSolid trap" << "\n" ;
#endif
        VRMLBeginModeling () ;
        ADDTHIS_WITH_NAME(trap)
}

void G4VRML1SCENEHANDLER::AddSolid(const G4Para& para)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddSolid para" << "\n" ;
#endif
        VRMLBeginModeling () ;
        ADDTHIS_WITH_NAME(para)
}

void G4VRML1SCENEHANDLER::AddSolid(const G4Torus& torus )
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddSolid torus" << "\n" ;
#endif
        VRMLBeginModeling () ;
        ADDTHIS_WITH_NAME(torus)
}


void G4VRML1SCENEHANDLER::AddSolid(const G4VSolid& vsolid)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddSolid vsolid" << "\n" ;
#endif
        VRMLBeginModeling () ;
        ADDTHIS_WITH_NAME(vsolid)
}

void G4VRML1SCENEHANDLER::AddSolid(const G4Tubs& tubs)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddSolid tubs" << "\n" ;
#endif
        VRMLBeginModeling () ;

        // set current name
        fCurrentDEF = "tubs_" + tubs.GetName();

        // Get data
        const G4double R  = tubs.GetRMax(); // outside radius
        const G4double r  = tubs.GetRMin(); // inside radius
        const G4double dz = tubs.GetDz();   // half length in z
        const G4double dp = tubs.GetDPhi(); // angle interval

        // Send data
        if ( r == 0.0 && dp >= 360. * CLHEP::deg ) {
                // Send a built-in VRML node (Cylinder)
                fDest << "Separator {" << "\n";
                SendMatrixTransformNode( fObjectTransformation );

                fDest << "\t" << "DEF " << fCurrentDEF << " Separator {" << "\n";
                SendMaterialNode();
                SendCylinderNode(R, dz * 2);
                fDest << "\t" << "}" << "\n"; // DEF Separator
                fDest << "}" << "\n"; // Separator
        } else {
                // call AddPrimitive(Polyhedron)
                RequestPrimitives(tubs); 
        }

        // reset current name to null
        fCurrentDEF = "";
}


void G4VRML1SCENEHANDLER::AddSolid(const G4Cons& cons)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddSolid cons" << "\n" ;
#endif
        VRMLBeginModeling () ;

        // set current name
        fCurrentDEF = "cons_" + cons.GetName();

        // Get data
        const G4double r1 = cons.GetRmin1(); // inside radius  at -dz
        const G4double R1 = cons.GetRmax1(); // outside radius at -dz
        const G4double r2 = cons.GetRmin2(); // inside radius  at +dz
        const G4double R2 = cons.GetRmax2(); // outside radius at +dz
        const G4double dz = cons.GetDz();    // half length in z
        //const G4double sp = cons.GetSPhi();  // starting angle
        const G4double dp = cons.GetDPhi();  // angle width

        // Send data
        if ( r1 == 0.0 && r2 == 0.0 && R1 == R2 && dp >= 360. * CLHEP::deg) {
                // Send a built-in VRML node (Cylinder)
                fDest << "Separator {" << "\n";
                SendMatrixTransformNode( fObjectTransformation );

                fDest << "\t" << "DEF " << fCurrentDEF << " Separator {" << "\n";
                SendMaterialNode();
                SendCylinderNode(R1, dz * 2);
                fDest << "\t" << "}" << "\n"; // DEF Separator
                fDest << "}" << "\n"; // Separator
        } else {
                // call AddPrimitive(Polyhedron)
                RequestPrimitives(cons); 
        }

        // reset current name to null
        fCurrentDEF = "";
}

void G4VRML1SCENEHANDLER::AddSolid(const G4Box& box)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddSolid box" << "\n" ;
#endif
        VRMLBeginModeling () ;

        // set current name
        fCurrentDEF = "box_" + box.GetName();

        // Send a built-in VRML node (Cube)
        fDest << "Separator {" << "\n";

        //fDest << "\t" << "renderCulling ON" << "\n";
        SendMatrixTransformNode( fObjectTransformation );

        fDest << "\t" << "DEF " << fCurrentDEF << " Separator {" << "\n";
        SendMaterialNode();
        SendCubeNode(box.GetXHalfLength() * 2, box.GetYHalfLength() * 2, box.GetZHalfLength() * 2);
        fDest << "\t" << "}" << "\n"; // DEF Separator

        fDest << "}" << "\n"; // Separator

        // reset current name to null
        fCurrentDEF = "";
}


void G4VRML1SCENEHANDLER::AddSolid(const G4Sphere& sphere)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddSolid sphere" << "\n" ;
#endif
        VRMLBeginModeling () ;

        // set current name
        fCurrentDEF = "sphere_" + sphere.GetName();

        // Get data
        G4double  dphi   = sphere.GetDPhi  () ;
        G4double  dtheta = sphere.GetDTheta() ;
        G4double  rmax   = sphere.GetRmax  () ;
        G4double  rmin   = sphere.GetRmin  () ;

        // Send data
        if ( (dphi >= 360. * CLHEP::deg) && (dtheta >= 180. * CLHEP::deg) && (rmin == 0.0)  ) {
                // Send a built-in VRML node (Sphere)
                fDest << "Separator {" << "\n";
                SendMatrixTransformNode( fObjectTransformation );

                fDest << "\t" << "DEF " << fCurrentDEF << " Separator {" << "\n";
                SendMaterialNode();
                SendSphereNode( rmax );
                fDest << "\t" << "}" << "\n"; // DEF Separator
                fDest << "}" << "\n"; // Separator
        } else {
                        // call AddPrimitive(Polyhedron)
                        RequestPrimitives( sphere ); 
        }

        // reset current name to null
        fCurrentDEF = "";
}

void G4VRML1SCENEHANDLER::AddPrimitive(const G4Polyline& polyline)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddPrimitive polyline" << "\n" ;
#endif 
        if (fProcessing2D) {
                static G4bool warned = false;
                if (!warned) {
                        warned = true;
                        G4Exception
                        ("G4VRML1SCENEHANDLER::AddPrimitive (const G4Polyline&)",
                        "VRML-1001", JustWarning,
                        "2D polylines not implemented.  Ignored.");
                }
                return;
        }

        VRMLBeginModeling () ;  

        fDest << "Separator {" << "\n";

        SendMatrixTransformNode (fObjectTransformation );

        SendMaterialNode( polyline.GetVisAttributes() );

        fDest << "\t" << "Coordinate3 {" << "\n";
        fDest << "\t\t" << "point [" << "\n";
        G4int e, i;
        for (i = 0, e = polyline.size(); e; i++, e--) {
                fDest << "\t\t\t";
                fDest << polyline[i].x() << " ";
                fDest << polyline[i].y() << " ";
                fDest << polyline[i].z() << "," << "\n";
        }
        fDest << "\t\t" << "]" << "\n";
        fDest << "\t" << "}" << "\n"; // Coordinate3

        fDest << "\t" << "IndexedLineSet {" << "\n";
        fDest << "\t\t" << "coordIndex [";
        for (i = 0, e = polyline.size(); e; i++, e--) {
                if (i % 10 == 0)
                        fDest << "\n" << "\t\t\t";
                fDest << i << ", ";
        }
        fDest << "-1" << "\n";
        fDest << "\t\t" << "]" << "\n";
        fDest << "\t" << "}" << "\n"; // IndexedLineSet

        fDest << "}" << "\n"; // Separator
}

void G4VRML1SCENEHANDLER::AddPrimitive(const G4Polyhedron& polyhedron)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddPrimitive(G4Polyhedron)" << "\n";
#endif

        if (polyhedron.GetNoFacets() == 0) return;

        if (fProcessing2D) {
                static G4bool warned = false;
                if (!warned) {
                        warned = true;
                        G4Exception
                        ("G4VRML1SCENEHANDLER::AddPrimitive (const G4Polyhedron&)",
                        "VRML-1002", JustWarning,
                        "2D polyhedra not implemented.  Ignored.");
                }
                return;
        }

        VRMLBeginModeling () ;

        fDest << "Separator {" << "\n";

        SendMatrixTransformNode( fObjectTransformation );

        fDest << "\t";
        if (fCurrentDEF != "")
                fDest << "DEF " << fCurrentDEF << " ";

        fDest << "Separator {" << "\n";

        //fDest << "\t\t" << "renderCulling ON" << "\n";

        fDest << "\t\t" << "ShapeHints {" << "\n";
        fDest << "\t\t\t" << "vertexOrdering COUNTERCLOCKWISE" << "\n";
        fDest << "\t\t\t" << "shapeType SOLID" << "\n";
        fDest << "\t\t\t" << "faceType CONVEX" << "\n";
        fDest << "\t\t" << "}" << "\n";

        SendMaterialNode();

        fDest << "\t\t" << "Coordinate3 {" << "\n";
        fDest << "\t\t\t" << "point [" << "\n";
        G4int i, j;
        for (i = 1, j = polyhedron.GetNoVertices(); j; j--, i++) {
                G4Point3D point = polyhedron.GetVertex(i);
                fDest << "\t\t\t\t";
                fDest << point.x() << " ";
                fDest << point.y() << " ";
                fDest << point.z() << "," << "\n";
        }
        fDest << "\t\t\t" << "]" << "\n";
        fDest << "\t\t" << "}" << "\n"; // Coordinate3

        fDest << "\t\t" << "IndexedFaceSet {" << "\n";
        fDest << "\t\t\t" << "coordIndex [" << "\n";

        // facet loop
        G4int f;
        for (f = polyhedron.GetNoFacets(); f; f--) {

                // edge loop  
                G4bool notLastEdge;
                G4int index = -1, edgeFlag = 1;
                fDest << "\t\t\t\t";
                do {
                        notLastEdge = polyhedron.GetNextVertexIndex(index, edgeFlag);
                        fDest << index - 1 << ", ";
                } while (notLastEdge);
                fDest << "-1," << "\n";
        }
        fDest << "\t\t\t" << "]" << "\n";
        fDest << "\t\t" << "}" << "\n"; // IndexFaceSet

        fDest << "\t" << "}" << "\n"; // (DEF) Separator
        fDest << "}" << "\n"; // Separator

}


void G4VRML1SCENEHANDLER::AddPrimitive(const G4NURBS&)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddPrimitive nurbs" << "\n" ;
#endif 
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "G4VRML1File::AddPrimitive(G4NURBS&): not implemented. " << "\n" ;
        VRMLBeginModeling () ;

}

void G4VRML1SCENEHANDLER::AddPrimitive( const G4Text& ) 
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddPrimitive text" << "\n" ;
#endif
        /*** You might need this
        if (fProcessing2D) {
                static G4bool warned = false;
                if (!warned) {
                        warned = true;
                        G4Exception
                        ("G4VRML1SCENEHANDLER::AddPrimitive (const G4Text&)",
                        "VRML-1003", JustWarning,
                        "2D text not implemented.  Ignored.");
                }
                return;
        }
        ***/

  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout <<
          "***** void G4VRML1SCENEHANDLER::AddPrimitive( const G4Text& text )"
          " not implemented yet."
             << "\n";

        VRMLBeginModeling () ;
}

void G4VRML1SCENEHANDLER::AddPrimitive( const G4Circle& circle ) 
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddPrimitive circle" << "\n" ;
#endif

        if (fProcessing2D) {
                static G4bool warned = false;
                if (!warned) {
                        warned = true;
                        G4Exception
                        ("G4VRML1SCENEHANDLER::AddPrimitive (const G4Circle&)",
                        "VRML-1004", JustWarning,
                        "2D circles not implemented.  Ignored.");
                }
                return;
        }

        VRMLBeginModeling () ;

        // begin sending a mark
        fDest << "Separator {" << "\n";

        // send color 
        SendMarkerColor    ( circle ) ;

        // position 
        SendMarkerWorldPosition ( circle ) ;

        // Calc size 
        G4double size = GetMarkerHalfSize ( circle );

        // send shape with size 
        fDest << "\t" << "Sphere {" << "\n";
        fDest << "\t\t" << "radius " << size << "\n";
        fDest << "\t" << "}" << "\n";

        // end sending a mark
        fDest << "}" << "\n"; // Separator
}


void G4VRML1SCENEHANDLER::AddPrimitive(const G4Square& square)
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** AddPrimitive square" << "\n" ;
#endif

        if (fProcessing2D) {
                static G4bool warned = false;
                if (!warned) {
                        warned = true;
                        G4Exception
                        ("G4VRML1SCENEHANDLER::AddPrimitive (const G4Square&)",
                        "VRML-1005", JustWarning,
                        "2D squares not implemented.  Ignored.");
                }
                return;
        }

        VRMLBeginModeling () ;

        // begin sending a mark
        fDest << "Separator {" << "\n";

        // send color 
        SendMarkerColor    ( square );

        // position 
        SendMarkerWorldPosition ( square );

        // Calc size 
        G4double size = GetMarkerHalfSize ( square );
        size *= 2.;

        // send shape with size 
        fDest << "\t" << "Cube {" << "\n";
        fDest << "\t\t" << "width "  << size << "\n";
        fDest << "\t\t" << "height " << size << "\n";
        fDest << "\t\t" << "depth "  << size << "\n";
        fDest << "\t" << "}" << "\n";

        // end sending a mark
        fDest << "}" << "\n"; // Separator
}

void G4VRML1SCENEHANDLER::BeginModeling()
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** BeginModeling " << "\n" ;
#endif
        G4VSceneHandler::BeginModeling();
}

void G4VRML1SCENEHANDLER::EndModeling()
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** EndModeling " << "\n" ;
#endif
        G4VSceneHandler::EndModeling();
}

void G4VRML1SCENEHANDLER::BeginPrimitives(const G4Transform3D& objectTransformation)
{
  G4VSceneHandler::BeginPrimitives (objectTransformation);
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** BeginPrimitives " << "\n" ;
#endif
        VRMLBeginModeling();
}

void G4VRML1SCENEHANDLER::EndPrimitives()
{
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** EndPrimitives " << "\n" ;
#endif
  G4VSceneHandler::EndPrimitives();
}

void G4VRML1SCENEHANDLER::SendMaterialNode( const G4VisAttributes*  pVA )
{
//      const double TRANSPARENCY = 0.9 ; 
        const double TRANSPARENCY = 0.5 ; 

        if (!pVA)
                return;

        const G4Color& color = pVA->GetColor();

        fDest << "\t\t" << "Material {" << "\n";

        if (pVA->IsForceDrawingStyle() &&
           (pVA->GetForcedDrawingStyle() == G4VisAttributes::wireframe)) {
                fDest << "\t\t\t" << "transparency " << TRANSPARENCY << "\n";
        }

        fDest << "\t\t\t" << "diffuseColor";
        fDest << " " << color.GetRed();
        fDest << " " << color.GetGreen();
        fDest << " " << color.GetBlue();
        fDest << "\n";
        fDest << "\t\t" << "}" << "\n";
}


void G4VRML1SCENEHANDLER::SendMaterialNode()
{
        SendMaterialNode
        ( fpViewer->GetApplicableVisAttributes (fpVisAttribs) );
}


void G4VRML1SCENEHANDLER::SendMatrixTransformNode(const G4Transform3D& trans)
{
        G4Point3D  B  (0.0, 0.0, 0.0);

        G4Point3D  x1 (1.0, 0.0, 0.0);
        G4Point3D  y1 (0.0, 1.0, 0.0);

        G4Vector3D e1 (1.0, 0.0, 0.0);
        G4Vector3D e2 (0.0, 1.0, 0.0);
        G4Vector3D e3 (0.0, 0.0, 1.0);

                //----- transformed origin of body coord
        B.transform(trans);

                //----- transformed base vectors of body coord
        x1.transform(trans);
        e1 = x1 - B;

        y1.transform(trans);
        e2 = y1 - B;

        e3 = e1.cross(e2);

        e1 = e1.unit(); // normalize again for accuracy
        e2 = e2.unit(); //
        e3 = e3.unit(); //

        fDest << "\t" << "MatrixTransform {" << "\n";
        fDest << "\t\t" << "matrix ";
        fDest << e1.x() << " " << e1.y() << " " << e1.z() << " 0 ";
        fDest << e2.x() << " " << e2.y() << " " << e2.z() << " 0 ";
        fDest << e3.x() << " " << e3.y() << " " << e3.z() << " 0 ";
        fDest << B.x()  << " " << B.y()  << " " << B.z()  << " 1" << "\n";
        fDest << "\t" << "}" << "\n";
}

void G4VRML1SCENEHANDLER::SendCubeNode(G4double w, G4double h, G4double d)
{
        fDest << "\t\t" << "Cube {" << "\n";
        fDest << "\t\t\t" << "width "  << w << "\n";
        fDest << "\t\t\t" << "height " << h << "\n";
        fDest << "\t\t\t" << "depth "  << d << "\n";
        fDest << "\t\t" << "}" << "\n";
}

void G4VRML1SCENEHANDLER::SendCylinderNode(G4double R, G4double h)
{
        fDest << "\t\t" << "Transform {" << "\n";
        fDest << "\t\t\t" << "rotation 1 0 0 " << (90. * CLHEP::deg) << "\n";
        fDest << "\t\t" << "}" << "\n";

        fDest << "\t\t" << "Cylinder {" << "\n";
        fDest << "\t\t\t" << "radius " << R << "\n";
        fDest << "\t\t\t" << "height " << h << "\n";
        fDest << "\t\t" << "}" << "\n";
}

void G4VRML1SCENEHANDLER::SendSphereNode(G4double R)
{
        fDest << "\t\t" << "Sphere {" << "\n";
        fDest << "\t\t\t" << "radius " << R << "\n";
        fDest << "\t\t" << "}" << "\n";
}

void G4VRML1SCENEHANDLER::VRMLBeginModeling()
{
        if (!IS_CONNECTED ) {
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** VRMLBeginModeling() (started)" << "\n" ;
#endif
                this->connectPort();
                fDest << "#VRML V1.0 ascii" << "\n";
                fDest << "# Generated by VRML 1.0 driver of GEANT4\n" << "\n";
        }
}

void G4VRML1SCENEHANDLER::VRMLEndModeling()
{
        if ( IS_CONNECTED ) {
#if defined DEBUG_SCENE_FUNC
  if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
        G4cout << "***** VRMLEndModeling() (started)" << "\n" ;
#endif

                fDest << "#End of file." << "\n";
                this->closePort();
        }
}

void      G4VRML1SCENEHANDLER::SendMarkerColor ( const G4VMarker& mark ) 
{
        const G4Color& color = GetColor( mark );

        fDest << "\t" << "Material {" << "\n";
        fDest << "\t\t";
        fDest << "ambientColor [] ";
        fDest << "specularColor [] ";
        fDest << "\t\t" << "diffuseColor";
        fDest << " " << color.GetRed();
        fDest << " " << color.GetGreen();
        fDest << " " << color.GetBlue();
        fDest << "\n";
        fDest << "\t\t" << "emissiveColor";
        fDest << " " << color.GetRed();
        fDest << " " << color.GetGreen();
        fDest << " " << color.GetBlue();
        fDest << "\n";
        fDest << "\t" << "}" << "\n";
}

void      
G4VRML1SCENEHANDLER::SendMarkerWorldPosition ( const G4VMarker& mark )
{
        G4Point3D point = mark.GetPosition();

        SendMatrixTransformNode( fObjectTransformation );

        fDest << "\t\t" << "Transform {" << "\n";
        fDest << "\t\t\t" << "translation ";
        fDest << point.x() << " " << point.y() << " " << point.z() << "\n";
        fDest << "\t\t" << "}" << "\n" ;
}


G4double  G4VRML1SCENEHANDLER::GetMarkerHalfSize ( const G4VMarker& mark ) 
{
        //----- return value ( marker radius in 3d units) 
        G4double size       = 1.0 ; // initialization

        //----- parameters to calculate 3d size from 2d size
        const double HALF_SCREEN_SIZE_2D = 300.0 ; // pixels
        double zoom_factor  = fpViewer->GetViewParameters().GetZoomFactor() ;
        if ( zoom_factor <=  0.0 ) { zoom_factor = 1.0 ; }
        double extent_radius_3d = GetScene()->GetExtent().GetExtentRadius() ;
        if ( extent_radius_3d <= 0.0 ) { extent_radius_3d = 1.0 ; } 

        //----- get marker radius in 3D units
        if        ( mark.GetWorldSize() > 0.0 ) {
                // get mark radius in 3D units
                size = 0.5 * mark.GetWorldSize()  ; 

        } else if ( mark.GetScreenSize() > 0.0 ) {
                // local
                double mark_radius_2d   = 0.5 * mark.GetScreenSize() ;

                // get mark radius in 3D units
                size \
                 = extent_radius_3d * ( mark_radius_2d / HALF_SCREEN_SIZE_2D );
                size *= zoom_factor ;

        } else {
                // local
                double mark_radius_2d \
                 = fpViewer->GetViewParameters().GetDefaultMarker().GetScreenSize();
                mark_radius_2d *= 0.1 ; // Magic number?

                // get mark radius in 3D units
                size \
                 = extent_radius_3d * ( mark_radius_2d / HALF_SCREEN_SIZE_2D );
                size *= zoom_factor ;
        }

                //----- global rescaling
        size *= fpViewer->GetViewParameters().GetGlobalMarkerScale(); 

                //----- return size
        return size ;

} 

void G4VRML1SCENEHANDLER::ClearTransientStore() 
{
  // This is typically called after an update and before drawing hits
  // of the next event.  To simulate the clearing of "transients"
  // (hits, etc.) the detector is redrawn...
  if (fpViewer) {
    fpViewer -> SetView ();
    fpViewer -> ClearView ();
    fpViewer -> DrawView ();
  }
}


// #undef ADDTHIS_WITH_NAME(Solid)
// #undef MAKE_NAME(Solid)
// End of file.

---