TGLScene

Class Description

                                                                      
 TGLScene                                                             
                                                                      
 A GL scene is the container for all the viewable objects (shapes)    
 loaded into the viewer. It consists of two main stl::maps containing 
 the TGLLogicalShape and TGLPhysicalShape collections, and interface  
 functions enabling viewers to manage objects in these. The physical  
 shapes defined the placement of copies of the logical shapes - see   
 TGLLogicalShape/TGLPhysicalShape for more information on relationship
                                                                      
 The scene can be drawn by owning viewer, passing camera, draw style  
 & quality (LOD), clipping etc - see Draw(). The scene can also be    
 drawn for selection in similar fashion - see Select(). The scene     
 keeps track of a single selected physical - which can be modified by 
 viewers.                                                             
                                                                      
 The scene maintains a lazy calculated bounding box for the total     
 scene extents, axis aligned round TGLPhysicalShape shapes.           
                                                                      
 Currently a scene is owned exclusively by one viewer - however it is 
 intended that it could easily be shared by multiple viewers - for    
 efficiency and syncronisation reasons. Hence viewer variant objects  
 camera, clips etc being owned by viewer and passed at draw/select

void AdoptLogical(TGLLogicalShape & shape)

 Adopt dynamically created logical 'shape' - add to internal map and take
 responsibility for deleting

Bool_t DestroyLogical(ULong_t ID)

 Zero ID logical shapes are not unique - this simple means the external object
 does not exist - should never be asked to destroy these singularly

TGLLogicalShape * FindLogical(ULong_t ID)

 Zero ID logical shapes are not unique - this simple means the external object
 does not exist - should never be asked to seach for this

void AdoptPhysical(TGLPhysicalShape & shape)

 Adopt dynamically created physical 'shape' - add to internal map and take
 responsibility for deleting

TGLLogicalShape * FindLogicalSmartRefresh(ULong_t ID)

 Find and return logical shape identified by unqiue 'ID' in refresh-cache.
 Returns 0 if not found.

void Draw(const TGLCamera & camera, TGLDrawFlags sceneFlags, Double_t timeout, Int_t axesType, const TGLVertex3 * reference, Bool_t forSelect)

 Draw out scene into current GL context, using passed arguments:

 'camera' - used for for object culling, manip scalling
 'sceneFlags'  - draw flags for scene - see TGLDrawFlags
 'timeout'- timeout for scene draw (in milliseconds) - if 0.0 unlimited
 'axesType' - axis style - one of TGLViewer::EAxesType
 'reference' - position of reference marker (or none if null)
 'forSelect' - is draw for select? If kTRUE clip and manip objects (which
            cannot be selected) are not drawn

void DrawPass(const TGLCamera & camera, const TGLDrawFlags & sceneFlags, Double_t timeout, const std::vector<TGLPlane> * clipPlanes)

 Perform a internal draw pass - multiple passes are required for some
 clip shapes

void SortDrawList()

 Sort the TGLPhysical draw list by shape bounding box volume, from
 large to small. This makes dropout of shapes with time limited
 Draw() calls must less noticable. As this does not use projected
 size it only needs to be done after a scene content change - not
 everytime scene drawn (potential camera/projection change).

Bool_t ComparePhysicalVolumes(const TGLPhysicalShape * shape1, const TGLPhysicalShape * shape2)

 Compare 'shape1' and 'shape2' bounding box volumes - return kTRUE if
 'shape1' bigger than 'shape2'

void DrawGuides(const TGLCamera & camera, Int_t axesType, const TGLVertex3 * reference)

 Draw out scene guides - axes and reference marker

 'camera'    - current active camera - required for calculating projection size
 'axesType'  - kAxesNone, kAxesOrigin (run through origin), kAxesEdge (at scene box edge)
 'reference' - if not null, draw orange reference sphere at vertex

Bool_t Select(const TGLCamera & camera, const TGLDrawFlags & sceneFlags)

 Perform select draw using arguments:

 'camera' - used for for object culling
 'style'  - draw style kFill (filled polygons) kOutline (polygons + outlines)
            kWireFrame

 Arguments are passed on to Draw(), with unlimted time

 Returns kTRUE if selection changed, kFALSE if not

Bool_t SetSelectedColor(const Float_t color[17])

 Set full color attributes on current selected physical shape:

 0...3  - diffuse
 4...7  - ambient
 8...11 - specular
 12..15 - emission
 16     - shininess

 see OpenGL documentation for details of materials

Bool_t SetColorOnSelectedFamily(const Float_t color[17])

 Set full color attributes on all physical shapes sharing the same
 logical shape as the selected physical

 0...3  - diffuse
 4...7  - ambient
 8...11 - specular
 12..15 - emission
 16     - shininess

 see OpenGL documentation for details of materials

Bool_t SetSelectedGeom(const TGLVertex3 & trans, const TGLVector3 & scale)

 Update geometry of the selected physical. 'trans' and 'scale' specify the
 translation and scaling components of the physical shapes translation matrix
 See TGLMatrix for more details

void GetClipState(EClipType type, Double_t data[6])

 Get state of clip object 'type' into data vector:

 'type' requested        'data' contents returned
 kClipPlane              4 components - A,B,C,D - of plane eq : Ax+By+CZ+D = 0
 kBoxPlane               6 components - Box Center X/Y/Z - Box Extents X/Y/Z

void SetClipState(EClipType type, const Double_t data[6])

 Set state of clip object 'type' into data vector:

 'type' specified        'data' contents interpretation
 kClipNone               ignored
 kClipPlane              4 components - A,B,C,D - of plane eq : Ax+By+CZ+D = 0
 kBoxPlane               6 components - Box Center X/Y/Z - Box Extents X/Y/Z

void SetCurrentClip(EClipType type, Bool_t edit)

 Set current clip active in viewer - 'type' is one of kClipNone
 kClipPlane or kClipBox. 'edit' indicates if clip object should
 been shown/edited directly in viewer (current manipulator attached to it)
 kTRUE if so (ignored for kClipNone), kFALSE otherwise

const TGLBoundingBox & BoundingBox()

 Update (if required) and return the scene bounding box
 Encapsulates all physical shapes bounding box with axes aligned box

UInt_t SizeOf()

 Return memory cost of scene
 Warning: NOT CORRECT at present - doesn't correctly calculate size
 of logical shapes with dynamic internal contents

TGLScene

class TGLScene

Data Members

Class Description