grcam.h

Go to the documentation of this file.

/***************************************************************************

    file                 : grcam.h
    created              : Mon Aug 21 20:55:02 CEST 2000
    copyright            : (C) 2000 by Eric Espie
    email                : torcs@free.fr
    version              : $Id$

 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef _GRCAM_H_
#define _GRCAM_H_

#include <track.h>
#include <car.h>
#include <raceman.h>
#ifdef WIN32
#include <float.h>
#endif

class cGrCamera;
class cGrScreen;

GF_TAILQ_HEAD(GrCamHead, cGrCamera);

/* Camera interface */
class cGrCamera 
{
 private:
    GF_TAILQ_ENTRY(cGrCamera) link;
    int         id;     /* Camera Id */
    int         drawCurrent;    /* flag to draw the current car */
    int         drawDriver; /* flag to draw the driver */
    int         drawBackground; /* flag to draw the background */
    int         mirrorAllowed;  /* flag to allox the display of mirror */

 protected:
    sgVec3 speed;
    sgVec3 eye;
    sgVec3 center;
    sgVec3 up;
    class cGrScreen *screen;    /* screen where the camera is attached */
    
 public:
    cGrCamera(class cGrScreen *myscreen, int myid = 0, int mydrawCurrent = 0, int mydrawdrv = 0, int mydrawBackground = 0, int mymirrorAllowed = 0) {
        screen = myscreen;
        id = myid;
        drawCurrent = mydrawCurrent;
        drawDriver = mydrawdrv;
        drawBackground = mydrawBackground;
        mirrorAllowed = mymirrorAllowed;
        speed[0] = speed[1] = speed[2] = 0.0;
        eye[0] = eye[1] = eye[2] = 0.0;
        center[0] = center[1] = center[2] = 0.0;
        up[0] = up[1] = 0.0; up[2] = 1.0;
    }

    virtual ~cGrCamera() {};
    
    virtual void update(tCarElt *car, tSituation *s) = 0;   /* Change the camera if necessary */
    virtual void setProjection(void) = 0;
    virtual void setModelView(void) = 0;
    virtual void setZoom(int cmd) = 0;              /* Set the zoom with commands */
    virtual void loadDefaults(char *attr) = 0;          /* Load the default values from parameter file */
    virtual void onSelect(tCarElt *car, tSituation *s) = 0; /* called when the camera is selected */

    virtual float getLODFactor(float x, float y, float z) = 0;  /* Get the LOD factor for an object located at x,y,z */

    /* Set the camera view */
    void action(void) {
    setProjection();
    setModelView();
    }
    
    /* Get the camera info */
    int getId(void)     { return id; }
    int getDrawCurrent(void)    { return drawCurrent; }
    int getDrawDriver(void) { return drawDriver; }
    int getDrawBackground(void) { return drawBackground; }
    int isMirrorAllowed(void)   { return mirrorAllowed; }

    t3Dd *getPos(void) {
    static t3Dd pos;
    pos.x = eye[0];
    pos.y = eye[1];
    pos.z = eye[2];
    return &pos;
    }
    sgVec3 *getPosv(void) {
    return &eye;
    }
    sgVec3 *getSpeedv(void) {
        return &speed;
    }
    t3Dd *getCenter(void) {
    static t3Dd pos;
    pos.x = center[0];
    pos.y = center[1];
    pos.z = center[2];
    return &pos;
    }
    sgVec3 *getCenterv(void) {
    return &center;
    }
    t3Dd *getUp(void) {
    static t3Dd pos;
    pos.x = up[0];

    pos.y = up[1];
    pos.z = up[2];
    return &pos;
    }
    sgVec3 *getUpv(void) {
    return &up;
    }

    virtual float getFovY(void) {
    return 67.5; // override in perspective camera
    }
    
    /* Add the camera in the corresponding list */
    void add(tGrCamHead *head) {
    GF_TAILQ_INSERT_TAIL(head, this, link);
    }
    
    /* Remove the camera from the corresponding list */
    void remove(tGrCamHead *head) {
    GF_TAILQ_REMOVE(head, this, link);
    }

    /* Get the squared distance between the car and the camera */
    float getDist2(tCarElt *car);

