src/Image.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 "Image.h"

#include <iostream>
#include <fstream>
#include <cstdlib>

#include "Constants.h"

int Image::readInt(std::ifstream &input) {
  char buffer[4];
  input.read(buffer, 4);
  return (int) (((unsigned char) buffer[3] << 24) |
                ((unsigned char) buffer[2] << 16) |
                ((unsigned char) buffer[1] <<  8) |
                 (unsigned char) buffer[0]);
}

short Image::readShort(std::ifstream &input) {
  char buffer[2];
  input.read(buffer, 2);
  return (short) (((unsigned char)buffer[1] << 8) |
                   (unsigned char)buffer[0]);
}

void Image::readBMPFileHeader(std::ifstream &input, BITMAPFILEHEADER *bfh) {
  bfh->bfType      = readShort(input);
  bfh->bfSize      = readInt(input);
  bfh->bfReserved1 = readShort(input);
  bfh->bfReserved2 = readShort(input);
  bfh->bfOffBits   = readInt(input);
}

void Image::readBMPInfoHeader(std::ifstream &input, BITMAPINFOHEADER *bih) {
  bih->biSize =          readInt(input);
  bih->biWidth =         readInt(input);
  bih->biHeight =        readInt(input);
  bih->biPlanes =        readShort(input);
  bih->biBitCount =      readShort(input);
  bih->biCompression =   readInt(input);
  bih->biSizeImage =     readInt(input);
  bih->biXPelsPerMeter = readInt(input);
  bih->biYPelsPerMeter = readInt(input);
  bih->biClrUsed =       readInt(input);
  bih->biClrImportant =  readInt(input);
}

void Image::readBMPColorTable(std::ifstream &input, int end, RGBQUAD *table) {
  int i, size = (end - input.tellg()) / 4;

  for(i = 0; i < size; i++) {
    input.read(&(table[i].rgbBlue), 1);
    input.read(&(table[i].rgbGreen), 1);
    input.read(&(table[i].rgbRed), 1);
    input.read(&(table[i].rgbReserved), 1);
  }
}

