Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file source file viewVC header viewVC source

Sections: class description function members data members class charts

class TGLRnrCtx


 The TGLRnrCtx class aggregates data for a given redering context as
 needed by various parts of the ROOT's OpenGL infractructure. It
 serves as a connecting point between the steering part of the
 infrastructure (viewer, scene) and concrete rendering classes
 (logical, physical shape). It is just a data-holder, there is no
 functionality in it.

 Development notes:

 One RnrCtx is created by each viewer and it is just an extension of
 the viewer context that changes along the render
 descend. Separating this also has some abstract benefit of hiding
 viewer implementation from those that do not need to know it.

 Current scene / scene-info part is always initialized by viewer,
 scenes can assume they're ok.

Function Members (Methods)

public:

	TGLRnrCtx(TGLViewerBase* viewer)
virtual	~TGLRnrCtx()
void	BeginSelection(Int_t x, Int_t y, Int_t r = 3)
TGLColorSet*	ChangeBaseColorSet(TGLColorSet* set)
static TClass*	Class()
TGLClip*	Clip() const
void	CloseDLCapture()
void	ColorOrForeground(Color_t col)
TGLColorSet&	ColorSet()
Short_t	CombiLOD() const
Short_t	DrawPass() const
void	EndSelection(Int_t glResult)
TGLColorSet*	GetBaseColorSet()
TGLCamera*	GetCamera()
const TGLCamera*	GetCamera() const
UInt_t	GetEventKeySym() const
TGLContextIdentity*	GetGLCtxIdentity() const
GLUquadric*	GetGluQuadric()
Bool_t	GetGrabImage() const
Int_t	GetPickRadius()
TGLRect*	GetPickRectangle()
Float_t	GetRenderScale() const
TGLSceneBase*	GetScene()
TGLSceneInfo*	GetSceneInfo()
TGLSelectBuffer*	GetSelectBuffer() const
TGLViewerBase*	GetViewer()
Bool_t	HasClip() const
Bool_t	HasStopwatchTimedOut()
Bool_t	Highlight() const
Bool_t	HighlightOutline() const
virtual TClass*	IsA() const
Bool_t	IsDLCaptureOpen() const
Bool_t	IsDrawPassFilled() const
Bool_t	IsDrawPassOutlineLine() const
Bool_t	IsStopwatchRunning() const
void	OpenDLCapture()
void	PopColorSet()
void	ProjectionMatrixPop()
void	ProjectionMatrixPushIdentity()
void	PushColorSet()
TGLCamera&	RefCamera()
const TGLCamera&	RefCamera() const
TGLSceneBase&	RefScene()
TGLSceneInfo&	RefSceneInfo()
TGLViewerBase&	RefViewer()
void	RegisterFont(Int_t size, Int_t file, Int_t mode, TGLFont& out)
void	RegisterFont(Int_t size, const char* name, Int_t mode, TGLFont& out)
void	RegisterFontNoScale(Int_t size, Int_t file, Int_t mode, TGLFont& out)
void	RegisterFontNoScale(Int_t size, const char* name, Int_t mode, TGLFont& out)
void	ReleaseFont(TGLFont& font)
Double_t	RenderTimeOut() const
TGLClip*	SceneClip() const
Short_t	SceneLOD() const
Float_t	SceneOLLineW() const
Short_t	SceneStyle() const
Float_t	SceneWFLineW() const
Bool_t	SecSelection() const
Bool_t	Selection() const
Short_t	SelectTransparents() const
void	SetCamera(TGLCamera* c)
void	SetClip(TGLClip* p)
void	SetCombiLOD(Short_t LOD)
void	SetDrawPass(Short_t dpass)
void	SetEventKeySym(UInt_t k)
void	SetGLCtxIdentity(TGLContextIdentity* cid)
void	SetGrabImage(Bool_t gi)
void	SetHighlight(Bool_t hil)
void	SetHighlightOutline(Bool_t ho)
void	SetRenderScale(Float_t s)
void	SetRenderTimeOut(Double_t tout)
void	SetSceneClip(TGLClip* p)
void	SetSceneInfo(TGLSceneInfo* si)
void	SetSceneLOD(Short_t LOD)
void	SetSceneOLLineW(Float_t w)
void	SetSceneStyle(Short_t sty)
void	SetSceneWFLineW(Float_t w)
void	SetSecSelection(Bool_t secSel)
void	SetSelection(Bool_t sel)
void	SetSelectTransparents(Short_t st)
void	SetShapeLOD(Short_t LOD)
void	SetShapePixSize(Float_t ps)
void	SetViewerClip(TGLClip* p)
void	SetViewerLOD(Short_t LOD)
void	SetViewerOLLineW(Float_t w)
void	SetViewerStyle(Short_t sty)
void	SetViewerWFLineW(Float_t w)
Short_t	ShapeLOD() const
Float_t	ShapePixSize() const
virtual void	ShowMembers(TMemberInspector&)
void	StartStopwatch()
void	StopStopwatch()
virtual void	Streamer(TBuffer&)
void	StreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
static const char*	StyleName(Short_t style)
TGLClip*	ViewerClip() const
Short_t	ViewerLOD() const
Float_t	ViewerOLLineW() const
Short_t	ViewerStyle() const
Float_t	ViewerWFLineW() const

