G4ToolsSGViewer< SG_SESSION, SG_VIEWER > Class Template Reference

#include <G4ToolsSGViewer.hh>

Inheritance diagram for G4ToolsSGViewer< SG_SESSION, SG_VIEWER >:

Classes
class	Messenger

Public Member Functions
virtual void	key_press (const tools::sg::key_down_event &a_event)
virtual void	key_release (const tools::sg::key_up_event &)
virtual void	mouse_press (const tools::sg::mouse_down_event &a_event)
virtual void	mouse_release (const tools::sg::mouse_up_event &)
virtual void	mouse_move (const tools::sg::mouse_move_event &a_event)
virtual void	wheel_rotate (const tools::sg::wheel_rotate_event &a_event)
	G4ToolsSGViewer (SG_SESSION &a_session, G4ToolsSGSceneHandler &a_scene_handler, const G4String &a_name)
virtual	~G4ToolsSGViewer ()
virtual void	Initialise ()
virtual void	SetView ()
virtual void	ClearView ()
virtual void	DrawView ()
virtual void	ShowView ()
virtual void	FinishView ()
virtual void	SwitchToVisSubThread ()
virtual void	SwitchToMasterThread ()
Public Member Functions inherited from G4VViewer
	G4VViewer (G4VSceneHandler &, G4int id, const G4String &name="")
virtual	~G4VViewer ()
virtual void	ResetView ()
void	RefreshView ()
virtual G4bool	ReadyToDraw ()
std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)
virtual void	DoneWithMasterThread ()
virtual void	MovingToVisSubThread ()
virtual void	DoneWithVisSubThread ()
virtual void	MovingToMasterThread ()
void	InsertModelInSceneTree (G4VModel *)
const G4SceneTreeItem &	GetSceneTree ()
G4SceneTreeItem &	AccessSceneTree ()
void	UpdateGUISceneTree ()
const G4String &	GetName () const
const G4String &	GetShortName () const
void	SetName (const G4String &)
G4int	GetViewId () const
G4VSceneHandler *	GetSceneHandler () const
const G4ViewParameters &	GetViewParameters () const
const G4ViewParameters &	GetDefaultViewParameters () const
G4double	GetKernelVisitElapsedTimeSeconds () const
virtual const std::vector< G4ModelingParameters::VisAttributesModifier > *	GetPrivateVisAttributesModifiers () const
void	SetViewParameters (const G4ViewParameters &vp)
void	SetDefaultViewParameters (const G4ViewParameters &vp)
const G4VisAttributes *	GetApplicableVisAttributes (const G4VisAttributes *) const
void	SetNeedKernelVisit (G4bool need)
void	NeedKernelVisit ()
void	ProcessView ()

Protected Member Functions
	G4ToolsSGViewer (const G4ToolsSGViewer &a_from)
G4ToolsSGViewer &	operator= (const G4ToolsSGViewer &)
void	KernelVisitDecision ()
G4bool	CompareForKernelVisit (G4ViewParameters &vp)
void	CreateSG (tools::sg::base_camera *a_camera, const G4Vector3D &a_light_dir)
void	Export (const G4String &a_format, const G4String &a_file, G4bool a_do_transparency)
Protected Member Functions inherited from G4VViewer
void	SetTouchable (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath)
void	TouchableSetVisibility (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, G4bool visibility)
void	TouchableSetColour (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, const G4Colour &)

Protected Attributes
SG_SESSION &	fSGSession
G4ToolsSGSceneHandler &	fSGSceneHandler
SG_VIEWER *	fSGViewer
G4ViewParameters	fLastVP
G4bool	fKeyPressed
G4bool	fKeyShift
G4bool	fMousePressed
G4double	fMousePressedX
G4double	fMousePressedY
tools::sg::zb_manager	f_zb_mgr
tools::sg::gl2ps_manager	f_gl2ps_mgr
Protected Attributes inherited from G4VViewer
G4VSceneHandler &	fSceneHandler
G4int	fViewId
G4String	fName
G4String	fShortName
G4ViewParameters	fVP
G4ViewParameters	fDefaultVP
G4double	fKernelVisitElapsedTimeSeconds = 999.
G4SceneTreeItem	fSceneTree
G4bool	fNeedKernelVisit