    cGrCamera *next(void) {
    return GF_TAILQ_NEXT(this, link);
    }
};


class cGrPerspCamera : public cGrCamera
{
 protected:
    float fovy;
    float fovymin;
    float fovymax;
    float fovydflt;
    float fnear;
    float ffar;
    float fogstart;
    float fogend;
    
 public:
    cGrPerspCamera(class cGrScreen *myscreen, int id, int drawCurr, int drawDrv, int drawBG, int mirrorAllowed,
           float myfovy, float myfovymin, float myfovymax,
           float myfnear, float myffar = 1500.0, float myfogstart = 1400.0, float myfogend = 1500.0);
    
    virtual void update(tCarElt *car, tSituation *s) = 0;   /* Change the camera if necessary */
    void setProjection(void);
    void setModelView(void);
    void loadDefaults(char *attr);
    void setZoom(int cmd);
    float getLODFactor(float x, float y, float z);
    float getFogStart(void) { return fogstart; }
    float getFogEnd(void) { return fogend; }

    cGrPerspCamera *next(void) {
    return (cGrPerspCamera *)cGrCamera::next();
    }

   void limitFov(void)  {}
   void onSelect(tCarElt *car, tSituation *s) {}

   virtual float getFovY(void) {
       return fovy;
   }

};



class cGrOrthoCamera : public cGrCamera
{
 protected:
    float left;
    float right;
    float bottom;
    float top;

 public:
    cGrOrthoCamera(class cGrScreen *myscreen, float myleft, float myright, float mybottom, float mytop)
    : cGrCamera(myscreen) {
    left   = myleft;
    right  = myright;
    bottom = mybottom;
    top    = mytop;
    }

    void setProjection(void);
    void setModelView(void);

    void update(tCarElt *car, tSituation *s) { }
    float getLODFactor(float x, float y, float z) { return 1; }
    void loadDefaults(char *attr) { }
    void setZoom(int cmd) { }
    void onSelect(tCarElt *car, tSituation *s) {}
};

class cGrBackgroundCam : public cGrPerspCamera
{
 public:
    cGrBackgroundCam(class cGrScreen *myscreen)
    : cGrPerspCamera(myscreen, 0, 0, 0, 1, 0,
             67.5f, 67.5f, 67.5f,
             0.1f, 2000.0f, 100000.0f, 100000.0f) {
    }
    
    void update(tCarElt *car, tSituation *s) {}

    void update(cGrCamera *curCam);
    void limitFov(void) { }
};

class cGrCarCamMirror : public cGrPerspCamera
{
 protected:
    int     vpx, vpy, vpw, vph; /* viewport size */
    int     tw, th;         /* texture size */
    int     mx, my, mw, mh;     /* drawing area */
    float   tsu, tsv, teu, tev; /* texture coord */
    GLuint  tex;            /* texture */
    cGrOrthoCamera *viewCam;
    
 public:
    cGrCarCamMirror(cGrScreen *myscreen, int id, int drawCurr, int drawBG,
            float myfovy, float myfovymin, float myfovymax,
            float myfnear, float myffar = 1500.0,
            float myfogstart = 1400.0, float myfogend = 1500.0)
    : cGrPerspCamera(myscreen, id, drawCurr, 1, drawBG, 1,
             myfovy, myfovymin, myfovymax,
             myfnear, myffar, myfogstart, myfogend) {
    glGenTextures (1, &tex);
    limitFov();
    viewCam = NULL;
    }
    virtual ~cGrCarCamMirror ();

    void update (tCarElt *car, tSituation *s);
    void limitFov (void);

    void setViewport (int x, int y, int w, int h);
    void setPos (int x, int y, int w, int h);
    void activateViewport (void);
    void store (void);
    void display (void);
};


#define GR_ZOOM_IN  0
#define GR_ZOOM_OUT     1
#define GR_ZOOM_MAX     2
#define GR_ZOOM_MIN     3
#define GR_ZOOM_DFLT    4

void grCamCreateSceneCameraList(class cGrScreen *myscreen, tGrCamHead *cams, tdble fovFactor);

#endif /* _GRCAM_H_ */