src/Display.cpp

Go to the documentation of this file.

/*
This file is part of Teapot Colony Wars.

Teapot Colony Wars 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.

Teapot Colony Wars is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Teapot Colony Wars.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "Display.h"

#include <cstdlib>
#include <cmath>

#include "Constants.h"
#include "Accum.h"
#include "Jitter.h"

void display_timer(int value) {
  Display::instance()->timer(value);
}

Display* Display::_instance = NULL;

Display::Display() : _world(12, 12, 2) {
  // initialisation du point au centre du champs de vision de la caméra
  _center_x = (GLint) (_world.getWidth() / 2) * CELL_SIZE;
  _center_y = 0;
  _center_z = (GLint) (_world.getHeight() / 2) * CELL_SIZE;

  // positionnement de la caméra
  _camera_x = (GLint) _center_x;
  _camera_y = (GLint) HEIGHT_MAX / 4;
  _camera_z = (GLint) _center_z + 3 * CELL_SIZE;

  // profondeur de champs
  _near = 0.1;
  _far = HORIZON;

  // angle d'ouverture
  _fovy = 45.0;

  // initialisation du timer
  _timer = true;
  glutTimerFunc(REDISPLAY_NB_MILLI_SEC, display_timer, 0);
}

GLfloat Display::focal_distance() {
  return sqrt((_camera_x - _center_x) * (_camera_x - _center_x) +
              (_camera_y - _center_y) * (_camera_y - _center_y) +
              (_camera_y - _center_y) * (_camera_y - _center_y));
}

void Display::translate_camera(GLfloat  inc_x, GLfloat  inc_z) {
  GLfloat tmp_x = _center_x + inc_x;
  GLfloat tmp_z = _center_z + inc_z;

  if(tmp_x > 0.0 && tmp_x < (_world.getWidth() - 1.0) * CELL_SIZE &&
      tmp_z > 0.0 && tmp_z < (_world.getHeight() - 1.0) * CELL_SIZE) {
    _camera_x += inc_x;
    _center_x = tmp_x;
    _camera_z += inc_z;
    _center_z = tmp_z;
    glutPostRedisplay();
  }
}

void Display::move_camera(GLfloat  inc_y) {
  GLfloat tmp_y = _camera_y + inc_y;

  if(tmp_y >= HEIGHT_MIN && tmp_y <= HEIGHT_MAX) {
    _camera_y += inc_y;
    glutPostRedisplay();
  }
}

void Display::zoom_camera(GLfloat  inc) {
  GLfloat tmp = focal_distance();

  if(_camera_y + inc >= HEIGHT_MIN && _camera_y + inc <= HEIGHT_MAX) {
    _camera_x = ((_camera_x - _center_x) * (1 + inc / tmp)) + _center_x;
    _camera_y = ((_camera_y - _center_y) * (1 + inc / tmp)) + _center_y;
    _camera_z = ((_camera_z - _center_z) * (1 + inc / tmp)) + _center_z;
    glutPostRedisplay();
  }
}

void Display::rotate_camera(GLfloat  inc) {
  GLfloat tmp = _camera_x;
  _camera_x = ((_camera_x - _center_x) * cos(inc) -
    (_camera_z - _center_z) * sin(inc)) + _center_x;
  _camera_z = ((tmp - _center_x) * sin(inc) +
    (_camera_z - _center_z) * cos(inc)) + _center_z;
  glutPostRedisplay();
}

Display::~Display() {
  destroy();
}

Display* Display::instance() {
  if(_instance == NULL) {
    _instance = new Display();
  }

  return _instance;
}

void Display::destroy() {
  if(_instance != NULL) {
    delete _instance;
    _instance = NULL;
  }
}

void Display::init() {
  // paramètres d'illumination
  GLfloat mat_specular[]   = {1.0, 1.0, 1.0, 1.0};
  GLfloat mat_shininess[]  = {100.0};
  GLfloat white_light[]    = {1.0, 1.0, 1.0, 1.0};
  GLfloat light_position[] = {
    _world.getWidth() / 2.0,
    HEIGHT_MAX,
    _world.getHeight() / 2.0,
    0.0
  };

  // couleur de vidage des buffers
  glClearColor(0.0, 0.0, 0.0, 1.0);

  // model d'ombres pour l'illumination
  glShadeModel(GL_FLAT);

  // propriétés de matière des objets
  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);

  // création de la source lumineuse
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light);
  glLightfv(GL_LIGHT0, GL_SPECULAR, white_light);

  // activation de l'illumination
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);

  // paramètres de génération automatique des coordonnées de texture
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

  // permet de prendre en compte la couleur des objets lors de leur illumination
  glEnable(GL_COLOR_MATERIAL);

  // initialisation du buffeur de profondeur
  glClearDepth(1.0);
  glDepthFunc(GL_LESS);
  glEnable(GL_DEPTH_TEST);

  // activation de la création automatique de vecteurs normaux normalisés
  glEnable(GL_AUTO_NORMAL);
  glEnable(GL_NORMALIZE);
}

void Display::quit() {

}

void Display::timer(int value) {
  _world.iteration();
  glutPostRedisplay();
  if(_timer) {
    // on relance le timer pour ré-appeler automatiquement la fonction plus tard
    glutTimerFunc(REDISPLAY_NB_MILLI_SEC, display_timer, 0);
  }
}

void Display::draw() {
  GLint viewport[4];
  GLdouble ratio;
  int nb_steps = j[ANTIALIASING_LEVEL].nb;
  GLdouble step = 1.0 / nb_steps;
  jitter_point* jp = j[ANTIALIASING_LEVEL].jitter_points;
  int jitter;

  // récupération des paramètres d'affichage à l'écran
  glGetIntegerv(GL_VIEWPORT, viewport);
  // calcul du ratio de l'image affichée
  ratio = (GLdouble) viewport[2] / (GLdouble) viewport[3];

  // vidage du tampon d'accumulation
  glClear(GL_ACCUM_BUFFER_BIT);
  for(jitter = 0; jitter < nb_steps; jitter++) {
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

    // modification de la matrice de projection en fonction du jitter
    // (pour l'antialiasing)
    accPerspective(_fovy, ratio, _near, _far,
                   jp[jitter].x, jp[jitter].y,
                   0.0, 0.0, 1.0);

    // passage en mode dessin
    glMatrixMode(GL_MODELVIEW);
    // chargement de la matrice de transformation identitaire
    // (remise à l'origine)
    glLoadIdentity();
    // positionnement de la caméra
    gluLookAt(_camera_x, _camera_y, _camera_z,
              _center_x, _center_y, _center_z,
              0.0, 1.0, 0.0);

    // affichage du curseur de position
    glColor3ub((GLubyte) (0.7 * COLOR_MAX), COLOR_MAX, COLOR_MAX);
    glPushMatrix();
    glTranslatef(_center_x, _center_y + 0.01 * CELL_SIZE, _center_z);
    glRotatef(90.0, 1.0, 0.0, 0.0);
    glutSolidTorus (0.03 * CELL_SIZE, 0.75 * CELL_SIZE,
      CELL_SIZE, 5 * CELL_SIZE);
    glPopMatrix();

    // affichage du monde
    _world.draw();

    // ajout de l'image produite dans le tampon d'accumulation
    glAccum(GL_ACCUM, step);
  }

  // récupération de l'image résultant de l'accumulation
  glAccum(GL_RETURN, 1.0);

  // inversion des buffers de dessin : apparition de l'image à l'écran
  glutSwapBuffers();
}

void Display::reshape(int width, int height) {
  // division par 0 : pas bô, alors autant l'éviter...
  if (height == 0)
    height = 1;

  // modification de la taille de la zone d'affichage
  glViewport(0, 0, width, height);

  // passage en mode projection
  glMatrixMode(GL_PROJECTION);

  // création de la nouvelle transformation de projection
  glLoadIdentity();
  gluPerspective(_fovy, (float) width / height, _near, _far);

  // réactivation du mode dessin
  glMatrixMode(GL_MODELVIEW);
}

void Display::inputKey(unsigned char key, int x, int y) {
  GLint specialKey = glutGetModifiers();

  switch(key) {
    case TRANSLATE_LEFT :
      translate_camera(-CELL_SIZE, 0.0);
      break;
    case TRANSLATE_RIGHT :
      translate_camera(CELL_SIZE, 0.0);;
      break;
    case TRANSLATE_UP :
      translate_camera(0.0, -CELL_SIZE);
      break;
    case TRANSLATE_DOWN :
      translate_camera(0.0, CELL_SIZE);
      break;
    case ZOOM_IN :
      if(specialKey == GLUT_ACTIVE_CTRL) {
        move_camera(MOVE_UP_SPEED);
      } else {
        zoom_camera(-ZOOM_SPEED);
      }
      break;
    case ZOOM_OUT :
      if(specialKey == GLUT_ACTIVE_CTRL) {
        move_camera(-MOVE_UP_SPEED);
      } else {
        zoom_camera(ZOOM_SPEED);
      }
      break;
    case ROTATE_LEFT :
      rotate_camera(-ROTATE_ANGLE);
      break;
    case ROTATE_RIGHT :
      rotate_camera(ROTATE_ANGLE);
      break;
    case PAUSE :
      if(_timer) {
        _timer = false;
      } else {
        _timer = true;
        // relance le timer
        glutTimerFunc(REDISPLAY_NB_MILLI_SEC, display_timer, 0);
      }
      break;
    case VALIDATE :
      _world.addGodsGift((unsigned int) _center_z / CELL_SIZE,
        (unsigned int) _center_x / CELL_SIZE);
      glutPostRedisplay();
      break;
  }
}

void Display::inputMouse(int button, int state, int x, int y) {
  GLint specialKey = glutGetModifiers();

  /*
  GLint viewport[4];
  GLdouble modelview[16];
  GLdouble projection[16];
  GLfloat win_x, win_y, win_z;
  GLdouble obj_x, obj_y, obj_z;

  glGetIntegerv(GL_VIEWPORT, viewport);
  glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
  glGetDoublev(GL_PROJECTION_MATRIX, projection);

  win_x = (GLfloat) x;
  win_y = (GLfloat) viewport[3] - (GLfloat) y;
  glReadPixels(win_x, win_y , 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &win_z);

  gluUnProject((GLdouble) win_x, (GLdouble) win_y, 0.0, modelview, projection,
    viewport, &obj_x, &obj_y, &obj_z);
  */

  if(state == GLUT_DOWN) {
    switch(button) {
      case GLUT_UP_BUTTON :
        if(specialKey == GLUT_ACTIVE_CTRL) {
          move_camera(MOVE_UP_SPEED);
        } else {
          zoom_camera(-ZOOM_SPEED);
        }
        break;
      case GLUT_DOWN_BUTTON :
        if(specialKey == GLUT_ACTIVE_CTRL) {
          move_camera(-MOVE_UP_SPEED);
        } else {
          zoom_camera(ZOOM_SPEED);
        }
        break;
      case GLUT_LEFT_BUTTON :
        if(specialKey == GLUT_ACTIVE_CTRL) {
          rotate_camera(-ROTATE_ANGLE);
        } else {
          _world.iteration();
          glutPostRedisplay();
        }
        break;
      case GLUT_RIGHT_BUTTON :
        if(specialKey == GLUT_ACTIVE_CTRL) {
          rotate_camera(ROTATE_ANGLE);
        }
        break;
    }
  }
}

---