#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 &)
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 ()
G4bool	GetWindowSize (unsigned int &a_w, unsigned int &a_h)
G4bool	GetRenderAreaSize (unsigned int &a_w, unsigned int &a_h)
virtual void	EmitWindowRender ()
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	SwitchToVisSubThread ()
virtual void	DoneWithVisSubThread ()
virtual void	MovingToMasterThread ()
virtual void	SwitchToMasterThread ()
void	InsertModelInSceneTree (G4VModel *)
const G4SceneTreeItem &	GetSceneTree ()
G4SceneTreeItem &	AccessSceneTree ()
void	UpdateGUISceneTree ()
void	UpdateGUIControlWidgets ()
void	UpdateGUIDrawingStyle ()
void	UpdateGUIProjectionStyle ()
void	UpdateGUITransparencySlider ()
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 ()
void	ProcessTransients ()
void	ZoomFromMouseWheel (G4double delta, G4bool shift=false, G4double xPos=0, G4double yPos=0)
Public Member Functions inherited from G4ToolsSG_viewer
	G4ToolsSG_viewer ()
virtual	~G4ToolsSG_viewer ()

Protected Member Functions
	G4ToolsSGViewer (const G4ToolsSGViewer &a_from)
G4ToolsSGViewer &	operator= (const G4ToolsSGViewer &)
void	KernelVisitDecision ()
G4bool	CompareForKernelVisit (G4ViewParameters &vp)
G4bool	CompareForTransientsRedraw (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)
G4double	GetSceneNearWidth ()
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 Member Functions inherited from G4ToolsSG_viewer
	G4ToolsSG_viewer (const G4ToolsSG_viewer &)
G4ToolsSG_viewer &	operator= (const G4ToolsSG_viewer &)

Protected Attributes
SG_SESSION &	fSGSession
G4ToolsSGSceneHandler &	fSGSceneHandler
SG_VIEWER *	fSGViewer
G4ViewParameters	fLastVP
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
G4bool	fTransientsNeedRedrawing

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

Detailed Description

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

Definition at line 65 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 126 of file G4ToolsSGViewer.hh.

  :parent(a_scene_handler,a_scene_handler.IncrementViewCount(),a_name)
  ,fSGSession(a_session)
  ,fSGSceneHandler(a_scene_handler)
  ,fSGViewer(nullptr)
  ,fMousePressed(false)
  ,fMousePressedX(0)
  ,fMousePressedY(0)
  {
    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 138 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 146 of file G4ToolsSGViewer.hh.

  :parent(a_from)
  ,parent_viewer(a_from)
  ,parent_interactor(a_from)
  ,fSGSession(a_from.fSGSession)
  ,fSGSceneHandler(a_from.fSGSceneHandler)
  ,fSGViewer(nullptr)
  ,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 290 of file G4ToolsSGViewer.hh.

290{}

◆ CompareForKernelVisit()

template<class SG_SESSION, class SG_VIEWER>

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

inlineprotected

Definition at line 346 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 ToolsSG 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())||
       (vp.GetTransparencyByDepth() != fVP.GetTransparencyByDepth()) ||
       (vp.IsDotsSmooth()        != fVP.IsDotsSmooth())        ||
       (vp.GetDotsSize()         != fVP.GetDotsSize())
       )
    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;
 
    if (vp.GetTransparencyByDepth() > 0. &&
        vp.GetTransparencyByDepthOption() != fVP.GetTransparencyByDepthOption())
      return true;
 
    return false;
  }

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

◆ CompareForTransientsRedraw()

template<class SG_SESSION, class SG_VIEWER>

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

inlineprotected

Definition at line 426 of file G4ToolsSGViewer.hh.

                                                          {
    if (vp.GetTimeParameters() != fVP.GetTimeParameters()) {
      return fTransientsNeedRedrawing = true;
    }
    return false;
  }

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

◆ 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 434 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::shade_model* shade_model = new tools::sg::shade_model;
    shade_model->model = tools::sg::shade_smooth;
    scene_3D->add(shade_model);}
 
   {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 292 of file G4ToolsSGViewer.hh.

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

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

◆ EmitWindowRender()

template<class SG_SESSION, class SG_VIEWER>

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

inlinevirtual

Reimplemented from G4ToolsSG_viewer.

Definition at line 334 of file G4ToolsSGViewer.hh.

                                  {
    if(!fSGViewer) return;
    fSGViewer->emit_win_render();
  }

◆ 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 473 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 314 of file G4ToolsSGViewer.hh.

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

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

◆ GetRenderAreaSize()

template<class SG_SESSION, class SG_VIEWER>

G4bool G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::GetRenderAreaSize	(	unsigned int &	a_w,
		unsigned int &	a_h )

inline

Definition at line 327 of file G4ToolsSGViewer.hh.

                                                                 {
    if (!fSGViewer) {a_w = 0; a_h = 0; return false;}
    fSGViewer->render_area_size(a_w, a_h);
    return true;
  }

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

◆ GetSceneNearWidth()

template<class SG_SESSION, class SG_VIEWER>

G4double G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::GetSceneNearWidth ( )

inlineprotectedvirtual

Reimplemented from G4VViewer.

Definition at line 487 of file G4ToolsSGViewer.hh.

                               {
    if (!fSGSceneHandler.GetScene()) {
      return 0;
    }
    const G4Point3D targetPoint =
      fSGSceneHandler.GetScene()->GetStandardTargetPoint() + fVP.GetCurrentTargetPoint();
    G4double radius = fSGSceneHandler.GetScene()->GetExtent().GetExtentRadius();
    if (radius <= 0.) radius = 1.;
    const G4double cameraDistance = fVP.GetCameraDistance(radius);
    const G4double pnear = fVP.GetNearDistance(cameraDistance, radius);
    
    G4double frontHalfHeight;
    if (fVP.GetFieldHalfAngle() == 0.) {
      frontHalfHeight = radius / fVP.GetZoomFactor();
    } else {
      // Code from G4ViewParameters adapted to the different zoom behavior in TSG (angle)
      frontHalfHeight = pnear * std::tan(fVP.GetFieldHalfAngle() / fVP.GetZoomFactor());
    }
    return 2 * frontHalfHeight;
  }

◆ GetWindowSize()

template<class SG_SESSION, class SG_VIEWER>

G4bool G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::GetWindowSize	(	unsigned int &	a_w,
		unsigned int &	a_h )

inlinevirtual

Reimplemented from G4VViewer.

Definition at line 323 of file G4ToolsSGViewer.hh.

                                                            {
    if(!fSGViewer) {a_w = 0; a_h = 0; return false;}
    return fSGViewer->window_size(a_w,a_h);
  }

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

◆ 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 340 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 & )

