---

glvu.hpp

//============================================================================
// glvu.hpp : OpenGL/GLUT -based viewer
//============================================================================

#ifndef _GLVU_
#define _GLVU_

#include <stdlib.h>
#include <time.h>            // FOR TIMED PATH PLAYBACK (glvu_camview)
#include <sys/timeb.h>       // FOR FRAME TIMING (glvu_camview)
#include <GL/glut.h>
#include <vec3f.hpp>
#include <camera.hpp>

#ifndef ABS
#define ABS(x) (((x)<0)?(-(x)):x)    // HANDY UNIVERSAL ABSOLUTE VALUE FUNC
#endif
#define INERTIA_MINMOVE 2            // AMOUNT (in pixels) TO MOVE TO INVOKE INERTIAL SYSTEM
#define MAX_GLVUS 33                 // MAX NUMBER OF WINDOWS PLUS 1 SUPPORTED IN ONE APP
#define FPS_INTEGRATE_INTERVAL 1.0f // MINIMUM NUMBER OF SECONDS TO INTEGRATE FRAME-RATE OVER

class GLVU
{
  public:


    enum WorldNavMode{
      NAV_MODE_TRACKBALL, 
      NAV_MODE_HYPERBALL,
      NAV_MODE_DRIVE, 
      NAV_MODE_TRANSLATE, 
      NAV_MODE_LOOK
    };

    enum CameraID
    {
      CAMERA_1,
      CAMERA_2,
      CAMERA_3,
      CAMERA_4,
      CAMERA_NUM_CAMS
    };
  
    typedef void (*InertiaFunc)(int x, int y);

    GLVU();
    virtual ~GLVU();
    int Init(char *WindowTitle, 
             unsigned int VisualMode,
             int WindowStartX, int WindowStartY,
             int WindowWidth, int WindowHeight);
    virtual int InitWin(int aPreviouslyCreatedGlutWindow);
    void BeginFrame();
    void EndFrame();

    // CAMVIEW
    int GetPlaybackOn() const;
    int GetRecordingOn() const;
     
    // CAMVIEW
    void SetAllCams(const Vec3f& WorldMin, const Vec3f& WorldMax, 
                    const Vec3f& Eye, const Vec3f& LookAtCntr, 
                    const Vec3f& viewup,
                    float Yfov, float Aspect, 
                    float NearFactor, float FarFactor);
    void AllCamsPerspectiveChange(float Yfov, float Aspect, 
                                 float Ndist, float Fdist);
    void AllCamsPerspectiveAspectChange(float Aspect);
    void AllCamsResetToOrig();
    float* GetModelviewMatrix(float* M);
    float* GetProjectionMatrix(float* M);
    void GetPixelRay(int sx, int sy, int ww, int wh, Vec3f *Start, Vec3f *Dir)
      const;
    void SelectCam(int WhichCam);
    Camera* GetCurrentCam();
    void SetCurrentCam(Camera *NewCam);
    Camera* GetCam(int WhichCam);
    int GetInOutMode() const;
    void SetInOutMode(int Bool);
    void ToggleInOutMode();
    void SetOrigCam(Camera *Cam);
    const Vec3f& GetViewUp() const ;
    const Vec3f& GetWorldCenter() const ;
    void SetWorldCenter(const Vec3f& newCenter);
    float GetWorldRadius() const ;
    void SetWorldRadius(float newRadius) ;
    void SetViewUp(Vec3f viewup) ;
    void SetMoveSpeed(float speed) ;
    void TranslateX(int OldX, int NewX, int WW);
    void TranslateY(int OldY, int NewY, int WH);
    void DriveY(int OldY, int NewY, int WH);
    void LookX(int OldX, int NewX, int WW);
    void LookY(int OldY, int NewY, int WH);
    void TrackBallX(int OldX, int NewX, int WW);
    void TrackBallY(int OldY, int NewY, int WH);
    void HyperBall(int OldX, int OldY, int NewX, int NewY,int WW, int WH);
    void StartRecording(const char *FileName = "path0.dat");
    void EndRecording();
    void StartPlayback(const char *FileName = "path0.dat");
    void EndPlayback();
    void StopRecordingPlayback();
    void StartFPSClock() ;
    void StopFPSClock() ;
    void DrawFPS(int xpos = 5, int ypos = 5);
    float GetFPS() const ;
    void UpdateFPS();  // USE ONLY IF YOU DO NOT CALL GLVU::BeginFrame()