Additional Inherited Members
Public Attributes inherited from G4VViewer
const G4int	fMaxNTouchables = 10000
G4bool	fCurtailDescent = false

Detailed Description

template<class SG_SESSION, class SG_VIEWER>
class G4ToolsSGViewer< SG_SESSION, SG_VIEWER >

Definition at line 53 of file G4ToolsSGViewer.hh.

Constructor & Destructor Documentation

G4ToolsSGViewer() [1/2]

template<class SG_SESSION, class SG_VIEWER>

G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::G4ToolsSGViewer ( SG_SESSION & a_session, G4ToolsSGSceneHandler & a_scene_handler, const G4String & a_name )

inline

Definition at line 122 of file G4ToolsSGViewer.hh.

  :parent(a_scene_handler,a_scene_handler.IncrementViewCount(),a_name)
  ,fSGSession(a_session)
  ,fSGSceneHandler(a_scene_handler)
  ,fSGViewer(nullptr)
  ,fKeyPressed(false)
  ,fKeyShift(false)
  ,fMousePressed(false)
  ,fMousePressedX(0)
  ,fMousePressedY(0)
  {
    //::printf("debug : G4ToolsSGViewer::G4ToolsSGViewer: %lu, %s\n",this,a_name.c_str());
    Messenger::Create();
  }

Referenced by G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Messenger::SetNewValue().

~G4ToolsSGViewer()

template<class SG_SESSION, class SG_VIEWER>

virtual G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::~G4ToolsSGViewer ( )

inlinevirtual

Definition at line 137 of file G4ToolsSGViewer.hh.

                             {
    //::printf("debug : G4ToolsSGViewer::~G4ToolsSGViewer: %lu\n",this);
    //WARNING : nodes may refer f_gl2ps_mgr, f_zb_mgr (to handle gstos (for GPU) or textures), then
    //          we have to delete them first.
    fSGViewer->sg().clear();
    delete fSGViewer;
  }

G4ToolsSGViewer() [2/2]

template<class SG_SESSION, class SG_VIEWER>

G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::G4ToolsSGViewer ( const G4ToolsSGViewer< SG_SESSION, SG_VIEWER > & a_from )

inlineprotected

Definition at line 145 of file G4ToolsSGViewer.hh.

  :parent(a_from)
  ,parent_interactor(a_from)
  ,fSGSession(a_from.fSGSession)
  ,fSGSceneHandler(a_from.fSGSceneHandler)
  ,fSGViewer(nullptr)
  ,fKeyPressed(false)
  ,fKeyShift(false)
  ,fMousePressed(false)
  ,fMousePressedX(0)
  ,fMousePressedY(0)
  {}

Member Function Documentation

ClearView()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::ClearView ( void )

inlinevirtual

Implements G4VViewer.

Reimplemented in G4ToolsSGOffscreenViewer.

Definition at line 274 of file G4ToolsSGViewer.hh.

{}

CompareForKernelVisit()

template<class SG_SESSION, class SG_VIEWER>

G4bool G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CompareForKernelVisit ( G4ViewParameters & vp )

inlineprotected

