---

x_tga.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine 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.
//
// The Omicron Engine  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 The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/07 19:02:06 $
// By           :       $Author: kolrabi $
// $Id: x_tga.cpp,v 1.1.1.1 2002/12/07 19:02:06 kolrabi Exp $ 

/*

  $Log: x_tga.cpp,v $
  Revision 1.1.1.1  2002/12/07 19:02:06  kolrabi
  initial release


*/

#include            "omicron/internal.h" 
#include            "omicron/file.h"
#include            "omicron/render.h"
#include            "omicron/image.h" 

/****************************************************************************
 ****************************************************************************
 * VARIABLES ****************************************************************
 ****************************************************************************
 ****************************************************************************/ 
 
// targa image data types 
#define     IDT_RGB     2 
#define     IDT_RGBRLE  10 
 
// vars 
static ulong        _tga_imagedatatype; 
static uchar        _tga_idfieldsize; 
static ulong        _tga_bottomup; 
static ulong        _tga_interleave; 
static long         _tga_dataofs; 
static ulong        _tga_origx,  
                    _tga_origy; 
 
/****************************************************************************
 ****************************************************************************
 * FUNCTIONS ****************************************************************
 ****************************************************************************
 ****************************************************************************/ 

/****************************************************************************
 * _image_load_tga_rgb                 load an uncompressed rgb targa image *
 ****************************************************************************/
bool image_c::load_tga_rgb
(
    file_t   *file                 // the file descriptor of the .tga 
) 
{ 
    AssertReturnValue1(file, false);

    char  *wp;                      // temporary write pointer 
    char  r,g,b,a;                  // temp. vars for reg green blue and alpha
 
    // create buffer 
    buflen = width*height*4; // always 32 bit
    buf    = new char[buflen]; 
 
    if (!buf)  
        return false;

    // set writepointer to beginning 
    wp  = buf; 
 
    // if image is bottomup, goto last line 
    if (_tga_bottomup) 
        wp += buflen-width*4;
 
    // seek to beginning of data 
    gv.fileman->seek( file, _tga_dataofs, SEEK_SET ); 
 
    // read the pixels 
    while( !gv.fileman->eof(file) && wp >= buf && wp < buf+buflen) 
    { 
        gv.fileman->getpixel( file, &r, &g, &b, &a, bpp ); 
     
        *wp = r; wp++; 
        *wp = g; wp++; 
        *wp = b; wp++; 
        *wp = a; wp++; 
 
        if ( _tga_bottomup && (wp-buf) % (width * 4) == 0 ) 
            wp -= width*4*2; 
    }

    bpp = 32;
    gv.fileman->close(file);
    return true; 
} // _load_tga_rgb 

bool image_c::load_tga_rgbrle     // returns a pointer to an image descriptor 
( 
    file_t *file       // the file descriptor of the .tga 
) 
{ 
    AssertReturnValue1(file, false);

    char  *wp;          // temporary write pointer 
    char  r,g,b,a;        // temp. vars for reg green blue and alpha 
    ulong x, y; 
 
    // create buffer 
    buflen = width * height * 4; 
    buf    = new char[buflen]; 
 
    if (!buf)  
        return false;
 
    // seek to beginning of data 
    gv.fileman->seek( file, _tga_dataofs, SEEK_SET ); 
 
    y = x = 0; 
    if (_tga_bottomup) 
        y = height-1; 
 
    wp = buf; 
 
    // read the pixels 
    while(!gv.fileman->eof(file) && y>=0 && y<height) 
    { 
        uchar    h = (uchar)gv.fileman->getch(file); 
        ulong   count; 
 
        count = (h&0x7f)+1; 
 
        if (h&0x80) 
        { 
            gv.fileman->getpixel( file, &r, &g, &b, &a, bpp ); 
 
            for ( ulong i=0; i<count; i++ ) 
            { 
                long ofs = (x+y*width)*4; 
                 
                wp[0+ofs] = r; 
                wp[1+ofs] = g; 
                wp[2+ofs] = b; 
                wp[3+ofs] = a; 
 
                x++; 
 
                if ( x >= width ) 
                { 
                    x %= width; 
                    if (_tga_bottomup) 
                        y--; 
                    else 
                        y++; 
                } 
            } 
 
        } 
        else 
        { 
            for ( ulong i=0; i<count; i++ ) 
            { 
                gv.fileman->getpixel( file, &r, &g, &b, &a, bpp ); 
 
                long ofs = (x+y*width)*4; 
                 
                wp[0+ofs] = r; 
                wp[1+ofs] = g; 
                wp[2+ofs] = b; 
                wp[3+ofs] = a; 
 
                x++; 
 
                if ( x>= width ) 
                { 
                    x %= width; 
                    if (_tga_bottomup) 
                        y--; 
                    else 
                        y++; 
                } 
            } 
 
        } 
    } 
 
    bpp  = 32;
    gv.fileman->close(file);
    return true; 
} // _load_tga_rgb 

 
 
 
// loads a targa file 
bool image_c::load_tga(const char *filename)
{ 
    AssertReturnValue1(filename, false);

    file_t *file = gv.fileman->load(filename, false);

    AssertReturnValue1(file, false);

    SafeArrayDelete(buf);

    gv.fileman->getch(file); 
 
    _tga_idfieldsize    = (uchar)gv.fileman->getch(file); 
    _tga_imagedatatype  = (uchar)gv.fileman->getch(file); 
 
    gv.fileman->seek( file, 8, SEEK_SET ); 

    _tga_origx      = gv.fileman->getch(file) | gv.fileman->getch(file)<<8;
    _tga_origy      = gv.fileman->getch(file) | gv.fileman->getch(file)<<8;

    // get dimensions
    width   = (ushort)gv.fileman->getch(file);
    width  |= (ushort)gv.fileman->getch(file)<<8; 

    height  = (ushort)gv.fileman->getch(file);
    height |= (ushort)gv.fileman->getch(file)<<8; 
 
    bpp     = (char)gv.fileman->getch(file); 
 
    if (bpp == 32) 
        hasalpha = true; 
    else 
        hasalpha = false; 
 
    char bb = (char)gv.fileman->getch(file); 
    _tga_bottomup   = !(bb & 1<<5); 
    _tga_interleave   = bb & 3<<6; 
 
    _tga_dataofs    = 18+_tga_idfieldsize; 

    switch(_tga_imagedatatype) 
    { 
        case IDT_RGB:       return load_tga_rgb( file ); 
        case IDT_RGBRLE:    return load_tga_rgbrle( file ); 
    } 
    return false; 
}

---