    // MENU
    int GetMainMenuID() const ;
    int GetWorldNavMode() const ;
    void SetWorldNavMode(int mode) ;
    int GetCamDisplayOn(int WhichCam) const ;
    int IsWorldNavMode() const ;

    // MOUSE
    int GetLeftButtonDown() const ;
    int GetInertiaOn() const ; 
    int GetInertiaEnabled() const ;
    void SetInertiaOn(int Bool);
    void SetInertiaEnabled(int Bool) ;
    int GetInertiaDelay() const ; 
    void SetInertiaDelay(int msec) ;
    void SetInertiaFunc(InertiaFunc f) ; 
    InertiaFunc GetInertiaFunc() const;

    // DEFAULT CALLBACK FUNCTIONS (MOSTLY JUST CALL THE CALLBACK METHODS)
    static void DefaultMouseFunc(int button, int state, int x, int y);
    static void DefaultMotionFunc(int x, int y);
    static void DefaultReshapeFunc(int WW, int WH);
    static void DefaultDisplayFunc();
    static void DefaultKeyboardFunc(unsigned char Key, int x, int y);
    static void DefaultInertiaFunc(int x, int y);
  
    // CALLBACK METHODS
    virtual void Mouse(int button, int state, int x, int y);
    virtual void Motion(int x, int y);
    virtual void Reshape(int WW, int WH);
    virtual void Display() ;
    virtual void Keyboard(unsigned char Key, int x, int y);
    virtual void Inertia(int x, int y);

    // MISC
    int GetWindowID() const;
    void MakeCurrent();
    static GLVU* GetCurrent();
    static GLVU* GetGLVU(int WindowID);
    static GLVU* GetGLVU(); // deprecated
    static void PrintVisualInfo();


  protected:

    // GL VIEWER STATE VARIABLES
    Camera *Cams;                // ARRAY OF 4 VIEWER CAMS
    Camera *Cam;                 // PTR TO CURRENT CAM (DEFAULT IS CAM 0)
    Camera OrigCam;              // THE ORIGINAL VIEW FOR RESETTING
    int RecordingOn, PlaybackOn; // CAMERA RECORDING/PLAYBACK FLAGS
    FILE *RecordPlaybackFP;      // RECORDING/PLAYBACK FILE POINTER
    Vec3f WorldCenter;           // WORLD BOUNDING-SPHERE CENTER
    float WorldRadius;           // WORLD BOUNDING-SPHERE RADIUS
    Vec3f ViewUp;                // THE WORLD UP-VECTOR
    int InsideLookingOutMode;    // NAVIGATION MODE (IN->OUT OR OUT->IN)
    clock_t PlaybackTime;        // FOR PATH PLAYBACK TIMING
    int NumCams;
    struct timeb lastFPSClock;
    int calcFPS;
    float lastFPS;
    int lastFPSCount;

    int LeftButtonDown;
    int OldX, OldY, NewX, NewY;  // CURRENT OLD AND NEW MOUSE POSITIONS
    float moveSpeed;
    int CtrlPressed;
    int InertiaOn, InertiaEnabled;
    int InertiaDelay;

    int MainMenuID;              // GLUT MAIN MENU ID
    int WorldNavMode;            // WORLD NAVIGATION MODE
    int *CamDisplayOn;           // DISPLAY FLAG FOR EACH CAMERA

    // MENU
    static void MainMenuHandler(int value);
    static void vuOptionsMenuHandler(int value);
    static void glOptionsMenuHandler(int value);
    static void PathPlaybackMenuHandler(int value);
    static void CamViewMenuHandler(int value);
    static void CamViewDisplayMenuHandler(int value);
    static void EscapeHandler(int value);

    // MOUSE
    int DoInertia();
    InertiaFunc UserInertiaFunc;

    static GLVU *GLVUs[MAX_GLVUS];

    // glut WindowID
    int WindowID;
   
    static void InertialTimerFunc(int value);
    static void PathPlaybackTimerFunc(int value);