Definition at line 332 of file G4ToolsSGViewer.hh.

                                                     {
    // Typical comparison.  Taken from OpenInventor.
    if (
       (vp.GetDrawingStyle ()    != fVP.GetDrawingStyle ())    ||
       (vp.GetNumberOfCloudPoints()  != fVP.GetNumberOfCloudPoints())  ||
       (vp.IsAuxEdgeVisible ()   != fVP.IsAuxEdgeVisible ())   ||
       (vp.IsCulling ()          != fVP.IsCulling ())          ||
       (vp.IsCullingInvisible () != fVP.IsCullingInvisible ()) ||
       (vp.IsDensityCulling ()   != fVP.IsDensityCulling ())   ||
       (vp.IsCullingCovered ()   != fVP.IsCullingCovered ())   ||
       (vp.GetCBDAlgorithmNumber() !=
        fVP.GetCBDAlgorithmNumber())                           ||
       (vp.IsSection ()          != fVP.IsSection ())          ||
       (vp.IsCutaway ()          != fVP.IsCutaway ())          ||
       // This assumes use of generic clipping (sectioning, slicing,
       // DCUT, cutaway).  If a decision is made to implement locally,
       // this will need changing.  See G4OpenGLViewer::SetView,
       // G4OpenGLStoredViewer.cc::CompareForKernelVisit and
       // G4OpenGLStoredSceneHander::CreateSection/CutawayPolyhedron.
       (vp.IsExplode ()          != fVP.IsExplode ())          ||
       (vp.GetNoOfSides ()       != fVP.GetNoOfSides ())       ||
       (vp.GetGlobalMarkerScale()    != fVP.GetGlobalMarkerScale())    ||
       (vp.GetGlobalLineWidthScale() != fVP.GetGlobalLineWidthScale()) ||
       (vp.IsMarkerNotHidden ()  != fVP.IsMarkerNotHidden ())  ||
       (vp.GetDefaultVisAttributes()->GetColour() !=
        fVP.GetDefaultVisAttributes()->GetColour())            ||
       (vp.GetDefaultTextVisAttributes()->GetColour() !=
        fVP.GetDefaultTextVisAttributes()->GetColour())        ||
       (vp.GetBackgroundColour ()!= fVP.GetBackgroundColour ())||
       (vp.IsPicking ()          != fVP.IsPicking ())          ||
       // Scaling for Open Inventor is done by the scene handler so it
       // needs a kernel visit.  (In this respect, it differs from the
       // OpenGL drivers, where it's done in SetView.)
       (vp.GetScaleFactor ()     != fVP.GetScaleFactor ())     ||
       (vp.GetVisAttributesModifiers() !=
        fVP.GetVisAttributesModifiers())                       ||
       (vp.IsSpecialMeshRendering() !=
        fVP.IsSpecialMeshRendering())                          ||
       (vp.GetSpecialMeshRenderingOption() !=
        fVP.GetSpecialMeshRenderingOption())
       )
    return true;
 
    if (vp.IsDensityCulling () &&
        (vp.GetVisibleDensity () != fVP.GetVisibleDensity ()))
      return true;
 
    if (vp.GetCBDAlgorithmNumber() > 0) {
      if (vp.GetCBDParameters().size() != fVP.GetCBDParameters().size()) return true;
      else if (vp.GetCBDParameters() != fVP.GetCBDParameters()) return true;
    }
 
    if (vp.IsSection () &&
        (vp.GetSectionPlane () != fVP.GetSectionPlane ()))
      return true;
 
    if (vp.IsCutaway ()) {
      if (vp.GetCutawayMode() != fVP.GetCutawayMode()) return true;
      if (vp.GetCutawayPlanes ().size () !=
          fVP.GetCutawayPlanes ().size ()) return true;
      for (size_t i = 0; i < vp.GetCutawayPlanes().size(); ++i)
      if (vp.GetCutawayPlanes()[i] != fVP.GetCutawayPlanes()[i])
        return true;
    }
 
    if (vp.IsExplode () &&
        (vp.GetExplodeFactor () != fVP.GetExplodeFactor ()))
      return true;
 
    if (vp.IsSpecialMeshRendering() &&
        (vp.GetSpecialMeshVolumes() != fVP.GetSpecialMeshVolumes()))
      return true;
 
    return false;
  }

Referenced by G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::KernelVisitDecision().

CreateSG()

