---

viewmodel.h

Go to the documentation of this file.

//                          viewmodel.h                                 //
//                         -------------                                //
//    begin                : 1998                                       //
//    copyright            : Paul Rademacher                            //
//    modified             : cbaudry (mainly removed global funcs)      //
//    email                : cedric.baudry@tremplin-utc.fr              //

//                                                                        //
//   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, version 2 of the License               //
//                                                                        //

#pragma once

#include "algebra3.h"     // Include algebra3.h first to avoid problems on MS Windows
#include <stdio.h>
#include <stdlib.h>

class ViewModel
{
  public:
    vec3 eye;     
    vec3 lookat;  
    vec3 up;      
    vec3 side;    
    vec3 forward; 
    mat4 mtx;     
    float distance; 

    void set_distance (float new_distance)
    {
        if (new_distance <= 0.0) /* Distance has to be positive */
            return;

        /* We find the current forward vector */
        forward = lookat - eye;
        forward.normalize ();

        /* Set distance */
        distance = new_distance;

        /* Find new eye point */
        eye = lookat - forward * distance;
    }

    void set_up (vec3 new_up)
    {
        up = new_up;
        update ();
    }

    void set_up (float x, float y, float z)
    {
        set_up (vec3 (x, y, z));
    }

    void set_eye (vec3 new_eye)
    {
        eye = new_eye;
        update ();
    }

    void set_eye (float x, float y, float z)
    {
        set_eye (vec3 (x, y, z));
    }

    void set_lookat (vec3 new_lookat)
    {
        lookat = new_lookat;
        update ();
    }

    void set_lookat (float x, float y, float z)
    {
        set_lookat (vec3 (x, y, z));
    }

    void roll (float angle)
    {
        mat4 rot = mat4::rotation3D (forward, angle);

        up = rot * up;

        update ();
    }

    void eye_yaw (float angle)
    {
        vec3 eye_pt = eye - lookat; /* eye w/lookat at center */
        mat4 rot = mat4::rotation3D (up, angle);

        eye_pt = rot * eye_pt;
        eye = lookat + eye_pt;

        update ();
    }

    void eye_yaw_abs (float angle, vec3 axis)
    {
        vec3 eye_pt = eye - lookat; /* eye w/lookat at center */
        mat4 rot = mat4::rotation3D (axis, angle);

        eye_pt = rot * eye_pt;
        eye = lookat + eye_pt;

        up = rot * up;

        update ();
    }

    void eye_pitch (float angle)
    {
        vec3 eye_pt = eye - lookat; /* eye w/lookat at center */
        mat4 rot = mat4::rotation3D (side, angle);

        eye_pt = rot * eye_pt;
        eye = lookat + eye_pt;

        up = rot * up;

        update ();
    }

    void lookat_yaw (float angle)
    {
        vec3 lookat_pt = lookat - eye; /* lookat w/eye at 
                                          center */
        mat4 rot = mat4::rotation3D (up, -angle);

        lookat_pt = rot * lookat_pt;
        lookat = eye + lookat_pt;

        update ();
    }

    void lookat_pitch (float angle)
    {
        vec3 lookat_pt = lookat - eye; /* lookat w/eye at 
                                          center */
        mat4 rot = mat4::rotation3D (side, -angle);

        lookat_pt = rot * lookat_pt;
        lookat = eye + lookat_pt;

        up = rot * up;

        update ();
    }

    void reset_up (int axis_num)
    {
        float eye_distance = (lookat - eye).length ();
        eye[axis_num] = lookat[axis_num];
        /* Bring eye to same level as lookat */

        vec3 vector = eye - lookat;
        vector.normalize ();
        vector *= eye_distance;

        eye = lookat + vector;
        up.set (0.0, 0.0, 0.0);
        up[axis_num] = 1.0;

        update ();
    }

    void reset_up (void)
    {
        reset_up (VY);          /* Resets to the Y axis */
    }

    void move (float side_move, float up_move, float forw_move)
    {
        eye += forward * forw_move;
        eye += side * side_move;
        eye += up * up_move;
        lookat += forward * forw_move;
        lookat += side * side_move;
        lookat += up * up_move;
        update ();
    }

    void move (vec3 v)
    {                           
        move (v[VX], v[VY], v[VZ]);
    }

    void move_by_eye (vec3 new_eye)
    {
        vec3 diff = new_eye - eye;

        eye += diff;
        lookat += diff;

        update ();
    }

    void move_by_lookat (vec3 new_lookat)
    {
        vec3 diff = new_lookat - lookat;

        lookat += diff;
        eye += diff;

        update ();
    }

    void move_abs (vec3 v)
    {
        eye += v;
        lookat += v;

        update ();
    }

    void rot_about_eye (mat4 rot)
    {
        vec3 view = lookat - eye;

        view = rot * view;
        up = rot * up;

        lookat = eye + view;

        update ();
    }

    void rot_about_lookat (mat4 rot)
    {
        // NOT QUITE RIGHT YET

        vec3 view = eye - lookat;

        view = rot * view;
        up = rot * up;

        eye = lookat + view;

        update ();
    }

    void make_mtx (void)
    {
        update ();

        mtx[0][0] = side[VX];
        mtx[0][1] = up[VX];
        mtx[0][2] = forward[VX];
        mtx[0][3] = 0.0;
        mtx[1][0] = side[VY];
        mtx[1][1] = up[VY];
        mtx[1][2] = forward[VY];
        mtx[1][3] = 0.0;
        mtx[2][0] = side[VZ];
        mtx[2][1] = up[VZ];
        mtx[2][2] = forward[VZ];
        mtx[2][3] = 0.0;
        mtx[3][0] = 0.0;
        mtx[3][1] = 0.0;
        mtx[3][2] = 0.0;
        mtx[3][3] = 1.0;
    }

    void load_to_openGL (void)
    {
        make_mtx ();

        glMatrixMode (GL_MODELVIEW);
        glLoadIdentity ();
        glMultMatrixf (&mtx[0][0]);
        glTranslatef (-eye[VX], -eye[VY], -eye[VZ]);
    }

    void load_to_openGL_noident (void)
    {

        make_mtx ();

        glMatrixMode (GL_MODELVIEW);
        glMultMatrixf ((float *) &mtx[0][0]);
        glTranslatef (-eye[VX], -eye[VY], -eye[VZ]);
    }

    void reset (void)
    {
        up.set (0.0, 1.0, 0.0);

        eye.set (0.0, 0.0, 10.0);
        lookat.set (0.0, 0.0, 0.0);

        mtx = mat4::identity3D ();

        update ();
    }

    ViewModel (void)
    {
        reset ();
    }

    void update (void)
    {
        /* get proper side and forward vectors, and distance  */
        forward = -(lookat - eye);
        distance = forward.length ();
        forward /= distance;

        side = up ^ forward;
        up = forward ^ side;

        forward.normalize ();
        up.normalize ();
        side.normalize ();
    }

    void dump (FILE * output)
    {
        fprintf (output, "Viewmodel: \n");
        eye.print (output, "  eye");
        lookat.print (output, "  lookat");
        up.print (output, "  up");
        side.print (output, "  side");
        forward.print (output, "  forward");
        mtx.print (output, "  mtx");
    }
};

---