#include <G4OpenGLImmediateWin32Viewer.hh>

Inheritance diagram for G4OpenGLImmediateWin32Viewer:

Public Member Functions
void	ClearView ()

void	ClearViewWithoutFlush ()

std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)

void	DrawView ()

virtual bool	exportImage (std::string name="", int width=-1, int height=-1)

void	FinishView ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

	G4OpenGLImmediateWin32Viewer (G4OpenGLImmediateSceneHandler &scene, const G4String &name="")

const G4VisAttributes *	GetApplicableVisAttributes (const G4VisAttributes *) const

const G4ViewParameters &	GetDefaultViewParameters () const

const G4String &	GetName () const

virtual const std::vector< G4ModelingParameters::VisAttributesModifier > *	GetPrivateVisAttributesModifiers () const

G4VSceneHandler *	GetSceneHandler () const

const G4String &	GetShortName () const

G4int	GetViewId () const

const G4ViewParameters &	GetViewParameters () const

void	Initialise ()

void	NeedKernelVisit ()

void	ProcessView ()

void	ProcessView ()

void	RefreshView ()

void	SetDefaultViewParameters (const G4ViewParameters &vp)

bool	setExportImageFormat (std::string format, bool quiet=false)

void	SetName (const G4String &)

void	SetNeedKernelVisit (G4bool need)

void	SetView ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

void	SetViewParameters (const G4ViewParameters &vp)

void	ShowView ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

Protected Member Functions
void	addExportImageFormat (std::string format)

void	ChangeLineWidth (G4double width)

void	ChangePointSize (G4double size)

virtual void	CreateFontLists ()

void	CreateGLWin32Context ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

virtual void	CreateMainWindow ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

virtual void	DrawText (const G4Text &)

void	g4GlFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

void	g4GlOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

void	g4GluLookAt (GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz)

void	g4GluPickMatrix (GLdouble x, GLdouble y, GLdouble width, GLdouble height, GLint viewport[4])

const std::vector< G4OpenGLViewerPickMap * > &	GetPickDetails (GLdouble x, GLdouble y)

std::string	getRealPrintFilename ()

GLdouble	getSceneDepth ()

GLdouble	getSceneFarWidth ()

GLdouble	getSceneNearWidth ()

void	GetWin32Connection ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

unsigned int	getWinHeight () const

unsigned int	getWinWidth () const

void	HaloingFirstPass ()

void	HaloingSecondPass ()

void	HLRFirstPass ()

void	HLRSecondPass ()

void	HLRThirdPass ()

void	InitializeGLView ()

G4bool	isFramebufferReady ()

G4bool	isGl2psWriting ()

virtual G4String	Pick (GLdouble x, GLdouble y)

void	ResetView ()

void	ResizeGLView ()

void	ResizeWindow (unsigned int, unsigned int)

void	rotateScene (G4double dx, G4double dy)

void	rotateSceneToggle (G4double dx, G4double dy)

bool	setExportFilename (G4String name, G4bool inc=true)

void	setExportSize (G4int, G4int)

void	SetTouchable (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath)

G4bool	sizeHasChanged ()

void	TouchableSetColour (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, const G4Colour &)

void	TouchableSetVisibility (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, G4bool visibility)

Protected Attributes
G4bool	antialiasing_enabled

G4Colour	background

std::string	fDefaultExportImageFormat

G4ViewParameters	fDefaultVP

int	fExportFilenameIndex

std::string	fExportImageFormat

std::vector< std::string >	fExportImageFormatVector

G4OpenGL2PSAction *	fGL2PSAction

HDC	fHDC

G4bool	fMouseHovered

G4bool	fMousePressed

G4int	fMousePressedX

G4int	fMousePressedY

G4String	fName

G4bool	fNeedKernelVisit

G4OpenGLSceneHandler &	fOpenGLSceneHandler

G4double	fPan_sens

G4bool	fPrintColour

G4int	fPrintSizeX

G4int	fPrintSizeY

G4double	fRot_sens

G4VSceneHandler &	fSceneHandler

G4String	fShortName

G4bool	fVectoredPs

G4int	fViewId

G4ViewParameters	fVP

unsigned int	fWinSize_x

unsigned int	fWinSize_y

G4bool	haloing_enabled

G4bool	transparency_enabled

Private Member Functions
G4int	getRealExportHeight ()

G4int	getRealExportWidth ()

GLubyte *	grabPixels (int inColor, unsigned int width, unsigned int height)

bool	printGl2PS ()

bool	printNonVectoredEPS ()

bool	printVectoredEPS ()

void	ReleaseMouse ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

void	rotateSceneInViewDirection (G4double dx, G4double dy)

void	rotateSceneThetaPhi (G4double dx, G4double dy)

void	SetRotation (G4int, G4int)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

void	SetShift (G4int, G4int)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

void	SetZoom (G4int)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

void	TrackMouse (G4int, G4int)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

Static Private Member Functions
static G4bool	SetWindowPixelFormat (HDC)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

static LRESULT CALLBACK	WindowProc (HWND, UINT, WPARAM, LPARAM)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

Private Attributes
G4String	fDefaultExportFilename

G4String	fExportFilename

int	fGl2psDefaultLineWith

int	fGl2psDefaultPointSize

bool	fGlViewInitialized

HGLRC	fHGLRC

G4bool	fInCreateWindow

bool	fIsGettingPickInfos

G4float	fPointSize

G4bool	fSizeHasChanged

HWND	fWindow

Detailed Description

Definition at line 42 of file G4OpenGLImmediateWin32Viewer.hh.

Constructor & Destructor Documentation

◆ G4OpenGLImmediateWin32Viewer()

G4OpenGLImmediateWin32Viewer::G4OpenGLImmediateWin32Viewer	(	G4OpenGLImmediateSceneHandler &	scene,
		const G4String &	name = `""`
	)

Definition at line 37 of file G4OpenGLImmediateWin32Viewer.cc.

                       :
G4OpenGLViewer (sceneHandler),
G4OpenGLWin32Viewer (sceneHandler),
G4OpenGLImmediateViewer (sceneHandler),
G4VViewer (sceneHandler, sceneHandler.IncrementViewCount (), name) {
 
  if (fViewId < 0) return;  // In case error in base class instantiation.
}

References G4VViewer::fViewId.

Member Function Documentation

◆ addExportImageFormat()

void G4OpenGLViewer::addExportImageFormat ( std::string format )

protectedinherited

Definition at line 1288 of file G4OpenGLViewer.cc.

                                                          {
  fExportImageFormatVector.push_back(format);
}

References G4OpenGLViewer::fExportImageFormatVector.

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer(), and G4OpenGLViewer::G4OpenGLViewer().

◆ ChangeLineWidth()

void G4OpenGLViewer::ChangeLineWidth ( G4double width )

protectedinherited

Change LineSize on gl2ps if needed

Definition at line 810 of file G4OpenGLViewer.cc.

                                                   {
 
  if (isGl2psWriting()) {
    fGL2PSAction->setLineWidth(int(width));
  } else {
    glLineWidth (width);
  }
}

References G4OpenGLViewer::fGL2PSAction, G4OpenGLViewer::isGl2psWriting(), and G4OpenGL2PSAction::setLineWidth().

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLViewer::HaloingFirstPass(), and G4OpenGLViewer::HaloingSecondPass().

◆ ChangePointSize()

void G4OpenGLViewer::ChangePointSize ( G4double size )

protectedinherited

Change PointSize on gl2ps if needed

Definition at line 798 of file G4OpenGLViewer.cc.

                                                  {
 
  if (isGl2psWriting()) {
    fGL2PSAction->setPointSize(int(size));
  } else {
    glPointSize (size);
  }
}

References G4OpenGLViewer::fGL2PSAction, G4OpenGLViewer::isGl2psWriting(), and G4OpenGL2PSAction::setPointSize().

Referenced by G4OpenGLSceneHandler::AddPrimitive().

◆ ClearView()

void G4OpenGLViewer::ClearView ( void )

virtualinherited

Implements G4VViewer.

Definition at line 203 of file G4OpenGLViewer.cc.

                                {
  ClearViewWithoutFlush();
 
  if(!isFramebufferReady()) {
    return;
  }
 
  glFlush();
}

References G4OpenGLViewer::ClearViewWithoutFlush(), and G4OpenGLViewer::isFramebufferReady().

◆ ClearViewWithoutFlush()

void G4OpenGLViewer::ClearViewWithoutFlush ( )

inherited

Definition at line 214 of file G4OpenGLViewer.cc.

                                            {
  // Ready for clear ?
  // See : http://lists.apple.com/archives/mac-opengl/2012/Jul/msg00038.html
  if(!isFramebufferReady()) {
    return;
  }
  
  glClearColor (background.GetRed(),
                background.GetGreen(),
                background.GetBlue(),
                1.);
  glClearDepth (1.0);
  //Below line does not compile with Mesa includes.
  //glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glClear (GL_COLOR_BUFFER_BIT);
  glClear (GL_DEPTH_BUFFER_BIT);
  glClear (GL_STENCIL_BUFFER_BIT);
}

References G4OpenGLViewer::background, G4Colour::GetBlue(), G4Colour::GetGreen(), G4Colour::GetRed(), and G4OpenGLViewer::isFramebufferReady().

Referenced by G4OpenGLViewer::ClearView().

◆ ComputeFlyThrough()

std::vector< G4ThreeVector > G4VViewer::ComputeFlyThrough ( G4Vector3D * )

inherited

Definition at line 215 of file G4VViewer.cc.

{
    enum CurveType {
        Bezier,
        G4SplineTest};
    
    // Choose a curve type (for testing)
//    int myCurveType = Bezier;
 
    // number if step points
    int stepPoints = 500;
 
    
    G4Spline spline;
 
    
    // At the moment we don't use the aVect parameters, but build it here :
    // Good step points for exampleB5
    spline.AddSplinePoint(G4Vector3D(0,1000,-14000));
    spline.AddSplinePoint(G4Vector3D(0,1000,0));
    spline.AddSplinePoint(G4Vector3D(-4000,1000,4000));
 
    
    std::vector <G4ThreeVector> viewVect;
 
//    if(myCurveType == Bezier) {
 
        
        // Draw the spline
        
        for (int i = 0; i < stepPoints; i++) {
            float t = (float)i / (float)stepPoints;
            G4Vector3D cameraPosition = spline.GetInterpolatedSplinePoint(t);
            //        G4Vector3D targetPoint = spline.GetInterpolatedSplinePoint(t);
            
            //        viewParam->SetViewAndLights(G4ThreeVector (cameraPosition.x(), cameraPosition.y(), cameraPosition.z()));
            //        viewParam->SetCurrentTargetPoint(targetPoint);
            G4cout << "FLY CR("<< i << "):" << cameraPosition << G4endl;
            viewVect.push_back(G4ThreeVector (cameraPosition.x(), cameraPosition.y(), cameraPosition.z()));
        }
        
//    } else if (myCurveType == G4SplineTest) {
        /*
         This method is a inspire from a Bezier curve. The problem of the Bezier curve is that the path does not go straight between two waypoints.
         This method add "stay straight" parameter which could be between 0 and 1 where the pass will follow exactly the line between the waypoints
         Ex : stay straight = 50%
         m1 = 3*(P1+P0)/2
         
         Ex : stay straight = 0%
         m1 = (P1+P0)/2
         
         P1
         /  \
         /    \
         a--x--b
         /  °  °  \
         / °      ° \
         m1           m2
         /              \
         /                \
         /                  \
         /                    \
         P0                     P2
         
         */
//        G4Vector3D a;
//        G4Vector3D b;
//        G4Vector3D m1;
//        G4Vector3D m2;
//        G4Vector3D P0;
//        G4Vector3D P1;
//        G4Vector3D P2;
//        G4double stayStraight = 0;
//        G4double bezierSpeed = 0.4; // Spend 40% time in bezier curve (time between m1-m2 is 40% of time between P0-P1)
//        
//        G4Vector3D firstPoint;
//        G4Vector3D lastPoint;
//        
//        float nbBezierSteps = (stepPoints * bezierSpeed*(1-stayStraight)) * (2./spline.GetNumPoints());
//        float nbFirstSteps = ((stepPoints/2-nbBezierSteps/2) /(1+stayStraight)) * (2./spline.GetNumPoints());
//        
//        // First points
//        firstPoint = spline.GetPoint(0);
//        lastPoint = (firstPoint + spline.GetPoint(1))/2;
//        
//        for( float j=0; j<1; j+= 1/nbFirstSteps) {
//            G4ThreeVector pt = firstPoint + (lastPoint - firstPoint) * j;
//            viewVect.push_back(pt);
//            G4cout << "FLY Bezier A1("<< viewVect.size()<< "):" << pt << G4endl;
//        }
//        
//        for (int i = 0; i < spline.GetNumPoints()-2; i++) {
//            P0 = spline.GetPoint(i);
//            P1 = spline.GetPoint(i+1);
//            P2 = spline.GetPoint(i+2);
//            
//            m1 = P1 - (P1-P0)*(1-stayStraight)/2;
//            m2 = P1 + (P2-P1)*(1-stayStraight)/2;
//            
//            // We have to get straight path from (middile of P0-P1) to (middile of P0-P1 + (dist P0-P1) * stayStraight/2)
//            if (stayStraight >0) {
//                
//                firstPoint = (P0 + P1)/2;
//                lastPoint = (P0 + P1)/2 + (P1-P0)*stayStraight/2;
//                
//                for( float j=0; j<1; j+= 1/(nbFirstSteps*stayStraight)) {
//                    G4ThreeVector pt = firstPoint + (lastPoint - firstPoint)* j;
//                    viewVect.push_back(pt);
//                    G4cout << "FLY Bezier A2("<< viewVect.size()<< "):" << pt << G4endl;
//                }
//            }
//            // Compute Bezier curve
//            for( float delta = 0 ; delta < 1 ; delta += 1/nbBezierSteps)
//            {
//                // The Green Line
//                a = m1 + ( (P1 - m1) * delta );
//                b = P1 + ( (m2 - P1) * delta );
//                
//                // Final point
//                G4ThreeVector pt = a + ((b-a) * delta );
//                viewVect.push_back(pt);
//                G4cout << "FLY Bezier("<< viewVect.size()<< "):" << pt << G4endl;
//            }
//            
//            // We have to get straight path
//            if (stayStraight >0) {
//                firstPoint = (P1 + P2)/2 - (P2-P1)*stayStraight/2;
//                lastPoint = (P1 + P2)/2;
//                
//                for( float j=0; j<1; j+= 1/(nbFirstSteps*stayStraight)) {
//                    G4ThreeVector pt = firstPoint + (lastPoint - firstPoint)* j;
//                    viewVect.push_back(pt);
//                    G4cout << "FLY Bezier B1("<< viewVect.size()<< "):" << pt << G4endl;
//                }
//            }
//        }
//        
//        // last points
//        firstPoint = spline.GetPoint(spline.GetNumPoints()-2);
//        lastPoint = spline.GetPoint(spline.GetNumPoints()-1);
//        for( float j=1; j>0; j-= 1/nbFirstSteps) {
//            G4ThreeVector pt = lastPoint - ((lastPoint-firstPoint)*((1-stayStraight)/2) * j );
//            viewVect.push_back(pt);
//            G4cout << "FLY Bezier B2("<< viewVect.size()<< "):" << pt << G4endl;
//        }
//    }
    return viewVect;
}

