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 TGLPhysicalShape


 Concrete physical shape - a GL drawable. Physical shapes are the
 objects the user can actually see, select, move in the viewer. It is
 a placement of the associated local frame TGLLogicaShape into the
 world frame. The draw process is:

 Load attributes - material colors etc
 Load translation matrix - placement
 Load gl name (for selection)
 Call our associated logical shape Draw() to draw placed shape

 The physical shape supports translation, scaling and rotation,
 selection, color changes, and permitted modification flags etc.
 A physical shape cannot modify or be bound to another (or no)
 logical shape - hence const & handle. It can perform mutable
 reference counting on the logical to enable purging.

 Physical shape also maintains a list of references to it and
 provides notifications of change and destruction.
 See class TGLPShapeRef which needs to be sub-classes for real use.

 See base/src/TVirtualViewer3D for description of common external 3D
 viewer architecture and how external viewer clients use it.

Function Members (Methods)

public:

virtual	~TGLPhysicalShape()
void	AddReference(TGLPShapeRef* ref)
const TGLBoundingBox&	BoundingBox() const
virtual void	CalculateShapeLOD(TGLRnrCtx& rnrCtx, Float_t& pixSize, Short_t& shapeLOD) const
static TClass*	Class()
const Float_t*	Color() const
virtual void	Draw(TGLRnrCtx& rnrCtx) const
const TGLLogicalShape*	GetLogical() const
TGLPhysicalShape::EManip	GetManip() const
const TGLPhysicalShape*	GetNextPhysical() const
TGLVector3	GetScale() const
UChar_t	GetSelected() const
TGLVertex3	GetTranslation() const
UInt_t	ID() const
void	InvokeContextMenu(TContextMenu& menu, UInt_t x, UInt_t y) const
virtual TClass*	IsA() const
Bool_t	IsInvisible() const
Bool_t	IsModified() const
Bool_t	IsSelected() const
Bool_t	IsTransparent() const
void	Modified()
virtual void	QuantizeShapeLOD(Short_t shapeLOD, Short_t combiLOD, Short_t& quantLOD) const
void	RemoveReference(TGLPShapeRef* ref)
void	Rotate(const TGLVertex3& pivot, const TGLVector3& axis, Double_t angle)
void	Scale(const TGLVector3& scale)
void	Select(UChar_t select)
void	SetColor(const Float_t[17] rgba)
void	SetColorOnFamily(const Float_t[17] rgba)
void	SetDiffuseColor(const Float_t[4] rgba)
void	SetDiffuseColor(const UChar_t[4] rgba)
void	SetDiffuseColor(Color_t ci, UChar_t transparency)
void	SetManip(TGLPhysicalShape::EManip manip)
void	SetTransform(const TGLMatrix& transform)
void	SetTransform(const Double_t[16] vals)
void	SetTranslation(const TGLVertex3& translation)
void	SetupGLColors(TGLRnrCtx& rnrCtx, const Float_t* color = 0) const
virtual void	ShowMembers(TMemberInspector& insp) const
virtual void	Streamer(TBuffer&)
void	StreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
	TGLPhysicalShape(UInt_t ID, const TGLLogicalShape& logicalShape, const TGLMatrix& transform, Bool_t invertedWind, const Float_t[4] rgba)
	TGLPhysicalShape(UInt_t ID, const TGLLogicalShape& logicalShape, const double* transform, Bool_t invertedWind, const Float_t[4] rgba)
void	Translate(const TGLVector3& vect)

private:

void	InitColor(const Float_t[4] rgba)
TGLPhysicalShape&	operator=(const TGLPhysicalShape&)
	TGLPhysicalShape(const TGLPhysicalShape&)
void	UpdateBoundingBox()

Data Members

public:

static TGLPhysicalShape::EManip	kManipAll
static TGLPhysicalShape::EManip	kRotateAll
static TGLPhysicalShape::EManip	kRotateX
static TGLPhysicalShape::EManip	kRotateY
static TGLPhysicalShape::EManip	kRotateZ
static TGLPhysicalShape::EManip	kScaleAll
static TGLPhysicalShape::EManip	kScaleX
static TGLPhysicalShape::EManip	kScaleY
static TGLPhysicalShape::EManip	kScaleZ
static TGLPhysicalShape::EManip	kTranslateAll
static TGLPhysicalShape::EManip	kTranslateX
static TGLPhysicalShape::EManip	kTranslateY
static TGLPhysicalShape::EManip	kTranslateZ

private:

TGLBoundingBox	fBoundingBox	! bounding box of the physical (transformed)
Float_t	fColor[17]	! GL color array
TGLPShapeRef*	fFirstPSRef	! pointer to first reference
UInt_t	fID	! unique physical ID within containing scene
Bool_t	fInvertedWind	! face winding TODO: can get directly from fTransform?
Bool_t	fIsScaleForRnr	! cache
const TGLLogicalShape*	fLogicalShape	! the associated logical shape
TGLPhysicalShape::EManip	fManip	! permitted manipulation bitflags - see EManip
Bool_t	fModified	! has been modified - retain across scene rebuilds
TGLPhysicalShape*	fNextPhysical	! pointer to next replica
UChar_t	fSelected	! selected state
TGLMatrix	fTransform	! transform (placement) of physical instance

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

