The world class. The interface to OpenGL/GLUT.

Only _one_ cWorld object may be active at once. This object _has_ to be the root of the scene graph.

Source:

../src/cWorld.hh:44

public cWorld ( cEventDispatcher * disp ,
                const char * name = NULL ) ;

default constructor w/ optional name

public cWorld ( const cWorld & ) ;

copy constructor

public virtual ~ cWorld ( ) ;

destructor

public virtual int Init ( int * argc ,
                          char * * argv ) ;

initialize world (and OpenGL window using GLUT)

public virtual int Init ( int * argc ,
                          char * * argv ,
                          unsigned int glut_display_mode ,
                          int default_width = - 1 ,
                          int default_height = - 1 ,
                          int default_pos_x = - 1 ,
                          int default_pos_y = - 1 ) ;

Initialize world and OpenGL window using GLUT and providing several defaults

If you provide one of default_width or default_height you have to provide the "opposite" as well. The same rule applies to default_pos_x and default_pos_y.

public virtual void ReshapeDisplay ( int width ,
                                     int height ) ;

set new window dimensions

public virtual void Draw ( ) ;

start drawing the whole world (wrapper for Activate())

note: this is called by GLUTDisplayCB, there should be no need to call it from somewhere else!

public virtual void SceneGraphToMenu ( int menu ) ;

make scene graph visible via menu

public virtual void SetWorkingMenu ( int id ) ;

set current menu where entries are added to

public virtual int GetWorkingMenu ( ) ;

get current menu where entries are added to

Return:

id number of active menu

public virtual int AddMenuEntry ( const char * entry ,
                                  const cEvent & event ) ;

add menu entry to actual menu

Return:

id of menu entry for later reference

public virtual int AddSubMenu ( const char * name ) ;

add sub menu to actual menu

Return:

id of sub menu entry for later reference

public virtual void AttachMenu ( int button ) ;

attach menu to given mouse button

public int SetCamera ( const cVertex & pos ,
                       const cVertex & lookat ,
                       const cVertex & up ) ;

set up camera

Return:

-1 on error, 0 on success

public int MoveCameraTo ( const cVertex & pos ) ;

move camera to a give point without changing LookAt, but probably with changing UpVector

Return:

-1 on error, 0 on success

public int MoveCameraBy ( const cVertex & dif ) ;

move camera by a given amount without changing LookAt

Return:

-1 on error, 0 on success

public void MoveCameraAndLookatBy ( const cVertex & dif ) ;

for "walk" navigation

public void PanCamera ( GLfloat x ,
                        GLfloat y ) ;

for "walk" navigation: look around

public void OrbitCamera ( GLfloat x ,
                          GLfloat y ) ;

for "orbit navigation": orbit around look-at

public void MoveLookAtBy ( const cVertex & dif ) ;

for "orbit navigation": move orbit center = look-at

public unsigned int GetDisplayWidth ( ) ;

query width of display

Return:

width of viewing window

public unsigned int GetDisplayHeight ( ) ;

query height of display

Return:

height of viewing window

public int SetPerspectiveProjection ( GLdouble fovy ,
                                      GLdouble near ,
                                      GLdouble far ) ;

activate pespective projection

Return:

-1 on error (invalid values), 0 on success

public int SetOrthoProjection ( GLdouble fovy ,
                                GLdouble near ,
                                GLdouble far ) ;

activate orthogonal projection

Return:

0 (always succeeds)

public int ActivateMenuEntry ( int id ) ;

trigger event bound to given menu id

this is basically an internal function, but can be called from outside without any risk

Return:

-1 if invalid ID was given

public void EnableAnimation ( ) ;

start animation

public void SetAnimationSpeed ( int speed ) ;

set or change animation speed

public void DisableAnimation ( ) ;

stop animation

public virtual int ReceiveEvent ( const cEvent & event ) ;

event receiver

public void Animate ( int value ) ;

broadcast animation event, re-register timer callback if animation still activated

Should not be called by user.

protected virtual void Activate ( ) ;

set up for drawing

protected virtual void Deactivate ( ) ;

clean up after drawing the world

protected virtual const char * GetDefaultName ( ) const ;

return name of class (for poor RTTI and as fallback for GetName)