References G4VViewer::G4Spline::AddSplinePoint(), G4cout, G4endl, G4VViewer::G4Spline::GetInterpolatedSplinePoint(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

◆ CreateFontLists()

virtual void G4OpenGLViewer::CreateFontLists ( )

inlineprotectedvirtualinherited

Reimplemented in G4OpenGLXViewer.

Definition at line 148 of file G4OpenGLViewer.hh.

148{}

Referenced by Initialise(), G4OpenGLImmediateXmViewer::Initialise(), G4OpenGLStoredWin32Viewer::Initialise(), and G4OpenGLStoredXmViewer::Initialise().

◆ CreateGLWin32Context()

void G4OpenGLWin32Viewer::CreateGLWin32Context ( )

protectedinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 83 of file G4OpenGLWin32Viewer.cc.

87{

88}

Referenced by Initialise(), and G4OpenGLStoredWin32Viewer::Initialise().

◆ CreateMainWindow()

void G4OpenGLWin32Viewer::CreateMainWindow ( )

protectedvirtualinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 91 of file G4OpenGLWin32Viewer.cc.

{
  if(fWindow) return; //Done.
 
  // Bill Gates stuff...
  static const char className[] = "G4OpenGLWin32";
  static G4bool done = false;
  if(done==false) {
    WNDCLASS wc;
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = (WNDPROC)WindowProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = ::GetModuleHandle(NULL);
    wc.hIcon = LoadIcon  (NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL,IDC_CROSS);
    wc.hbrBackground = NULL;
    wc.lpszMenuName = className;
    wc.lpszClassName = className;
    ::RegisterClass(&wc);
    done = true;
  }  
  
  ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
 
  G4int x_res=GetSystemMetrics(SM_CXSCREEN);
  G4int y_res=GetSystemMetrics(SM_CYSCREEN);
  
  //FIXME : NOT tested !
  fWindow = ::CreateWindowEx(0, className,fName.c_str(),
               WS_OVERLAPPEDWINDOW,
               //WS_CHILD | WS_VISIBLE,
                           //              0,0,
                           fVP.GetWindowAbsoluteLocationHintX(x_res),
                           fVP.GetWindowAbsoluteLocationHintY(y_res),
               getWinWidth(), getWinHeight(),
               NULL, NULL, 
               ::GetModuleHandle(NULL),
               NULL);
  if(!fWindow) return;
 
  ::SetWindowLongPtr(fWindow,GWLP_USERDATA,LONG_PTR(this));
 
  // initialize OpenGL rendering :
  fHDC = ::GetDC(fWindow);
  if( fHDC && (SetWindowPixelFormat(fHDC)==TRUE) ) {
    fHGLRC = ::wglCreateContext(fHDC);
  }
  
  if(fHDC && fHGLRC) {
    ::wglMakeCurrent(fHDC,fHGLRC);
  }
 
  //G.Barrand : avoid to indirectly pass in
  //              WindowProc/[WM_SIZE,WM_PAINT]/This->DrawView()
  //            from this method. Else we have crash.
  fInCreateWindow = true;
 
  ::SetForegroundWindow(fWindow);
  ::ShowWindow(fWindow,SW_SHOWDEFAULT);
  ::UpdateWindow(fWindow);
  ::DrawMenuBar(fWindow);
 
  fInCreateWindow = false;
}

References className, G4OpenGLWin32Viewer::fHDC, G4OpenGLWin32Viewer::fHGLRC, G4OpenGLWin32Viewer::fInCreateWindow, G4VViewer::fName, G4VViewer::fVP, G4OpenGLWin32Viewer::fWindow, G4ViewParameters::GetWindowAbsoluteLocationHintX(), G4ViewParameters::GetWindowAbsoluteLocationHintY(), G4ViewParameters::GetWindowSizeHintX(), G4ViewParameters::GetWindowSizeHintY(), G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::getWinWidth(), G4OpenGLViewer::ResizeWindow(), G4OpenGLWin32Viewer::SetWindowPixelFormat(), TRUE, and G4OpenGLWin32Viewer::WindowProc().

Referenced by Initialise(), and G4OpenGLStoredWin32Viewer::Initialise().

◆ DrawText()

void G4OpenGLViewer::DrawText ( const G4Text & g4text )

protectedvirtualinherited

Reimplemented in G4OpenGLQtViewer, and G4OpenGLXViewer.

Definition at line 758 of file G4OpenGLViewer.cc.

{
  // gl2ps or GL window ?
  if (isGl2psWriting()) {
 
    G4VSceneHandler::MarkerSizeType sizeType;
    G4double size = fSceneHandler.GetMarkerSize(g4text,sizeType);
    G4Point3D position = g4text.GetPosition();
 
    G4String textString = g4text.GetText();
    
    glRasterPos3d(position.x(),position.y(),position.z());
    GLint align = GL2PS_TEXT_B;
 
    switch (g4text.GetLayout()) {
    case G4Text::left: align = GL2PS_TEXT_BL; break;
    case G4Text::centre: align = GL2PS_TEXT_B; break;
    case G4Text::right: align = GL2PS_TEXT_BR;
    }
    
    gl2psTextOpt(textString.c_str(),"Times-Roman",GLshort(size),align,0);
 
  } else {
 
    static G4int callCount = 0;
    ++callCount;
    //if (callCount <= 10 || callCount%100 == 0) {
    if (callCount <= 1) {
      G4cout <<
    "G4OpenGLViewer::DrawText: Not implemented for \""
         << fName <<
    "\"\n  Called with "
         << g4text
         << G4endl;
    }
  }
}

References G4Text::centre, G4VViewer::fName, G4VViewer::fSceneHandler, G4cout, G4endl, G4Text::GetLayout(), G4VSceneHandler::GetMarkerSize(), G4VMarker::GetPosition(), G4Text::GetText(), GL2PS_TEXT_B, GL2PS_TEXT_BL, GL2PS_TEXT_BR, gl2psTextOpt, G4OpenGLViewer::isGl2psWriting(), G4Text::left, and G4Text::right.

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLQtViewer::DrawText(), and G4OpenGLXViewer::DrawText().

◆ DrawView()

void G4OpenGLImmediateWin32Viewer::DrawView ( )

virtual

Implements G4VViewer.

Definition at line 68 of file G4OpenGLImmediateWin32Viewer.cc.

                                             {
 
  // If a double buffer context has been forced upon us, ignore the
  // back buffer for this OpenGLImmediate view.
  glDrawBuffer (GL_FRONT);
 
  G4ViewParameters::DrawingStyle style = GetViewParameters().GetDrawingStyle();
 
  glViewport (0, 0, getWinWidth(), getWinHeight());
 
  if(style!=G4ViewParameters::hlr &&
     haloing_enabled) {
 
    HaloingFirstPass ();
    NeedKernelVisit ();
    ProcessView ();
    glFlush ();
 
    HaloingSecondPass ();
 
  }
 
  NeedKernelVisit ();  // Always need to visit G4 kernel.
  ProcessView ();
  FinishView ();
 
}

References FinishView(), G4ViewParameters::GetDrawingStyle(), G4VViewer::GetViewParameters(), G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::getWinWidth(), G4OpenGLViewer::haloing_enabled, G4OpenGLViewer::HaloingFirstPass(), G4OpenGLViewer::HaloingSecondPass(), G4ViewParameters::hlr, G4VViewer::NeedKernelVisit(), and G4OpenGLImmediateViewer::ProcessView().

◆ exportImage()

bool G4OpenGLViewer::exportImage	(	std::string	name = `""`,
		int	width = `-1`,
		int	height = `-1`
	)

virtualinherited

Export image with the given name with width and height Several cases : If name is "", filename will have the default value If name is "toto.png", set the name to "toto" and the format to "png". No incremented suffix is added. If name is "toto", set the name to "toto" and the format to default (or current format if specify). Will also add an incremented suffix at the end of the file

Reimplemented in G4OpenGLQtViewer.

Definition at line 827 of file G4OpenGLViewer.cc.

                                                                      {
 
  if (! setExportFilename(name)) {
    return false;
  }
 
  if ((width != -1) && (height != -1)) {
    setExportSize(width, height);
  }
 
  if (fExportImageFormat == "eps") {
    fGL2PSAction->setExportImageFormat(GL2PS_EPS);
  } else if (fExportImageFormat == "ps") {
    fGL2PSAction->setExportImageFormat(GL2PS_PS);
  } else if (fExportImageFormat == "svg") {
    fGL2PSAction->setExportImageFormat(GL2PS_SVG);
  } else if (fExportImageFormat == "pdf") {
    fGL2PSAction->setExportImageFormat(GL2PS_PDF);
  } else {
    setExportImageFormat(fExportImageFormat,true); // will display a message if this format is not correct for the current viewer
    return false;
  }
 
  bool res;
 
  // Change the LC_NUMERIC value in order to have "." separtor and not ","
  // This case is only useful for French, Canadien...
  size_t len = strlen(setlocale(LC_NUMERIC,NULL));
  char* oldLocale = (char*)(malloc(len+1));
  if(oldLocale!=NULL) strncpy(oldLocale,setlocale(LC_NUMERIC,NULL),len);
  setlocale(LC_NUMERIC,"C");
 
  if (((fExportImageFormat == "eps") || (fExportImageFormat == "ps")) && (!fVectoredPs)) {
    res = printNonVectoredEPS();
  } else {
    res = printVectoredEPS();
  }
 
  // restore the local
  if (oldLocale) {
    setlocale(LC_NUMERIC,oldLocale);
    free(oldLocale);
  }
 
  if (res == false) {
    G4cerr << "Error saving file... " << getRealPrintFilename().c_str() << G4endl;
  } else {
    G4cout << "File " << getRealPrintFilename().c_str() << " size: " << getRealExportWidth() << "x" << getRealExportHeight() << " has been saved " << G4endl;
 
    // increment index if necessary
    if ( fExportFilenameIndex != -1) {
      fExportFilenameIndex++;
    }
  }
 
  return res;
}

References G4OpenGLViewer::fExportFilenameIndex, G4OpenGLViewer::fExportImageFormat, G4OpenGLViewer::fGL2PSAction, free, G4OpenGLViewer::fVectoredPs, G4cerr, G4cout, G4endl, G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getRealPrintFilename(), GL2PS_EPS, GL2PS_PDF, GL2PS_PS, GL2PS_SVG, G4InuclParticleNames::name(), G4OpenGLViewer::printNonVectoredEPS(), G4OpenGLViewer::printVectoredEPS(), G4OpenGLViewer::setExportFilename(), G4OpenGLViewer::setExportImageFormat(), G4OpenGL2PSAction::setExportImageFormat(), and G4OpenGLViewer::setExportSize().

Referenced by G4OpenGLQtViewer::exportImage(), G4OpenGLXmViewer::print_callback(), and G4OpenGLViewerMessenger::SetNewValue().

◆ FinishView()

void G4OpenGLImmediateWin32Viewer::FinishView ( void )

virtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Reimplemented from G4VViewer.

Definition at line 97 of file G4OpenGLImmediateWin32Viewer.cc.

{
  if(!fHDC) return;
 
  glFlush ();
 
  // Empty the Windows message queue :
  MSG event;
  while ( ::PeekMessage(&event, NULL, 0, 0, PM_REMOVE) ) {
    ::TranslateMessage(&event);
    ::DispatchMessage (&event);
  }
}

References G4OpenGLWin32Viewer::fHDC.

Referenced by DrawView(), and Initialise().

◆ g4GlFrustum()

void G4OpenGLViewer::g4GlFrustum	(	GLdouble	left,
		GLdouble	right,
		GLdouble	bottom,
		GLdouble	top,
		GLdouble	near,
		GLdouble	far
	)

protectedinherited

Definition at line 1467 of file G4OpenGLViewer.cc.

                                                                                                                             {
  //  glFrustum (left, right, bottom, top, near, far);
  
  GLdouble deltaX = right - left;
  GLdouble deltaY = top - bottom;
  GLdouble deltaZ = zFar - zNear;
  
  GLdouble a = 2.0f * zNear / deltaX;
  GLdouble b = 2.0f * zNear / deltaY;
  GLdouble c = (right + left) / deltaX;
  GLdouble d = (top + bottom) / deltaY;
  GLdouble e = -(zFar + zNear) / (zFar - zNear);
  GLdouble f = -2.0f * zFar * zNear / deltaZ;
  
  GLdouble proj[16] = {
    a, 0, 0, 0,
    0, b, 0, 0,
    c, d, e, -1.0f,
    0, 0, f, 0
  };
  
  glMultMatrixd(proj);
  
}

Referenced by G4OpenGLViewer::SetView().

◆ g4GlOrtho()

void G4OpenGLViewer::g4GlOrtho	(	GLdouble	left,
		GLdouble	right,
		GLdouble	bottom,
		GLdouble	top,
		GLdouble	near,
		GLdouble	far
	)

protectedinherited

Definition at line 1445 of file G4OpenGLViewer.cc.

                                                                                                                           {
  //  glOrtho (left, right, bottom, top, near, far);
  
  GLdouble a = 2.0 / (right - left);
  GLdouble b = 2.0 / (top - bottom);
  GLdouble c = -2.0 / (zFar - zNear);
  
  GLdouble tx = - (right + left)/(right - left);
  GLdouble ty = - (top + bottom)/(top - bottom);
  GLdouble tz = - (zFar + zNear)/(zFar - zNear);
  
  GLdouble ortho[16] = {
    a, 0, 0, 0,
    0, b, 0, 0,
    0, 0, c, 0,
    tx, ty, tz, 1
  };
  glMultMatrixd(ortho);
  
}

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLImmediateSceneHandler::BeginPrimitives2D(), G4OpenGLStoredViewer::DrawDisplayLists(), and G4OpenGLViewer::SetView().

◆ g4GluLookAt()

void G4OpenGLViewer::g4GluLookAt	(	GLdouble	eyex,
		GLdouble	eyey,
		GLdouble	eyez,
		GLdouble	centerx,
		GLdouble	centery,
		GLdouble	centerz,
		GLdouble	upx,
		GLdouble	upy,
		GLdouble	upz
	)

protectedinherited

Definition at line 1365 of file G4OpenGLViewer.cc.

{
    GLdouble mat[16];
    GLdouble x[3], y[3], z[3];
    GLdouble mag;
  
    /* Make rotation matrix */
  
    /* Z vector */
    z[0] = eyex - centerx;
    z[1] = eyey - centery;
    z[2] = eyez - centerz;
    mag = std::sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
    if (mag) {          /* mpichler, 19950515 */
        z[0] /= mag;
        z[1] /= mag;
        z[2] /= mag;
    }
  
    /* Y vector */
    y[0] = upx;
    y[1] = upy;
    y[2] = upz;
  
    /* X vector = Y cross Z */
    x[0] = y[1] * z[2] - y[2] * z[1];
    x[1] = -y[0] * z[2] + y[2] * z[0];
    x[2] = y[0] * z[1] - y[1] * z[0];
  
    /* Recompute Y = Z cross X */
    y[0] = z[1] * x[2] - z[2] * x[1];
    y[1] = -z[0] * x[2] + z[2] * x[0];
    y[2] = z[0] * x[1] - z[1] * x[0];
  
    /* mpichler, 19950515 */
    /* cross product gives area of parallelogram, which is < 1.0 for
     * non-perpendicular unit-length vectors; so normalize x, y here
     */
  
    mag = std::sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
    if (mag) {
        x[0] /= mag;
        x[1] /= mag;
        x[2] /= mag;
    }
  
    mag = std::sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
    if (mag) {
        y[0] /= mag;
        y[1] /= mag;
        y[2] /= mag;
    }
  
#define M(row,col)  mat[col*4+row]
    M(0, 0) = x[0];
    M(0, 1) = x[1];
    M(0, 2) = x[2];
    M(0, 3) = 0.0;
    M(1, 0) = y[0];
    M(1, 1) = y[1];
    M(1, 2) = y[2];
    M(1, 3) = 0.0;
    M(2, 0) = z[0];
    M(2, 1) = z[1];
    M(2, 2) = z[2];
    M(2, 3) = 0.0;
    M(3, 0) = 0.0;
    M(3, 1) = 0.0;
    M(3, 2) = 0.0;
    M(3, 3) = 1.0;
#undef M
    glMultMatrixd(mat);
  
    /* Translate Eye to Origin */
    glTranslated(-eyex, -eyey, -eyez);
}

References M.

Referenced by G4OpenGLViewer::SetView().

◆ g4GluPickMatrix()

void G4OpenGLViewer::g4GluPickMatrix	(	GLdouble	x,
		GLdouble	y,
		GLdouble	width,
		GLdouble	height,
		GLint	viewport[4]
	)

protectedinherited

Definition at line 1323 of file G4OpenGLViewer.cc.

  {
    GLdouble mat[16];
    GLdouble sx, sy;
    GLdouble tx, ty;
    
    sx = viewport[2] / width;
    sy = viewport[3] / height;
    tx = (viewport[2] + 2.0 * (viewport[0] - x)) / width;
    ty = (viewport[3] + 2.0 * (viewport[1] - y)) / height;
    
#define M(row, col) mat[col*4+row]
    M(0, 0) = sx;
    M(0, 1) = 0.0;
    M(0, 2) = 0.0;
    M(0, 3) = tx;
    M(1, 0) = 0.0;
    M(1, 1) = sy;
    M(1, 2) = 0.0;
    M(1, 3) = ty;
    M(2, 0) = 0.0;
    M(2, 1) = 0.0;
    M(2, 2) = 1.0;
    M(2, 3) = 0.0;
    M(3, 0) = 0.0;
    M(3, 1) = 0.0;
    M(3, 2) = 0.0;
    M(3, 3) = 1.0;
#undef M
    
    glMultMatrixd(mat);
}

References M.

Referenced by G4OpenGLViewer::GetPickDetails().

◆ GetApplicableVisAttributes()

const G4VisAttributes * G4VViewer::GetApplicableVisAttributes ( const G4VisAttributes * ) const

inherited

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4VtkSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4OpenInventorSceneHandler::AddProperties(), G4HepRepFileSceneHandler::AddSolid(), G4VSceneHandler::AddSolidT(), G4VSceneHandler::AddSolidWithAuxiliaryEdges(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VSceneHandler::GetColour(), and G4GMocrenFileSceneHandler::IsVisible().

◆ GetDefaultViewParameters()

const G4ViewParameters & G4VViewer::GetDefaultViewParameters ( ) const

inherited

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ GetName()

const G4String & G4VViewer::GetName ( ) const

inherited

◆ GetPickDetails()

const std::vector< G4OpenGLViewerPickMap * > & G4OpenGLViewer::GetPickDetails	(	GLdouble	x,
		GLdouble	y
	)

protectedinherited

Definition at line 488 of file G4OpenGLViewer.cc.

{
  static std::vector < G4OpenGLViewerPickMap* > pickMapVector;
  for (auto pickMap: pickMapVector) {
    delete pickMap;
  }
  pickMapVector.clear();
  
  const G4int BUFSIZE = 512;
  GLuint selectBuffer[BUFSIZE];
  glSelectBuffer(BUFSIZE, selectBuffer);
  glRenderMode(GL_SELECT);
  glInitNames();
  glPushName(0);
  glMatrixMode(GL_PROJECTION);
  G4double currentProjectionMatrix[16];
  glGetDoublev(GL_PROJECTION_MATRIX, currentProjectionMatrix);
  glPushMatrix();
  glLoadIdentity();
  GLint viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);
/*  G4cout
  << "viewport, x,y: "
  << viewport[0] << ',' << viewport[1] << ',' << viewport[2] << ',' << viewport[3]
  << ", " << x << ',' << y
  << G4endl;
*/
  fIsGettingPickInfos = true;
  // Define 5x5 pixel pick area
  g4GluPickMatrix(x, viewport[3] - y, 5., 5., viewport);
  glMultMatrixd(currentProjectionMatrix);
  glMatrixMode(GL_MODELVIEW);
  DrawView();
  GLint hits = glRenderMode(GL_RENDER);
  fIsGettingPickInfos = false;
  if (hits < 0) {
    G4cout << "Too many hits.  Zoom in to reduce overlaps." << G4endl;
    goto restoreMatrices;
  }
  if (hits > 0) {
    GLuint* p = selectBuffer;
    for (GLint i = 0; i < hits; ++i) {
      GLuint nnames = *p++;
      // This bit of debug code or...
      //GLuint zmin = *p++;
      //GLuint zmax = *p++;
      //G4cout << "Hit " << i << ": " << nnames << " names"
      //       << "\nzmin: " << zmin << ", zmax: " << zmax << G4endl;
      // ...just increment the pointer
      p++;
      p++;
      for (GLuint j = 0; j < nnames; ++j) {
        GLuint name = *p++;
    std::map<GLuint, G4AttHolder*>::iterator iter =
      fOpenGLSceneHandler.fPickMap.find(name);
    if (iter != fOpenGLSceneHandler.fPickMap.end()) {
      G4AttHolder* attHolder = iter->second;
      if(attHolder && attHolder->GetAttDefs().size()) {
        for (size_t iAtt = 0;
         iAtt < attHolder->GetAttDefs().size(); ++iAtt) {
              std::ostringstream oss;
          oss << G4AttCheck(attHolder->GetAttValues()[iAtt],
                                attHolder->GetAttDefs()[iAtt]);
              G4OpenGLViewerPickMap* pickMap = new G4OpenGLViewerPickMap();
//              G4cout
//              << "i,j, attHolder->GetAttDefs().size(): "
//              << i << ',' << j
//              << ", " << attHolder->GetAttDefs().size()
//              << G4endl;
//              G4cout << "G4OpenGLViewer::GetPickDetails: " << oss.str() << G4endl;
              pickMap->addAttributes(oss.str());
              pickMap->setHitNumber(i);
              pickMap->setSubHitNumber(j);
              pickMap->setPickName(name);
              pickMapVector.push_back(pickMap);
            }
          }
        }
      }
    }
  }
 
restoreMatrices:
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
 
  return pickMapVector;
}

References G4OpenGLViewerPickMap::addAttributes(), BUFSIZE, G4VViewer::DrawView(), G4OpenGLViewer::fIsGettingPickInfos, G4OpenGLViewer::fOpenGLSceneHandler, G4OpenGLSceneHandler::fPickMap, G4cout, G4endl, G4OpenGLViewer::g4GluPickMatrix(), G4AttHolder::GetAttDefs(), G4AttHolder::GetAttValues(), G4InuclParticleNames::name(), G4OpenGLViewerPickMap::setHitNumber(), G4OpenGLViewerPickMap::setPickName(), and G4OpenGLViewerPickMap::setSubHitNumber().

Referenced by G4OpenGLViewer::Pick(), and G4OpenGLQtViewer::updatePickInfosWidget().

◆ GetPrivateVisAttributesModifiers()

virtual const std::vector< G4ModelingParameters::VisAttributesModifier > * G4VViewer::GetPrivateVisAttributesModifiers ( ) const

virtualinherited

Reimplemented in G4OpenGLQtViewer.

Referenced by G4VisCommandViewerSave::SetNewValue(), and G4VisCommandsViewerSet::SetNewValue().

◆ getRealExportHeight()

G4int G4OpenGLViewer::getRealExportHeight ( )

privateinherited

Definition at line 1004 of file G4OpenGLViewer.cc.

                                          {
  if (fPrintSizeY == -1) {
    return fWinSize_y;
  }
  GLint dims[2];
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  // L.Garnier 01-2010: Some problems with mac 10.6
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
    if (fPrintSizeY > dims[1]){
      return dims[1];
    }
  }
  if (fPrintSizeY < -1){
    return 0;
  }
  return fPrintSizeY;
}