template<class SG_SESSION, class SG_VIEWER>

void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::CreateSG ( tools::sg::base_camera * a_camera, const G4Vector3D & a_light_dir )

inlineprotected

2D scene graph: ///////////////////////////////

3D scene graph: ///////////////////////////////

Definition at line 416 of file G4ToolsSGViewer.hh.

                                                                            {
    tools::sg::group& _parent = fSGViewer->sg();
    _parent.clear();    
 
    ///////////////////////////////////////////////////
    /// 2D scene graph: ///////////////////////////////
    ///////////////////////////////////////////////////
    tools::sg::separator* scene_2D = new tools::sg::separator;
    _parent.add(scene_2D);
    scene_2D->add(new tools::sg::noderef(fSGSceneHandler.GetTransient2DObjects()));
    scene_2D->add(new tools::sg::noderef(fSGSceneHandler.GetPersistent2DObjects()));
  
    ///////////////////////////////////////////////////
    /// 3D scene graph: ///////////////////////////////
    ///////////////////////////////////////////////////
    tools::sg::separator* scene_3D = new tools::sg::separator;
    _parent.add(scene_3D);
  
    scene_3D->add(a_camera);
  
   {tools::sg::torche* light = new tools::sg::torche;
    light->on = true;
    light->direction = tools::vec3f(-a_light_dir.x(),-a_light_dir.y(),-a_light_dir.z());
    light->ambient = tools::colorf(0.2f,0.2f,0.2f,1.0f);  //same as in G4OpenGLViewer.cc glLight(GL_LIGHT0,GL_AMBIENT and GL_DIFFUSE).
    light->color = tools::colorf(0.8f,0.8f,0.8f,1.0f);    //idem.
    scene_3D->add(light);}
  
   {tools::sg::blend* blend = new tools::sg::blend;
    blend->on = true; //to handle transparency.
    scene_3D->add(blend);}
 
    scene_3D->add(new tools::sg::noderef(fSGSceneHandler.GetTransient3DObjects()));
    scene_3D->add(new tools::sg::noderef(fSGSceneHandler.GetPersistent3DObjects()));
  }

Referenced by G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::SetView().

DrawView()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::DrawView ( )

inlinevirtual

Implements G4VViewer.

Reimplemented in G4ToolsSGOffscreenViewer.

Definition at line 276 of file G4ToolsSGViewer.hh.

                          {
    if (!fNeedKernelVisit) KernelVisitDecision();
    G4bool kernelVisitWasNeeded = fNeedKernelVisit; // Keep (ProcessView resets).
    fLastVP = fVP;
    ProcessView();  // Clears store and processes scene only if necessary.
    if (kernelVisitWasNeeded) {
      // We might need to do something if the kernel was visited.
    } else {
    }
    FinishView ();       // Flush streams and/or swap buffers.
  }

Referenced by G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::mouse_move(), G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::SwitchToMasterThread(), and G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::wheel_rotate().

Export()

template<class SG_SESSION, class SG_VIEWER>

void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Export ( const G4String & a_format, const G4String & a_file, G4bool a_do_transparency )

inlineprotected

Definition at line 451 of file G4ToolsSGViewer.hh.

                                                                                        {
    if(!fSGViewer) return;
    const G4Colour& back_color = fVP.GetBackgroundColour();
    bool top_to_bottom = false;  //if using tools::fpng, tools::toojpeg.
    if(!tools::sg::write_paper(G4cout,f_gl2ps_mgr,f_zb_mgr,
                    tools::fpng::write,tools::toojpeg::write,
                    float(back_color.GetRed()),float(back_color.GetGreen()),float(back_color.GetBlue()),float(back_color.GetAlpha()),
                    fSGViewer->sg(),fSGViewer->width(),fSGViewer->height(),
                    a_file,a_format,a_do_transparency,top_to_bottom,std::string(),std::string())) {
      G4cout << "G4ToolsSGViewer::Export: write_paper() failed." << G4endl;
      return;
    }
  }