void Image::loadBMP(const char* filename) {
  std::ifstream input;
  BITMAPFILEHEADER *bfh;
  BITMAPINFOHEADER *bih;
  RGBQUAD *colorTable;
  int bytesPerRow, size, i, j, k, l;
  float factor;
  char *datas;
  char c;

  // ouverture du fichier
  input.open(filename, std::ios::in | std::ifstream::binary);
  if(input.fail()) {
    std::cerr << filename << " : could not find file" << std::endl;
    exit(EXIT_FAILURE);
  }

  // lecture de l'entête du fichier
  bfh = new BITMAPFILEHEADER;
  readBMPFileHeader(input, bfh);

  // les deux premiers octets d'un fichier bitmap doivent être "BM"
  if(bfh->bfType != 0x4D42) {
    std::cerr << filename << " : not a bitmap file" << std::endl;
    exit(EXIT_FAILURE);
  }

  // lecture des informations du bitmap
  bih = new BITMAPINFOHEADER;
  readBMPInfoHeader(input, bih);

  // on vérifie que le fichier n'est pas compressé
  if(bih->biCompression != 0) {
    std::cerr << filename << " : image is compressed" << std::endl;
    exit(EXIT_FAILURE);
  }

  // on récupère la largeur et la hauteur de l'image
  _width = bih->biWidth;
  _height = bih->biHeight;

  // chaque ligne de données du fichier doit comporter un nombre de bits
  // multiple de 4, les lignes sont éventuellement complètées par des 0.
  // on va donc calculer la taille des lignes à lire...
  switch(bih->biBitCount) {
    case 24:
      factor = 3.0;
      break;
    case 8:
      factor = 1.0;
      break;
    case 4:
      factor = 1.0 / 2.0;
      break;
    case 1:
      factor = 1.0 / 8.0;
      break;
    default:
      std::cerr << filename << " : invalid color depth" << std::endl;
      exit(EXIT_FAILURE);
  }
  float x = factor * (float) _width;
  int bytesToRead = ((int) x) + (((float) ((int) x)) != x);
  bytesPerRow = ((int) (((float) bytesToRead + 3.0) / 4.0)) * 4;
  int bytesToSkip = bytesPerRow - bytesToRead;
  size = bytesPerRow * _height;

  // création de la zone de mémoire temporaire pour stocker les données bruts.
  datas = new char[size];
  // ainsi que celle qui contiendra les données finales
  _pixels = new GLubyte[4 * _width * _height];

  // la lecture des données est différente selon que la composante couleur
  // par pixel est codée sur 24, 8, 4 ou 1 bits.
  switch(bih->biBitCount) {
    case 24:
      // on se positionne au début des données et on les lit en un seul passage
      input.seekg(bfh->bfOffBits, std::ios::beg);
      input.read(datas, size);
      // les données sont stockées sous forme BGR, il faut les retransformer
      // en RBG, en ajoutant une composante pour le blending alpha (on choisit
      // de rendre les pixels opaques, mais il serait envisageable de changer
      // cela par la suite)
      for(i = 0; i < _height; i++) {
        for(j = 0; j < _width; j++) {
          _pixels[4 * (i * _width + j)]     = datas[i * bytesPerRow + 3 * j + 2];
          _pixels[4 * (i * _width + j) + 1] = datas[i * bytesPerRow + 3 * j + 1];
          _pixels[4 * (i * _width + j) + 2] = datas[i * bytesPerRow + 3 * j];
          _pixels[4 * (i * _width + j) + 3] = COLOR_MAX;
        }
      }
      break;
    case 8:
      // création et lecture de la table des couleurs
      colorTable = new RGBQUAD[256];
      readBMPColorTable(input, bfh->bfOffBits, colorTable);
      // on se positionne au début des données
      input.seekg(bfh->bfOffBits, std::ios::beg);
      for(i = 0; i < _height; i++) {
        for(j = 0; j < _width; j++) {
          // on lit les octets un par un
          input.read(&c, 1);
          // chaque octet représente un pixel, la valeur stockée correspond
          // à l'index dans la table chromatique
          _pixels[4 * (i * _width + j)]     = colorTable[c].rgbRed;
          _pixels[4 * (i * _width + j) + 1] = colorTable[c].rgbGreen;
          _pixels[4 * (i * _width + j) + 2] = colorTable[c].rgbBlue;
          _pixels[4 * (i * _width + j) + 3] = COLOR_MAX;
        }
        input.seekg(bytesToSkip, std::ios::cur);
      }
      delete colorTable;
      break;
    case 4:
      // création et lecture de la table des couleurs
      colorTable = new RGBQUAD[16];
      readBMPColorTable(input, bfh->bfOffBits, colorTable);
      // on se positionne au début des données
      input.seekg(bfh->bfOffBits, std::ios::beg);
      for(i = 0; i < _height; i++) {
        for(j = 0; j < _width; j++) {
          // chaque octet représente deux pixels, la valeur stockée correspond
          // à l'index dans la table chromatique
          if((j % 2) == 0) {
            // on lit les octets un par un (pour un pixel sur deux)
            input.read(&c, 1);
            // on prend la valeur des quatres bits de poids fort
            k = c / 16;
          } else {
            // idem pour le deuxième pixel, mais pas besoin de relire l'octet
            // cette fois on veut la valeur des quatres bits de poids faible
            k = c % 16;
          }
          _pixels[4 * (i * _width + j)]     = colorTable[k].rgbRed;
          _pixels[4 * (i * _width + j) + 1] = colorTable[k].rgbGreen;
          _pixels[4 * (i * _width + j) + 2] = colorTable[k].rgbBlue;
          _pixels[4 * (i * _width + j) + 3] = COLOR_MAX;
        }
        input.seekg(bytesToSkip, std::ios::cur);
      }
      delete colorTable;
      break;
    case 1:
      // création et lecture de la table des couleurs
      colorTable = new RGBQUAD[2];
      readBMPColorTable(input, bfh->bfOffBits, colorTable);
      // on se positionne au début des données
      input.seekg(bfh->bfOffBits, std::ios::beg);
      for(i = 0; i < _height; i++) {
        for(j = 0; j < _width; j += 8) {
          // chaque octet représente huit pixels, la valeur stockée correspond
          // à l'index dans la table chromatique
          // on lit les octets un par un
          input.read(&c, 1);
          for(k = 0; k < 8 && 8 * j + k < _width; k++) {
            // on prend la valeur du bit correspondant au pixel
            l = (((1 << (7 - k)) & (((int) c) & 0xff)) > 0);
            _pixels[4 * (i * _width + j + k)]     = colorTable[l].rgbRed;
            _pixels[4 * (i * _width + j + k) + 1] = colorTable[l].rgbGreen;
            _pixels[4 * (i * _width + j + k) + 2] = colorTable[l].rgbBlue;
            _pixels[4 * (i * _width + j + k) + 3] = COLOR_MAX;
          }
        }
        input.seekg(bytesToSkip, std::ios::cur);
      }
      delete colorTable;
      break;
    default:
      std::cerr << filename << " : invalid color depth" << std::endl;
      exit(EXIT_FAILURE);
  }

  // on fait un peut de ménage...
  delete bfh;
  delete bih;
  delete datas;
  input.close();
}

Image::Image(const char* filename) {
  loadBMP(filename);
}

Image::Image(GLuint width, GLuint height) : _width(width), _height(height) {
  int i, size = _width * _height;

  _pixels = new GLubyte[4 * size];
  for(i = 0; i < size; i++) {
    _pixels[i]     = COLOR_MIN;
    _pixels[i + 1] = COLOR_MIN;
    _pixels[i + 2] = COLOR_MIN;
    _pixels[i + 3] = COLOR_MAX;
  }
}

Image::~Image() {
  delete _pixels;
}

GLuint Image::genTexture1D() {
  GLuint tex_name;

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  // création d'une nouvelle texture
  glGenTextures(1, &tex_name);
  // cette texture est maintenant la texture courante
  glBindTexture(GL_TEXTURE_1D, tex_name);
  // association de la texture avec l'image
  glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, _width * _height, 0,
               GL_RGBA, GL_UNSIGNED_BYTE, _pixels);

  // paramètres de la texture
  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

  return tex_name;
}

GLuint Image::genTexture2D() {
  GLuint tex_name;

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  // création d'une nouvelle texture
  glGenTextures(1, &tex_name);
  // cette texture est maintenant la texture courante
  glBindTexture(GL_TEXTURE_2D, tex_name);
  // association de la texture avec l'image
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, _width, _height, 0,
               GL_RGBA, GL_UNSIGNED_BYTE, _pixels);

  // paramètres de la texture
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  return tex_name;
}

---