References G4OpenGLViewer::fPrintSizeY, and G4OpenGLViewer::fWinSize_y.

Referenced by G4OpenGLViewer::exportImage(), G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::printNonVectoredEPS().

◆ getRealExportWidth()

G4int G4OpenGLViewer::getRealExportWidth ( )

privateinherited

Definition at line 985 of file G4OpenGLViewer.cc.

                                         {
  if (fPrintSizeX == -1) {
    return fWinSize_x;
  }
  GLint dims[2];
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  // L.Garnier 01-2010: Some problems with mac 10.6
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
    if (fPrintSizeX > dims[0]){
      return dims[0];
    }
  }
  if (fPrintSizeX < -1){
    return 0;
  }
  return fPrintSizeX;
}

References G4OpenGLViewer::fPrintSizeX, and G4OpenGLViewer::fWinSize_x.

Referenced by G4OpenGLViewer::exportImage(), G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::printNonVectoredEPS().

◆ getRealPrintFilename()

std::string G4OpenGLViewer::getRealPrintFilename ( )

protectedinherited

Definition at line 1066 of file G4OpenGLViewer.cc.

                                               {
  std::string temp = fExportFilename;
  if (fExportFilenameIndex != -1) {
    temp += std::string("_");
    std::ostringstream os;
    os << std::setw(4) << std::setfill('0') << fExportFilenameIndex;
    std::string nb_str = os.str();
    temp += nb_str;
  }
  temp += "."+fExportImageFormat;
  return temp;
}

References G4OpenGLViewer::fExportFilename, G4OpenGLViewer::fExportFilenameIndex, and G4OpenGLViewer::fExportImageFormat.

Referenced by G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), G4OpenGLXmViewer::misc_callback(), G4OpenGLViewer::printGl2PS(), G4OpenGLViewer::printNonVectoredEPS(), and G4OpenGLViewer::setExportFilename().

◆ getSceneDepth()

GLdouble G4OpenGLViewer::getSceneDepth ( )

protectedinherited

Definition at line 1111 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  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 GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  return fVP.GetFarDistance  (cameraDistance, pnear, radius)- pnear;
}

References G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetCameraDistance(), G4ViewParameters::GetCurrentTargetPoint(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetFarDistance(), G4ViewParameters::GetNearDistance(), G4VSceneHandler::GetScene(), and G4Scene::GetStandardTargetPoint().

Referenced by G4OpenGLQtViewer::moveScene().

◆ getSceneFarWidth()

GLdouble G4OpenGLViewer::getSceneFarWidth ( )

protectedinherited

Definition at line 1094 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  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 GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  const GLdouble pfar    = fVP.GetFarDistance  (cameraDistance, pnear, radius);
  return 2 * fVP.GetFrontHalfHeight (pfar, radius);
}

References G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetCameraDistance(), G4ViewParameters::GetCurrentTargetPoint(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetFarDistance(), G4ViewParameters::GetFrontHalfHeight(), G4ViewParameters::GetNearDistance(), G4VSceneHandler::GetScene(), and G4Scene::GetStandardTargetPoint().

◆ GetSceneHandler()

G4VSceneHandler * G4VViewer::GetSceneHandler ( ) const

inherited

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLXmViewer::left_right_pan_callback(), G4OpenGLXmViewer::misc_callback(), G4VVisCommand::RefreshIfRequired(), G4OpenGLXmViewer::ResetView(), G4OpenGLViewerMessenger::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerClearTransients::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), G4VisCommandViewerRebuild::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandViewerUpdate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLWin32Viewer::SetShift(), and G4OpenGLXmViewer::up_down_pan_callback().

◆ getSceneNearWidth()

GLdouble G4OpenGLViewer::getSceneNearWidth ( )

protectedinherited

Definition at line 1079 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  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 GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  return 2 * fVP.GetFrontHalfHeight (pnear, radius);
}