Referenced by G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Messenger::SetNewValue().

FinishView()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::FinishView ( void )

inlinevirtual

Reimplemented from G4VViewer.

Reimplemented in G4ToolsSGOffscreenViewer.

Definition at line 290 of file G4ToolsSGViewer.hh.

                            {
    if(fSGViewer) {
      fSGSceneHandler.TouchPlotters(fSGViewer->sg());
      fSGViewer->show();
      fSGViewer->win_render();
      fSGSession.sync();
    }
  }

Referenced by G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::DrawView(), and G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::ShowView().

Initialise()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise ( )

inlinevirtual

create the viewer, set the scene graph ///////////////

Reimplemented from G4VViewer.

Reimplemented in G4ToolsSGOffscreenViewer, G4ToolsSGQtGLESViewer, and G4ToolsSGQtZBViewer.

Definition at line 159 of file G4ToolsSGViewer.hh.

                            {
    if(fSGViewer) return; //done.
    fVP.SetAutoRefresh(true);
    fDefaultVP.SetAutoRefresh(true);
    //::printf("debug : G4ToolsSGViewer::Initialise\n");
    //////////////////////////////////////////////////////////
    /// create the viewer, set the scene graph ///////////////
    //////////////////////////////////////////////////////////
    fSGViewer = new SG_VIEWER(fSGSession
      ,fVP.GetWindowAbsoluteLocationHintX(1440)
      ,fVP.GetWindowAbsoluteLocationHintY(900)
      ,fVP.GetWindowSizeHintX()
      ,fVP.GetWindowSizeHintY()
      ,fName);
    if(!fSGViewer->has_window()) {
      fViewId = -1;  // This flags an error.
      G4cerr << "G4ToolsSGViewer::Initialise : SG_VIEWER::has_window() failed." << G4endl;
      return;
    }
    fSGViewer->set_device_interactor(this);
  }

KernelVisitDecision()

template<class SG_SESSION, class SG_VIEWER>

void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::KernelVisitDecision ( )

inlineprotected

Definition at line 326 of file G4ToolsSGViewer.hh.

                              {
    if (CompareForKernelVisit(fLastVP)) {
      NeedKernelVisit ();  // Sets fNeedKernelVisit.
    }
  }

Referenced by G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::DrawView().

key_press()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::key_press ( const tools::sg::key_down_event & a_event )

inlinevirtual

Definition at line 57 of file G4ToolsSGViewer.hh.

                                                               {
    fKeyPressed = true;
    fKeyShift = a_event.key() == tools::sg::key_shift()?true:false;
  }

key_release()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::key_release ( const tools::sg::key_up_event & )

inlinevirtual

Definition at line 61 of file G4ToolsSGViewer.hh.

{fKeyPressed = false;}

mouse_move()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move ( const tools::sg::mouse_move_event & a_event )

inlinevirtual

Definition at line 68 of file G4ToolsSGViewer.hh.

                                                                  {
    G4double x = a_event.x();
    G4double y = a_event.y();
    G4double dx = x-fMousePressedX;
    G4double dy = y-fMousePressedY;
    fMousePressedX = x;
    fMousePressedY = y;
 
    if (fMousePressed) {
 
      if (fKeyPressed && fKeyShift) {  // Translation (pan)
 
        const G4double sceneRadius = fSGSceneHandler.GetScene()->GetExtent().GetExtentRadius();
        const G4double scale = 300;  // Roughly pixels per window, empirically chosen
        const G4double dxScene = dx*sceneRadius/scale;
        const G4double dyScene = dy*sceneRadius/scale;
        fVP.IncrementPan(-dxScene,dyScene);
 
      } else {  // Rotation
 
        // Simple ad-hoc algorithms
        const G4Vector3D& x_prime = fVP.GetViewpointDirection().cross(fVP.GetUpVector());
        const G4Vector3D& y_prime = x_prime.cross(fVP.GetViewpointDirection());
        const G4double scale = 200;  // Roughly pixels per window, empirically chosen
        G4Vector3D newViewpointDirection = fVP.GetViewpointDirection();
        newViewpointDirection += dx*x_prime/scale;
        newViewpointDirection += dy*y_prime/scale;
        fVP.SetViewpointDirection(newViewpointDirection.unit());
 
        if (fVP.GetRotationStyle() == G4ViewParameters::freeRotation) {
          G4Vector3D newUpVector = fVP.GetUpVector();
          newUpVector += dx*x_prime/scale;
          newUpVector += dy*y_prime/scale;
          fVP.SetUpVector(newUpVector.unit());
        }
      }
    }
 
    SetView();
    DrawView();
  }

