Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file inheritance tree (.pdf)

Sections: class description function members data members class charts

class TGLRnrCtx

Function Members (Methods)

public:

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& insp) const
void	StartStopwatch()
void	StopStopwatch()
virtual void	Streamer(TBuffer&)
void	StreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
static const char*	StyleName(Short_t style)
	TGLRnrCtx(TGLViewerBase* viewer)
TGLClip*	ViewerClip() const
Short_t	ViewerLOD() const
Float_t	ViewerOLLineW() const
Short_t	ViewerStyle() const
Float_t	ViewerWFLineW() const

private:

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

Data Members

public:

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

protected:

TGLCamera*	fCamera
TGLClip*	fClip
TGLRnrCtx::lpTGLColorSet_t*	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 Chart:

TGLRnrCtx

Function documentation

const char* StyleName(Short_t style)

TGLRnrCtx(const TGLRnrCtx& )

TGLRnrCtx& operator=(const TGLRnrCtx& )

TGLRnrCtx(TGLViewerBase* viewer)

virtual ~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; }

TGLSceneBase * GetScene()

TGLSceneBase & RefScene()

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 IsDrawPassFilled() const

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 HasStopwatchTimedOut()

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; }

TGLRect * GetPickRectangle()

Int_t GetPickRadius()

TGLSelectBuffer * GetSelectBuffer() const

 Selection setup / end

{ return fSelectBuffer; }

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

void EndSelection(Int_t glResult)

void PushColorSet()

void PopColorSet()

TGLColorSet* ChangeBaseColorSet(TGLColorSet* set)

TGLColorSet* GetBaseColorSet()

void ColorOrForeground(Color_t col)

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; }

void OpenDLCapture()

void CloseDLCapture()

TGLContextIdentity* GetGLCtxIdentity() const

{ return fGLCtxIdentity; }

void SetGLCtxIdentity(TGLContextIdentity* cid)

{ fGLCtxIdentity = cid; }

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)

GLUquadric* GetGluQuadric()

void SetGrabImage(Bool_t gi)

 Picture grabbing

{ fGrabImage = gi; }

Bool_t GetGrabImage() const

{ return fGrabImage; }

void ProjectionMatrixPushIdentity()

 Matrix manipulation helpers

void ProjectionMatrixPop()