References G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetCameraDistance(), G4ViewParameters::GetCurrentTargetPoint(), G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetFrontHalfHeight(), G4ViewParameters::GetNearDistance(), G4VSceneHandler::GetScene(), and G4Scene::GetStandardTargetPoint().

Referenced by G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::moveScene().

◆ GetShortName()

const G4String & G4VViewer::GetShortName ( ) const

inherited

Referenced by G4OpenGLViewer::G4OpenGLViewer().

◆ GetViewId()

G4int G4VViewer::GetViewId ( ) const

inherited

Referenced by G4RayTracer::CreateViewer(), G4RayTracerX::CreateViewer(), G4HepRepFile::CreateViewer(), G4Qt3D::CreateViewer(), G4ToolsSGQtGLES::CreateViewer(), G4ToolsSGWindowsGLES::CreateViewer(), G4ToolsSGX11GLES::CreateViewer(), G4ToolsSGXtGLES::CreateViewer(), G4Vtk::CreateViewer(), and G4VtkQt::CreateViewer().

◆ GetViewParameters()

const G4ViewParameters & G4VViewer::GetViewParameters ( ) const

inherited

◆ GetWin32Connection()

void G4OpenGLWin32Viewer::GetWin32Connection ( )

protectedinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 75 of file G4OpenGLWin32Viewer.cc.

79{

80}

◆ getWinHeight()

unsigned int G4OpenGLViewer::getWinHeight ( ) const

protectedinherited

Definition at line 977 of file G4OpenGLViewer.cc.

                                               {
  return fWinSize_y;
}

References G4OpenGLViewer::fWinSize_y.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::DrawText(), DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::moveScene(), G4OpenGLImmediateQtViewer::paintGL(), and G4OpenGLStoredQtViewer::paintGL().

◆ getWinWidth()

unsigned int G4OpenGLViewer::getWinWidth ( ) const

protectedinherited

Definition at line 973 of file G4OpenGLViewer.cc.

                                              {
  return fWinSize_x;
}

References G4OpenGLViewer::fWinSize_x.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::DrawText(), DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::moveScene(), G4OpenGLImmediateQtViewer::paintGL(), and G4OpenGLStoredQtViewer::paintGL().

◆ grabPixels()

GLubyte * G4OpenGLViewer::grabPixels	(	int	inColor,
		unsigned int	width,
		unsigned int	height
	)

privateinherited

Definition at line 578 of file G4OpenGLViewer.cc.

                                                       {
  
  GLubyte* buffer;
  GLint swapbytes, lsbfirst, rowlength;
  GLint skiprows, skippixels, alignment;
  GLenum format;
  int size;
 
  if (inColor) {
    format = GL_RGB;
    size = width*height*3;
  } else {
    format = GL_LUMINANCE;
    size = width*height*1;
  }
 
  buffer = new GLubyte[size];
  if (buffer == NULL)
    return NULL;
 
  glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapbytes);
  glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirst);
  glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlength);
 
  glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprows);
  glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skippixels);
  glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignment);
 
  glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
  glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
  glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
 
  glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
  glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 
  glReadBuffer(GL_FRONT);
  glReadPixels (0, 0, (GLsizei)width, (GLsizei)height, format, GL_UNSIGNED_BYTE, (GLvoid*) buffer);
 
  glPixelStorei (GL_UNPACK_SWAP_BYTES, swapbytes);
  glPixelStorei (GL_UNPACK_LSB_FIRST, lsbfirst);
  glPixelStorei (GL_UNPACK_ROW_LENGTH, rowlength);
  
  glPixelStorei (GL_UNPACK_SKIP_ROWS, skiprows);
  glPixelStorei (GL_UNPACK_SKIP_PIXELS, skippixels);
  glPixelStorei (GL_UNPACK_ALIGNMENT, alignment);
  
  return buffer;
}

References buffer.

Referenced by G4OpenGLViewer::printNonVectoredEPS().

◆ HaloingFirstPass()

void G4OpenGLViewer::HaloingFirstPass ( )

protectedinherited

Definition at line 441 of file G4OpenGLViewer.cc.

                                       {
  
  //To perform haloing, first Draw all information to the depth buffer
  //alone, using a chunky line width, and then Draw all info again, to
  //the colour buffer, setting a thinner line width an the depth testing 
  //function to less than or equal, so if two lines cross, the one 
  //passing behind the other will not pass the depth test, and so not
  //get rendered either side of the infront line for a short distance.
 
  //First, disable writing to the colo(u)r buffer...
  glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
  //Now enable writing to the depth buffer...
  glDepthMask (GL_TRUE);
  glDepthFunc (GL_LESS);
  glClearDepth (1.0);
 
  //Finally, set the line width to something wide...
  ChangeLineWidth(3.0);
 
}

References G4OpenGLViewer::ChangeLineWidth().

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), G4OpenGLStoredQtViewer::ComputeView(), DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

◆ HaloingSecondPass()

void G4OpenGLViewer::HaloingSecondPass ( )

protectedinherited

Definition at line 463 of file G4OpenGLViewer.cc.

                                        {
 
  //And finally, turn the colour buffer back on with a sesible line width...
  glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  glDepthFunc (GL_LEQUAL);
  ChangeLineWidth(1.0);
 
}

References G4OpenGLViewer::ChangeLineWidth().

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), G4OpenGLStoredQtViewer::ComputeView(), DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

◆ HLRFirstPass()

void G4OpenGLViewer::HLRFirstPass ( )

protectedinherited

◆ HLRSecondPass()

void G4OpenGLViewer::HLRSecondPass ( )

protectedinherited

◆ HLRThirdPass()

void G4OpenGLViewer::HLRThirdPass ( )

protectedinherited

◆ Initialise()

void G4OpenGLImmediateWin32Viewer::Initialise ( )

virtual

Reimplemented from G4VViewer.

Definition at line 48 of file G4OpenGLImmediateWin32Viewer.cc.

                                               {
 
// ensure a suitable window was found
 
  CreateGLWin32Context ();
  CreateMainWindow ();
  CreateFontLists ();
 
  // If a double buffer context has been forced upon us, ignore the
  // back buffer for this OpenGLImmediate view.
  glDrawBuffer (GL_FRONT);
 
  // clear the buffers and window.
  ClearView ();
  FinishView ();
 
  glDepthFunc (GL_LEQUAL);
  glDepthMask (GL_TRUE);
}

References G4OpenGLViewer::ClearView(), G4OpenGLViewer::CreateFontLists(), G4OpenGLWin32Viewer::CreateGLWin32Context(), G4OpenGLWin32Viewer::CreateMainWindow(), and FinishView().

◆ InitializeGLView()

void G4OpenGLViewer::InitializeGLView ( )

protectedinherited

Definition at line 127 of file G4OpenGLViewer.cc.

{
#ifdef G4OPENGL_VERSION_2
  if (fVboDrawer) {
    
    // First, load a simple shader
    fShaderProgram = glCreateProgram();
    Shader vertexShader = glCreateShader(GL_VERTEX_SHADER);
    const char * vSrc = fVboDrawer->getVertexShaderSrc();
    glShaderSource(vertexShader, 1, &vSrc, NULL);
    glCompileShader(vertexShader);
    glAttachShader(fShaderProgram, vertexShader);
    
    Shader fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    const char * fSrc = fVboDrawer->getFragmentShaderSrc();
    glShaderSource(fragmentShader, 1, &fSrc, NULL);
    glCompileShader(fragmentShader);
    
    glAttachShader(fShaderProgram, fragmentShader);
    glLinkProgram(fShaderProgram);
    glUseProgram(fShaderProgram);
    
    //   UniformLocation uColor = getUniformLocation(fShaderProgram, "uColor");
    //   uniform4fv(uColor, [0.0, 0.3, 0.0, 1.0]);
    
    // Extract the references to the attributes from the shader.
    
    fVertexPositionAttribute =
    glGetAttribLocation(fShaderProgram, "aVertexPosition");
    
    
    glEnableVertexAttribArray(fVertexPositionAttribute);
    
    // Extract the references the uniforms from the shader
    fpMatrixUniform  = glGetUniformLocation(fShaderProgram, "uPMatrix");
    fcMatrixUniform  = glGetUniformLocation(fShaderProgram, "uCMatrix");
    fmvMatrixUniform = glGetUniformLocation(fShaderProgram, "uMVMatrix");
    fnMatrixUniform  = glGetUniformLocation(fShaderProgram, "uNMatrix");
    ftMatrixUniform  = glGetUniformLocation(fShaderProgram, "uTMatrix");
    
    /*    glUniformMatrix4fv(fcMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(fpMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(ftMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(fmvMatrixUniform, 1, 0, identity);
     */
    // We have to set that in order to avoid calls on opengl commands before all is ready
    fGlViewInitialized = true;
  }
#endif
  
  if (fWinSize_x == 0) {
    fWinSize_x = fVP.GetWindowSizeHintX();
  }
  if (fWinSize_y == 0) {
    fWinSize_y = fVP.GetWindowSizeHintY();
  }
 
  glClearColor (0.0, 0.0, 0.0, 0.0);
  glClearDepth (1.0);
#ifndef G4OPENGL_VERSION_2
  glDisable (GL_LINE_SMOOTH);
  glDisable (GL_POLYGON_SMOOTH);
#endif
 
// clear the buffers and window?
  ClearView ();
  FinishView ();
  
  glDepthFunc (GL_LEQUAL);
  glDepthMask (GL_TRUE);
  
  glEnable (GL_BLEND);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
}

References G4OpenGLViewer::ClearView(), G4OpenGLViewer::fGlViewInitialized, G4VViewer::FinishView(), G4VViewer::fVP, G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4ViewParameters::GetWindowSizeHintX(), and G4ViewParameters::GetWindowSizeHintY().

Referenced by G4OpenGLImmediateXmViewer::Initialise(), G4OpenGLImmediateXViewer::Initialise(), G4OpenGLStoredXmViewer::Initialise(), G4OpenGLStoredXViewer::Initialise(), G4OpenGLImmediateQtViewer::initializeGL(), and G4OpenGLStoredQtViewer::initializeGL().

◆ isFramebufferReady()

G4bool G4OpenGLViewer::isFramebufferReady ( )

protectedinherited

Definition at line 730 of file G4OpenGLViewer.cc.

                                          {
  bool check = false;
#ifdef G4VIS_BUILD_OPENGLQT_DRIVER
  check = true;
#endif
#ifdef G4VIS_BUILD_OPENGLX_DRIVER
  check = false;
#endif
#ifdef G4VIS_BUILD_OPENGLXM_DRIVER
  check = false;
#endif
#ifdef G4VIS_BUILD_OPENGLWIN32_DRIVER
  check = false;
#endif
 
#if GL_ARB_framebuffer_object
  if (check) {
//    if ( glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_UNDEFINED) {
//      return false;
//    }
  }
#endif
    return true;
}

Referenced by G4OpenGLViewer::ClearView(), G4OpenGLViewer::ClearViewWithoutFlush(), G4OpenGLImmediateQtViewer::paintEvent(), and G4OpenGLStoredQtViewer::paintEvent().

◆ isGl2psWriting()

bool G4OpenGLViewer::isGl2psWriting ( )

protectedinherited

Return if gl2ps is currently writing

Definition at line 720 of file G4OpenGLViewer.cc.

                                    {
 
  if (!fGL2PSAction) return false;
  if (fGL2PSAction->fileWritingEnabled()) {
    return true;
  }
  return false;
}

References G4OpenGLViewer::fGL2PSAction, and G4OpenGL2PSAction::fileWritingEnabled().

Referenced by G4OpenGLViewer::ChangeLineWidth(), G4OpenGLViewer::ChangePointSize(), G4OpenGLQtViewer::DrawText(), G4OpenGLViewer::DrawText(), and G4OpenGLXViewer::DrawText().

◆ NeedKernelVisit()

void G4VViewer::NeedKernelVisit ( )

inherited

Definition at line 78 of file G4VViewer.cc.

                                 {
 
  fNeedKernelVisit = true;
 
  // At one time I thought we'd better notify all viewers.  But I guess
  // each viewer can take care of itself, so the following code is
  // redundant (but keep it commented out for now).   (John Allison)
  // Notify all viewers that a kernel visit is required.
  // const G4ViewerList& viewerList = fSceneHandler.GetViewerList ();
  // G4ViewerListConstIterator i;
  // for (i = viewerList.begin(); i != viewerList.end(); i++) {
  //   (*i) -> SetNeedKernelVisit ();
  // }
  // ??...but, there's a problem in OpenGL Stored which seems to
  // require *all* viewers to revisit the kernel, so...
  //  const G4ViewerList& viewerList = fSceneHandler.GetViewerList ();
  //  G4ViewerListConstIterator i;
  //  for (i = viewerList.begin(); i != viewerList.end(); i++) {
  //    (*i) -> SetNeedKernelVisit (true);
  //  }
  // Feb 2005 - commented out.  Let's fix OpenGL if necessary.
}

