Move some things into renderercommon
This commit is contained in:
Tim Angus
parent
372b07a97a
commit
93e6183ce3
7
Makefile
7
Makefile
|
|
@ -211,6 +211,7 @@ BD=$(BUILD_DIR)/debug-$(PLATFORM)-$(ARCH)
|
||||||
BR=$(BUILD_DIR)/release-$(PLATFORM)-$(ARCH)
|
BR=$(BUILD_DIR)/release-$(PLATFORM)-$(ARCH)
|
||||||
CDIR=$(MOUNT_DIR)/client
|
CDIR=$(MOUNT_DIR)/client
|
||||||
SDIR=$(MOUNT_DIR)/server
|
SDIR=$(MOUNT_DIR)/server
|
||||||
|
RCOMMONDIR=$(MOUNT_DIR)/renderercommon
|
||||||
RGL1DIR=$(MOUNT_DIR)/renderergl1
|
RGL1DIR=$(MOUNT_DIR)/renderergl1
|
||||||
RGL2DIR=$(MOUNT_DIR)/renderergl2
|
RGL2DIR=$(MOUNT_DIR)/renderergl2
|
||||||
CMDIR=$(MOUNT_DIR)/qcommon
|
CMDIR=$(MOUNT_DIR)/qcommon
|
||||||
|
|
@ -2355,6 +2356,9 @@ $(B)/renderergl1/%.o: $(SDLDIR)/%.c
|
||||||
$(B)/renderergl1/%.o: $(JPDIR)/%.c
|
$(B)/renderergl1/%.o: $(JPDIR)/%.c
|
||||||
$(DO_REF_CC)
|
$(DO_REF_CC)
|
||||||
|
|
||||||
|
$(B)/renderergl1/%.o: $(RCOMMONDIR)/%.c
|
||||||
|
$(DO_REF_CC)
|
||||||
|
|
||||||
$(B)/renderergl1/%.o: $(RGL1DIR)/%.c
|
$(B)/renderergl1/%.o: $(RGL1DIR)/%.c
|
||||||
$(DO_REF_CC)
|
$(DO_REF_CC)
|
||||||
|
|
||||||
|
|
@ -2364,6 +2368,9 @@ $(B)/renderergl2/glsl/%.c: $(RGL2DIR)/glsl/%.glsl
|
||||||
$(B)/renderergl2/glsl/%.o: $(B)/renderergl2/glsl/%.c
|
$(B)/renderergl2/glsl/%.o: $(B)/renderergl2/glsl/%.c
|
||||||
$(DO_REF_CC)
|
$(DO_REF_CC)
|
||||||
|
|
||||||
|
$(B)/renderergl2/%.o: $(RCOMMONDIR)/%.c
|
||||||
|
$(DO_REF_CC)
|
||||||
|
|
||||||
$(B)/renderergl2/%.o: $(RGL2DIR)/%.c
|
$(B)/renderergl2/%.o: $(RGL2DIR)/%.c
|
||||||
$(DO_REF_CC)
|
$(DO_REF_CC)
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -20,7 +20,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||||
===========================================================================
|
===========================================================================
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "tr_local.h"
|
#include "../renderergl1/tr_local.h"
|
||||||
|
|
||||||
typedef struct
|
typedef struct
|
||||||
{
|
{
|
||||||
|
|
@ -20,7 +20,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||||
===========================================================================
|
===========================================================================
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "tr_local.h"
|
#include "../renderergl1/tr_local.h"
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Include file for users of JPEG library.
|
* Include file for users of JPEG library.
|
||||||
|
|
@ -21,7 +21,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||||
===========================================================================
|
===========================================================================
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "tr_local.h"
|
#include "../renderergl1/tr_local.h"
|
||||||
|
|
||||||
/*
|
/*
|
||||||
========================================================================
|
========================================================================
|
||||||
|
|
@ -19,7 +19,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||||
===========================================================================
|
===========================================================================
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "tr_local.h"
|
#include "../renderergl1/tr_local.h"
|
||||||
|
|
||||||
#include "../qcommon/puff.h"
|
#include "../qcommon/puff.h"
|
||||||
|
|
||||||
|
|
@ -20,7 +20,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||||
===========================================================================
|
===========================================================================
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "tr_local.h"
|
#include "../renderergl1/tr_local.h"
|
||||||
|
|
||||||
/*
|
/*
|
||||||
========================================================================
|
========================================================================
|
||||||
|
|
@ -20,7 +20,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||||
===========================================================================
|
===========================================================================
|
||||||
*/
|
*/
|
||||||
// tr_noise.c
|
// tr_noise.c
|
||||||
#include "tr_local.h"
|
#include "../renderergl1/tr_local.h"
|
||||||
|
|
||||||
#define NOISE_SIZE 256
|
#define NOISE_SIZE 256
|
||||||
#define NOISE_MASK ( NOISE_SIZE - 1 )
|
#define NOISE_MASK ( NOISE_SIZE - 1 )
|
||||||
|
|
@ -1,243 +0,0 @@
|
||||||
/*
|
|
||||||
===========================================================================
|
|
||||||
Copyright (C) 1999-2005 Id Software, Inc.
|
|
||||||
|
|
||||||
This file is part of Quake III Arena source code.
|
|
||||||
|
|
||||||
Quake III Arena source code 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.
|
|
||||||
|
|
||||||
Quake III Arena source code 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 Quake III Arena source code; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
===========================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "../qcommon/q_shared.h"
|
|
||||||
#include "../qcommon/qfiles.h"
|
|
||||||
#include "../qcommon/qcommon.h"
|
|
||||||
#include "../renderercommon/tr_public.h"
|
|
||||||
extern refimport_t ri;
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
char id[2];
|
|
||||||
unsigned fileSize;
|
|
||||||
unsigned reserved0;
|
|
||||||
unsigned bitmapDataOffset;
|
|
||||||
unsigned bitmapHeaderSize;
|
|
||||||
unsigned width;
|
|
||||||
unsigned height;
|
|
||||||
unsigned short planes;
|
|
||||||
unsigned short bitsPerPixel;
|
|
||||||
unsigned compression;
|
|
||||||
unsigned bitmapDataSize;
|
|
||||||
unsigned hRes;
|
|
||||||
unsigned vRes;
|
|
||||||
unsigned colors;
|
|
||||||
unsigned importantColors;
|
|
||||||
unsigned char palette[256][4];
|
|
||||||
} BMPHeader_t;
|
|
||||||
|
|
||||||
void R_LoadBMP( const char *name, byte **pic, int *width, int *height )
|
|
||||||
{
|
|
||||||
int columns, rows;
|
|
||||||
unsigned numPixels;
|
|
||||||
byte *pixbuf;
|
|
||||||
int row, column;
|
|
||||||
byte *buf_p;
|
|
||||||
byte *end;
|
|
||||||
union {
|
|
||||||
byte *b;
|
|
||||||
void *v;
|
|
||||||
} buffer;
|
|
||||||
int length;
|
|
||||||
BMPHeader_t bmpHeader;
|
|
||||||
byte *bmpRGBA;
|
|
||||||
|
|
||||||
*pic = NULL;
|
|
||||||
|
|
||||||
if(width)
|
|
||||||
*width = 0;
|
|
||||||
|
|
||||||
if(height)
|
|
||||||
*height = 0;
|
|
||||||
|
|
||||||
//
|
|
||||||
// load the file
|
|
||||||
//
|
|
||||||
length = ri.FS_ReadFile( ( char * ) name, &buffer.v);
|
|
||||||
if (!buffer.b || length < 0) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (length < 54)
|
|
||||||
{
|
|
||||||
ri.Error( ERR_DROP, "LoadBMP: header too short (%s)", name );
|
|
||||||
}
|
|
||||||
|
|
||||||
buf_p = buffer.b;
|
|
||||||
end = buffer.b + length;
|
|
||||||
|
|
||||||
bmpHeader.id[0] = *buf_p++;
|
|
||||||
bmpHeader.id[1] = *buf_p++;
|
|
||||||
bmpHeader.fileSize = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.reserved0 = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.bitmapDataOffset = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.bitmapHeaderSize = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.width = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.height = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.planes = LittleShort( * ( short * ) buf_p );
|
|
||||||
buf_p += 2;
|
|
||||||
bmpHeader.bitsPerPixel = LittleShort( * ( short * ) buf_p );
|
|
||||||
buf_p += 2;
|
|
||||||
bmpHeader.compression = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.bitmapDataSize = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.hRes = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.vRes = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.colors = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
bmpHeader.importantColors = LittleLong( * ( int * ) buf_p );
|
|
||||||
buf_p += 4;
|
|
||||||
|
|
||||||
if ( bmpHeader.bitsPerPixel == 8 )
|
|
||||||
{
|
|
||||||
if (buf_p + sizeof(bmpHeader.palette) > end)
|
|
||||||
ri.Error( ERR_DROP, "LoadBMP: header too short (%s)", name );
|
|
||||||
|
|
||||||
Com_Memcpy( bmpHeader.palette, buf_p, sizeof( bmpHeader.palette ) );
|
|
||||||
buf_p += sizeof(bmpHeader.palette);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (buffer.b + bmpHeader.bitmapDataOffset > end)
|
|
||||||
{
|
|
||||||
ri.Error( ERR_DROP, "LoadBMP: invalid offset value in header (%s)", name );
|
|
||||||
}
|
|
||||||
|
|
||||||
buf_p = buffer.b + bmpHeader.bitmapDataOffset;
|
|
||||||
|
|
||||||
if ( bmpHeader.id[0] != 'B' && bmpHeader.id[1] != 'M' )
|
|
||||||
{
|
|
||||||
ri.Error( ERR_DROP, "LoadBMP: only Windows-style BMP files supported (%s)", name );
|
|
||||||
}
|
|
||||||
if ( bmpHeader.fileSize != length )
|
|
||||||
{
|
|
||||||
ri.Error( ERR_DROP, "LoadBMP: header size does not match file size (%u vs. %u) (%s)", bmpHeader.fileSize, length, name );
|
|
||||||
}
|
|
||||||
if ( bmpHeader.compression != 0 )
|
|
||||||
{
|
|
||||||
ri.Error( ERR_DROP, "LoadBMP: only uncompressed BMP files supported (%s)", name );
|
|
||||||
}
|
|
||||||
if ( bmpHeader.bitsPerPixel < 8 )
|
|
||||||
{
|
|
||||||
ri.Error( ERR_DROP, "LoadBMP: monochrome and 4-bit BMP files not supported (%s)", name );
|
|
||||||
}
|
|
||||||
|
|
||||||
switch ( bmpHeader.bitsPerPixel )
|
|
||||||
{
|
|
||||||
case 8:
|
|
||||||
case 16:
|
|
||||||
case 24:
|
|
||||||
case 32:
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
ri.Error( ERR_DROP, "LoadBMP: illegal pixel_size '%hu' in file '%s'", bmpHeader.bitsPerPixel, name );
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
columns = bmpHeader.width;
|
|
||||||
rows = bmpHeader.height;
|
|
||||||
if ( rows < 0 )
|
|
||||||
rows = -rows;
|
|
||||||
numPixels = columns * rows;
|
|
||||||
|
|
||||||
if(columns <= 0 || !rows || numPixels > 0x1FFFFFFF // 4*1FFFFFFF == 0x7FFFFFFC < 0x7FFFFFFF
|
|
||||||
|| ((numPixels * 4) / columns) / 4 != rows)
|
|
||||||
{
|
|
||||||
ri.Error (ERR_DROP, "LoadBMP: %s has an invalid image size", name);
|
|
||||||
}
|
|
||||||
if(buf_p + numPixels*bmpHeader.bitsPerPixel/8 > end)
|
|
||||||
{
|
|
||||||
ri.Error (ERR_DROP, "LoadBMP: file truncated (%s)", name);
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( width )
|
|
||||||
*width = columns;
|
|
||||||
if ( height )
|
|
||||||
*height = rows;
|
|
||||||
|
|
||||||
bmpRGBA = ri.Malloc( numPixels * 4 );
|
|
||||||
*pic = bmpRGBA;
|
|
||||||
|
|
||||||
|
|
||||||
for ( row = rows-1; row >= 0; row-- )
|
|
||||||
{
|
|
||||||
pixbuf = bmpRGBA + row*columns*4;
|
|
||||||
|
|
||||||
for ( column = 0; column < columns; column++ )
|
|
||||||
{
|
|
||||||
unsigned char red, green, blue, alpha;
|
|
||||||
int palIndex;
|
|
||||||
unsigned short shortPixel;
|
|
||||||
|
|
||||||
switch ( bmpHeader.bitsPerPixel )
|
|
||||||
{
|
|
||||||
case 8:
|
|
||||||
palIndex = *buf_p++;
|
|
||||||
*pixbuf++ = bmpHeader.palette[palIndex][2];
|
|
||||||
*pixbuf++ = bmpHeader.palette[palIndex][1];
|
|
||||||
*pixbuf++ = bmpHeader.palette[palIndex][0];
|
|
||||||
*pixbuf++ = 0xff;
|
|
||||||
break;
|
|
||||||
case 16:
|
|
||||||
shortPixel = * ( unsigned short * ) pixbuf;
|
|
||||||
pixbuf += 2;
|
|
||||||
*pixbuf++ = ( shortPixel & ( 31 << 10 ) ) >> 7;
|
|
||||||
*pixbuf++ = ( shortPixel & ( 31 << 5 ) ) >> 2;
|
|
||||||
*pixbuf++ = ( shortPixel & ( 31 ) ) << 3;
|
|
||||||
*pixbuf++ = 0xff;
|
|
||||||
break;
|
|
||||||
|
|
||||||
case 24:
|
|
||||||
blue = *buf_p++;
|
|
||||||
green = *buf_p++;
|
|
||||||
red = *buf_p++;
|
|
||||||
*pixbuf++ = red;
|
|
||||||
*pixbuf++ = green;
|
|
||||||
*pixbuf++ = blue;
|
|
||||||
*pixbuf++ = 255;
|
|
||||||
break;
|
|
||||||
case 32:
|
|
||||||
blue = *buf_p++;
|
|
||||||
green = *buf_p++;
|
|
||||||
red = *buf_p++;
|
|
||||||
alpha = *buf_p++;
|
|
||||||
*pixbuf++ = red;
|
|
||||||
*pixbuf++ = green;
|
|
||||||
*pixbuf++ = blue;
|
|
||||||
*pixbuf++ = alpha;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
ri.FS_FreeFile( buffer.v );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
@ -1,441 +0,0 @@
|
||||||
/*
|
|
||||||
===========================================================================
|
|
||||||
Copyright (C) 1999-2005 Id Software, Inc.
|
|
||||||
|
|
||||||
This file is part of Quake III Arena source code.
|
|
||||||
|
|
||||||
Quake III Arena source code 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.
|
|
||||||
|
|
||||||
Quake III Arena source code 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 Quake III Arena source code; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
===========================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "../qcommon/q_shared.h"
|
|
||||||
#include "../qcommon/qfiles.h"
|
|
||||||
#include "../qcommon/qcommon.h"
|
|
||||||
#include "../renderercommon/tr_public.h"
|
|
||||||
extern refimport_t ri;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Include file for users of JPEG library.
|
|
||||||
* You will need to have included system headers that define at least
|
|
||||||
* the typedefs FILE and size_t before you can include jpeglib.h.
|
|
||||||
* (stdio.h is sufficient on ANSI-conforming systems.)
|
|
||||||
* You may also wish to include "jerror.h".
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifdef USE_INTERNAL_JPEG
|
|
||||||
# define JPEG_INTERNALS
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <jpeglib.h>
|
|
||||||
|
|
||||||
#ifndef USE_INTERNAL_JPEG
|
|
||||||
# if JPEG_LIB_VERSION < 80
|
|
||||||
# error Need system libjpeg >= 80
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
static void R_JPGErrorExit(j_common_ptr cinfo)
|
|
||||||
{
|
|
||||||
char buffer[JMSG_LENGTH_MAX];
|
|
||||||
|
|
||||||
(*cinfo->err->format_message) (cinfo, buffer);
|
|
||||||
|
|
||||||
/* Let the memory manager delete any temp files before we die */
|
|
||||||
jpeg_destroy(cinfo);
|
|
||||||
|
|
||||||
ri.Error(ERR_FATAL, "%s", buffer);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void R_JPGOutputMessage(j_common_ptr cinfo)
|
|
||||||
{
|
|
||||||
char buffer[JMSG_LENGTH_MAX];
|
|
||||||
|
|
||||||
/* Create the message */
|
|
||||||
(*cinfo->err->format_message) (cinfo, buffer);
|
|
||||||
|
|
||||||
/* Send it to stderr, adding a newline */
|
|
||||||
ri.Printf(PRINT_ALL, "%s\n", buffer);
|
|
||||||
}
|
|
||||||
|
|
||||||
void R_LoadJPG(const char *filename, unsigned char **pic, int *width, int *height)
|
|
||||||
{
|
|
||||||
/* This struct contains the JPEG decompression parameters and pointers to
|
|
||||||
* working space (which is allocated as needed by the JPEG library).
|
|
||||||
*/
|
|
||||||
struct jpeg_decompress_struct cinfo = {NULL};
|
|
||||||
/* We use our private extension JPEG error handler.
|
|
||||||
* Note that this struct must live as long as the main JPEG parameter
|
|
||||||
* struct, to avoid dangling-pointer problems.
|
|
||||||
*/
|
|
||||||
/* This struct represents a JPEG error handler. It is declared separately
|
|
||||||
* because applications often want to supply a specialized error handler
|
|
||||||
* (see the second half of this file for an example). But here we just
|
|
||||||
* take the easy way out and use the standard error handler, which will
|
|
||||||
* print a message on stderr and call exit() if compression fails.
|
|
||||||
* Note that this struct must live as long as the main JPEG parameter
|
|
||||||
* struct, to avoid dangling-pointer problems.
|
|
||||||
*/
|
|
||||||
struct jpeg_error_mgr jerr;
|
|
||||||
/* More stuff */
|
|
||||||
JSAMPARRAY buffer; /* Output row buffer */
|
|
||||||
unsigned int row_stride; /* physical row width in output buffer */
|
|
||||||
unsigned int pixelcount, memcount;
|
|
||||||
unsigned int sindex, dindex;
|
|
||||||
byte *out;
|
|
||||||
int len;
|
|
||||||
union {
|
|
||||||
byte *b;
|
|
||||||
void *v;
|
|
||||||
} fbuffer;
|
|
||||||
byte *buf;
|
|
||||||
|
|
||||||
/* In this example we want to open the input file before doing anything else,
|
|
||||||
* so that the setjmp() error recovery below can assume the file is open.
|
|
||||||
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
|
|
||||||
* requires it in order to read binary files.
|
|
||||||
*/
|
|
||||||
|
|
||||||
len = ri.FS_ReadFile ( ( char * ) filename, &fbuffer.v);
|
|
||||||
if (!fbuffer.b || len < 0) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Step 1: allocate and initialize JPEG decompression object */
|
|
||||||
|
|
||||||
/* We have to set up the error handler first, in case the initialization
|
|
||||||
* step fails. (Unlikely, but it could happen if you are out of memory.)
|
|
||||||
* This routine fills in the contents of struct jerr, and returns jerr's
|
|
||||||
* address which we place into the link field in cinfo.
|
|
||||||
*/
|
|
||||||
cinfo.err = jpeg_std_error(&jerr);
|
|
||||||
cinfo.err->error_exit = R_JPGErrorExit;
|
|
||||||
cinfo.err->output_message = R_JPGOutputMessage;
|
|
||||||
|
|
||||||
/* Now we can initialize the JPEG decompression object. */
|
|
||||||
jpeg_create_decompress(&cinfo);
|
|
||||||
|
|
||||||
/* Step 2: specify data source (eg, a file) */
|
|
||||||
|
|
||||||
jpeg_mem_src(&cinfo, fbuffer.b, len);
|
|
||||||
|
|
||||||
/* Step 3: read file parameters with jpeg_read_header() */
|
|
||||||
|
|
||||||
(void) jpeg_read_header(&cinfo, TRUE);
|
|
||||||
/* We can ignore the return value from jpeg_read_header since
|
|
||||||
* (a) suspension is not possible with the stdio data source, and
|
|
||||||
* (b) we passed TRUE to reject a tables-only JPEG file as an error.
|
|
||||||
* See libjpeg.doc for more info.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Step 4: set parameters for decompression */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Make sure it always converts images to RGB color space. This will
|
|
||||||
* automatically convert 8-bit greyscale images to RGB as well.
|
|
||||||
*/
|
|
||||||
cinfo.out_color_space = JCS_RGB;
|
|
||||||
|
|
||||||
/* Step 5: Start decompressor */
|
|
||||||
|
|
||||||
(void) jpeg_start_decompress(&cinfo);
|
|
||||||
/* We can ignore the return value since suspension is not possible
|
|
||||||
* with the stdio data source.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* We may need to do some setup of our own at this point before reading
|
|
||||||
* the data. After jpeg_start_decompress() we have the correct scaled
|
|
||||||
* output image dimensions available, as well as the output colormap
|
|
||||||
* if we asked for color quantization.
|
|
||||||
* In this example, we need to make an output work buffer of the right size.
|
|
||||||
*/
|
|
||||||
/* JSAMPLEs per row in output buffer */
|
|
||||||
|
|
||||||
pixelcount = cinfo.output_width * cinfo.output_height;
|
|
||||||
|
|
||||||
if(!cinfo.output_width || !cinfo.output_height
|
|
||||||
|| ((pixelcount * 4) / cinfo.output_width) / 4 != cinfo.output_height
|
|
||||||
|| pixelcount > 0x1FFFFFFF || cinfo.output_components != 3
|
|
||||||
)
|
|
||||||
{
|
|
||||||
// Free the memory to make sure we don't leak memory
|
|
||||||
ri.FS_FreeFile (fbuffer.v);
|
|
||||||
jpeg_destroy_decompress(&cinfo);
|
|
||||||
|
|
||||||
ri.Error(ERR_DROP, "LoadJPG: %s has an invalid image format: %dx%d*4=%d, components: %d", filename,
|
|
||||||
cinfo.output_width, cinfo.output_height, pixelcount * 4, cinfo.output_components);
|
|
||||||
}
|
|
||||||
|
|
||||||
memcount = pixelcount * 4;
|
|
||||||
row_stride = cinfo.output_width * cinfo.output_components;
|
|
||||||
|
|
||||||
out = ri.Malloc(memcount);
|
|
||||||
|
|
||||||
*width = cinfo.output_width;
|
|
||||||
*height = cinfo.output_height;
|
|
||||||
|
|
||||||
/* Step 6: while (scan lines remain to be read) */
|
|
||||||
/* jpeg_read_scanlines(...); */
|
|
||||||
|
|
||||||
/* Here we use the library's state variable cinfo.output_scanline as the
|
|
||||||
* loop counter, so that we don't have to keep track ourselves.
|
|
||||||
*/
|
|
||||||
while (cinfo.output_scanline < cinfo.output_height) {
|
|
||||||
/* jpeg_read_scanlines expects an array of pointers to scanlines.
|
|
||||||
* Here the array is only one element long, but you could ask for
|
|
||||||
* more than one scanline at a time if that's more convenient.
|
|
||||||
*/
|
|
||||||
buf = ((out+(row_stride*cinfo.output_scanline)));
|
|
||||||
buffer = &buf;
|
|
||||||
(void) jpeg_read_scanlines(&cinfo, buffer, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
buf = out;
|
|
||||||
|
|
||||||
// Expand from RGB to RGBA
|
|
||||||
sindex = pixelcount * cinfo.output_components;
|
|
||||||
dindex = memcount;
|
|
||||||
|
|
||||||
do
|
|
||||||
{
|
|
||||||
buf[--dindex] = 255;
|
|
||||||
buf[--dindex] = buf[--sindex];
|
|
||||||
buf[--dindex] = buf[--sindex];
|
|
||||||
buf[--dindex] = buf[--sindex];
|
|
||||||
} while(sindex);
|
|
||||||
|
|
||||||
*pic = out;
|
|
||||||
|
|
||||||
/* Step 7: Finish decompression */
|
|
||||||
|
|
||||||
jpeg_finish_decompress(&cinfo);
|
|
||||||
/* We can ignore the return value since suspension is not possible
|
|
||||||
* with the stdio data source.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Step 8: Release JPEG decompression object */
|
|
||||||
|
|
||||||
/* This is an important step since it will release a good deal of memory. */
|
|
||||||
jpeg_destroy_decompress(&cinfo);
|
|
||||||
|
|
||||||
/* After finish_decompress, we can close the input file.
|
|
||||||
* Here we postpone it until after no more JPEG errors are possible,
|
|
||||||
* so as to simplify the setjmp error logic above. (Actually, I don't
|
|
||||||
* think that jpeg_destroy can do an error exit, but why assume anything...)
|
|
||||||
*/
|
|
||||||
ri.FS_FreeFile (fbuffer.v);
|
|
||||||
|
|
||||||
/* At this point you may want to check to see whether any corrupt-data
|
|
||||||
* warnings occurred (test whether jerr.pub.num_warnings is nonzero).
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* And we're done! */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* Expanded data destination object for stdio output */
|
|
||||||
|
|
||||||
typedef struct {
|
|
||||||
struct jpeg_destination_mgr pub; /* public fields */
|
|
||||||
|
|
||||||
byte* outfile; /* target stream */
|
|
||||||
int size;
|
|
||||||
} my_destination_mgr;
|
|
||||||
|
|
||||||
typedef my_destination_mgr * my_dest_ptr;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Initialize destination --- called by jpeg_start_compress
|
|
||||||
* before any data is actually written.
|
|
||||||
*/
|
|
||||||
|
|
||||||
static void
|
|
||||||
init_destination (j_compress_ptr cinfo)
|
|
||||||
{
|
|
||||||
my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
|
|
||||||
|
|
||||||
dest->pub.next_output_byte = dest->outfile;
|
|
||||||
dest->pub.free_in_buffer = dest->size;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Empty the output buffer --- called whenever buffer fills up.
|
|
||||||
*
|
|
||||||
* In typical applications, this should write the entire output buffer
|
|
||||||
* (ignoring the current state of next_output_byte & free_in_buffer),
|
|
||||||
* reset the pointer & count to the start of the buffer, and return TRUE
|
|
||||||
* indicating that the buffer has been dumped.
|
|
||||||
*
|
|
||||||
* In applications that need to be able to suspend compression due to output
|
|
||||||
* overrun, a FALSE return indicates that the buffer cannot be emptied now.
|
|
||||||
* In this situation, the compressor will return to its caller (possibly with
|
|
||||||
* an indication that it has not accepted all the supplied scanlines). The
|
|
||||||
* application should resume compression after it has made more room in the
|
|
||||||
* output buffer. Note that there are substantial restrictions on the use of
|
|
||||||
* suspension --- see the documentation.
|
|
||||||
*
|
|
||||||
* When suspending, the compressor will back up to a convenient restart point
|
|
||||||
* (typically the start of the current MCU). next_output_byte & free_in_buffer
|
|
||||||
* indicate where the restart point will be if the current call returns FALSE.
|
|
||||||
* Data beyond this point will be regenerated after resumption, so do not
|
|
||||||
* write it out when emptying the buffer externally.
|
|
||||||
*/
|
|
||||||
|
|
||||||
static boolean
|
|
||||||
empty_output_buffer (j_compress_ptr cinfo)
|
|
||||||
{
|
|
||||||
my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
|
|
||||||
|
|
||||||
jpeg_destroy_compress(cinfo);
|
|
||||||
|
|
||||||
// Make crash fatal or we would probably leak memory.
|
|
||||||
ri.Error(ERR_FATAL, "Output buffer for encoded JPEG image has insufficient size of %d bytes",
|
|
||||||
dest->size);
|
|
||||||
|
|
||||||
return FALSE;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Terminate destination --- called by jpeg_finish_compress
|
|
||||||
* after all data has been written. Usually needs to flush buffer.
|
|
||||||
*
|
|
||||||
* NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
|
|
||||||
* application must deal with any cleanup that should happen even
|
|
||||||
* for error exit.
|
|
||||||
*/
|
|
||||||
|
|
||||||
static void term_destination(j_compress_ptr cinfo)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Prepare for output to a stdio stream.
|
|
||||||
* The caller must have already opened the stream, and is responsible
|
|
||||||
* for closing it after finishing compression.
|
|
||||||
*/
|
|
||||||
|
|
||||||
static void
|
|
||||||
jpegDest (j_compress_ptr cinfo, byte* outfile, int size)
|
|
||||||
{
|
|
||||||
my_dest_ptr dest;
|
|
||||||
|
|
||||||
/* The destination object is made permanent so that multiple JPEG images
|
|
||||||
* can be written to the same file without re-executing jpeg_stdio_dest.
|
|
||||||
* This makes it dangerous to use this manager and a different destination
|
|
||||||
* manager serially with the same JPEG object, because their private object
|
|
||||||
* sizes may be different. Caveat programmer.
|
|
||||||
*/
|
|
||||||
if (cinfo->dest == NULL) { /* first time for this JPEG object? */
|
|
||||||
cinfo->dest = (struct jpeg_destination_mgr *)
|
|
||||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
|
|
||||||
sizeof(my_destination_mgr));
|
|
||||||
}
|
|
||||||
|
|
||||||
dest = (my_dest_ptr) cinfo->dest;
|
|
||||||
dest->pub.init_destination = init_destination;
|
|
||||||
dest->pub.empty_output_buffer = empty_output_buffer;
|
|
||||||
dest->pub.term_destination = term_destination;
|
|
||||||
dest->outfile = outfile;
|
|
||||||
dest->size = size;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
=================
|
|
||||||
SaveJPGToBuffer
|
|
||||||
|
|
||||||
Encodes JPEG from image in image_buffer and writes to buffer.
|
|
||||||
Expects RGB input data
|
|
||||||
=================
|
|
||||||
*/
|
|
||||||
size_t RE_SaveJPGToBuffer(byte *buffer, size_t bufSize, int quality,
|
|
||||||
int image_width, int image_height, byte *image_buffer, int padding)
|
|
||||||
{
|
|
||||||
struct jpeg_compress_struct cinfo;
|
|
||||||
struct jpeg_error_mgr jerr;
|
|
||||||
JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
|
|
||||||
my_dest_ptr dest;
|
|
||||||
int row_stride; /* physical row width in image buffer */
|
|
||||||
size_t outcount;
|
|
||||||
|
|
||||||
/* Step 1: allocate and initialize JPEG compression object */
|
|
||||||
cinfo.err = jpeg_std_error(&jerr);
|
|
||||||
cinfo.err->error_exit = R_JPGErrorExit;
|
|
||||||
cinfo.err->output_message = R_JPGOutputMessage;
|
|
||||||
|
|
||||||
/* Now we can initialize the JPEG compression object. */
|
|
||||||
jpeg_create_compress(&cinfo);
|
|
||||||
|
|
||||||
/* Step 2: specify data destination (eg, a file) */
|
|
||||||
/* Note: steps 2 and 3 can be done in either order. */
|
|
||||||
jpegDest(&cinfo, buffer, bufSize);
|
|
||||||
|
|
||||||
/* Step 3: set parameters for compression */
|
|
||||||
cinfo.image_width = image_width; /* image width and height, in pixels */
|
|
||||||
cinfo.image_height = image_height;
|
|
||||||
cinfo.input_components = 3; /* # of color components per pixel */
|
|
||||||
cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
|
|
||||||
|
|
||||||
jpeg_set_defaults(&cinfo);
|
|
||||||
jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
|
|
||||||
/* If quality is set high, disable chroma subsampling */
|
|
||||||
if (quality >= 85) {
|
|
||||||
cinfo.comp_info[0].h_samp_factor = 1;
|
|
||||||
cinfo.comp_info[0].v_samp_factor = 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Step 4: Start compressor */
|
|
||||||
jpeg_start_compress(&cinfo, TRUE);
|
|
||||||
|
|
||||||
/* Step 5: while (scan lines remain to be written) */
|
|
||||||
/* jpeg_write_scanlines(...); */
|
|
||||||
row_stride = image_width * cinfo.input_components + padding; /* JSAMPLEs per row in image_buffer */
|
|
||||||
|
|
||||||
while (cinfo.next_scanline < cinfo.image_height) {
|
|
||||||
/* jpeg_write_scanlines expects an array of pointers to scanlines.
|
|
||||||
* Here the array is only one element long, but you could pass
|
|
||||||
* more than one scanline at a time if that's more convenient.
|
|
||||||
*/
|
|
||||||
row_pointer[0] = &image_buffer[((cinfo.image_height-1)*row_stride)-cinfo.next_scanline * row_stride];
|
|
||||||
(void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Step 6: Finish compression */
|
|
||||||
jpeg_finish_compress(&cinfo);
|
|
||||||
|
|
||||||
dest = (my_dest_ptr) cinfo.dest;
|
|
||||||
outcount = dest->size - dest->pub.free_in_buffer;
|
|
||||||
|
|
||||||
/* Step 7: release JPEG compression object */
|
|
||||||
jpeg_destroy_compress(&cinfo);
|
|
||||||
|
|
||||||
/* And we're done! */
|
|
||||||
return outcount;
|
|
||||||
}
|
|
||||||
|
|
||||||
void RE_SaveJPG(char * filename, int quality, int image_width, int image_height, byte *image_buffer, int padding)
|
|
||||||
{
|
|
||||||
byte *out;
|
|
||||||
size_t bufSize;
|
|
||||||
|
|
||||||
bufSize = image_width * image_height * 3;
|
|
||||||
out = ri.Hunk_AllocateTempMemory(bufSize);
|
|
||||||
|
|
||||||
bufSize = RE_SaveJPGToBuffer(out, bufSize, quality, image_width, image_height, image_buffer, padding);
|
|
||||||
ri.FS_WriteFile(filename, out, bufSize);
|
|
||||||
|
|
||||||
ri.Hunk_FreeTempMemory(out);
|
|
||||||
}
|
|
||||||
|
|
@ -1,179 +0,0 @@
|
||||||
/*
|
|
||||||
===========================================================================
|
|
||||||
Copyright (C) 1999-2005 Id Software, Inc.
|
|
||||||
2008 Ludwig Nussel
|
|
||||||
|
|
||||||
This file is part of Quake III Arena source code.
|
|
||||||
|
|
||||||
Quake III Arena source code 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.
|
|
||||||
|
|
||||||
Quake III Arena source code 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 Quake III Arena source code; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
===========================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "../qcommon/q_shared.h"
|
|
||||||
#include "../qcommon/qfiles.h"
|
|
||||||
#include "../qcommon/qcommon.h"
|
|
||||||
#include "../renderercommon/tr_public.h"
|
|
||||||
extern refimport_t ri;
|
|
||||||
|
|
||||||
/*
|
|
||||||
========================================================================
|
|
||||||
|
|
||||||
PCX files are used for 8 bit images
|
|
||||||
|
|
||||||
========================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
typedef struct {
|
|
||||||
char manufacturer;
|
|
||||||
char version;
|
|
||||||
char encoding;
|
|
||||||
char bits_per_pixel;
|
|
||||||
unsigned short xmin,ymin,xmax,ymax;
|
|
||||||
unsigned short hres,vres;
|
|
||||||
unsigned char palette[48];
|
|
||||||
char reserved;
|
|
||||||
char color_planes;
|
|
||||||
unsigned short bytes_per_line;
|
|
||||||
unsigned short palette_type;
|
|
||||||
unsigned short hscreensize, vscreensize;
|
|
||||||
char filler[54];
|
|
||||||
unsigned char data[];
|
|
||||||
} pcx_t;
|
|
||||||
|
|
||||||
void R_LoadPCX ( const char *filename, byte **pic, int *width, int *height)
|
|
||||||
{
|
|
||||||
union {
|
|
||||||
byte *b;
|
|
||||||
void *v;
|
|
||||||
} raw;
|
|
||||||
byte *end;
|
|
||||||
pcx_t *pcx;
|
|
||||||
int len;
|
|
||||||
unsigned char dataByte = 0, runLength = 0;
|
|
||||||
byte *out, *pix;
|
|
||||||
unsigned short w, h;
|
|
||||||
byte *pic8;
|
|
||||||
byte *palette;
|
|
||||||
int i;
|
|
||||||
unsigned size = 0;
|
|
||||||
|
|
||||||
if (width)
|
|
||||||
*width = 0;
|
|
||||||
if (height)
|
|
||||||
*height = 0;
|
|
||||||
*pic = NULL;
|
|
||||||
|
|
||||||
//
|
|
||||||
// load the file
|
|
||||||
//
|
|
||||||
len = ri.FS_ReadFile( ( char * ) filename, &raw.v);
|
|
||||||
if (!raw.b || len < 0) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if((unsigned)len < sizeof(pcx_t))
|
|
||||||
{
|
|
||||||
ri.Printf (PRINT_ALL, "PCX truncated: %s\n", filename);
|
|
||||||
ri.FS_FreeFile (raw.v);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// parse the PCX file
|
|
||||||
//
|
|
||||||
pcx = (pcx_t *)raw.b;
|
|
||||||
end = raw.b+len;
|
|
||||||
|
|
||||||
w = LittleShort(pcx->xmax)+1;
|
|
||||||
h = LittleShort(pcx->ymax)+1;
|
|
||||||
size = w*h;
|
|
||||||
|
|
||||||
if (pcx->manufacturer != 0x0a
|
|
||||||
|| pcx->version != 5
|
|
||||||
|| pcx->encoding != 1
|
|
||||||
|| pcx->color_planes != 1
|
|
||||||
|| pcx->bits_per_pixel != 8
|
|
||||||
|| w >= 1024
|
|
||||||
|| h >= 1024)
|
|
||||||
{
|
|
||||||
ri.Printf (PRINT_ALL, "Bad or unsupported pcx file %s (%dx%d@%d)\n", filename, w, h, pcx->bits_per_pixel);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
pix = pic8 = ri.Malloc ( size );
|
|
||||||
|
|
||||||
raw.b = pcx->data;
|
|
||||||
// FIXME: should use bytes_per_line but original q3 didn't do that either
|
|
||||||
while(pix < pic8+size)
|
|
||||||
{
|
|
||||||
if(runLength > 0) {
|
|
||||||
*pix++ = dataByte;
|
|
||||||
--runLength;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(raw.b+1 > end)
|
|
||||||
break;
|
|
||||||
dataByte = *raw.b++;
|
|
||||||
|
|
||||||
if((dataByte & 0xC0) == 0xC0)
|
|
||||||
{
|
|
||||||
if(raw.b+1 > end)
|
|
||||||
break;
|
|
||||||
runLength = dataByte & 0x3F;
|
|
||||||
dataByte = *raw.b++;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
runLength = 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(pix < pic8+size)
|
|
||||||
{
|
|
||||||
ri.Printf (PRINT_ALL, "PCX file truncated: %s\n", filename);
|
|
||||||
ri.FS_FreeFile (pcx);
|
|
||||||
ri.Free (pic8);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (raw.b-(byte*)pcx >= end - (byte*)769 || end[-769] != 0x0c)
|
|
||||||
{
|
|
||||||
ri.Printf (PRINT_ALL, "PCX missing palette: %s\n", filename);
|
|
||||||
ri.FS_FreeFile (pcx);
|
|
||||||
ri.Free (pic8);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
palette = end-768;
|
|
||||||
|
|
||||||
pix = out = ri.Malloc(4 * size );
|
|
||||||
for (i = 0 ; i < size ; i++)
|
|
||||||
{
|
|
||||||
unsigned char p = pic8[i];
|
|
||||||
pix[0] = palette[p*3];
|
|
||||||
pix[1] = palette[p*3 + 1];
|
|
||||||
pix[2] = palette[p*3 + 2];
|
|
||||||
pix[3] = 255;
|
|
||||||
pix += 4;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (width)
|
|
||||||
*width = w;
|
|
||||||
if (height)
|
|
||||||
*height = h;
|
|
||||||
|
|
||||||
*pic = out;
|
|
||||||
|
|
||||||
ri.FS_FreeFile (pcx);
|
|
||||||
ri.Free (pic8);
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,324 +0,0 @@
|
||||||
/*
|
|
||||||
===========================================================================
|
|
||||||
Copyright (C) 1999-2005 Id Software, Inc.
|
|
||||||
|
|
||||||
This file is part of Quake III Arena source code.
|
|
||||||
|
|
||||||
Quake III Arena source code 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.
|
|
||||||
|
|
||||||
Quake III Arena source code 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 Quake III Arena source code; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
===========================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "../qcommon/q_shared.h"
|
|
||||||
#include "../qcommon/qfiles.h"
|
|
||||||
#include "../qcommon/qcommon.h"
|
|
||||||
#include "../renderercommon/tr_public.h"
|
|
||||||
extern refimport_t ri;
|
|
||||||
|
|
||||||
/*
|
|
||||||
========================================================================
|
|
||||||
|
|
||||||
TGA files are used for 24/32 bit images
|
|
||||||
|
|
||||||
========================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
typedef struct _TargaHeader {
|
|
||||||
unsigned char id_length, colormap_type, image_type;
|
|
||||||
unsigned short colormap_index, colormap_length;
|
|
||||||
unsigned char colormap_size;
|
|
||||||
unsigned short x_origin, y_origin, width, height;
|
|
||||||
unsigned char pixel_size, attributes;
|
|
||||||
} TargaHeader;
|
|
||||||
|
|
||||||
void R_LoadTGA ( const char *name, byte **pic, int *width, int *height)
|
|
||||||
{
|
|
||||||
unsigned columns, rows, numPixels;
|
|
||||||
byte *pixbuf;
|
|
||||||
int row, column;
|
|
||||||
byte *buf_p;
|
|
||||||
byte *end;
|
|
||||||
union {
|
|
||||||
byte *b;
|
|
||||||
void *v;
|
|
||||||
} buffer;
|
|
||||||
TargaHeader targa_header;
|
|
||||||
byte *targa_rgba;
|
|
||||||
int length;
|
|
||||||
|
|
||||||
*pic = NULL;
|
|
||||||
|
|
||||||
if(width)
|
|
||||||
*width = 0;
|
|
||||||
if(height)
|
|
||||||
*height = 0;
|
|
||||||
|
|
||||||
//
|
|
||||||
// load the file
|
|
||||||
//
|
|
||||||
length = ri.FS_ReadFile ( ( char * ) name, &buffer.v);
|
|
||||||
if (!buffer.b || length < 0) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(length < 18)
|
|
||||||
{
|
|
||||||
ri.Error( ERR_DROP, "LoadTGA: header too short (%s)", name );
|
|
||||||
}
|
|
||||||
|
|
||||||
buf_p = buffer.b;
|
|
||||||
end = buffer.b + length;
|
|
||||||
|
|
||||||
targa_header.id_length = buf_p[0];
|
|
||||||
targa_header.colormap_type = buf_p[1];
|
|
||||||
targa_header.image_type = buf_p[2];
|
|
||||||
|
|
||||||
memcpy(&targa_header.colormap_index, &buf_p[3], 2);
|
|
||||||
memcpy(&targa_header.colormap_length, &buf_p[5], 2);
|
|
||||||
targa_header.colormap_size = buf_p[7];
|
|
||||||
memcpy(&targa_header.x_origin, &buf_p[8], 2);
|
|
||||||
memcpy(&targa_header.y_origin, &buf_p[10], 2);
|
|
||||||
memcpy(&targa_header.width, &buf_p[12], 2);
|
|
||||||
memcpy(&targa_header.height, &buf_p[14], 2);
|
|
||||||
targa_header.pixel_size = buf_p[16];
|
|
||||||
targa_header.attributes = buf_p[17];
|
|
||||||
|
|
||||||
targa_header.colormap_index = LittleShort(targa_header.colormap_index);
|
|
||||||
targa_header.colormap_length = LittleShort(targa_header.colormap_length);
|
|
||||||
targa_header.x_origin = LittleShort(targa_header.x_origin);
|
|
||||||
targa_header.y_origin = LittleShort(targa_header.y_origin);
|
|
||||||
targa_header.width = LittleShort(targa_header.width);
|
|
||||||
targa_header.height = LittleShort(targa_header.height);
|
|
||||||
|
|
||||||
buf_p += 18;
|
|
||||||
|
|
||||||
if (targa_header.image_type!=2
|
|
||||||
&& targa_header.image_type!=10
|
|
||||||
&& targa_header.image_type != 3 )
|
|
||||||
{
|
|
||||||
ri.Error (ERR_DROP, "LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported");
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( targa_header.colormap_type != 0 )
|
|
||||||
{
|
|
||||||
ri.Error( ERR_DROP, "LoadTGA: colormaps not supported" );
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( ( targa_header.pixel_size != 32 && targa_header.pixel_size != 24 ) && targa_header.image_type != 3 )
|
|
||||||
{
|
|
||||||
ri.Error (ERR_DROP, "LoadTGA: Only 32 or 24 bit images supported (no colormaps)");
|
|
||||||
}
|
|
||||||
|
|
||||||
columns = targa_header.width;
|
|
||||||
rows = targa_header.height;
|
|
||||||
numPixels = columns * rows * 4;
|
|
||||||
|
|
||||||
if(!columns || !rows || numPixels > 0x7FFFFFFF || numPixels / columns / 4 != rows)
|
|
||||||
{
|
|
||||||
ri.Error (ERR_DROP, "LoadTGA: %s has an invalid image size", name);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
targa_rgba = ri.Malloc (numPixels);
|
|
||||||
|
|
||||||
if (targa_header.id_length != 0)
|
|
||||||
{
|
|
||||||
if (buf_p + targa_header.id_length > end)
|
|
||||||
ri.Error( ERR_DROP, "LoadTGA: header too short (%s)", name );
|
|
||||||
|
|
||||||
buf_p += targa_header.id_length; // skip TARGA image comment
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( targa_header.image_type==2 || targa_header.image_type == 3 )
|
|
||||||
{
|
|
||||||
if(buf_p + columns*rows*targa_header.pixel_size/8 > end)
|
|
||||||
{
|
|
||||||
ri.Error (ERR_DROP, "LoadTGA: file truncated (%s)", name);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Uncompressed RGB or gray scale image
|
|
||||||
for(row=rows-1; row>=0; row--)
|
|
||||||
{
|
|
||||||
pixbuf = targa_rgba + row*columns*4;
|
|
||||||
for(column=0; column<columns; column++)
|
|
||||||
{
|
|
||||||
unsigned char red,green,blue,alphabyte;
|
|
||||||
switch (targa_header.pixel_size)
|
|
||||||
{
|
|
||||||
|
|
||||||
case 8:
|
|
||||||
blue = *buf_p++;
|
|
||||||
green = blue;
|
|
||||||
red = blue;
|
|
||||||
*pixbuf++ = red;
|
|
||||||
*pixbuf++ = green;
|
|
||||||
*pixbuf++ = blue;
|
|
||||||
*pixbuf++ = 255;
|
|
||||||
break;
|
|
||||||
|
|
||||||
case 24:
|
|
||||||
blue = *buf_p++;
|
|
||||||
green = *buf_p++;
|
|
||||||
red = *buf_p++;
|
|
||||||
*pixbuf++ = red;
|
|
||||||
*pixbuf++ = green;
|
|
||||||
*pixbuf++ = blue;
|
|
||||||
*pixbuf++ = 255;
|
|
||||||
break;
|
|
||||||
case 32:
|
|
||||||
blue = *buf_p++;
|
|
||||||
green = *buf_p++;
|
|
||||||
red = *buf_p++;
|
|
||||||
alphabyte = *buf_p++;
|
|
||||||
*pixbuf++ = red;
|
|
||||||
*pixbuf++ = green;
|
|
||||||
*pixbuf++ = blue;
|
|
||||||
*pixbuf++ = alphabyte;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
ri.Error( ERR_DROP, "LoadTGA: illegal pixel_size '%d' in file '%s'", targa_header.pixel_size, name );
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else if (targa_header.image_type==10) { // Runlength encoded RGB images
|
|
||||||
unsigned char red,green,blue,alphabyte,packetHeader,packetSize,j;
|
|
||||||
|
|
||||||
red = 0;
|
|
||||||
green = 0;
|
|
||||||
blue = 0;
|
|
||||||
alphabyte = 0xff;
|
|
||||||
|
|
||||||
for(row=rows-1; row>=0; row--) {
|
|
||||||
pixbuf = targa_rgba + row*columns*4;
|
|
||||||
for(column=0; column<columns; ) {
|
|
||||||
if(buf_p + 1 > end)
|
|
||||||
ri.Error (ERR_DROP, "LoadTGA: file truncated (%s)", name);
|
|
||||||
packetHeader= *buf_p++;
|
|
||||||
packetSize = 1 + (packetHeader & 0x7f);
|
|
||||||
if (packetHeader & 0x80) { // run-length packet
|
|
||||||
if(buf_p + targa_header.pixel_size/8 > end)
|
|
||||||
ri.Error (ERR_DROP, "LoadTGA: file truncated (%s)", name);
|
|
||||||
switch (targa_header.pixel_size) {
|
|
||||||
case 24:
|
|
||||||
blue = *buf_p++;
|
|
||||||
green = *buf_p++;
|
|
||||||
red = *buf_p++;
|
|
||||||
alphabyte = 255;
|
|
||||||
break;
|
|
||||||
case 32:
|
|
||||||
blue = *buf_p++;
|
|
||||||
green = *buf_p++;
|
|
||||||
red = *buf_p++;
|
|
||||||
alphabyte = *buf_p++;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
ri.Error( ERR_DROP, "LoadTGA: illegal pixel_size '%d' in file '%s'", targa_header.pixel_size, name );
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
for(j=0;j<packetSize;j++) {
|
|
||||||
*pixbuf++=red;
|
|
||||||
*pixbuf++=green;
|
|
||||||
*pixbuf++=blue;
|
|
||||||
*pixbuf++=alphabyte;
|
|
||||||
column++;
|
|
||||||
if (column==columns) { // run spans across rows
|
|
||||||
column=0;
|
|
||||||
if (row>0)
|
|
||||||
row--;
|
|
||||||
else
|
|
||||||
goto breakOut;
|
|
||||||
pixbuf = targa_rgba + row*columns*4;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else { // non run-length packet
|
|
||||||
|
|
||||||
if(buf_p + targa_header.pixel_size/8*packetSize > end)
|
|
||||||
ri.Error (ERR_DROP, "LoadTGA: file truncated (%s)", name);
|
|
||||||
for(j=0;j<packetSize;j++) {
|
|
||||||
switch (targa_header.pixel_size) {
|
|
||||||
case 24:
|
|
||||||
blue = *buf_p++;
|
|
||||||
green = *buf_p++;
|
|
||||||
red = *buf_p++;
|
|
||||||
*pixbuf++ = red;
|
|
||||||
*pixbuf++ = green;
|
|
||||||
*pixbuf++ = blue;
|
|
||||||
*pixbuf++ = 255;
|
|
||||||
break;
|
|
||||||
case 32:
|
|
||||||
blue = *buf_p++;
|
|
||||||
green = *buf_p++;
|
|
||||||
red = *buf_p++;
|
|
||||||
alphabyte = *buf_p++;
|
|
||||||
*pixbuf++ = red;
|
|
||||||
*pixbuf++ = green;
|
|
||||||
*pixbuf++ = blue;
|
|
||||||
*pixbuf++ = alphabyte;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
ri.Error( ERR_DROP, "LoadTGA: illegal pixel_size '%d' in file '%s'", targa_header.pixel_size, name );
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
column++;
|
|
||||||
if (column==columns) { // pixel packet run spans across rows
|
|
||||||
column=0;
|
|
||||||
if (row>0)
|
|
||||||
row--;
|
|
||||||
else
|
|
||||||
goto breakOut;
|
|
||||||
pixbuf = targa_rgba + row*columns*4;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
breakOut:;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
// TTimo: this is the chunk of code to ensure a behavior that meets TGA specs
|
|
||||||
// bit 5 set => top-down
|
|
||||||
if (targa_header.attributes & 0x20) {
|
|
||||||
unsigned char *flip = (unsigned char*)malloc (columns*4);
|
|
||||||
unsigned char *src, *dst;
|
|
||||||
|
|
||||||
for (row = 0; row < rows/2; row++) {
|
|
||||||
src = targa_rgba + row * 4 * columns;
|
|
||||||
dst = targa_rgba + (rows - row - 1) * 4 * columns;
|
|
||||||
|
|
||||||
memcpy (flip, src, columns*4);
|
|
||||||
memcpy (src, dst, columns*4);
|
|
||||||
memcpy (dst, flip, columns*4);
|
|
||||||
}
|
|
||||||
free (flip);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
// instead we just print a warning
|
|
||||||
if (targa_header.attributes & 0x20) {
|
|
||||||
ri.Printf( PRINT_WARNING, "WARNING: '%s' TGA file header declares top-down image, ignoring\n", name);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (width)
|
|
||||||
*width = columns;
|
|
||||||
if (height)
|
|
||||||
*height = rows;
|
|
||||||
|
|
||||||
*pic = targa_rgba;
|
|
||||||
|
|
||||||
ri.FS_FreeFile (buffer.v);
|
|
||||||
}
|
|
||||||
|
|
@ -1,93 +0,0 @@
|
||||||
/*
|
|
||||||
===========================================================================
|
|
||||||
Copyright (C) 1999-2005 Id Software, Inc.
|
|
||||||
|
|
||||||
This file is part of Quake III Arena source code.
|
|
||||||
|
|
||||||
Quake III Arena source code 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.
|
|
||||||
|
|
||||||
Quake III Arena source code 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 Quake III Arena source code; if not, write to the Free Software
|
|
||||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
===========================================================================
|
|
||||||
*/
|
|
||||||
// tr_noise.c
|
|
||||||
#include "../qcommon/q_shared.h"
|
|
||||||
#include "../qcommon/qfiles.h"
|
|
||||||
#include "../qcommon/qcommon.h"
|
|
||||||
|
|
||||||
#define NOISE_SIZE 256
|
|
||||||
#define NOISE_MASK ( NOISE_SIZE - 1 )
|
|
||||||
|
|
||||||
#define VAL( a ) s_noise_perm[ ( a ) & ( NOISE_MASK )]
|
|
||||||
#define INDEX( x, y, z, t ) VAL( x + VAL( y + VAL( z + VAL( t ) ) ) )
|
|
||||||
|
|
||||||
static float s_noise_table[NOISE_SIZE];
|
|
||||||
static int s_noise_perm[NOISE_SIZE];
|
|
||||||
|
|
||||||
static float GetNoiseValue( int x, int y, int z, int t )
|
|
||||||
{
|
|
||||||
int index = INDEX( ( int ) x, ( int ) y, ( int ) z, ( int ) t );
|
|
||||||
|
|
||||||
return s_noise_table[index];
|
|
||||||
}
|
|
||||||
|
|
||||||
void R_NoiseInit( void )
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for ( i = 0; i < NOISE_SIZE; i++ )
|
|
||||||
{
|
|
||||||
s_noise_table[i] = ( float ) ( ( ( rand() / ( float ) RAND_MAX ) * 2.0 - 1.0 ) );
|
|
||||||
s_noise_perm[i] = ( unsigned char ) ( rand() / ( float ) RAND_MAX * 255 );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
float R_NoiseGet4f( float x, float y, float z, float t )
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
int ix, iy, iz, it;
|
|
||||||
float fx, fy, fz, ft;
|
|
||||||
float front[4];
|
|
||||||
float back[4];
|
|
||||||
float fvalue, bvalue, value[2], finalvalue;
|
|
||||||
|
|
||||||
ix = ( int ) floor( x );
|
|
||||||
fx = x - ix;
|
|
||||||
iy = ( int ) floor( y );
|
|
||||||
fy = y - iy;
|
|
||||||
iz = ( int ) floor( z );
|
|
||||||
fz = z - iz;
|
|
||||||
it = ( int ) floor( t );
|
|
||||||
ft = t - it;
|
|
||||||
|
|
||||||
for ( i = 0; i < 2; i++ )
|
|
||||||
{
|
|
||||||
front[0] = GetNoiseValue( ix, iy, iz, it + i );
|
|
||||||
front[1] = GetNoiseValue( ix+1, iy, iz, it + i );
|
|
||||||
front[2] = GetNoiseValue( ix, iy+1, iz, it + i );
|
|
||||||
front[3] = GetNoiseValue( ix+1, iy+1, iz, it + i );
|
|
||||||
|
|
||||||
back[0] = GetNoiseValue( ix, iy, iz + 1, it + i );
|
|
||||||
back[1] = GetNoiseValue( ix+1, iy, iz + 1, it + i );
|
|
||||||
back[2] = GetNoiseValue( ix, iy+1, iz + 1, it + i );
|
|
||||||
back[3] = GetNoiseValue( ix+1, iy+1, iz + 1, it + i );
|
|
||||||
|
|
||||||
fvalue = LERP( LERP( front[0], front[1], fx ), LERP( front[2], front[3], fx ), fy );
|
|
||||||
bvalue = LERP( LERP( back[0], back[1], fx ), LERP( back[2], back[3], fx ), fy );
|
|
||||||
|
|
||||||
value[i] = LERP( fvalue, bvalue, fz );
|
|
||||||
}
|
|
||||||
|
|
||||||
finalvalue = LERP( value[0], value[1], ft );
|
|
||||||
|
|
||||||
return finalvalue;
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue