gr -> gl
this has been annoying me since ages lol
This commit is contained in:
1 parent
a9759f2740
commit
1b293981fa
25 files changed
+924
-926
No files matched your search
@@ -270,7 +270,7 @@ void HWR_RenderBatches(void)
|
||||
|
||||
// sort polygons
|
||||
PS_START_TIMING(ps_hw_batchsorttime);
|
||||
if (cv_grshaders.value && gr_shadersavailable)
|
||||
if (cv_glshaders.value && gl_shadersavailable)
|
||||
qs22j(polygonArraySorted, polygonArraySize, sizeof(PolygonArrayEntry *), comparePolygons);
|
||||
else
|
||||
qs22j(polygonArraySorted, polygonArraySize, sizeof(PolygonArrayEntry *), comparePolygonsNoShaders);
|
||||
@@ -293,7 +293,7 @@ void HWR_RenderBatches(void)
|
||||
|
||||
// set state for first batch
|
||||
|
||||
if (cv_grshaders.value && gr_shadersavailable)
|
||||
if (cv_glshaders.value && gl_shadersavailable)
|
||||
{
|
||||
HWD.pfnSetShader(currentShader);
|
||||
}
|
||||
@@ -375,7 +375,7 @@ void HWR_RenderBatches(void)
|
||||
nextSurfaceInfo = nextEntry->surf;
|
||||
if (nextPolyFlags & PF_NoTexture)
|
||||
nextTexture = 0;
|
||||
if (currentShader != nextShader && cv_grshaders.value && gr_shadersavailable)
|
||||
if (currentShader != nextShader && cv_glshaders.value && gl_shadersavailable)
|
||||
{
|
||||
changeState = true;
|
||||
changeShader = true;
|
||||
@@ -390,7 +390,7 @@ void HWR_RenderBatches(void)
|
||||
changeState = true;
|
||||
changePolyFlags = true;
|
||||
}
|
||||
if (cv_grshaders.value && gr_shadersavailable)
|
||||
if (cv_glshaders.value && gl_shadersavailable)
|
||||
{
|
||||
if (currentSurfaceInfo.PolyColor.rgba != nextSurfaceInfo.PolyColor.rgba ||
|
||||
currentSurfaceInfo.TintColor.rgba != nextSurfaceInfo.TintColor.rgba ||
|
||||
|
||||
@@ -46,7 +46,7 @@ typedef struct
|
||||
|
||||
// when loading the map, this is set to true if portals are found.
|
||||
// if no portals are found, the portal scanning phase can be skipped while rendering, saving a bit of time.
|
||||
boolean gr_maphasportals = false;
|
||||
boolean gl_maphasportals = false;
|
||||
|
||||
// ==========================================================================
|
||||
// FLOOR & CEILING CONVEX POLYS GENERATION
|
||||
@@ -371,14 +371,14 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 count, poly_t *poly)
|
||||
line_t *line = lseg->linedef;
|
||||
|
||||
// portal check
|
||||
if (!gr_maphasportals && line->special == 40 && lseg->side == 0)
|
||||
if (!gl_maphasportals && line->special == 40 && lseg->side == 0)
|
||||
{
|
||||
// Find the other side!
|
||||
INT32 line2 = P_FindSpecialLineFromTag(40, line->tag, -1);
|
||||
if (line == &lines[line2])
|
||||
line2 = P_FindSpecialLineFromTag(40, line->tag, line2);
|
||||
if (line2 >= 0) // found it!
|
||||
gr_maphasportals = 1;
|
||||
gl_maphasportals = 1;
|
||||
}
|
||||
|
||||
p1.x = FIXED_TO_FLOAT(lseg->side ? line->v2->x : line->v1->x);
|
||||
@@ -768,7 +768,7 @@ static INT32 SolveTProblem(void)
|
||||
INT32 i;
|
||||
size_t l;
|
||||
|
||||
if (cv_grsolvetjoin.value == 0)
|
||||
if (cv_glsolvetjoin.value == 0)
|
||||
return 0;
|
||||
|
||||
CONS_Debug(DBG_RENDER, "Solving T-joins. This may take a while. Please wait...\n");
|
||||
@@ -905,7 +905,7 @@ void HWR_CreatePlanePolygons(INT32 bspnum)
|
||||
#endif
|
||||
|
||||
// reset the portal flag
|
||||
gr_maphasportals = 0;
|
||||
gl_maphasportals = 0;
|
||||
|
||||
// find min/max boundaries of map
|
||||
//CONS_Debug(DBG_RENDER, "Looking for boundaries of map...\n");
|
||||
@@ -923,9 +923,9 @@ void HWR_CreatePlanePolygons(INT32 bspnum)
|
||||
I_Error("couldn't malloc extrasubsectors totsubsectors %s\n", sizeu1(totsubsectors));
|
||||
|
||||
// allocate table for back to front drawing of subsectors
|
||||
/*gr_drawsubsectors = (INT16 *)malloc(sizeof (*gr_drawsubsectors) * totsubsectors);
|
||||
if (!gr_drawsubsectors)
|
||||
I_Error("couldn't malloc gr_drawsubsectors\n");*/
|
||||
/*gl_drawsubsectors = (INT16 *)malloc(sizeof (*gl_drawsubsectors) * totsubsectors);
|
||||
if (!gl_drawsubsectors)
|
||||
I_Error("couldn't malloc gl_drawsubsectors\n");*/
|
||||
|
||||
// number of the first new subsector that might be added
|
||||
addsubsector = numsubsectors;
|
||||
|
||||
+119
-119
@@ -278,15 +278,15 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
|
||||
}
|
||||
}
|
||||
|
||||
static UINT8 *MakeBlock(GLMipmap_t *grMipmap)
|
||||
static UINT8 *MakeBlock(GLMipmap_t *glMipmap)
|
||||
{
|
||||
UINT8 *block;
|
||||
INT32 bpp, i;
|
||||
UINT16 bu16 = ((0x00 <<8) | HWR_PATCHES_CHROMAKEY_COLORINDEX);
|
||||
INT32 blocksize = (grMipmap->width * grMipmap->height);
|
||||
INT32 blocksize = (glMipmap->width * glMipmap->height);
|
||||
|
||||
bpp = format2bpp(grMipmap->format);
|
||||
block = Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(grMipmap->data));
|
||||
bpp = format2bpp(glMipmap->format);
|
||||
block = Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data));
|
||||
|
||||
switch (bpp)
|
||||
{
|
||||
@@ -306,7 +306,7 @@ static UINT8 *MakeBlock(GLMipmap_t *grMipmap)
|
||||
// Create a composite texture from patches, adapt the texture size to a power of 2
|
||||
// height and width for the hardware texture cache.
|
||||
//
|
||||
static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *grtex, boolean noencore)
|
||||
static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noencore)
|
||||
{
|
||||
UINT8 *block;
|
||||
texture_t *texture;
|
||||
@@ -331,30 +331,30 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *grtex, boolean noe
|
||||
)
|
||||
{
|
||||
skyspecial = true;
|
||||
grtex->mipmap.flags = TF_WRAPXY; // don't use the chromakey for sky
|
||||
gltex->mipmap.flags = TF_WRAPXY; // don't use the chromakey for sky
|
||||
}
|
||||
else
|
||||
grtex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
|
||||
gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
|
||||
|
||||
grtex->mipmap.width = (UINT16)texture->width;
|
||||
grtex->mipmap.height = (UINT16)texture->height;
|
||||
gltex->mipmap.width = (UINT16)texture->width;
|
||||
gltex->mipmap.height = (UINT16)texture->height;
|
||||
|
||||
if (skyspecial)
|
||||
grtex->mipmap.format = GL_TEXFMT_RGBA; // that skyspecial code below assumes this format ...
|
||||
gltex->mipmap.format = GL_TEXFMT_RGBA; // that skyspecial code below assumes this format ...
|
||||
else
|
||||
grtex->mipmap.format = textureformat;
|
||||
gltex->mipmap.format = textureformat;
|
||||
|
||||
grtex->mipmap.colormap = colormaps;
|
||||
gltex->mipmap.colormap = colormaps;
|
||||
|
||||
#ifdef GLENCORE
|
||||
if (encoremap && !noencore)
|
||||
grtex->mipmap.colormap += COLORMAP_REMAPOFFSET;
|
||||
gltex->mipmap.colormap += COLORMAP_REMAPOFFSET;
|
||||
#endif
|
||||
|
||||
blockwidth = texture->width;
|
||||
blockheight = texture->height;
|
||||
blocksize = (blockwidth * blockheight);
|
||||
block = MakeBlock(&grtex->mipmap);
|
||||
block = MakeBlock(&gltex->mipmap);
|
||||
|
||||
if (skyspecial) //Hurdler: not efficient, but better than holes in the sky (and it's done only at level loading)
|
||||
{
|
||||
@@ -378,7 +378,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *grtex, boolean noe
|
||||
for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
|
||||
{
|
||||
realpatch = W_CacheLumpNumPwad(patch->wad, patch->lump, PU_CACHE);
|
||||
HWR_DrawTexturePatchInCache(&grtex->mipmap,
|
||||
HWR_DrawTexturePatchInCache(&gltex->mipmap,
|
||||
blockwidth, blockheight,
|
||||
texture, patch,
|
||||
realpatch);
|
||||
@@ -386,78 +386,78 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *grtex, boolean noe
|
||||
}
|
||||
|
||||
//Hurdler: not efficient at all but I don't remember exactly how HWR_DrawPatchInCache works :(
|
||||
if (format2bpp(grtex->mipmap.format)==4)
|
||||
if (format2bpp(gltex->mipmap.format)==4)
|
||||
{
|
||||
for (i = 3; i < blocksize*4; i += 4) // blocksize*4 because blocksize doesn't include the bpp
|
||||
{
|
||||
if (block[i] != 0)
|
||||
continue;
|
||||
|
||||
grtex->mipmap.flags |= TF_TRANSPARENT;
|
||||
gltex->mipmap.flags |= TF_TRANSPARENT;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
grtex->scaleX = 1.0f/(texture->width*FRACUNIT);
|
||||
grtex->scaleY = 1.0f/(texture->height*FRACUNIT);
|
||||
gltex->scaleX = 1.0f/(texture->width*FRACUNIT);
|
||||
gltex->scaleY = 1.0f/(texture->height*FRACUNIT);
|
||||
}
|
||||
|
||||
// patch may be NULL if grMipmap has been initialised already and makebitmap is false
|
||||
void HWR_MakePatch (patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipmap, boolean makebitmap)
|
||||
// patch may be NULL if glMipmap has been initialised already and makebitmap is false
|
||||
void HWR_MakePatch (patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipmap, boolean makebitmap)
|
||||
{
|
||||
// don't do it twice (like a cache)
|
||||
if (grMipmap->width == 0)
|
||||
if (glMipmap->width == 0)
|
||||
{
|
||||
// save the original patch header so that the GLPatch can be casted
|
||||
// into a standard patch_t struct and the existing code can get the
|
||||
// orginal patch dimensions and offsets.
|
||||
grPatch->width = SHORT(patch->width);
|
||||
grPatch->height = SHORT(patch->height);
|
||||
grPatch->leftoffset = SHORT(patch->leftoffset);
|
||||
grPatch->topoffset = SHORT(patch->topoffset);
|
||||
glPatch->width = SHORT(patch->width);
|
||||
glPatch->height = SHORT(patch->height);
|
||||
glPatch->leftoffset = SHORT(patch->leftoffset);
|
||||
glPatch->topoffset = SHORT(patch->topoffset);
|
||||
|
||||
//grMipmap->width = (UINT16)SHORT(patch->width);
|
||||
//grMipmap->height = (UINT16)SHORT(patch->height);
|
||||
grMipmap->width = grMipmap->height = 1;
|
||||
while (grMipmap->width < grPatch->width) grMipmap->width <<= 1;
|
||||
while (grMipmap->height < grPatch->height) grMipmap->height <<= 1;
|
||||
//glMipmap->width = (UINT16)SHORT(patch->width);
|
||||
//glMipmap->height = (UINT16)SHORT(patch->height);
|
||||
glMipmap->width = glMipmap->height = 1;
|
||||
while (glMipmap->width < glPatch->width) glMipmap->width <<= 1;
|
||||
while (glMipmap->height < glPatch->height) glMipmap->height <<= 1;
|
||||
|
||||
// no wrap around, no chroma key
|
||||
grMipmap->flags = 0;
|
||||
glMipmap->flags = 0;
|
||||
// setup the texture info
|
||||
grMipmap->format = patchformat;
|
||||
glMipmap->format = patchformat;
|
||||
|
||||
//grPatch->max_s = grPatch->max_t = 1.0f;
|
||||
grPatch->max_s = (float)grPatch->width / (float)grMipmap->width;
|
||||
grPatch->max_t = (float)grPatch->height / (float)grMipmap->height;
|
||||
//glPatch->max_s = glPatch->max_t = 1.0f;
|
||||
glPatch->max_s = (float)glPatch->width / (float)glMipmap->width;
|
||||
glPatch->max_t = (float)glPatch->height / (float)glMipmap->height;
|
||||
}
|
||||
|
||||
Z_Free(grMipmap->data);
|
||||
grMipmap->data = NULL;
|
||||
Z_Free(glMipmap->data);
|
||||
glMipmap->data = NULL;
|
||||
|
||||
if (makebitmap)
|
||||
{
|
||||
MakeBlock(grMipmap);
|
||||
HWR_DrawPatchInCache(grMipmap,
|
||||
grMipmap->width, grMipmap->height,
|
||||
grPatch->width, grPatch->height,
|
||||
MakeBlock(glMipmap);
|
||||
HWR_DrawPatchInCache(glMipmap,
|
||||
glMipmap->width, glMipmap->height,
|
||||
glPatch->width, glPatch->height,
|
||||
patch);
|
||||
}
|
||||
|
||||
//grPatch->max_s = grPatch->max_t = 1.0f;
|
||||
//glPatch->max_s = glPatch->max_t = 1.0f;
|
||||
}
|
||||
|
||||
// =================================================
|
||||
// CACHING HANDLING
|
||||
// =================================================
|
||||
|
||||
static size_t gr_numtextures;
|
||||
static GLMapTexture_t *gr_textures; // For all textures
|
||||
static size_t gl_numtextures;
|
||||
static GLMapTexture_t *gl_textures; // For all textures
|
||||
|
||||
void HWR_InitTextureCache(void)
|
||||
{
|
||||
gr_numtextures = 0;
|
||||
gr_textures = NULL;
|
||||
gl_numtextures = 0;
|
||||
gl_textures = NULL;
|
||||
}
|
||||
|
||||
// Callback function for HWR_FreeTextureCache.
|
||||
@@ -529,10 +529,10 @@ void HWR_FreeTextureCache(void)
|
||||
|
||||
// now the heap don't have any 'user' pointing to our
|
||||
// texturecache info, we can free it
|
||||
if (gr_textures)
|
||||
free(gr_textures);
|
||||
gr_textures = NULL;
|
||||
gr_numtextures = 0;
|
||||
if (gl_textures)
|
||||
free(gl_textures);
|
||||
gl_textures = NULL;
|
||||
gl_numtextures = 0;
|
||||
}
|
||||
|
||||
void HWR_LoadTextures(size_t pnumtextures)
|
||||
@@ -540,13 +540,13 @@ void HWR_LoadTextures(size_t pnumtextures)
|
||||
// we must free it since numtextures changed
|
||||
HWR_FreeTextureCache();
|
||||
|
||||
gr_numtextures = pnumtextures;
|
||||
gl_numtextures = pnumtextures;
|
||||
#ifdef GLENCORE
|
||||
gr_textures = calloc(pnumtextures, sizeof (*gr_textures)*2); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore)
|
||||
gl_textures = calloc(pnumtextures, sizeof (*gl_textures)*2); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore)
|
||||
#else
|
||||
gr_textures = calloc(pnumtextures, sizeof (*gr_textures));
|
||||
gl_textures = calloc(pnumtextures, sizeof (*gl_textures));
|
||||
#endif
|
||||
if (gr_textures == NULL)
|
||||
if (gl_textures == NULL)
|
||||
I_Error("HWR_LoadTextures: ran out of memory for OpenGL textures. Sad!");
|
||||
}
|
||||
|
||||
@@ -555,9 +555,9 @@ void HWR_LoadTextures(size_t pnumtextures)
|
||||
// --------------------------------------------------------------------------
|
||||
GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean noencore)
|
||||
{
|
||||
GLMapTexture_t *grtex;
|
||||
GLMapTexture_t *gltex;
|
||||
|
||||
if (tex < 0 || tex >= (signed)gr_numtextures)
|
||||
if (tex < 0 || tex >= (signed)gl_numtextures)
|
||||
{
|
||||
#ifdef PARANOIA
|
||||
I_Error("HWR_GetTexture: Invalid texture ID %d", tex);
|
||||
@@ -566,25 +566,25 @@ GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean noencore)
|
||||
#endif
|
||||
}
|
||||
#ifdef GLENCORE
|
||||
grtex = &gr_textures[tex*2 + (encoremap && !noencore ? 0 : 1)];
|
||||
gltex = &gl_textures[tex*2 + (encoremap && !noencore ? 0 : 1)];
|
||||
#else
|
||||
grtex = &gr_textures[tex];
|
||||
gltex = &gl_textures[tex];
|
||||
#endif
|
||||
if (!grtex->mipmap.data && !grtex->mipmap.downloaded)
|
||||
HWR_GenerateTexture(tex, grtex, noencore);
|
||||
if (!gltex->mipmap.data && !gltex->mipmap.downloaded)
|
||||
HWR_GenerateTexture(tex, gltex, noencore);
|
||||
|
||||
// If hardware does not have the texture, then call pfnSetTexture to upload it
|
||||
if (!grtex->mipmap.downloaded)
|
||||
HWD.pfnSetTexture(&grtex->mipmap);
|
||||
HWR_SetCurrentTexture(&grtex->mipmap);
|
||||
if (!gltex->mipmap.downloaded)
|
||||
HWD.pfnSetTexture(&gltex->mipmap);
|
||||
HWR_SetCurrentTexture(&gltex->mipmap);
|
||||
|
||||
// The system-memory data can be purged now.
|
||||
Z_ChangeTag(grtex->mipmap.data, PU_HWRCACHE_UNLOCKED);
|
||||
Z_ChangeTag(gltex->mipmap.data, PU_HWRCACHE_UNLOCKED);
|
||||
|
||||
return grtex;
|
||||
return gltex;
|
||||
}
|
||||
|
||||
static void HWR_CacheFlat(GLMipmap_t *grMipmap, lumpnum_t flatlumpnum)
|
||||
static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
|
||||
{
|
||||
#ifdef GLENCORE
|
||||
UINT8 *flat;
|
||||
@@ -593,8 +593,8 @@ static void HWR_CacheFlat(GLMipmap_t *grMipmap, lumpnum_t flatlumpnum)
|
||||
size_t size, pflatsize;
|
||||
|
||||
// setup the texture info
|
||||
grMipmap->format = GL_TEXFMT_P_8;
|
||||
grMipmap->flags = TF_WRAPXY|TF_CHROMAKEYED;
|
||||
glMipmap->format = GL_TEXFMT_P_8;
|
||||
glMipmap->flags = TF_WRAPXY|TF_CHROMAKEYED;
|
||||
|
||||
size = W_LumpLength(flatlumpnum);
|
||||
|
||||
@@ -622,21 +622,21 @@ static void HWR_CacheFlat(GLMipmap_t *grMipmap, lumpnum_t flatlumpnum)
|
||||
pflatsize = 64;
|
||||
break;
|
||||
}
|
||||
grMipmap->width = (UINT16)pflatsize;
|
||||
grMipmap->height = (UINT16)pflatsize;
|
||||
glMipmap->width = (UINT16)pflatsize;
|
||||
glMipmap->height = (UINT16)pflatsize;
|
||||
|
||||
// the flat raw data needn't be converted with palettized textures
|
||||
W_ReadLump(flatlumpnum, Z_Malloc(W_LumpLength(flatlumpnum),
|
||||
PU_HWRCACHE, &grMipmap->data));
|
||||
PU_HWRCACHE, &glMipmap->data));
|
||||
|
||||
#ifdef GLENCORE
|
||||
flat = grMipmap->data;
|
||||
flat = glMipmap->data;
|
||||
for (steppy = 0; steppy < size; steppy++)
|
||||
{
|
||||
if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX)
|
||||
continue;
|
||||
|
||||
flat[steppy] = grMipmap->colormap[flat[steppy]];
|
||||
flat[steppy] = glMipmap->colormap[flat[steppy]];
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -644,44 +644,44 @@ static void HWR_CacheFlat(GLMipmap_t *grMipmap, lumpnum_t flatlumpnum)
|
||||
// Download a Doom 'flat' to the hardware cache and make it ready for use
|
||||
void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
|
||||
{
|
||||
GLMipmap_t *grmip;
|
||||
GLMipmap_t *glmip;
|
||||
|
||||
if (flatlumpnum == LUMPERROR)
|
||||
return;
|
||||
|
||||
grmip = HWR_GetCachedGLPatch(flatlumpnum)->mipmap;
|
||||
glmip = HWR_GetCachedGLPatch(flatlumpnum)->mipmap;
|
||||
|
||||
grmip->colormap = colormaps;
|
||||
glmip->colormap = colormaps;
|
||||
|
||||
#ifdef GLENCORE
|
||||
if (!noencoremap && encoremap)
|
||||
grmip->colormap += COLORMAP_REMAPOFFSET;
|
||||
glmip->colormap += COLORMAP_REMAPOFFSET;
|
||||
#endif
|
||||
|
||||
if (!grmip->downloaded && !grmip->data)
|
||||
HWR_CacheFlat(grmip, flatlumpnum);
|
||||
if (!glmip->downloaded && !glmip->data)
|
||||
HWR_CacheFlat(glmip, flatlumpnum);
|
||||
|
||||
// If hardware does not have the texture, then call pfnSetTexture to upload it
|
||||
if (!grmip->downloaded)
|
||||
HWD.pfnSetTexture(grmip);
|
||||
HWR_SetCurrentTexture(grmip);
|
||||
if (!glmip->downloaded)
|
||||
HWD.pfnSetTexture(glmip);
|
||||
HWR_SetCurrentTexture(glmip);
|
||||
|
||||
// The system-memory data can be purged now.
|
||||
Z_ChangeTag(grmip->data, PU_HWRCACHE_UNLOCKED);
|
||||
Z_ChangeTag(glmip->data, PU_HWRCACHE_UNLOCKED);
|
||||
}
|
||||
|
||||
//
|
||||
// HWR_LoadMappedPatch(): replace the skin color of the sprite in cache
|
||||
// : load it first in doom cache if not already
|
||||
//
|
||||
static void HWR_LoadMappedPatch(GLMipmap_t *grmip, GLPatch_t *gpatch)
|
||||
static void HWR_LoadMappedPatch(GLMipmap_t *glmip, GLPatch_t *gpatch)
|
||||
{
|
||||
if (!grmip->downloaded && !grmip->data)
|
||||
if (!glmip->downloaded && !glmip->data)
|
||||
{
|
||||
patch_t *patch = gpatch->rawpatch;
|
||||
if (!patch)
|
||||
patch = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC);
|
||||
HWR_MakePatch(patch, gpatch, grmip, true);
|
||||
HWR_MakePatch(patch, gpatch, glmip, true);
|
||||
|
||||
// You can't free rawpatch for some reason?
|
||||
// (Obviously I can't, sprite rotation needs that...)
|
||||
@@ -691,12 +691,12 @@ static void HWR_LoadMappedPatch(GLMipmap_t *grmip, GLPatch_t *gpatch)
|
||||
}
|
||||
|
||||
// If hardware does not have the texture, then call pfnSetTexture to upload it
|
||||
if (!grmip->downloaded)
|
||||
HWD.pfnSetTexture(grmip);
|
||||
HWR_SetCurrentTexture(grmip);
|
||||
if (!glmip->downloaded)
|
||||
HWD.pfnSetTexture(glmip);
|
||||
HWR_SetCurrentTexture(glmip);
|
||||
|
||||
// The system-memory data can be purged now.
|
||||
Z_ChangeTag(grmip->data, PU_HWRCACHE_UNLOCKED);
|
||||
Z_ChangeTag(glmip->data, PU_HWRCACHE_UNLOCKED);
|
||||
}
|
||||
|
||||
// -----------------+
|
||||
@@ -735,7 +735,7 @@ void HWR_GetPatch(GLPatch_t *gpatch)
|
||||
// -------------------+
|
||||
void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap)
|
||||
{
|
||||
GLMipmap_t *grmip, *newmip;
|
||||
GLMipmap_t *glmip, *newmip;
|
||||
|
||||
// Blatant hack for encore colormapping aside...
|
||||
if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
|
||||
@@ -747,14 +747,14 @@ void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap)
|
||||
|
||||
// search for the mimmap
|
||||
// skip the first (no colormap translated)
|
||||
for (grmip = gpatch->mipmap; grmip->nextcolormap; )
|
||||
for (glmip = gpatch->mipmap; glmip->nextcolormap; )
|
||||
{
|
||||
grmip = grmip->nextcolormap;
|
||||
glmip = glmip->nextcolormap;
|
||||
|
||||
if (grmip->colormap != colormap)
|
||||
if (glmip->colormap != colormap)
|
||||
continue;
|
||||
|
||||
HWR_LoadMappedPatch(grmip, gpatch);
|
||||
HWR_LoadMappedPatch(glmip, gpatch);
|
||||
return;
|
||||
}
|
||||
// not found, create it!
|
||||
@@ -767,7 +767,7 @@ void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap)
|
||||
newmip = calloc(1, sizeof (*newmip));
|
||||
if (newmip == NULL)
|
||||
I_Error("%s: Out of memory", "HWR_GetMappedPatch");
|
||||
grmip->nextcolormap = newmip;
|
||||
glmip->nextcolormap = newmip;
|
||||
|
||||
newmip->colormap = colormap;
|
||||
HWR_LoadMappedPatch(newmip, gpatch);
|
||||
@@ -784,18 +784,18 @@ void HWR_UnlockCachedPatch(GLPatch_t *gpatch)
|
||||
GLPatch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
|
||||
{
|
||||
aatree_t *hwrcache = wadfiles[wadnum]->hwrcache;
|
||||
GLPatch_t *grpatch;
|
||||
GLPatch_t *glpatch;
|
||||
|
||||
if (!(grpatch = M_AATreeGet(hwrcache, lumpnum)))
|
||||
if (!(glpatch = M_AATreeGet(hwrcache, lumpnum)))
|
||||
{
|
||||
grpatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL);
|
||||
grpatch->wadnum = wadnum;
|
||||
grpatch->lumpnum = lumpnum;
|
||||
grpatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
M_AATreeSet(hwrcache, lumpnum, grpatch);
|
||||
glpatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL);
|
||||
glpatch->wadnum = wadnum;
|
||||
glpatch->lumpnum = lumpnum;
|
||||
glpatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
M_AATreeSet(hwrcache, lumpnum, glpatch);
|
||||
}
|
||||
|
||||
return grpatch;
|
||||
return glpatch;
|
||||
}
|
||||
|
||||
GLPatch_t *HWR_GetCachedGLPatch(lumpnum_t lumpnum)
|
||||
@@ -843,14 +843,14 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
|
||||
Z_Free(flat);
|
||||
}
|
||||
|
||||
static void HWR_CacheFadeMask(GLMipmap_t *grMipmap, lumpnum_t fademasklumpnum)
|
||||
static void HWR_CacheFadeMask(GLMipmap_t *glMipmap, lumpnum_t fademasklumpnum)
|
||||
{
|
||||
size_t size;
|
||||
UINT16 fmheight = 0, fmwidth = 0;
|
||||
|
||||
// setup the texture info
|
||||
grMipmap->format = GL_TEXFMT_ALPHA_8; // put the correct alpha levels straight in so I don't need to convert it later
|
||||
grMipmap->flags = 0;
|
||||
glMipmap->format = GL_TEXFMT_ALPHA_8; // put the correct alpha levels straight in so I don't need to convert it later
|
||||
glMipmap->flags = 0;
|
||||
|
||||
size = W_LumpLength(fademasklumpnum);
|
||||
|
||||
@@ -879,28 +879,28 @@ static void HWR_CacheFadeMask(GLMipmap_t *grMipmap, lumpnum_t fademasklumpnum)
|
||||
}
|
||||
|
||||
// Thankfully, this will still work for this scenario
|
||||
grMipmap->width = fmwidth;
|
||||
grMipmap->height = fmheight;
|
||||
glMipmap->width = fmwidth;
|
||||
glMipmap->height = fmheight;
|
||||
|
||||
MakeBlock(grMipmap);
|
||||
MakeBlock(glMipmap);
|
||||
|
||||
HWR_DrawFadeMaskInCache(grMipmap, fmwidth, fmheight, fademasklumpnum, fmwidth, fmheight);
|
||||
HWR_DrawFadeMaskInCache(glMipmap, fmwidth, fmheight, fademasklumpnum, fmwidth, fmheight);
|
||||
// I DO need to convert this because it isn't power of 2 and we need the alpha
|
||||
}
|
||||
|
||||
void HWR_GetFadeMask(lumpnum_t fademasklumpnum)
|
||||
{
|
||||
GLMipmap_t *grmip;
|
||||
GLMipmap_t *glmip;
|
||||
|
||||
grmip = HWR_GetCachedGLPatch(fademasklumpnum)->mipmap;
|
||||
glmip = HWR_GetCachedGLPatch(fademasklumpnum)->mipmap;
|
||||
|
||||
if (!grmip->downloaded && !grmip->data)
|
||||
HWR_CacheFadeMask(grmip, fademasklumpnum);
|
||||
if (!glmip->downloaded && !glmip->data)
|
||||
HWR_CacheFadeMask(glmip, fademasklumpnum);
|
||||
|
||||
HWD.pfnSetTexture(grmip);
|
||||
HWD.pfnSetTexture(glmip);
|
||||
|
||||
// The system-memory data can be purged now.
|
||||
Z_ChangeTag(grmip->data, PU_HWRCACHE_UNLOCKED);
|
||||
Z_ChangeTag(glmip->data, PU_HWRCACHE_UNLOCKED);
|
||||
}
|
||||
|
||||
// =================================================
|
||||
@@ -912,7 +912,7 @@ void HWR_SetPalette(RGBA_t *palette)
|
||||
if (HWR_ShouldUsePaletteRendering())
|
||||
{
|
||||
// set the palette for palette postprocessing
|
||||
if (cv_grpalettedepth.value == 16)
|
||||
if (cv_glpalettedepth.value == 16)
|
||||
{
|
||||
// crush to 16-bit rgb565, like software currently does in the standard configuration
|
||||
// Note: Software's screenshots have the 24-bit palette, but the screen gets
|
||||
|
||||
@@ -121,8 +121,6 @@ typedef struct
|
||||
poly_t *planepoly; // the generated convex polygon
|
||||
} extrasubsector_t;
|
||||
|
||||
//here lies gr_vissprite
|
||||
|
||||
// Kart features
|
||||
#define USE_FTRANSFORM_ANGLEZ
|
||||
#define USE_FTRANSFORM_MIRROR
|
||||
|
||||
@@ -569,7 +569,7 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
|
||||
|
||||
if (color & 0xFF00) // Do COLORMAP fade.
|
||||
{
|
||||
if (HWR_ShouldUsePaletteRendering() && cv_grscreentextures.value)
|
||||
if (HWR_ShouldUsePaletteRendering() && cv_glscreentextures.value)
|
||||
{
|
||||
const hwdscreentexture_t scr_tex = HWD_SCREENTEXTURE_GENERIC2;
|
||||
|
||||
@@ -652,17 +652,17 @@ void HWR_DrawViewBorder(INT32 clearlines)
|
||||
INT32 basewindowx, basewindowy;
|
||||
GLPatch_t *patch;
|
||||
|
||||
// if (gr_viewwidth == vid.width)
|
||||
// if (gl_viewwidth == vid.width)
|
||||
// return;
|
||||
|
||||
if (!clearlines)
|
||||
clearlines = BASEVIDHEIGHT; // refresh all
|
||||
|
||||
// calc view size based on original game resolution
|
||||
baseviewwidth = FixedInt(FixedDiv(FLOAT_TO_FIXED(gr_viewwidth), vid.fdupx)); //(cv_viewsize.value * BASEVIDWIDTH/10)&~7;
|
||||
baseviewheight = FixedInt(FixedDiv(FLOAT_TO_FIXED(gr_viewheight), vid.fdupy));
|
||||
top = FixedInt(FixedDiv(FLOAT_TO_FIXED(gr_baseviewwindowy), vid.fdupy));
|
||||
side = FixedInt(FixedDiv(FLOAT_TO_FIXED(gr_baseviewwindowx), vid.fdupx));
|
||||
baseviewwidth = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_viewwidth), vid.fdupx)); //(cv_viewsize.value * BASEVIDWIDTH/10)&~7;
|
||||
baseviewheight = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_viewheight), vid.fdupy));
|
||||
top = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_baseviewwindowy), vid.fdupy));
|
||||
side = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_baseviewwindowx), vid.fdupx));
|
||||
|
||||
// top
|
||||
HWR_DrawFlatFill(0, 0,
|
||||
|
||||
@@ -23,7 +23,7 @@
|
||||
|
||||
// needed for sprite rendering
|
||||
// equivalent of the software renderer's vissprites
|
||||
typedef struct gr_vissprite_s
|
||||
typedef struct gl_vissprite_s
|
||||
{
|
||||
float x1, x2;
|
||||
float z1, z2;
|
||||
@@ -41,9 +41,9 @@ typedef struct gr_vissprite_s
|
||||
//Hurdler: 25/04/2000: now support colormap in hardware mode
|
||||
UINT8 *colormap;
|
||||
INT32 dispoffset; // copy of info->dispoffset, affects ordering but not drawing
|
||||
} gr_vissprite_t;
|
||||
} gl_vissprite_t;
|
||||
|
||||
void HWR_ObjectLightLevelPost(gr_vissprite_t *spr, const sector_t *sector, INT32 *lightlevel, boolean model);
|
||||
void HWR_ObjectLightLevelPost(gl_vissprite_t *spr, const sector_t *sector, INT32 *lightlevel, boolean model);
|
||||
|
||||
// --------
|
||||
// hw_bsp.c
|
||||
@@ -65,7 +65,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap);
|
||||
GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean noencore);
|
||||
void HWR_GetPatch(GLPatch_t *gpatch);
|
||||
void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap);
|
||||
void HWR_MakePatch(patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipmap, boolean makebitmap);
|
||||
void HWR_MakePatch(patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipmap, boolean makebitmap);
|
||||
void HWR_UnlockCachedPatch(GLPatch_t *gpatch);
|
||||
void HWR_SetPalette(RGBA_t *palette);
|
||||
|
||||
|
||||
+608
-608
File diff suppressed because it is too large.
Load diff
+35
-35
@@ -36,23 +36,23 @@
|
||||
void HWR_Startup(void);
|
||||
void HWR_Shutdown(void);
|
||||
|
||||
extern float gr_viewwidth, gr_viewheight, gr_baseviewwindowx, gr_baseviewwindowy;
|
||||
extern float gl_viewwidth, gl_viewheight, gl_baseviewwindowx, gl_baseviewwindowy;
|
||||
|
||||
extern float gr_basewindowcenterx, gr_basewindowcentery;
|
||||
extern float gl_basewindowcenterx, gl_basewindowcentery;
|
||||
|
||||
extern unsigned msaa;
|
||||
extern boolean a2c;
|
||||
|
||||
extern FTransform atransform;
|
||||
extern float gr_viewsin, gr_viewcos;
|
||||
extern float gl_viewsin, gl_viewcos;
|
||||
|
||||
extern boolean gl_drawing_stencil;
|
||||
|
||||
extern seg_t *gr_curline;
|
||||
extern side_t *gr_sidedef;
|
||||
extern line_t *gr_linedef;
|
||||
extern sector_t *gr_frontsector;
|
||||
extern sector_t *gr_backsector;
|
||||
extern seg_t *gl_curline;
|
||||
extern side_t *gl_sidedef;
|
||||
extern line_t *gl_linedef;
|
||||
extern sector_t *gl_frontsector;
|
||||
extern sector_t *gl_backsector;
|
||||
|
||||
enum
|
||||
{
|
||||
@@ -80,7 +80,7 @@ extern ps_metric_t ps_hw_numcolors;
|
||||
extern ps_metric_t ps_hw_batchsorttime;
|
||||
extern ps_metric_t ps_hw_batchdrawtime;
|
||||
|
||||
extern boolean gr_shadersavailable;
|
||||
extern boolean gl_shadersavailable;
|
||||
|
||||
// hw_draw.c
|
||||
void HWR_DrawPatch(GLPatch_t *gpatch, INT32 x, INT32 y, INT32 option);
|
||||
@@ -138,43 +138,43 @@ void HWR_ProcessSeg(void); // Sort of like GLWall::Process in GZDoom
|
||||
|
||||
// hw_bsp.c
|
||||
void HWR_CreatePlanePolygons(INT32 bspnum);
|
||||
extern boolean gr_maphasportals;
|
||||
extern boolean gl_maphasportals;
|
||||
|
||||
// hw_cache.c
|
||||
void HWR_LoadTextures(size_t pnumtextures);
|
||||
RGBA_t *HWR_GetTexturePalette(void);
|
||||
|
||||
// Console variables
|
||||
extern consvar_t cv_grshaders;
|
||||
extern consvar_t cv_glshaders;
|
||||
#ifdef USE_FBO_OGL
|
||||
extern consvar_t cv_grframebuffer;
|
||||
extern consvar_t cv_glframebuffer;
|
||||
#endif
|
||||
extern consvar_t cv_splitwallfix;
|
||||
extern consvar_t cv_grshearing;
|
||||
extern consvar_t cv_grfov;
|
||||
extern consvar_t cv_grmdls;
|
||||
extern consvar_t cv_grfog;
|
||||
extern consvar_t cv_grfogdensity;
|
||||
extern consvar_t cv_grfiltermode;
|
||||
extern consvar_t cv_granisotropicmode;
|
||||
extern consvar_t cv_grcorrecttricks;
|
||||
extern consvar_t cv_grfovchange;
|
||||
extern consvar_t cv_grsolvetjoin;
|
||||
extern consvar_t cv_grspritebillboarding;
|
||||
extern consvar_t cv_grfakecontrast;
|
||||
extern consvar_t cv_grslopecontrast;
|
||||
extern consvar_t cv_grhorizonlines;
|
||||
extern consvar_t cv_grfallbackplayermodel;
|
||||
extern consvar_t cv_grbatching;
|
||||
extern consvar_t cv_grrenderdistance;
|
||||
extern consvar_t cv_grpaletterendering;
|
||||
extern consvar_t cv_grpalettedepth;
|
||||
extern consvar_t cv_grflashpal;
|
||||
extern consvar_t cv_glshearing;
|
||||
extern consvar_t cv_glfov;
|
||||
extern consvar_t cv_glmdls;
|
||||
extern consvar_t cv_glfog;
|
||||
extern consvar_t cv_glfogdensity;
|
||||
extern consvar_t cv_glfiltermode;
|
||||
extern consvar_t cv_glanisotropicmode;
|
||||
extern consvar_t cv_glcorrecttricks;
|
||||
extern consvar_t cv_glfovchange;
|
||||
extern consvar_t cv_glsolvetjoin;
|
||||
extern consvar_t cv_glspritebillboarding;
|
||||
extern consvar_t cv_glfakecontrast;
|
||||
extern consvar_t cv_glslopecontrast;
|
||||
extern consvar_t cv_glhorizonlines;
|
||||
extern consvar_t cv_glfallbackplayermodel;
|
||||
extern consvar_t cv_glbatching;
|
||||
extern consvar_t cv_glrenderdistance;
|
||||
extern consvar_t cv_glpaletterendering;
|
||||
extern consvar_t cv_glpalettedepth;
|
||||
extern consvar_t cv_glflashpal;
|
||||
extern consvar_t cv_lightdither;
|
||||
extern consvar_t cv_grscreentextures;
|
||||
extern consvar_t cv_grportals;
|
||||
extern consvar_t cv_glscreentextures;
|
||||
extern consvar_t cv_glportals;
|
||||
extern consvar_t cv_secbright;
|
||||
|
||||
extern CV_PossibleValue_t granisotropicmode_cons_t[];
|
||||
extern CV_PossibleValue_t glanisotropicmode_cons_t[];
|
||||
|
||||
#endif
|
||||
+83
-83
@@ -148,7 +148,7 @@ static void PNG_warn(png_structp PNG, png_const_charp pngtext)
|
||||
CONS_Debug(DBG_RENDER, "libpng warning at %p: %s", PNG, pngtext);
|
||||
}
|
||||
|
||||
static GLTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_t *grpatch)
|
||||
static GLTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_t *glpatch)
|
||||
{
|
||||
png_structp png_ptr;
|
||||
png_infop png_info_ptr;
|
||||
@@ -202,7 +202,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);
|
||||
png_destroy_read_struct(&png_ptr, &png_info_ptr, NULL);
|
||||
fclose(png_FILE);
|
||||
Z_Free(grpatch->mipmap->data);
|
||||
Z_Free(glpatch->mipmap->data);
|
||||
return 0;
|
||||
}
|
||||
#ifdef USE_FAR_KEYWORD
|
||||
@@ -243,7 +243,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_bytep PNG_image = Z_Malloc(pitch*height, PU_HWRCACHE, &grpatch->mipmap->data);
|
||||
png_bytep PNG_image = Z_Malloc(pitch*height, PU_HWRCACHE, &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;
|
||||
@@ -283,7 +283,7 @@ typedef struct
|
||||
} PcxHeader;
|
||||
|
||||
static GLTextureFormat_t PCX_Load(const char *filename, int *w, int *h,
|
||||
GLPatch_t *grpatch)
|
||||
GLPatch_t *glpatch)
|
||||
{
|
||||
PcxHeader header;
|
||||
#define PALSIZE 768
|
||||
@@ -323,7 +323,7 @@ static GLTextureFormat_t PCX_Load(const char *filename, int *w, int *h,
|
||||
|
||||
pw = *w = header.xmax - header.xmin + 1;
|
||||
ph = *h = header.ymax - header.ymin + 1;
|
||||
image = Z_Malloc(pw*ph*4, PU_HWRCACHE, &grpatch->mipmap->data);
|
||||
image = Z_Malloc(pw*ph*4, PU_HWRCACHE, &glpatch->mipmap->data);
|
||||
|
||||
if (fread(palette, sizeof (UINT8), PALSIZE, file) != PALSIZE)
|
||||
{
|
||||
@@ -365,43 +365,43 @@ static GLTextureFormat_t PCX_Load(const char *filename, int *w, int *h,
|
||||
// -----------------+
|
||||
static void md2_loadTexture(md2_t *model)
|
||||
{
|
||||
GLPatch_t *grpatch;
|
||||
GLPatch_t *glpatch;
|
||||
const char *filename = model->filename;
|
||||
|
||||
if (model->grpatch)
|
||||
if (model->glpatch)
|
||||
{
|
||||
grpatch = model->grpatch;
|
||||
Z_Free(grpatch->mipmap->data);
|
||||
glpatch = model->glpatch;
|
||||
Z_Free(glpatch->mipmap->data);
|
||||
}
|
||||
else
|
||||
{
|
||||
grpatch = Z_Calloc(sizeof *grpatch, PU_HWRPATCHINFO,
|
||||
&(model->grpatch));
|
||||
grpatch->mipmap = Z_Calloc(sizeof (GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
glpatch = Z_Calloc(sizeof *glpatch, PU_HWRPATCHINFO,
|
||||
&(model->glpatch));
|
||||
glpatch->mipmap = Z_Calloc(sizeof (GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
}
|
||||
|
||||
if (!grpatch->mipmap->downloaded && !grpatch->mipmap->data)
|
||||
if (!glpatch->mipmap->downloaded && !glpatch->mipmap->data)
|
||||
{
|
||||
int w = 0, h = 0;
|
||||
|
||||
#ifdef HAVE_PNG
|
||||
grpatch->mipmap->format = PNG_Load(filename, &w, &h, grpatch);
|
||||
if (grpatch->mipmap->format == 0)
|
||||
glpatch->mipmap->format = PNG_Load(filename, &w, &h, glpatch);
|
||||
if (glpatch->mipmap->format == 0)
|
||||
#endif
|
||||
grpatch->mipmap->format = PCX_Load(filename, &w, &h, grpatch);
|
||||
if (grpatch->mipmap->format == 0)
|
||||
glpatch->mipmap->format = PCX_Load(filename, &w, &h, glpatch);
|
||||
if (glpatch->mipmap->format == 0)
|
||||
{
|
||||
grpatch->notfound = true;// mark it so its not searched for again repeatedly
|
||||
glpatch->notfound = true;// mark it so its not searched for again repeatedly
|
||||
return;
|
||||
}
|
||||
|
||||
grpatch->mipmap->downloaded = 0;
|
||||
grpatch->mipmap->flags = 0;
|
||||
glpatch->mipmap->downloaded = 0;
|
||||
glpatch->mipmap->flags = 0;
|
||||
|
||||
grpatch->width = (INT16)w;
|
||||
grpatch->height = (INT16)h;
|
||||
grpatch->mipmap->width = (UINT16)w;
|
||||
grpatch->mipmap->height = (UINT16)h;
|
||||
glpatch->width = (INT16)w;
|
||||
glpatch->height = (INT16)h;
|
||||
glpatch->mipmap->width = (UINT16)w;
|
||||
glpatch->mipmap->height = (UINT16)h;
|
||||
|
||||
// for palette rendering, color cube is applied in post-processing instead of here
|
||||
if (!HWR_ShouldUsePaletteRendering())
|
||||
@@ -409,7 +409,7 @@ static void md2_loadTexture(md2_t *model)
|
||||
UINT32 size;
|
||||
RGBA_t *image;
|
||||
// Lactozilla: Apply colour cube
|
||||
image = grpatch->mipmap->data;
|
||||
image = glpatch->mipmap->data;
|
||||
size = w*h;
|
||||
while (size--)
|
||||
{
|
||||
@@ -418,8 +418,8 @@ static void md2_loadTexture(md2_t *model)
|
||||
}
|
||||
}
|
||||
}
|
||||
HWD.pfnSetTexture(grpatch->mipmap);
|
||||
HWR_UnlockCachedPatch(grpatch);
|
||||
HWD.pfnSetTexture(glpatch->mipmap);
|
||||
HWR_UnlockCachedPatch(glpatch);
|
||||
}
|
||||
|
||||
// -----------------+
|
||||
@@ -427,49 +427,49 @@ static void md2_loadTexture(md2_t *model)
|
||||
// -----------------+
|
||||
static void md2_loadBlendTexture(md2_t *model)
|
||||
{
|
||||
GLPatch_t *grpatch;
|
||||
GLPatch_t *glpatch;
|
||||
char *filename = Z_Malloc(strlen(model->filename)+7, PU_STATIC, NULL);
|
||||
strcpy(filename, model->filename);
|
||||
|
||||
FIL_ForceExtension(filename, "_blend.png");
|
||||
|
||||
if (model->blendgrpatch)
|
||||
if (model->blendglpatch)
|
||||
{
|
||||
grpatch = model->blendgrpatch;
|
||||
Z_Free(grpatch->mipmap->data);
|
||||
glpatch = model->blendglpatch;
|
||||
Z_Free(glpatch->mipmap->data);
|
||||
}
|
||||
else
|
||||
{
|
||||
grpatch = Z_Calloc(sizeof *grpatch, PU_HWRPATCHINFO,
|
||||
&(model->blendgrpatch));
|
||||
grpatch->mipmap = Z_Calloc(sizeof (GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
glpatch = Z_Calloc(sizeof *glpatch, PU_HWRPATCHINFO,
|
||||
&(model->blendglpatch));
|
||||
glpatch->mipmap = Z_Calloc(sizeof (GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
}
|
||||
|
||||
if (!grpatch->mipmap->downloaded && !grpatch->mipmap->data)
|
||||
if (!glpatch->mipmap->downloaded && !glpatch->mipmap->data)
|
||||
{
|
||||
int w = 0, h = 0;
|
||||
#ifdef HAVE_PNG
|
||||
grpatch->mipmap->format = PNG_Load(filename, &w, &h, grpatch);
|
||||
if (grpatch->mipmap->format == 0)
|
||||
glpatch->mipmap->format = PNG_Load(filename, &w, &h, glpatch);
|
||||
if (glpatch->mipmap->format == 0)
|
||||
#endif
|
||||
grpatch->mipmap->format = PCX_Load(filename, &w, &h, grpatch);
|
||||
if (grpatch->mipmap->format == 0)
|
||||
glpatch->mipmap->format = PCX_Load(filename, &w, &h, glpatch);
|
||||
if (glpatch->mipmap->format == 0)
|
||||
{
|
||||
grpatch->notfound = true;// mark it so its not searched for again repeatedly
|
||||
glpatch->notfound = true;// mark it so its not searched for again repeatedly
|
||||
Z_Free(filename);
|
||||
return;
|
||||
}
|
||||
|
||||
grpatch->mipmap->downloaded = 0;
|
||||
grpatch->mipmap->flags = 0;
|
||||
glpatch->mipmap->downloaded = 0;
|
||||
glpatch->mipmap->flags = 0;
|
||||
|
||||
grpatch->width = (INT16)w;
|
||||
grpatch->height = (INT16)h;
|
||||
grpatch->mipmap->width = (UINT16)w;
|
||||
grpatch->mipmap->height = (UINT16)h;
|
||||
glpatch->width = (INT16)w;
|
||||
glpatch->height = (INT16)h;
|
||||
glpatch->mipmap->width = (UINT16)w;
|
||||
glpatch->mipmap->height = (UINT16)h;
|
||||
}
|
||||
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);
|
||||
HWD.pfnSetTexture(glpatch->mipmap); // We do need to do this so that it can be cleared and knows to recreate it when necessary
|
||||
HWR_UnlockCachedPatch(glpatch);
|
||||
|
||||
Z_Free(filename);
|
||||
}
|
||||
@@ -490,7 +490,7 @@ void HWR_InitMD2(void)
|
||||
{
|
||||
md2_playermodels[s].scale = -1.0f;
|
||||
md2_playermodels[s].model = NULL;
|
||||
md2_playermodels[s].grpatch = NULL;
|
||||
md2_playermodels[s].glpatch = NULL;
|
||||
md2_playermodels[s].skin = -1;
|
||||
md2_playermodels[s].notfound = true;
|
||||
md2_playermodels[s].error = false;
|
||||
@@ -499,7 +499,7 @@ void HWR_InitMD2(void)
|
||||
{
|
||||
md2_localplayermodels[s].scale = -1.0f;
|
||||
md2_localplayermodels[s].model = NULL;
|
||||
md2_localplayermodels[s].grpatch = NULL;
|
||||
md2_localplayermodels[s].glpatch = NULL;
|
||||
md2_localplayermodels[s].skin = -1;
|
||||
md2_localplayermodels[s].notfound = true;
|
||||
md2_localplayermodels[s].error = false;
|
||||
@@ -508,7 +508,7 @@ void HWR_InitMD2(void)
|
||||
{
|
||||
md2_models[i].scale = -1.0f;
|
||||
md2_models[i].model = NULL;
|
||||
md2_models[i].grpatch = NULL;
|
||||
md2_models[i].glpatch = NULL;
|
||||
md2_models[i].skin = -1;
|
||||
md2_models[i].notfound = true;
|
||||
md2_models[i].error = false;
|
||||
@@ -681,7 +681,7 @@ spritemd2found:
|
||||
#define SETBRIGHTNESS(brightness,r,g,b) \
|
||||
brightness = (UINT8)(((1063*(UINT32)(r))/5000) + ((3576*(UINT32)(g))/5000) + ((361*(UINT32)(b))/5000))
|
||||
|
||||
static void HWR_CreateBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, GLMipmap_t *grmip, INT32 skinnum, skincolors_t color)
|
||||
static void HWR_CreateBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, GLMipmap_t *glmip, INT32 skinnum, skincolors_t color)
|
||||
{
|
||||
UINT16 w = gpatch->width, h = gpatch->height;
|
||||
UINT32 size = w*h;
|
||||
@@ -697,24 +697,24 @@ static void HWR_CreateBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch,
|
||||
memset(translation, 0, sizeof(translation));
|
||||
memset(cutoff, 0, sizeof(cutoff));
|
||||
|
||||
if (grmip->width == 0)
|
||||
if (glmip->width == 0)
|
||||
{
|
||||
grmip->width = gpatch->width;
|
||||
grmip->height = gpatch->height;
|
||||
glmip->width = gpatch->width;
|
||||
glmip->height = gpatch->height;
|
||||
|
||||
// no wrap around, no chroma key
|
||||
grmip->flags = 0;
|
||||
glmip->flags = 0;
|
||||
// setup the texture info
|
||||
grmip->format = GL_TEXFMT_RGBA;
|
||||
glmip->format = GL_TEXFMT_RGBA;
|
||||
}
|
||||
|
||||
if (grmip->data)
|
||||
if (glmip->data)
|
||||
{
|
||||
Z_Free(grmip->data);
|
||||
grmip->data = NULL;
|
||||
Z_Free(glmip->data);
|
||||
glmip->data = NULL;
|
||||
}
|
||||
|
||||
cur = Z_Malloc(size*4, PU_HWRCACHE, &grmip->data);
|
||||
cur = Z_Malloc(size*4, PU_HWRCACHE, &glmip->data);
|
||||
memset(cur, 0x00, size*4);
|
||||
|
||||
image = gpatch->mipmap->data;
|
||||
@@ -1044,7 +1044,7 @@ skippixel:
|
||||
static void HWR_GetBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, INT32 skinnum, const UINT8 *colormap, skincolors_t color)
|
||||
{
|
||||
// mostly copied from HWR_GetMappedPatch, hence the similarities and comment
|
||||
GLMipmap_t *grmip, *newmip;
|
||||
GLMipmap_t *glmip, *newmip;
|
||||
|
||||
if (colormap == colormaps || colormap == NULL)
|
||||
{
|
||||
@@ -1055,15 +1055,15 @@ static void HWR_GetBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, INT
|
||||
|
||||
// search for the mimmap
|
||||
// skip the first (no colormap translated)
|
||||
for (grmip = gpatch->mipmap; grmip->nextcolormap; )
|
||||
for (glmip = gpatch->mipmap; glmip->nextcolormap; )
|
||||
{
|
||||
grmip = grmip->nextcolormap;
|
||||
if (grmip->colormap == colormap)
|
||||
glmip = glmip->nextcolormap;
|
||||
if (glmip->colormap == colormap)
|
||||
{
|
||||
if (grmip->downloaded && grmip->data)
|
||||
if (glmip->downloaded && glmip->data)
|
||||
{
|
||||
HWD.pfnSetTexture(grmip); // found the colormap, set it to the correct texture
|
||||
Z_ChangeTag(grmip->data, PU_HWRCACHE_UNLOCKED);
|
||||
HWD.pfnSetTexture(glmip); // found the colormap, set it to the correct texture
|
||||
Z_ChangeTag(glmip->data, PU_HWRCACHE_UNLOCKED);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@@ -1079,7 +1079,7 @@ static void HWR_GetBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, INT
|
||||
newmip = calloc(1, sizeof (*newmip));
|
||||
if (newmip == NULL)
|
||||
I_Error("%s: Out of memory", "HWR_GetMappedPatch");
|
||||
grmip->nextcolormap = newmip;
|
||||
glmip->nextcolormap = newmip;
|
||||
newmip->colormap = colormap;
|
||||
|
||||
HWR_CreateBlendedTexture(gpatch, blendgpatch, newmip, skinnum, color);
|
||||
@@ -1095,7 +1095,7 @@ static void HWR_GetBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, INT
|
||||
// Returns :
|
||||
// -----------------+
|
||||
|
||||
void HWR_DrawMD2(gr_vissprite_t *spr)
|
||||
void HWR_DrawMD2(gl_vissprite_t *spr)
|
||||
{
|
||||
md2_t *md2;
|
||||
|
||||
@@ -1105,7 +1105,7 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
|
||||
FTransform p;
|
||||
FSurfaceInfo Surf;
|
||||
|
||||
if (!cv_grmdls.value)
|
||||
if (!cv_glmdls.value)
|
||||
return;
|
||||
|
||||
if (spr->precip)
|
||||
@@ -1166,7 +1166,7 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
|
||||
angle_t ang;
|
||||
interpmobjstate_t interp;
|
||||
|
||||
if (R_UsingFrameInterpolation() && !paused && (!cv_grmaxinterpdist.value || R_QuickCamDist(spr->mobj->x, spr->mobj->y) < cv_grmaxinterpdist.value))
|
||||
if (R_UsingFrameInterpolation() && !paused && (!cv_maxinterpdist.value || R_QuickCamDist(spr->mobj->x, spr->mobj->y) < cv_maxinterpdist.value))
|
||||
{
|
||||
R_InterpolateMobjState(spr->mobj, rendertimefrac, &interp);
|
||||
}
|
||||
@@ -1246,22 +1246,22 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
|
||||
}
|
||||
}
|
||||
//Hurdler: arf, I don't like that implementation at all... too much crappy
|
||||
gpatch = md2->grpatch;
|
||||
gpatch = md2->glpatch;
|
||||
if (!gpatch || ((!gpatch->mipmap->format || !gpatch->mipmap->downloaded) && !gpatch->notfound))
|
||||
md2_loadTexture(md2);
|
||||
gpatch = md2->grpatch; // Load it again, because it isn't being loaded into gpatch after md2_loadtexture...
|
||||
gpatch = md2->glpatch; // Load it again, because it isn't being loaded into gpatch after md2_loadtexture...
|
||||
|
||||
if ((gpatch && gpatch->mipmap->format) // don't load the blend texture if the base texture isn't available
|
||||
&& (!md2->blendgrpatch
|
||||
|| ((!((GLPatch_t *)md2->blendgrpatch)->mipmap->format || !((GLPatch_t *)md2->blendgrpatch)->mipmap->downloaded)
|
||||
&& !((GLPatch_t *)md2->blendgrpatch)->notfound)))
|
||||
&& (!md2->blendglpatch
|
||||
|| ((!((GLPatch_t *)md2->blendglpatch)->mipmap->format || !((GLPatch_t *)md2->blendglpatch)->mipmap->downloaded)
|
||||
&& !((GLPatch_t *)md2->blendglpatch)->notfound)))
|
||||
md2_loadBlendTexture(md2);
|
||||
|
||||
if (gpatch && gpatch->mipmap->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 &&
|
||||
md2->blendgrpatch && ((GLPatch_t *)md2->blendgrpatch)->mipmap->format
|
||||
&& gpatch->width == ((GLPatch_t *)md2->blendgrpatch)->width && gpatch->height == ((GLPatch_t *)md2->blendgrpatch)->height)
|
||||
md2->blendglpatch && ((GLPatch_t *)md2->blendglpatch)->mipmap->format
|
||||
&& gpatch->width == ((GLPatch_t *)md2->blendglpatch)->width && gpatch->height == ((GLPatch_t *)md2->blendglpatch)->height)
|
||||
{
|
||||
INT32 tcskinnum = TC_DEFAULT;
|
||||
if ((spr->mobj->flags & MF_BOSS) && (spr->mobj->flags2 & MF2_FRET) && (leveltime & 1)) // Bosses "flash"
|
||||
@@ -1286,7 +1286,7 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
|
||||
}
|
||||
else tcskinnum = TC_DEFAULT;
|
||||
}
|
||||
HWR_GetBlendedTexture(gpatch, (GLPatch_t *)md2->blendgrpatch, tcskinnum, spr->colormap, (skincolors_t)spr->mobj->color);
|
||||
HWR_GetBlendedTexture(gpatch, (GLPatch_t *)md2->blendglpatch, tcskinnum, spr->colormap, (skincolors_t)spr->mobj->color);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1315,7 +1315,7 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
|
||||
// Interpolate the model interpolation. (lol)
|
||||
tics -= FixedToFloat(rendertimefrac);
|
||||
|
||||
if (cv_grmdls.value == 1 && tics <= durs)
|
||||
if (cv_glmdls.value == 1 && tics <= durs)
|
||||
{
|
||||
// frames are handled differently for states with FF_ANIMATE, so get the next frame differently for the interpolation
|
||||
if (spr->mobj->frame & FF_ANIMATE)
|
||||
@@ -1480,8 +1480,8 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
|
||||
float oy = ys * flipfactor*FIXED_TO_FLOAT(interp.spriteyoffset);
|
||||
|
||||
// offset perpendicular to the camera angle
|
||||
p.x -= ox * gr_viewsin;
|
||||
p.y += ox * gr_viewcos;
|
||||
p.x -= ox * gl_viewsin;
|
||||
p.y += ox * gl_viewcos;
|
||||
p.z += oy;
|
||||
|
||||
HWD.pfnDrawModel(md2->model, frame, durs, tics, nextFrame, &p, md2->scale * xs, md2->scale * ys, flip, hflip, &Surf);
|
||||
|
||||
@@ -28,8 +28,8 @@ typedef struct
|
||||
float scale;
|
||||
float offset;
|
||||
model_t *model;
|
||||
void *grpatch;
|
||||
void *blendgrpatch;
|
||||
void *glpatch;
|
||||
void *blendglpatch;
|
||||
boolean notfound;
|
||||
INT32 skin;
|
||||
boolean error;
|
||||
@@ -40,7 +40,7 @@ extern md2_t md2_playermodels[MAXSKINS];
|
||||
extern md2_t md2_localplayermodels[MAXLOCALSKINS];
|
||||
|
||||
void HWR_InitMD2(void);
|
||||
void HWR_DrawMD2(gr_vissprite_t *spr);
|
||||
void HWR_DrawMD2(gl_vissprite_t *spr);
|
||||
void HWR_AddPlayerMD2(INT32 skin, boolean local);
|
||||
void HWR_AddSpriteMD2(size_t spritenum);
|
||||
|
||||
|
||||
@@ -28,7 +28,7 @@
|
||||
#include "hw_main.h"
|
||||
#include "hw_portal.h"
|
||||
|
||||
SINT8 gl_portal_state = GRPORTAL_OFF;
|
||||
SINT8 gl_portal_state = GLPORTAL_OFF;
|
||||
|
||||
gl_portallist_t portallist;
|
||||
gl_portallist_t *currentportallist;
|
||||
@@ -152,9 +152,9 @@ void HWR_RenderPortalSeg(gl_portal_t* portal, SINT8 state)
|
||||
gl_drawing_stencil = true; // do not draw outside of the stencil buffer, idiot.
|
||||
// set our portal state and prepare to render the seg
|
||||
HWR_SetPortalState(state);
|
||||
gr_curline = portal->seg;
|
||||
gr_frontsector = portal->seg->frontsector;
|
||||
gr_backsector = portal->seg->backsector;
|
||||
gl_curline = portal->seg;
|
||||
gl_frontsector = portal->seg->frontsector;
|
||||
gl_backsector = portal->seg->backsector;
|
||||
HWR_ProcessSeg();
|
||||
gl_drawing_stencil = false;
|
||||
// need to work around the r_opengl PF_Invisible bug with this call
|
||||
@@ -170,7 +170,7 @@ void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float
|
||||
HWR_ClearClipper();
|
||||
|
||||
HWR_SetStencilState(HWR_STENCIL_BEGIN, stencil_level);
|
||||
HWR_RenderPortalSeg(portal, GRPORTAL_STENCIL);
|
||||
HWR_RenderPortalSeg(portal, GLPORTAL_STENCIL);
|
||||
|
||||
// go to portal frame lmao
|
||||
HWR_PortalFrame(portal);
|
||||
@@ -190,12 +190,12 @@ void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float
|
||||
HWR_ClearClipper();
|
||||
|
||||
HWR_SetStencilState(HWR_STENCIL_REVERSE, stencil_level);
|
||||
HWR_RenderPortalSeg(portal, GRPORTAL_STENCIL);
|
||||
HWR_RenderPortalSeg(portal, GLPORTAL_STENCIL);
|
||||
|
||||
// draw portal seg to depth buffer
|
||||
HWR_ClearClipper();
|
||||
HWR_SetStencilState(HWR_STENCIL_DEPTH, stencil_level);
|
||||
HWR_RenderPortalSeg(portal, GRPORTAL_DEPTH);
|
||||
HWR_RenderPortalSeg(portal, GLPORTAL_DEPTH);
|
||||
}
|
||||
|
||||
// idea for fixing fakery map: one portal pillar works, 2 pillars have left/right bug wall, 1 pillar has both sides bugged.
|
||||
|
||||
@@ -24,11 +24,11 @@
|
||||
*/
|
||||
enum
|
||||
{
|
||||
GRPORTAL_OFF,
|
||||
GRPORTAL_SEARCH,
|
||||
GRPORTAL_STENCIL,
|
||||
GRPORTAL_DEPTH,
|
||||
GRPORTAL_INSIDE,
|
||||
GLPORTAL_OFF,
|
||||
GLPORTAL_SEARCH,
|
||||
GLPORTAL_STENCIL,
|
||||
GLPORTAL_DEPTH,
|
||||
GLPORTAL_INSIDE,
|
||||
};
|
||||
|
||||
typedef struct gl_portal_s
|
||||
|
||||
@@ -283,7 +283,7 @@ static char *HWR_PreprocessShader(char *original)
|
||||
// Calculate length of modified shader.
|
||||
new_len = original_len;
|
||||
|
||||
if (cv_grpaletterendering.value)
|
||||
if (cv_glpaletterendering.value)
|
||||
ADD_TO_LEN(PALETTE_RENDERING_DEFINE)
|
||||
|
||||
if (cv_lightdither.value)
|
||||
@@ -327,7 +327,7 @@ static char *HWR_PreprocessShader(char *original)
|
||||
}
|
||||
|
||||
// Write the defines.
|
||||
if (cv_grpaletterendering.value)
|
||||
if (cv_glpaletterendering.value)
|
||||
WRITE_DEFINE(PALETTE_RENDERING_DEFINE)
|
||||
|
||||
if (cv_lightdither.value)
|
||||
@@ -413,7 +413,7 @@ int HWR_GetShaderFromTarget(int shader_target)
|
||||
// - custom shaders are enabled
|
||||
// - custom shaders are allowed by the server
|
||||
if (custom_shader != -1 && gl_shaders[custom_shader].compiled &&
|
||||
cv_grshaders.value == 1)
|
||||
cv_glshaders.value == 1)
|
||||
return custom_shader;
|
||||
else
|
||||
return gl_shadertargets[shader_target].base_shader;
|
||||
@@ -569,7 +569,7 @@ void HWR_LoadCustomShadersFromFile(UINT16 wadnum, boolean PK3)
|
||||
int i;
|
||||
boolean modified_shaders[NUMSHADERTARGETS] = {0};
|
||||
|
||||
if (!gr_shadersavailable)
|
||||
if (!gl_shadersavailable)
|
||||
return;
|
||||
|
||||
lump = HWR_FindShaderDefs(wadnum);
|
||||
|
||||
@@ -2428,7 +2428,7 @@ EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value)
|
||||
if (!supportFBO)
|
||||
{
|
||||
FrameBufferEnabled = GL_FALSE;
|
||||
CV_Set(&cv_grframebuffer, "Off");
|
||||
CV_Set(&cv_glframebuffer, "Off");
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
|
||||
+1
-1
@@ -9325,7 +9325,7 @@ static boolean K_GetScreenCoords(vector2_t *vec, player_t *player, mobj_t *targe
|
||||
|
||||
#ifdef HWRENDER
|
||||
// NOW we can get the angle differnce
|
||||
if (rendermode == render_opengl && cv_grshearing.value == 0)
|
||||
if (rendermode == render_opengl && cv_glshearing.value == 0)
|
||||
{
|
||||
angle_t yang = R_PointToAngle2(0, 0, dist, y); // not perspective
|
||||
x = FixedMul(x, FINECOSINE((yang>>ANGLETOFINESHIFT) & FINEMASK)); // perspective
|
||||
|
||||
+19
-19
@@ -1484,7 +1484,7 @@ static menuitem_t OP_ColorOptionsMenu[] =
|
||||
static menuitem_t OP_ExpOptionsMenu[] =
|
||||
{
|
||||
{IT_HEADER, NULL, "Advanced Video Options", NULL, 10},
|
||||
{IT_STRING|IT_CVAR, NULL, "Interpolation Distance", &cv_grmaxinterpdist, 30},
|
||||
{IT_STRING|IT_CVAR, NULL, "Interpolation Distance", &cv_maxinterpdist, 30},
|
||||
{IT_STRING | IT_CVAR, NULL, "Weather Interpolation", &cv_precipinterp, 40},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Scale Weather with Mobjscale", &cv_mobjscaleprecip, 60},
|
||||
@@ -1493,11 +1493,11 @@ static menuitem_t OP_ExpOptionsMenu[] =
|
||||
{IT_STRING | IT_CVAR, NULL, "Skyboxes", &cv_skybox, 80},
|
||||
|
||||
#ifdef HWRENDER
|
||||
{IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_grscreentextures, 100},
|
||||
{IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 100},
|
||||
#ifdef USE_FBO_OGL
|
||||
{IT_STRING | IT_CVAR, NULL, "FBO Downsampling support", &cv_grframebuffer, 110},
|
||||
{IT_STRING | IT_CVAR, NULL, "FBO Downsampling support", &cv_glframebuffer, 110},
|
||||
#endif
|
||||
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_grpalettedepth, 130},
|
||||
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 130},
|
||||
#endif
|
||||
};
|
||||
|
||||
@@ -1527,7 +1527,7 @@ enum
|
||||
op_exp_lessprecip,
|
||||
op_exp_skybox,
|
||||
#ifdef HWRENDER
|
||||
op_exp_grscrtx,
|
||||
op_exp_glscrtx,
|
||||
#ifdef USE_FBO_OGL
|
||||
op_exp_fbo,
|
||||
#endif
|
||||
@@ -1539,24 +1539,24 @@ enum
|
||||
#ifdef HWRENDER
|
||||
static menuitem_t OP_OpenGLOptionsMenu[] =
|
||||
{
|
||||
{IT_STRING | IT_CVAR, NULL, "3D Models", &cv_grmdls, 15},
|
||||
{IT_STRING | IT_CVAR, NULL, "Fallback Player 3D Model", &cv_grfallbackplayermodel, 20},
|
||||
{IT_STRING | IT_CVAR, NULL, "Shaders", &cv_grshaders, 25},
|
||||
{IT_STRING | IT_CVAR, NULL, "Palette Rendering", &cv_grpaletterendering, 30},
|
||||
{IT_STRING | IT_CVAR, NULL, "Flashpals in Palette Renderer", &cv_grflashpal, 35},
|
||||
{IT_STRING | IT_CVAR, NULL, "3D Models", &cv_glmdls, 15},
|
||||
{IT_STRING | IT_CVAR, NULL, "Fallback Player 3D Model", &cv_glfallbackplayermodel, 20},
|
||||
{IT_STRING | IT_CVAR, NULL, "Shaders", &cv_glshaders, 25},
|
||||
{IT_STRING | IT_CVAR, NULL, "Palette Rendering", &cv_glpaletterendering, 30},
|
||||
{IT_STRING | IT_CVAR, NULL, "Flashpals in Palette Renderer", &cv_glflashpal, 35},
|
||||
{IT_STRING | IT_CVAR, NULL, "Min Shader Brightness", &cv_secbright, 40},
|
||||
|
||||
{IT_STRING|IT_CVAR, NULL, "Texture Quality", &cv_scr_depth, 50},
|
||||
{IT_STRING|IT_CVAR, NULL, "Texture Filter", &cv_grfiltermode, 55},
|
||||
{IT_STRING|IT_CVAR, NULL, "Anisotropic", &cv_granisotropicmode, 60},
|
||||
{IT_STRING|IT_CVAR, NULL, "Visual Portals", &cv_grportals, 65},
|
||||
{IT_STRING|IT_CVAR, NULL, "Texture Filter", &cv_glfiltermode, 55},
|
||||
{IT_STRING|IT_CVAR, NULL, "Anisotropic", &cv_glanisotropicmode, 60},
|
||||
{IT_STRING|IT_CVAR, NULL, "Visual Portals", &cv_glportals, 65},
|
||||
|
||||
{IT_STRING|IT_CVAR, NULL, "Wall Contrast Style", &cv_grfakecontrast, 75},
|
||||
{IT_STRING|IT_CVAR, NULL, "Slope Contrast", &cv_grslopecontrast, 80},
|
||||
{IT_STRING|IT_CVAR, NULL, "Wall Contrast Style", &cv_glfakecontrast, 75},
|
||||
{IT_STRING|IT_CVAR, NULL, "Slope Contrast", &cv_glslopecontrast, 80},
|
||||
{IT_STRING | IT_CVAR, NULL, "Dithered Lightning", &cv_lightdither, 85},
|
||||
{IT_STRING|IT_CVAR, NULL, "Sprite Billboarding", &cv_grspritebillboarding, 90},
|
||||
{IT_STRING|IT_CVAR, NULL, "Software Perspective", &cv_grshearing, 95},
|
||||
{IT_STRING|IT_CVAR, NULL, "Rendering Distance", &cv_grrenderdistance, 100},
|
||||
{IT_STRING|IT_CVAR, NULL, "Sprite Billboarding", &cv_glspritebillboarding, 90},
|
||||
{IT_STRING|IT_CVAR, NULL, "Software Perspective", &cv_glshearing, 95},
|
||||
{IT_STRING|IT_CVAR, NULL, "Rendering Distance", &cv_glrenderdistance, 100},
|
||||
};
|
||||
|
||||
static const char* OP_OpenGLTooltips[] =
|
||||
@@ -4687,7 +4687,7 @@ void M_Init(void)
|
||||
if (rendermode == render_soft)
|
||||
{
|
||||
OP_VideoOptionsMenu[op_video_ogl].status = IT_DISABLED;
|
||||
OP_ExpOptionsMenu[op_exp_grscrtx].status = IT_DISABLED;
|
||||
OP_ExpOptionsMenu[op_exp_glscrtx].status = IT_DISABLED;
|
||||
#ifdef USE_FBO_OGL
|
||||
OP_ExpOptionsMenu[op_exp_fbo].status = IT_DISABLED;
|
||||
#endif
|
||||
|
||||
+4
-4
@@ -301,7 +301,7 @@ static boolean PS_IsRowValid(perfstatrow_t *row)
|
||||
|| (row->flags & PS_SW && rendermode != render_soft)
|
||||
|| (row->flags & PS_HW && rendermode != render_opengl)
|
||||
#ifdef HWRENDER
|
||||
|| (row->flags & PS_BATCHING && !cv_grbatching.value)
|
||||
|| (row->flags & PS_BATCHING && !cv_glbatching.value)
|
||||
#endif
|
||||
);
|
||||
}
|
||||
@@ -518,7 +518,7 @@ static void PS_UpdateFrameStats(void)
|
||||
ps_hw_spritesorttime.value.p +
|
||||
ps_hw_spritedrawtime.value.p;
|
||||
|
||||
if (cv_grbatching.value)
|
||||
if (cv_glbatching.value)
|
||||
{
|
||||
ps_otherrendertime.value.p -=
|
||||
ps_hw_batchsorttime.value.p +
|
||||
@@ -547,7 +547,7 @@ static void PS_UpdateFrameStats(void)
|
||||
PS_UpdateRowHistories(interpolation_rows, true);*/
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl && cv_grbatching.value)
|
||||
if (rendermode == render_opengl && cv_glbatching.value)
|
||||
{
|
||||
PS_UpdateRowHistories(batchcount_rows, true);
|
||||
PS_UpdateRowHistories(batchcalls_rows, true);
|
||||
@@ -760,7 +760,7 @@ static void PS_DrawRenderStats(void)
|
||||
/*cy = */PS_DrawPerfRows(x, 10, V_BLUEMAP, commoncounter_rows);// + half_row;
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl && cv_grbatching.value)
|
||||
if (rendermode == render_opengl && cv_glbatching.value)
|
||||
{
|
||||
x = hires ? 200 : 155;
|
||||
y = PS_DrawPerfRows(x, 10, V_PURPLEMAP, batchcount_rows);
|
||||
|
||||
+1
-1
@@ -2370,7 +2370,7 @@ static void P_MovePlayer(player_t *player)
|
||||
}
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode != render_soft && rendermode != render_none && cv_grfovchange.value)
|
||||
if (rendermode != render_soft && rendermode != render_none && cv_glfovchange.value)
|
||||
{
|
||||
fixed_t speed;
|
||||
const fixed_t runnyspeed = 20*FRACUNIT;
|
||||
|
||||
+2
-2
@@ -131,7 +131,7 @@ static void R_SetupFreelook(void)
|
||||
// (lmps, network and use F12...)
|
||||
if (rendermode == render_soft
|
||||
#ifdef HWRENDER
|
||||
|| cv_grshearing.value
|
||||
|| cv_glshearing.value
|
||||
#endif
|
||||
)
|
||||
{
|
||||
@@ -333,7 +333,7 @@ void R_InterpolateMobjState(mobj_t *mobj, fixed_t frac, interpmobjstate_t *out)
|
||||
out->angle = mobj->resetinterp ? mobj->angle : R_LerpAngle(mobj->old_angle, mobj->angle, frac);
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (cv_grmdls.value)
|
||||
if (cv_glmdls.value)
|
||||
{
|
||||
// pitch roll stuff
|
||||
out->pitch = mobj->resetinterp ? mobj->pitch : R_LerpAngle(mobj->old_pitch, mobj->pitch, frac);
|
||||
|
||||
+2
-2
@@ -193,7 +193,7 @@ consvar_t cv_drawdist_precip = {"drawdist_precip", "1024", CV_SAVE|CV_CALL|CV_NO
|
||||
consvar_t cv_lessprecip = {"lessweathereffects", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, Precipstuff_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_mobjscaleprecip = {"scaleprecipmobjscale", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, Precipstuff_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_grmaxinterpdist = {"gr_maxinterpdist", "Infinite", CV_SAVE, maxinterpdist_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_maxinterpdist = {"maxinterpdist", "Infinite", CV_SAVE, maxinterpdist_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_ripplewater = {"waterripples", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
@@ -1556,7 +1556,7 @@ void R_RegisterEngineStuff(void)
|
||||
|
||||
CV_RegisterVar(&cv_maxportals);
|
||||
|
||||
CV_RegisterVar(&cv_grmaxinterpdist);
|
||||
CV_RegisterVar(&cv_maxinterpdist);
|
||||
|
||||
CV_RegisterVar(&cv_ripplewater);
|
||||
|
||||
|
||||
+1
-1
@@ -205,7 +205,7 @@ extern consvar_t cv_drawdist, cv_drawdist_precip, cv_lessprecip, cv_mobjscalepre
|
||||
extern consvar_t cv_fov;
|
||||
extern consvar_t cv_skybox;
|
||||
extern consvar_t cv_tailspickup;
|
||||
extern consvar_t cv_grmaxinterpdist;
|
||||
extern consvar_t cv_maxinterpdist;
|
||||
extern consvar_t cv_ripplewater;
|
||||
|
||||
// Called by startup code.
|
||||
|
||||
+4
-4
@@ -1202,14 +1202,14 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
|
||||
INT32 dist = -1;
|
||||
|
||||
if (cv_grmaxinterpdist.value)
|
||||
if (cv_maxinterpdist.value)
|
||||
dist = R_QuickCamDist(thing->x, thing->y);
|
||||
|
||||
// uncapped/interpolation
|
||||
interpmobjstate_t interp = {0};
|
||||
|
||||
// do interpolation
|
||||
if (R_UsingFrameInterpolation() && !paused && (!cv_grmaxinterpdist.value || dist < cv_grmaxinterpdist.value))
|
||||
if (R_UsingFrameInterpolation() && !paused && (!cv_maxinterpdist.value || dist < cv_maxinterpdist.value))
|
||||
{
|
||||
R_InterpolateMobjState(oldthing, rendertimefrac, &interp);
|
||||
}
|
||||
@@ -1812,7 +1812,7 @@ static void R_ProjectPrecipitationSprite(precipmobj_t *thing)
|
||||
|
||||
INT32 dist = 1;
|
||||
|
||||
if (cv_grmaxinterpdist.value)
|
||||
if (cv_maxinterpdist.value)
|
||||
dist = R_QuickCamDist(thing->x, thing->y);
|
||||
|
||||
// uncapped/interpolation
|
||||
@@ -1825,7 +1825,7 @@ static void R_ProjectPrecipitationSprite(precipmobj_t *thing)
|
||||
}
|
||||
|
||||
// do interpolation
|
||||
if (R_UsingFrameInterpolation() && !paused && (!cv_grmaxinterpdist.value || dist < cv_grmaxinterpdist.value))
|
||||
if (R_UsingFrameInterpolation() && !paused && (!cv_maxinterpdist.value || dist < cv_maxinterpdist.value))
|
||||
{
|
||||
R_InterpolatePrecipMobjState(thing, rendertimefrac, &interp);
|
||||
}
|
||||
|
||||
+1
-1
@@ -709,7 +709,7 @@ static INT32 SDLJoyAxis(const Sint16 axis, evtype_t which)
|
||||
#ifdef USE_FBO_OGL
|
||||
void I_DownSample(void)
|
||||
{
|
||||
if (!cv_grframebuffer.value || !supportFBO) //no sense to do this crap if we cant benefit from it
|
||||
if (!cv_glframebuffer.value || !supportFBO) //no sense to do this crap if we cant benefit from it
|
||||
{
|
||||
downsample = false;
|
||||
return;
|
||||
|
||||
+1
-1
@@ -171,7 +171,7 @@ boolean OglSdlSurface(INT32 w, INT32 h)
|
||||
else
|
||||
maximumAnisotropy = 1;
|
||||
|
||||
granisotropicmode_cons_t[1].value = maximumAnisotropy;
|
||||
glanisotropicmode_cons_t[1].value = maximumAnisotropy;
|
||||
|
||||
#if defined (__unix__)
|
||||
#ifdef USE_FBO_OGL
|
||||
|
||||
+1
-1
@@ -368,7 +368,7 @@ void Y_IntermissionDrawer(void)
|
||||
|
||||
if (cv_betainterscreen.value == 1
|
||||
#ifdef HWRENDER
|
||||
|| (rendermode == render_opengl && cv_grscreentextures.value != 2) // use the neato kart bg for intermission on disabled screen textures
|
||||
|| (rendermode == render_opengl && cv_glscreentextures.value != 2) // use the neato kart bg for intermission on disabled screen textures
|
||||
#endif
|
||||
)
|
||||
V_DrawPatchFill(bgtile); // use the neato kart bg for intermission on disabled screen textures
|
||||
|
||||
Reference in new issue
Block a user