References G4VViewer::fNeedKernelVisit.

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), G4DAWNFILEViewer::DrawView(), G4GMocrenFileViewer::DrawView(), G4HepRepFileViewer::DrawView(), DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4VTreeViewer::DrawView(), G4VRML2FileViewer::DrawView(), G4VtkViewer::DrawView(), G4VisManager::GeometryHasChanged(), G4OpenGLStoredViewer::KernelVisitDecision(), G4OpenInventorViewer::KernelVisitDecision(), G4Qt3DViewer::KernelVisitDecision(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::KernelVisitDecision(), G4VisManager::NotifyHandlers(), G4OpenGLImmediateViewer::ProcessView(), G4VisCommandViewerRebuild::SetNewValue(), G4OpenInventorViewer::SetPreview(), G4OpenInventorViewer::SetPreviewAndFull(), G4OpenInventorViewer::SetReducedWireFrame(), and G4OpenInventorViewer::UpdateScene().

◆ Pick()

G4String G4OpenGLViewer::Pick	(	GLdouble	x,
		GLdouble	y
	)

protectedvirtualinherited

Definition at line 472 of file G4OpenGLViewer.cc.

{
  const std::vector < G4OpenGLViewerPickMap* > & pickMap = GetPickDetails(x,y);
  G4String txt = "";
  if (pickMap.size() == 0) {
//        txt += "No hits recorded.";;
  } else {
    for (unsigned int a=0; a < pickMap.size(); a++) {
      if (pickMap[a]->getAttributes().size() > 0) {
        txt += pickMap[a]->print();
      }
    }
  }
  return txt;
}

References G4OpenGLViewer::GetPickDetails().

Referenced by G4OpenGLXViewer::ShowView().

◆ printGl2PS()

bool G4OpenGLViewer::printGl2PS ( )

privateinherited

Definition at line 886 of file G4OpenGLViewer.cc.

                                {
 
  int width = getRealExportWidth();
  int height = getRealExportHeight();
  bool res = true;
 
  // no need to redraw at each new primitive for printgl2PS
  G4OpenGLSceneHandler& oglSceneHandler = dynamic_cast<G4OpenGLSceneHandler&>(fSceneHandler);
  G4OpenGLSceneHandler::FlushAction originalFlushAction = oglSceneHandler.GetFlushAction();
  oglSceneHandler.SetFlushAction(G4OpenGLSceneHandler::never);
 
  if (!fGL2PSAction) return false;
 
  fGL2PSAction->setFileName(getRealPrintFilename().c_str());
  // try to resize
  int X = fWinSize_x;
  int Y = fWinSize_y;
 
  fWinSize_x = width;
  fWinSize_y = height;
  // Laurent G. 16/03/10 : Not the good way to do. 
  // We should draw in a new offscreen context instead of
  // resizing and drawing in current window...
  // This should be solve when we will do an offscreen method
  // to render OpenGL
  // See : 
  // http://developer.apple.com/Mac/library/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_offscreen/opengl_offscreen.html
  // http://www.songho.ca/opengl/gl_fbo.html
 
   ResizeGLView();
   bool extendBuffer = true;
   bool endWriteAction = false;
   bool beginWriteAction = true;
   bool filePointerOk = true;
   while ((extendBuffer) && (! endWriteAction) && (filePointerOk)) {
     
     beginWriteAction = fGL2PSAction->enableFileWriting();
     // 3 cases :
     // - true
     // - false && ! fGL2PSAction->fileWritingEnabled() => bad file name
     // - false && fGL2PSAction->fileWritingEnabled() => buffer size problem ?
 
     filePointerOk = fGL2PSAction->fileWritingEnabled();
       
     if (beginWriteAction) {
       
       // Set the viewport
       // By default, we choose the line width (trajectories...)
       fGL2PSAction->setLineWidth(fGl2psDefaultLineWith);
       // By default, we choose the point size (markers...)
       fGL2PSAction->setPointSize(fGl2psDefaultPointSize);
       
       DrawView ();
       endWriteAction = fGL2PSAction->disableFileWriting();
     }
     if (filePointerOk) {
       if ((! endWriteAction) || (! beginWriteAction)) {
         extendBuffer = fGL2PSAction->extendBufferSize();
       }
     }
   }
   fGL2PSAction->resetBufferSizeParameters();
 
   if (!extendBuffer ) {
     G4cerr << "ERROR: gl2ps buffer size is not big enough to print this geometry. Try to extend it. No output produced"<< G4endl;
     res = false;
   }
   if (!beginWriteAction ) {
     G4cerr << "ERROR: saving file "<<getRealPrintFilename().c_str()<<". Check read/write access. No output produced" << G4endl;
     res = false;
   }
   if (!endWriteAction ) {
     G4cerr << "gl2ps error. No output produced" << G4endl;
     res = false;
   }
  fWinSize_x = X;
  fWinSize_y = Y;
 
  oglSceneHandler.SetFlushAction(originalFlushAction);
 
  // Reset for next time (useful is size change)
  //  fPrintSizeX = 0;
  //  fPrintSizeY = 0;
 
  return res;
}

References G4OpenGL2PSAction::disableFileWriting(), G4VViewer::DrawView(), G4OpenGL2PSAction::enableFileWriting(), G4OpenGL2PSAction::extendBufferSize(), G4OpenGLViewer::fGL2PSAction, G4OpenGLViewer::fGl2psDefaultLineWith, G4OpenGLViewer::fGl2psDefaultPointSize, G4OpenGL2PSAction::fileWritingEnabled(), G4VViewer::fSceneHandler, G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4cerr, G4endl, G4OpenGLSceneHandler::GetFlushAction(), G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getRealPrintFilename(), G4OpenGLSceneHandler::never, G4OpenGL2PSAction::resetBufferSizeParameters(), G4OpenGLViewer::ResizeGLView(), G4OpenGL2PSAction::setFileName(), G4OpenGLSceneHandler::SetFlushAction(), G4OpenGL2PSAction::setLineWidth(), G4OpenGL2PSAction::setPointSize(), and Y().

Referenced by G4OpenGLViewer::printVectoredEPS().

◆ printNonVectoredEPS()

bool G4OpenGLViewer::printNonVectoredEPS ( )

privateinherited

Definition at line 633 of file G4OpenGLViewer.cc.

                                          {
 
  int width = getRealExportWidth();
  int height = getRealExportHeight();
 
  FILE* fp;
  GLubyte* pixels;
  GLubyte* curpix;
  int components, pos, i;
 
  pixels = grabPixels (fPrintColour, width, height);
 
  if (pixels == NULL) {
      G4cerr << "Failed to get pixels from OpenGl viewport" << G4endl;
    return false;
  }
  if (fPrintColour) {
    components = 3;
  } else {
    components = 1;
  }
  std::string name = getRealPrintFilename();
  fp = fopen (name.c_str(), "w");
  if (fp == NULL) {
    G4cerr << "Can't open filename " << name.c_str() << G4endl;
    return false;
  }
  
  fprintf (fp, "%%!PS-Adobe-2.0 EPSF-1.2\n");
  fprintf (fp, "%%%%Title: %s\n", name.c_str());
  fprintf (fp, "%%%%Creator: OpenGL pixmap render output\n");
  fprintf (fp, "%%%%BoundingBox: 0 0 %d %d\n", width, height);
  fprintf (fp, "%%%%EndComments\n");
  fprintf (fp, "gsave\n");
  fprintf (fp, "/bwproc {\n");
  fprintf (fp, "    rgbproc\n");
  fprintf (fp, "    dup length 3 idiv string 0 3 0 \n");
  fprintf (fp, "    5 -1 roll {\n");
  fprintf (fp, "    add 2 1 roll 1 sub dup 0 eq\n");
  fprintf (fp, "    { pop 3 idiv 3 -1 roll dup 4 -1 roll dup\n");
  fprintf (fp, "       3 1 roll 5 -1 roll } put 1 add 3 0 \n");
  fprintf (fp, "    { 2 1 roll } ifelse\n");
  fprintf (fp, "    }forall\n");
  fprintf (fp, "    pop pop pop\n");
  fprintf (fp, "} def\n");
  fprintf (fp, "systemdict /colorimage known not {\n");
  fprintf (fp, "   /colorimage {\n");
  fprintf (fp, "       pop\n");
  fprintf (fp, "       pop\n");
  fprintf (fp, "       /rgbproc exch def\n");
  fprintf (fp, "       { bwproc } image\n");
  fprintf (fp, "   }  def\n");
  fprintf (fp, "} if\n");
  fprintf (fp, "/picstr %d string def\n", width * components);
  fprintf (fp, "%d %d scale\n", width, height);
  fprintf (fp, "%d %d %d\n", width, height, 8);
  fprintf (fp, "[%d 0 0 %d 0 0]\n", width, height);
  fprintf (fp, "{currentfile picstr readhexstring pop}\n");
  fprintf (fp, "false %d\n", components);
  fprintf (fp, "colorimage\n");
  
  curpix = (GLubyte*) pixels;
  pos = 0;
  for (i = width*height*components; i>0; i--) {
    fprintf (fp, "%02hx ", (unsigned short)(*(curpix++)));
    if (++pos >= 32) {
      fprintf (fp, "\n");
      pos = 0; 
    }
  }
  if (pos)
    fprintf (fp, "\n");
 
  fprintf (fp, "grestore\n");
  fprintf (fp, "showpage\n");
  delete [] pixels;
  fclose (fp);
 
  // Reset for next time (useful is size change)
  //  fPrintSizeX = -1;
  //  fPrintSizeY = -1;
 
  return true;
}

References G4OpenGLViewer::fPrintColour, G4cerr, G4endl, G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getRealPrintFilename(), G4OpenGLViewer::grabPixels(), G4InuclParticleNames::name(), and pos.

Referenced by G4OpenGLViewer::exportImage().

◆ printVectoredEPS()

bool G4OpenGLViewer::printVectoredEPS ( )

privateinherited

Definition at line 629 of file G4OpenGLViewer.cc.

                                      {
  return printGl2PS();
}

References G4OpenGLViewer::printGl2PS().

Referenced by G4OpenGLViewer::exportImage().

◆ ProcessView() [1/2]

void G4VViewer::ProcessView ( )

inherited

Definition at line 105 of file G4VViewer.cc.

{
  // If the scene has changed, or if the concrete viewer has decided
  // that it necessary to visit the kernel, perhaps because the view
  // parameters have changed significantly (this should be done in the
  // concrete viewer's DrawView)...
  if (fNeedKernelVisit) {
    // Reset flag.  This must be done before ProcessScene to prevent
    // recursive calls when recomputing transients...
    fNeedKernelVisit = false;
    fSceneHandler.ClearStore ();
    fSceneHandler.ProcessScene ();
  }
}

References G4VSceneHandler::ClearStore(), G4VViewer::fNeedKernelVisit, G4VViewer::fSceneHandler, and G4VSceneHandler::ProcessScene().

◆ ProcessView() [2/2]

void G4OpenGLImmediateViewer::ProcessView ( )

inherited

Definition at line 42 of file G4OpenGLImmediateViewer.cc.

{
  const G4Planes& cutaways = fVP.GetCutawayPlanes();
  G4bool cutawayUnion = fVP.IsCutaway() &&
    fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion;
  size_t nPasses = cutawayUnion? cutaways.size(): 1;
  for (size_t i = 0; i < nPasses; ++i) {
 
    if (cutawayUnion) {
      double a[4];
      a[0] = cutaways[i].a();
      a[1] = cutaways[i].b();
      a[2] = cutaways[i].c();
      a[3] = cutaways[i].d();
      glClipPlane (GL_CLIP_PLANE2, a);
      glEnable (GL_CLIP_PLANE2);
    }
 
    NeedKernelVisit ();  // Always need to visit G4 kernel.
    G4VViewer::ProcessView ();
 
    if (cutawayUnion) glDisable (GL_CLIP_PLANE2);
  }
}

References G4ViewParameters::cutawayUnion, G4VViewer::fVP, G4ViewParameters::GetCutawayMode(), G4ViewParameters::GetCutawayPlanes(), G4ViewParameters::IsCutaway(), G4VViewer::NeedKernelVisit(), and G4VViewer::ProcessView().

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), DrawView(), G4OpenGLImmediateXmViewer::DrawView(), and G4OpenGLImmediateXViewer::DrawView().

◆ RefreshView()

void G4VViewer::RefreshView ( )

inherited

Referenced by G4VisManager::EndOfRun(), G4VVisCommand::InterpolateViews(), and G4VisCommandViewerInterpolate::SetNewValue().

◆ ReleaseMouse()

void G4OpenGLWin32Viewer::ReleaseMouse ( )

privateinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 417 of file G4OpenGLWin32Viewer.cc.

{
  fMousePressed = false;
  fMousePressedX = 0;
  fMousePressedY = 0;
}

References G4OpenGLWin32Viewer::fMousePressed, G4OpenGLWin32Viewer::fMousePressedX, and G4OpenGLWin32Viewer::fMousePressedY.

◆ ResetView()

void G4OpenGLViewer::ResetView ( )

protectedvirtualinherited

Reimplemented from G4VViewer.

Reimplemented in G4OpenGLXmViewer.

Definition at line 434 of file G4OpenGLViewer.cc.

                                {
  G4VViewer::ResetView();
  fRot_sens = 1;
  fPan_sens = 0.01;
}

References G4OpenGLViewer::fPan_sens, G4OpenGLViewer::fRot_sens, and G4VViewer::ResetView().

Referenced by G4OpenGLQtViewer::ResetView(), and G4OpenGLXmViewer::ResetView().

◆ ResizeGLView()

void G4OpenGLViewer::ResizeGLView ( )

protectedinherited

Set the viewport of the scene MAXIMUM SIZE is : GLint dims[2]; glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);

Definition at line 250 of file G4OpenGLViewer.cc.

{
  // Check size
  GLint dims[2];
  dims[0] = 0;
  dims[1] = 0;
 
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
 
    if (fWinSize_x > (unsigned)dims[0]) {
      G4cerr << "Try to resize view greater than max X viewport dimension. Desired size "<<fWinSize_x <<" is resize to "<<  dims[0] << G4endl;
      fWinSize_x = dims[0];
    }
    if (fWinSize_y > (unsigned)dims[1]) {
      G4cerr << "Try to resize view greater than max Y viewport dimension. Desired size "<<fWinSize_y <<" is resize to "<<  dims[1] << G4endl;
      fWinSize_y = dims[1];
    }
  }
    
  glViewport(0, 0, fWinSize_x,fWinSize_y);   
 
 
}

References G4OpenGLViewer::fWinSize_x, G4OpenGLViewer::fWinSize_y, G4cerr, and G4endl.

Referenced by G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::SetView().

◆ ResizeWindow()

void G4OpenGLViewer::ResizeWindow	(	unsigned int	aWidth,
		unsigned int	aHeight
	)

protectedinherited

Definition at line 234 of file G4OpenGLViewer.cc.

                                                                           {
  if ((fWinSize_x != aWidth) || (fWinSize_y != aHeight)) {
    fWinSize_x = aWidth;
    fWinSize_y = aHeight;
    fSizeHasChanged = true;
  } else {
    fSizeHasChanged = false;
  }
}

References G4OpenGLViewer::fSizeHasChanged, G4OpenGLViewer::fWinSize_x, and G4OpenGLViewer::fWinSize_y.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLXmViewer::expose_callback(), G4OpenGLImmediateQtViewer::resizeGL(), and G4OpenGLStoredQtViewer::resizeGL().

◆ rotateScene()

void G4OpenGLViewer::rotateScene	(	G4double	dx,
		G4double	dy
	)

protectedinherited