mouse_press()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_press ( const tools::sg::mouse_down_event & a_event )

inlinevirtual

Definition at line 62 of file G4ToolsSGViewer.hh.

                                                                   {
    fMousePressed = true;
    fMousePressedX = a_event.x();
    fMousePressedY = a_event.y();
  }

mouse_release()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_release ( const tools::sg::mouse_up_event & )

inlinevirtual

Definition at line 67 of file G4ToolsSGViewer.hh.

{fMousePressed = false;}    

operator=()

template<class SG_SESSION, class SG_VIEWER>

G4ToolsSGViewer & G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::operator= ( const G4ToolsSGViewer< SG_SESSION, SG_VIEWER > & )

inlineprotected

Definition at line 157 of file G4ToolsSGViewer.hh.

{return *this;}

SetView()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView ( )

inlinevirtual

create scene graph ///////////////////////////////////

Implements G4VViewer.

Reimplemented in G4ToolsSGOffscreenViewer, G4ToolsSGQtGLESViewer, and G4ToolsSGQtZBViewer.

Definition at line 181 of file G4ToolsSGViewer.hh.

                         {
    //::printf("debug : G4ToolsSGViewer::SetView\n");
    if(!fSceneHandler.GetScene()) {
      fSGViewer->set_clear_color(0.3,0.3,0.3,1); //some grey color to signal the user that something is wrong.
      G4cerr << "G4ToolsSGViewer::SetView : no G4Scene.." << G4endl;
      return;
    }
 
    //////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////
    // Get radius of scene, etc.
    // Note that this procedure properly takes into account zoom, dolly and pan.
    const G4Point3D targetPoint
      = fSceneHandler.GetScene()->GetStandardTargetPoint() + fVP.GetCurrentTargetPoint ();
    G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
    if(radius<=0.) radius = 1.;
    const G4double cameraDistance = fVP.GetCameraDistance (radius);
    const G4Point3D cameraPosition = targetPoint + cameraDistance * fVP.GetViewpointDirection().unit();
    const G4Normal3D& up = fVP.GetUpVector ();  
    const G4double pnear  = fVP.GetNearDistance (cameraDistance, radius);
    const G4double pfar   = fVP.GetFarDistance  (cameraDistance, pnear, radius);
  //const G4double right  = fVP.GetFrontHalfHeight (pnear, radius);
  //const G4double left   = -right;
    const G4double top    = fVP.GetFrontHalfHeight (pnear, radius);
    const G4double bottom = -top;
    // sanity check :
    tools::vec3f dir(float(targetPoint.x()-cameraPosition.x()),
                     float(targetPoint.y()-cameraPosition.y()),
                     float(targetPoint.z()-cameraPosition.z()));
    if(!dir.length()) {
      fSGViewer->set_clear_color(0.3,0.3,0.3,1);
      G4cerr << "G4ToolsSGViewer::SetView : null size viewer area." << G4endl;
      return;      
    }
    
    //////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////
    /*
    G4cout << "debug : 0002 : radius " << radius << std::endl;
    G4cout << "debug : cameraDistance : " << cameraDistance << std::endl;
    G4cout << "debug : fieldHalfAngle : " << fVP.GetFieldHalfAngle() << std::endl;
    G4cout << "debug : zoomFactor : " << fVP.GetZoomFactor() << std::endl;
    G4cout << "debug : up : " << up.x() << " " << up.y() << " " << up.z() << std::endl;
    G4cout << "debug : targetPoint : " << targetPoint.x() << " " << targetPoint.y() << " " << targetPoint.z() << std::endl;
    G4cout << "debug : cameraPosition : " << cameraPosition.x() << " " << cameraPosition.y() << " " << cameraPosition.z() << std::endl;
    G4cout << "debug : camera : znear " << pnear << ", zfar " << pfar << std::endl;
    */
    //////////////////////////////////////////////////////////
    /// create scene graph ///////////////////////////////////
    //////////////////////////////////////////////////////////
    // Set projection, then create the tools::sg camera node :
    tools::sg::base_camera* _camera = nullptr;
    if (fVP.GetFieldHalfAngle() <= 0.) {
      //G4cout << "debug : camera : ortho : top " << top << " bottom " << bottom << " top-bottom " << top-bottom << std::endl;
      if((top-bottom)<=0) {
        fSGViewer->set_clear_color(0.3,0.3,0.3,1);
        G4cerr << "G4ToolsSGViewer::SetView : for ortho camera, (top-bottom)<=0." << G4endl;
        return;
      }
      tools::sg::ortho* ortho_camera = new tools::sg::ortho;
      ortho_camera->height.value(float(top-bottom));
      _camera = ortho_camera;
    } else {
      //G4cout << "debug : camera : perspec : heightAngle " << float(2*fVP.GetFieldHalfAngle()) << std::endl;
      tools::sg::perspective* perspective_camera = new tools::sg::perspective;
      perspective_camera->height_angle.value(float(2*fVP.GetFieldHalfAngle()));
      _camera = perspective_camera;
    }
    
    _camera->position.value
      (tools::vec3f(float(cameraPosition.x()),
            float(cameraPosition.y()),
            float(cameraPosition.z())));
    _camera->znear.value(float(pnear));
    _camera->zfar.value(float(pfar));
 
    _camera->look_at(dir,tools::vec3f(up.x(),up.y(),up.z()));  //same logic as in G4OpenInventorViewer.
 
    /*
    const G4Vector3D& lightDirection = fVP.GetLightpointDirection();
    G4cout << "debug : lightDirection : " << lightDirection.x() << " " << lightDirection.y() << " " << lightDirection.z() << std::endl;
    const G4Vector3D& actualLightDirection = fVP.GetActualLightpointDirection();
    G4cout << "debug : actualLightDirection : " << actualLightDirection.x() << " " << actualLightDirection.y() << " " << actualLightDirection.z() << std::endl;
    */
 
    CreateSG(_camera,fVP.GetActualLightpointDirection());
    
   {G4Color background = fVP.GetBackgroundColour ();
    fSGViewer->set_clear_color(float(background.GetRed()),float(background.GetGreen()),float(background.GetBlue()),1);}
  }

