Removed MtkImage files

ChangeLog

@@ -6,7 +6,7 @@
  OpenRaider (0.1.2) xythobuz <xythobuz@xythobuz.de>
 
 	[ 20140103 ]
-	* Removed MD3 stuff!
+	* Removed unused MD3, mtk3d, MtkImage stuff!
 
 	[ 20140102 ]
 	* Improved the Mac build steps...

src/MtkImage.cpp

@@ -1,852 +0,0 @@
-/*================================================================
- * 
- * Project : Freyja
- * Author  : Mongoose
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : MtkImage
- * License : GPL See file COPYING, also (C) 2000 Mongoose
- * Comments: This is the new mtkImage class for mtk
- *
- *
- *           This file was generated using Mongoose's C++ 
- *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------- 
- *
- * 2000-10-05:
- * Mongoose - Created
- =================================================================*/
-
-#include "MtkImage.h"
-
-#ifdef DEBUG_MEMEORY
-#   include "memeory_test.h"
-#endif
-
-
-#include <dlfcn.h>
-static const char *mtk_image_module_names[] = {
-  "pcx",
-  "ppm",
-  "tga",
-  "jpeg",
-  "png"
-};
-
-#define MTK_IMAGE_MODULE_NAME_COUNT (sizeof(mtk_image_module_names) / sizeof(mtk_image_module_names[0]))
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-int mtkExtCheck(char *filename, char *ext)
-{
-  unsigned int len_f, len_e;
- 
- 
-  len_f = strlen(filename) - 1;
-  len_e = strlen(ext) - 1;
-
-  while (len_f+1 && len_e+1)
-  {
-    //printf("extcheck: %c %c\n", filename[len_f], ext[len_e]);
-
-    if (filename[len_f] == ext[len_e])
-    {
-      if (ext[len_e] == '.')
-      {
-	//printf("extcheck: match\n");
-	return 0;
-      }
-    }
-    else if (filename[len_f] < ext[len_e])
-      return -1;
-    else if (filename[len_f] > ext[len_e])
-      return 1;
-
-    len_f--;
-    len_e--;
-  }
-
-  return 1;
-}
-
-//////////////////////////////////////////////
-
-MtkImage::MtkImage()
-{
-  _image = NULL;
-  _palette = NULL;
-  _width = 0;             
-  _height = 0;            
-  _original_width = 0;    
-  _original_height = 0;   
-  _color_mode = COLORMODE_RGB;
-  _image_bpp = 0;
-  _palette_bpp = 0;
-}
-
-
-MtkImage::~MtkImage()
-{
-  Clear();
-}
-
-
-void MtkImage::Clear()
-{
-   if (_image)
-      delete [] _image;
-
-   if (_palette)
-      delete [] _palette;
-
-   _width = 0;
-   _height = 0;  
-   _original_width = 0;
-   _original_height = 0;
-   _palette_bpp = 0;
-}
-
-
-int MtkImage::Width()
-{
-  return _width;
-}
-
-
-int MtkImage::Height()
-{
-  return _height;
-}
-
-
-int MtkImage::OriginalWidth()
-{
-  return _original_width;
-}
-
-
-int MtkImage::OriginalHeight()
-{
-  return _original_height;
-}
-
-
-void MtkImage::Mode(mtk_colormode mode)
-{
-  fprintf(stderr, "MtkImage::Mode> ERROR not implemented, %s:%i\n",
-	  __FILE__, __LINE__);
-}
-
-
-//FIXME: Add support for 32bit!
-int MtkImage::PaletteLoad(unsigned char *buffer, int bpp)
-{
-  if (buffer && buffer != _palette && 
-      (bpp == 8 || bpp == 16 || bpp == 24))
-  {
-    if (_palette)
-      delete [] _palette;
-
-    _palette_bpp = bpp;
-
-    _palette = new unsigned char[768];
-    memcpy(_palette, buffer, 768);
-      
-    return 0;
-  }
-
-  printf("MtkImage::LoadPaletteBuffer()> Assertion Error bpp not {8,16,24}\n");
-  return -1;
-}
-
-
-int MtkImage::LoadIndexed(unsigned char *image, int width, int height)
-{
-  int i, size, index;
-
-
-  if (!image || !_palette || !width || !height || image == _image)
-  {
-    printf("MtkImage::LoadIndexedBuffer> Assertion failed\n");
-    return -1;
-  }
-
-  if (_image)
-    delete [] _image;
-
-  size = width * height;
-
-  _width = _original_width = width;
-  _height = _original_height = height;
-  _image = new unsigned char[size * 3];
-
-  _color_mode = COLORMODE_RGB;
-
-  for (i = 0; i < size; i++)
-  {
-    index = image[i];
-
-    if (index * 3 + 2 > 768)
-      printf("Index outside of palette!\n");
-    else
-    {
-      _image[i*3] = _palette[index*3];
-      _image[i*3+1] = _palette[index*3+1];
-      _image[i*3+2] = _palette[index*3+2];
-    }
-  }
-
-  return 0;
-}
-
-void MtkImage::PaletteBrighten(float p)
-{
-  int i;
-
-
-  if (p <= 0.0 || p > 0.999)
-  {
-    printf("MtkImage::BrightenPalette> %f isn't a postive percentage\n", p);
-    return;
-  }
-
-  if (_palette)
-  {
-    for (i = 0; i < 255; i++)
-    {
-      _palette[i*3] += (unsigned char)(_palette[i*3] * p);
-      _palette[i*3+1] += (unsigned char)(_palette[i*3+1] * p);
-      _palette[i*3+2] += (unsigned char)(_palette[i*3+2] * p);
-    }    
-  }
-}
-
-
-void MtkImage::Image(unsigned char **buffer)
-{
-  *buffer = NULL;
-
-  if (!_image)
-  {
-    printf("Image::ImageBuffer> No image allocated\n");
-    return;
-  }
-
-  switch (_color_mode)
-  {
-  case COLORMODE_RGB:
-    *buffer = new unsigned char[_width*_height*3];
-    memcpy(*buffer, _image, _width*_height*3);
-    break;
-  case COLORMODE_RGBA:
-    *buffer = new unsigned char[_width*_height*4];
-    memcpy(*buffer, _image, _width*_height*4);
-    break;
-  case COLORMODE_INDEXED:
-    break;
-  }
-}
-
-
-void MtkImage::Palette(unsigned char **buffer)
-{
-  *buffer = NULL;
-
-  if (!_palette)
-  {
-    printf("Image::PaletteBuffer> No palette allocated\n");
-    return;
-  }
-
-  *buffer = new unsigned char[768];
-  memcpy(*buffer, _palette, 768);
-}
-
-
-void MtkImage::IndexedImage(unsigned char **buffer)
-{
-  int size = _width * _height;
-  float rgb[3];
-  int i;
-
-
-  *buffer = NULL;
-
-  if (!_image || !_palette)
-  {
-    printf("MtkImage::IndexedImage> No image or palette allocated\n");
-    return;
-  }
-
-  *buffer = new unsigned char[size];
-
-  for (i = 0; i < size; i++)
-  {
-    rgb[0] = _image[i*3]/255.0;
-    rgb[1] = _image[i*3+1]/255.0;
-    rgb[2] = _image[i*3+2]/255.0;
-
-    (*buffer)[i] = PaletteMatchColor(rgb);
-  }
-}
-
-void MtkImage::FlipVertical()
-{
-  int i, j;
-  unsigned char *swap_row = NULL;
-
-
-  if (!_image)
-    return;
-
-  switch(_color_mode)
-  {
-  case COLORMODE_INDEXED:
-    // We don't store images as indexed, they're computed
-    break;
-  case COLORMODE_RGB:
-    swap_row = new unsigned char[_width*3];
-
-    for (i = 0, j = _height-1; i < _height/2; i++, j--)
-    {
-      memcpy(swap_row, &_image[i*_width*3], _width*3);
-      memcpy(&_image[i*_width*3], &_image[j*_width*3], _width*3);
-      memcpy(&_image[j*_width*3], swap_row, _width*3);
-    }
-
-    delete [] swap_row;
-    break;
-  case COLORMODE_RGBA:
-    swap_row = new unsigned char[_width*4];
-
-    for (i = 0, j = _height-1; i < _height/2; i++, j--)
-    {
-      memcpy(swap_row, &_image[i*_width*4], _width*4);
-      memcpy(&_image[i*_width*4], &_image[j*_width*4], _width*4);
-      memcpy(&_image[j*_width*4], swap_row, _width*4);
-    }
-
-    delete [] swap_row;
-    break;
-  }
-}
-
-// FIXME: static only for now
-int MtkImage::Load(char *filename)
-{
-  int (*load)(char *filename, unsigned char **image, 
-	      unsigned int *width, unsigned int *height, char *type);
-  int (*check)(char *filename);
-  void *handle;
-  char *error;
-  FILE *f;
-  unsigned int i;
-  char module_filename[128];
-  char module_check[128];
-  char module_load[128];
-  char *name;
-  unsigned char *image;
-  unsigned int w, h;
-  bool loaded = false;
-  char type;
-
-
-  f = fopen(filename, "rb");
-
-  if (!f)
-  {
-    perror("MtkImage::Load> File open failed.\n");
-    return -1;
-  }
-
-  printf("[MtkImage module loader invoked]\n");
-
-  for (i = 0; i < MTK_IMAGE_MODULE_NAME_COUNT && !loaded; i++)
-  {
-    name = (char *)mtk_image_module_names[i];
-
-    snprintf(module_filename, 128, "libmtk_loader-%s.so", name);
-    snprintf(module_load, 128, "mtk_image__%s_load", name);
-    snprintf(module_check, 128, "mtk_image__%s_check", name);
-
-    if (!(handle = dlopen (module_filename, RTLD_NOW))) //RTLD_LAZY)))
-    {
-      fprintf(stderr, "\tERROR: Couldn't find module '%s'.\n", module_filename);
-      return -1;
-    }
-    else
-    {
-      printf("\tModule '%s' opened.\n", module_filename);
-    
-      check = (int (*)(char *filename))dlsym(handle, module_check);
-      
-      load = (int (*)(char * filename, unsigned char **image, 
-		      unsigned int *w, unsigned int *h, 
-		      char *type))dlsym(handle, module_load);
-
-      if ((error = dlerror()) != NULL)  
-      {
-	fprintf (stderr, "\tERROR: %s\n", error);
-	return -5;
-      }
-
-      loaded = (loaded || (!(*check)(filename) && 
-			   !(*load)(filename, &image, &w, &h, &type)));
-
-      if ((error = dlerror()) != NULL) 
-	return -10;
-     
-      dlclose(handle);
-    }
-  }
-
-
-  if (loaded)
-  {
-    Clear();
-
-    _image = image;
-    _original_width = _width = w;
-    _original_height = _height = h;
-
-    switch (type)
-    {
-    case 4:
-    case 2:
-      _color_mode = COLORMODE_RGBA;
-      break;
-    default:
-      _color_mode = COLORMODE_RGB;
-    }
-    return 0;
-  }
-  else
-    return -2;
-}
-
-int MtkImage::Save(char *filename, char *format)
-{
-  extern int mtk_image__tga_save(FILE *f, unsigned char *image,
-				 unsigned int width, unsigned int height, 
-				 char bpp);
-  FILE *f;
-  int ret;
-  
-
-  f = fopen(filename, "wb");
-
-
-  ret = mtk_image__tga_save(f, _image, _width, _height, _color_mode+1);
-
-  if (f)
-    fclose(f);
-
-  return ret;
-}
-
-
-int MtkImage::Load(unsigned char *image, unsigned int w, unsigned int h,
-	 mtk_colormode mode)
-{
-  switch (mode)
-  {
-  case COLORMODE_INDEXED:
-    return LoadIndexed(image, w, h);
-    break;
-  case COLORMODE_RGB:
-    if (!image || !w || !h || image == _image)
-      return -1;  
-
-    _width = _original_width = w;
-    _height = _original_height = h;
-
-    if (_image)
-      delete [] _image;
-
-    _color_mode = COLORMODE_RGB;
-
-    _image = new unsigned char[w * h * 3];
-    memcpy(_image, image, w * h * 3);
-
-    return 0;
-    break;
-  case COLORMODE_RGBA:
-    if (!image || !w || !h || image == _image)
-      return -1;  
-
-    _width = _original_width = w;
-    _height = _original_height = h;
-
-    if (_image)
-      delete [] _image;
-
-    _color_mode = COLORMODE_RGBA;
-
-    _image = new unsigned char[w * h * 4];
-    memcpy(_image, image, w * h * 4);
-
-    return 0;
-    break;
-  }
-
-  return -1;
-}
-
-
-// Palette ////////////////////////////////////////////
-
-// Search palette for matching ( or closest ) rgb color
-// Colors *must be 0.0 to 1.0 form!
-//
-// Note if you have a small palette this may 'wash' to black
-// quickly after running through a few times ( 0.0 is default )
-int MtkImage::PaletteMatchColor(float rgb[3])
-{
-  float color[3];
-  float best_weight, current_weight;
-  int i, best;
-
-
-  if (!_palette)
-  {
-    printf("MtkImage::MatchColor> ERROR no palette loaded\n");
-    return -1;
-  }
-
-  best_weight = current_weight = 0.0;
-  
-  for (best = 0, i = 0; i < 256; i++)
-  {
-    // Convert from 0-255 to 0.0-1.0 color scale
-    PaletteColor(i, color);
-    //color[0] = _palette[i*3]/255.0;
-    //color[1] = _palette[i*3+1]/255.0;
-    //color[2] = _palette[i*3+2]/255.0;
-
-    // FIXME: Should be 0.0 (far off) to 1.0 (exact match)
-    current_weight = 1.0 - ((fabs(rgb[0] - color[0]) + 
-			     fabs(rgb[1] - color[1]) + 
-			     fabs(rgb[2] - color[2])) / 3.0);
-
-    if (current_weight > best_weight)
-    {
-      best_weight = current_weight;
-      best = i;
-
-      if (best_weight == 1.0)
-	i = 1024; // break;
-    }
-  }
-
-  return best;
-}
-
-void MtkImage::PaletteColor(int i, float rgb[3])
-{
-  if (i > 0 && i < 256 && rgb && _palette)
-  {
-    rgb[0] = (float)_palette[i*3]/255.0;
-    rgb[1] = (float)_palette[i*3+1]/255.0;
-    rgb[2] = (float)_palette[i*3+2]/255.0;
-  }
-}	
-
-
-int MtkImage::PaletteLoadLMP(char *filename)
-{
-  FILE *f;
-	
-
-  f = fopen(filename, "rb");
-
-  if (f)
-  {
-    if (!_palette)
-      _palette = new unsigned char[768];
-
-    fread(_palette, 1, 768, f);
-    fclose(f);
-    return 0;
-  }
-
-  return -1;
-}
-
-int MtkImage::PaletteLoad(char *filename)
-{
-  FILE *f;
-  int i;
-  unsigned int rgb[3];
-
-
-  if (!filename)
-    return -1;
-
-  f = fopen(filename, "r");
-
-  if (f)
-  {
-    if (_palette)
-      delete [] _palette;
-
-    _palette = new unsigned char[768];
-
-    for (i = 0; i < 768; i+=3)
-    {
-      fscanf(f, "%u %u %u\n", 
-	     &rgb[0],
-	     &rgb[1],
-	     &rgb[2]);
-
-      _palette[i]   = rgb[0];
-      _palette[i+1] = rgb[1];
-      _palette[i+2] = rgb[2];
-    }
-    
-    fclose(f);
-    return 0;
-  }
-
-  return 1;
-}
-
-int MtkImage::PaletteSave(char *filename)
-{
-  FILE *f;
-  int i;
-
-
-  if (!_palette || !filename)
-    return -1;
-
-  f = fopen(filename, "w");
-
-  if (f)
-  {
-    for (i = 0; i < 768; i+=3)
-    {
-      fprintf(f, "%i %i %i\n", 
-	      (int)_palette[i], 
-	      (int)_palette[i+1], 
-	      (int)_palette[i+2]);
-    }
-    
-    fclose(f);
-    return 0;
-  }
-
-  return 1;
-}
-
-mtk_colormode MtkImage::Mode()
-{
-  return _color_mode;
-}
-
-
-/* This code based off on gluScaleImage()  */
-void MtkImage::Scale()
-{
-   int i, j, k;
-   float* tempin;
-   float* tempout;
-   float sx, sy;
-   int components = 3;
-   unsigned char *image;
-
-
-   if (!_image || !_width || !_height)
-     return;
-
-   _height = NextPower(_height);
-   _width = NextPower(_width);
-
-   if (_height > 256) 
-     _height = 256;
-    
-   if (_width > 256) 
-     _width = 256;
-    
-
-   // Check to see if scaling is needed
-   if (_height == _original_height && _width == _original_width) 
-     return;
-
-   image = new unsigned char[_height * _width * 3];
-
-   tempin = new float[_original_width * _original_height * 
-		      components * sizeof(float)];
-   tempout = new float[_width * _height * components * sizeof(float)];
-
-   if (!tempout || !tempin)
-   {
-     if (tempout)
-       delete [] tempout;
-
-     if (tempin)
-       delete [] tempin;
-
-     printf("Oh shit out of memory!\n");
-     return;
-   }
-
-   // Copy user data to float format.
-   for (i = 0; i < _original_height * _original_width * components; i++) 
-   {
-     tempin[i] = (float)_image[i];
-   }
-
-   // Determine which filter to use by checking ratios.
-   if (_width > 1) 
-   {
-     sx = (float)(_original_width - 1) / (float)(_width - 1);
-   } 
-   else 
-   {
-     sx = (float)(_original_width - 1);
-   }
-
-   if (_height > 1)
-   {
-     sy = (float)(_original_height - 1) / (float) (_height - 1);
-   } 
-   else 
-   {
-     sy = (float)(_original_height - 1);
-   }
-
-   if (sx < 1.0 && sy < 1.0) 
-   {
-     /* Magnify both width and height:  use weighted sample of 4 pixels */
-     int i0, i1, j0, j1;
-     float alpha, beta;
-     float* src00;
-     float* src01;
-     float* src10;
-     float* src11;
-     float s1, s2;
-     float* dst;
-
-     for(i = 0; i < _height; i++) 
-     {
-       i0 = (int)(i * sy);
-       i1 = i0 + 1;
-
-       if (i1 >= _original_height) 
-       {
-	 i1 = _original_height - 1;
-       }
-
-       alpha = i * sy - i0;
-
-       for (j = 0; j < _width; j++) 
-       {
-	 j0 = (int) (j * sx);
-	 j1 = j0 + 1;
-
-	 if (j1 >= _original_width) 
-	 {
-	   j1 = _original_width - 1;
-	 }
-
-	 beta = j * sx - j0;
-
-	 /* Compute weighted average of pixels in rect (i0,j0)-(i1,j1) */
-	 src00 = tempin + (i0 * _original_width + j0) * components;
-	 src01 = tempin + (i0 * _original_width + j1) * components;
-	 src10 = tempin + (i1 * _original_width + j0) * components;
-	 src11 = tempin + (i1 * _original_width + j1) * components;
-
-	 dst = tempout + (i * _width + j) * components;
-
-	 for (k = 0; k < components; k++) 
-	 {
-	   s1 = *src00++ * (1.0 - beta) + *src01++ * beta;
-	   s2 = *src10++ * (1.0 - beta) + *src11++ * beta;
-	   *dst++ = s1 * (1.0 - alpha) + s2 * alpha;
-	 } 
-       }
-     }     
-   }
-   else 
-   {
-     /* Shrink width and/or height:  use an unweighted box filter */
-     int i0, i1;
-     int j0, j1;
-     int ii, jj;
-     float sum;
-     float* dst;
-
-     for (i = 0; i < _height; i++) 
-     {
-       i0 = (int) (i * sy);
-       i1 = i0 + 1;
-
-       if (i1 >= _original_height) 
-       {
-	 i1 = _original_height - 1;
-       }
-
-       for (j = 0; j < _width; j++) 
-       {
-	 j0 = (int) (j * sx);
-	 j1 = j0 + 1;
-
-	 if (j1 >= _original_width) 
-	 {
-	   j1 = _original_width - 1;
-	 }
-
-	 dst = tempout + (i * _width + j) * components;
-
-	 /* Compute average of pixels in the rectangle (i0,j0)-(i1,j1) */
-	 for (k = 0; k < components; k++) 
-	 {
-	   sum = 0.0;
-
-	   for (ii = i0; ii <= i1; ii++) 
-	   {
-	     for (jj = j0; jj <= j1; jj++) 
-	     {
-	       sum += *(tempin + (ii * _original_width + jj) 
-			* components + k);
-	     }
-	   }
-
-	   sum /= ( j1 - j0 + 1 ) * ( i1 - i0 + 1 );
-	   *dst++ = sum;
-	 }
-       } 
-     }
-   }
-
-   // Copy to our results.
-   for( i = 0; i < _height * _width * components; i++ ) 
-   {
-     image[i] = (unsigned char) tempout[i];
-   }
-
-   // Delete our temp buffers.
-   delete[] tempin;
-   delete[] tempout;
-   delete[] _image;
-
-   _image = image;
-}
-
-int MtkImage::NextPower(int seed)
-{
-  int i;
-
-  for(i = 1; i < seed; i *= 2) 
-    ;
-
-  return i;
-}
-
-
-