Definition at line 1128 of file G4OpenGLViewer.cc.

{
  if (fVP.GetRotationStyle() == G4ViewParameters::freeRotation) {
    rotateSceneInViewDirection(dx,dy);
  } else {
    if( dx != 0) {
      rotateSceneThetaPhi(dx,0);
    }
    if( dy != 0) {
      rotateSceneThetaPhi(0,dy);
    }
  }
}

References G4ViewParameters::freeRotation, G4VViewer::fVP, G4ViewParameters::GetRotationStyle(), G4OpenGLViewer::rotateSceneInViewDirection(), and G4OpenGLViewer::rotateSceneThetaPhi().

Referenced by G4OpenGLXmViewer::rotate_in_phi(), G4OpenGLXmViewer::rotate_in_theta(), and G4OpenGLQtViewer::rotateQtScene().

◆ rotateSceneInViewDirection()

void G4OpenGLViewer::rotateSceneInViewDirection	(	G4double	dx,
		G4double	dy
	)

privateinherited

Definition at line 1241 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return;
  }
 
  G4Vector3D vp;
  G4Vector3D up;
  
  G4Vector3D xprime;
  G4Vector3D yprime;
  G4Vector3D zprime;
  
  G4Vector3D new_vp;
  G4Vector3D new_up;
  
  G4Vector3D a1;
  G4Vector3D a2;
  G4Vector3D delta;
  G4Vector3D viewPoint;
 
  dx = dx/100;
  dy = dy/100;
 
  //phi spin stuff here
  
  vp = fVP.GetViewpointDirection ().unit();
  up = fVP.GetUpVector ().unit();
 
  G4Vector3D zPrimeVector = G4Vector3D(up.y()*vp.z()-up.z()*vp.y(),
                             up.z()*vp.x()-up.x()*vp.z(),
                             up.x()*vp.y()-up.y()*vp.x());
 
  viewPoint = vp/fRot_sens + (zPrimeVector*dx - up*dy) ;
  new_up = G4Vector3D(viewPoint.y()*zPrimeVector.z()-viewPoint.z()*zPrimeVector.y(),
                       viewPoint.z()*zPrimeVector.x()-viewPoint.x()*zPrimeVector.z(),
                       viewPoint.x()*zPrimeVector.y()-viewPoint.y()*zPrimeVector.x());
 
  G4Vector3D new_upUnit = new_up.unit();
  
  
 
   fVP.SetUpVector(new_upUnit);
   fVP.SetViewAndLights (viewPoint);
}

References G4OpenGLViewer::fRot_sens, G4VViewer::fSceneHandler, G4VViewer::fVP, G4VSceneHandler::GetScene(), G4ViewParameters::GetUpVector(), G4ViewParameters::GetViewpointDirection(), G4ViewParameters::SetUpVector(), G4ViewParameters::SetViewAndLights(), HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

Referenced by G4OpenGLViewer::rotateScene(), and G4OpenGLViewer::rotateSceneToggle().

◆ rotateSceneThetaPhi()

void G4OpenGLViewer::rotateSceneThetaPhi	(	G4double	dx,
		G4double	dy
	)

privateinherited

Definition at line 1157 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return;
  }
 
  G4Vector3D vp;
  G4Vector3D up;
  
  G4Vector3D xprime;
  G4Vector3D yprime;
  G4Vector3D zprime;
  
  G4double delta_alpha;
  G4double delta_theta;
  
  G4Vector3D new_vp;
  G4Vector3D new_up;
  
  G4double cosalpha;
  G4double sinalpha;
  
  G4Vector3D a1;
  G4Vector3D a2;
  G4Vector3D delta;
  G4Vector3D viewPoint;
 
    
  //phi spin stuff here
  
  vp = fVP.GetViewpointDirection ().unit ();
  up = fVP.GetUpVector ().unit ();
  
  yprime = (up.cross(vp)).unit();
  zprime = (vp.cross(yprime)).unit();
  
  if (fVP.GetLightsMoveWithCamera()) {
    delta_alpha = dy * fRot_sens;
    delta_theta = -dx * fRot_sens;
  } else {
    delta_alpha = -dy * fRot_sens;
    delta_theta = dx * fRot_sens;
  }    
  
  delta_alpha *= CLHEP::deg;
  delta_theta *= CLHEP::deg;
  
  new_vp = std::cos(delta_alpha) * vp + std::sin(delta_alpha) * zprime;
  
  // to avoid z rotation flipping
  // to allow more than 360∞ rotation
 
  if (fVP.GetLightsMoveWithCamera()) {
    new_up = (new_vp.cross(yprime)).unit();
    if (new_vp.z()*vp.z() <0) {
      new_up.set(new_up.x(),-new_up.y(),new_up.z());
    }
  } else {
    new_up = up;
    if (new_vp.z()*vp.z() <0) {
      new_up.set(new_up.x(),-new_up.y(),new_up.z());
    }
  }
  fVP.SetUpVector(new_up);
  // Rotates by fixed azimuthal angle delta_theta.
  
  cosalpha = new_up.dot (new_vp.unit());
  sinalpha = std::sqrt (1. - std::pow (cosalpha, 2));
  yprime = (new_up.cross (new_vp.unit())).unit ();
  xprime = yprime.cross (new_up);
  // Projection of vp on plane perpendicular to up...
  a1 = sinalpha * xprime;
  // Required new projection...
  a2 = sinalpha * (std::cos (delta_theta) * xprime + std::sin (delta_theta) * yprime);
  // Required Increment vector...
  delta = a2 - a1;
  // So new viewpoint is...
  viewPoint = new_vp.unit() + delta;
  
  fVP.SetViewAndLights (viewPoint);
}

References HepGeom::BasicVector3D< T >::cross(), CLHEP::deg, HepGeom::BasicVector3D< T >::dot(), G4OpenGLViewer::fRot_sens, G4VViewer::fSceneHandler, G4VViewer::fVP, G4ViewParameters::GetLightsMoveWithCamera(), G4VSceneHandler::GetScene(), G4ViewParameters::GetUpVector(), G4ViewParameters::GetViewpointDirection(), HepGeom::BasicVector3D< T >::set(), G4ViewParameters::SetUpVector(), G4ViewParameters::SetViewAndLights(), HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

Referenced by G4OpenGLViewer::rotateScene(), and G4OpenGLViewer::rotateSceneToggle().

◆ rotateSceneToggle()

void G4OpenGLViewer::rotateSceneToggle	(	G4double	dx,
		G4double	dy
	)

protectedinherited

Definition at line 1143 of file G4OpenGLViewer.cc.

{
  if (fVP.GetRotationStyle() != G4ViewParameters::freeRotation) {
    rotateSceneInViewDirection(dx,dy);
  } else {
    if( dx != 0) {
      rotateSceneThetaPhi(dx,0);
    }
    if( dy != 0) {
      rotateSceneThetaPhi(0,dy);
    }
  }
}

References G4ViewParameters::freeRotation, G4VViewer::fVP, G4ViewParameters::GetRotationStyle(), G4OpenGLViewer::rotateSceneInViewDirection(), and G4OpenGLViewer::rotateSceneThetaPhi().

Referenced by G4OpenGLQtViewer::rotateQtSceneToggle().

◆ SetDefaultViewParameters()

void G4VViewer::SetDefaultViewParameters ( const G4ViewParameters & vp )

inherited

◆ setExportFilename()

bool G4OpenGLViewer::setExportFilename	(	G4String	name,
		G4bool	inc = `true`
	)

protectedinherited

If name is "" or "!", filename and extension will have the default value. If name is "toto.png", set the name to "toto" and the format to "png". No incremented suffix is added. If name is "toto", set the name to "toto" and the format to default (or current format if specify). If name is the same as previous, do not reset incremented suffix.

Definition at line 1034 of file G4OpenGLViewer.cc.

                                                               {
  if (name == "!") {
    name = "";
  }
 
  if (inc) {
    if ((name != "") && (fExportFilename != name)) {
      fExportFilenameIndex=0;
    }
  } else {
    fExportFilenameIndex=-1;
  }
 
  if (name.size() == 0) {
    name = getRealPrintFilename().c_str();
  } else {
    // guess format by extention
    std::string extension = name.substr(name.find_last_of(".") + 1);
    // If there is a dot in the name the above might find rubbish, so...
    if (extension.size() >= 3 && extension.size() <= 4) {  // Possible extension
      if (setExportImageFormat(extension, false)) {  // Extension found
        fExportFilename = name.substr(0,name.find_last_of("."));
      } else {  // No viable extension found
        return false;
      }
    } else {  // Assume name is already the required without-extension part
        fExportFilename = name;
    }
  }
  return true;
}

References G4OpenGLViewer::fExportFilename, G4OpenGLViewer::fExportFilenameIndex, G4OpenGLViewer::getRealPrintFilename(), G4InuclParticleNames::name(), and G4OpenGLViewer::setExportImageFormat().

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), and G4OpenGLViewerMessenger::SetNewValue().

◆ setExportImageFormat()

bool G4OpenGLViewer::setExportImageFormat	(	std::string	format,
		bool	quiet = `false`
	)

inherited

Definition at line 1292 of file G4OpenGLViewer.cc.

                                                                      {
  bool found = false;
  std::string list;
  for (unsigned int a=0; a<fExportImageFormatVector.size(); a++) {
    list +=fExportImageFormatVector.at(a) + " ";
 
    if (fExportImageFormatVector.at(a) == format) {
      if (! quiet) {
        G4cout << " Changing export format to \"" << format << "\"" << G4endl;
      }
      if (format != fExportImageFormat) {
        fExportFilenameIndex = 0;
        fExportImageFormat = format;
      }
      return true;
    }
  }
  if (! found) {
    if (format.size() == 0) {
      G4cout << " Current formats availables are : " << list << G4endl;
    } else {
      G4cerr << " Format \"" << format << "\" is not available for the selected viewer. Current formats availables are : " << list << G4endl;
    }
  }
  return false;
}

References G4OpenGLViewer::fExportFilenameIndex, G4OpenGLViewer::fExportImageFormat, G4OpenGLViewer::fExportImageFormatVector, G4cerr, G4cout, and G4endl.

Referenced by G4OpenGLViewer::exportImage(), G4OpenGLImmediateQtViewer::initializeGL(), G4OpenGLStoredQtViewer::initializeGL(), G4OpenGLViewer::setExportFilename(), and G4OpenGLViewerMessenger::SetNewValue().

◆ setExportSize()

void G4OpenGLViewer::setExportSize	(	G4int	X,
		G4int	Y
	)

protectedinherited

Definition at line 1023 of file G4OpenGLViewer.cc.

                                                   {
  fPrintSizeX = X;
  fPrintSizeY = Y;
}

References G4OpenGLViewer::fPrintSizeX, G4OpenGLViewer::fPrintSizeY, and Y().

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), and G4OpenGLViewerMessenger::SetNewValue().

◆ SetName()

void G4VViewer::SetName ( const G4String & name )

inherited

Definition at line 72 of file G4VViewer.cc.

                                             {
  fName = name;
  fShortName = fName.substr(0, fName.find (' '));
  G4StrUtil::strip(fShortName);
}

References G4VViewer::fName, G4VViewer::fShortName, G4InuclParticleNames::name(), and G4StrUtil::strip().

◆ SetNeedKernelVisit()

void G4VViewer::SetNeedKernelVisit ( G4bool need )

inherited

Referenced by G4OpenGLXmViewer::aux_edge_callback(), G4OpenGLQtViewer::toggleAux(), G4OpenGLQtViewer::toggleTransparency(), and G4OpenGLXmViewer::transparency_callback().

◆ SetRotation()

void G4OpenGLWin32Viewer::SetRotation	(	G4int	dx,
		G4int	dy
	)

privateinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 444 of file G4OpenGLWin32Viewer.cc.

{
  // Simple ad-hoc algorithms (borrowed from G4Qt3DViewer)
  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());
  }
}

References HepGeom::BasicVector3D< T >::cross(), G4ViewParameters::freeRotation, G4VViewer::fVP, G4ViewParameters::GetRotationStyle(), G4ViewParameters::GetUpVector(), G4ViewParameters::GetViewpointDirection(), G4ViewParameters::SetUpVector(), G4ViewParameters::SetViewpointDirection(), and HepGeom::BasicVector3D< T >::unit().

◆ SetShift()

void G4OpenGLWin32Viewer::SetShift	(	G4int	dx,
		G4int	dy
	)

privateinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 428 of file G4OpenGLWin32Viewer.cc.

{
  const G4double sceneRadius = GetSceneHandler()->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);
}

References G4VViewer::fVP, G4Scene::GetExtent(), G4VisExtent::GetExtentRadius(), G4VSceneHandler::GetScene(), G4VViewer::GetSceneHandler(), and G4ViewParameters::IncrementPan().

◆ SetTouchable()

void G4VViewer::SetTouchable ( const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > & fullPath )

protectedinherited

Definition at line 124 of file G4VViewer.cc.

{
  // Set the touchable for /vis/touchable/set/... commands.
  std::ostringstream oss;
  const auto& pvStore = G4PhysicalVolumeStore::GetInstance();
  for (const auto& pvNodeId: fullPath) {
    const auto& pv = pvNodeId.GetPhysicalVolume();
    auto iterator = find(pvStore->begin(),pvStore->end(),pv);
    if (iterator == pvStore->end()) {
      G4ExceptionDescription ed;
      ed << "Volume no longer in physical volume store.";
      G4Exception("G4VViewer::SetTouchable", "visman0501", JustWarning, ed);
    } else {
      oss
      << ' ' << pvNodeId.GetPhysicalVolume()->GetName()
      << ' ' << pvNodeId.GetCopyNo();
    }
  }
  G4UImanager::GetUIpointer()->ApplyCommand("/vis/set/touchable" + oss.str());
}

References G4UImanager::ApplyCommand(), G4Exception(), G4PhysicalVolumeStore::GetInstance(), G4UImanager::GetUIpointer(), and JustWarning.

Referenced by G4OpenGLQtViewer::changeColorAndTransparency(), and G4OpenGLQtViewer::setCheckComponent().

◆ SetView()

void G4OpenGLWin32Viewer::SetView ( )

virtualinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Reimplemented from G4OpenGLViewer.

Definition at line 47 of file G4OpenGLWin32Viewer.cc.