    virtual void InitMenu();

};

//----------------------------------------------------------------------------


inline int GLVU::GetPlaybackOn() const
{
  return(PlaybackOn); 
}


inline int GLVU::GetRecordingOn() const
{
  return(RecordingOn); 
}


inline void GLVU::SelectCam(int WhichCam)
{
  Cam = &Cams[WhichCam]; 
}

inline Camera* GLVU::GetCurrentCam() 
{
  return(Cam); 
}


inline void GLVU::SetCurrentCam(Camera *NewCam) 
{
  Cam=NewCam; 
}


inline Camera* GLVU::GetCam(int WhichCam) 
{
  return(&Cams[WhichCam]); 
}
   
inline int GLVU::GetInOutMode() const 
{
  return(InsideLookingOutMode); 
}

inline void GLVU::SetInOutMode(int Bool) 
{
  InsideLookingOutMode=Bool; 
}

inline void GLVU::ToggleInOutMode() 
{
  if (InsideLookingOutMode) InsideLookingOutMode=0;
  else InsideLookingOutMode=1; 
}

inline void GLVU::SetOrigCam(Camera *Cam) 
{
  OrigCam.Copy(*Cam); 
}

inline const Vec3f& GLVU::GetViewUp() const 
{
  return(ViewUp); 
}

inline const Vec3f& GLVU::GetWorldCenter() const 
{
  return WorldCenter; 
}

inline void GLVU::SetWorldCenter(const Vec3f& center)
{
  WorldCenter = center;
}

inline float GLVU::GetWorldRadius() const 
{
  return WorldRadius; 
}

inline void GLVU::SetWorldRadius(float newRadius) 
{
  WorldRadius = newRadius; 
}

inline void GLVU::SetViewUp(Vec3f viewup) 
{
  ViewUp=viewup; 
}

inline void GLVU::SetMoveSpeed(float speed) 
{
  moveSpeed = speed; 
}

inline void GLVU::StartFPSClock() 
{
  calcFPS = 1; ftime(&lastFPSClock); lastFPSCount=0;
}

inline void GLVU::StopFPSClock() 
{
  calcFPS = 0; 
}

inline float GLVU::GetFPS() const 
{
  return lastFPS; 
}

inline int GLVU::GetMainMenuID() const 
{
  return(MainMenuID); 
}

inline int GLVU::GetWorldNavMode() const 
{
  return(WorldNavMode); 
}

inline void GLVU::SetWorldNavMode(int mode) 
{
  WorldNavMode=mode; 
}

inline int GLVU::GetCamDisplayOn(int WhichCam) const 
{
  return(CamDisplayOn[WhichCam]); 
}
inline int GLVU::IsWorldNavMode() const 
{
  return(WorldNavMode>=0 && WorldNavMode<=3); 
}

inline int GLVU::GetLeftButtonDown() const 
{
  return(LeftButtonDown); 
}

inline int GLVU::GetInertiaOn() const 
{
  return(InertiaOn); 
} 


inline int GLVU::GetInertiaEnabled() const 
{
  return(InertiaEnabled);
}


inline void GLVU::SetInertiaEnabled(int Bool) 
{
  InertiaEnabled=Bool;
}



inline int GLVU::GetInertiaDelay() const 
{
  return(InertiaDelay);
} 


inline void GLVU::SetInertiaDelay(int msec) 
{
  InertiaDelay=msec;
}


inline void GLVU::SetInertiaFunc(GLVU::InertiaFunc f) 
{
  UserInertiaFunc=f;
} 


inline GLVU::InertiaFunc GLVU::GetInertiaFunc() const
{
  return UserInertiaFunc;
}


inline int GLVU::GetWindowID() const
{
  return WindowID;
}


inline void GLVU::MakeCurrent()
{
  glutSetWindow(WindowID);
}


inline GLVU* GLVU::GetCurrent()
{
  return GLVUs[ glutGetWindow() ];
}


inline GLVU* GLVU::GetGLVU(int WindowID)
{
  return GLVUs[ WindowID ];
}


inline GLVU* GLVU::GetGLVU(void)
{
  return GLVUs[ glutGetWindow() ];
}


#endif

---