Camera.h

gehe zur Dokumentation dieser Datei

/*
Autor: $Author: kunkel $ State: $State: Exp $
Datum: $Date: 2005/05/30 12:35:25 $
Version: $Revision: 1.1 $
*/

#ifndef CAMERA_H
#define CAMERA_H

#include "config.h"
#include "Vector.h"
#include "Object.h"

class Camera {
public:
    static const int CAMERA_SAVES = 10;
private:
    class cameraPos {
    public:
        Vector place;

        Vector upper;

        Vector projectionCenter;
    };

    Vector place;

    Vector upper;

    Vector projectionCenter;

    cameraPos positionList[CAMERA_SAVES];

    double aperture;

    int screenwidth, screenheight;


public:
    Camera();

    void saveAktuallCameraPosition(int to);

    void loadAktuallCameraPosition(int from);

    typedef enum {NONE, ROTATEXY,ROTATEZ,FORWARD,MOVE,ROTATEKEEPPOSXY,ZOOM} Action;

    Action action;

    int getScreenWidth() {
        return screenwidth;
    }

    int getScreenHeight() {
        return screenheight;
    }

    void setScreen(int width,int height) {
        screenwidth = width;
        screenheight = height;
    }


    /* Breite und Hoehe der Projektionsflaeche       */

    void rotateKeepViewPoint(int ix, int iy, int iz);
    void rotateKeepPosition(int ix, int iy);

    void saveCamera(ostream & FILE);
    void loadCamera(istream & FILE);
    void reloadAutomaticAdaption();

    inline void loadCameraMatrix() {
        /* Eine perspektivische Projektion einstellen. (Die soeben geladene
        Einheitsmatrix wird mit einer aus den folgenden Angaben berechneten
        Projektionsmatrix multipliziert.) Das erste Argument ist
        der Oeffnungswinkel der Kamera in Grad; danach steht das Verhaeltnis
        von Projektionsflaechenbreite zu -hoehe, anschliessend werden die
        Abstaende zwischen Kamera und vorderer Beschneidungsflaeche sowie
        zwischen Kamera und hinterer Beschneidungsflaeche angegeben. Alles,
        was sich zwischen diesen beiden, senkrecht zur Blickrichtung stehenden
        Flaechen befindet, wird in die Darstellung der Szene mit einbezogen. */
        gluLookAt(place.x, place.y, place.z,
                  projectionCenter.x, projectionCenter.y, projectionCenter.z,
                  upper.x, upper.y, upper.z);
    }

    inline void loadCameraPerspective() {
        gluPerspective(aperture, screenwidth / (double) screenheight, 0.2, 1e12);
    }

    void setAllToViewObject(Object *);

    void home();
    void moveForward(double multiplier);
    void move(double unten, double right); // 2 Dimensional gesehene Bewegung
    void zoom(double multiplier) ;
    void zoomTo(Vector & pos_, double distance_);
    void changeLinearScaleFactor(double multiplier);

    inline void setProjectionCenter(const Vector & pos_) {
        projectionCenter = pos_;
    }

    inline Vector getProjectionCenter() {
        return projectionCenter;
    }

    inline Vector getViewDirectionOrthogonal() {
        Vector viewDirection=projectionCenter - place;
        viewDirection.normalise();
        return  viewDirection.crossProduct(upper);
    }

    inline void setPosition(const Vector & pos_) {
        place = pos_;
    }

    inline void setUpper(const Vector & pos_) {
        upper = pos_;
        upper.normalise();
    }

    inline Vector getUpper() {
        return upper;
    }

    inline Vector getPosition() {
        return place;
    }

    double getProjectionDistance() {
        return (projectionCenter-place).length();
    }
};

extern Camera ourCamera;

#endif

---