{
  if(!fHDC) return;
  if(!fHGLRC) return;
  ::wglMakeCurrent(fHDC,fHGLRC);
  G4OpenGLViewer::SetView ();  
}

References G4OpenGLWin32Viewer::fHDC, G4OpenGLWin32Viewer::fHGLRC, and G4OpenGLViewer::SetView().

◆ SetViewParameters()

void G4VViewer::SetViewParameters ( const G4ViewParameters & vp )

inherited

Definition at line 120 of file G4VViewer.cc.

                                                             {
  fVP = vp;
}

References G4VViewer::fVP.

Referenced by G4VVisCommand::InterpolateViews(), G4VisCommandDrawView::SetNewValue(), G4VisCommandViewerCreate::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenInventorViewer::SetReducedWireFrame(), G4OpenInventorViewer::SetSolid(), G4VVisCommand::SetViewParameters(), and G4OpenInventorViewer::SetWireFrame().

◆ SetWindowPixelFormat()

G4bool G4OpenGLWin32Viewer::SetWindowPixelFormat ( HDC aHdc )

staticprivateinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 349 of file G4OpenGLWin32Viewer.cc.

{
  // The ungessable...
 
  PIXELFORMATDESCRIPTOR pfd;
  pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
  pfd.nVersion = 1;
  pfd.dwFlags = 
    PFD_DRAW_TO_WINDOW | 
    PFD_SUPPORT_OPENGL | 
    PFD_DOUBLEBUFFER | 
    PFD_STEREO_DONTCARE;  
  pfd.iPixelType = PFD_TYPE_RGBA;
  pfd.cColorBits = 32;
  pfd.cRedBits = 8;
  pfd.cRedShift = 16;
  pfd.cGreenBits = 8;
  pfd.cGreenShift = 8;
  pfd.cBlueBits = 8;
  pfd.cBlueShift = 0;
  pfd.cAlphaBits = 0;
  pfd.cAlphaShift = 0;
  pfd.cAccumBits = 64;  
  pfd.cAccumRedBits = 16;
  pfd.cAccumGreenBits = 16;
  pfd.cAccumBlueBits = 16;
  pfd.cAccumAlphaBits = 0;
  pfd.cDepthBits = 32;
  pfd.cStencilBits = 8;
  pfd.cAuxBuffers = 0;
  pfd.iLayerType = PFD_MAIN_PLANE;
  pfd.bReserved = 0;
  pfd.dwLayerMask = 0;
  pfd.dwVisibleMask = 0;
  pfd.dwDamageMask = 0;
  
  G4int pixelIndex = ::ChoosePixelFormat(aHdc,&pfd);
  if (pixelIndex==0) {
    pixelIndex = 1; 
    if (::DescribePixelFormat(aHdc, 
                  pixelIndex, 
                  sizeof(PIXELFORMATDESCRIPTOR), 
                  &pfd)==0) {
      return false;
    }
  }
  if (::SetPixelFormat(aHdc,pixelIndex,&pfd)==FALSE) return false;
  return true;
}

References FALSE.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow().

◆ SetZoom()

void G4OpenGLWin32Viewer::SetZoom ( G4int delta )

privateinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 470 of file G4OpenGLWin32Viewer.cc.

{
    if (fVP.GetFieldHalfAngle() == 0.) {  // Orthographic projection
        const G4double scale = 500;  // Empirically chosen
        fVP.MultiplyZoomFactor(1. + delta/scale);
    } else {                              // Perspective projection
        const G4double scale = fVP.GetFieldHalfAngle()/(10.*deg);  // Empirical
        fVP.SetDolly(fVP.GetDolly() + delta/scale);
    }
}

References deg, G4VViewer::fVP, G4ViewParameters::GetDolly(), G4ViewParameters::GetFieldHalfAngle(), G4ViewParameters::MultiplyZoomFactor(), and G4ViewParameters::SetDolly().

◆ ShowView()

void G4OpenGLWin32Viewer::ShowView ( void )

virtualinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Reimplemented from G4VViewer.

Definition at line 59 of file G4OpenGLWin32Viewer.cc.

{
  if(!fHDC) return;
  glFlush ();
  // Empty the Windows message queue :
  MSG event;
  while ( ::PeekMessage(&event, NULL, 0, 0, PM_REMOVE) ) {
    ::TranslateMessage(&event);
    ::DispatchMessage (&event);
  }
}

References G4OpenGLWin32Viewer::fHDC.

◆ sizeHasChanged()

G4bool G4OpenGLViewer::sizeHasChanged ( )

protectedinherited

Definition at line 981 of file G4OpenGLViewer.cc.

                                      {
  return fSizeHasChanged;
}

References G4OpenGLViewer::fSizeHasChanged.

Referenced by G4OpenGLImmediateQtViewer::resizeGL(), and G4OpenGLStoredQtViewer::resizeGL().

◆ TouchableSetColour()

void G4VViewer::TouchableSetColour	(	const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &	fullPath,
		const G4Colour &	colour
	)

protectedinherited

Definition at line 180 of file G4VViewer.cc.

{
  // Changes the Vis Attribute Modifiers WITHOUT triggering a rebuild.
 
  std::ostringstream oss;
  oss << "/vis/touchable/set/colour "
  << colour.GetRed() << ' ' << colour.GetGreen()
  << ' ' << colour.GetBlue() << ' ' << colour.GetAlpha();
 
  // The following is equivalent to
  //  G4UImanager::GetUIpointer()->ApplyCommand(oss.str());
  // (assuming the touchable has already been set), but avoids view rebuild.
 
  // Instantiate a working copy of a G4VisAttributes object...
  G4VisAttributes workingVisAtts;
  // and set the colour.
  workingVisAtts.SetColour(colour);
 
  fVP.AddVisAttributesModifier
  (G4ModelingParameters::VisAttributesModifier
   (workingVisAtts,
    G4ModelingParameters::VASColour,
    G4PhysicalVolumeModel::GetPVNameCopyNoPath(fullPath)));
  // G4ModelingParameters::VASColour (VAS = Vis Attribute Signifier)
  // signifies that it is the colour that should be picked out
  // and merged with the touchable's normal vis attributes.
 
  // Record on G4cout (with #) for information.
  if (G4UImanager::GetUIpointer()->GetVerboseLevel() >= 2) {
    G4cout << "# " << oss.str() << G4endl;
  }
}

References G4ViewParameters::AddVisAttributesModifier(), G4VViewer::fVP, G4cout, G4endl, G4Colour::GetAlpha(), G4Colour::GetBlue(), G4Colour::GetGreen(), G4PhysicalVolumeModel::GetPVNameCopyNoPath(), G4Colour::GetRed(), G4UImanager::GetUIpointer(), G4VisAttributes::SetColour(), and G4ModelingParameters::VASColour.

Referenced by G4OpenGLQtViewer::changeColorAndTransparency().

◆ TouchableSetVisibility()

void G4VViewer::TouchableSetVisibility	(	const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &	fullPath,
		G4bool	visibility
	)

protectedinherited

Definition at line 146 of file G4VViewer.cc.

{
  // Changes the Vis Attribute Modifiers WITHOUT triggering a rebuild.
 
  std::ostringstream oss;
  oss << "/vis/touchable/set/visibility ";
  if (visibiity) oss << "true"; else oss << "false";
 
  // The following is equivalent to
  //  G4UImanager::GetUIpointer()->ApplyCommand(oss.str());
  // (assuming the touchable has already been set), but avoids view rebuild.
 
  // Instantiate a working copy of a G4VisAttributes object...
  G4VisAttributes workingVisAtts;
  // and set the visibility.
  workingVisAtts.SetVisibility(visibiity);
 
  fVP.AddVisAttributesModifier
  (G4ModelingParameters::VisAttributesModifier
   (workingVisAtts,
    G4ModelingParameters::VASVisibility,
    G4PhysicalVolumeModel::GetPVNameCopyNoPath(fullPath)));
  // G4ModelingParameters::VASVisibility (VAS = Vis Attribute Signifier)
  // signifies that it is the visibility that should be picked out
  // and merged with the touchable's normal vis attributes.
 
  // Record on G4cout (with #) for information.
  if (G4UImanager::GetUIpointer()->GetVerboseLevel() >= 2) {
    G4cout << "# " << oss.str() << G4endl;
  }
}

References G4ViewParameters::AddVisAttributesModifier(), G4VViewer::fVP, G4cout, G4endl, G4PhysicalVolumeModel::GetPVNameCopyNoPath(), G4UImanager::GetUIpointer(), G4VisAttributes::SetVisibility(), and G4ModelingParameters::VASVisibility.

Referenced by G4OpenGLQtViewer::setCheckComponent().

◆ TrackMouse()

void G4OpenGLWin32Viewer::TrackMouse	(	G4int	x,
		G4int	y
	)

privateinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 404 of file G4OpenGLWin32Viewer.cc.

{
  fMousePressed = true;
  fMousePressedX = x;
  fMousePressedY = y;
}

References G4OpenGLWin32Viewer::fMousePressed, G4OpenGLWin32Viewer::fMousePressedX, and G4OpenGLWin32Viewer::fMousePressedY.

◆ WindowProc()

LRESULT CALLBACK G4OpenGLWin32Viewer::WindowProc	(	HWND	aWindow,
		UINT	aMessage,
		WPARAM	aWParam,
		LPARAM	aLParam
	)

staticprivateinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 202 of file G4OpenGLWin32Viewer.cc.

{
  switch (aMessage) {
    case WM_SIZE: {
      //FIXME : have to handle WM_RESIZE
      // Seems to be done (ovidio.pena AT upm.es, 2021/02/23)
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
      if (This) {
        This->fWinSize_x = (G4int) LOWORD(aLParam);
        This->fWinSize_y = (G4int) HIWORD(aLParam);
        if (!This->fInCreateWindow) {
          This->SetView();
          glViewport(0, 0, This->fWinSize_x, This->fWinSize_y);
          This->DrawView();
        }
      }
      return 0;
    }
 
    case WM_PAINT: {
      PAINTSTRUCT ps;
      BeginPaint(aWindow, &ps);
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
      if (This) {
        //FIXME : To have an automatic refresh someone have to redraw here.
        // Seems to be done (ovidio.pena AT upm.es, 2021/02/23)
        if(!This->fInCreateWindow) {
          This->SetView();
          This->ClearView();
          This->DrawView();
        }
      }
      EndPaint(aWindow, &ps);
      return 0;
    }
 
    case WM_LBUTTONDOWN: {
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
      This->TrackMouse(LOWORD(aLParam), HIWORD(aLParam));
      return 0;
    }
 
    case WM_RBUTTONDOWN: {
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
      This->TrackMouse(LOWORD(aLParam), HIWORD(aLParam));
      return 0;
    }
 
    case WM_LBUTTONUP: {
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
      This->ReleaseMouse();
      return 0;
    }
 
    case WM_RBUTTONUP: {
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
      This->ReleaseMouse();
      return 0;
    }
 
    case WM_MOUSEHOVER: {
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
      This->fMouseHovered = true;
            return 0;
    }
 
    case WM_MOUSELEAVE: {
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
      This->fMouseHovered = false;
      return 0;
    }
 
    case WM_MOUSEMOVE: {
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
 
      if (!This->fMouseHovered) {
        // mouse hover/leave tracking
        TRACKMOUSEEVENT tme;
        tme.cbSize = sizeof(tme);
        tme.dwFlags = TME_HOVER | TME_LEAVE;
        tme.hwndTrack = aWindow;
        tme.dwHoverTime = HOVER_DEFAULT;
        ::TrackMouseEvent(&tme);
        This->fMouseHovered = true;
      }
 
      if (This->fMousePressed) {
        G4int x = (G4int) LOWORD(aLParam);
        G4int y = (G4int) HIWORD(aLParam);
        G4int dx = x - This->fMousePressedX;
        G4int dy = y - This->fMousePressedY;
        This->fMousePressedX = x;
        This->fMousePressedY = y;
 
        if (aWParam == MK_LBUTTON) {  // Rotation
          This->SetRotation(dx, dy);
        }
 
        if (aWParam == MK_RBUTTON) {  // Shift
          This->SetShift(dx, dy);
        }
 
        This->SetView();
        This->ClearView();
        This->DrawView();
      }
 
      return 0;
    }
 
    case WM_MOUSEWHEEL: {
      auto* This = (G4OpenGLWin32Viewer*)
                   ::GetWindowLongPtr(aWindow, GWLP_USERDATA);
 
      G4int delta = (short) HIWORD(aWParam);
 
      This->SetZoom(delta);
 
      This->SetView();
      This->ClearView();
      This->DrawView();
      return 0;
    }
 
    default:
      return DefWindowProc(aWindow, aMessage, aWParam, aLParam);
  }
//  return DefWindowProc(aWindow,aMessage,aWParam,aLParam);
}

References ps.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow().

Field Documentation

◆ antialiasing_enabled

G4bool G4OpenGLViewer::antialiasing_enabled

protectedinherited

Definition at line 201 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::antialias_callback(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), and G4OpenGLQtViewer::toggleAntialiasing().

◆ background

G4Colour G4OpenGLViewer::background

protectedinherited

Definition at line 198 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::ClearViewWithoutFlush(), G4OpenGLXmViewer::CreateMainWindow(), and G4OpenGLViewer::SetView().

◆ fDefaultExportFilename

G4String G4OpenGLViewer::fDefaultExportFilename

privateinherited

Definition at line 220 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::G4OpenGLViewer().

◆ fDefaultExportImageFormat

std::string G4OpenGLViewer::fDefaultExportImageFormat

protectedinherited

Definition at line 210 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage().

◆ fDefaultVP

G4ViewParameters G4VViewer::fDefaultVP

protectedinherited

Definition at line 220 of file G4VViewer.hh.

Referenced by G4ASCIITreeViewer::G4ASCIITreeViewer(), G4HepRepFileViewer::G4HepRepFileViewer(), G4OpenGLStoredViewer::G4OpenGLStoredViewer(), G4OpenGLViewer::G4OpenGLViewer(), G4OpenInventorViewer::G4OpenInventorViewer(), G4VtkViewer::G4VtkViewer(), G4VViewer::G4VViewer(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), and G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise().

◆ fExportFilename

G4String G4OpenGLViewer::fExportFilename

privateinherited

