hw_cache: use verstable for flat precache checking + convert back to C

This commit is contained in:
alufolie91 committed 2026-02-24 15:11:33 +01:00
1 parent 7b2e28ef84
commit 39408c3623
4 files changed
+162 -185

No files matched your search

+1 -1
View File
@@ -2,7 +2,7 @@ hw_bsp.c
hw_draw.c
hw_main.cpp
hw_clip.c
hw_md2.cpp
hw_md2.c
hw_cache.c
hw_md2load.c
hw_md3load.c
@@ -15,9 +15,6 @@
#ifdef HWRENDER
#include <unordered_set>
#include <unordered_map>
#include "hw_main.h"
#include "hw_glob.h"
#include "hw_gl.h"
@@ -36,10 +33,6 @@
#include "../p_spec.h" // anim_t
#include "../r_sky.h"
struct ColorMipMap {
std::unordered_map<const UINT8*, GLMipmap_t*> map;
};
INT32 patchformat = GL_TEXFMT_AP_88; // use alpha for holes
INT32 textureformat = GL_TEXFMT_P_8; // use chromakey for hole
@@ -105,7 +98,7 @@ static void HWR_DrawColumnInCache(const column_t *patchcol, UINT8 *block, GLMipm
position = 0;
}
position = std::max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
position = max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
if (position + count >= pblockheight)
count = pblockheight - position;
@@ -169,7 +162,7 @@ static void HWR_DrawPatchInCache(GLMipmap_t *mipmap,
fixed_t xfrac, xfracstep;
fixed_t yfracstep, scale_y;
const column_t *patchcol;
UINT8 *block = static_cast<UINT8 *>(mipmap->data);
UINT8 *block = (UINT8 *)(mipmap->data);
INT32 bpp;
INT32 blockmodulo;
RGBA_t *palette;
@@ -219,7 +212,7 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
fixed_t xfrac, xfracstep;
fixed_t yfracstep, scale_y;
const column_t *patchcol;
UINT8 *block = static_cast<UINT8 *>(mipmap->data);
UINT8 *block = (UINT8 *)(mipmap->data);
INT32 bpp;
INT32 blockmodulo;
INT32 width, height;
@@ -295,7 +288,7 @@ static UINT8 *MakeBlock(GLMipmap_t *glMipmap)
INT32 blocksize = (glMipmap->width * glMipmap->height);
bpp = format2bpp(glMipmap->format);
block = static_cast<UINT8 *>(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
block = (UINT8 *)(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
switch (bpp)
{
@@ -332,7 +325,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
texture = textures[texnum];
gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
gltex->mipmap.format = static_cast<GLTextureFormat_t>(textureformat);
gltex->mipmap.format = (GLTextureFormat_t)(textureformat);
// hack the Legacy skies..
if (UNLIKELY(memcmp(texture->name, "SKY", 3) == 0 &&
@@ -351,7 +344,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
colormap += COLORMAP_REMAPOFFSET;
#endif
gltex->mipmap.colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
gltex->mipmap.colormap = (GLColormap_t *)(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
gltex->mipmap.colormap->source = colormap;
memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
@@ -384,7 +377,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
// Composite the columns together.
for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
{
pdata = static_cast<UINT8 *>(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
pdata = (UINT8 *)(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
realpatch = (softwarepatch_t *)pdata;
HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
@@ -420,7 +413,7 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
glMipmap->flags = 0;
// setup the texture info
glMipmap->format = static_cast<GLTextureFormat_t>(patchformat);
glMipmap->format = (GLTextureFormat_t)(patchformat);
glPatch->max_s = (float)patch->width / (float)glMipmap->width;
glPatch->max_t = (float)patch->height / (float)glMipmap->height;
@@ -462,7 +455,7 @@ static void HWR_FreeTextureData(patch_t *patch)
if (!patch || !patch->hardware)
return;
glPatch = static_cast<GLPatch_t *>(patch->hardware);
glPatch = (GLPatch_t *)(patch->hardware);
if (vid.glstate == VID_GL_LIBRARY_LOADED)
GL_DeleteTexture(glPatch->mipmap);
@@ -478,7 +471,7 @@ void HWR_FreeTexture(patch_t *patch)
if (patch->hardware)
{
GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
HWR_FreeTextureColormaps(patch);
@@ -504,36 +497,39 @@ static void HWR_FreeTextureColormaps(patch_t *patch)
if (!patch)
return;
pat = static_cast<GLPatch_t *>(patch->hardware);
pat = (GLPatch_t *)(patch->hardware);
if (!pat)
return;
// The mipmap must be valid, obviously
if (!pat->mipmap)
return;
if (pat->mipmap->nextcolormap)
while (pat->mipmap)
{
for (auto& pair : pat->mipmap->nextcolormap->map)
{
GLMipmap_t *glMipmap = pair.second;
// Confusing at first, but pat->mipmap->nextcolormap
// at the beginning of the loop is the first colormap
// from the linked list of colormaps.
GLMipmap_t *next = NULL;
if (glMipmap)
{
// Free image data from memory.
Z_Free(glMipmap->data);
Z_Free(glMipmap->colormap);
glMipmap->data = NULL;
glMipmap->colormap = NULL;
GL_DeleteTexture(glMipmap);
// No mipmap in this patch, break out of the loop.
if (!pat->mipmap)
break;
// Free the colormap mipmap from memory.
free(glMipmap);
}
}
// No colormap mipmaps either.
if (!pat->mipmap->nextcolormap)
break;
delete pat->mipmap->nextcolormap;
pat->mipmap->nextcolormap = NULL;
// Set the first colormap to the one that comes after it.
next = pat->mipmap->nextcolormap;
pat->mipmap->nextcolormap = next->nextcolormap;
// Free image data from memory.
Z_Free(next->data);
Z_Free(next->colormap);
next->data = NULL;
next->colormap = NULL;
GL_DeleteTexture(next);
// Free the old colormap mipmap from memory.
free(next);
}
}
@@ -616,24 +612,20 @@ void HWR_FreeMapTextures(void)
gl_numtextures = 0;
}
#define NAME lumpset
#define KEY_TY UINT32
#define HASH_FN vt_hash_integer
#define CMPR_FN vt_cmpr_integer
#include "../verstable.h"
static void HWR_PrecacheLevelFlats(void)
{
// lookup for flats that may´ve been already loaded
// too lazy to make a hashtable or smth so unordered set will do :carbuncle:
std::unordered_set<UINT32> flatpresent;
lumpset flatpresent;
lumpset_init(&flatpresent);
size_t i, j;
INT32 k;
auto load_flat = [&](lumpnum_t lump, boolean noencoremap)
{
// flat already loaded?
if (flatpresent.count(lump) == 0)
{
HWR_GetFlat(lump, noencoremap);
flatpresent.insert(lump);
}
};
// special case for encore
#ifdef GLENCORE
if (encoremap)
@@ -651,14 +643,23 @@ static void HWR_PrecacheLevelFlats(void)
const levelflat_t *levelflat = &levelflats[pic];
load_flat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
if (lumpset_is_end(lumpset_get(&flatpresent, levelflat->lumpnum)))
{
HWR_GetFlat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
lumpset_insert(&flatpresent, levelflat->lumpnum);
}
if (levelflat->speed) // is it an animated flat ?
{
// start from 0, occasionally basenumlump != flat->lumpnum
for (k = 0; k < levelflat->numpics; k++)
{
load_flat(levelflat->baselumpnum + k, R_NoEncore(sec, ceiling));
lumpnum_t lump = levelflat->baselumpnum + k;
if (lumpset_is_end(lumpset_get(&flatpresent, lump)))
{
HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
lumpset_insert(&flatpresent, lump);
}
}
}
}
@@ -673,18 +674,29 @@ static void HWR_PrecacheLevelFlats(void)
{
const levelflat_t *levelflat = &levelflats[i];
load_flat(levelflat->lumpnum, false);
if (lumpset_is_end(lumpset_get(&flatpresent, levelflat->lumpnum)))
{
HWR_GetFlat(levelflat->lumpnum, false);
lumpset_insert(&flatpresent, levelflat->lumpnum);
}
if (levelflat->speed) // is it an animated flat ?
{
// start from 0, occasionally basenumlump != flat->lumpnum
for (k = 0; k < levelflat->numpics; k++)
{
load_flat(levelflat->baselumpnum + k, false);
lumpnum_t lump = levelflat->baselumpnum + k;
if (lumpset_is_end(lumpset_get(&flatpresent, lump)))
{
HWR_GetFlat(lump, false);
lumpset_insert(&flatpresent, lump);
}
}
}
}
}
lumpset_cleanup(&flatpresent);
}
static void HWR_PrecacheLevelTextures(void)
@@ -694,7 +706,7 @@ static void HWR_PrecacheLevelTextures(void)
size_t i, j, f;
INT32 h;
texturepresent = static_cast<char *>(calloc(gl_numtextures, sizeof(*texturepresent)));
texturepresent = (char *)(calloc(gl_numtextures, sizeof(*texturepresent)));
if (texturepresent == NULL)
I_Error("%s: Out of memory looking up textures", "HWR_PrecacheLevel");
@@ -869,7 +881,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
HWR_FreeMapTextures();
gl_numtextures = pnumtextures;
gl_textures = static_cast<GLMapTextureSet_t *>(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
gl_textures = (GLMapTextureSet_t *)(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
if (gl_textures == NULL)
I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
@@ -966,7 +978,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data));
#ifdef GLENCORE
flat = static_cast<UINT8 *>(glMipmap->data);
flat = (UINT8 *)(glMipmap->data);
for (steppy = 0; steppy < size; steppy++)
{
if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX)
@@ -1010,7 +1022,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
if (!noencoremap && encoremap)
colormap += COLORMAP_REMAPOFFSET;
#endif
glMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
glMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
glMipmap->colormap->source = colormap;
memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
}
@@ -1034,7 +1046,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
// --------------------+
static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
{
GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
if (!glMipmap->downloaded)
{
@@ -1055,7 +1067,7 @@ static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
// ----------------------+
static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
{
GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware);
HWR_MakePatch(patch, glPatch, glMipmap, true);
// If hardware does not have the texture, then call GL_SetTexture to upload it
@@ -1087,11 +1099,11 @@ void HWR_GetPatch(patch_t *patch)
void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
{
GLPatch_t *glPatch;
GLMipmap_t *newMipmap;
GLMipmap_t *glMipmap, *newMipmap;
if (!patch->hardware)
Patch_CreateGL(patch);
glPatch = static_cast<GLPatch_t *>(patch->hardware);
glPatch = (GLPatch_t *)(patch->hardware);
// Blatant hack for encore colormapping aside...
if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
@@ -1101,19 +1113,11 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
return;
}
// gotta make our map if theres none
if (!glPatch->mipmap->nextcolormap)
{
glPatch->mipmap->nextcolormap = new ColorMipMap();
}
// search for the mipmap
auto& map = glPatch->mipmap->nextcolormap->map;
auto it = map.find(colormap);
if (it != map.end())
// skip the first (no colormap translated)
for (glMipmap = glPatch->mipmap; glMipmap->nextcolormap;)
{
GLMipmap_t *glMipmap = it->second;
glMipmap = glMipmap->nextcolormap;
if (glMipmap->colormap && glMipmap->colormap->source == colormap)
{
@@ -1137,14 +1141,12 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
// (it have a liste of mipmap)
// this malloc is cleared in HWR_FreeColormapCache
// (...) unfortunately z_malloc fragment alot the memory :(so malloc is better
newMipmap = static_cast<GLMipmap_t *>(calloc(1, sizeof (*newMipmap)));
newMipmap = (GLMipmap_t *)(calloc(1, sizeof (*newMipmap)));
if (newMipmap == NULL)
I_Error("%s: Out of memory", "HWR_GetMappedPatch");
glMipmap->nextcolormap = newMipmap;
// add to nextcolormap map
map[colormap] = newMipmap;
newMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
newMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
newMipmap->colormap->source = colormap;
memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
@@ -1167,7 +1169,7 @@ patch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
{
void *ptr = Z_Calloc(sizeof(patch_t), PU_PATCH, &lumpcache[lumpnum]);
Patch_Create(NULL, 0, ptr);
Patch_AllocateHardwarePatch(static_cast<patch_t *>(ptr));
Patch_AllocateHardwarePatch((patch_t *)(ptr));
}
return (patch_t *)(lumpcache[lumpnum]);
@@ -1184,7 +1186,7 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
{
INT32 i,j;
fixed_t posx, posy, stepx, stepy;
UINT8 *block = static_cast<UINT8 *>(mipmap->data); // places the data directly into here
UINT8 *block = (UINT8 *)(mipmap->data); // places the data directly into here
UINT8 *flat;
UINT8 *dest, *src, texel;
RGBA_t col;
@@ -1340,7 +1342,7 @@ void HWR_SetPalette(RGBA_t *palette)
static void HWR_SetPaletteLookup(RGBA_t *palette)
{
int r, g, b;
UINT8 *lut = static_cast<UINT8 *>(Z_Malloc(
UINT8 *lut = (UINT8 *)(Z_Malloc(
HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*sizeof(UINT8),
PU_STATIC, NULL));
#define STEP_SIZE (256/HWR_PALETTE_LUT_SIZE)
@@ -1385,7 +1387,7 @@ void HWR_SetMapPalette(void)
if (palsize < 768) // 256 * 3
I_Error("HWR_SetMapPalette: A programmer assumed palette lumps are at least 768 bytes long, but apparently this was a wrong assumption!\n");
RGB_data = static_cast<UINT8 *>(W_CacheLumpNum(lumpnum, PU_CACHE));
RGB_data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_CACHE));
// we got the RGB palette now, but we need it in RGBA format.
for (i = 0; i < 256; i++)
{
@@ -1420,7 +1422,7 @@ static UINT32 HWR_CreateLightTable(UINT8 *lighttable)
{
UINT32 i, id;
RGBA_t *palette = HWR_GetTexturePalette();
RGBA_t *hw_lighttable = static_cast<RGBA_t *>(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
RGBA_t *hw_lighttable = (RGBA_t *)(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
// To make the palette index -> RGBA mapping easier for the shader,
// the hardware lighttable is composed of RGBA colors instead of palette indices.
+1 -2
View File
@@ -23,7 +23,6 @@
typedef enum GLTextureFormat_e
{
GL_TEXFMT_NULL = 0x00,
GL_TEXFMT_P_8 = 0x01, /* 8-bit palette */
GL_TEXFMT_AP_88 = 0x02, /* 8-bit alpha, 8-bit palette */
@@ -55,7 +54,7 @@ struct GLMipmap_s
UINT16 width, height;
UINT32 downloaded; // The GPU has this texture.
struct ColorMipMap *nextcolormap;
struct GLMipmap_s *nextcolormap;
struct GLColormap_s *colormap;
};
typedef struct GLMipmap_s GLMipmap_t;
@@ -13,7 +13,6 @@
/// Inspired from md2.c by Mete Ciragan (mete@swissquake.ch)
#include "hw_data.h"
#ifdef __GNUC__
#include <unistd.h>
#endif
@@ -73,12 +72,6 @@
#include <errno.h>
#endif
#include <unordered_map>
struct ColorMipMap {
std::unordered_map<const UINT8*, GLMipmap_t*> map;
};
md2_t md2_models[NUMSPRITES] = {};
md2_t md2_playermodels[MAXSKINS] = {};
md2_t md2_localplayermodels[MAXLOCALSKINS] = {};
@@ -100,10 +93,10 @@ static void md2_freeModel (model_t *model)
static model_t *md2_readModel(const char *filename)
{
//Filename checking fixed ~Monster Iestyn and Golden
if (FIL_FileExists(va("%s" PATHSEP "%s", srb2home, filename)))
return LoadModel(va("%s" PATHSEP "%s", srb2home, filename), PU_STATIC);
else if (FIL_FileExists(va("%s" PATHSEP "%s", srb2path, filename)))
return LoadModel(va("%s" PATHSEP "%s", srb2path, filename), PU_STATIC);
if (FIL_FileExists(va("%s"PATHSEP"%s", srb2home, filename)))
return LoadModel(va("%s"PATHSEP"%s", srb2home, filename), PU_STATIC);
else if (FIL_FileExists(va("%s"PATHSEP"%s", srb2path, filename)))
return LoadModel(va("%s"PATHSEP"%s", srb2path, filename), PU_STATIC);
return NULL;
}
@@ -166,18 +159,18 @@ static GLTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_
#endif
volatile png_FILE_p png_FILE;
//Filename checking fixed ~Monster Iestyn and Golden
char *pngfilename = va("%s" PATHSEP "mdls" PATHSEP "%s", srb2home, filename);
char *pngfilename = va("%s"PATHSEP"mdls"PATHSEP"%s", srb2home, filename);
FIL_ForceExtension(pngfilename, ".png");
png_FILE = fopen(pngfilename, "rb");
if (!png_FILE)
{
pngfilename = va("%s" PATHSEP "mdls" PATHSEP "%s", srb2path, filename);
pngfilename = va("%s"PATHSEP"mdls"PATHSEP"%s", srb2path, filename);
FIL_ForceExtension(pngfilename, ".png");
png_FILE = fopen(pngfilename, "rb");
//CONS_Debug(DBG_RENDER, "M_SavePNG: Error on opening %s for loading\n", filename);
if (!png_FILE)
return GL_TEXFMT_NULL;
return 0;
}
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
@@ -186,7 +179,7 @@ static GLTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_
{
CONS_Debug(DBG_RENDER, "PNG_Load: Error on initialize libpng\n");
fclose(png_FILE);
return GL_TEXFMT_NULL;
return 0;
}
png_info_ptr = png_create_info_struct(png_ptr);
@@ -195,7 +188,7 @@ static GLTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_
CONS_Debug(DBG_RENDER, "PNG_Load: Error on allocate for libpng\n");
png_destroy_read_struct(&png_ptr, NULL, NULL);
fclose(png_FILE);
return GL_TEXFMT_NULL;
return 0;
}
#ifdef USE_FAR_KEYWORD
@@ -208,7 +201,7 @@ static GLTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_
png_destroy_read_struct(&png_ptr, &png_info_ptr, NULL);
fclose(png_FILE);
Z_Free(glpatch->mipmap->data);
return GL_TEXFMT_NULL;
return 0;
}
#ifdef USE_FAR_KEYWORD
png_memcpy(png_jmpbuf(png_ptr), jmpbuf, sizeof jmp_buf);
@@ -248,8 +241,8 @@ static GLTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_
{
png_uint_32 i, pitch = png_get_rowbytes(png_ptr, png_info_ptr);
png_bytep PNG_image = static_cast<png_bytep>(Z_Malloc(pitch*height, PU_HWRMODELTEXTURE, &glpatch->mipmap->data));
png_bytepp row_pointers = static_cast<png_bytepp>(png_malloc(png_ptr, height * sizeof (png_bytep)));
png_bytep PNG_image = Z_Malloc(pitch*height, PU_HWRMODELTEXTURE, &glpatch->mipmap->data);
png_bytepp row_pointers = png_malloc(png_ptr, height * sizeof (png_bytep));
for (i = 0; i < height; i++)
row_pointers[i] = PNG_image + i*pitch;
png_read_image(png_ptr, row_pointers);
@@ -299,42 +292,42 @@ static GLTextureFormat_t PCX_Load(const char *filename, int *w, int *h,
INT32 ch, rep;
FILE *file;
//Filename checking fixed ~Monster Iestyn and Golden
char *pcxfilename = va("%s" PATHSEP "mdls" PATHSEP "%s", srb2home, filename);
char *pcxfilename = va("%s"PATHSEP"mdls"PATHSEP"%s", srb2home, filename);
FIL_ForceExtension(pcxfilename, ".pcx");
file = fopen(pcxfilename, "rb");
if (!file)
{
pcxfilename = va("%s" PATHSEP "mdls" PATHSEP "%s", srb2path, filename);
pcxfilename = va("%s"PATHSEP"mdls"PATHSEP"%s", srb2path, filename);
FIL_ForceExtension(pcxfilename, ".pcx");
file = fopen(pcxfilename, "rb");
if (!file)
return GL_TEXFMT_NULL;
return 0;
}
if (fread(&header, sizeof (PcxHeader), 1, file) != 1)
{
fclose(file);
return GL_TEXFMT_NULL;
return 0;
}
if (header.bitsPerPixel != 8)
{
fclose(file);
return GL_TEXFMT_NULL;
return 0;
}
fseek(file, -PALSIZE, SEEK_END);
pw = *w = header.xmax - header.xmin + 1;
ph = *h = header.ymax - header.ymin + 1;
image = static_cast<RGBA_t *>(Z_Malloc(pw*ph*4, PU_HWRMODELTEXTURE, &glpatch->mipmap->data));
image = Z_Malloc(pw*ph*4, PU_HWRMODELTEXTURE, &glpatch->mipmap->data);
if (fread(palette, sizeof (UINT8), PALSIZE, file) != PALSIZE)
{
Z_Free(image);
fclose(file);
return GL_TEXFMT_NULL;
return 0;
}
fseek(file, sizeof (PcxHeader), SEEK_SET);
@@ -376,8 +369,8 @@ static void md2_loadTexture(md2_t *model)
if (model->glpatch)
{
patch = static_cast<patch_t *>(model->glpatch);
glPatch = static_cast<GLPatch_t *>(patch->hardware);
patch = model->glpatch;
glPatch = (GLPatch_t *)(patch->hardware);
if (glPatch)
Z_Free(glPatch->mipmap->data);
}
@@ -388,7 +381,7 @@ static void md2_loadTexture(md2_t *model)
Patch_AllocateHardwarePatch(patch);
if (glPatch == NULL)
glPatch = static_cast<GLPatch_t *>(patch->hardware);
glPatch = (GLPatch_t *)(patch->hardware);
if (!glPatch->mipmap->downloaded && !glPatch->mipmap->data)
{
@@ -396,10 +389,10 @@ static void md2_loadTexture(md2_t *model)
#ifdef HAVE_PNG
glPatch->mipmap->format = PNG_Load(filename, &w, &h, glPatch);
if (glPatch->mipmap->format == GL_TEXFMT_NULL)
if (glPatch->mipmap->format == 0)
#endif
glPatch->mipmap->format = PCX_Load(filename, &w, &h, glPatch);
if (glPatch->mipmap->format == GL_TEXFMT_NULL)
if (glPatch->mipmap->format == 0)
{
model->notexturefile = true; // mark it so its not searched for again repeatedly
return;
@@ -419,7 +412,7 @@ static void md2_loadTexture(md2_t *model)
UINT32 size;
RGBA_t *image;
// Lactozilla: Apply colour cube
image = static_cast<RGBA_t *>(glPatch->mipmap->data);
image = glPatch->mipmap->data;
size = w*h;
while (size--)
{
@@ -440,7 +433,7 @@ static void md2_loadBlendTexture(md2_t *model)
patch_t *patch;
GLPatch_t *glPatch = NULL;
char *filename = static_cast<char *>(Z_Malloc(strlen(model->filename)+7, PU_STATIC, NULL));
char *filename = Z_Malloc(strlen(model->filename)+7, PU_STATIC, NULL);
strcpy(filename, model->filename);
@@ -448,8 +441,8 @@ static void md2_loadBlendTexture(md2_t *model)
if (model->blendglpatch)
{
patch = static_cast<patch_t *>(model->blendglpatch);
glPatch = static_cast<GLPatch_t *>(patch->hardware);
patch = model->blendglpatch;
glPatch = (GLPatch_t *)(patch->hardware);
if (glPatch)
Z_Free(glPatch->mipmap->data);
}
@@ -460,17 +453,17 @@ static void md2_loadBlendTexture(md2_t *model)
Patch_AllocateHardwarePatch(patch);
if (glPatch == NULL)
glPatch = static_cast<GLPatch_t *>(patch->hardware);
glPatch = (GLPatch_t *)(patch->hardware);
if (!glPatch->mipmap->downloaded && !glPatch->mipmap->data)
{
int w = 0, h = 0;
#ifdef HAVE_PNG
glPatch->mipmap->format = PNG_Load(filename, &w, &h, glPatch);
if (glPatch->mipmap->format == GL_TEXFMT_NULL)
if (glPatch->mipmap->format == 0)
#endif
glPatch->mipmap->format = PCX_Load(filename, &w, &h, glPatch);
if (glPatch->mipmap->format == GL_TEXFMT_NULL)
if (glPatch->mipmap->format == 0)
{
model->noblendfile = true; // mark it so its not searched for again repeatedly
Z_Free(filename);
@@ -539,11 +532,11 @@ void HWR_InitMD2(void)
// read the mdls.dat file
//Filename checking fixed ~Monster Iestyn and Golden
f = fopen(va("%s" PATHSEP "%s", srb2home, "mdls.dat"), "rt");
f = fopen(va("%s"PATHSEP"%s", srb2home, "mdls.dat"), "rt");
if (!f)
{
f = fopen(va("%s" PATHSEP "%s", srb2path, "mdls.dat"), "rt");
f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
if (!f)
{
CONS_Printf("%s %s\n", M_GetText("Error while loading mdls.dat:"), strerror(errno));
@@ -600,11 +593,11 @@ void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added af
// read the mdls.dat file
//Filename checking fixed ~Monster Iestyn and Golden
f = fopen(va("%s" PATHSEP "%s", srb2home, "mdls.dat"), "rt");
f = fopen(va("%s"PATHSEP"%s", srb2home, "mdls.dat"), "rt");
if (!f)
{
f = fopen(va("%s" PATHSEP "%s", srb2path, "mdls.dat"), "rt");
f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
if (!f)
{
CONS_Printf("%s %s\n", M_GetText("Error while loading mdls.dat:"), strerror(errno));
@@ -652,11 +645,11 @@ void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startu
// Read the md2.dat file
//Filename checking fixed ~Monster Iestyn and Golden
f = fopen(va("%s" PATHSEP "%s", srb2home, "mdls.dat"), "rt");
f = fopen(va("%s"PATHSEP"%s", srb2home, "mdls.dat"), "rt");
if (!f)
{
f = fopen(va("%s" PATHSEP "%s", srb2path, "mdls.dat"), "rt");
f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
if (!f)
{
@@ -696,21 +689,19 @@ spritemd2found:
static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMipmap_t *glMipmap, INT32 skinnum, skincolors_t color)
{
GLPatch_t *hwrPatch = static_cast<GLPatch_t *>(gpatch->hardware);
GLPatch_t *hwrBlendPatch = static_cast<GLPatch_t *>(blendgpatch->hardware);
GLPatch_t *hwrPatch = gpatch->hardware;
GLPatch_t *hwrBlendPatch = blendgpatch->hardware;
UINT16 w = gpatch->width, h = gpatch->height;
UINT32 size = w*h;
RGBA_t *image, *blendimage, *cur, blendcolor;
RGBA_t *image, *blendimage, *cur;
RGBA_t blendcolor = {};
RGBA_t *palette = HWR_GetTexturePalette();
UINT8 translation[17]; // First the color index
UINT8 cutoff[17]; // Brightness cutoff before using the next color
UINT8 translation[17] = {}; // First the color index
UINT8 cutoff[17] = {}; // Brightness cutoff before using the next color
UINT8 translen = 0;
UINT8 i;
UINT8 colorbrightnesses[17];
UINT8 color_match_lookup[256]; // optimization attempt
memset(translation, 0, sizeof(translation));
memset(cutoff, 0, sizeof(cutoff));
UINT8 colorbrightnesses[17] = {};
UINT8 color_match_lookup[256] = {}; // optimization attempt
if (glMipmap->width == 0)
{
@@ -723,17 +714,13 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
glMipmap->format = GL_TEXFMT_RGBA;
}
if (glMipmap->data)
{
Z_Free(glMipmap->data);
glMipmap->data = NULL;
}
Z_Free(glMipmap->data);
glMipmap->data = NULL;
cur = static_cast<RGBA_t *>(Z_Malloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data));
memset(cur, 0x00, size*4);
cur = Z_Calloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data);
image = static_cast<RGBA_t *>(hwrPatch->mipmap->data);
blendimage = static_cast<RGBA_t *>(hwrBlendPatch->mipmap->data);
image = hwrPatch->mipmap->data;
blendimage = hwrBlendPatch->mipmap->data;
// TC_METALSONIC includes an actual skincolor translation, on top of its flashing.
if (skinnum == TC_METALSONIC)
@@ -979,15 +966,15 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
colorbright = 1; // no dividing by 0 please
tempcolor = (brightness * blendcolor.s.red) / colorbright;
tempcolor = std::min<UINT32>(255, tempcolor);
tempcolor = min(255, tempcolor);
cur->s.red = (UINT8)tempcolor;
tempcolor = (brightness * blendcolor.s.green) / colorbright;
tempcolor = std::min<UINT32>(255, tempcolor);
tempcolor = min(255, tempcolor);
cur->s.green = (UINT8)tempcolor;
tempcolor = (brightness * blendcolor.s.blue) / colorbright;
tempcolor = std::min<UINT32>(255, tempcolor);
tempcolor = min(255, tempcolor);
cur->s.blue = (UINT8)tempcolor;
cur->s.alpha = image->s.alpha;
}
@@ -997,15 +984,15 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
INT32 tempcolor;
tempcolor = ((image->s.red * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.red * blendimage->s.alpha) / 255);
tempcolor = std::min<UINT32>(255, tempcolor);
tempcolor = min(255, tempcolor);
cur->s.red = (UINT8)tempcolor;
tempcolor = ((image->s.green * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.green * blendimage->s.alpha) / 255);
tempcolor = std::min<UINT32>(255, tempcolor);
tempcolor = min(255, tempcolor);
cur->s.green = (UINT8)tempcolor;
tempcolor = ((image->s.blue * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.blue * blendimage->s.alpha) / 255);
tempcolor = std::min<UINT32>(255, tempcolor);
tempcolor = min(255, tempcolor);
cur->s.blue = (UINT8)tempcolor;
cur->s.alpha = image->s.alpha;
}
@@ -1041,30 +1028,21 @@ skippixel:
static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 skinnum, const UINT8 *colormap, skincolors_t color)
{
// mostly copied from HWR_GetMappedPatch, hence the similarities and comment
GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
GLMipmap_t *newMipmap;
GLPatch_t *glPatch = patch->hardware;
GLMipmap_t *glMipmap, *newMipmap;
if (blendgpatch == NULL || colormap == colormaps
|| colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
if (blendgpatch == NULL || colormap == colormaps || colormap == NULL)
{
// Don't do any blending
GL_SetTexture(glPatch->mipmap);
return;
}
// gotta make our map if theres none
if (!glPatch->mipmap->nextcolormap)
{
glPatch->mipmap->nextcolormap = new ColorMipMap();
}
// search for the Mipmap
auto& map = glPatch->mipmap->nextcolormap->map;
auto it = map.find(colormap);
if (it != map.end())
// skip the first (no colormap translated)
for (glMipmap = glPatch->mipmap; glMipmap->nextcolormap; )
{
GLMipmap_t *glMipmap = it->second;
glMipmap = glMipmap->nextcolormap;
if (glMipmap->colormap && glMipmap->colormap->source == colormap)
{
@@ -1092,14 +1070,12 @@ static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 sk
// (it have a liste of mipmap)
// this malloc is cleared in HWR_FreeTextureCache
// (...) unfortunately z_malloc fragment alot the memory :(so malloc is better
newMipmap = static_cast<GLMipmap_t *>(calloc(1, sizeof(*newMipmap)));
newMipmap = calloc(1, sizeof (*newMipmap));
if (newMipmap == NULL)
I_Error("%s: Out of memory", "HWR_GetBlendedTexture");
glMipmap->nextcolormap = newMipmap;
// add to nextcolormap map
map[colormap] = newMipmap;
newMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
newMipmap->colormap = Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL);
newMipmap->colormap->source = colormap;
memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
@@ -1196,7 +1172,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
else
blendmode = spr->mobj->blendmode;
blendmode = std::min<INT32>(AST_MODULATE, blendmode);
blendmode = min(AST_MODULATE, blendmode);
if (spr->mobj->flags2 & MF2_SHADOW)
{
@@ -1285,7 +1261,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
}
//Hurdler: arf, I don't like that implementation at all... too much crappy
gpatch = static_cast<patch_t *>(md2->glpatch);
gpatch = md2->glpatch;
if (gpatch)
hwrPatch = ((GLPatch_t *)gpatch->hardware);
@@ -1294,12 +1270,12 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
md2_loadTexture(md2);
// Load it again, because it isn't being loaded into gpatch after md2_loadtexture...
gpatch = static_cast<patch_t *>(md2->glpatch);
gpatch = md2->glpatch;
if (gpatch)
hwrPatch = ((GLPatch_t *)gpatch->hardware);
// Load blend texture
blendgpatch = static_cast<patch_t *>(md2->blendglpatch);
blendgpatch = md2->blendglpatch;
if (blendgpatch)
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
@@ -1309,7 +1285,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
md2_loadBlendTexture(md2);
// Load it again, because it isn't being loaded into blendgpatch after md2_loadblendtexture...
blendgpatch = static_cast<patch_t *>(md2->blendglpatch);
blendgpatch = md2->blendglpatch;
if (blendgpatch)
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
@@ -1525,7 +1501,7 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
else
frame = 0;
gpatch = static_cast<patch_t *>(md2->glpatch);
gpatch = (patch_t *)(md2->glpatch);
if (gpatch)
hwrPatch = ((GLPatch_t *)gpatch->hardware);
@@ -1533,11 +1509,11 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
((!hwrPatch->mipmap->format || !hwrPatch->mipmap->downloaded) && !md2->notexturefile))
md2_loadTexture(md2);
gpatch = static_cast<patch_t *>(md2->glpatch);
gpatch = (patch_t*)(md2->glpatch);
if (gpatch)
hwrPatch = ((GLPatch_t *)gpatch->hardware);
blendgpatch = static_cast<patch_t *>(md2->blendglpatch);
blendgpatch = (patch_t*)(md2->blendglpatch);
if (blendgpatch)
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
@@ -1546,7 +1522,7 @@ void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t c
((!hwrBlendPatch->mipmap->format || !hwrBlendPatch->mipmap->downloaded) && !md2->noblendfile)))
md2_loadBlendTexture(md2);
blendgpatch = static_cast<patch_t *>(md2->blendglpatch);
blendgpatch = (patch_t*)(md2->blendglpatch);
if (blendgpatch)
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);