private:

	TGLRnrCtx(const TGLRnrCtx&)
TGLRnrCtx&	operator=(const TGLRnrCtx&)

Data Members

public:

enum EStyle {	kStyleUndef
	kFill
	kOutline
	kWireFrame
};
enum EPass {	kPassUndef
	kPassFill
	kPassOutlineFill
	kPassOutlineLine
	kPassWireFrame
};
enum ELODPresets {	kLODUndef
	kLODPixel
	kLODLow
	kLODMed
	kLODHigh
};
enum EShapeSelectionLevel {	kSSLNotSelected
	kSSLSelected
	kSSLImpliedSelected
	kSSLHighlighted
	kSSLImpliedHighlighted
	kSSLEnd
};
enum ESelectabilityOfTransparents {	kIfNoOpaques
	kIfClosest
	kNever
};

protected:

TGLCamera*	fCamera
TGLClip*	fClip
list<TGLColorSet,allocator<TGLColorSet> >*	fColorSetStack
Short_t	fCombiLOD	Combined viewer/scene lod.
Bool_t	fDLCaptureOpen	! DL-capture currently open
Short_t	fDrawPass
UInt_t	fEventKeySym
TGLContextIdentity*	fGLCtxIdentity	! Current GL context identity
Int_t	fGrabBuffer	Which buffer to grab after render.
Bool_t	fGrabImage	Set to true to store the image.
UChar_t*	fGrabbedImage	Buffer where image was stored after rendering.
Bool_t	fHasTimedOut
Bool_t	fHighlight	True when in highlight.
Bool_t	fHighlightOutline	True when in highlight-outline.
Bool_t	fIsRunning
Int_t	fPickRadius
TGLRect*	fPickRectangle
GLUquadric*	fQuadric
Float_t	fRenderScale
Double_t	fRenderTimeOut
TGLClip*	fSceneClip
TGLSceneInfo*	fSceneInfo
Short_t	fSceneLOD
Float_t	fSceneOLLineW
Short_t	fSceneStyle
Float_t	fSceneWFLineW
Bool_t	fSecSelection	True when in secondary selection.
TGLSelectBuffer*	fSelectBuffer
Short_t	fSelectTransparents
Bool_t	fSelection	True when in selection.
Short_t	fShapeLOD	LOD calculated for current shape.
Float_t	fShapePixSize	Only relevant when not using display lists.
TGLStopwatch	fStopwatch
TGLViewerBase*	fViewer
TGLClip*	fViewerClip
Short_t	fViewerLOD
Float_t	fViewerOLLineW
Short_t	fViewerStyle
Float_t	fViewerWFLineW

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

