mirror of
https://github.com/UberGames/lilium-voyager.git
synced 2025-01-18 13:41:37 +00:00
Move some things into renderercommon
This commit is contained in:
Tim Angus
parent
372b07a97a
commit
93e6183ce3
13 changed files with 13 additions and 3776 deletions
7
Makefile
7
Makefile
|
|
@ -211,6 +211,7 @@ BD=$(BUILD_DIR)/debug-$(PLATFORM)-$(ARCH)
|
|||
BR=$(BUILD_DIR)/release-$(PLATFORM)-$(ARCH)
|
||||
CDIR=$(MOUNT_DIR)/client
|
||||
SDIR=$(MOUNT_DIR)/server
|
||||
RCOMMONDIR=$(MOUNT_DIR)/renderercommon
|
||||
RGL1DIR=$(MOUNT_DIR)/renderergl1
|
||||
RGL2DIR=$(MOUNT_DIR)/renderergl2
|
||||
CMDIR=$(MOUNT_DIR)/qcommon
|
||||
|
|
@ -2355,6 +2356,9 @@ $(B)/renderergl1/%.o: $(SDLDIR)/%.c
|
|||
$(B)/renderergl1/%.o: $(JPDIR)/%.c
|
||||
$(DO_REF_CC)
|
||||
|
||||
$(B)/renderergl1/%.o: $(RCOMMONDIR)/%.c
|
||||
$(DO_REF_CC)
|
||||
|
||||
$(B)/renderergl1/%.o: $(RGL1DIR)/%.c
|
||||
$(DO_REF_CC)
|
||||
|
||||
|
|
@ -2364,6 +2368,9 @@ $(B)/renderergl2/glsl/%.c: $(RGL2DIR)/glsl/%.glsl
|
|||
$(B)/renderergl2/glsl/%.o: $(B)/renderergl2/glsl/%.c
|
||||
$(DO_REF_CC)
|
||||
|
||||
$(B)/renderergl2/%.o: $(RCOMMONDIR)/%.c
|
||||
$(DO_REF_CC)
|
||||
|
||||
$(B)/renderergl2/%.o: $(RGL2DIR)/%.c
|
||||
$(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
|
||||
{
|
||||
|
|
@ -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.
|
||||
|
|
@ -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"
|
||||
|
||||
|
|
@ -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
|
||||
#include "tr_local.h"
|
||||
#include "../renderergl1/tr_local.h"
|
||||
|
||||
#define NOISE_SIZE 256
|
||||
#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 a new issue