vivlim
/
Kart-Public
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'kill-these-please-12' into 'awful-mix' 

Compiler errors, again, again

See merge request SinnamonLat/Kart-Public!5
This commit is contained in:
wolfs 2020-04-12 07:00:05 -04:00
parent da2a640c6c 60a38cbec3
commit ee0bba26f4
7 changed files with 77 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile.cfg
View File

@ -222,7 +222,7 @@ endif
ifdef GCC71 ifdef GCC71
WFLAGS+=-Wno-error=implicit-fallthrough WFLAGS+=-Wno-error=implicit-fallthrough
WFLAGS+=-Wno-implicit-fallthrough WFLAGS+=-Wno-implicit-fallthrough
WFLAGS+=-Wno-error=format-truncation WFLAGS+=-Wno-format-truncation
endif endif
ifdef GCC80 ifdef GCC80
WFLAGS+=-Wno-error=format-overflow WFLAGS+=-Wno-error=format-overflow

23
src/hardware/hw_cache.c
View File

@ -481,10 +481,10 @@ static void FreeMipmapColormap(INT32 patchnum, void *patch)
{ {
GLPatch_t* const grpatch = patch; GLPatch_t* const grpatch = patch;
(void)patchnum; //unused (void)patchnum; //unused
while (grpatch->mipmap.nextcolormap) while (grpatch->mipmap->nextcolormap)
{ {
GLMipmap_t *grmip = grpatch->mipmap.nextcolormap; GLMipmap_t *grmip = grpatch->mipmap->nextcolormap;
grpatch->mipmap.nextcolormap = grmip->nextcolormap; grpatch->mipmap->nextcolormap = grmip->nextcolormap;
if (grmip->grInfo.data) Z_Free(grmip->grInfo.data); if (grmip->grInfo.data) Z_Free(grmip->grInfo.data);
free(grmip); free(grmip);
} }
@ -638,7 +638,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
{ {
GLMipmap_t *grmip; GLMipmap_t *grmip;
grmip = &HWR_GetCachedGLPatch(flatlumpnum)->mipmap; grmip = HWR_GetCachedGLPatch(flatlumpnum)->mipmap;
grmip->colormap = colormaps; grmip->colormap = colormaps;
@ -690,22 +690,22 @@ static void HWR_LoadMappedPatch(GLMipmap_t *grmip, GLPatch_t *gpatch)
void HWR_GetPatch(GLPatch_t *gpatch) void HWR_GetPatch(GLPatch_t *gpatch)
{ {
// is it in hardware cache // is it in hardware cache
if (!gpatch->mipmap.downloaded && !gpatch->mipmap.grInfo.data) if (!gpatch->mipmap->downloaded && !gpatch->mipmap->grInfo.data)
{ {
// load the software patch, PU_STATIC or the Z_Malloc for hardware patch will // load the software patch, PU_STATIC or the Z_Malloc for hardware patch will
// flush the software patch before the conversion! oh yeah I suffered // flush the software patch before the conversion! oh yeah I suffered
patch_t *patch = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC); patch_t *patch = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC);
HWR_MakePatch(patch, gpatch, &gpatch->mipmap, true); HWR_MakePatch(patch, gpatch, gpatch->mipmap, true);
// this is inefficient.. but the hardware patch in heap is purgeable so it should // this is inefficient.. but the hardware patch in heap is purgeable so it should
// not fragment memory, and besides the REAL cache here is the hardware memory // not fragment memory, and besides the REAL cache here is the hardware memory
Z_Free(patch); Z_Free(patch);
} }
HWD.pfnSetTexture(&gpatch->mipmap); HWD.pfnSetTexture(gpatch->mipmap);
// The system-memory patch data can be purged now. // The system-memory patch data can be purged now.
Z_ChangeTag(gpatch->mipmap.grInfo.data, PU_HWRCACHE_UNLOCKED); Z_ChangeTag(gpatch->mipmap->grInfo.data, PU_HWRCACHE_UNLOCKED);
} }
@ -725,7 +725,7 @@ void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap)
// search for the mimmap // search for the mimmap
// skip the first (no colormap translated) // skip the first (no colormap translated)
for (grmip = &gpatch->mipmap; grmip->nextcolormap; ) for (grmip = gpatch->mipmap; grmip->nextcolormap; )
{ {
grmip = grmip->nextcolormap; grmip = grmip->nextcolormap;
if (grmip->colormap == colormap) if (grmip->colormap == colormap)
@ -755,7 +755,7 @@ void HWR_UnlockCachedPatch(GLPatch_t *gpatch)
if (!gpatch) if (!gpatch)
return; return;
Z_ChangeTag(gpatch->mipmap.grInfo.data, PU_HWRCACHE_UNLOCKED); Z_ChangeTag(gpatch->mipmap->grInfo.data, PU_HWRCACHE_UNLOCKED);
Z_ChangeTag(gpatch, PU_HWRPATCHINFO_UNLOCKED); Z_ChangeTag(gpatch, PU_HWRPATCHINFO_UNLOCKED);
} }
@ -769,6 +769,7 @@ GLPatch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
grpatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL); grpatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL);
grpatch->wadnum = wadnum; grpatch->wadnum = wadnum;
grpatch->lumpnum = lumpnum; grpatch->lumpnum = lumpnum;
grpatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, NULL);
M_AATreeSet(hwrcache, lumpnum, grpatch); M_AATreeSet(hwrcache, lumpnum, grpatch);
} }
@ -872,7 +873,7 @@ void HWR_GetFadeMask(lumpnum_t fademasklumpnum)
{ {
GLMipmap_t *grmip; GLMipmap_t *grmip;
grmip = &HWR_GetCachedGLPatch(fademasklumpnum)->mipmap; grmip = HWR_GetCachedGLPatch(fademasklumpnum)->mipmap;
if (!grmip->downloaded && !grmip->grInfo.data) if (!grmip->downloaded && !grmip->grInfo.data)
HWR_CacheFadeMask(grmip, fademasklumpnum); HWR_CacheFadeMask(grmip, fademasklumpnum);

4
src/hardware/hw_data.h
View File

@ -107,10 +107,10 @@ struct GLPatch_s
float max_s,max_t; float max_s,max_t;
UINT16 wadnum; // the software patch lump num for when the hardware patch UINT16 wadnum; // the software patch lump num for when the hardware patch
UINT16 lumpnum; // was flushed, and we need to re-create it UINT16 lumpnum; // was flushed, and we need to re-create it
GLMipmap_t mipmap; GLMipmap_t *mipmap;
boolean notfound; // if the texture file was not found, mark it here (used in model texture loading) boolean notfound; // if the texture file was not found, mark it here (used in model texture loading)
}; } ATTRPACK;
typedef struct GLPatch_s GLPatch_t; typedef struct GLPatch_s GLPatch_t;
#endif //_HWR_DATA_ #endif //_HWR_DATA_

2
src/hardware/hw_light.c
View File

@ -24,4 +24,4 @@
#include "../r_main.h" #include "../r_main.h"
#include "../p_local.h" #include "../p_local.h"
#endif // HWRENDER #endif // HWRENDER

88
src/hardware/hw_md2.c
View File

@ -199,7 +199,7 @@ static GLTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_
//CONS_Debug(DBG_RENDER, "libpng load error on %s\n", filename); //CONS_Debug(DBG_RENDER, "libpng load error on %s\n", filename);
png_destroy_read_struct(&png_ptr, &png_info_ptr, NULL); png_destroy_read_struct(&png_ptr, &png_info_ptr, NULL);
fclose(png_FILE); fclose(png_FILE);
Z_Free(grpatch->mipmap.grInfo.data); Z_Free(grpatch->mipmap->grInfo.data);
return 0; return 0;
} }
#ifdef USE_FAR_KEYWORD #ifdef USE_FAR_KEYWORD
@ -240,7 +240,7 @@ 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_uint_32 i, pitch = png_get_rowbytes(png_ptr, png_info_ptr);
png_bytep PNG_image = Z_Malloc(pitch*height, PU_HWRCACHE, &grpatch->mipmap.grInfo.data); png_bytep PNG_image = Z_Malloc(pitch*height, PU_HWRCACHE, &grpatch->mipmap->grInfo.data);
png_bytepp row_pointers = png_malloc(png_ptr, height * sizeof (png_bytep)); png_bytepp row_pointers = png_malloc(png_ptr, height * sizeof (png_bytep));
for (i = 0; i < height; i++) for (i = 0; i < height; i++)
row_pointers[i] = PNG_image + i*pitch; row_pointers[i] = PNG_image + i*pitch;
@ -320,7 +320,7 @@ static GLTextureFormat_t PCX_Load(const char *filename, int *w, int *h,
pw = *w = header.xmax - header.xmin + 1; pw = *w = header.xmax - header.xmin + 1;
ph = *h = header.ymax - header.ymin + 1; ph = *h = header.ymax - header.ymin + 1;
image = Z_Malloc(pw*ph*4, PU_HWRCACHE, &grpatch->mipmap.grInfo.data); image = Z_Malloc(pw*ph*4, PU_HWRCACHE, &grpatch->mipmap->grInfo.data);
if (fread(palette, sizeof (UINT8), PALSIZE, file) != PALSIZE) if (fread(palette, sizeof (UINT8), PALSIZE, file) != PALSIZE)
{ {
@ -368,40 +368,43 @@ static void md2_loadTexture(md2_t *model)
if (model->grpatch) if (model->grpatch)
{ {
grpatch = model->grpatch; grpatch = model->grpatch;
Z_Free(grpatch->mipmap.grInfo.data); Z_Free(grpatch->mipmap->grInfo.data);
} }
else else
{
grpatch = Z_Calloc(sizeof *grpatch, PU_HWRPATCHINFO, grpatch = Z_Calloc(sizeof *grpatch, PU_HWRPATCHINFO,
&(model->grpatch)); &(model->grpatch));
grpatch->mipmap = Z_Calloc(sizeof (GLMipmap_t), PU_HWRPATCHINFO, NULL);
}
if (!grpatch->mipmap.downloaded && !grpatch->mipmap.grInfo.data) if (!grpatch->mipmap->downloaded && !grpatch->mipmap->grInfo.data)
{ {
int w = 0, h = 0; int w = 0, h = 0;
#ifdef HAVE_PNG #ifdef HAVE_PNG
grpatch->mipmap.grInfo.format = PNG_Load(filename, &w, &h, grpatch); grpatch->mipmap->grInfo.format = PNG_Load(filename, &w, &h, grpatch);
if (grpatch->mipmap.grInfo.format == 0) if (grpatch->mipmap->grInfo.format == 0)
#endif #endif
grpatch->mipmap.grInfo.format = PCX_Load(filename, &w, &h, grpatch); grpatch->mipmap->grInfo.format = PCX_Load(filename, &w, &h, grpatch);
if (grpatch->mipmap.grInfo.format == 0) if (grpatch->mipmap->grInfo.format == 0)
{ {
grpatch->notfound = true;// mark it so its not searched for again repeatedly grpatch->notfound = true;// mark it so its not searched for again repeatedly
return; return;
} }
grpatch->mipmap.downloaded = 0; grpatch->mipmap->downloaded = 0;
grpatch->mipmap.flags = 0; grpatch->mipmap->flags = 0;
grpatch->width = (INT16)w; grpatch->width = (INT16)w;
grpatch->height = (INT16)h; grpatch->height = (INT16)h;
grpatch->mipmap.width = (UINT16)w; grpatch->mipmap->width = (UINT16)w;
grpatch->mipmap.height = (UINT16)h; grpatch->mipmap->height = (UINT16)h;
// not correct! // not correct!
grpatch->mipmap.grInfo.smallLodLog2 = GR_LOD_LOG2_256; grpatch->mipmap->grInfo.smallLodLog2 = GR_LOD_LOG2_256;
grpatch->mipmap.grInfo.largeLodLog2 = GR_LOD_LOG2_256; grpatch->mipmap->grInfo.largeLodLog2 = GR_LOD_LOG2_256;
grpatch->mipmap.grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1; grpatch->mipmap->grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
} }
HWD.pfnSetTexture(&grpatch->mipmap); HWD.pfnSetTexture(grpatch->mipmap);
HWR_UnlockCachedPatch(grpatch); HWR_UnlockCachedPatch(grpatch);
} }
@ -419,41 +422,44 @@ static void md2_loadBlendTexture(md2_t *model)
if (model->blendgrpatch) if (model->blendgrpatch)
{ {
grpatch = model->blendgrpatch; grpatch = model->blendgrpatch;
Z_Free(grpatch->mipmap.grInfo.data); Z_Free(grpatch->mipmap->grInfo.data);
} }
else else
{
grpatch = Z_Calloc(sizeof *grpatch, PU_HWRPATCHINFO, grpatch = Z_Calloc(sizeof *grpatch, PU_HWRPATCHINFO,
&(model->blendgrpatch)); &(model->blendgrpatch));
grpatch->mipmap = Z_Calloc(sizeof (GLMipmap_t), PU_HWRPATCHINFO, NULL);
}
if (!grpatch->mipmap.downloaded && !grpatch->mipmap.grInfo.data) if (!grpatch->mipmap->downloaded && !grpatch->mipmap->grInfo.data)
{ {
int w = 0, h = 0; int w = 0, h = 0;
#ifdef HAVE_PNG #ifdef HAVE_PNG
grpatch->mipmap.grInfo.format = PNG_Load(filename, &w, &h, grpatch); grpatch->mipmap->grInfo.format = PNG_Load(filename, &w, &h, grpatch);
if (grpatch->mipmap.grInfo.format == 0) if (grpatch->mipmap->grInfo.format == 0)
#endif #endif
grpatch->mipmap.grInfo.format = PCX_Load(filename, &w, &h, grpatch); grpatch->mipmap->grInfo.format = PCX_Load(filename, &w, &h, grpatch);
if (grpatch->mipmap.grInfo.format == 0) if (grpatch->mipmap->grInfo.format == 0)
{ {
grpatch->notfound = true;// mark it so its not searched for again repeatedly grpatch->notfound = true;// mark it so its not searched for again repeatedly
Z_Free(filename); Z_Free(filename);
return; return;
} }
grpatch->mipmap.downloaded = 0; grpatch->mipmap->downloaded = 0;
grpatch->mipmap.flags = 0; grpatch->mipmap->flags = 0;
grpatch->width = (INT16)w; grpatch->width = (INT16)w;
grpatch->height = (INT16)h; grpatch->height = (INT16)h;
grpatch->mipmap.width = (UINT16)w; grpatch->mipmap->width = (UINT16)w;
grpatch->mipmap.height = (UINT16)h; grpatch->mipmap->height = (UINT16)h;
// not correct! // not correct!
grpatch->mipmap.grInfo.smallLodLog2 = GR_LOD_LOG2_256; grpatch->mipmap->grInfo.smallLodLog2 = GR_LOD_LOG2_256;
grpatch->mipmap.grInfo.largeLodLog2 = GR_LOD_LOG2_256; grpatch->mipmap->grInfo.largeLodLog2 = GR_LOD_LOG2_256;
grpatch->mipmap.grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1; grpatch->mipmap->grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
} }
HWD.pfnSetTexture(&grpatch->mipmap); // We do need to do this so that it can be cleared and knows to recreate it when necessary HWD.pfnSetTexture(grpatch->mipmap); // We do need to do this so that it can be cleared and knows to recreate it when necessary
HWR_UnlockCachedPatch(grpatch); HWR_UnlockCachedPatch(grpatch);
Z_Free(filename); Z_Free(filename);
@ -680,8 +686,8 @@ static void HWR_CreateBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch,
cur = Z_Malloc(size*4, PU_HWRCACHE, &grmip->grInfo.data); cur = Z_Malloc(size*4, PU_HWRCACHE, &grmip->grInfo.data);
memset(cur, 0x00, size*4); memset(cur, 0x00, size*4);
image = gpatch->mipmap.grInfo.data; image = gpatch->mipmap->grInfo.data;
blendimage = blendgpatch->mipmap.grInfo.data; blendimage = blendgpatch->mipmap->grInfo.data;
// Average all of the translation's colors // Average all of the translation's colors
{ {
@ -793,13 +799,13 @@ static void HWR_GetBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, INT
if (colormap == colormaps || colormap == NULL) if (colormap == colormaps || colormap == NULL)
{ {
// Don't do any blending // Don't do any blending
HWD.pfnSetTexture(&gpatch->mipmap); HWD.pfnSetTexture(gpatch->mipmap);
return; return;
} }
// search for the mimmap // search for the mimmap
// skip the first (no colormap translated) // skip the first (no colormap translated)
for (grmip = &gpatch->mipmap; grmip->nextcolormap; ) for (grmip = gpatch->mipmap; grmip->nextcolormap; )
{ {
grmip = grmip->nextcolormap; grmip = grmip->nextcolormap;
if (grmip->colormap == colormap) if (grmip->colormap == colormap)
@ -952,20 +958,20 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
finalscale = md2->scale; finalscale = md2->scale;
//Hurdler: arf, I don't like that implementation at all... too much crappy //Hurdler: arf, I don't like that implementation at all... too much crappy
gpatch = md2->grpatch; gpatch = md2->grpatch;
if (!gpatch || ((!gpatch->mipmap.grInfo.format || !gpatch->mipmap.downloaded) && !gpatch->notfound)) if (!gpatch || ((!gpatch->mipmap->grInfo.format || !gpatch->mipmap->downloaded) && !gpatch->notfound))
md2_loadTexture(md2); md2_loadTexture(md2);
gpatch = md2->grpatch; // Load it again, because it isn't being loaded into gpatch after md2_loadtexture... gpatch = md2->grpatch; // Load it again, because it isn't being loaded into gpatch after md2_loadtexture...
if ((gpatch && gpatch->mipmap.grInfo.format) // don't load the blend texture if the base texture isn't available if ((gpatch && gpatch->mipmap->grInfo.format) // don't load the blend texture if the base texture isn't available
&& (!md2->blendgrpatch && (!md2->blendgrpatch
|| ((!((GLPatch_t *)md2->blendgrpatch)->mipmap.grInfo.format || !((GLPatch_t *)md2->blendgrpatch)->mipmap.downloaded) || ((!((GLPatch_t *)md2->blendgrpatch)->mipmap->grInfo.format || !((GLPatch_t *)md2->blendgrpatch)->mipmap->downloaded)
&& !((GLPatch_t *)md2->blendgrpatch)->notfound))) && !((GLPatch_t *)md2->blendgrpatch)->notfound)))
md2_loadBlendTexture(md2); md2_loadBlendTexture(md2);
if (gpatch && gpatch->mipmap.grInfo.format) // else if meant that if a texture couldn't be loaded, it would just end up using something else's texture if (gpatch && gpatch->mipmap->grInfo.format) // else if meant that if a texture couldn't be loaded, it would just end up using something else's texture
{ {
if ((skincolors_t)spr->mobj->color != SKINCOLOR_NONE && if ((skincolors_t)spr->mobj->color != SKINCOLOR_NONE &&
md2->blendgrpatch && ((GLPatch_t *)md2->blendgrpatch)->mipmap.grInfo.format md2->blendgrpatch && ((GLPatch_t *)md2->blendgrpatch)->mipmap->grInfo.format
&& gpatch->width == ((GLPatch_t *)md2->blendgrpatch)->width && gpatch->height == ((GLPatch_t *)md2->blendgrpatch)->height) && gpatch->width == ((GLPatch_t *)md2->blendgrpatch)->width && gpatch->height == ((GLPatch_t *)md2->blendgrpatch)->height)
{ {
INT32 skinnum = TC_DEFAULT; INT32 skinnum = TC_DEFAULT;
@ -996,7 +1002,7 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
else else
{ {
// This is safe, since we know the texture has been downloaded // This is safe, since we know the texture has been downloaded
HWD.pfnSetTexture(&gpatch->mipmap); HWD.pfnSetTexture(gpatch->mipmap);
} }
} }
else else

20
src/r_data.c
View File

@ -198,7 +198,7 @@ static UINT8 *R_GenerateTexture(size_t texnum)
int x, x1, x2, i; int x, x1, x2, i;
size_t blocksize; size_t blocksize;
column_t *patchcol; column_t *patchcol;
UINT32 *colofs; UINT8 *colofs;
I_Assert(texnum <= (size_t)numtextures); I_Assert(texnum <= (size_t)numtextures);
texture = textures[texnum]; texture = textures[texnum];
@ -219,10 +219,10 @@ static UINT8 *R_GenerateTexture(size_t texnum)
// Check the patch for holes. // Check the patch for holes.
if (texture->width > SHORT(realpatch->width) || texture->height > SHORT(realpatch->height)) if (texture->width > SHORT(realpatch->width) || texture->height > SHORT(realpatch->height))
holey = true; holey = true;
colofs = (UINT32 *)realpatch->columnofs; colofs = (UINT8 *)realpatch->columnofs;
for (x = 0; x < texture->width && !holey; x++) for (x = 0; x < texture->width && !holey; x++)
{ {
column_t *col = (column_t *)((UINT8 *)realpatch + LONG(colofs[x])); column_t *col = (column_t *)((UINT8 *)realpatch + LONG(*(UINT32 *)&colofs[x<<2]));
INT32 topdelta, prevdelta = -1, y = 0; INT32 topdelta, prevdelta = -1, y = 0;
while (col->topdelta != 0xff) while (col->topdelta != 0xff)
{ {
@ -250,11 +250,11 @@ static UINT8 *R_GenerateTexture(size_t texnum)
texturememory += blocksize; texturememory += blocksize;
// use the patch's column lookup // use the patch's column lookup
colofs = (UINT32 *)(void *)(block + 8); colofs = (block + 8);
texturecolumnofs[texnum] = colofs; texturecolumnofs[texnum] = (UINT32 *)colofs;
blocktex = block; blocktex = block;
for (x = 0; x < texture->width; x++) for (x = 0; x < texture->width; x++)
colofs[x] = LONG(LONG(colofs[x]) + 3); *(UINT32 *)&colofs[x<<2] = LONG(LONG(*(UINT32 *)&colofs[x<<2]) + 3);
goto done; goto done;
} }
@ -270,8 +270,8 @@ static UINT8 *R_GenerateTexture(size_t texnum)
memset(block, 0xF7, blocksize+1); // Transparency hack memset(block, 0xF7, blocksize+1); // Transparency hack
// columns lookup table // columns lookup table
colofs = (UINT32 *)(void *)block; colofs = block;
texturecolumnofs[texnum] = colofs; texturecolumnofs[texnum] = (UINT32 *)colofs;
// texture data after the lookup table // texture data after the lookup table
blocktex = block + (texture->width*4); blocktex = block + (texture->width*4);
@ -296,8 +296,8 @@ static UINT8 *R_GenerateTexture(size_t texnum)
patchcol = (column_t *)((UINT8 *)realpatch + LONG(realpatch->columnofs[x-x1])); patchcol = (column_t *)((UINT8 *)realpatch + LONG(realpatch->columnofs[x-x1]));
// generate column ofset lookup // generate column ofset lookup
colofs[x] = LONG((x * texture->height) + (texture->width*4)); *(UINT32 *)&colofs[x<<2] = LONG((x * texture->height) + (texture->width*4));
R_DrawColumnInCache(patchcol, block + LONG(colofs[x]), patch->originy, texture->height); R_DrawColumnInCache(patchcol, block + LONG(*(UINT32 *)&colofs[x<<2]), patch->originy, texture->height);
} }
} }

8
src/w_wad.c
View File

@ -1485,22 +1485,22 @@ static inline void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
grPatch = HWR_GetCachedGLPatchPwad(wad, lump); grPatch = HWR_GetCachedGLPatchPwad(wad, lump);
if (grPatch->mipmap.grInfo.data) if (grPatch->mipmap->grInfo.data)
{ {
if (tag == PU_CACHE) if (tag == PU_CACHE)
tag = PU_HWRCACHE; tag = PU_HWRCACHE;
Z_ChangeTag(grPatch->mipmap.grInfo.data, tag); Z_ChangeTag(grPatch->mipmap->grInfo.data, tag);
} }
else else
{ {
patch_t *ptr = NULL; patch_t *ptr = NULL;
// Only load the patch if we haven't initialised the grPatch yet // Only load the patch if we haven't initialised the grPatch yet
if (grPatch->mipmap.width == 0) if (grPatch->mipmap->width == 0)
ptr = W_CacheLumpNumPwad(grPatch->wadnum, grPatch->lumpnum, PU_STATIC); ptr = W_CacheLumpNumPwad(grPatch->wadnum, grPatch->lumpnum, PU_STATIC);
// Run HWR_MakePatch in all cases, to recalculate some things // Run HWR_MakePatch in all cases, to recalculate some things
HWR_MakePatch(ptr, grPatch, &grPatch->mipmap, false); HWR_MakePatch(ptr, grPatch, grPatch->mipmap, false);
Z_Free(ptr); Z_Free(ptr);
} }