Referenced by G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::mouse_move(), and G4ToolsSGViewer< tools::offscreen::session, tools::offscreen::sg_viewer >::wheel_rotate().

ShowView()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::ShowView ( void )

inlinevirtual

Reimplemented from G4VViewer.

Reimplemented in G4ToolsSGOffscreenViewer.

Definition at line 288 of file G4ToolsSGViewer.hh.

{FinishView();}

SwitchToMasterThread()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SwitchToMasterThread ( )

inlinevirtual

Reimplemented from G4VViewer.

Definition at line 301 of file G4ToolsSGViewer.hh.

                                      {
    if (G4Threading::IsMultithreadedApplication()) {
      // I have not figured out how to draw during a run.
      //
      // Setting fNeedKernelVisit=true causes scene deletion and a complete rebuild,
      // including trajectories, hits, etc. from kept events.
      //
      // Clearly this is a limitation because even if you run 1000 events you only
      // get those kept (default 100), and even worse, if end-if-event-action is
      // "refresh", you only get one event (the last I think).
      //
      // Also, strictly, there is no need to rebuid run-duration models (detector),
      // but a complete rebuild is the easiest way (already imeplemented).
      //
      // Only do this if there are end-of-event models (e.g., trajectories) that
      // may require it.
      if (fSceneHandler.GetScene() && fSceneHandler.GetScene()->GetEndOfEventModelList().size()) {
        fNeedKernelVisit = true;
        DrawView();  // Draw trajectories, etc., from kept events
      }
    }
  }