TGLRnrCtx(TGLViewerBase* viewer)

 Constructor.

~TGLRnrCtx()

 Destructor.

TGLSceneBase * GetScene()

 Return current scene (based on scene-info data).

TGLSceneBase & RefScene()

 Return current scene (based on scene-info data).

Bool_t IsDrawPassFilled() const

 Returns true if current render-pass uses filled polygon style.

Bool_t HasStopwatchTimedOut()

 Check if the stopwatch went beyond the render time limit.

void BeginSelection(Int_t x, Int_t y, Int_t r = 3)

 Setup context for running selection.
 x and y are in window coordinates.

void EndSelection(Int_t glResult)

 End selection.

TGLRect * GetPickRectangle()

 Return current pick rectangle. This is *zero* when
 selection is not set.

Int_t GetPickRadius()

 Return pick radius. If selection is not active it returns 0.

void PushColorSet()

 Create copy of current color-set on the top of the stack.

TGLColorSet& ColorSet()

 Return reference to current color-set (top of hte stack).

void PopColorSet()

 Pops the top-most color-set.
 If only one entry is available, error is printed and the entry remains.

TGLColorSet* ChangeBaseColorSet(TGLColorSet* set)

 Change the default/bottom color-set.
 Returns the previous color-set.

TGLColorSet* GetBaseColorSet()

 Returns the current base color-set.

void ColorOrForeground(Color_t col)

 Set col if it is different from background, otherwise use
 current foreground color.

void OpenDLCapture()

 Start display-list capture.

void CloseDLCapture()

 End display list capture.

void ReleaseFont(TGLFont& font)

 Release font in the GL rendering context.

void RegisterFontNoScale(Int_t size, Int_t file, Int_t mode, TGLFont& out)

 Get font in the GL rendering context.

void RegisterFontNoScale(Int_t size, const char* name, Int_t mode, TGLFont& out)

 Get font in the GL rendering context.

void RegisterFont(Int_t size, Int_t file, Int_t mode, TGLFont& out)

 Get font in the GL rendering context.
 The font is scaled relative to current render scale.

void RegisterFont(Int_t size, const char* name, Int_t mode, TGLFont& out)

 Get font in the GL rendering context.
 The font is scaled relative to current render scale.

GLUquadric * GetGluQuadric()

 Initialize fQuadric.

void ProjectionMatrixPushIdentity()

void ProjectionMatrixPop()

const char* StyleName(Short_t style)

 Return string describing the style.

TGLRnrCtx(const TGLRnrCtx& )

TGLRnrCtx& operator=(const TGLRnrCtx& )

TGLViewerBase * GetViewer()

 Central objects

{ return fViewer; }

TGLViewerBase & RefViewer()

{ return *fViewer; }

TGLCamera * GetCamera()

{ return fCamera; }

TGLCamera & RefCamera()

{ return *fCamera; }

TGLSceneInfo * GetSceneInfo()

{ return fSceneInfo; }

TGLSceneInfo & RefSceneInfo()

{ return *fSceneInfo; }

const TGLCamera & RefCamera() const

{ return *fCamera; }

const TGLCamera * GetCamera() const

{ return fCamera; }

void SetCamera(TGLCamera* c)

 void SetViewer   (TGLViewerBase* v) { fViewer = v; }

{ fCamera = c; }

void SetSceneInfo(TGLSceneInfo* si)

{ fSceneInfo = si; }

Short_t ViewerLOD() const

 Draw LOD, style, clip, rnr-pass

{ return fViewerLOD; }

void SetViewerLOD(Short_t LOD)

{ fViewerLOD = LOD; }

Short_t SceneLOD() const

{ return fSceneLOD; }

void SetSceneLOD(Short_t LOD)

{ fSceneLOD = LOD; }

Short_t CombiLOD() const

{ return fCombiLOD; }

void SetCombiLOD(Short_t LOD)