src/MtkImage.h

@@ -1,243 +0,0 @@
-/*================================================================
- * 
- * Project : Freyja
- * Author  : Mongoose
- * Website : http://www.westga.edu/~stu7440/
- * Email   : stu7440@westga.edu
- * Object  : MtkImage
- * License : GPL See file COPYING, also (C) 2000 Mongoose
- * Comments: This is the mtkImage agent/class for mtk
- *
- *
- *           This file was generated using Mongoose's C++ 
- *           template generator script.  <stu7440@westga.edu>
- * 
- *-- History ------------------------------------------------ 
- *
- * 2000-10-05:
- * Mongoose - Created
- ================================================================*/
-
-
-#ifndef __MTK_MONGOOSE_MTKIMAGE_H_
-#define __MTK_MONGOOSE_MTKIMAGE_H_
-
-#include <stdio.h>
-
-typedef enum mtk_colormode
-{
-  COLORMODE_INDEXED = 1, 
-  COLORMODE_RGB     = 2, 
-  COLORMODE_RGBA    = 3
-};
-
-int mtkExtCheck(char *filename, char *ext);
-
-class MtkImage
-{
- public:
-
-  MtkImage();
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : None
-   * Post : MtkImage agent is constructed
-   --------------------------------------------*/
-
-  ~MtkImage();
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : MtkImage agent is allocated
-   * Post : MtkImage agent is deconstructed
-   --------------------------------------------*/
-
-   void Clear();
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : None
-   * Post : MtkImage agent's data is reset to 
-   *        initial state
-   --------------------------------------------*/
-
-   int Width();
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : None
-   * Post : Returns image width
-   --------------------------------------------*/
-
-   int Height();
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : None
-   * Post : Returns image height
-   --------------------------------------------*/
-
-   int OriginalWidth();
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : None
-   * Post : Returns image width before transforms
-   --------------------------------------------*/
-
-   int OriginalHeight();
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : None
-   * Post : Returns image height before transforms
-   --------------------------------------------*/
-
-   void Mode(mtk_colormode mode);
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : mode is an mtk_colormode
-   * 
-   *        NOTE: You can't set to an indexed mode
-   *        since they are computed per palette
-   * 
-   * Post : Converts image into a new color mode
-   *        if not in that mode already
-   --------------------------------------------*/
-
-   void Image(unsigned char **image);
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : image must be an unallocated pointer
-   *
-   * Post : Returns a copy of the image buffer
-   *        in mode, or NULL if unable
-   --------------------------------------------*/
-
-   void IndexedImage(unsigned char **image);
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : image must be an unallocated pointer
-   *        A palette must have been loaded
-   *
-   * Post : Returns a copy of a computed
-   *        indexed image
-   --------------------------------------------*/
-
-   int Load(unsigned char *image, unsigned int width, unsigned int height, 
-	    mtk_colormode mode);
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : image must be valid
-   *        width and height must be valid
-   *        mode must be valid
-   *
-   *        1. Palettes must be loaded to make
-   *           a computed INDEXED mode image
-   *
-   * Post : Loads image of type mode
-   --------------------------------------------*/
-
-   void Palette(unsigned char **buffer);
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : buffer must be an unallocated pointer
-   * Post : Returns a copy of the palette buffer
-   --------------------------------------------*/
-
-   int PaletteMatchColor(float rgb[3]);
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : rgb is a color as defined as an
-   *        array of Red Green and Blue with
-   *        colors ranged 0.0 to 1.0
-   *
-   * Post : Returns closest matched color index
-   *        it can find in a loaded palette
-   *
-   *        NOTE: tends to lean to darker shades
-   --------------------------------------------*/
-
-   //////////////////////////////////////////////
-   int Load(char *filename);
-   int Save(char *filename, char *format);
-
-   int PaletteLoad(unsigned char *filename, int bpp);
-   int PaletteSave(char *filename);
-   int PaletteLoad(char *filename);
-   int PaletteLoadLMP(char *filename);
-   //////////////////////////////////////////////
-
-   void Scale();
-   void PaletteBrighten(float p);
-   void PaletteGamma(float b);
-   void PaletteColor(int i, float rgb[3]);
-   void FlipVertical();
-   mtk_colormode Mode();
-
- private:
-
-   int LoadIndexed(unsigned char *image, int width, int height);
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : image must be valid indexed image
-   *        width must be valid
-   *        height must be valid
-   *        pallette must have been previously
-   *        loaded
-   *
-   * Post : Loads indexed image using previously
-   *        loaded pallette
-   --------------------------------------------*/
-
-   int NextPower(int seed);
-  /*--------------------------------------------
-   * Created  : 2000-10-05 by Mongoose
-   * Modified : 
-   *
-   * Pre  : seed is valid ( last power )
-   * Post : Returns next power of 2
-   --------------------------------------------*/
-
-   unsigned char *_image;                 /* Image buffer */
-
-   unsigned char *_palette;               /* Image palette */
-
-   int _width;                            /* Width of image */
-
-   int _height;                           /* Height of image */
-
-   int _original_width;                   /* Width before transforms */
-
-   int _original_height;                  /* Height before transforms */
-
-   enum mtk_colormode _color_mode;        /* Color mode of image */
-
-   int _image_bpp;                        /* Color depth of image */ 
-
-   int _palette_bpp;                      /* Color depth of palette */
-};
-
-#endif