TGLPhysicalShape(UInt_t ID, const TGLLogicalShape& logicalShape, const TGLMatrix& transform, Bool_t invertedWind, const Float_t[4] rgba)

 Construct a physical shape using arguments:
    ID             - unique drawable id.
    logicalShape   - bound logical shape
    transform      - transform for placement of logical drawing
    invertedWind   - use inverted face polygon winding?
    rgba           - basic four component (RGBA) diffuse color

TGLPhysicalShape(UInt_t ID, const TGLLogicalShape& logicalShape, const double* transform, Bool_t invertedWind, const Float_t[4] rgba)

 Construct a physical shape using arguments:
    id             - unique drawable id.
    logicalShape   - bound logical shape
    transform      - 16 Double_t component transform for placement of logical drawing
    invertedWind   - use inverted face polygon winding?
    rgba           - basic four component (RGBA) diffuse color

~TGLPhysicalShape()

 Destroy the physical shape.

void AddReference(TGLPShapeRef* ref)

 Add reference ref.

void RemoveReference(TGLPShapeRef* ref)

 Remove reference ref.

void Modified()

 Call this after modifying the physical so that the information
 can be propagated to the object referencing it.

void UpdateBoundingBox()

 Update our internal bounding box (in global frame).

void InitColor(const Float_t[4] rgba)

 Initialise the colors, using basic RGBA diffuse material color supplied

void SetColor(const Float_t[17] rgba)

 Set full color attributes - see OpenGL material documentation
 for full description.
 0->3 diffuse, 4->7 ambient, 8->11 specular, 12->15 emission, 16 shininess

void SetColorOnFamily(const Float_t[17] rgba)

 Set full color attributes to all physicals sharing the same
 logical with this object.

void SetDiffuseColor(const Float_t rgba[4])

 Set color from ROOT color index and transparency [0,100].

void SetDiffuseColor(const UChar_t rgba[4])

 Set color from RGBA quadruplet.

void SetDiffuseColor(Color_t ci, UChar_t transparency)

 Set color from standard ROOT representation, that is color index
 + transparency in range [0, 100].

void SetupGLColors(TGLRnrCtx& rnrCtx, const Float_t* color = 0) const

 Setup colors - avoid setting things not required
 for current draw flags.

void Draw(TGLRnrCtx& rnrCtx) const

 Draw physical shape, using LOD flags, potential from display list cache

void CalculateShapeLOD(TGLRnrCtx& rnrCtx, Float_t& pixSize, Short_t& shapeLOD) const

 Calculate shape-lod, suitible for use under
 projection defined by 'rnrCtx', taking account of which local
 axes of the shape support LOD adjustment, and the global
 'sceneFlags' passed.

 Returned shapeLOD component is from 0 (kLODPixel - lowest
 quality) to 100 (kLODHigh - highest quality).

 Scene flags are not used. LOD quantization is not done.  RnrCtx
 is not modified as this is called via lodification stage of
 rendering.

void QuantizeShapeLOD(Short_t shapeLOD, Short_t combiLOD, Short_t& quantLOD) const

 Factor in scene/vierer LOD and Quantize ... forward to
 logical shape.

void InvokeContextMenu(TContextMenu& menu, UInt_t x, UInt_t y) const

 Request creation of context menu on shape, attached to 'menu' at screen position
 'x' 'y'

TGLVector3 GetScale() const

TGLVertex3 GetTranslation() const

void SetTransform(const TGLMatrix& transform)

void SetTransform(const Double_t[16] vals)

void SetTranslation(const TGLVertex3& translation)

void Translate(const TGLVector3& vect)

void Scale(const TGLVector3& scale)

void Rotate(const TGLVertex3& pivot, const TGLVector3& axis, Double_t angle)

TGLPhysicalShape(const TGLPhysicalShape& )

TGLPhysicalShape& operator=(const TGLPhysicalShape& )

UInt_t ID() const

{ return fID; }

const TGLLogicalShape * GetLogical() const

{ return fLogicalShape; }

const TGLPhysicalShape * GetNextPhysical() const

{ return fNextPhysical; }

EManip GetManip() const

 Modification and manipulation

{ return fManip; }

void SetManip(TGLPhysicalShape::EManip manip)

{ fManip = manip; }

Bool_t IsModified() const

{ return fModified; }

Bool_t IsSelected() const

 Selection

{ return fSelected != 0; }

UChar_t GetSelected() const

{ return fSelected; }

void Select(UChar_t select)

{ fSelected = select; }

const Float_t * Color() const

 Color

{ return fColor; }

Bool_t IsTransparent() const

{ return fColor[3] < 1.f; }

Bool_t IsInvisible() const

{ return fColor[3] == 0.f; }