inlinevirtual

Definition at line 70 of file G4ToolsSGViewer.hh.

70{}

◆ 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 71 of file G4ToolsSGViewer.hh.

71{}

◆ 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 78 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 (a_event.shift_modifier()) {  // 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 72 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 77 of file G4ToolsSGViewer.hh.

77{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.

157{return *this;}

◆ SetView()

template<class SG_SESSION, class SG_VIEWER>

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

inlinevirtual

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

Implements G4VViewer.

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;      
    }
    
   {// With Qt/Cocoa/OpenGL, Qt/Windows/OpenGL, the received size in
    // tools::sg::glarea::resizeGL is the QWidget::[width(),height()] multiplied by the "devicePixelRatio"
    // (with a value of 2 seen on a MacBookPro and 1.5 seen on a Windows laptop).
    //  In general it does not pose problem, except when rendering 2D texts.
    // In order to have similar sizes than other drivers, we adapt their scale accordingly.
    unsigned int ww,wh;
    if(GetWindowSize(ww,wh)) {
      unsigned int raw,rah;
      if(GetRenderAreaSize(raw,rah)) {
        if(ww!=0) {
          double width_ratio = double(raw)/double(ww);
          fSGSceneHandler.SetMarkerScale(width_ratio);
        }
      }
    }}
 
    //////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////
    /*
    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(2 * std::atan(std::tan(fVP.GetFieldHalfAngle()) / fVP.GetZoomFactor()));
      _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 312 of file G4ToolsSGViewer.hh.

312{FinishView();}

◆ 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 118 of file G4ToolsSGViewer.hh.

                                                                      {
 
    ZoomFromMouseWheel(a_event.angle(), a_event.shift_modifier(), a_event.x(), a_event.y());
 
    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 584 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 583 of file G4ToolsSGViewer.hh.

◆ fLastVP

template<class SG_SESSION, class SG_VIEWER>

G4ViewParameters G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fLastVP

protected

Definition at line 578 of file G4ToolsSGViewer.hh.

◆ fMousePressed

template<class SG_SESSION, class SG_VIEWER>

G4bool G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fMousePressed

protected

Definition at line 580 of file G4ToolsSGViewer.hh.

◆ fMousePressedX

template<class SG_SESSION, class SG_VIEWER>

G4double G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fMousePressedX

protected

Definition at line 581 of file G4ToolsSGViewer.hh.

◆ fMousePressedY

template<class SG_SESSION, class SG_VIEWER>

G4double G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fMousePressedY

protected

Definition at line 581 of file G4ToolsSGViewer.hh.

◆ fSGSceneHandler

template<class SG_SESSION, class SG_VIEWER>

G4ToolsSGSceneHandler& G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fSGSceneHandler

protected

Definition at line 576 of file G4ToolsSGViewer.hh.

◆ fSGSession

template<class SG_SESSION, class SG_VIEWER>

SG_SESSION& G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fSGSession

protected

Definition at line 575 of file G4ToolsSGViewer.hh.

◆ fSGViewer

template<class SG_SESSION, class SG_VIEWER>

SG_VIEWER* G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::fSGViewer

protected

Definition at line 577 of file G4ToolsSGViewer.hh.

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

G4ToolsSGViewer.hh

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4ToolsSGViewer() [1/2]

◆ ~G4ToolsSGViewer()

◆ G4ToolsSGViewer() [2/2]

Member Function Documentation

◆ ClearView()

◆ CompareForKernelVisit()

◆ CompareForTransientsRedraw()

◆ CreateSG()

◆ DrawView()

◆ EmitWindowRender()

◆ Export()

◆ FinishView()

◆ GetRenderAreaSize()

◆ GetSceneNearWidth()

◆ GetWindowSize()

◆ Initialise()

◆ KernelVisitDecision()

◆ key_press()

◆ key_release()

◆ mouse_move()

◆ mouse_press()

◆ mouse_release()

◆ operator=()

◆ SetView()

◆ ShowView()

◆ wheel_rotate()

Member Data Documentation

◆ f_gl2ps_mgr

◆ f_zb_mgr

◆ fLastVP

◆ fMousePressed

◆ fMousePressedX

◆ fMousePressedY

◆ fSGSceneHandler

◆ fSGSession

◆ fSGViewer