157 lines
3.4 KiB
C++
157 lines
3.4 KiB
C++
/*
|
|
Copyright (C) 2001-2006, William Joseph.
|
|
All Rights Reserved.
|
|
|
|
This file is part of GtkRadiant.
|
|
|
|
GtkRadiant 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.
|
|
|
|
GtkRadiant 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 GtkRadiant; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "mdlimage.h"
|
|
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "ifilesystem.h"
|
|
#include "bytestreamutils.h"
|
|
|
|
#include "stream/textstream.h"
|
|
#include "imagelib.h"
|
|
|
|
#include "mdlformat.h"
|
|
#include "ident.h"
|
|
|
|
|
|
unsigned char mdl_palette[768];
|
|
/*
|
|
==============
|
|
Texture_InitPalette
|
|
==============
|
|
*/
|
|
void Texture_InitPalette( byte *pal ){
|
|
int r,g,b;
|
|
int i;
|
|
int inf;
|
|
byte gammatable[256];
|
|
double gamma;
|
|
|
|
gamma = 1.0; //g_qeglobals.d_savedinfo.fGamma;
|
|
|
|
if ( gamma == 1.0 ) {
|
|
for ( i = 0; i < 256; i++ )
|
|
gammatable[i] = i;
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0; i < 256; i++ )
|
|
{
|
|
inf = (int)( 255 * pow( ( i + 0.5 ) / 255.5, gamma ) + 0.5 );
|
|
if ( inf < 0 ) {
|
|
inf = 0;
|
|
}
|
|
if ( inf > 255 ) {
|
|
inf = 255;
|
|
}
|
|
gammatable[i] = inf;
|
|
}
|
|
}
|
|
|
|
for ( i = 0; i < 256; i++ )
|
|
{
|
|
r = gammatable[pal[0]];
|
|
g = gammatable[pal[1]];
|
|
b = gammatable[pal[2]];
|
|
pal += 3;
|
|
|
|
//v = (r<<24) + (g<<16) + (b<<8) + 255;
|
|
//v = BigLong (v);
|
|
|
|
//mdl_palette[i] = v;
|
|
mdl_palette[i * 3 + 0] = r;
|
|
mdl_palette[i * 3 + 1] = g;
|
|
mdl_palette[i * 3 + 2] = b;
|
|
}
|
|
}
|
|
|
|
bool LoadPalette(){
|
|
unsigned char* buffer;
|
|
//int len =
|
|
vfsLoadFile( "gfx/palette.lmp", (void **) &buffer );
|
|
if ( buffer == 0 ) {
|
|
return false;
|
|
}
|
|
|
|
Texture_InitPalette( buffer );
|
|
|
|
vfsFreeFile( buffer );
|
|
|
|
return true;
|
|
}
|
|
|
|
Image* LoadMDLImageBuff( byte* buffer ){
|
|
if ( !LoadPalette() ) {
|
|
return 0;
|
|
}
|
|
|
|
if ( !ident_equal( buffer, MDL_IDENT ) ) {
|
|
globalErrorStream() << "LoadMDLImage: data has wrong ident\n";
|
|
return 0;
|
|
}
|
|
|
|
PointerInputStream inputStream( buffer );
|
|
inputStream.seek( 4 + 4 + 12 + 12 + 4 + 12 );
|
|
//int numskins =
|
|
istream_read_int32_le( inputStream );
|
|
int skinwidth = istream_read_int32_le( inputStream );
|
|
int skinheight = istream_read_int32_le( inputStream );
|
|
inputStream.seek( 4 + 4 + 4 + 4 + 4 + 4 );
|
|
|
|
switch ( istream_read_int32_le( inputStream ) )
|
|
{
|
|
case MDL_SKIN_SINGLE:
|
|
break;
|
|
case MDL_SKIN_GROUP:
|
|
int numskins = istream_read_int32_le( inputStream );
|
|
inputStream.seek( numskins * 4 );
|
|
break;
|
|
}
|
|
|
|
RGBAImage* image = new RGBAImage( skinwidth, skinheight );
|
|
unsigned char* pRGBA = image->getRGBAPixels();
|
|
|
|
for ( int i = 0; i < ( skinheight ); i++ )
|
|
{
|
|
for ( int j = 0; j < ( skinwidth ); j++ )
|
|
{
|
|
byte index = istream_read_byte( inputStream );
|
|
*pRGBA++ = mdl_palette[index * 3 + 0];
|
|
*pRGBA++ = mdl_palette[index * 3 + 1];
|
|
*pRGBA++ = mdl_palette[index * 3 + 2];
|
|
*pRGBA++ = 255;
|
|
}
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
Image* LoadMDLImage( ArchiveFile& file ){
|
|
ScopedArchiveBuffer buffer( file );
|
|
return LoadMDLImageBuff( buffer.buffer );
|
|
}
|
|
|
|
void MDLImage_Destroy( byte* pic ){
|
|
free( pic );
|
|
}
|