{ fCombiLOD = LOD; }

Short_t ShapeLOD() const

{ return fShapeLOD; }

void SetShapeLOD(Short_t LOD)

{ fShapeLOD = LOD; }

Float_t ShapePixSize() const

{ return fShapePixSize; }

void SetShapePixSize(Float_t ps)

{ fShapePixSize = ps; }

Short_t ViewerStyle() const

{ return fViewerStyle; }

void SetViewerStyle(Short_t sty)

{ fViewerStyle = sty; }

Short_t SceneStyle() const

{ return fSceneStyle; }

void SetSceneStyle(Short_t sty)

{ fSceneStyle = sty; }

Float_t ViewerWFLineW() const

{ return fViewerWFLineW; }

void SetViewerWFLineW(Float_t w)

{ fViewerWFLineW = w; }

Float_t SceneWFLineW() const

{ return fSceneWFLineW; }

void SetSceneWFLineW(Float_t w)

{ fSceneWFLineW = w; }

Float_t ViewerOLLineW() const

{ return fViewerOLLineW; }

void SetViewerOLLineW(Float_t w)

{ fViewerOLLineW = w; }

Float_t SceneOLLineW() const

{ return fSceneOLLineW; }

void SetSceneOLLineW(Float_t w)

{ fSceneOLLineW = w; }

TGLClip* ViewerClip() const

{ return fViewerClip; }

void SetViewerClip(TGLClip* p)

{ fViewerClip = p; }

TGLClip* SceneClip() const

{ return fSceneClip; }

void SetSceneClip(TGLClip* p)

{ fSceneClip = p; }

void SetClip(TGLClip* p)

{ fClip = p; }

Bool_t HasClip() const

{ return fClip != 0; }

Short_t DrawPass() const

{ return fDrawPass; }

void SetDrawPass(Short_t dpass)

{ fDrawPass = dpass; }

Bool_t IsDrawPassOutlineLine() const

{ return fDrawPass == kPassOutlineLine; }

Double_t RenderTimeOut() const

 Render time-out

{ return fRenderTimeOut; }

void SetRenderTimeOut(Double_t tout)

{ fRenderTimeOut = tout; }

void StartStopwatch()

void StopStopwatch()

Bool_t IsStopwatchRunning() const

{ return fIsRunning; }

Bool_t Highlight() const

 Highlight / Selection state during rendering

{ return fHighlight; }

void SetHighlight(Bool_t hil)

{ fHighlight = hil; }

Bool_t HighlightOutline() const

{ return fHighlightOutline; }

void SetHighlightOutline(Bool_t ho)

{ fHighlightOutline = ho; }

Bool_t Selection() const

{ return fSelection; }

void SetSelection(Bool_t sel)

{ fSelection = sel; }

Bool_t SecSelection() const

{ return fSecSelection; }

void SetSecSelection(Bool_t secSel)

 Highlight / selection parameters

{ fSecSelection = secSel; }

Short_t SelectTransparents() const

{ return fSelectTransparents; }

void SetSelectTransparents(Short_t st)

{ fSelectTransparents = st; }

TGLSelectBuffer * GetSelectBuffer() const

 Selection setup / end

{ return fSelectBuffer; }

Float_t GetRenderScale() const

{ return fRenderScale; }

void SetRenderScale(Float_t s)

{ fRenderScale = s; }

UInt_t GetEventKeySym() const

{ return fEventKeySym; }

void SetEventKeySym(UInt_t k)

{ fEventKeySym = k; }

Bool_t IsDLCaptureOpen() const

{ return fDLCaptureOpen; }

TGLContextIdentity* GetGLCtxIdentity() const

{ return fGLCtxIdentity; }

void SetGLCtxIdentity(TGLContextIdentity* cid)

{ fGLCtxIdentity = cid; }

void SetGrabImage(Bool_t gi)

 Picture grabbing

{ fGrabImage = gi; }

Bool_t GetGrabImage() const

{ return fGrabImage; }