Definition at line 219 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::G4OpenGLViewer(), G4OpenGLViewer::getRealPrintFilename(), and G4OpenGLViewer::setExportFilename().

◆ fExportFilenameIndex

int G4OpenGLViewer::fExportFilenameIndex

protectedinherited

Definition at line 212 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::exportImage(), G4OpenGLViewer::exportImage(), G4OpenGLViewer::getRealPrintFilename(), G4OpenGLViewer::setExportFilename(), and G4OpenGLViewer::setExportImageFormat().

◆ fExportImageFormat

std::string G4OpenGLViewer::fExportImageFormat

protectedinherited

Definition at line 211 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLViewer::exportImage(), G4OpenGLViewer::getRealPrintFilename(), and G4OpenGLViewer::setExportImageFormat().

◆ fExportImageFormatVector

std::vector< std::string > G4OpenGLViewer::fExportImageFormatVector

protectedinherited

Definition at line 209 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLViewer::addExportImageFormat(), and G4OpenGLViewer::setExportImageFormat().

◆ fGL2PSAction

G4OpenGL2PSAction* G4OpenGLViewer::fGL2PSAction

protectedinherited

Definition at line 203 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::ChangeLineWidth(), G4OpenGLViewer::ChangePointSize(), G4OpenGLViewer::exportImage(), G4OpenGLViewer::G4OpenGLViewer(), G4OpenGLViewer::isGl2psWriting(), G4OpenGLViewer::printGl2PS(), and G4OpenGLViewer::~G4OpenGLViewer().

◆ fGl2psDefaultLineWith

int G4OpenGLViewer::fGl2psDefaultLineWith

privateinherited

Definition at line 222 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::printGl2PS().

◆ fGl2psDefaultPointSize

int G4OpenGLViewer::fGl2psDefaultPointSize

privateinherited

Definition at line 223 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::printGl2PS().

◆ fGlViewInitialized

bool G4OpenGLViewer::fGlViewInitialized

privateinherited

Definition at line 224 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::InitializeGLView().

◆ fHDC

HDC G4OpenGLWin32Viewer::fHDC

protectedinherited

Definition at line 53 of file G4OpenGLWin32Viewer.hh.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), FinishView(), G4OpenGLStoredWin32Viewer::FinishView(), G4OpenGLWin32Viewer::SetView(), G4OpenGLWin32Viewer::ShowView(), and G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer().

◆ fHGLRC

HGLRC G4OpenGLWin32Viewer::fHGLRC

privateinherited

Definition at line 70 of file G4OpenGLWin32Viewer.hh.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLWin32Viewer::SetView(), and G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer().

◆ fInCreateWindow

G4bool G4OpenGLWin32Viewer::fInCreateWindow

privateinherited

Definition at line 71 of file G4OpenGLWin32Viewer.hh.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow().

◆ fIsGettingPickInfos

bool G4OpenGLViewer::fIsGettingPickInfos

privateinherited

Definition at line 241 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::GetPickDetails(), and G4OpenGLViewer::SetView().

◆ fMouseHovered

G4bool G4OpenGLWin32Viewer::fMouseHovered

protectedinherited

Definition at line 55 of file G4OpenGLWin32Viewer.hh.

◆ fMousePressed

G4bool G4OpenGLWin32Viewer::fMousePressed

protectedinherited

Definition at line 56 of file G4OpenGLWin32Viewer.hh.

Referenced by G4OpenGLWin32Viewer::ReleaseMouse(), and G4OpenGLWin32Viewer::TrackMouse().

◆ fMousePressedX

G4int G4OpenGLWin32Viewer::fMousePressedX

protectedinherited

Definition at line 57 of file G4OpenGLWin32Viewer.hh.

Referenced by G4OpenGLWin32Viewer::ReleaseMouse(), and G4OpenGLWin32Viewer::TrackMouse().

◆ fMousePressedY

G4int G4OpenGLWin32Viewer::fMousePressedY

protectedinherited

Definition at line 57 of file G4OpenGLWin32Viewer.hh.

Referenced by G4OpenGLWin32Viewer::ReleaseMouse(), and G4OpenGLWin32Viewer::TrackMouse().

◆ fName

G4String G4VViewer::fName

protectedinherited

Definition at line 217 of file G4VViewer.hh.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLViewer::DrawText(), G4OpenGLXViewer::DrawText(), G4OpenInventorQtViewer::G4OpenInventorQtViewer(), G4OpenInventorWinViewer::G4OpenInventorWinViewer(), G4OpenInventorXtExtendedViewer::G4OpenInventorXtExtendedViewer(), G4OpenInventorXtViewer::G4OpenInventorXtViewer(), G4VViewer::G4VViewer(), G4OpenGLXmViewer::GetXmConnection(), G4OpenInventorQtViewer::Initialise(), G4OpenInventorWinViewer::Initialise(), G4OpenInventorXtExtendedViewer::Initialise(), G4OpenInventorXtViewer::Initialise(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), G4VViewer::SetName(), and G4Qt3DViewer::SetView().

◆ fNeedKernelVisit

G4bool G4VViewer::fNeedKernelVisit

protectedinherited

Definition at line 224 of file G4VViewer.hh.

Referenced by G4OpenGLStoredQtViewer::ComputeView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenInventorViewer::DrawView(), G4Qt3DViewer::DrawView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::DrawView(), G4VViewer::NeedKernelVisit(), and G4VViewer::ProcessView().

◆ fOpenGLSceneHandler

G4OpenGLSceneHandler& G4OpenGLViewer::fOpenGLSceneHandler

protectedinherited

Definition at line 197 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::GetPickDetails().

◆ fPan_sens

G4double G4OpenGLViewer::fPan_sens

protectedinherited

Definition at line 206 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLXmViewer::left_right_pan_callback(), G4OpenGLQtViewer::moveScene(), G4OpenGLViewer::ResetView(), G4OpenGLXmViewer::ResetView(), G4OpenGLXmViewer::set_pan_sens_callback(), G4OpenGLXmViewer::up_down_pan_callback(), and G4OpenGLXmViewer::UpdateControlPanel().

◆ fPointSize

G4float G4OpenGLViewer::fPointSize

privateinherited

Definition at line 218 of file G4OpenGLViewer.hh.

◆ fPrintColour

G4bool G4OpenGLViewer::fPrintColour

protectedinherited

Definition at line 194 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::misc_callback(), G4OpenGLViewer::printNonVectoredEPS(), G4OpenGLXmViewer::set_print_colour_callback(), and G4OpenGLXmViewer::set_print_style_callback().

◆ fPrintSizeX

G4int G4OpenGLViewer::fPrintSizeX

protectedinherited

Definition at line 213 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::getRealExportWidth(), and G4OpenGLViewer::setExportSize().

◆ fPrintSizeY

G4int G4OpenGLViewer::fPrintSizeY

protectedinherited

Definition at line 214 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::getRealExportHeight(), and G4OpenGLViewer::setExportSize().

◆ fRot_sens

G4double G4OpenGLViewer::fRot_sens

protectedinherited

Definition at line 205 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLQtViewer::G4keyPressEvent(), G4OpenGLViewer::ResetView(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4OpenGLXmViewer::set_rot_sens_callback(), and G4OpenGLXmViewer::UpdateControlPanel().

◆ fSceneHandler

G4VSceneHandler& G4VViewer::fSceneHandler

protectedinherited

Definition at line 215 of file G4VViewer.hh.

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4OpenGLQtViewer::addPVSceneTreeElement(), G4VtkViewer::ClearView(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLQtViewer::DrawText(), G4OpenGLViewer::DrawText(), G4OpenGLXViewer::DrawText(), G4VtkViewer::FinishView(), G4VViewer::G4VViewer(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4OpenGLImmediateQtViewer::initializeGL(), G4OpenGLStoredQtViewer::initializeGL(), G4OpenGLQtViewer::parseAndInsertInSceneTree(), G4OpenGLViewer::printGl2PS(), G4VViewer::ProcessView(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4VtkViewer::SetView(), G4VtkViewer::ShowView(), G4OpenGLQtViewer::updateViewerPropertiesTableWidget(), and G4VViewer::~G4VViewer().

◆ fShortName

G4String G4VViewer::fShortName

protectedinherited

Definition at line 218 of file G4VViewer.hh.

Referenced by G4RayTracerViewer::DrawView(), G4VViewer::G4VViewer(), and G4VViewer::SetName().

◆ fSizeHasChanged

G4bool G4OpenGLViewer::fSizeHasChanged

privateinherited

Definition at line 221 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::sizeHasChanged().

◆ fVectoredPs

G4bool G4OpenGLViewer::fVectoredPs

protectedinherited

Definition at line 195 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::actionSaveImage(), G4OpenGLViewer::exportImage(), G4OpenGLXmViewer::misc_callback(), G4OpenGLXmViewer::set_print_style_callback(), and G4OpenGLViewerMessenger::SetNewValue().

◆ fViewId

G4int G4VViewer::fViewId

protectedinherited

Definition at line 216 of file G4VViewer.hh.

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLXViewer::CreateGLXContext(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLImmediateQtViewer::G4OpenGLImmediateQtViewer(), G4OpenGLImmediateWin32Viewer(), G4OpenGLImmediateXmViewer::G4OpenGLImmediateXmViewer(), G4OpenGLImmediateXViewer::G4OpenGLImmediateXViewer(), G4OpenGLStoredQtViewer::G4OpenGLStoredQtViewer(), G4OpenGLStoredWin32Viewer::G4OpenGLStoredWin32Viewer(), G4OpenGLStoredXmViewer::G4OpenGLStoredXmViewer(), G4OpenGLStoredXViewer::G4OpenGLStoredXViewer(), G4OpenGLXmViewer::G4OpenGLXmViewer(), G4OpenGLXViewer::G4OpenGLXViewer(), G4RayTracerViewer::G4RayTracerViewer(), G4VViewer::G4VViewer(), G4OpenGLXViewer::GetXConnection(), G4OpenGLXmViewer::GetXmConnection(), G4Qt3DViewer::Initialise(), G4RayTracerXViewer::Initialise(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Initialise(), G4OpenGLXmViewer::misc_callback(), G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer(), and G4OpenGLXViewer::~G4OpenGLXViewer().

◆ fVP

G4ViewParameters G4VViewer::fVP

protectedinherited

Definition at line 219 of file G4VViewer.hh.

◆ fWindow

HWND G4OpenGLWin32Viewer::fWindow

privateinherited

Definition at line 69 of file G4OpenGLWin32Viewer.hh.

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), and G4OpenGLWin32Viewer::~G4OpenGLWin32Viewer().

◆ fWinSize_x

unsigned int G4OpenGLViewer::fWinSize_x

protectedinherited

Definition at line 207 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLViewer::getRealExportWidth(), G4OpenGLViewer::getWinWidth(), G4OpenGLViewer::InitializeGLView(), G4OpenGLViewer::printGl2PS(), G4OpenGLViewer::ResizeGLView(), G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::SetView().

◆ fWinSize_y

unsigned int G4OpenGLViewer::fWinSize_y

protectedinherited

Definition at line 208 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLViewer::getRealExportHeight(), G4OpenGLViewer::getWinHeight(), G4OpenGLViewer::InitializeGLView(), G4OpenGLViewer::printGl2PS(), G4OpenGLViewer::ResizeGLView(), G4OpenGLViewer::ResizeWindow(), and G4OpenGLViewer::SetView().

◆ haloing_enabled

G4bool G4OpenGLViewer::haloing_enabled

protectedinherited

Definition at line 202 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLImmediateQtViewer::ComputeView(), G4OpenGLStoredQtViewer::ComputeView(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenGLXmViewer::haloing_callback(), and G4OpenGLQtViewer::toggleHaloing().

◆ transparency_enabled

G4bool G4OpenGLViewer::transparency_enabled

protectedinherited

Definition at line 200 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLQtViewer::createPopupMenu(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLViewerMessenger::SetNewValue(), G4OpenGLQtViewer::toggleTransparency(), and G4OpenGLXmViewer::transparency_callback().

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

source/visualization/OpenGL/include/G4OpenGLImmediateWin32Viewer.hh
source/visualization/OpenGL/src/G4OpenGLImmediateWin32Viewer.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4OpenGLImmediateWin32Viewer()

Member Function Documentation

◆ addExportImageFormat()

◆ ChangeLineWidth()

◆ ChangePointSize()

◆ ClearView()

◆ ClearViewWithoutFlush()

◆ ComputeFlyThrough()

◆ CreateFontLists()

◆ CreateGLWin32Context()

◆ CreateMainWindow()

◆ DrawText()

◆ DrawView()

◆ exportImage()

◆ FinishView()

◆ g4GlFrustum()

◆ g4GlOrtho()

◆ g4GluLookAt()

◆ g4GluPickMatrix()

◆ GetApplicableVisAttributes()

◆ GetDefaultViewParameters()

◆ GetName()

◆ GetPickDetails()

◆ GetPrivateVisAttributesModifiers()

◆ getRealExportHeight()

◆ getRealExportWidth()

◆ getRealPrintFilename()

◆ getSceneDepth()

◆ getSceneFarWidth()

◆ GetSceneHandler()

◆ getSceneNearWidth()

◆ GetShortName()

◆ GetViewId()

◆ GetViewParameters()

◆ GetWin32Connection()

◆ getWinHeight()

◆ getWinWidth()

◆ grabPixels()

◆ HaloingFirstPass()

◆ HaloingSecondPass()

◆ HLRFirstPass()

◆ HLRSecondPass()

◆ HLRThirdPass()

◆ Initialise()

◆ InitializeGLView()

◆ isFramebufferReady()

◆ isGl2psWriting()

◆ NeedKernelVisit()

◆ Pick()

◆ printGl2PS()

◆ printNonVectoredEPS()

◆ printVectoredEPS()

◆ ProcessView() [1/2]

◆ ProcessView() [2/2]

◆ RefreshView()

◆ ReleaseMouse()

◆ ResetView()

◆ ResizeGLView()

◆ ResizeWindow()

◆ rotateScene()

◆ rotateSceneInViewDirection()

◆ rotateSceneThetaPhi()

◆ rotateSceneToggle()

◆ SetDefaultViewParameters()

◆ setExportFilename()

◆ setExportImageFormat()

◆ setExportSize()

◆ SetName()

◆ SetNeedKernelVisit()

◆ SetRotation()

◆ SetShift()

◆ SetTouchable()