SwitchToVisSubThread()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SwitchToVisSubThread ( )

inlinevirtual

Reimplemented from G4VViewer.

Definition at line 299 of file G4ToolsSGViewer.hh.

{}

wheel_rotate()

template<class SG_SESSION, class SG_VIEWER>

virtual void G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::wheel_rotate ( const tools::sg::wheel_rotate_event & a_event )

inlinevirtual

Definition at line 109 of file G4ToolsSGViewer.hh.

                                                                      {
    const G4double angleY = a_event.angle();
    if (fVP.GetFieldHalfAngle() == 0.) {  // Orthographic projection
      const G4double scale = 500;  // Empirically chosen
      fVP.MultiplyZoomFactor(1.+angleY/scale);
    } else {                              // Perspective projection
      const G4double delta = fSceneHandler.GetExtent().GetExtentRadius()/200.;  // Empirical
      fVP.SetDolly(fVP.GetDolly()+angleY*delta);
    }
    SetView();
    DrawView();
  }

Member Data Documentation

f_gl2ps_mgr

template<class SG_SESSION, class SG_VIEWER>

tools::sg::gl2ps_manager G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::f_gl2ps_mgr

protected

Definition at line 542 of file G4ToolsSGViewer.hh.

f_zb_mgr

template<class SG_SESSION, class SG_VIEWER>

tools::sg::zb_manager G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::f_zb_mgr

protected

Definition at line 541 of file G4ToolsSGViewer.hh.

fKeyPressed

template<class SG_SESSION, class SG_VIEWER>

G4bool G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fKeyPressed

protected

Definition at line 536 of file G4ToolsSGViewer.hh.

fKeyShift

template<class SG_SESSION, class SG_VIEWER>

G4bool G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fKeyShift

protected

Definition at line 537 of file G4ToolsSGViewer.hh.

fLastVP

template<class SG_SESSION, class SG_VIEWER>

G4ViewParameters G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fLastVP

protected

Definition at line 534 of file G4ToolsSGViewer.hh.

fMousePressed

template<class SG_SESSION, class SG_VIEWER>

G4bool G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fMousePressed

protected

Definition at line 538 of file G4ToolsSGViewer.hh.

fMousePressedX

template<class SG_SESSION, class SG_VIEWER>

G4double G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fMousePressedX

protected

Definition at line 539 of file G4ToolsSGViewer.hh.

fMousePressedY

template<class SG_SESSION, class SG_VIEWER>

G4double G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fMousePressedY

protected

Definition at line 539 of file G4ToolsSGViewer.hh.

fSGSceneHandler

template<class SG_SESSION, class SG_VIEWER>

G4ToolsSGSceneHandler& G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fSGSceneHandler

protected

Definition at line 532 of file G4ToolsSGViewer.hh.

fSGSession

template<class SG_SESSION, class SG_VIEWER>

SG_SESSION& G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fSGSession

protected

Definition at line 531 of file G4ToolsSGViewer.hh.

fSGViewer

template<class SG_SESSION, class SG_VIEWER>

SG_VIEWER* G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fSGViewer

protected

Definition at line 533 of file G4ToolsSGViewer.hh.

---

The documentation for this class was generated from the following file:

• G4ToolsSGViewer.hh