LoadPCX
============
*/
-qbyte* LoadPCX (qbyte *f, int matchwidth, int matchheight)
+qbyte* LoadPCX (const qbyte *f, int matchwidth, int matchheight)
{
pcx_t pcx;
qbyte *a, *b, *image_rgba, *pbuf;
LoadTGA
=============
*/
-qbyte *LoadTGA (qbyte *f, int matchwidth, int matchheight)
+qbyte *LoadTGA (const qbyte *f, int matchwidth, int matchheight)
{
- int x, y, row_inc, compressed, readpixelcount, red, green, blue, alpha, runlen, pindex;
+ int x, y, row_inc, compressed, readpixelcount, red, green, blue, alpha, runlen, pindex, alphabits;
qbyte *pixbuf, *image_rgba;
- qbyte *fin, *enddata;
+ const qbyte *fin, *enddata;
TargaHeader targa_header;
unsigned char palette[256*4], *p;
targa_header.pixel_size = f[16];
targa_header.attributes = f[17];
+ // advance to end of header
fin = f + 18;
- if (targa_header.id_length != 0)
- fin += targa_header.id_length; // skip TARGA image comment
- if (targa_header.image_type == 2 || targa_header.image_type == 10)
- {
- if (targa_header.pixel_size != 24 && targa_header.pixel_size != 32)
- {
- Con_Print("LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n");
- PrintTargaHeader(&targa_header);
- return NULL;
- }
- }
- else if (targa_header.image_type == 1 || targa_header.image_type == 9)
+
+ // skip TARGA image comment (usually 0 bytes)
+ fin += targa_header.id_length;
+
+ // read/skip the colormap if present (note: according to the TARGA spec it
+ // can be present even on truecolor or greyscale images, just not used by
+ // the image data)
+ if (targa_header.colormap_type)
{
- if (targa_header.pixel_size != 8)
- {
- Con_Print("LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
- PrintTargaHeader(&targa_header);
- return NULL;
- }
if (targa_header.colormap_length > 256)
{
Con_Print("LoadTGA: only up to 256 colormap_length supported\n");
return NULL;
}
}
+
+ // check our pixel_size restrictions according to image_type
+ if (targa_header.image_type == 2 || targa_header.image_type == 10)
+ {
+ if (targa_header.pixel_size != 24 && targa_header.pixel_size != 32)
+ {
+ Con_Print("LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n");
+ PrintTargaHeader(&targa_header);
+ return NULL;
+ }
+ }
+ else if (targa_header.image_type == 1 || targa_header.image_type == 9)
+ {
+ if (targa_header.pixel_size != 8)
+ {
+ Con_Print("LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
+ PrintTargaHeader(&targa_header);
+ return NULL;
+ }
+ }
else if (targa_header.image_type == 3 || targa_header.image_type == 11)
{
if (targa_header.pixel_size != 8)
row_inc = 0;
}
+ // number of attribute bits per pixel, we only support 0 or 8
+ alphabits = targa_header.attributes & 0x0F;
+ if (alphabits != 8 && alphabits != 0)
+ {
+ Con_Print("LoadTGA: only 0 or 8 attribute (alpha) bits supported\n");
+ return NULL;
+ }
+
compressed = targa_header.image_type == 9 || targa_header.image_type == 10 || targa_header.image_type == 11;
x = 0;
y = 0;
red = green = blue = *fin++;
break;
}
+ if (!alphabits)
+ alpha = 255;
}
}
*pixbuf++ = red;
LoadLMP
============
*/
-qbyte *LoadLMP (qbyte *f, int matchwidth, int matchheight)
+qbyte *LoadLMP (const qbyte *f, int matchwidth, int matchheight, qboolean loadAs8Bit)
{
- qbyte *image_rgba;
+ qbyte *image_buffer;
if (fs_filesize < 9)
{
}
// parse the very complicated header *chuckle*
- image_width = f[0] + f[1] * 256 + f[2] * 65536 + f[3] * 16777216;
- image_height = f[4] + f[5] * 256 + f[6] * 65536 + f[7] * 16777216;
+ image_width = BuffLittleLong(f);
+ image_height = BuffLittleLong(f + 4);
if (image_width > 4096 || image_height > 4096 || image_width <= 0 || image_height <= 0)
{
Con_Printf("LoadLMP: invalid size %ix%i\n", image_width, image_height);
return NULL;
}
- image_rgba = Mem_Alloc(tempmempool, image_width * image_height * 4);
- if (!image_rgba)
+ if (loadAs8Bit)
{
- Con_Printf("LoadLMP: not enough memory for %i by %i image\n", image_width, image_height);
- return NULL;
+ image_buffer = Mem_Alloc(tempmempool, image_width * image_height);
+ memcpy(image_buffer, f + 8, image_width * image_height);
}
- Image_Copy8bitRGBA(f + 8, image_rgba, image_width * image_height, palette_complete);
- return image_rgba;
+ else
+ {
+ image_buffer = Mem_Alloc(tempmempool, image_width * image_height * 4);
+ Image_Copy8bitRGBA(f + 8, image_buffer, image_width * image_height, palette_complete);
+ }
+ return image_buffer;
+}
+
+static qbyte *LoadLMPRGBA (const qbyte *f, int matchwidth, int matchheight)
+{
+ return LoadLMP(f, matchwidth, matchheight, false);
}
+
typedef struct
{
char name[32];
int value;
} q2wal_t;
-qbyte *LoadWAL (qbyte *f, int matchwidth, int matchheight)
+qbyte *LoadWAL (const qbyte *f, int matchwidth, int matchheight)
{
qbyte *image_rgba;
const q2wal_t *inwal = (const void *)f;
}
-
-/*
-============
-LoadLMP
-============
-*/
-qbyte *LoadLMPAs8Bit (qbyte *f, int matchwidth, int matchheight)
-{
- qbyte *image_8bit;
-
- if (fs_filesize < 9)
- {
- Con_Print("LoadLMPAs8Bit: invalid LMP file\n");
- return NULL;
- }
-
- // parse the very complicated header *chuckle*
- image_width = f[0] + f[1] * 256 + f[2] * 65536 + f[3] * 16777216;
- image_height = f[4] + f[5] * 256 + f[6] * 65536 + f[7] * 16777216;
- if (image_width > 4096 || image_height > 4096 || image_width <= 0 || image_height <= 0)
- {
- Con_Printf("LoadLMPAs8Bit: invalid size %ix%i\n", image_width, image_height);
- return NULL;
- }
- if ((matchwidth && image_width != matchwidth) || (matchheight && image_height != matchheight))
- return NULL;
-
- if (fs_filesize < 8 + image_width * image_height)
- {
- Con_Print("LoadLMPAs8Bit: invalid LMP file\n");
- return NULL;
- }
-
- image_8bit = Mem_Alloc(tempmempool, image_width * image_height);
- if (!image_8bit)
- {
- Con_Printf("LoadLMPAs8Bit: not enough memory for %i by %i image\n", image_width, image_height);
- return NULL;
- }
- memcpy(image_8bit, f + 8, image_width * image_height);
- return image_8bit;
-}
-
void Image_StripImageExtension (const char *in, char *out)
{
const char *end, *temp;
struct
{
const char *formatstring;
- qbyte *(*loadfunc)(qbyte *f, int matchwidth, int matchheight);
+ qbyte *(*loadfunc)(const qbyte *f, int matchwidth, int matchheight);
}
imageformats[] =
{
{"%s.tga", LoadTGA},
{"%s.jpg", JPEG_LoadImage},
{"%s.pcx", LoadPCX},
- {"%s.lmp", LoadLMP},
+ {"%s.lmp", LoadLMPRGBA},
{NULL, NULL}
};
char basename[MAX_QPATH], name[MAX_QPATH], *c;
if (developer_memorydebug.integer)
Mem_CheckSentinelsGlobal();
- Image_StripImageExtension(filename, basename); // strip filename extensions to allow replacement by other types
+ if (developer_texturelogging.integer)
+ Log_Printf("textures.log", "%s\n", filename);
+ strlcpy(basename, filename, sizeof(basename));
+ Image_StripImageExtension(basename, basename); // strip filename extensions to allow replacement by other types
// replace *'s with #, so commandline utils don't get confused when dealing with the external files
for (c = basename;*c;c++)
if (*c == '*')
buffer[14] = (height >> 0) & 0xFF;
buffer[15] = (height >> 8) & 0xFF;
buffer[16] = 32; // pixel size
+ buffer[17] = 8; // transparent flag? (seems to be needed by gimp)
// swap rgba to bgra and flip upside down
out = buffer + 18;
}
}
-int resamplerowsize = 0;
-qbyte *resamplerow1 = NULL;
-qbyte *resamplerow2 = NULL;
-mempool_t *resamplemempool = NULL;
-
#define LERPBYTE(i) r = resamplerow1[i];out[i] = (qbyte) ((((resamplerow2[i] - r) * lerp) >> 16) + r)
void Image_Resample32Lerp(const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
{
int i, j, r, yi, oldy, f, fstep, lerp, endy = (inheight-1), inwidth4 = inwidth*4, outwidth4 = outwidth*4;
qbyte *out;
const qbyte *inrow;
+ qbyte *resamplerow1;
+ qbyte *resamplerow2;
out = outdata;
fstep = (int) (inheight*65536.0f/outheight);
+ resamplerow1 = Mem_Alloc(tempmempool, outwidth*4*2);
+ resamplerow2 = resamplerow1 + outwidth*4;
+
inrow = indata;
oldy = 0;
Image_Resample32LerpLine (inrow, resamplerow1, inwidth, outwidth);
memcpy(out, resamplerow1, outwidth4);
}
}
+
+ Mem_Free(resamplerow1);
+ resamplerow1 = NULL;
+ resamplerow2 = NULL;
}
-void Image_Resample32Nearest(const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
+void Image_Resample32Nolerp(const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
{
int i, j;
unsigned frac, fracstep;
int i, j, r, yi, oldy, f, fstep, lerp, endy = (inheight-1), inwidth3 = inwidth * 3, outwidth3 = outwidth * 3;
qbyte *out;
const qbyte *inrow;
+ qbyte *resamplerow1;
+ qbyte *resamplerow2;
out = outdata;
fstep = (int) (inheight*65536.0f/outheight);
+ resamplerow1 = Mem_Alloc(tempmempool, outwidth*3*2);
+ resamplerow2 = resamplerow1 + outwidth*3;
+
inrow = indata;
oldy = 0;
Image_Resample24LerpLine (inrow, resamplerow1, inwidth, outwidth);
memcpy(out, resamplerow1, outwidth3);
}
}
+ Mem_Free(resamplerow1);
+ resamplerow1 = NULL;
+ resamplerow2 = NULL;
}
void Image_Resample24Nolerp(const void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
void Image_Resample (const void *indata, int inwidth, int inheight, int indepth, void *outdata, int outwidth, int outheight, int outdepth, int bytesperpixel, int quality)
{
if (indepth != 1 || outdepth != 1)
- Sys_Error("Image_Resample: 3D resampling not supported\n");
- if (resamplerowsize < outwidth*4)
{
- if (resamplerow1)
- Mem_Free(resamplerow1);
- resamplerowsize = outwidth*4;
- if (!resamplemempool)
- resamplemempool = Mem_AllocPool("Image Scaling Buffer", 0, NULL);
- resamplerow1 = Mem_Alloc(resamplemempool, resamplerowsize*2);
- resamplerow2 = resamplerow1 + resamplerowsize;
+ Con_Printf ("Image_Resample: 3D resampling not supported\n");
+ return;
}
if (bytesperpixel == 4)
{
if (quality)
Image_Resample32Lerp(indata, inwidth, inheight, outdata, outwidth, outheight);
else
- Image_Resample32Nearest(indata, inwidth, inheight, outdata, outwidth, outheight);
+ Image_Resample32Nolerp(indata, inwidth, inheight, outdata, outwidth, outheight);
}
else if (bytesperpixel == 3)
{
Image_Resample24Nolerp(indata, inwidth, inheight, outdata, outwidth, outheight);
}
else
- Sys_Error("Image_Resample: unsupported bytesperpixel %i\n", bytesperpixel);
+ Con_Printf ("Image_Resample: unsupported bytesperpixel %i\n", bytesperpixel);
}
// in can be the same as out
{
int x, y, nextrow;
if (*depth != 1 || destdepth != 1)
- Sys_Error("Image_Resample: 3D resampling not supported\n");
+ {
+ Con_Printf ("Image_Resample: 3D resampling not supported\n");
+ return;
+ }
nextrow = *width * bytesperpixel;
if (*width > destwidth)
{
}
}
else
- Sys_Error("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
+ Con_Printf ("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
}
else
{
}
}
else
- Sys_Error("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
+ Con_Printf ("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
}
}
else
}
}
else
- Sys_Error("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
+ Con_Printf ("Image_MipReduce: unsupported bytesperpixel %i\n", bytesperpixel);
}
else
- Sys_Error("Image_MipReduce: desired size already achieved\n");
+ Con_Printf ("Image_MipReduce: desired size already achieved\n");
}
}
out[0] = 128.0f + n[0] * 127.0f;
out[1] = 128.0f + n[1] * 127.0f;
out[2] = 128.0f + n[2] * 127.0f;
- out[3] = 255;
+ out[3] = (p0[0] + p0[1] + p0[2]) / 3;
out += 4;
}
}
qbyte *bumppixels;
int bumppixels_width, bumppixels_height;
char name[MAX_QPATH];
- Image_StripImageExtension(shadername, name);
+ strlcpy(name, shadername, sizeof(name));
+ Image_StripImageExtension(name, name);
memset(s, 0, sizeof(*s));
s->basepixels = loadimagepixels(name, false, 0, 0);
if (s->basepixels == NULL)
projects / xonotic / darkplaces.git / blobdiff