Merge branch 'refactorogl' into Saturn-Testing
This commit is contained in:
commit
acd9763b9d
57 files changed
+2635
-2451
No files matched your search
@@ -470,6 +470,7 @@ if(${SRB2_CONFIG_HWRENDER})
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_clip.c
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_draw.c
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.c
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_portal.c
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2.c
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2load.c
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md3load.c
|
||||
@@ -487,6 +488,7 @@ if(${SRB2_CONFIG_HWRENDER})
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_drv.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_glob.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_portal.c
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2load.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md3load.h
|
||||
|
||||
+4
-3
@@ -293,7 +293,7 @@ ifdef NOHW
|
||||
else
|
||||
OPTS+=-DHWRENDER
|
||||
OBJS+=$(OBJDIR)/hw_bsp.o $(OBJDIR)/hw_draw.o \
|
||||
$(OBJDIR)/hw_main.o $(OBJDIR)/hw_clip.o $(OBJDIR)/hw_md2.o $(OBJDIR)/hw_cache.o \
|
||||
$(OBJDIR)/hw_main.o $(OBJDIR)/hw_clip.o $(OBJDIR)/hw_md2.o $(OBJDIR)/hw_cache.o $(OBJDIR)/hw_portal.o\
|
||||
$(OBJDIR)/hw_md2load.o $(OBJDIR)/hw_md3load.o $(OBJDIR)/hw_model.o $(OBJDIR)/u_list.o $(OBJDIR)/hw_batching.o $(OBJDIR)/hw_shaders.o
|
||||
endif
|
||||
|
||||
@@ -563,6 +563,7 @@ OBJS:=$(i_main_o) \
|
||||
$(OBJDIR)/r_splats.o \
|
||||
$(OBJDIR)/r_patch.o \
|
||||
$(OBJDIR)/r_things.o \
|
||||
$(OBJDIR)/r_portal.o \
|
||||
$(OBJDIR)/screen.o \
|
||||
$(OBJDIR)/v_video.o \
|
||||
$(OBJDIR)/s_sound.o \
|
||||
@@ -738,7 +739,7 @@ ifdef MINGW
|
||||
$(OBJDIR)/r_opengl.o: hardware/r_opengl/r_opengl.c hardware/r_opengl/r_opengl.h \
|
||||
doomdef.h doomtype.h g_state.h m_swap.h hardware/hw_drv.h screen.h \
|
||||
command.h hardware/hw_data.h hardware/hw_defs.h hardware/hw_md2.h \
|
||||
hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h \
|
||||
hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h hardware/hw_portal.h\
|
||||
hardware/hw_md2load.h hardware/hw_md3load.h hardware/hw_model.h hardware/u_list.h \
|
||||
am_map.h d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
|
||||
p_mobj.h doomdata.h d_ticcmd.h r_defs.h hardware/hw_dll.h
|
||||
@@ -747,7 +748,7 @@ else
|
||||
$(OBJDIR)/r_opengl.o: hardware/r_opengl/r_opengl.c hardware/r_opengl/r_opengl.h \
|
||||
doomdef.h doomtype.h g_state.h m_swap.h hardware/hw_drv.h screen.h \
|
||||
command.h hardware/hw_data.h hardware/hw_defs.h hardware/hw_md2.h \
|
||||
hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h \
|
||||
hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h hardware/hw_portal.h \
|
||||
hardware/hw_md2load.h hardware/hw_md3load.h hardware/hw_model.h hardware/u_list.h \
|
||||
am_map.h d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
|
||||
p_mobj.h doomdata.h d_ticcmd.h r_defs.h hardware/hw_dll.h
|
||||
|
||||
+1
-1
@@ -628,7 +628,7 @@ static void COM_ExecuteString(char *ptext)
|
||||
|
||||
// check cvars
|
||||
// Hurdler: added at Ebola's request ;)
|
||||
// (don't flood the console in software mode with bad gr_xxx command)
|
||||
// (don't flood the console in software mode with bad gl_xxx command)
|
||||
if (!CV_Command() && con_destlines)
|
||||
CONS_Printf(M_GetText("Unknown command '%s'\n"), COM_Argv(0));
|
||||
}
|
||||
|
||||
+1
-1
@@ -4345,7 +4345,7 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
|
||||
if (server && multiplayer && motd[0] != '\0')
|
||||
COM_BufAddText(va("sayto %d %s\n", newplayernum, motd));
|
||||
|
||||
D_AddAutoloadFiles();
|
||||
D_AddPostloadFiles();
|
||||
|
||||
LUAh_PlayerJoin(newplayernum);
|
||||
|
||||
|
||||
+29
-55
@@ -117,7 +117,6 @@ boolean devparm = false; // started game with -devparm
|
||||
boolean singletics = false; // timedemo
|
||||
boolean lastdraw = false;
|
||||
|
||||
postimg_t postimgtype[MAXSPLITSCREENPLAYERS];
|
||||
INT32 postimgparam[MAXSPLITSCREENPLAYERS];
|
||||
|
||||
// These variables are only true if
|
||||
@@ -514,15 +513,12 @@ static boolean D_Display(void)
|
||||
|
||||
if (rendermode == render_soft)
|
||||
{
|
||||
if (!splitscreen)
|
||||
R_ApplyViewMorph();
|
||||
if (!splitscreen)
|
||||
R_ApplyViewMorph();
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (!postimgtype[i])
|
||||
continue;
|
||||
|
||||
V_DoPostProcessor(i, postimgtype[i], postimgparam[i]);
|
||||
V_DoPostProcessor(i, &players[displayplayers[i]], postimgparam[i]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1073,8 +1069,7 @@ static void D_FindAddonsToAutoload(void)
|
||||
const char *autoloadpath;
|
||||
boolean postload;
|
||||
|
||||
INT32 i, len;
|
||||
boolean hasprefix = false;
|
||||
INT32 i;
|
||||
char wadsToAutoload[256] = "";
|
||||
|
||||
// does it exist tho
|
||||
@@ -1096,7 +1091,8 @@ static void D_FindAddonsToAutoload(void)
|
||||
|| (wadsToAutoload[0] == '#'))
|
||||
continue;
|
||||
// this marks it so that it loads after loading server addons
|
||||
else if (fastncmp(wadsToAutoload, "postload ", 9)) {
|
||||
else if (fastncmp(wadsToAutoload, "postload ", 9))
|
||||
{
|
||||
strremove(wadsToAutoload, "postload ");
|
||||
postload = true;
|
||||
}
|
||||
@@ -1108,34 +1104,10 @@ static void D_FindAddonsToAutoload(void)
|
||||
wadsToAutoload[i] = '\0';
|
||||
}
|
||||
|
||||
len = strlen(wadsToAutoload);
|
||||
hasprefix = false;
|
||||
|
||||
for (i = 0; i < len; ++i)
|
||||
if (!postload && W_CheckPostLoadList(wadsToAutoload))
|
||||
{
|
||||
if (wadsToAutoload[i] == '_')
|
||||
{
|
||||
hasprefix = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Lets just hope no one adds bonuschars in autoload
|
||||
if (hasprefix)
|
||||
{
|
||||
// We searching for c in prefix, which stands for "character" and doesn't work well with
|
||||
// autoload atm, only fine for postload
|
||||
for (i = 0; i < len; ++i)
|
||||
{
|
||||
if (wadsToAutoload[i] == '_') break; // Prefix end
|
||||
|
||||
if (wadsToAutoload[i] == 'c' || wadsToAutoload[i] == 'C')
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, "forcing postload for %s as local skin\n", wadsToAutoload);
|
||||
postload = true;
|
||||
break; // Found it
|
||||
}
|
||||
}
|
||||
CONS_Printf("forcing postload for file %s\n", wadsToAutoload);
|
||||
postload = true;
|
||||
}
|
||||
|
||||
// LOAD IT
|
||||
@@ -1153,30 +1125,30 @@ static void D_FindAddonsToAutoload(void)
|
||||
fclose(autoloadconfigfile);
|
||||
}
|
||||
|
||||
void D_AddAutoloadFiles(void)
|
||||
static void D_AddAutoloadFiles(void)
|
||||
{
|
||||
if (wasautoloaded && postautoloaded)
|
||||
if (wasautoloaded)
|
||||
return;
|
||||
|
||||
if (!wasautoloaded && !modeattacking)
|
||||
{
|
||||
CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
|
||||
if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
|
||||
CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
|
||||
D_CleanFile(autoloadwadfiles);
|
||||
CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
|
||||
if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
|
||||
CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
|
||||
D_CleanFile(autoloadwadfiles);
|
||||
|
||||
wasautoloaded = true;
|
||||
}
|
||||
wasautoloaded = true;
|
||||
}
|
||||
|
||||
if ((!postautoloaded) && netgame)
|
||||
{
|
||||
CONS_Printf("D_AutoloadFile(): Loading postloaded addons...\n");
|
||||
if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
|
||||
CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
|
||||
D_CleanFile(autoloadwadfilespost);
|
||||
void D_AddPostloadFiles(void)
|
||||
{
|
||||
if (postautoloaded || !netgame)
|
||||
return;
|
||||
|
||||
postautoloaded = true;
|
||||
}
|
||||
CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
|
||||
if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
|
||||
CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");
|
||||
D_CleanFile(autoloadwadfilespost);
|
||||
|
||||
postautoloaded = true;
|
||||
}
|
||||
|
||||
void D_CleanFile(char **filearray)
|
||||
@@ -1874,6 +1846,8 @@ void D_SRB2Main(void)
|
||||
CONS_Printf("ST_Init(): Init status bar.\n");
|
||||
ST_Init();
|
||||
|
||||
D_AddAutoloadFiles();
|
||||
|
||||
// Set up splitscreen players before joining!
|
||||
if (!dedicated && (M_CheckParm("-splitscreen") && M_IsNextParm()))
|
||||
{
|
||||
|
||||
+3
-3
@@ -45,12 +45,12 @@ extern boolean statdp; // stat display for extended player setup
|
||||
extern boolean nametaggfx; // Nametag stuffs
|
||||
extern boolean driftgaugegfx;
|
||||
|
||||
void D_AddAutoloadFiles(void);
|
||||
|
||||
// autoload stuff
|
||||
extern boolean autoloading;
|
||||
extern boolean autoloaded;
|
||||
extern boolean postautoloaded;
|
||||
extern boolean wasautoloaded;
|
||||
|
||||
void D_AddPostloadFiles(void);
|
||||
|
||||
extern char *autoloadwadfilespost[MAX_WADFILES];
|
||||
extern char *autoloadwadfiles[MAX_WADFILES];
|
||||
|
||||
@@ -413,6 +413,8 @@ typedef struct player_s
|
||||
// See pflags_t, above.
|
||||
pflags_t pflags;
|
||||
|
||||
UINT16 postimgflags;
|
||||
|
||||
// playing animation.
|
||||
panim_t panim;
|
||||
|
||||
|
||||
@@ -112,7 +112,6 @@ extern UINT8 window_notinfocus; // are we in focus? (backend independant -- hand
|
||||
extern boolean nodrawers;
|
||||
extern boolean noblit;
|
||||
extern boolean lastdraw;
|
||||
extern postimg_t postimgtype[MAXSPLITSCREENPLAYERS];
|
||||
extern INT32 postimgparam[MAXSPLITSCREENPLAYERS];
|
||||
|
||||
extern INT32 viewwindowx, viewwindowy;
|
||||
|
||||
+6
-8
@@ -344,14 +344,12 @@ typedef union FColorRGBA RGBA_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
postimg_none,
|
||||
postimg_water,
|
||||
postimg_motion,
|
||||
postimg_flip,
|
||||
postimg_heat,
|
||||
postimg_mirror,
|
||||
postimg_mirrorflip
|
||||
} postimg_t;
|
||||
POSTIMG_WATER = 1, // Underwater screen effect.
|
||||
POSTIMG_MOTION = 1<<1, // Unused motion blur effect.
|
||||
POSTIMG_FLIP = 1<<2, // Flipcam screen effect.
|
||||
POSTIMG_HEAT = 1<<3, // Heatwave screen effect.
|
||||
POSTIMG_MIRROR = 1<<4, // encore screen effect.
|
||||
} postimgflag_t;
|
||||
|
||||
typedef UINT32 lumpnum_t; // 16 : 16 unsigned long (wad num: lump num)
|
||||
#define LUMPERROR UINT32_MAX
|
||||
|
||||
+23
-21
@@ -46,12 +46,12 @@ int unsortedVertexArrayAllocSize = 65536;
|
||||
// Call HWR_RenderBatches to render all the collected geometry.
|
||||
void HWR_StartBatching(void)
|
||||
{
|
||||
if (currently_batching)
|
||||
if (currently_batching)
|
||||
{
|
||||
I_Error("Repeat call to HWR_StartBatching without HWR_RenderBatches");
|
||||
I_Error("Repeat call to HWR_StartBatching without HWR_RenderBatches");
|
||||
}
|
||||
|
||||
// init arrays if that has not been done yet
|
||||
// init arrays if that has not been done yet
|
||||
if (!finalVertexArray)
|
||||
{
|
||||
finalVertexArray = malloc(finalVertexArrayAllocSize * sizeof(FOutVector));
|
||||
@@ -61,7 +61,7 @@ void HWR_StartBatching(void)
|
||||
unsortedVertexArray = malloc(unsortedVertexArrayAllocSize * sizeof(FOutVector));
|
||||
}
|
||||
|
||||
currently_batching = true;
|
||||
currently_batching = true;
|
||||
}
|
||||
|
||||
// This replaces the direct calls to pfnSetTexture in cases where batching is available.
|
||||
@@ -69,14 +69,14 @@ void HWR_StartBatching(void)
|
||||
// Doing this was easier than getting a texture pointer to HWR_ProcessPolygon.
|
||||
void HWR_SetCurrentTexture(GLMipmap_t *texture)
|
||||
{
|
||||
if (currently_batching)
|
||||
{
|
||||
current_texture = texture;
|
||||
}
|
||||
else
|
||||
{
|
||||
HWD.pfnSetTexture(texture);
|
||||
}
|
||||
if (currently_batching)
|
||||
{
|
||||
current_texture = texture;
|
||||
}
|
||||
else
|
||||
{
|
||||
HWD.pfnSetTexture(texture);
|
||||
}
|
||||
}
|
||||
|
||||
// If batching is enabled, this function collects the polygon data and the chosen texture
|
||||
@@ -84,7 +84,7 @@ void HWR_SetCurrentTexture(GLMipmap_t *texture)
|
||||
// render the polygon immediately.
|
||||
void HWR_ProcessPolygon(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags, int shader_target, boolean horizonSpecial)
|
||||
{
|
||||
if (currently_batching)
|
||||
if (currently_batching)
|
||||
{
|
||||
if (!pSurf)
|
||||
I_Error("Got a null FSurfaceInfo in batching");// nulls should not come in the stuff that batching currently applies to
|
||||
@@ -220,7 +220,7 @@ static int comparePolygonsNoShaders(const void *p1, const void *p2)
|
||||
// the rendering backend to draw them.
|
||||
void HWR_RenderBatches(void)
|
||||
{
|
||||
int finalVertexWritePos = 0;// position in finalVertexArray
|
||||
int finalVertexWritePos = 0;// position in finalVertexArray
|
||||
int finalIndexWritePos = 0;// position in finalVertexIndexArray
|
||||
|
||||
int polygonReadPos = 0;// position in polygonArraySorted
|
||||
@@ -236,7 +236,7 @@ void HWR_RenderBatches(void)
|
||||
|
||||
int i;
|
||||
|
||||
if (!currently_batching)
|
||||
if (!currently_batching)
|
||||
I_Error("HWR_RenderBatches called without starting batching");
|
||||
|
||||
nextSurfaceInfo.LightInfo.fade_end = 0;
|
||||
@@ -256,6 +256,7 @@ void HWR_RenderBatches(void)
|
||||
ps_hw_numcalls.value.i = ps_hw_numverts.value.i = 0;
|
||||
ps_hw_numshaders.value.i = ps_hw_numtextures.value.i
|
||||
= ps_hw_numpolyflags.value.i = ps_hw_numcolors.value.i = 1;
|
||||
|
||||
// init polygonArraySorted
|
||||
for (i = 0; i < polygonArraySize; i++)
|
||||
{
|
||||
@@ -264,11 +265,12 @@ 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);
|
||||
PS_STOP_TIMING(ps_hw_batchsorttime);
|
||||
|
||||
// sort order
|
||||
// 1. shader
|
||||
// 2. texture
|
||||
@@ -287,14 +289,14 @@ void HWR_RenderBatches(void)
|
||||
|
||||
// set state for first batch
|
||||
|
||||
if (cv_grshaders.value && gr_shadersavailable)
|
||||
if (cv_glshaders.value && gl_shadersavailable)
|
||||
{
|
||||
HWD.pfnSetShader(currentShader);
|
||||
}
|
||||
|
||||
if (currentPolyFlags & PF_NoTexture)
|
||||
currentTexture = NULL;
|
||||
else
|
||||
else
|
||||
HWD.pfnSetTexture(currentTexture);
|
||||
|
||||
while (1)// note: remember handling notexture polyflag as having texture number 0 (also in comparePolygons)
|
||||
@@ -369,7 +371,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;
|
||||
@@ -384,7 +386,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 ||
|
||||
@@ -457,6 +459,7 @@ void HWR_RenderBatches(void)
|
||||
|
||||
ps_hw_numcolors.value.i++;
|
||||
}
|
||||
// and that should be it?
|
||||
}
|
||||
}
|
||||
// reset the arrays (set sizes to 0)
|
||||
@@ -466,5 +469,4 @@ void HWR_RenderBatches(void)
|
||||
PS_STOP_TIMING(ps_hw_batchdrawtime);
|
||||
}
|
||||
|
||||
|
||||
#endif // HWRENDER
|
||||
@@ -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;
|
||||
|
||||
+132
-133
@@ -166,7 +166,7 @@ static void HWR_DrawPatchInCache(GLMipmap_t *mipmap,
|
||||
|
||||
if (pwidth <= 0 || pheight <= 0)
|
||||
return;
|
||||
|
||||
|
||||
palette = HWR_GetTexturePalette();
|
||||
|
||||
ncols = pwidth;
|
||||
@@ -216,7 +216,7 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
|
||||
|
||||
if (texture->width <= 0 || texture->height <= 0)
|
||||
return;
|
||||
|
||||
|
||||
palette = HWR_GetTexturePalette();
|
||||
|
||||
x1 = patch->originx;
|
||||
@@ -275,15 +275,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)
|
||||
{
|
||||
@@ -303,7 +303,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;
|
||||
@@ -313,7 +313,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *grtex, boolean noe
|
||||
|
||||
INT32 i;
|
||||
boolean skyspecial = false; //poor hack for Legacy large skies..
|
||||
|
||||
|
||||
RGBA_t *palette;
|
||||
palette = HWR_GetTexturePalette();
|
||||
|
||||
@@ -328,30 +328,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)
|
||||
{
|
||||
@@ -375,7 +375,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);
|
||||
@@ -383,78 +383,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;
|
||||
|
||||
//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;
|
||||
glMipmap->format = patchformat;
|
||||
|
||||
//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.
|
||||
@@ -526,10 +526,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)
|
||||
@@ -537,13 +537,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!");
|
||||
}
|
||||
|
||||
@@ -552,9 +552,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);
|
||||
@@ -563,25 +563,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;
|
||||
@@ -590,8 +590,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);
|
||||
|
||||
@@ -619,21 +619,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
|
||||
}
|
||||
@@ -641,44 +641,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...)
|
||||
@@ -688,12 +688,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);
|
||||
}
|
||||
|
||||
// -----------------+
|
||||
@@ -732,7 +732,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))
|
||||
@@ -744,14 +744,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!
|
||||
@@ -764,7 +764,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);
|
||||
@@ -781,18 +781,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)
|
||||
@@ -840,14 +840,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);
|
||||
|
||||
@@ -876,28 +876,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);
|
||||
}
|
||||
|
||||
// =================================================
|
||||
@@ -909,15 +909,15 @@ 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
|
||||
// the 16-bit version! For making comparison screenshots either use an external screenshot
|
||||
// tool or set the palette depth to 24 bits.
|
||||
RGBA_t crushed_palette[256];
|
||||
int i;
|
||||
for (i = 0; i < 256; i++)
|
||||
|
||||
for (int i = 0; i < 256; i++)
|
||||
{
|
||||
float fred = (float)(palette[i].s.red >> 3);
|
||||
float fgreen = (float)(palette[i].s.green >> 2);
|
||||
@@ -935,7 +935,7 @@ void HWR_SetPalette(RGBA_t *palette)
|
||||
}
|
||||
|
||||
// this part is responsible for keeping track of the palette OUTSIDE of a level.
|
||||
if ((!(gamestate == GS_LEVEL)) || (gamestate == GS_TITLESCREEN))
|
||||
if (gamestate != GS_LEVEL || gamestate == GS_TITLESCREEN)
|
||||
HWR_SetMapPalette();
|
||||
}
|
||||
else
|
||||
@@ -987,11 +987,9 @@ void HWR_SetMapPalette(void)
|
||||
RGBA_t *palette;
|
||||
int i;
|
||||
|
||||
if ((!(gamestate == GS_LEVEL)) || (gamestate == GS_TITLESCREEN))
|
||||
if (gamestate != GS_LEVEL || gamestate == GS_TITLESCREEN)
|
||||
{
|
||||
// outside of a level, pMasterPalette should have PLAYPAL ready for us
|
||||
//palette = pMasterPalette; // we dont have this in kart so just use pLocalPalette as before
|
||||
|
||||
// outside of a level, pLocalPalette should have PLAYPAL ready for us
|
||||
palette = pLocalPalette;
|
||||
}
|
||||
else
|
||||
@@ -1001,8 +999,10 @@ void HWR_SetMapPalette(void)
|
||||
lumpnum_t lumpnum = W_GetNumForName(GetPalette());
|
||||
size_t palsize = W_LumpLength(lumpnum);
|
||||
UINT8 *RGB_data;
|
||||
|
||||
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 = W_CacheLumpNum(lumpnum, PU_CACHE);
|
||||
// we got the RGB palette now, but we need it in RGBA format.
|
||||
for (i = 0; i < 256; i++)
|
||||
@@ -1050,7 +1050,6 @@ UINT32 HWR_CreateLightTable(UINT8 *lighttable)
|
||||
return id;
|
||||
}
|
||||
|
||||
|
||||
// get hwr lighttable id for colormap, create it if it doesn't already exist
|
||||
UINT32 HWR_GetLightTableID(extracolormap_t *colormap)
|
||||
{
|
||||
|
||||
@@ -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
|
||||
|
||||
+10
-10
@@ -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;
|
||||
|
||||
@@ -593,12 +593,12 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
|
||||
{
|
||||
RGBA_t *palette = HWR_GetTexturePalette();
|
||||
Surf.PolyColor.rgba = palette[color&0xFF].rgba;
|
||||
|
||||
|
||||
if (HWR_ShouldUsePaletteRendering())
|
||||
Surf.PolyColor.s.alpha = softwaretranstogl[strength];
|
||||
else
|
||||
Surf.PolyColor.s.alpha = (UINT8)(strength*25.5f);
|
||||
|
||||
|
||||
poly_flags |= PF_Translucent;
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
@@ -776,9 +776,9 @@ void HWR_drawAMline(const fline_t *fl, INT32 color)
|
||||
F2DCoord v1, v2;
|
||||
RGBA_t color_rgba;
|
||||
RGBA_t *palette = HWR_GetTexturePalette();
|
||||
|
||||
|
||||
color_rgba = palette[color&0xFF];
|
||||
|
||||
|
||||
v1.x = ((float)fl->a.x-(vid.width/2.0f))*(2.0f/vid.width);
|
||||
v1.y = ((float)fl->a.y-(vid.height/2.0f))*(2.0f/vid.height);
|
||||
|
||||
|
||||
+3
-11
@@ -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,7 +41,7 @@ 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;
|
||||
|
||||
// --------
|
||||
// hw_bsp.c
|
||||
@@ -63,7 +63,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);
|
||||
|
||||
@@ -81,14 +81,6 @@ void HWR_GetFadeMask(lumpnum_t fademasklumpnum);
|
||||
extern INT32 patchformat;
|
||||
extern INT32 textureformat;
|
||||
|
||||
// --------
|
||||
// hw_main.c // originally hw_drawnodes.c from HWPortal branch
|
||||
// --------
|
||||
void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, INT32 texnum, boolean noencore, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
|
||||
void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap);
|
||||
void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, polyobj_t *polysector, boolean isceiling, fixed_t fixedheight,
|
||||
INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, extracolormap_t *planecolormap);
|
||||
|
||||
// --------
|
||||
// hw_shaders.c
|
||||
// --------
|
||||
|
||||
+833
-1166
File diff suppressed because it is too large.
Load diff
+63
-53
@@ -23,6 +23,7 @@
|
||||
#include "hw_glob.h"
|
||||
#include "hw_data.h"
|
||||
#include "hw_defs.h"
|
||||
#include "hw_portal.h"
|
||||
|
||||
#include "../am_map.h"
|
||||
#include "../d_player.h"
|
||||
@@ -35,15 +36,32 @@
|
||||
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 *gl_curline;
|
||||
extern side_t *gl_sidedef;
|
||||
extern line_t *gl_linedef;
|
||||
extern sector_t *gl_frontsector;
|
||||
extern sector_t *gl_backsector;
|
||||
|
||||
enum
|
||||
{
|
||||
HWR_STENCIL_NORMAL,
|
||||
HWR_STENCIL_BEGIN,
|
||||
HWR_STENCIL_REVERSE,
|
||||
HWR_STENCIL_DEPTH,
|
||||
HWR_STENCIL_SKY
|
||||
};
|
||||
|
||||
// Performance stats
|
||||
extern ps_metric_t ps_hw_nodesorttime;
|
||||
@@ -62,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);
|
||||
@@ -81,24 +99,25 @@ UINT8 *HWR_GetScreenshot(void);
|
||||
boolean HWR_Screenshot(const char *lbmname);
|
||||
|
||||
// hw_main.c
|
||||
void HWR_RenderFrame(INT32 viewnumber, player_t *player, boolean skybox);
|
||||
void HWR_RenderPlayerView(INT32 viewnumber, player_t *player);
|
||||
void HWR_SetViewSize(void);
|
||||
void HWR_AddCommands(void);
|
||||
|
||||
void HWR_RenderPlayerView(INT32 viewnumber, player_t *player);
|
||||
void HWR_RenderViewpoint(gl_portal_t *rootportal, const float fpov, player_t *player, int stencil_level, boolean allow_portals);
|
||||
|
||||
void HWR_SetTransform(float fpov, player_t *player);
|
||||
void HWR_ClearClipper(void);
|
||||
void HWR_SetStencilState(int state, int level);
|
||||
|
||||
boolean HWR_UseShader(void);
|
||||
boolean HWR_ShouldUsePaletteRendering(void);
|
||||
boolean HWR_PalRenderFlashpal(void);
|
||||
void HWR_TogglePaletteRendering(void);
|
||||
|
||||
// My original intention was to split hw_main.c
|
||||
// into files like hw_bsp.c, hw_sprites.c...
|
||||
|
||||
// hw_main.c: Lighting and fog
|
||||
void HWR_Lighting(FSurfaceInfo *Surface, INT32 light_level, extracolormap_t *colormap);
|
||||
UINT8 HWR_FogBlockAlpha(INT32 light, extracolormap_t *colormap); // Let's see if this can work
|
||||
|
||||
FBITFIELD HWR_TranstableToAlpha(INT32 transtablenum, FSurfaceInfo *pSurf);
|
||||
|
||||
@@ -106,7 +125,6 @@ FBITFIELD HWR_TranstableToAlpha(INT32 transtablenum, FSurfaceInfo *pSurf);
|
||||
INT32 HWR_GetTextureUsed(void);
|
||||
|
||||
// hw_main.c: Post-rendering
|
||||
void HWR_DoPostProcessor(player_t *player);
|
||||
void HWR_StartScreenWipe(void);
|
||||
void HWR_EndScreenWipe(void);
|
||||
void HWR_DrawIntermissionBG(void);
|
||||
@@ -115,63 +133,55 @@ void HWR_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT
|
||||
void HWR_MakeScreenFinalTexture(void);
|
||||
void HWR_DrawScreenFinalTexture(INT32 width, INT32 height);
|
||||
|
||||
// hw_main.c: Planes
|
||||
//void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap);
|
||||
void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap);
|
||||
|
||||
void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling, fixed_t fixedheight, FBITFIELD blendmode, UINT8 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap);
|
||||
void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, polyobj_t *polysector, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, extracolormap_t *planecolormap);
|
||||
|
||||
// hw_main.c: Segs
|
||||
void HWR_ProcessSeg(void); // Sort of like GLWall::Process in GZDoom
|
||||
void HWR_RenderWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
|
||||
void HWR_ProjectWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, FBITFIELD blendmode, INT32 lightlevel, extracolormap_t *wallcolormap);
|
||||
void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo * pSurf, INT32 texnum, boolean noencore, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
|
||||
// moved HWR_SplitWall to hw_main.c
|
||||
void HWR_DrawSkyWall(FOutVector *wallVerts, FSurfaceInfo *Surf);
|
||||
void HWR_DrawSkyBackground(float fpov);
|
||||
|
||||
// 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);
|
||||
|
||||
void HWR_SetShaderState(void);
|
||||
|
||||
// Console variables
|
||||
extern consvar_t cv_grshaders;
|
||||
extern CV_PossibleValue_t glanisotropicmode_cons_t[];
|
||||
|
||||
extern consvar_t cv_glscreentextures;
|
||||
#ifdef USE_FBO_OGL
|
||||
extern consvar_t cv_grframebuffer;
|
||||
extern consvar_t cv_glframebuffer;
|
||||
#endif
|
||||
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_lightdither;
|
||||
extern consvar_t cv_grscreentextures;
|
||||
extern consvar_t cv_grportals;
|
||||
extern consvar_t cv_nostencil;
|
||||
extern consvar_t cv_secbright;
|
||||
|
||||
extern CV_PossibleValue_t granisotropicmode_cons_t[];
|
||||
extern consvar_t cv_glmdls;
|
||||
extern consvar_t cv_glfallbackplayermodel;
|
||||
|
||||
extern consvar_t cv_glspritebillboarding;
|
||||
extern consvar_t cv_glshearing;
|
||||
|
||||
extern consvar_t cv_glfakecontrast;
|
||||
extern consvar_t cv_glslopecontrast;
|
||||
|
||||
extern consvar_t cv_glshaders;
|
||||
|
||||
extern consvar_t cv_gllightdither;
|
||||
extern consvar_t cv_glsecbright;
|
||||
|
||||
extern consvar_t cv_glfiltermode;
|
||||
extern consvar_t cv_glanisotropicmode;
|
||||
|
||||
extern consvar_t cv_glsolvetjoin;
|
||||
|
||||
extern consvar_t cv_glbatching;
|
||||
|
||||
extern consvar_t cv_glrenderdistance;
|
||||
|
||||
extern consvar_t cv_glhorizonlines;
|
||||
extern consvar_t cv_glportals;
|
||||
|
||||
extern consvar_t cv_glfovchange;
|
||||
|
||||
extern consvar_t cv_glpaletterendering;
|
||||
extern consvar_t cv_glpalettedepth;
|
||||
extern consvar_t cv_glflashpal;
|
||||
|
||||
#endif
|
||||
+83
-83
@@ -147,7 +147,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;
|
||||
@@ -201,7 +201,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
|
||||
@@ -242,7 +242,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;
|
||||
@@ -282,7 +282,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
|
||||
@@ -322,7 +322,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)
|
||||
{
|
||||
@@ -364,43 +364,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())
|
||||
@@ -408,7 +408,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--)
|
||||
{
|
||||
@@ -417,8 +417,8 @@ static void md2_loadTexture(md2_t *model)
|
||||
}
|
||||
}
|
||||
}
|
||||
HWD.pfnSetTexture(grpatch->mipmap);
|
||||
HWR_UnlockCachedPatch(grpatch);
|
||||
HWD.pfnSetTexture(glpatch->mipmap);
|
||||
HWR_UnlockCachedPatch(glpatch);
|
||||
}
|
||||
|
||||
// -----------------+
|
||||
@@ -426,49 +426,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);
|
||||
}
|
||||
@@ -489,7 +489,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;
|
||||
@@ -498,7 +498,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;
|
||||
@@ -507,7 +507,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;
|
||||
@@ -680,7 +680,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;
|
||||
@@ -696,24 +696,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)
|
||||
@@ -1164,7 +1164,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);
|
||||
}
|
||||
@@ -1244,22 +1244,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"
|
||||
@@ -1284,7 +1284,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
|
||||
{
|
||||
@@ -1313,7 +1313,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)
|
||||
@@ -1478,8 +1478,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);
|
||||
|
||||
|
||||
@@ -0,0 +1,227 @@
|
||||
// SONIC ROBO BLAST 2 KART
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2024 by Kart Krew.
|
||||
// Copyright (C) 2020 by Sonic Team Junior.
|
||||
// Copyright (C) 2000 by DooM Legacy Team.
|
||||
// Copyright (C) 1996 by id Software, Inc.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
// See the 'LICENSE' file for more details.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file hw_portal.c
|
||||
/// \brief OpenGL renderer portals.
|
||||
|
||||
// ==========================================================================
|
||||
// Visual portals (attr. Hannu Hanhi)
|
||||
// ==========================================================================
|
||||
|
||||
#ifdef HWRENDER
|
||||
|
||||
#include "../r_portal.h"
|
||||
|
||||
#include "../z_zone.h"
|
||||
|
||||
#include "hw_clip.h"
|
||||
#include "hw_drv.h"
|
||||
#include "hw_defs.h"
|
||||
#include "hw_main.h"
|
||||
#include "hw_portal.h"
|
||||
|
||||
SINT8 gl_portal_state = GLPORTAL_OFF;
|
||||
|
||||
gl_portallist_t *currentportallist;
|
||||
|
||||
// clip the area outside the portal destination window
|
||||
void HWR_PortalClipping(gl_portal_t *portal)
|
||||
{
|
||||
gld_clipper_SafeAddClipRange(portal->angle1, portal->angle2);
|
||||
}
|
||||
|
||||
static gl_portal_t* HWR_Portal_Add (seg_t *seg)
|
||||
{
|
||||
gl_portal_t *portal = Z_Malloc(sizeof(gl_portal_t), PU_STATIC, NULL);
|
||||
|
||||
// Linked list.
|
||||
if (!currentportallist->base)
|
||||
{
|
||||
currentportallist->base = portal;
|
||||
currentportallist->cap = portal;
|
||||
}
|
||||
else
|
||||
{
|
||||
currentportallist->cap->next = portal;
|
||||
currentportallist->cap = portal;
|
||||
}
|
||||
portal->next = NULL;
|
||||
|
||||
portal->seg = seg;
|
||||
|
||||
return portal;
|
||||
}
|
||||
|
||||
void HWR_FreePortalList(gl_portallist_t freelist)
|
||||
{
|
||||
portalcullsector = NULL;
|
||||
|
||||
// free memory from portal list allocated by calls to Add2Lines
|
||||
gl_portal_t *gl_portal_temp = freelist.base;
|
||||
while (gl_portal_temp)
|
||||
{
|
||||
gl_portal_t *nextportal = gl_portal_temp->next;
|
||||
Z_Free(gl_portal_temp);
|
||||
gl_portal_temp = nextportal;
|
||||
}
|
||||
}
|
||||
|
||||
void HWR_Portal_Add2Lines(const INT32 line1, const INT32 line2, seg_t *seg)
|
||||
{
|
||||
gl_portal_t *portal = HWR_Portal_Add(seg);
|
||||
|
||||
// Offset the portal view by the linedef centers
|
||||
line_t* start = &lines[line1];
|
||||
line_t* dest = &lines[line2];
|
||||
|
||||
angle_t dangle = R_PointToAngle2(0, 0, dest->dx, dest->dy) - R_PointToAngle2(start->dx, start->dy, 0, 0);
|
||||
|
||||
fixed_t disttopoint;
|
||||
angle_t angtopoint;
|
||||
|
||||
vertex_t dest_c, start_c;
|
||||
|
||||
// looking glass center
|
||||
start_c.x = start->v1->x/2 + start->v2->x/2;
|
||||
start_c.y = start->v1->y/2 + start->v2->y/2;
|
||||
|
||||
// other side center
|
||||
dest_c.x = dest->v1->x/2 + dest->v2->x/2;
|
||||
dest_c.y = dest->v1->y/2 + dest->v2->y/2;
|
||||
|
||||
disttopoint = R_PointToDist2(start_c.x, start_c.y, viewx, viewy);
|
||||
angtopoint = R_PointToAngle2(start_c.x, start_c.y, viewx, viewy);
|
||||
angtopoint += dangle;
|
||||
|
||||
portal->viewx = dest_c.x + FixedMul(FINECOSINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
|
||||
portal->viewy = dest_c.y + FixedMul(FINESINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
|
||||
portal->viewz = viewz + dest->frontsector->floorheight - start->frontsector->floorheight;
|
||||
portal->viewangle = viewangle + dangle;
|
||||
|
||||
portal->angle1 = R_PointToAngle64(seg->v1->x, seg->v1->y) + dangle;
|
||||
portal->angle2 = R_PointToAngle64(seg->v2->x, seg->v2->y) + dangle;
|
||||
|
||||
portal->clipline = line2;
|
||||
}
|
||||
|
||||
void HWR_PortalFrame(gl_portal_t* portal)
|
||||
{
|
||||
viewx = portal->viewx;
|
||||
viewy = portal->viewy;
|
||||
viewz = portal->viewz;
|
||||
|
||||
viewangle = portal->viewangle;
|
||||
//viewsin = FINESINE(viewangle>>ANGLETOFINESHIFT);
|
||||
//viewcos = FINECOSINE(viewangle>>ANGLETOFINESHIFT);
|
||||
|
||||
if (portal->clipline != -1)
|
||||
{
|
||||
portalclipline = &lines[portal->clipline];
|
||||
portalcullsector = portalclipline->frontsector;
|
||||
viewsector = portalclipline->frontsector;
|
||||
}
|
||||
else
|
||||
{
|
||||
portalclipline = NULL;
|
||||
portalcullsector = NULL;
|
||||
viewsector = R_PointInSubsector(viewx, viewy)->sector;
|
||||
}
|
||||
}
|
||||
|
||||
// Renders a portal segment.
|
||||
static 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);
|
||||
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
|
||||
// similarly as in the linkdraw hack in HWR_DrawSprites
|
||||
HWD.pfnSetBlend(PF_Translucent|PF_Occlude|PF_Masked);
|
||||
}
|
||||
|
||||
// Renders a single portal from the current viewpoint.
|
||||
void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float fpov, player_t *player, int stencil_level)
|
||||
{
|
||||
// draw portal seg to stencil buffer with increment
|
||||
HWR_SetTransform(fpov, player);
|
||||
HWR_ClearClipper();
|
||||
|
||||
HWR_SetStencilState(HWR_STENCIL_BEGIN, stencil_level);
|
||||
HWR_RenderPortalSeg(portal, GLPORTAL_STENCIL);
|
||||
|
||||
// go to portal frame lmao
|
||||
HWR_PortalFrame(portal);
|
||||
// call HWR_RenderViewpoint
|
||||
HWR_RenderViewpoint(portal, fpov, player, stencil_level + 1, true);
|
||||
// return to current frame
|
||||
if (rootportal)
|
||||
HWR_PortalFrame(rootportal);
|
||||
else // current frame is not a portal frame but the main view!
|
||||
{
|
||||
R_SetupFrame(player, false);
|
||||
portalclipline = NULL;
|
||||
}
|
||||
|
||||
// remove portal seg from stencil buffer
|
||||
HWR_SetTransform(fpov, player);
|
||||
HWR_ClearClipper();
|
||||
|
||||
HWR_SetStencilState(HWR_STENCIL_REVERSE, stencil_level);
|
||||
HWR_RenderPortalSeg(portal, GLPORTAL_STENCIL);
|
||||
|
||||
// draw portal seg to depth buffer
|
||||
HWR_ClearClipper();
|
||||
HWR_SetStencilState(HWR_STENCIL_DEPTH, stencil_level);
|
||||
HWR_RenderPortalSeg(portal, GLPORTAL_DEPTH);
|
||||
}
|
||||
|
||||
// returns true if the point is on the correct (viewable) side of the
|
||||
// portal destination line
|
||||
boolean HWR_PortalCheckPointSide(fixed_t x, fixed_t y)
|
||||
{
|
||||
// we are checking if the point is on the viewable side of the portal exit.
|
||||
// being exactly on the portal exit line is not enough to pass the test.
|
||||
// P_PointOnLineSide could behave differently from this expectation on this case,
|
||||
// so first check if the point is precisely on the line, and then if not, check the side.
|
||||
|
||||
vertex_t closest_point;
|
||||
P_ClosestPointOnLine(x, y, portalclipline, &closest_point);
|
||||
if (closest_point.x != x || closest_point.y != y)
|
||||
{
|
||||
if (P_PointOnLineSide(x, y, portalclipline) != 1)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
boolean HWR_PortalCheckBBox(const fixed_t *bspcoord)
|
||||
{
|
||||
if (!portalclipline)
|
||||
return true;
|
||||
|
||||
if (HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXTOP]) ||
|
||||
HWR_PortalCheckPointSide(bspcoord[BOXLEFT], bspcoord[BOXBOTTOM]) ||
|
||||
HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXTOP]) ||
|
||||
HWR_PortalCheckPointSide(bspcoord[BOXRIGHT], bspcoord[BOXBOTTOM]))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
// we did not find any reason to pass the check, so return failure
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,81 @@
|
||||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
// Copyright (C) 1999-2018 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
// See the 'LICENSE' file for more details.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file hw_portal.h
|
||||
/// \brief OpenGL renderer portal struct, functions, linked list extern.
|
||||
|
||||
#ifndef __HW_PORTAL__
|
||||
#define __HW_PORTAL__
|
||||
|
||||
#ifdef HWRENDER
|
||||
|
||||
#include "../doomstat.h"
|
||||
#include "../r_data.h"
|
||||
#include "../r_bsp.h"
|
||||
|
||||
/** Portal structure.
|
||||
*/
|
||||
enum
|
||||
{
|
||||
GLPORTAL_OFF,
|
||||
GLPORTAL_SEARCH,
|
||||
GLPORTAL_STENCIL,
|
||||
GLPORTAL_DEPTH,
|
||||
GLPORTAL_INSIDE,
|
||||
};
|
||||
|
||||
typedef struct gl_portal_s
|
||||
{
|
||||
struct gl_portal_s *next;
|
||||
|
||||
// Viewport.
|
||||
fixed_t viewx;
|
||||
fixed_t viewy;
|
||||
fixed_t viewz;
|
||||
angle_t viewangle;
|
||||
|
||||
seg_t *seg; // seg that is used for drawing to the stencil buffer
|
||||
INT32 clipline; // Optional clipline for line-based portals
|
||||
|
||||
// angles for the left and right edges of the portal
|
||||
// relative to the viewpoint
|
||||
angle_t angle1;
|
||||
angle_t angle2;
|
||||
} gl_portal_t;
|
||||
|
||||
typedef struct gl_portallist_s
|
||||
{
|
||||
gl_portal_t *base;
|
||||
gl_portal_t *cap;
|
||||
} gl_portallist_t;
|
||||
|
||||
extern SINT8 gl_portal_state;
|
||||
|
||||
// new thing
|
||||
extern gl_portallist_t *currentportallist;
|
||||
|
||||
static inline void HWR_SetPortalState (SINT8 state)
|
||||
{
|
||||
gl_portal_state = state;
|
||||
}
|
||||
|
||||
// Adds an entry to the clipper for portal rendering
|
||||
void HWR_PortalClipping(gl_portal_t *portal);
|
||||
|
||||
void HWR_Portal_Add2Lines(const INT32 line1, const INT32 line2, seg_t *seg);
|
||||
void HWR_PortalFrame(gl_portal_t* portal);
|
||||
void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float fpov, player_t *player, int stencil_level);
|
||||
void HWR_FreePortalList(gl_portallist_t portallist);
|
||||
|
||||
boolean HWR_PortalCheckPointSide(fixed_t x, fixed_t y);
|
||||
boolean HWR_PortalCheckBBox(const fixed_t *bspcoord);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
@@ -25,7 +25,7 @@ static struct {
|
||||
const char *vertex;
|
||||
const char *fragment;
|
||||
} const gl_shadersources[] = {
|
||||
|
||||
|
||||
// Floor shader
|
||||
{GLSL_DEFAULT_VERTEX_SHADER, GLSL_FLOOR_FRAGMENT_SHADER},
|
||||
|
||||
@@ -52,7 +52,7 @@ static struct {
|
||||
|
||||
// Palette postprocess shader
|
||||
{GLSL_DEFAULT_VERTEX_SHADER, GLSL_PALETTE_POSTPROCESS_FRAGMENT_SHADER},
|
||||
|
||||
|
||||
// UI colormap fade shader
|
||||
{GLSL_DEFAULT_VERTEX_SHADER, GLSL_UI_COLORMAP_FADE_FRAGMENT_SHADER},
|
||||
|
||||
@@ -279,11 +279,11 @@ 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)
|
||||
if (cv_gllightdither.value)
|
||||
ADD_TO_LEN(LIGHT_DITHERING_DEFINE)
|
||||
|
||||
#undef ADD_TO_LEN
|
||||
@@ -324,10 +324,10 @@ 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)
|
||||
if (cv_gllightdither.value)
|
||||
WRITE_DEFINE(LIGHT_DITHERING_DEFINE)
|
||||
|
||||
#undef WRITE_DEFINE
|
||||
@@ -410,7 +410,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;
|
||||
@@ -565,7 +565,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);
|
||||
|
||||
@@ -171,7 +171,7 @@
|
||||
"gl_FragColor = final_color;\n" \
|
||||
"}\n" \
|
||||
"#endif\0"
|
||||
|
||||
|
||||
#define GLSL_SOFTWARE_FRAGMENT_SHADER_NOPAL \
|
||||
"uniform sampler2D tex;\n" \
|
||||
"uniform vec4 poly_color;\n" \
|
||||
@@ -210,7 +210,7 @@
|
||||
#define GLSL_WALL_FRAGMENT_SHADER \
|
||||
GLSL_WALL_FUDGES \
|
||||
GLSL_SOFTWARE_FRAGMENT_SHADER
|
||||
|
||||
|
||||
#define GLSL_SHADOW_FRAGMENT_SHADER \
|
||||
GLSL_FLOOR_FUDGES \
|
||||
GLSL_SOFTWARE_FRAGMENT_SHADER_NOPAL
|
||||
|
||||
@@ -2357,7 +2357,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
|
||||
|
||||
+38
-47
@@ -2779,16 +2779,9 @@ void K_SpawnKartExplosion(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32
|
||||
TVector v;
|
||||
TVector *res;
|
||||
fixed_t finalx, finaly, finalz, dist;
|
||||
//mobj_t hoopcenter;
|
||||
angle_t degrees, fa, closestangle;
|
||||
fixed_t mobjx, mobjy, mobjz;
|
||||
|
||||
//hoopcenter.x = x;
|
||||
//hoopcenter.y = y;
|
||||
//hoopcenter.z = z;
|
||||
|
||||
//hoopcenter.z = z - mobjinfo[type].height/2;
|
||||
|
||||
degrees = FINEANGLES/number;
|
||||
|
||||
closestangle = 0;
|
||||
@@ -3174,17 +3167,19 @@ static void K_SpawnAIZDust(player_t *player)
|
||||
|
||||
static void K_StretchPlayerGravity(player_t *p)
|
||||
{
|
||||
fixed_t mos = FRACUNIT;
|
||||
fixed_t rzs = abs(p->mo->momz);
|
||||
fixed_t zspd = abs(rzs/mos);
|
||||
I_Assert(p != NULL);
|
||||
I_Assert(p->mo != NULL);
|
||||
I_Assert(!P_MobjWasRemoved(p->mo));
|
||||
|
||||
fixed_t mos = FRACUNIT;
|
||||
fixed_t rzs = abs(p->mo->momz);
|
||||
fixed_t zspd = abs(rzs/mos);
|
||||
fixed_t stretchScaleFactor = 0;
|
||||
fixed_t rzsDiv = 1;
|
||||
fixed_t slamDiv = 1;
|
||||
|
||||
fixed_t dxs = p->mo->realxscale;
|
||||
fixed_t dys = p->mo->realyscale;
|
||||
//boolean gravSlamming = false;
|
||||
//fixed_t impactFactor = 0;
|
||||
fixed_t dxs = p->mo->realxscale;
|
||||
fixed_t dys = p->mo->realyscale;
|
||||
stretchScaleFactor = FixedDiv(FRACUNIT*60, cv_gravstretch.value);
|
||||
|
||||
if (stretchScaleFactor > 17476977)
|
||||
@@ -3194,10 +3189,6 @@ static void K_StretchPlayerGravity(player_t *p)
|
||||
|
||||
//CONS_Printf(M_GetText("div: %d, scale factor: %d, stretch value: %d\n"), rzsDiv, stretchScaleFactor, cv_gravstretch.value);
|
||||
|
||||
I_Assert(p != NULL);
|
||||
I_Assert(p->mo != NULL);
|
||||
I_Assert(!P_MobjWasRemoved(p->mo));
|
||||
|
||||
if (p->mo->slamsoundtimer)
|
||||
p->mo->slamsoundtimer--;
|
||||
|
||||
@@ -3207,40 +3198,40 @@ static void K_StretchPlayerGravity(player_t *p)
|
||||
p->mo->slamsoundtimer = TICRATE;
|
||||
}
|
||||
|
||||
if (!P_IsObjectOnGround(p->mo))
|
||||
{
|
||||
if (zspd != 0)
|
||||
{
|
||||
if (((dxs-(rzsDiv))) > (dxs/5))
|
||||
{
|
||||
p->mo->spritexscale = ((dxs-(rzsDiv)));
|
||||
p->mo->stretchslam = rzs;
|
||||
}
|
||||
else
|
||||
p->mo->spritexscale = (dxs/5);
|
||||
if (!P_IsObjectOnGround(p->mo))
|
||||
{
|
||||
if (zspd != 0)
|
||||
{
|
||||
if (((dxs-(rzsDiv))) > (dxs/5))
|
||||
{
|
||||
p->mo->spritexscale = ((dxs-(rzsDiv)));
|
||||
p->mo->stretchslam = rzs;
|
||||
}
|
||||
else
|
||||
p->mo->spritexscale = (dxs/5);
|
||||
|
||||
p->mo->spriteyscale = (dys+((rzsDiv*2)/3));
|
||||
}
|
||||
else
|
||||
{
|
||||
p->mo->spritexscale = (dxs);
|
||||
p->mo->spriteyscale = (dys);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
p->mo->spriteyscale = (dys+((rzsDiv*2)/3));
|
||||
}
|
||||
else
|
||||
{
|
||||
p->mo->spritexscale = (dxs);
|
||||
p->mo->spriteyscale = (dys);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (stretchScaleFactor > 17476977)
|
||||
slamDiv = 0;
|
||||
else
|
||||
slamDiv = FixedDiv(p->mo->stretchslam, stretchScaleFactor);
|
||||
|
||||
p->mo->spritexscale = (dxs+(((slamDiv*2)/3)*2));
|
||||
p->mo->spriteyscale = (dys-(slamDiv));
|
||||
if (p->mo->stretchslam > 0)
|
||||
p->mo->stretchslam -= (4*mos);
|
||||
else
|
||||
p->mo->stretchslam = 0;
|
||||
}
|
||||
p->mo->spritexscale = (dxs+(((slamDiv*2)/3)*2));
|
||||
p->mo->spriteyscale = (dys-(slamDiv));
|
||||
if (p->mo->stretchslam > 0)
|
||||
p->mo->stretchslam -= (4*mos);
|
||||
else
|
||||
p->mo->stretchslam = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void K_QuiteSaltyHop(player_t *p)
|
||||
@@ -9020,7 +9011,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
|
||||
|
||||
@@ -111,6 +111,8 @@ static void A_Lua(mobj_t *actor)
|
||||
lua_pushinteger(gL, var2);
|
||||
LUA_Call(gL, 3, 0, 1);
|
||||
|
||||
lua_pop(gL, 1); // pop error handler
|
||||
|
||||
if (found)
|
||||
{
|
||||
--superstack;
|
||||
|
||||
@@ -37,8 +37,9 @@
|
||||
/*
|
||||
* Sacrifice very little compression quality in favour of compression speed.
|
||||
* This gives almost the same compression as the default code, and is
|
||||
* (very roughly) 15% faster. This is the preferred mode of operation.
|
||||
* (very roughly) 15% faster. This is the preferable mode of operation.
|
||||
*/
|
||||
|
||||
#ifndef VERY_FAST
|
||||
# define VERY_FAST 1
|
||||
#endif
|
||||
@@ -47,7 +48,7 @@
|
||||
* Sacrifice some more compression quality in favour of compression speed.
|
||||
* (roughly 1-2% worse compression for large blocks and
|
||||
* 9-10% for small, redundant, blocks and >>20% better speed in both cases)
|
||||
* In short: when in need for speed, enable this for binary data,
|
||||
* In INT16: when in need for speed, enable this for binary data,
|
||||
* possibly disable this for text data.
|
||||
*/
|
||||
#ifndef ULTRA_FAST
|
||||
@@ -65,10 +66,21 @@
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Use string functions to copy memory.
|
||||
* this is usually a loss, even with glibc's optimized memcpy
|
||||
*/
|
||||
#ifndef USE_MEMCPY
|
||||
#ifdef _MSC_VER
|
||||
# define USE_MEMCPY 0
|
||||
#else
|
||||
# define USE_MEMCPY 1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* You may choose to pre-set the hash table (might be faster on some
|
||||
* modern cpus and large (>>64k) blocks, and also makes compression
|
||||
* deterministic/repeatable when the configuration otherwise is the same).
|
||||
* modern cpus and large (>>64k) blocks)
|
||||
*/
|
||||
#ifndef INIT_HTAB
|
||||
# define INIT_HTAB 1
|
||||
@@ -76,15 +88,15 @@
|
||||
|
||||
/*
|
||||
* Avoid assigning values to errno variable? for some embedding purposes
|
||||
* (linux kernel for example), this is necessary. NOTE: this breaks
|
||||
* the documentation in lzf.h. Avoiding errno has no speed impact.
|
||||
* (linux kernel for example), this is neccessary. NOTE: this breaks
|
||||
* the documentation in lzf.h.
|
||||
*/
|
||||
#ifndef AVOID_ERRNO
|
||||
# define AVOID_ERRNO 0
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Whether to pass the LZF_STATE variable as argument, or allocate it
|
||||
* Wether to pass the LZF_STATE variable as argument, or allocate it
|
||||
* on the stack. For small-stack environments, define this to 1.
|
||||
* NOTE: this breaks the prototype in lzf.h.
|
||||
*/
|
||||
@@ -93,108 +105,50 @@
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Whether to add extra checks for input validity in lzf_decompress
|
||||
* Wether to add extra checks for input validity in lzf_decompress
|
||||
* and return EINVAL if the input stream has been corrupted. This
|
||||
* only shields against overflowing the input buffer and will not
|
||||
* detect most corrupted streams.
|
||||
* This check is not normally noticeable on modern hardware
|
||||
* This check is not normally noticable on modern hardware
|
||||
* (<1% slowdown), but might slow down older cpus considerably.
|
||||
*/
|
||||
#ifndef CHECK_INPUT
|
||||
# define CHECK_INPUT 1
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Whether the target CPU has a slow multiplication. This affects
|
||||
* the default hash function for the compressor, and enables a slightly
|
||||
* worse hash function that needs only shifts.
|
||||
*/
|
||||
#ifndef MULTIPLICATION_IS_SLOW
|
||||
# define MULTIPLICATION_IS_SLOW 0
|
||||
#endif
|
||||
|
||||
/*
|
||||
* If defined, then this data type will be used for storing offsets.
|
||||
* This can be useful if you want to use a huge hashtable, want to
|
||||
* conserve memory, or both, and your data fits into e.g. 64kb.
|
||||
* If instead you want to compress data > 4GB, then it's better to
|
||||
* to "#define LZF_USE_OFFSETS 0" instead.
|
||||
*/
|
||||
/*#define LZF_HSLOT unsigned short*/
|
||||
|
||||
/*
|
||||
* Whether to store pointers or offsets inside the hash table. On
|
||||
* 64 bit architetcures, pointers take up twice as much space,
|
||||
* and might also be slower. Default is to autodetect.
|
||||
*/
|
||||
/*#define LZF_USE_OFFSETS autodetect */
|
||||
|
||||
/*
|
||||
* Whether to optimise code for size, at the expense of speed. Use
|
||||
* this when you are extremely tight on memory, perhaps in combination
|
||||
* with AVOID_ERRNO 1 and CHECK_INPUT 0.
|
||||
*/
|
||||
#ifndef OPTIMISE_SIZE
|
||||
# ifdef __OPTIMIZE_SIZE__
|
||||
# define OPTIMISE_SIZE 1
|
||||
# else
|
||||
# define OPTIMISE_SIZE 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/*****************************************************************************/
|
||||
/* nothing should be changed below */
|
||||
|
||||
# include <string.h>
|
||||
# include <limits.h>
|
||||
|
||||
#if ULTRA_FAST
|
||||
# undef VERY_FAST
|
||||
#endif
|
||||
|
||||
#ifndef LZF_USE_OFFSETS
|
||||
# ifdef _WIN32
|
||||
# define LZF_USE_OFFSETS defined(_M_X64)
|
||||
# else
|
||||
# include <stdint.h>
|
||||
# define LZF_USE_OFFSETS (UINTPTR_MAX > 0xffffffffU)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
typedef unsigned char u8;
|
||||
|
||||
#ifdef LZF_HSLOT
|
||||
# define LZF_HSLOT_BIAS ((const u8 *)in_data)
|
||||
#else
|
||||
# ifdef LZF_USE_OFFSETS
|
||||
# define LZF_HSLOT_BIAS ((const u8 *)in_data)
|
||||
typedef unsigned int LZF_HSLOT;
|
||||
typedef const u8 *LZF_STATE[1 << (HLOG)];
|
||||
|
||||
#if !STRICT_ALIGN
|
||||
/* for unaligned accesses we need a 16 bit datatype. */
|
||||
# include <limits.h>
|
||||
# if USHRT_MAX == 65535
|
||||
typedef unsigned short u16;
|
||||
# elif UINT_MAX == 65535
|
||||
typedef unsigned int u16;
|
||||
# else
|
||||
# define LZF_HSLOT_BIAS 0
|
||||
typedef const u8 *LZF_HSLOT;
|
||||
# undef STRICT_ALIGN
|
||||
# define STRICT_ALIGN 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if USHRT_MAX == 65535
|
||||
typedef unsigned short u16;
|
||||
#elif UINT_MAX == 65535
|
||||
typedef unsigned int u16;
|
||||
#else
|
||||
# undef STRICT_ALIGN
|
||||
# define STRICT_ALIGN 1
|
||||
#if ULTRA_FAST
|
||||
# if defined(VERY_FAST)
|
||||
# undef VERY_FAST
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#define LZF_MAX_LIT (1 << 5)
|
||||
#define LZF_MAX_OFF (1 << 13)
|
||||
#define LZF_MAX_REF ((1 << 8) + (1 << 3))
|
||||
|
||||
typedef LZF_HSLOT LZF_STATE[1 << (HLOG)];
|
||||
|
||||
typedef struct
|
||||
{
|
||||
const u8 *first [1 << (6+8)]; /* most recent occurance of a match */
|
||||
u16 prev [LZF_MAX_OFF]; /* how many bytes to go backwards for the next match */
|
||||
} LZF_STATE_BEST[1];
|
||||
#if USE_MEMCPY || INIT_HTAB
|
||||
# ifdef __cplusplus
|
||||
# include <cstring>
|
||||
# else
|
||||
# include <string.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -210,31 +164,14 @@ typedef struct
|
||||
# define SET_ERRNO(n) errno = (n)
|
||||
#endif
|
||||
|
||||
#ifndef USE_REP_MOVSB
|
||||
#if (defined (__i386) || defined (__amd64)) && __GNUC__ >= 3
|
||||
#define USE_REP_MOVSB 1
|
||||
#else
|
||||
#define USE_REP_MOVSB 0 // Default to 0 if not defined elsewhere
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if USE_REP_MOVSB /* small win on amd, big loss on intel */
|
||||
#if (defined (__i386) || defined (__amd64)) && __GNUC__ >= 3
|
||||
# define lzf_movsb(dst, src, len) \
|
||||
asm ("rep movsb" \
|
||||
: "=D" (dst), "=S" (src), "=c" (len) \
|
||||
: "0" (dst), "1" (src), "2" (len));
|
||||
#endif
|
||||
#endif
|
||||
|
||||
size_t
|
||||
lzf_decompress (const void *const in_data, size_t in_len,
|
||||
void *out_data, size_t out_len)
|
||||
void *out_data, size_t out_len)
|
||||
{
|
||||
u8 const *ip = (const u8 *)in_data;
|
||||
u8 *op = (u8 *)out_data;
|
||||
u8 *op = (u8 *)out_data;
|
||||
u8 const *const in_end = ip + in_len;
|
||||
u8 *const out_end = op + out_len;
|
||||
u8 *const out_end = op + out_len;
|
||||
|
||||
do
|
||||
{
|
||||
@@ -258,23 +195,14 @@ lzf_decompress (const void *const in_data, size_t in_len,
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef lzf_movsb
|
||||
lzf_movsb (op, ip, ctrl);
|
||||
#elif OPTIMISE_SIZE
|
||||
while (ctrl--)
|
||||
*op++ = *ip++;
|
||||
#if USE_MEMCPY
|
||||
M_Memcpy (op, ip, ctrl);
|
||||
op += ctrl;
|
||||
ip += ctrl;
|
||||
#else
|
||||
switch (ctrl)
|
||||
{
|
||||
case 32: *op++ = *ip++; case 31: *op++ = *ip++; case 30: *op++ = *ip++; case 29: *op++ = *ip++;
|
||||
case 28: *op++ = *ip++; case 27: *op++ = *ip++; case 26: *op++ = *ip++; case 25: *op++ = *ip++;
|
||||
case 24: *op++ = *ip++; case 23: *op++ = *ip++; case 22: *op++ = *ip++; case 21: *op++ = *ip++;
|
||||
case 20: *op++ = *ip++; case 19: *op++ = *ip++; case 18: *op++ = *ip++; case 17: *op++ = *ip++;
|
||||
case 16: *op++ = *ip++; case 15: *op++ = *ip++; case 14: *op++ = *ip++; case 13: *op++ = *ip++;
|
||||
case 12: *op++ = *ip++; case 11: *op++ = *ip++; case 10: *op++ = *ip++; case 9: *op++ = *ip++;
|
||||
case 8: *op++ = *ip++; case 7: *op++ = *ip++; case 6: *op++ = *ip++; case 5: *op++ = *ip++;
|
||||
case 4: *op++ = *ip++; case 3: *op++ = *ip++; case 2: *op++ = *ip++; case 1: *op++ = *ip++;
|
||||
}
|
||||
do
|
||||
*op++ = *ip++;
|
||||
while (--ctrl);
|
||||
#endif
|
||||
}
|
||||
else /* back reference */
|
||||
@@ -316,49 +244,12 @@ lzf_decompress (const void *const in_data, size_t in_len,
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef lzf_movsb
|
||||
len += 2;
|
||||
lzf_movsb (op, ref, len);
|
||||
#elif OPTIMISE_SIZE
|
||||
len += 2;
|
||||
*op++ = *ref++;
|
||||
*op++ = *ref++;
|
||||
|
||||
do
|
||||
*op++ = *ref++;
|
||||
while (--len);
|
||||
#else
|
||||
switch (len)
|
||||
{
|
||||
default:
|
||||
len += 2;
|
||||
|
||||
if (op >= ref + len)
|
||||
{
|
||||
/* disjunct areas */
|
||||
memcpy (op, ref, len);
|
||||
op += len;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* overlapping, use octet by octet copying */
|
||||
do
|
||||
*op++ = *ref++;
|
||||
while (--len);
|
||||
}
|
||||
break;
|
||||
|
||||
case 9: *op++ = *ref++;
|
||||
case 8: *op++ = *ref++;
|
||||
case 7: *op++ = *ref++;
|
||||
case 6: *op++ = *ref++;
|
||||
case 5: *op++ = *ref++;
|
||||
case 4: *op++ = *ref++;
|
||||
case 3: *op++ = *ref++;
|
||||
case 2: *op++ = *ref++;
|
||||
case 1: *op++ = *ref++;
|
||||
case 0: *op++ = *ref++; /* two octets more */
|
||||
*op++ = *ref++;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
while (ip < in_end);
|
||||
@@ -375,29 +266,23 @@ lzf_decompress (const void *const in_data, size_t in_len,
|
||||
|
||||
/*
|
||||
* don't play with this unless you benchmark!
|
||||
* the data format is not dependent on the hash function.
|
||||
* the hash function might seem strange, just believe me,
|
||||
* decompression is not dependent on the hash function
|
||||
* the hashing function might seem strange, just believe me
|
||||
* it works ;)
|
||||
*/
|
||||
#ifndef FRST
|
||||
# define FRST(p) (((p[0]) << 8) | p[1])
|
||||
# define NEXT(v,p) (((v) << 8) | p[2])
|
||||
# if MULTIPLICATION_IS_SLOW
|
||||
# if ULTRA_FAST
|
||||
# define IDX(h) ((( h >> (3*8 - HLOG)) - h ) & (HSIZE - 1))
|
||||
# elif VERY_FAST
|
||||
# define IDX(h) ((( h >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
|
||||
# else
|
||||
# define IDX(h) ((((h ^ (h << 5)) >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
|
||||
# endif
|
||||
# else
|
||||
/* this one was developed with sesse,
|
||||
* and is very similar to the one in snappy.
|
||||
* it does need a modern enough cpu with a fast multiplication.
|
||||
*/
|
||||
# define IDX(h) (((h * 0x1e35a7bdU) >> (32 - HLOG - 8)) & (HSIZE - 1))
|
||||
# endif
|
||||
# define IDX(h) ((((h ^ (h << 5)) >> (3*8 - HLOG)) - h*5) & (HSIZE - 1))
|
||||
#endif
|
||||
/*
|
||||
* IDX works because it is very similar to a multiplicative hash, e.g.
|
||||
* ((h * 57321 >> (3*8 - HLOG)) & (HSIZE - 1))
|
||||
* the latter is also quite fast on newer CPUs, and sligthly better
|
||||
*
|
||||
* the next one is also quite good, albeit slow ;)
|
||||
* (int)(cos(h & 0xffffff) * 1e6)
|
||||
*/
|
||||
|
||||
#if 0
|
||||
/* original lzv-like hash function, much worse and thus slower */
|
||||
@@ -406,214 +291,177 @@ lzf_decompress (const void *const in_data, size_t in_len,
|
||||
# define IDX(h) ((h) & (HSIZE - 1))
|
||||
#endif
|
||||
|
||||
#if __GNUC__ >= 3
|
||||
# define expect(expr,value) __builtin_expect ((expr),(value))
|
||||
# define inline inline
|
||||
#else
|
||||
# define expect(expr,value) (expr)
|
||||
# define inline static
|
||||
#endif
|
||||
|
||||
#define expect_false(expr) expect ((expr) != 0, 0)
|
||||
#define expect_true(expr) expect ((expr) != 0, 1)
|
||||
#define MAX_LIT (1 << 5)
|
||||
#define MAX_OFF (1 << 13)
|
||||
#define MAX_REF ((1 << 8) + (1 << 3))
|
||||
|
||||
/*
|
||||
* compressed format
|
||||
*
|
||||
* 000LLLLL <L+1> ; literal, L+1=1..33 octets
|
||||
* LLLooooo oooooooo ; backref L+1=1..7 octets, o+1=1..4096 offset
|
||||
* 111ooooo LLLLLLLL oooooooo ; backref L+8 octets, o+1=1..4096 offset
|
||||
* 000LLLLL <L+1> ; literal
|
||||
* LLLooooo oooooooo ; backref L
|
||||
* 111ooooo LLLLLLLL oooooooo ; backref L+7
|
||||
*
|
||||
*/
|
||||
|
||||
size_t
|
||||
lzf_compress (const void *const in_data, size_t in_len,
|
||||
void *out_data, size_t out_len
|
||||
lzf_compress (const void *const in_data,size_t in_len,
|
||||
void *out_data, size_t out_len
|
||||
#if LZF_STATE_ARG
|
||||
, LZF_STATE htab
|
||||
, LZF_STATE *htab
|
||||
#endif
|
||||
)
|
||||
)
|
||||
{
|
||||
#if !LZF_STATE_ARG
|
||||
LZF_STATE htab;
|
||||
#endif
|
||||
const u8 **hslot;
|
||||
const u8 *ip = (const u8 *)in_data;
|
||||
u8 *op = (u8 *)out_data;
|
||||
u8 *op = (u8 *)out_data;
|
||||
const u8 *in_end = ip + in_len;
|
||||
u8 *out_end = op + out_len;
|
||||
const u8 *ref;
|
||||
|
||||
/*
|
||||
* off requires a type wide enough to hold a general pointer difference.
|
||||
* ISO C doesn't have that (size_t might not be enough and ptrdiff_t only
|
||||
* works for differences within a single object). We also assume that
|
||||
* no bit pattern traps. Since the only platform that is both non-POSIX
|
||||
* and fails to support both assumptions is windows 64 bit, we make a
|
||||
* special workaround for it.
|
||||
*/
|
||||
u8 *out_end = op + out_len;
|
||||
const u8 *ref = NULL;
|
||||
|
||||
unsigned int hval = FRST (ip);
|
||||
size_t off;
|
||||
unsigned int hval;
|
||||
int lit;
|
||||
|
||||
if (!in_len || !out_len)
|
||||
return 0;
|
||||
int lit = 0;
|
||||
|
||||
#if INIT_HTAB
|
||||
# if USE_MEMCPY
|
||||
memset (htab, 0, sizeof (htab));
|
||||
# else
|
||||
for (hslot = htab; hslot < htab + HSIZE; hslot++)
|
||||
*hslot++ = ip;
|
||||
# endif
|
||||
#endif
|
||||
|
||||
lit = 0; op++; /* start run */
|
||||
|
||||
hval = FRST (ip);
|
||||
while (ip < in_end - 2)
|
||||
for (;;)
|
||||
{
|
||||
LZF_HSLOT *hslot;
|
||||
|
||||
hval = NEXT (hval, ip);
|
||||
hslot = htab + IDX (hval);
|
||||
ref = *hslot + LZF_HSLOT_BIAS; *hslot = ip - LZF_HSLOT_BIAS;
|
||||
|
||||
if (1
|
||||
#if INIT_HTAB
|
||||
&& ref < ip /* the next test will actually take care of this, but this is faster */
|
||||
#endif
|
||||
&& (off = ip - ref - 1) < LZF_MAX_OFF
|
||||
&& ref > (const u8 *)in_data
|
||||
&& ref[2] == ip[2]
|
||||
#if STRICT_ALIGN
|
||||
&& ((ref[1] << 8) | ref[0]) == ((ip[1] << 8) | ip[0])
|
||||
#else
|
||||
&& *(const u16 *)ref == *(const u16 *)ip
|
||||
#endif
|
||||
)
|
||||
if (ip < in_end - 2)
|
||||
{
|
||||
/* match found at *ref++ */
|
||||
unsigned int len = 2;
|
||||
size_t maxlen = in_end - ip - len;
|
||||
maxlen = maxlen > LZF_MAX_REF ? LZF_MAX_REF : maxlen;
|
||||
hval = NEXT (hval, ip);
|
||||
hslot = htab + IDX (hval);
|
||||
ref = *hslot; *hslot = ip;
|
||||
|
||||
if (expect_false (op + 3 + 1 >= out_end)) /* first a faster conservative test */
|
||||
if (op - !lit + 3 + 1 >= out_end) /* second the exact but rare test */
|
||||
return 0;
|
||||
|
||||
op [- lit - 1] = lit - 1; /* stop run */
|
||||
op -= !lit; /* undo run if length is zero */
|
||||
|
||||
for (;;)
|
||||
if (
|
||||
#if INIT_HTAB && !USE_MEMCPY
|
||||
ref < ip /* the next test will actually take care of this, but this is faster */
|
||||
&&
|
||||
#endif
|
||||
(off = ip - ref - 1) < MAX_OFF
|
||||
&& ip + 4 < in_end
|
||||
&& ref > (const u8 *)in_data
|
||||
#if STRICT_ALIGN
|
||||
&& ref[0] == ip[0]
|
||||
&& ref[1] == ip[1]
|
||||
&& ref[2] == ip[2]
|
||||
#else
|
||||
&& *(const u16 *)ref == *(const u16 *)ip
|
||||
&& ref[2] == ip[2]
|
||||
#endif
|
||||
)
|
||||
{
|
||||
if (expect_true (maxlen > 16))
|
||||
{
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
/* match found at *ref++ */
|
||||
unsigned int len = 2;
|
||||
size_t maxlen = in_end - ip - len;
|
||||
maxlen = maxlen > MAX_REF ? MAX_REF : maxlen;
|
||||
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
len++; if (ref [len] != ip [len]) break;
|
||||
}
|
||||
if (op + lit + 1 + 3 >= out_end)
|
||||
return 0;
|
||||
|
||||
do
|
||||
len++;
|
||||
while (len < maxlen && ref[len] == ip[len]);
|
||||
|
||||
break;
|
||||
}
|
||||
if (lit)
|
||||
{
|
||||
*op++ = (u8)(lit - 1);
|
||||
lit = -lit;
|
||||
do
|
||||
*op++ = ip[lit];
|
||||
while (++lit);
|
||||
}
|
||||
|
||||
len -= 2; /* len is now #octets - 1 */
|
||||
ip++;
|
||||
len -= 2;
|
||||
ip++;
|
||||
|
||||
if (len < 7)
|
||||
{
|
||||
*op++ = (off >> 8) + (len << 5);
|
||||
}
|
||||
else
|
||||
{
|
||||
*op++ = (off >> 8) + ( 7 << 5);
|
||||
*op++ = len - 7;
|
||||
}
|
||||
if (len < 7)
|
||||
{
|
||||
*op++ = (u8)((off >> 8) + (len << 5));
|
||||
}
|
||||
else
|
||||
{
|
||||
*op++ = (u8)((off >> 8) + ( 7 << 5));
|
||||
*op++ = (u8)(len - 7);
|
||||
}
|
||||
|
||||
*op++ = off;
|
||||
|
||||
lit = 0; op++; /* start run */
|
||||
|
||||
ip += len + 1;
|
||||
|
||||
if (expect_false (ip >= in_end - 2))
|
||||
break;
|
||||
*op++ = (u8)off;
|
||||
|
||||
#if ULTRA_FAST || VERY_FAST
|
||||
--ip;
|
||||
# if VERY_FAST && !ULTRA_FAST
|
||||
--ip;
|
||||
# endif
|
||||
hval = FRST (ip);
|
||||
|
||||
hval = NEXT (hval, ip);
|
||||
htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
|
||||
ip++;
|
||||
|
||||
# if VERY_FAST && !ULTRA_FAST
|
||||
hval = NEXT (hval, ip);
|
||||
htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
|
||||
ip++;
|
||||
# endif
|
||||
#else
|
||||
ip -= len + 1;
|
||||
|
||||
do
|
||||
{
|
||||
hval = NEXT (hval, ip);
|
||||
htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
|
||||
ip++;
|
||||
}
|
||||
while (len--);
|
||||
ip += len;
|
||||
#if VERY_FAST && !ULTRA_FAST
|
||||
--ip;
|
||||
#endif
|
||||
hval = FRST (ip);
|
||||
|
||||
hval = NEXT (hval, ip);
|
||||
htab[IDX (hval)] = ip;
|
||||
ip++;
|
||||
|
||||
#if VERY_FAST && !ULTRA_FAST
|
||||
hval = NEXT (hval, ip);
|
||||
htab[IDX (hval)] = ip;
|
||||
ip++;
|
||||
#endif
|
||||
#else
|
||||
do
|
||||
{
|
||||
hval = NEXT (hval, ip);
|
||||
htab[IDX (hval)] = ip;
|
||||
ip++;
|
||||
}
|
||||
while (len--);
|
||||
#endif
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else
|
||||
else if (ip == in_end)
|
||||
break;
|
||||
|
||||
/* one more literal byte we must copy */
|
||||
lit++;
|
||||
ip++;
|
||||
|
||||
if (lit == MAX_LIT)
|
||||
{
|
||||
/* one more literal byte we must copy */
|
||||
if (expect_false (op >= out_end))
|
||||
if (op + 1 + MAX_LIT >= out_end)
|
||||
return 0;
|
||||
|
||||
lit++; *op++ = *ip++;
|
||||
|
||||
if (expect_false (lit == LZF_MAX_LIT))
|
||||
{
|
||||
op [- lit - 1] = lit - 1; /* stop run */
|
||||
lit = 0; op++; /* start run */
|
||||
}
|
||||
*op++ = MAX_LIT - 1;
|
||||
#if USE_MEMCPY
|
||||
M_Memcpy (op, ip - MAX_LIT, MAX_LIT);
|
||||
op += MAX_LIT;
|
||||
lit = 0;
|
||||
#else
|
||||
lit = -lit;
|
||||
do
|
||||
*op++ = ip[lit];
|
||||
while (++lit);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
if (op + 3 > out_end) /* at most 3 bytes can be missing here */
|
||||
return 0;
|
||||
|
||||
while (ip < in_end)
|
||||
if (lit)
|
||||
{
|
||||
lit++; *op++ = *ip++;
|
||||
if (op + lit + 1 >= out_end)
|
||||
return 0;
|
||||
|
||||
if (expect_false (lit == LZF_MAX_LIT))
|
||||
{
|
||||
op [- lit - 1] = lit - 1; /* stop run */
|
||||
lit = 0; op++; /* start run */
|
||||
}
|
||||
*op++ = (u8)(lit - 1);
|
||||
lit = -lit;
|
||||
do
|
||||
*op++ = ip[lit];
|
||||
while (++lit);
|
||||
}
|
||||
|
||||
op [- lit - 1] = lit - 1; /* end run */
|
||||
op -= !lit; /* undo run if length is zero */
|
||||
|
||||
return op - (u8 *)out_data;
|
||||
return op - (u8 *) out_data;
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (c) 2000-2010 Marc Alexander Lehmann <schmorp@schmorp.de>
|
||||
// Copyright (C) 2000-2005 by Marc Alexander Lehmann <schmorp@schmorp.de>
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
@@ -22,7 +22,7 @@
|
||||
**
|
||||
***********************************************************************/
|
||||
|
||||
#define LZF_VERSION 0x0106 /* 1.6 */
|
||||
#define LZF_VERSION 0x0105 /* 1.5 */
|
||||
|
||||
/*
|
||||
* Compress in_len bytes stored at the memory block starting at
|
||||
|
||||
+138
-89
@@ -1160,7 +1160,7 @@ static menuitem_t OP_ControlsMenu[] =
|
||||
|
||||
{IT_CALL | IT_STRING, NULL, "Player 3 Controls...", &M_Setup3PControlsMenu, 30},
|
||||
{IT_CALL | IT_STRING, NULL, "Player 4 Controls...", &M_Setup4PControlsMenu, 40},
|
||||
|
||||
|
||||
{IT_SUBMENU | IT_STRING, NULL, "Mouse Options...", &OP_MouseOptionsDef, 60},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Controls per key", &cv_controlperkey, 80},
|
||||
@@ -1372,7 +1372,7 @@ static menuitem_t OP_VideoOptionsMenu[] =
|
||||
|
||||
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
|
||||
NULL, "Saturation", &cv_globalsaturation , 40},
|
||||
|
||||
|
||||
{IT_SUBMENU|IT_STRING, NULL, "Advanced Color Settings...", &OP_ColorOptionsDef, 50},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Draw Distance", &cv_drawdist, 65},
|
||||
@@ -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},
|
||||
@@ -1492,13 +1492,13 @@ 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},
|
||||
#ifdef HWRENDER
|
||||
{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_glpalettedepth, 130},
|
||||
#endif
|
||||
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_grpalettedepth, 130},
|
||||
#endif
|
||||
};
|
||||
|
||||
static const char* OP_ExpTooltips[] =
|
||||
@@ -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, "Min Shader Brightness", &cv_secbright, 40},
|
||||
{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, "Palette Rendering Flashpals",&cv_glflashpal, 35},
|
||||
{IT_STRING | IT_CVAR, NULL, "Min Shader Brightness", &cv_glsecbright, 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 Quality", &cv_scr_depth, 50},
|
||||
{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, "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, "Wall Contrast Style", &cv_glfakecontrast, 75},
|
||||
{IT_STRING | IT_CVAR, NULL, "Slope Contrast", &cv_glslopecontrast, 80},
|
||||
{IT_STRING | IT_CVAR, NULL, "Dithered Lightning", &cv_gllightdither, 85},
|
||||
{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[] =
|
||||
@@ -1573,11 +1573,32 @@ static const char* OP_OpenGLTooltips[] =
|
||||
"Recreates an effect from software mode that is used on some maps.",
|
||||
"The look of the wall contrast effect.",
|
||||
"Wall contrast but for slopes.",
|
||||
"Should OpenGL lightning be dithered?",
|
||||
"Should shader lightning be dithered?",
|
||||
"Should sprites always face the camera?",
|
||||
"Recreates the look of software mode camera perspective.",
|
||||
"How far the game world should be drawn.",
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
op_gl_mdls,
|
||||
op_gl_falbckmdls,
|
||||
op_gl_shader,
|
||||
op_gl_palrender,
|
||||
op_gl_flashpal,
|
||||
op_gl_secbright,
|
||||
op_gl_scrdepth,
|
||||
op_gl_filter,
|
||||
op_gl_anis,
|
||||
op_gl_portal,
|
||||
op_gl_wallcont,
|
||||
op_gl_slopecont,
|
||||
op_gl_lightdither,
|
||||
op_gl_bill,
|
||||
op_gl_shearing,
|
||||
op_gl_renderdist,
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
static menuitem_t OP_SoundOptionsMenu[] =
|
||||
@@ -1604,7 +1625,7 @@ static menuitem_t OP_SoundOptionsMenu[] =
|
||||
{IT_STRING|IT_CVAR, NULL, "Character voices", &cv_kartvoices, 75},
|
||||
{IT_STRING|IT_CVAR, NULL, "Hit Em Delay", &cv_karthitemdialog, 85},
|
||||
{IT_STRING|IT_CVAR, NULL, "Powerup Warning", &cv_kartinvinsfx, 95},
|
||||
|
||||
|
||||
{IT_KEYHANDLER|IT_STRING, NULL, "Sound Test", M_HandleSoundTest, 105},
|
||||
{IT_STRING|IT_CALL, NULL, "Music Test", M_MusicTest, 115},
|
||||
|
||||
@@ -1618,7 +1639,7 @@ static menuitem_t OP_SoundOptionsMenu[] =
|
||||
{IT_STRING|IT_CVAR, NULL, "Character voices", &cv_kartvoices, 85},
|
||||
{IT_STRING|IT_CVAR, NULL, "Hit Em Delay", &cv_karthitemdialog, 95},
|
||||
{IT_STRING|IT_CVAR, NULL, "Powerup Warning", &cv_kartinvinsfx, 105},
|
||||
|
||||
|
||||
{IT_KEYHANDLER|IT_STRING, NULL, "Sound Test", M_HandleSoundTest, 115},
|
||||
{IT_STRING|IT_CALL, NULL, "Music Test", M_MusicTest, 125},
|
||||
|
||||
@@ -1679,7 +1700,7 @@ static const char* OP_SoundAdvancedTooltips[] =
|
||||
{
|
||||
#ifdef HAVE_OPENMPT
|
||||
NULL,
|
||||
|
||||
|
||||
"Filter used to resample tracker instruments.",
|
||||
"Resample tracker modules to sound similar to Paula hardware.",
|
||||
#if OPENMPT_API_VERSION_MAJOR < 1 && OPENMPT_API_VERSION_MINOR > 4
|
||||
@@ -1792,7 +1813,7 @@ static menuitem_t OP_HUDOptionsMenu[] =
|
||||
{
|
||||
{IT_STRING | IT_CVAR, NULL, "Show HUD (F3)", &cv_showhud, 10},
|
||||
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
|
||||
NULL, "HUD Visibility", &cv_translucenthud, 20},
|
||||
NULL, "HUD Visibility", &cv_translucenthud, 20},
|
||||
|
||||
{IT_STRING | IT_SUBMENU, NULL, "Online HUD options...", &OP_ChatOptionsDef, 35},
|
||||
{IT_STRING | IT_CVAR, NULL, "Background Glass", &cons_backcolor, 45},
|
||||
@@ -1808,9 +1829,9 @@ static menuitem_t OP_HUDOptionsMenu[] =
|
||||
{IT_STRING | IT_CVAR, NULL, "Console Text Size", &cv_constextsize, 120},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Show Track Addon Name", &cv_showtrackaddon, 135},
|
||||
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Show All Maps", &cv_showallmaps, 145},
|
||||
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "Show \"FOCUS LOST\"", &cv_showfocuslost, 155},
|
||||
|
||||
{IT_STRING | IT_CVAR, NULL, "2D character select", &cv_skinselectmenu, 165},
|
||||
@@ -2062,7 +2083,7 @@ static menuitem_t OP_AdvServerOptionsMenu[] =
|
||||
};
|
||||
|
||||
static const char* OP_AdvServerOptionsTooltips[] =
|
||||
{
|
||||
{
|
||||
"Server used for master server.",
|
||||
"Attempts to resynchronise player to server.",
|
||||
#ifdef SATURNSYNCH
|
||||
@@ -2326,7 +2347,6 @@ enum
|
||||
sh_hudoffsets,
|
||||
};
|
||||
|
||||
|
||||
static menuitem_t OP_HudOffsetMenu[] =
|
||||
{
|
||||
{IT_HEADER, NULL, "Kart Hud Offsets", NULL, 0},
|
||||
@@ -2380,7 +2400,7 @@ static menuitem_t OP_SaturnCreditsMenu[] =
|
||||
{IT_STRING2+IT_SPACE, NULL, "xyzzy", NULL, 70},
|
||||
{IT_STRING2+IT_SPACE, NULL, "Chearii", NULL, 80},
|
||||
|
||||
{IT_STRING+IT_SPACE, NULL, "", NULL, 83}, // dummy text
|
||||
{IT_STRING+IT_SPACE, NULL, "", NULL, 83}, // dummy text
|
||||
|
||||
{IT_STRING2+IT_SPACE, NULL, "Sunflower aka AnimeSonic", NULL, 90},
|
||||
{IT_STRING2+IT_SPACE, NULL, "Yuz aka Yuzler", NULL, 100},
|
||||
@@ -3373,7 +3393,7 @@ void PDistort_menu_Onchange(void)
|
||||
OP_PlayerDistortMenu[slrotatedist].status = IT_STRING | IT_CVAR;
|
||||
else
|
||||
OP_PlayerDistortMenu[slrotatedist].status = IT_GRAYEDOUT;
|
||||
|
||||
|
||||
if ((cv_sloperoll.value == 2) && (cv_spriteroll.value)) //enable/disable sparkroll depending on which setting
|
||||
OP_PlayerDistortMenu[sparkrotate].status = IT_STRING | IT_CVAR;
|
||||
else
|
||||
@@ -3402,7 +3422,7 @@ void Bird_menu_Onchange(void)
|
||||
OP_AdvancedBirdMenu[fadegrow].status = status;
|
||||
OP_AdvancedBirdMenu[respawnfadeout].status = status;
|
||||
OP_AdvancedBirdMenu[respawnfadein].status = status;
|
||||
|
||||
|
||||
if (cv_birdmusic.value)
|
||||
{
|
||||
OP_BirdMenu[lvlresum].status = IT_STRING | IT_CVAR;
|
||||
@@ -3414,7 +3434,7 @@ void Bird_menu_Onchange(void)
|
||||
OP_BirdMenu[lvlresum].status = IT_GRAYEDOUT;
|
||||
OP_BirdMenu[spclresum].status = IT_GRAYEDOUT;
|
||||
OP_BirdMenu[advmusic].status = IT_GRAYEDOUT;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//menu code is nice
|
||||
@@ -3426,11 +3446,28 @@ void SaturnHud_menu_Onchange(void)
|
||||
status = IT_STRING | IT_CVAR;
|
||||
else
|
||||
status = IT_GRAYEDOUT;
|
||||
|
||||
|
||||
OP_SaturnHudMenu[sh_coloritem].status = status;
|
||||
OP_SaturnHudMenu[sh_colorhud_customcolor].status = status;
|
||||
}
|
||||
|
||||
#ifdef HWRENDER
|
||||
void M_UpdateOGLMenu(void)
|
||||
{
|
||||
OP_ExpOptionsMenu[op_exp_fbo].status = (!supportFBO || cv_glscreentextures.value != 2) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
|
||||
OP_ExpOptionsMenu[op_exp_paldepth].status = (!HWR_ShouldUsePaletteRendering()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
|
||||
|
||||
OP_OpenGLOptionsMenu[op_gl_falbckmdls].status = (!cv_glmdls.value) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
|
||||
|
||||
OP_OpenGLOptionsMenu[op_gl_lightdither].status = (!HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
|
||||
OP_OpenGLOptionsMenu[op_gl_secbright].status = (!HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
|
||||
|
||||
OP_OpenGLOptionsMenu[op_gl_palrender].status = (cv_glscreentextures.value != 2 || !HWR_UseShader()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
|
||||
OP_OpenGLOptionsMenu[op_gl_flashpal].status = (!HWR_ShouldUsePaletteRendering()) ? IT_GRAYEDOUT : IT_STRING | IT_CVAR;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
// ==========================================================================
|
||||
// END ORGANIZATION STUFF.
|
||||
// ==========================================================================
|
||||
@@ -4301,9 +4338,9 @@ void M_Drawer(void)
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
V_DrawThinString(0, 0, V_GREENMAP|V_SNAPTOTOP|V_SNAPTOLEFT|V_TRANSLUCENT|V_ALLOWLOWERCASE, ("Opengl"));
|
||||
#endif
|
||||
#endif
|
||||
if (rendermode == render_soft)
|
||||
V_DrawThinString(0, 0, V_REDMAP|V_SNAPTOTOP|V_SNAPTOLEFT|V_TRANSLUCENT|V_ALLOWLOWERCASE, ("Software"));
|
||||
V_DrawThinString(0, 0, V_REDMAP|V_SNAPTOTOP|V_SNAPTOLEFT|V_TRANSLUCENT|V_ALLOWLOWERCASE, ("Software"));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4394,18 +4431,18 @@ void M_StartControlPanel(void)
|
||||
MPauseMenu[mpause_psetup].status = IT_DISABLED;
|
||||
MISC_ChangeTeamMenu[0].status = IT_DISABLED;
|
||||
MISC_ChangeSpectateMenu[0].status = IT_DISABLED;
|
||||
|
||||
|
||||
MPauseMenu[mpause_addlocalskins].status = IT_STRING | IT_CALL;
|
||||
MPauseMenu[mpause_localskin].status = IT_STRING | IT_CALL;
|
||||
|
||||
// Reset these in case splitscreen messes things up
|
||||
MPauseMenu[mpause_addons].alphaKey = 8;
|
||||
|
||||
|
||||
if (IsPlayerAdmin(consoleplayer))
|
||||
MPauseMenu[mpause_addlocalskins].alphaKey = 16;
|
||||
else
|
||||
MPauseMenu[mpause_addlocalskins].alphaKey = 24;
|
||||
|
||||
|
||||
MPauseMenu[mpause_scramble].alphaKey = 8;
|
||||
MPauseMenu[mpause_switchmap].alphaKey = 24;
|
||||
|
||||
@@ -4423,17 +4460,17 @@ void M_StartControlPanel(void)
|
||||
MPauseMenu[mpause_switchmap].status = IT_STRING | IT_CALL;
|
||||
MPauseMenu[mpause_addons].status = IT_STRING | IT_CALL;
|
||||
}
|
||||
|
||||
|
||||
if (server || (!cv_showlocalskinmenus.value))
|
||||
{
|
||||
MPauseMenu[mpause_addlocalskins].status = IT_DISABLED;
|
||||
MPauseMenu[mpause_localskin].status = IT_DISABLED;
|
||||
|
||||
|
||||
MPauseMenu[mpause_options].alphaKey = 64;
|
||||
MPauseMenu[mpause_title].alphaKey = 80;
|
||||
MPauseMenu[mpause_quit].alphaKey = 88;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (splitscreen)
|
||||
{
|
||||
@@ -4687,10 +4724,12 @@ 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
|
||||
OP_ExpOptionsMenu[op_exp_paldepth].status = IT_DISABLED;
|
||||
}
|
||||
|
||||
if (rendermode == render_opengl)
|
||||
@@ -4699,15 +4738,25 @@ void M_Init(void)
|
||||
if (!supportFBO)
|
||||
OP_ExpOptionsMenu[op_exp_fbo].status = IT_GRAYEDOUT;
|
||||
#endif
|
||||
if (!gl_shadersavailable)
|
||||
{
|
||||
OP_OpenGLOptionsMenu[op_gl_shader].status = IT_GRAYEDOUT;
|
||||
OP_OpenGLOptionsMenu[op_gl_lightdither].status = IT_GRAYEDOUT;
|
||||
OP_OpenGLOptionsMenu[op_gl_secbright].status = IT_GRAYEDOUT;
|
||||
OP_OpenGLOptionsMenu[op_gl_palrender].status = IT_GRAYEDOUT;
|
||||
OP_OpenGLOptionsMenu[op_gl_flashpal].status = IT_GRAYEDOUT;
|
||||
|
||||
OP_ExpOptionsMenu[op_exp_paldepth].status = IT_GRAYEDOUT;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!xtra_speedo && !kartzspeedo && !achi_speedo) // why bother?
|
||||
OP_SaturnHudMenu[sh_speedometer].status = IT_GRAYEDOUT;
|
||||
|
||||
|
||||
//if (!xtra_speedo && kartzspeedo)
|
||||
//OP_SaturnMenu[sm_speedometer].text = "Speedometer (No Small)";
|
||||
|
||||
|
||||
//if (xtra_speedo && !kartzspeedo)
|
||||
//OP_SaturnMenu[sm_speedometer].text = "Speedometer (No PMeter)";
|
||||
// idk i dont wanna bother with this tbh lmao
|
||||
@@ -5043,7 +5092,7 @@ static void M_DrawSplitText(INT32 x, INT32 y, INT32 option, const char* str, INT
|
||||
yoffset = (((5*10 - num_lines*10)));
|
||||
|
||||
// Draw BG first,,,
|
||||
for (int i = 0; i < num_lines; i++)
|
||||
for (int i = 0; i < num_lines; i++)
|
||||
{
|
||||
V_DrawFill(0, (y + yoffset - 6)+5, vid.width, 11, 239|V_SNAPTOBOTTOM|V_SNAPTOLEFT);
|
||||
yoffset += 11;
|
||||
@@ -5052,7 +5101,7 @@ static void M_DrawSplitText(INT32 x, INT32 y, INT32 option, const char* str, INT
|
||||
yoffset = (((5*10 - num_lines*10)));
|
||||
|
||||
// THEN the text
|
||||
for (int i = 0; i < num_lines; i++)
|
||||
for (int i = 0; i < num_lines; i++)
|
||||
{
|
||||
V_DrawCenteredThinString(x, y + yoffset, option, clines[i]);
|
||||
V_DrawCenteredThinString(x, y + yoffset, option|V_YELLOWMAP|((9 - alpha) << V_ALPHASHIFT), clines[i]);
|
||||
@@ -5068,7 +5117,7 @@ static void M_DrawSplitText(INT32 x, INT32 y, INT32 option, const char* str, INT
|
||||
static void M_DrawGenericMenu(void)
|
||||
{
|
||||
INT32 x, y, w, i, cursory = 0;
|
||||
|
||||
|
||||
INT32 lowercase = !cv_menucaps.value ? V_ALLOWLOWERCASE : 0;
|
||||
|
||||
// DRAW MENU
|
||||
@@ -5284,7 +5333,7 @@ static void M_DrawGenericScrollMenu(void)
|
||||
|
||||
// draw title (or big pic)
|
||||
M_DrawMenuTitle();
|
||||
|
||||
|
||||
INT32 lowercase = !cv_menucaps.value ? V_ALLOWLOWERCASE : 0;
|
||||
|
||||
for (; i < max; i++)
|
||||
@@ -5406,7 +5455,7 @@ static void M_DrawCenteredMenu(void)
|
||||
|
||||
// draw title (or big pic)
|
||||
M_DrawMenuTitle();
|
||||
|
||||
|
||||
INT32 lowercase = !cv_menucaps.value ? V_ALLOWLOWERCASE : 0;
|
||||
|
||||
for (i = 0; i < currentMenu->numitems; i++)
|
||||
@@ -6335,7 +6384,7 @@ static void M_AddonAutoLoad(INT32 ch)
|
||||
S_StartSound(NULL, sfx_s26d);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// first, find the file //
|
||||
path = va("%s"PATHSEP"%s", srb2home, AUTOLOADCONFIGFILENAME);
|
||||
autoloadconfigfile = fopen(path, "a");
|
||||
@@ -6350,7 +6399,7 @@ static void M_AddonAutoLoad(INT32 ch)
|
||||
case EXT_CFG:
|
||||
CONS_Printf("Added the \x82%s\x80 console script to the autoload configuration list.\n", dirmenu[dir_on[menudepthleft]]+DIR_STRING);
|
||||
fprintf(autoloadconfigfile, "%s\n", dirmenu[dir_on[menudepthleft]]+DIR_STRING);
|
||||
|
||||
|
||||
S_StartSound(NULL, sfx_s221);
|
||||
break;
|
||||
case EXT_LUA:
|
||||
@@ -6363,7 +6412,7 @@ static void M_AddonAutoLoad(INT32 ch)
|
||||
{
|
||||
CONS_Printf("Added \x82%s\x80 to the autoload configuration list.\n", dirmenu[dir_on[menudepthleft]]+DIR_STRING);
|
||||
fprintf(autoloadconfigfile, "%s\n", dirmenu[dir_on[menudepthleft]]+DIR_STRING);
|
||||
|
||||
|
||||
S_StartSound(NULL, sfx_s221);
|
||||
}
|
||||
else
|
||||
@@ -6373,7 +6422,7 @@ static void M_AddonAutoLoad(INT32 ch)
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
// lastly, do some last things and close the autoload config file //
|
||||
fclose(autoloadconfigfile);
|
||||
}
|
||||
@@ -6577,7 +6626,7 @@ static void M_HandleAddons(INT32 choice)
|
||||
|| (strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, AUTOLOADCONFIGFILENAME) == 0)
|
||||
|| (strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartserv.cfg") == 0)
|
||||
|| (strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartexec.cfg") == 0))
|
||||
{
|
||||
{
|
||||
M_StartMessage(va("%c%s\x80\nYou can't autoload this builds' base console scripts, silly!\n They're already autoloaded on startup! \n\n(Press a key)\n", ('\x80' + (highlightflags>>V_CHARCOLORSHIFT)), dirmenu[dir_on[menudepthleft]]+DIR_STRING),NULL,MM_NOTHING);
|
||||
S_StartSound(NULL, sfx_s26d);
|
||||
}
|
||||
@@ -7848,7 +7897,7 @@ static void M_Options(INT32 choice)
|
||||
OP_MainMenu[5].status = OP_MainMenu[6].status = (Playing() && !(server || IsPlayerAdmin(consoleplayer))) ? (IT_GRAYEDOUT) : (IT_STRING|IT_SUBMENU);
|
||||
|
||||
OP_MainMenu[10].status = (Playing()) ? (IT_GRAYEDOUT) : (IT_STRING|IT_CALL); // Play credits
|
||||
|
||||
|
||||
OP_MainMenu[13].status = (!cv_showlocalskinmenus.value) ? (IT_DISABLED) : (IT_CALL|IT_STRING);
|
||||
|
||||
#ifdef HAVE_DISCORDRPC
|
||||
@@ -8422,14 +8471,14 @@ static void M_DrawMusicTest(void)
|
||||
|
||||
if (curplaying && curplaying->authors[0])
|
||||
V_DrawRightAlignedThinString(BASEVIDWIDTH-16, 46, V_ALLOWLOWERCASE, curplaying->authors);
|
||||
|
||||
|
||||
if (curplaying)
|
||||
{
|
||||
if (!curplaying->usage[0])
|
||||
V_DrawString(vid.dupx, vid.height - 10*vid.dupy, V_NOSCALESTART|V_ALLOWLOWERCASE, va("%.6s", curplaying->name));
|
||||
else
|
||||
V_DrawSmallString(vid.dupx, vid.height - 5*vid.dupy, V_NOSCALESTART|V_ALLOWLOWERCASE, va("%.6s - %.255s\n", curplaying->name, curplaying->usage));
|
||||
|
||||
|
||||
if (cv_showmusicfilename.value)
|
||||
V_DrawSmallString(0, 0, V_SNAPTOTOP|V_SNAPTOLEFT|V_ALLOWLOWERCASE, curplaying->filename);
|
||||
}
|
||||
@@ -8575,7 +8624,7 @@ static void M_HandleMusicTest(INT32 choice)
|
||||
case KEY_ENTER:
|
||||
S_StopSounds();
|
||||
S_StopMusic();
|
||||
curplaying = soundtestdefs[st_sel];
|
||||
curplaying = soundtestdefs[st_sel];
|
||||
S_ChangeMusicInternal(curplaying->name, true);
|
||||
break;
|
||||
|
||||
@@ -9440,10 +9489,10 @@ static void M_Connect(INT32 choice)
|
||||
{
|
||||
// do not call menuexitfunc
|
||||
M_ClearMenus(false);
|
||||
|
||||
|
||||
CV_Set(&cv_lastserver, I_GetNodeAddress(serverlist[choice-FIRSTSERVERLINE + serverlistpage * SERVERS_PER_PAGE].node));
|
||||
|
||||
COM_BufAddText(va("connect node %d\n", serverlist[choice-FIRSTSERVERLINE + serverlistpage * SERVERS_PER_PAGE].node));
|
||||
|
||||
COM_BufAddText(va("connect node %d\n", serverlist[choice-FIRSTSERVERLINE + serverlistpage * SERVERS_PER_PAGE].node));
|
||||
}
|
||||
|
||||
static void M_Refresh(INT32 choice)
|
||||
@@ -9689,7 +9738,7 @@ void M_SortServerList(void)
|
||||
|
||||
#ifndef NONET
|
||||
#ifdef UPDATE_ALERT
|
||||
#ifdef MASTERSERVER
|
||||
#ifdef MASTERSERVER
|
||||
static void M_CheckMODVersion(int id)
|
||||
{
|
||||
char updatestring[500];
|
||||
@@ -10189,7 +10238,7 @@ static void M_DrawMPMainMenu(void)
|
||||
|
||||
// use generic drawer for cursor, items and title
|
||||
M_DrawGenericMenu();
|
||||
|
||||
|
||||
INT32 lowercase = !cv_menucaps.value ? V_ALLOWLOWERCASE : 0;
|
||||
|
||||
#ifndef NONET
|
||||
@@ -10396,7 +10445,7 @@ static void M_ConnectLastServer(INT32 choice)
|
||||
}
|
||||
|
||||
M_ClearMenus(true);
|
||||
COM_BufAddText(va("connect \"%s\"\n", cv_lastserver.string));
|
||||
COM_BufAddText(va("connect \"%s\"\n", cv_lastserver.string));
|
||||
}
|
||||
|
||||
// Tails 11-19-2002
|
||||
@@ -10567,11 +10616,11 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
statoffset = 0;
|
||||
tw = V_StringWidth("Character", 0);//V_StringWidth(GETSELECTEDSKINNAME, 0);
|
||||
st = V_StringWidth(GETSELECTEDSKINNAME, 0);
|
||||
|
||||
|
||||
INT32 selectedskin = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
|
||||
speed = skins[selectedskin].kartspeed;
|
||||
weight = skins[selectedskin].kartweight;
|
||||
|
||||
weight = skins[selectedskin].kartweight;
|
||||
|
||||
V_DrawString((mx+(tw/2)) - (st/2), my + 37,
|
||||
((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0) | highlightflags | V_ALLOWLOWERCASE,
|
||||
GETSELECTEDSKINNAME);
|
||||
@@ -10579,7 +10628,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
statoffset = 50;
|
||||
else
|
||||
statoffset = 113;
|
||||
|
||||
|
||||
V_DrawString(statx - statoffset, staty - 10, V_6WIDTHSPACE, va("\x84%dS \x87%dW", GETSELECTEDSPEED, GETSELECTEDWEIGHT));
|
||||
#undef GETSELECTEDSKINNAME
|
||||
#undef GETSELECTEDSPEED
|
||||
@@ -10644,7 +10693,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
V_DrawCharacter(mx + 2 + st + (skullAnimCounter/5), my + 164,
|
||||
'\x1D' | highlightflags, false); // right arrow
|
||||
}
|
||||
break;
|
||||
break;
|
||||
case SKINMENUTYPE_GRID:
|
||||
case SKINMENUTYPE_2D:
|
||||
V_DrawString(mx, my + 152, highlightflags | V_ALLOWLOWERCASE, KartColor_Names[setupm_fakecolor]); // SRB2kart
|
||||
@@ -10688,8 +10737,8 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
{
|
||||
//Background
|
||||
V_DrawScaledPatch(statx - 50, staty + 4, 0, W_CachePatchName("K_STATNB", PU_CACHE));
|
||||
|
||||
//Speed
|
||||
|
||||
//Speed
|
||||
for (i = 0; i < GETSELECTEDSPEED; i++) // draw the stat bars
|
||||
{
|
||||
if (i == 0)
|
||||
@@ -10699,11 +10748,11 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
else
|
||||
V_DrawScaledPatch(statx - 45, staty + 63 -(5 *i), 0, W_CachePatchName("K_STATN2", PU_CACHE));
|
||||
}
|
||||
|
||||
|
||||
//Weight
|
||||
for (i = 0; i < GETSELECTEDWEIGHT; i++) // draw the stat bars
|
||||
{
|
||||
|
||||
|
||||
if (i == 0)
|
||||
V_DrawScaledPatch(statx - 30, staty + 63, 0, W_CachePatchName("K_STATN4", PU_CACHE));
|
||||
else if (i == GETSELECTEDWEIGHT -1)
|
||||
@@ -10979,10 +11028,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
#define indexwidth 8
|
||||
{
|
||||
INT32 colwidth = ((BASEVIDWIDTH-(2*mx))-charw)/(2*indexwidth);
|
||||
|
||||
|
||||
if (cv_skinselectmenu.value == SKINMENUTYPE_EXTENDED)
|
||||
colwidth = colwidth - 10;
|
||||
|
||||
|
||||
INT32 j = -colwidth;
|
||||
INT16 col = setupm_fakecolor - colwidth;
|
||||
INT32 x = mx;
|
||||
@@ -11116,7 +11165,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
|
||||
frame = 0; // Try to use standing frame
|
||||
|
||||
sprframe = &sprdef->spriteframes[frame];
|
||||
|
||||
|
||||
//minenice's speen css, it's a piece of shit but hey
|
||||
//patch = W_CachePatchNum(sprframe->lumppat[1], PU_CACHE);
|
||||
speenframe = (I_GetTime()*cv_skinselectspin.value/TICRATE + 1)%8;
|
||||
@@ -11186,7 +11235,7 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
if (setupm_skinselect < ROUNDSKINSUPTO8 - SKINGRIDWIDTH) //if we arent at the bottom of the menu
|
||||
{
|
||||
setupm_skinselect += SKINGRIDWIDTH;
|
||||
|
||||
|
||||
if (cv_skinselectmenu.value == SKINMENUTYPE_GRID){
|
||||
if (setupm_skinselect >= ((setupm_skinypos-1)+SKINGRIDHEIGHT)*8 && setupm_skinypos < (ROUNDSKINSUPTO8/8)-SKINGRIDHEIGHT)
|
||||
setupm_skinypos++;
|
||||
@@ -11259,9 +11308,9 @@ static void M_HandleSetupMultiPlayer(INT32 choice)
|
||||
else if (cv_skinselectmenu.value == SKINMENUTYPE_EXTENDED){
|
||||
setupm_skinypos = (((numskins / SKINGRIDWIDTH) - (SKINGRIDHEIGHT-1)-2) > 0 ? ((numskins / SKINGRIDWIDTH) - (SKINGRIDHEIGHT-1)-2) : 0);
|
||||
M_PrevOpt();
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
else
|
||||
M_PrevOpt();
|
||||
@@ -11722,7 +11771,7 @@ static boolean M_QuitMultiPlayerMenu(void)
|
||||
}
|
||||
// you know what? always putting these in the buffer won't hurt anything.
|
||||
COM_BufAddText (va("%s \"%s\"\n",setupm_cvskin->name,skins[setupm_fakeskin].name));
|
||||
COM_BufAddText (va("%s %d\n",setupm_cvcolor->name,setupm_fakecolor));
|
||||
COM_BufAddText (va("%s %d\n",setupm_cvcolor->name,setupm_fakecolor));
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -12547,7 +12596,7 @@ static void M_VideoModeMenu(INT32 choice)
|
||||
static void M_DrawVideoMenu(void)
|
||||
{
|
||||
M_DrawGenericMenu();
|
||||
|
||||
|
||||
INT32 lowercase = !cv_menucaps.value ? V_ALLOWLOWERCASE : 0;
|
||||
|
||||
V_DrawRightAlignedString(BASEVIDWIDTH - currentMenu->x, currentMenu->y + OP_VideoOptionsMenu[0].alphaKey,
|
||||
@@ -12640,7 +12689,7 @@ static void M_DrawLocalSkinMenu(void)
|
||||
else
|
||||
multi_tics += multi_state->tics * FRACUNIT;
|
||||
}
|
||||
|
||||
|
||||
// skin 0 is default player sprite
|
||||
if (R_AnySkinAvailable(cv_fakelocalskin.string) != -1)
|
||||
{
|
||||
@@ -12649,7 +12698,7 @@ static void M_DrawLocalSkinMenu(void)
|
||||
}
|
||||
else
|
||||
{
|
||||
// ATTEMPT TO FIND REAL SKIN
|
||||
// ATTEMPT TO FIND REAL SKIN
|
||||
if (R_AnySkinAvailable(cv_skin.string) != -1)
|
||||
{
|
||||
sprdef = &allskins[R_AnySkinAvailable(cv_skin.string)].spritedef;
|
||||
|
||||
@@ -299,6 +299,10 @@ void Bird_menu_Onchange(void);
|
||||
// Saturn Hud menu updating
|
||||
void SaturnHud_menu_Onchange(void);
|
||||
|
||||
#ifdef HWRENDER
|
||||
void M_UpdateOGLMenu(void);
|
||||
#endif
|
||||
|
||||
void M_ReplayHut(INT32 choice);
|
||||
void M_SetPlaybackMenuPointer(void);
|
||||
|
||||
|
||||
+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);
|
||||
|
||||
+16
-5
@@ -118,6 +118,15 @@ static void M_TextInputToWordBegin(textinput_t *input, boolean move_sel)
|
||||
if (move_sel) input->select = input->cursor;
|
||||
}
|
||||
|
||||
static void M_TextInputPaste(textinput_t *input)
|
||||
{
|
||||
const char *paste = I_ClipboardPaste();
|
||||
if (input->select != input->cursor)
|
||||
M_TextInputDelSelection(input);
|
||||
if (paste != NULL)
|
||||
M_TextInputAddString(input, paste);
|
||||
}
|
||||
|
||||
void M_TextInputInit(textinput_t *input, char *buffer, size_t buffer_size)
|
||||
{
|
||||
input->buffer = buffer;
|
||||
@@ -147,6 +156,12 @@ boolean M_TextInputHandle(textinput_t *input, INT32 key)
|
||||
|| key == KEY_LALT || key == KEY_RALT)
|
||||
return false;
|
||||
|
||||
if (shiftdown && key == KEY_INS)
|
||||
{
|
||||
M_TextInputPaste(input);
|
||||
return true;
|
||||
}
|
||||
|
||||
if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
|
||||
{
|
||||
if (key == 'x' || key == 'X')
|
||||
@@ -168,11 +183,7 @@ boolean M_TextInputHandle(textinput_t *input, INT32 key)
|
||||
}
|
||||
else if (key == 'v' || key == 'V')
|
||||
{
|
||||
const char *paste = I_ClipboardPaste();
|
||||
if (input->select != input->cursor)
|
||||
M_TextInputDelSelection(input);
|
||||
if (paste != NULL)
|
||||
M_TextInputAddString(input, paste);
|
||||
M_TextInputPaste(input);
|
||||
return true;
|
||||
}
|
||||
else if (key == 'w' || key == 'W')
|
||||
|
||||
+8
-1
@@ -286,7 +286,14 @@ mobj_t *P_SPMAngle(mobj_t *source, mobjtype_t type, angle_t angle, UINT8 aimtype
|
||||
#ifdef SEENAMES
|
||||
#define P_SpawnNameFinder(s,t) P_SPMAngle(s,t,s->angle,true,0)
|
||||
#endif
|
||||
SINT8 P_MobjFlip(const mobj_t *mobj);
|
||||
|
||||
// P_MobjFlip
|
||||
// Special utility to return +1 or -1 depending on mobj's gravity
|
||||
FUNCINLINE static ATTRINLINE SINT8 P_MobjFlip(const mobj_t *mobj)
|
||||
{
|
||||
return (mobj && mobj->eflags & MFE_VERTICALFLIP) ? -1 : 1;
|
||||
}
|
||||
|
||||
fixed_t P_GetMobjGravity(mobj_t *mo);
|
||||
FUNCMATH boolean P_WeaponOrPanel(mobjtype_t type);
|
||||
|
||||
|
||||
+44
-43
@@ -91,6 +91,7 @@ FUNCINLINE static ATTRINLINE void P_CycleStateAnimation(mobj_t *mobj)
|
||||
// var2 determines delay between animation frames
|
||||
if (!(mobj->frame & FF_ANIMATE) || --mobj->anim_duration != 0)
|
||||
return;
|
||||
|
||||
mobj->anim_duration = (UINT16)mobj->state->var2;
|
||||
|
||||
// compare the current sprite frame to the one we started from
|
||||
@@ -351,18 +352,6 @@ static boolean P_SetPrecipMobjState(precipmobj_t *mobj, statenum_t state)
|
||||
return true;
|
||||
}
|
||||
|
||||
//
|
||||
// P_MobjFlip
|
||||
//
|
||||
// Special utility to return +1 or -1 depending on mobj's gravity
|
||||
//
|
||||
SINT8 P_MobjFlip(const mobj_t *mobj)
|
||||
{
|
||||
if (mobj && mobj->eflags & MFE_VERTICALFLIP)
|
||||
return -1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
//
|
||||
// P_WeaponOrPanel
|
||||
//
|
||||
@@ -3230,77 +3219,86 @@ void P_DestroyRobots(void)
|
||||
}
|
||||
}
|
||||
|
||||
// P_CameraThinker
|
||||
//
|
||||
// Process the mobj-ish required functions of the camera
|
||||
boolean P_CameraThinker(player_t *player, camera_t *thiscam, boolean resetcalled)
|
||||
// the below is chasecam only, if you're curious. check out P_CalcPostImg in p_user.c for first person
|
||||
static void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
|
||||
{
|
||||
boolean flipcam = (player->pflags & PF_FLIPCAM && !(player->pflags & PF_NIGHTSMODE) && player->mo->eflags & MFE_VERTICALFLIP);
|
||||
postimg_t postimg = postimg_none;
|
||||
const boolean flipcam = (player->pflags & PF_FLIPCAM && !(player->pflags & PF_NIGHTSMODE) && player->mo->eflags & MFE_VERTICALFLIP);
|
||||
UINT16 postimgflags = 0;
|
||||
UINT8 i;
|
||||
|
||||
// This can happen when joining
|
||||
if (thiscam->subsector == NULL || thiscam->subsector->sector == NULL)
|
||||
return true;
|
||||
if (encoremode)
|
||||
postimgflags |= POSTIMG_MIRROR;
|
||||
if (flipcam)
|
||||
postimgflags |= POSTIMG_FLIP;
|
||||
|
||||
if (encoremode && !flipcam)
|
||||
postimg = postimg_mirror;
|
||||
else if (!encoremode && flipcam)
|
||||
postimg = postimg_flip;
|
||||
else if (encoremode && flipcam)
|
||||
postimg = postimg_mirrorflip;
|
||||
else if (player->awayviewtics && player->awayviewmobj && !P_MobjWasRemoved(player->awayviewmobj)) // Camera must obviously exist
|
||||
if (player->awayviewtics && player->awayviewmobj && !P_MobjWasRemoved(player->awayviewmobj)) // Camera must obviously exist
|
||||
{
|
||||
camera_t dummycam;
|
||||
|
||||
dummycam.subsector = player->awayviewmobj->subsector;
|
||||
dummycam.x = player->awayviewmobj->x;
|
||||
dummycam.y = player->awayviewmobj->y;
|
||||
dummycam.z = player->awayviewmobj->z;
|
||||
//dummycam.height = 40*FRACUNIT; // alt view height is 20*FRACUNIT
|
||||
dummycam.height = 0; // Why? Remote viewpoint cameras have no height.
|
||||
|
||||
// Are we in water?
|
||||
if (P_CameraCheckWater(&dummycam))
|
||||
postimg = postimg_water;
|
||||
else if (P_CameraCheckHeat(&dummycam))
|
||||
postimg = postimg_heat;
|
||||
postimgflags |= POSTIMG_WATER;
|
||||
if (P_CameraCheckHeat(&dummycam))
|
||||
postimgflags |= POSTIMG_HEAT;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Are we in water?
|
||||
if (P_CameraCheckWater(thiscam))
|
||||
postimg = postimg_water;
|
||||
else if (P_CameraCheckHeat(thiscam))
|
||||
postimg = postimg_heat;
|
||||
postimgflags |= POSTIMG_WATER;
|
||||
if (P_CameraCheckHeat(thiscam))
|
||||
postimgflags |= POSTIMG_HEAT;
|
||||
}
|
||||
|
||||
if (postimg != postimg_none)
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (player != &players[displayplayers[i]])
|
||||
continue;
|
||||
if (player != &players[displayplayers[i]])
|
||||
continue;
|
||||
|
||||
postimgtype[i] = postimg;
|
||||
}
|
||||
players[displayplayers[i]].postimgflags = postimgflags;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// P_CameraThinker
|
||||
//
|
||||
// Process the mobj-ish required functions of the camera
|
||||
boolean P_CameraThinker(player_t *player, camera_t *thiscam, boolean resetcalled)
|
||||
{
|
||||
// This can happen when joining
|
||||
if (thiscam->subsector == NULL || thiscam->subsector->sector == NULL)
|
||||
return true;
|
||||
|
||||
P_CalcChasePostImg(player, thiscam);
|
||||
|
||||
if (thiscam->momx || thiscam->momy)
|
||||
{
|
||||
if (!P_TryCameraMove(thiscam->x + thiscam->momx, thiscam->y + thiscam->momy, thiscam))
|
||||
{ // Never fails for 2D mode.
|
||||
if (!P_TryCameraMove(thiscam->x + thiscam->momx, thiscam->y + thiscam->momy, thiscam)) // Never fails for 2D mode.
|
||||
{
|
||||
mobj_t dummy;
|
||||
|
||||
dummy.thinker.function.acp1 = (actionf_p1)P_MobjThinker;
|
||||
dummy.subsector = thiscam->subsector;
|
||||
dummy.x = thiscam->x;
|
||||
dummy.y = thiscam->y;
|
||||
dummy.z = thiscam->z;
|
||||
dummy.height = thiscam->height;
|
||||
|
||||
if (player->pflags & PF_TIMEOVER)
|
||||
player->kartstuff[k_timeovercam] = (2*TICRATE)+1;
|
||||
|
||||
if (!resetcalled && !(player->pflags & PF_NOCLIP || leveltime < introtime) && !P_CheckSight(&dummy, player->mo)) // TODO: "P_CheckCameraSight" instead.
|
||||
P_ResetCamera(player, thiscam);
|
||||
else
|
||||
P_SlideCameraMove(thiscam);
|
||||
|
||||
if (resetcalled) // Okay this means the camera is fully reset.
|
||||
return true;
|
||||
}
|
||||
@@ -6883,6 +6881,9 @@ void P_MobjThinker(mobj_t *mobj)
|
||||
// separate thinker
|
||||
if (mobj->flags & MF_PUSHABLE || (mobj->info->flags & MF_PUSHABLE && mobj->fuse))
|
||||
{
|
||||
if (!mobj)
|
||||
return;
|
||||
|
||||
P_MobjCheckWater(mobj);
|
||||
P_PushableThinker(mobj);
|
||||
|
||||
|
||||
+7
-10
@@ -411,7 +411,7 @@ void P_UpdateSegLightOffset(seg_t *li)
|
||||
// Loads the SEGS resource from a level.
|
||||
static void P_LoadRawSegs(UINT8 *data)
|
||||
{
|
||||
INT32 linedef, side;
|
||||
INT32 rawlinedef, rawside;
|
||||
mapseg_t *ml = (mapseg_t*)data;
|
||||
seg_t *li = segs;
|
||||
line_t *ldef;
|
||||
@@ -431,14 +431,14 @@ static void P_LoadRawSegs(UINT8 *data)
|
||||
|
||||
li->angle = (SHORT(ml->angle))<<FRACBITS;
|
||||
li->offset = (SHORT(ml->offset))<<FRACBITS;
|
||||
linedef = SHORT(ml->linedef);
|
||||
ldef = &lines[linedef];
|
||||
rawlinedef = SHORT(ml->linedef);
|
||||
ldef = &lines[rawlinedef];
|
||||
li->linedef = ldef;
|
||||
li->side = side = SHORT(ml->side);
|
||||
li->sidedef = &sides[ldef->sidenum[side]];
|
||||
li->frontsector = sides[ldef->sidenum[side]].sector;
|
||||
li->side = rawside = SHORT(ml->side);
|
||||
li->sidedef = &sides[ldef->sidenum[rawside]];
|
||||
li->frontsector = sides[ldef->sidenum[rawside]].sector;
|
||||
if (ldef->flags & ML_TWOSIDED)
|
||||
li->backsector = sides[ldef->sidenum[side^1]].sector;
|
||||
li->backsector = sides[ldef->sidenum[rawside^1]].sector;
|
||||
else
|
||||
li->backsector = 0;
|
||||
|
||||
@@ -2481,9 +2481,6 @@ boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate)
|
||||
|
||||
P_LevelInitStuff(reloadinggamestate);
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
postimgtype[i] = postimg_none;
|
||||
|
||||
if (mapheaderinfo[gamemap-1]->forcecharacter[0] != '\0'
|
||||
&& atoi(mapheaderinfo[gamemap-1]->forcecharacter) != 255)
|
||||
P_ForceCharacter(mapheaderinfo[gamemap-1]->forcecharacter);
|
||||
|
||||
@@ -480,9 +480,6 @@ void P_Ticker(boolean run)
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
postimgtype[i] = postimg_none;
|
||||
|
||||
P_MapStart();
|
||||
|
||||
if (run)
|
||||
@@ -718,9 +715,6 @@ void P_PreTicker(INT32 frames)
|
||||
INT32 i;
|
||||
ticcmd_t temptic;
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
postimgtype[i] = postimg_none;
|
||||
|
||||
hook_defrosting = frames;
|
||||
|
||||
while (hook_defrosting)
|
||||
|
||||
+26
-27
@@ -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_opengl && cv_glfovchange.value)
|
||||
{
|
||||
fixed_t speed;
|
||||
const fixed_t runnyspeed = 20*FRACUNIT;
|
||||
@@ -3871,11 +3871,12 @@ boolean P_SpectatorJoinGame(player_t *player)
|
||||
return false;
|
||||
}
|
||||
|
||||
// the below is first person only, if you're curious. check out P_CalcChasePostImg in p_mobj.c for chasecam
|
||||
static void P_CalcPostImg(player_t *player)
|
||||
{
|
||||
sector_t *sector = player->mo->subsector->sector;
|
||||
postimg_t *type = NULL;
|
||||
INT32 *param;
|
||||
INT16 typeflag = 0;
|
||||
//INT32 *param;
|
||||
fixed_t pviewheight;
|
||||
UINT8 i;
|
||||
|
||||
@@ -3890,20 +3891,19 @@ static void P_CalcPostImg(player_t *player)
|
||||
pviewheight = player->awayviewmobj->z + 20*FRACUNIT;
|
||||
}
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
/*for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (player == &players[displayplayers[i]])
|
||||
{
|
||||
type = &postimgtype[i];
|
||||
param = &postimgparam[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}*/
|
||||
|
||||
// see if we are in heat (no, not THAT kind of heat...)
|
||||
|
||||
if (P_FindSpecialLineFromTag(13, sector->tag, -1) != -1)
|
||||
*type = postimg_heat;
|
||||
typeflag |= POSTIMG_HEAT;
|
||||
else if (sector->ffloors)
|
||||
{
|
||||
ffloor_t *rover;
|
||||
@@ -3922,7 +3922,7 @@ static void P_CalcPostImg(player_t *player)
|
||||
continue;
|
||||
|
||||
if (P_FindSpecialLineFromTag(13, rover->master->frontsector->tag, -1) != -1)
|
||||
*type = postimg_heat;
|
||||
typeflag |= POSTIMG_HEAT;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3944,36 +3944,35 @@ static void P_CalcPostImg(player_t *player)
|
||||
if (pviewheight >= topheight || pviewheight <= bottomheight)
|
||||
continue;
|
||||
|
||||
*type = postimg_water;
|
||||
typeflag |= POSTIMG_WATER;
|
||||
}
|
||||
}
|
||||
|
||||
if (!encoremode) // srb2kart
|
||||
{
|
||||
if (player->mo->eflags & MFE_VERTICALFLIP)
|
||||
*type = postimg_flip;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (player->mo->eflags & MFE_VERTICALFLIP)
|
||||
*type = postimg_mirrorflip;
|
||||
else
|
||||
*type = postimg_mirror;
|
||||
}
|
||||
if (encoremode) // srb2kart
|
||||
typeflag |= POSTIMG_MIRROR;
|
||||
|
||||
if (player->mo->eflags & MFE_VERTICALFLIP)
|
||||
typeflag |= POSTIMG_FLIP;
|
||||
|
||||
#if 1
|
||||
(void)param;
|
||||
#else
|
||||
// Motion blur
|
||||
if (player->speed > (35<<FRACBITS))
|
||||
// unused
|
||||
/*if (player->speed > (35<<FRACBITS))
|
||||
{
|
||||
*type = postimg_motion;
|
||||
typeflag |= POSTIMG_MOTION;
|
||||
*param = (player->speed - 32)/4;
|
||||
|
||||
if (*param > 5)
|
||||
*param = 5;
|
||||
}*/
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (player != &players[displayplayers[i]])
|
||||
continue;
|
||||
|
||||
players[displayplayers[i]].postimgflags = typeflag;
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void P_DoTimeOver(player_t *player)
|
||||
|
||||
+4
-4
@@ -15,6 +15,8 @@
|
||||
#include "g_game.h"
|
||||
#include "r_local.h"
|
||||
#include "r_state.h"
|
||||
#include "r_portal.h" // Add seg portals
|
||||
|
||||
|
||||
#include "r_splats.h"
|
||||
#include "p_local.h" // camera
|
||||
@@ -28,7 +30,6 @@ side_t *sidedef;
|
||||
line_t *linedef;
|
||||
sector_t *frontsector;
|
||||
sector_t *backsector;
|
||||
portal_pair *g_portal; // is curline a portal seg?
|
||||
|
||||
// very ugly realloc() of drawsegs at run-time, I upped it to 512
|
||||
// instead of 256.. and someone managed to send me a level with
|
||||
@@ -486,7 +487,7 @@ static void R_AddLine(seg_t *line)
|
||||
line2 = P_FindSpecialLineFromTag(40, line->linedef->tag, line2);
|
||||
if (line2 >= 0) // found it!
|
||||
{
|
||||
R_AddPortal(line->linedef-lines, line2, x1, x2); // Remember the lines for later rendering
|
||||
Portal_Add2Lines(line->linedef-lines, line2, x1, x2); // Remember the lines for later rendering
|
||||
//return; // Don't fill in that space now!
|
||||
goto clipsolid;
|
||||
}
|
||||
@@ -1319,8 +1320,7 @@ void R_RenderBSPNode(INT32 bspnum)
|
||||
bsp = &nodes[bspnum];
|
||||
|
||||
// Decide which side the view point is on.
|
||||
side = R_PointOnSideRender(viewx, viewy, bsp);
|
||||
|
||||
side = R_PointOnSide(viewx, viewy, bsp);
|
||||
// Recursively divide front space.
|
||||
R_RenderBSPNode(bsp->children[side]);
|
||||
|
||||
|
||||
+2
-2
@@ -25,7 +25,8 @@ extern side_t *sidedef;
|
||||
extern line_t *linedef;
|
||||
extern sector_t *frontsector;
|
||||
extern sector_t *backsector;
|
||||
extern portal_pair *g_portal; // is curline a portal seg?
|
||||
typedef struct portal_s portal_t;
|
||||
extern portal_t *g_portal; // is curline a portal seg?
|
||||
|
||||
// drawsegs are allocated on the fly... see r_segs.c
|
||||
|
||||
@@ -41,7 +42,6 @@ void R_ClearClipSegs(void);
|
||||
void R_PortalClearClipSegs(INT32 start, INT32 end);
|
||||
void R_ClearDrawSegs(void);
|
||||
void R_RenderBSPNode(INT32 bspnum);
|
||||
void R_AddPortal(INT32 line1, INT32 line2, INT32 x1, INT32 x2);
|
||||
|
||||
// determines when a given sector shouldn't abide by the encoremap's palette.
|
||||
// no longer a static since this is used for encore in hw_main.c as well now:
|
||||
|
||||
+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
|
||||
)
|
||||
{
|
||||
@@ -331,7 +331,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);
|
||||
|
||||
+39
-126
@@ -31,6 +31,7 @@
|
||||
#include "p_spec.h" // skyboxmo
|
||||
#include "z_zone.h"
|
||||
#include "m_random.h" // quake camera shake
|
||||
#include "r_portal.h"
|
||||
#include "doomstat.h" // MAXSPLITSCREENPLAYERS
|
||||
#include "r_fps.h" // Frame interpolation/uncapped
|
||||
#include "tables.h"
|
||||
@@ -66,14 +67,6 @@ boolean skyVisiblePerPlayer[MAXSPLITSCREENPLAYERS]; // saved values of skyVisibl
|
||||
sector_t *viewsector;
|
||||
player_t *viewplayer;
|
||||
|
||||
// PORTALS!
|
||||
// You can thank and/or curse JTE for these.
|
||||
UINT8 portalrender;
|
||||
sector_t *portalcullsector;
|
||||
portal_pair *portal_base, *portal_cap;
|
||||
line_t *portalclipline;
|
||||
INT32 portalclipstart, portalclipend;
|
||||
|
||||
fixed_t rendertimefrac;
|
||||
fixed_t rendertimefrac_unpaused;
|
||||
fixed_t renderdeltatics;
|
||||
@@ -200,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};
|
||||
|
||||
@@ -1317,112 +1310,30 @@ void R_SetupFrame(int s, boolean skybox)
|
||||
}
|
||||
}
|
||||
|
||||
#define ANGLED_PORTALS
|
||||
|
||||
static void R_PortalFrame(line_t *start, line_t *dest, portal_pair *portal)
|
||||
static void R_PortalFrame(portal_t *portal)
|
||||
{
|
||||
vertex_t dest_c, start_c;
|
||||
#ifdef ANGLED_PORTALS
|
||||
// delta angle
|
||||
angle_t dangle = R_PointToAngle2(0,0,dest->dx,dest->dy) - R_PointToAngle2(start->dx,start->dy,0,0);
|
||||
#endif
|
||||
|
||||
//R_SetupFrame(player, false);
|
||||
viewx = portal->viewx;
|
||||
viewy = portal->viewy;
|
||||
viewz = portal->viewz;
|
||||
|
||||
viewangle = portal->viewangle;
|
||||
// newview->sin = FINESINE(newview->angle>>ANGLETOFINESHIFT);
|
||||
// newview->cos = FINECOSINE(newview->angle>>ANGLETOFINESHIFT);
|
||||
// viewsin = FINESINE(viewangle>>ANGLETOFINESHIFT);
|
||||
// viewcos = FINECOSINE(viewangle>>ANGLETOFINESHIFT);
|
||||
|
||||
portalcullsector = dest->frontsector;
|
||||
viewsector = dest->frontsector;
|
||||
portalclipline = dest;
|
||||
portalclipstart = portal->start;
|
||||
portalclipend = portal->end;
|
||||
|
||||
// Offset the portal view by the linedef centers
|
||||
|
||||
// looking glass center
|
||||
start_c.x = (start->v1->x + start->v2->x) / 2;
|
||||
start_c.y = (start->v1->y + start->v2->y) / 2;
|
||||
|
||||
// other side center
|
||||
dest_c.x = (dest->v1->x + dest->v2->x) / 2;
|
||||
dest_c.y = (dest->v1->y + dest->v2->y) / 2;
|
||||
|
||||
// Heights!
|
||||
viewz += dest->frontsector->floorheight - start->frontsector->floorheight;
|
||||
|
||||
// calculate the difference in position and rotation!
|
||||
#ifdef ANGLED_PORTALS
|
||||
if (dangle == 0)
|
||||
#endif
|
||||
{ // the entrance goes straight opposite the exit, so we just need to mess with the offset.
|
||||
viewx += dest_c.x - start_c.x;
|
||||
viewy += dest_c.y - start_c.y;
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef ANGLED_PORTALS
|
||||
viewangle += dangle;
|
||||
// newview->sin = FINESINE(newview->angle>>ANGLETOFINESHIFT);
|
||||
// newview->cos = FINECOSINE(newview->angle>>ANGLETOFINESHIFT);
|
||||
//CONS_Printf("dangle == %u\n", AngleFixed(dangle)>>FRACBITS);
|
||||
|
||||
// ????
|
||||
if (portal->clipline != -1)
|
||||
{
|
||||
fixed_t disttopoint;
|
||||
angle_t angtopoint;
|
||||
|
||||
disttopoint = R_PointToDist2(start_c.x, start_c.y, newview->x, newview->y);
|
||||
angtopoint = R_PointToAngle2(start_c.x, start_c.y, newview->x, newview->y);
|
||||
angtopoint += dangle;
|
||||
|
||||
viewx = dest_c.x+FixedMul(FINECOSINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
|
||||
viewy = dest_c.y+FixedMul(FINESINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void R_AddPortal(INT32 line1, INT32 line2, INT32 x1, INT32 x2)
|
||||
{
|
||||
portal_pair *portal = Z_Malloc(sizeof(portal_pair), PU_LEVEL, NULL);
|
||||
INT16 *ceilingclipsave = Z_Malloc(sizeof(INT16)*(x2-x1), PU_LEVEL, NULL);
|
||||
INT16 *floorclipsave = Z_Malloc(sizeof(INT16)*(x2-x1), PU_LEVEL, NULL);
|
||||
fixed_t *frontscalesave = Z_Malloc(sizeof(fixed_t)*(x2-x1), PU_LEVEL, NULL);
|
||||
|
||||
portal->line1 = line1;
|
||||
portal->line2 = line2;
|
||||
portal->pass = portalrender+1;
|
||||
portal->next = NULL;
|
||||
|
||||
R_PortalStoreClipValues(x1, x2, ceilingclipsave, floorclipsave, frontscalesave);
|
||||
|
||||
portal->ceilingclip = ceilingclipsave;
|
||||
portal->floorclip = floorclipsave;
|
||||
portal->frontscale = frontscalesave;
|
||||
|
||||
portal->start = x1;
|
||||
portal->end = x2;
|
||||
|
||||
g_portal = portal; // this tells R_StoreWallRange that curline is a portal seg
|
||||
|
||||
portal->viewx = viewx;
|
||||
portal->viewy = viewy;
|
||||
portal->viewz = viewz;
|
||||
portal->viewangle = viewangle;
|
||||
|
||||
if (!portal_base)
|
||||
{
|
||||
portal_base = portal;
|
||||
portal_cap = portal;
|
||||
portalclipline = &lines[portal->clipline];
|
||||
portalcullsector = portalclipline->frontsector;
|
||||
viewsector = portalclipline->frontsector;
|
||||
}
|
||||
else
|
||||
{
|
||||
portal_cap->next = portal;
|
||||
portal_cap = portal;
|
||||
portalclipline = NULL;
|
||||
portalcullsector = NULL;
|
||||
viewsector = R_PointInSubsector(viewx, viewy)->sector;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1438,7 +1349,6 @@ void R_AddPortal(INT32 line1, INT32 line2, INT32 x1, INT32 x2)
|
||||
|
||||
void R_RenderPlayerView(player_t *player)
|
||||
{
|
||||
portal_pair *portal;
|
||||
const boolean skybox = (skyboxmo[0] && cv_skybox.value);
|
||||
UINT8 i;
|
||||
|
||||
@@ -1475,8 +1385,7 @@ void R_RenderPlayerView(player_t *player)
|
||||
break;
|
||||
}
|
||||
|
||||
portalrender = 0;
|
||||
portal_base = portal_cap = NULL;
|
||||
Portal_InitList();
|
||||
|
||||
PS_START_TIMING(ps_skyboxtime);
|
||||
if (skybox && skyVisible)
|
||||
@@ -1541,37 +1450,41 @@ void R_RenderPlayerView(player_t *player)
|
||||
|
||||
ps_numsprites.value.i = numvisiblesprites;
|
||||
|
||||
// PORTAL RENDERING
|
||||
PS_START_TIMING(ps_sw_portaltime);
|
||||
for(portal = portal_base; portal; portal = portal_base)
|
||||
// Portal rendering. Hijacks the BSP traversal.
|
||||
if (portal_base)
|
||||
{
|
||||
// render the portal
|
||||
CONS_Debug(DBG_RENDER, "Rendering portal from line %d to %d\n", portal->line1, portal->line2);
|
||||
portalrender = portal->pass;
|
||||
portal_t *portal;
|
||||
|
||||
R_PortalFrame(&lines[portal->line1], &lines[portal->line2], portal);
|
||||
for (portal = portal_base; portal; portal = portal_base)
|
||||
{
|
||||
portalrender = portal->pass; // Recursiveness depth.
|
||||
|
||||
R_PortalClearClipSegs(portal->start, portal->end);
|
||||
R_ClearFFloorClips();
|
||||
|
||||
R_PortalRestoreClipValues(portal->start, portal->end, portal->ceilingclip, portal->floorclip, portal->frontscale);
|
||||
// Apply the viewpoint stored for the portal.
|
||||
R_PortalFrame(portal);
|
||||
|
||||
validcount++;
|
||||
// Hack in the clipsegs to delimit the starting
|
||||
// clipping for sprites and possibly other similar
|
||||
// future items.
|
||||
R_PortalClearClipSegs(portal->start, portal->end);
|
||||
|
||||
R_RenderBSPNode((INT32)numnodes - 1);
|
||||
R_ClipSprites();
|
||||
//R_DrawPlanes();
|
||||
//R_DrawMasked();
|
||||
// Hack in the top/bottom clip values for the window
|
||||
// that were previously stored.
|
||||
Portal_ClipApply(portal);
|
||||
|
||||
// okay done. free it.
|
||||
portalcullsector = NULL; // Just in case...
|
||||
portal_base = portal->next;
|
||||
Z_Free(portal->ceilingclip);
|
||||
Z_Free(portal->floorclip);
|
||||
Z_Free(portal->frontscale);
|
||||
Z_Free(portal);
|
||||
// Render the BSP from the new viewpoint, and clip
|
||||
// any sprites with the new clipsegs and window.
|
||||
R_RenderBSPNode((INT32)numnodes - 1);
|
||||
R_ClipSprites();
|
||||
|
||||
Portal_Remove(portal);
|
||||
|
||||
validcount++;
|
||||
}
|
||||
}
|
||||
PS_STOP_TIMING(ps_sw_portaltime);
|
||||
// END PORTAL RENDERING
|
||||
|
||||
PS_START_TIMING(ps_sw_planetime);
|
||||
R_DrawPlanes();
|
||||
@@ -1668,7 +1581,7 @@ void R_RegisterEngineStuff(void)
|
||||
|
||||
CV_RegisterVar(&cv_maxportals);
|
||||
|
||||
CV_RegisterVar(&cv_grmaxinterpdist);
|
||||
CV_RegisterVar(&cv_maxinterpdist);
|
||||
|
||||
CV_RegisterVar(&cv_ripplewater);
|
||||
|
||||
|
||||
+1
-28
@@ -74,12 +74,6 @@ extern lighttable_t *zlight[LIGHTLEVELS][MAXLIGHTZ];
|
||||
// Utility functions.
|
||||
INT32 R_PointOnSide(fixed_t x, fixed_t y, const node_t *node);
|
||||
|
||||
FUNCINLINE static ATTRINLINE PUREFUNC INT32 R_PointOnSideRender(fixed_t x, fixed_t y, const node_t *node)
|
||||
{
|
||||
// use cross product to determine side quickly
|
||||
return (INT64)(y - node->y) * node->dx - (INT64)(x - node->x) * node->dy > 0;
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE PUREFUNC INT32 R_PointOnSegSide(fixed_t x, fixed_t y, const seg_t *line)
|
||||
{
|
||||
fixed_t lx = line->v1->x;
|
||||
@@ -107,27 +101,6 @@ subsector_t *R_IsPointInSubsector(fixed_t x, fixed_t y);
|
||||
boolean R_DoCulling(line_t *cullheight, line_t *viewcullheight, fixed_t vz, fixed_t bottomh, fixed_t toph);
|
||||
void R_GetRenderBlockMapDimensions(fixed_t drawdist, INT32 *xl, INT32 *xh, INT32 *yl, INT32 *yh);
|
||||
|
||||
|
||||
typedef struct portal_pair
|
||||
{
|
||||
INT32 line1;
|
||||
INT32 line2;
|
||||
UINT8 pass;
|
||||
struct portal_pair *next;
|
||||
|
||||
fixed_t viewx;
|
||||
fixed_t viewy;
|
||||
fixed_t viewz;
|
||||
angle_t viewangle;
|
||||
|
||||
INT32 start;
|
||||
INT32 end;
|
||||
INT16 *ceilingclip;
|
||||
INT16 *floorclip;
|
||||
fixed_t *frontscale;
|
||||
} portal_pair;
|
||||
|
||||
|
||||
// Performance stats
|
||||
extern precise_t ps_prevframetime;// time when previous frame was rendered
|
||||
extern ps_metric_t ps_rendercalltime;
|
||||
@@ -163,7 +136,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.
|
||||
|
||||
+5
-5
@@ -775,11 +775,11 @@ static UINT16 GetPatchPixel(patch_t *patch, INT32 x, INT32 y, boolean flip)
|
||||
#ifdef HWRENDER
|
||||
static patch_t *R_CreateHardwarePatch(patch_t *patch)
|
||||
{
|
||||
GLPatch_t *grPatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL);
|
||||
grPatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
grPatch->rawpatch = patch;
|
||||
HWR_MakePatch(patch, grPatch, grPatch->mipmap, false);
|
||||
return (patch_t *)grPatch;
|
||||
GLPatch_t *glPatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL);
|
||||
glPatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, NULL);
|
||||
glPatch->rawpatch = patch;
|
||||
HWR_MakePatch(patch, glPatch, glPatch->mipmap, false);
|
||||
return (patch_t *)glPatch;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
+18
-50
@@ -28,6 +28,7 @@
|
||||
#include "z_zone.h"
|
||||
#include "p_tick.h"
|
||||
#include "r_fps.h"
|
||||
#include "r_portal.h"
|
||||
|
||||
//
|
||||
// opening
|
||||
@@ -39,12 +40,6 @@
|
||||
// good night sweet prince
|
||||
//#define SHITPLANESPARENCY
|
||||
|
||||
//SoM: 3/23/2000: Use Boom visplane hashing.
|
||||
#define VISPLANEHASHBITS 9
|
||||
#define VISPLANEHASHMASK ((1<<VISPLANEHASHBITS)-1)
|
||||
// the last visplane list is outside of the hash table and is used for fof planes
|
||||
#define MAXVISPLANES ((1<<VISPLANEHASHBITS)+1)
|
||||
|
||||
static visplane_t *visplanes[MAXVISPLANES];
|
||||
static visplane_t *freetail;
|
||||
static visplane_t **freehead = &freetail;
|
||||
@@ -112,50 +107,6 @@ void R_InitPlanes(void)
|
||||
// FIXME: unused
|
||||
}
|
||||
|
||||
// R_PortalStoreClipValues
|
||||
// Saves clipping values for later. -Red
|
||||
void R_PortalStoreClipValues(INT32 start, INT32 end, INT16 *ceil, INT16 *floor, fixed_t *scale)
|
||||
{
|
||||
INT32 i;
|
||||
for (i = 0; i < end-start; i++)
|
||||
{
|
||||
*ceil = ceilingclip[start+i];
|
||||
ceil++;
|
||||
*floor = floorclip[start+i];
|
||||
floor++;
|
||||
*scale = frontscale[start+i];
|
||||
scale++;
|
||||
}
|
||||
}
|
||||
|
||||
// R_PortalRestoreClipValues
|
||||
// Inverse of the above. Restores the old value!
|
||||
void R_PortalRestoreClipValues(INT32 start, INT32 end, INT16 *ceil, INT16 *floor, fixed_t *scale)
|
||||
{
|
||||
INT32 i;
|
||||
for (i = 0; i < end-start; i++)
|
||||
{
|
||||
ceilingclip[start+i] = *ceil;
|
||||
ceil++;
|
||||
floorclip[start+i] = *floor;
|
||||
floor++;
|
||||
frontscale[start+i] = *scale;
|
||||
scale++;
|
||||
}
|
||||
|
||||
// HACKS FOLLOW
|
||||
for (i = 0; i < start; i++)
|
||||
{
|
||||
floorclip[i] = -1;
|
||||
ceilingclip[i] = (INT16)viewheight;
|
||||
}
|
||||
for (i = end; i < vid.width; i++)
|
||||
{
|
||||
floorclip[i] = -1;
|
||||
ceilingclip[i] = (INT16)viewheight;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Water ripple effect!!
|
||||
// Needs the height of the plane, and the vertical position of the span.
|
||||
@@ -307,6 +258,23 @@ void R_MapPlane(INT32 y, INT32 x1, INT32 x2)
|
||||
spanfunc();
|
||||
}
|
||||
|
||||
void R_ClearFFloorClips (void)
|
||||
{
|
||||
INT32 i, p;
|
||||
|
||||
// opening / clipping determination
|
||||
for (i = 0; i < viewwidth; i++)
|
||||
{
|
||||
for (p = 0; p < MAXFFLOORS; p++)
|
||||
{
|
||||
ffloor[p].f_clip[i] = (INT16)viewheight;
|
||||
ffloor[p].c_clip[i] = -1;
|
||||
}
|
||||
}
|
||||
|
||||
numffloors = 0;
|
||||
}
|
||||
|
||||
//
|
||||
// R_ClearPlanes
|
||||
// At begining of frame.
|
||||
|
||||
+2
-2
@@ -18,6 +18,7 @@
|
||||
#include "r_data.h"
|
||||
#include "p_polyobj.h"
|
||||
|
||||
//SoM: 3/23/2000: Use Boom visplane hashing.
|
||||
#define VISPLANEHASHBITS 9
|
||||
#define VISPLANEHASHMASK ((1<<VISPLANEHASHBITS)-1)
|
||||
// the last visplane list is outside of the hash table and is used for fof planes
|
||||
@@ -75,9 +76,8 @@ extern fixed_t *yslope;
|
||||
extern lighttable_t **planezlight;
|
||||
|
||||
void R_InitPlanes(void);
|
||||
void R_PortalStoreClipValues(INT32 start, INT32 end, INT16 *ceil, INT16 *floor, fixed_t *scale);
|
||||
void R_PortalRestoreClipValues(INT32 start, INT32 end, INT16 *ceil, INT16 *floor, fixed_t *scale);
|
||||
void R_ClearPlanes(void);
|
||||
void R_ClearFFloorClips (void);
|
||||
|
||||
void R_MapPlane(INT32 y, INT32 x1, INT32 x2);
|
||||
void R_MakeSpans(INT32 x, INT32 t1, INT32 b1, INT32 t2, INT32 b2);
|
||||
|
||||
+193
@@ -0,0 +1,193 @@
|
||||
// SONIC ROBO BLAST 2 KART
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2024 by Kart Krew.
|
||||
// Copyright (C) 2020 by Sonic Team Junior.
|
||||
// Copyright (C) 2000 by DooM Legacy Team.
|
||||
// Copyright (C) 1996 by id Software, Inc.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
// See the 'LICENSE' file for more details.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file r_portal.c
|
||||
/// \brief Software renderer portals.
|
||||
|
||||
#include "r_portal.h"
|
||||
#include "r_plane.h"
|
||||
#include "r_main.h" // viewheight, viewwidth
|
||||
#include "z_zone.h"
|
||||
#include "r_things.h"
|
||||
#include "r_sky.h"
|
||||
|
||||
UINT8 portalrender; /**< When rendering a portal, it establishes the depth of the current BSP traversal. */
|
||||
|
||||
// Linked list for portals.
|
||||
portal_t *portal_base, *portal_cap;
|
||||
|
||||
line_t *portalclipline;
|
||||
sector_t *portalcullsector;
|
||||
INT32 portalclipstart, portalclipend;
|
||||
|
||||
portal_t *g_portal; // is curline a portal seg?
|
||||
|
||||
void Portal_InitList (void)
|
||||
{
|
||||
portalrender = 0;
|
||||
portal_base = portal_cap = NULL;
|
||||
}
|
||||
|
||||
|
||||
/** Store the clipping window for a portal in its given range.
|
||||
*
|
||||
* The window is copied from the current window at the time
|
||||
* the function is called, so it is useful for converting one-sided
|
||||
* lines into portals.
|
||||
*/
|
||||
static void Portal_ClipRange (portal_t* portal)
|
||||
{
|
||||
INT32 start = portal->start;
|
||||
INT32 end = portal->end;
|
||||
INT16 *ceil = portal->ceilingclip;
|
||||
INT16 *floor = portal->floorclip;
|
||||
fixed_t *scale = portal->frontscale;
|
||||
|
||||
INT32 i;
|
||||
for (i = 0; i < end-start; i++)
|
||||
{
|
||||
*ceil = ceilingclip[start+i];
|
||||
ceil++;
|
||||
*floor = floorclip[start+i];
|
||||
floor++;
|
||||
*scale = frontscale[start+i];
|
||||
scale++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** Apply the clipping window from a portal.
|
||||
*/
|
||||
void Portal_ClipApply (const portal_t* portal)
|
||||
{
|
||||
INT32 i;
|
||||
INT32 start = portal->start;
|
||||
INT32 end = portal->end;
|
||||
INT16 *ceil = portal->ceilingclip;
|
||||
INT16 *floor = portal->floorclip;
|
||||
fixed_t *scale = portal->frontscale;
|
||||
|
||||
for (i = 0; i < end-start; i++)
|
||||
{
|
||||
ceilingclip[start+i] = *ceil;
|
||||
ceil++;
|
||||
floorclip[start+i] = *floor;
|
||||
floor++;
|
||||
frontscale[start+i] = *scale;
|
||||
scale++;
|
||||
}
|
||||
|
||||
// HACKS FOLLOW
|
||||
for (i = 0; i < start; i++)
|
||||
{
|
||||
floorclip[i] = -1;
|
||||
ceilingclip[i] = (INT16)viewheight;
|
||||
}
|
||||
for (i = end; i < vid.width; i++)
|
||||
{
|
||||
floorclip[i] = -1;
|
||||
ceilingclip[i] = (INT16)viewheight;
|
||||
}
|
||||
}
|
||||
|
||||
static portal_t* Portal_Add (const INT16 x1, const INT16 x2)
|
||||
{
|
||||
portal_t *portal = Z_Malloc(sizeof(portal_t), PU_LEVEL, NULL);
|
||||
INT16 *ceilingclipsave = Z_Malloc(sizeof(INT16)*(x2-x1 + 1), PU_LEVEL, NULL);
|
||||
INT16 *floorclipsave = Z_Malloc(sizeof(INT16)*(x2-x1 + 1), PU_LEVEL, NULL);
|
||||
fixed_t *frontscalesave = Z_Malloc(sizeof(fixed_t)*(x2-x1 + 1), PU_LEVEL, NULL);
|
||||
|
||||
// Linked list.
|
||||
if (!portal_base)
|
||||
{
|
||||
portal_base = portal;
|
||||
portal_cap = portal;
|
||||
}
|
||||
else
|
||||
{
|
||||
portal_cap->next = portal;
|
||||
portal_cap = portal;
|
||||
}
|
||||
portal->next = NULL;
|
||||
|
||||
// Store clipping values so they can be restored once the portal is rendered.
|
||||
portal->ceilingclip = ceilingclipsave;
|
||||
portal->floorclip = floorclipsave;
|
||||
portal->frontscale = frontscalesave;
|
||||
portal->start = x1;
|
||||
portal->end = x2;
|
||||
|
||||
// Increase recursion level.
|
||||
portal->pass = portalrender+1;
|
||||
|
||||
return portal;
|
||||
}
|
||||
|
||||
void Portal_Remove (portal_t* portal)
|
||||
{
|
||||
portalcullsector = NULL;
|
||||
portal_base = portal->next;
|
||||
Z_Free(portal->ceilingclip);
|
||||
Z_Free(portal->floorclip);
|
||||
Z_Free(portal->frontscale);
|
||||
Z_Free(portal);
|
||||
}
|
||||
|
||||
/** Creates a portal out of two lines and a determined screen range.
|
||||
*
|
||||
* line1 determines the entrance, and line2 the exit.
|
||||
* x1 and x2 determine the screen's column bounds.
|
||||
|
||||
* The view's offset from the entry line center is obtained,
|
||||
* and then rotated&translated to the exit line's center.
|
||||
* When the portal renders, it will create the illusion of
|
||||
* the two lines being seamed together.
|
||||
*/
|
||||
void Portal_Add2Lines (const INT32 line1, const INT32 line2, const INT32 x1, const INT32 x2)
|
||||
{
|
||||
portal_t* portal = Portal_Add(x1, x2);
|
||||
|
||||
// Offset the portal view by the linedef centers
|
||||
line_t* start = &lines[line1];
|
||||
line_t* dest = &lines[line2];
|
||||
|
||||
angle_t dangle = R_PointToAngle2(0,0,dest->dx,dest->dy) - R_PointToAngle2(start->dx,start->dy,0,0);
|
||||
|
||||
fixed_t disttopoint;
|
||||
angle_t angtopoint;
|
||||
|
||||
vertex_t dest_c, start_c;
|
||||
|
||||
// looking glass center
|
||||
start_c.x = (start->v1->x + start->v2->x) / 2;
|
||||
start_c.y = (start->v1->y + start->v2->y) / 2;
|
||||
|
||||
// other side center
|
||||
dest_c.x = (dest->v1->x + dest->v2->x) / 2;
|
||||
dest_c.y = (dest->v1->y + dest->v2->y) / 2;
|
||||
|
||||
disttopoint = R_PointToDist2(start_c.x, start_c.y, viewx, viewy);
|
||||
angtopoint = R_PointToAngle2(start_c.x, start_c.y, viewx, viewy);
|
||||
angtopoint += dangle;
|
||||
|
||||
portal->viewx = dest_c.x + FixedMul(FINECOSINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
|
||||
portal->viewy = dest_c.y + FixedMul(FINESINE(angtopoint>>ANGLETOFINESHIFT), disttopoint);
|
||||
portal->viewz = viewz + dest->frontsector->floorheight - start->frontsector->floorheight;
|
||||
portal->viewangle = viewangle + dangle;
|
||||
|
||||
portal->clipline = line2;
|
||||
|
||||
Portal_ClipRange(portal);
|
||||
|
||||
g_portal = portal; // this tells R_StoreWallRange that curline is a portal seg
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
// Copyright (C) 1999-2018 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
// See the 'LICENSE' file for more details.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file r_portal.h
|
||||
/// \brief Software renderer portal struct, functions, linked list extern.
|
||||
|
||||
#ifndef __R_PORTAL__
|
||||
#define __R_PORTAL__
|
||||
|
||||
#include "r_data.h"
|
||||
|
||||
|
||||
/** Portal structure.
|
||||
*/
|
||||
typedef struct portal_s
|
||||
{
|
||||
struct portal_s *next;
|
||||
|
||||
// Viewport.
|
||||
fixed_t viewx;
|
||||
fixed_t viewy;
|
||||
fixed_t viewz;
|
||||
angle_t viewangle;
|
||||
|
||||
UINT8 pass; /**< Keeps track of the portal's recursion depth. */
|
||||
INT32 clipline; /**< Optional clipline for line-based portals. */
|
||||
|
||||
// Clipping information.
|
||||
INT32 start; /**< First horizontal pixel coordinate to draw at. */
|
||||
INT32 end; /**< Last horizontal pixel coordinate to draw at. */
|
||||
INT16 *ceilingclip; /**< Temporary screen top clipping array. */
|
||||
INT16 *floorclip; /**< Temporary screen bottom clipping array. */
|
||||
fixed_t *frontscale;/**< Temporary screen bottom clipping array. */
|
||||
} portal_t;
|
||||
|
||||
extern portal_t* portal_base;
|
||||
extern portal_t* portal_cap;
|
||||
extern UINT8 portalrender;
|
||||
|
||||
extern line_t *portalclipline;
|
||||
extern sector_t *portalcullsector;
|
||||
extern INT32 portalclipstart, portalclipend;
|
||||
|
||||
void Portal_InitList (void);
|
||||
void Portal_Remove (portal_t* portal);
|
||||
void Portal_Add2Lines (const INT32 line1, const INT32 line2, const INT32 x1, const INT32 x2);
|
||||
|
||||
void Portal_ClipApply (const portal_t* portal);
|
||||
|
||||
#endif
|
||||
@@ -15,6 +15,7 @@
|
||||
#include "r_local.h"
|
||||
#include "r_sky.h"
|
||||
|
||||
#include "r_portal.h"
|
||||
#include "r_splats.h"
|
||||
|
||||
#include "w_wad.h"
|
||||
|
||||
@@ -94,10 +94,6 @@ extern boolean viewsky, skyVisible;
|
||||
extern boolean skyVisiblePerPlayer[MAXSPLITSCREENPLAYERS]; // saved values of skyVisible of each splitscreen player
|
||||
extern sector_t *viewsector;
|
||||
extern player_t *viewplayer;
|
||||
extern UINT8 portalrender;
|
||||
extern sector_t *portalcullsector;
|
||||
extern line_t *portalclipline;
|
||||
extern INT32 portalclipstart, portalclipend;
|
||||
|
||||
extern consvar_t cv_allowmlook;
|
||||
extern consvar_t cv_maxportals;
|
||||
|
||||
+5
-4
@@ -31,6 +31,7 @@
|
||||
#include "dehacked.h" // get_number (for thok)
|
||||
#include "d_netfil.h" // blargh. for nameonly().
|
||||
#include "m_cheat.h" // objectplace
|
||||
#include "r_portal.h"
|
||||
#include "k_kart.h" // SRB2kart
|
||||
#include "p_local.h" // stplyr
|
||||
#ifdef HWRENDER
|
||||
@@ -1169,14 +1170,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);
|
||||
}
|
||||
@@ -1738,7 +1739,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
|
||||
@@ -1751,7 +1752,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
@@ -705,7 +705,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;
|
||||
|
||||
+7
-4
@@ -112,10 +112,11 @@ boolean LoadGL(void)
|
||||
|
||||
\return if true, changed video mode
|
||||
*/
|
||||
static boolean first_init = false;
|
||||
|
||||
boolean OglSdlSurface(INT32 w, INT32 h)
|
||||
{
|
||||
INT32 cbpp = cv_scr_depth.value < 16 ? 16 : cv_scr_depth.value;
|
||||
static boolean first_init = false;
|
||||
const char *gllogdir = NULL;
|
||||
|
||||
oglflags = 0;
|
||||
@@ -171,7 +172,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
|
||||
@@ -180,7 +181,6 @@ boolean OglSdlSurface(INT32 w, INT32 h)
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
first_init = true;
|
||||
|
||||
SDL_GL_SetSwapInterval(cv_vidwait.value ? 1 : 0);
|
||||
|
||||
@@ -214,9 +214,12 @@ boolean OglSdlSurface(INT32 w, INT32 h)
|
||||
GLFramebuffer_Disable();
|
||||
#endif
|
||||
|
||||
HWR_Startup();
|
||||
if (!first_init)
|
||||
HWR_Startup();
|
||||
textureformatGL = cbpp > 16 ? GL_RGBA : GL_RGB5_A1;
|
||||
|
||||
first_init = true;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
+60
-59
@@ -1112,7 +1112,7 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
|
||||
|
||||
if (x >= vid.width || y >= vid.height)
|
||||
return; // off the screen
|
||||
|
||||
|
||||
if (x < 0)
|
||||
{
|
||||
w += x;
|
||||
@@ -1126,7 +1126,7 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
|
||||
|
||||
if (w <= 0 || h <= 0)
|
||||
return; // zero width/height wouldn't draw anything
|
||||
|
||||
|
||||
if (x + w > vid.width)
|
||||
w = vid.width-x;
|
||||
if (y + h > vid.height)
|
||||
@@ -1149,7 +1149,7 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
|
||||
}
|
||||
|
||||
c &= 255;
|
||||
|
||||
|
||||
if (alphalevel)
|
||||
{
|
||||
const UINT8 *fadetable = ((UINT8 *)transtables + ((alphalevel-1)<<FF_TRANSSHIFT) + (c*256));
|
||||
@@ -2495,7 +2495,7 @@ void V_DrawThinStringAtFixed(fixed_t x, fixed_t y, INT32 option, const char *str
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
charflags = (option & V_CHARCOLORMASK);
|
||||
colormap = V_GetStringColormap(charflags);
|
||||
|
||||
@@ -3189,7 +3189,7 @@ INT32 heatindex[MAXSPLITSCREENPLAYERS] = {0, 0, 0, 0};
|
||||
// Perform a particular image postprocessing function.
|
||||
//
|
||||
|
||||
void V_DoPostProcessor(INT32 view, postimg_t type, INT32 param)
|
||||
void V_DoPostProcessor(INT32 view, player_t *player, INT32 param)
|
||||
{
|
||||
#if NUMSCREENS < 5
|
||||
// do not enable image post processing for ARM, SH and MIPS CPUs
|
||||
@@ -3197,6 +3197,7 @@ void V_DoPostProcessor(INT32 view, postimg_t type, INT32 param)
|
||||
(void)type;
|
||||
(void)param;
|
||||
#else
|
||||
(void)param; // unused motion blur stuff
|
||||
INT32 yoffset, xoffset;
|
||||
|
||||
#ifdef HWRENDER
|
||||
@@ -3207,6 +3208,9 @@ void V_DoPostProcessor(INT32 view, postimg_t type, INT32 param)
|
||||
if (view < 0 || view > 3 || view > splitscreen)
|
||||
return;
|
||||
|
||||
if (!player->postimgflags)
|
||||
return;
|
||||
|
||||
if ((view == 1 && splitscreen == 1) || view >= 2)
|
||||
yoffset = viewheight;
|
||||
else
|
||||
@@ -3217,10 +3221,11 @@ void V_DoPostProcessor(INT32 view, postimg_t type, INT32 param)
|
||||
else
|
||||
xoffset = 0;
|
||||
|
||||
if (type == postimg_water)
|
||||
UINT8 *tmpscr = screens[4];
|
||||
UINT8 *srcscr = screens[0];
|
||||
|
||||
if (player->postimgflags & POSTIMG_WATER)
|
||||
{
|
||||
UINT8 *tmpscr = screens[4];
|
||||
UINT8 *srcscr = screens[0];
|
||||
INT32 y;
|
||||
// Set disStart to a range from 0 to FINEANGLE, incrementing by 128 per tic
|
||||
angle_t disStart = (((leveltime-1)*128) + (rendertimefrac / (FRACUNIT/128))) & FINEMASK;
|
||||
@@ -3257,29 +3262,30 @@ void V_DoPostProcessor(INT32 view, postimg_t type, INT32 param)
|
||||
}
|
||||
|
||||
/*
|
||||
Unoptimized version
|
||||
for (x = 0; x < vid.width*vid.bpp; x++)
|
||||
{
|
||||
newpix = (x + sine);
|
||||
Unoptimized version
|
||||
for (x = 0; x < vid.width*vid.bpp; x++)
|
||||
{
|
||||
newpix = (x + sine);
|
||||
|
||||
if (newpix < 0)
|
||||
newpix = 0;
|
||||
else if (newpix >= vid.width)
|
||||
newpix = vid.width-1;
|
||||
if (newpix < 0)
|
||||
newpix = 0;
|
||||
else if (newpix >= vid.width)
|
||||
newpix = vid.width-1;
|
||||
|
||||
tmpscr[y*vid.width + x] = srcscr[y*vid.width+newpix]; // *(transme + (srcscr[y*vid.width+x]<<8) + srcscr[y*vid.width+newpix]);
|
||||
}*/
|
||||
|
||||
tmpscr[y*vid.width + x] = srcscr[y*vid.width+newpix]; // *(transme + (srcscr[y*vid.width+x]<<8) + srcscr[y*vid.width+newpix]);
|
||||
}*/
|
||||
disStart += 22;//the offset into the displacement map, increment each game loop
|
||||
disStart &= FINEMASK; //clip it to FINEMASK
|
||||
}
|
||||
|
||||
VID_BlitLinearScreen(tmpscr+vid.width*vid.bpp*yoffset+xoffset, screens[0]+vid.width*vid.bpp*yoffset+xoffset,
|
||||
viewwidth*vid.bpp, viewheight, vid.width*vid.bpp, vid.width);
|
||||
UINT8 *tmp = tmpscr;
|
||||
tmpscr = srcscr;
|
||||
srcscr = tmp;
|
||||
}
|
||||
else if (type == postimg_motion) // Motion Blur!
|
||||
{
|
||||
UINT8 *tmpscr = screens[4];
|
||||
UINT8 *srcscr = screens[0];
|
||||
|
||||
/*if (player->postimgflags & POSTIMG_MOTION) // Motion Blur!
|
||||
{
|
||||
INT32 x, y;
|
||||
|
||||
// TODO: Add a postimg_param so that we can pick the translucency level...
|
||||
@@ -3288,30 +3294,12 @@ void V_DoPostProcessor(INT32 view, postimg_t type, INT32 param)
|
||||
for (y = yoffset; y < yoffset+viewheight; y++)
|
||||
{
|
||||
for (x = xoffset; x < xoffset+viewwidth; x++)
|
||||
{
|
||||
tmpscr[y*vid.width + x]
|
||||
= colormaps[*(transme + (srcscr [(y*vid.width)+x ] <<8) + (tmpscr[(y*vid.width)+x]))];
|
||||
}
|
||||
tmpscr[y*vid.width + x] = colormaps[*(transme + (srcscr [(y*vid.width)+x ] <<8) + (tmpscr[(y*vid.width)+x]))];
|
||||
}
|
||||
VID_BlitLinearScreen(tmpscr+vid.width*vid.bpp*yoffset+xoffset, screens[0]+vid.width*vid.bpp*yoffset+xoffset,
|
||||
viewwidth*vid.bpp, viewheight, vid.width*vid.bpp, vid.width);
|
||||
}
|
||||
else if (type == postimg_flip) // Flip the screen upside-down
|
||||
{
|
||||
UINT8 *tmpscr = screens[4];
|
||||
UINT8 *srcscr = screens[0];
|
||||
INT32 y, y2;
|
||||
}*/
|
||||
|
||||
for (y = yoffset, y2 = yoffset+viewheight - 1; y < yoffset+viewheight; y++, y2--)
|
||||
M_Memcpy(&tmpscr[(y2*vid.width)+xoffset], &srcscr[(y*vid.width)+xoffset], viewwidth);
|
||||
|
||||
VID_BlitLinearScreen(tmpscr+vid.width*vid.bpp*yoffset+xoffset, screens[0]+vid.width*vid.bpp*yoffset+xoffset,
|
||||
viewwidth*vid.bpp, viewheight, vid.width*vid.bpp, vid.width);
|
||||
}
|
||||
else if (type == postimg_heat) // Heat wave
|
||||
if (player->postimgflags & POSTIMG_HEAT) // Heat wave
|
||||
{
|
||||
UINT8 *tmpscr = screens[4];
|
||||
UINT8 *srcscr = screens[0];
|
||||
INT32 y;
|
||||
|
||||
// Make sure table is built
|
||||
@@ -3352,40 +3340,53 @@ void V_DoPostProcessor(INT32 view, postimg_t type, INT32 param)
|
||||
heatindex[view] %= vid.height;
|
||||
}
|
||||
|
||||
VID_BlitLinearScreen(tmpscr+vid.width*vid.bpp*yoffset+xoffset, screens[0]+vid.width*vid.bpp*yoffset+xoffset,
|
||||
viewwidth*vid.bpp, viewheight, vid.width*vid.bpp, vid.width);
|
||||
UINT8 *tmp = tmpscr;
|
||||
tmpscr = srcscr;
|
||||
srcscr = tmp;
|
||||
}
|
||||
else if (type == postimg_mirror) // Flip the screen on the x axis
|
||||
|
||||
if ((player->postimgflags & POSTIMG_FLIP) && !(player->postimgflags & POSTIMG_MIRROR)) // Flip the screen upside-down
|
||||
{
|
||||
INT32 y, y2;
|
||||
|
||||
for (y = yoffset, y2 = yoffset+viewheight - 1; y < yoffset+viewheight; y++, y2--)
|
||||
M_Memcpy(&tmpscr[(y2*vid.width)+xoffset], &srcscr[(y*vid.width)+xoffset], viewwidth);
|
||||
|
||||
UINT8 *tmp = tmpscr;
|
||||
tmpscr = srcscr;
|
||||
srcscr = tmp;
|
||||
}
|
||||
else if ((player->postimgflags & POSTIMG_MIRROR) && !(player->postimgflags & POSTIMG_FLIP)) // Flip the screen on the x axis
|
||||
{
|
||||
UINT8 *tmpscr = screens[4];
|
||||
UINT8 *srcscr = screens[0];
|
||||
INT32 y, x, x2;
|
||||
|
||||
for (y = yoffset; y < yoffset+viewheight; y++)
|
||||
{
|
||||
for (x = xoffset, x2 = xoffset+((viewwidth*vid.bpp)-1); x < xoffset+(viewwidth*vid.bpp); x++, x2--)
|
||||
tmpscr[y*vid.width + x2] = srcscr[y*vid.width + x];
|
||||
}
|
||||
|
||||
VID_BlitLinearScreen(tmpscr+vid.width*vid.bpp*yoffset+xoffset, screens[0]+vid.width*vid.bpp*yoffset+xoffset,
|
||||
viewwidth*vid.bpp, viewheight, vid.width*vid.bpp, vid.width);
|
||||
UINT8 *tmp = tmpscr;
|
||||
tmpscr = srcscr;
|
||||
srcscr = tmp;
|
||||
}
|
||||
else if (type == postimg_mirrorflip) // Flip the screen upside-down and on the x axis
|
||||
else if ((player->postimgflags & POSTIMG_MIRROR) && (player->postimgflags & POSTIMG_FLIP)) // Flip the screen upside-down and on the x axis
|
||||
{
|
||||
UINT8 *tmpscr = screens[4];
|
||||
UINT8 *srcscr = screens[0];
|
||||
INT32 y, x;
|
||||
|
||||
for (y = yoffset; y < yoffset + viewheight; y++)
|
||||
for (x = xoffset; x < xoffset + viewwidth; x++)
|
||||
tmpscr[((yoffset + viewheight - 1 - y) * vid.width) + xoffset + viewwidth - (x - xoffset) - 1] = srcscr[(y * vid.width) + x];
|
||||
|
||||
VID_BlitLinearScreen(tmpscr+vid.width*vid.bpp*yoffset+xoffset, screens[0]+vid.width*vid.bpp*yoffset+xoffset,
|
||||
viewwidth*vid.bpp, viewheight, vid.width*vid.bpp, vid.width);
|
||||
UINT8 *tmp = tmpscr;
|
||||
tmpscr = srcscr;
|
||||
srcscr = tmp;
|
||||
}
|
||||
|
||||
VID_BlitLinearScreen(srcscr+vid.width*vid.bpp*yoffset+xoffset, tmpscr+vid.width*vid.bpp*yoffset+xoffset,
|
||||
viewwidth*vid.bpp, viewheight, vid.width*vid.bpp, vid.width);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
// Taken from my videos-in-SRB2 project
|
||||
// Generates a color look-up table
|
||||
// which has up to 64 colors at each channel
|
||||
|
||||
+3
-1
@@ -251,7 +251,9 @@ INT32 V_SubStringLengthToFit(const char *string, INT32 width, INT32 option);
|
||||
|
||||
char V_GetSkincolorChar(INT32 color);
|
||||
|
||||
void V_DoPostProcessor(INT32 view, postimg_t type, INT32 param);
|
||||
typedef struct player_s player_t;
|
||||
|
||||
void V_DoPostProcessor(INT32 view, player_t *player, INT32 param);
|
||||
|
||||
void V_DrawPatchFill(patch_t *pat);
|
||||
|
||||
|
||||
+228
-9
@@ -1699,7 +1699,7 @@ void *W_CacheLumpName(const char *name, INT32 tag)
|
||||
#ifdef HWRENDER
|
||||
FUNCINLINE static ATTRINLINE void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
|
||||
{
|
||||
GLPatch_t *grPatch;
|
||||
GLPatch_t *glPatch;
|
||||
|
||||
if (rendermode == render_soft || rendermode == render_none)
|
||||
return W_CacheLumpNumPwad(wad, lump, tag);
|
||||
@@ -1707,29 +1707,29 @@ FUNCINLINE static ATTRINLINE void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump,
|
||||
if (!TestValidLump(wad, lump))
|
||||
return NULL;
|
||||
|
||||
grPatch = HWR_GetCachedGLPatchPwad(wad, lump);
|
||||
glPatch = HWR_GetCachedGLPatchPwad(wad, lump);
|
||||
|
||||
if (grPatch->mipmap->data)
|
||||
if (glPatch->mipmap->data)
|
||||
{
|
||||
if (tag == PU_CACHE)
|
||||
tag = PU_HWRCACHE;
|
||||
Z_ChangeTag(grPatch->mipmap->data, tag);
|
||||
Z_ChangeTag(glPatch->mipmap->data, tag);
|
||||
}
|
||||
else
|
||||
{
|
||||
patch_t *ptr = NULL;
|
||||
|
||||
// Only load the patch if we haven't initialised the grPatch yet
|
||||
if (grPatch->mipmap->width == 0)
|
||||
ptr = W_CacheLumpNumPwad(grPatch->wadnum, grPatch->lumpnum, PU_STATIC);
|
||||
// Only load the patch if we haven't initialised the glPatch yet
|
||||
if (glPatch->mipmap->width == 0)
|
||||
ptr = W_CacheLumpNumPwad(glPatch->wadnum, glPatch->lumpnum, PU_STATIC);
|
||||
|
||||
// Run HWR_MakePatch in all cases, to recalculate some things
|
||||
HWR_MakePatch(ptr, grPatch, grPatch->mipmap, false);
|
||||
HWR_MakePatch(ptr, glPatch, glPatch->mipmap, false);
|
||||
Z_Free(ptr);
|
||||
}
|
||||
|
||||
// return GLPatch_t, which can be casted to (patch_t) with valid patch header info
|
||||
return (void *)grPatch;
|
||||
return (void *)glPatch;
|
||||
}
|
||||
|
||||
void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag)
|
||||
@@ -2120,6 +2120,225 @@ int W_VerifyNMUSlumps(const char *filename)
|
||||
return W_VerifyFile(filename, NMUSlist, false);
|
||||
}
|
||||
|
||||
static int W_NameStartsWith(const char *name, lumpchecklist_t *checklist)
|
||||
{
|
||||
size_t j;
|
||||
for (j = 0; checklist[j].len && checklist[j].name; ++j)
|
||||
{
|
||||
if (strncasecmp(name, checklist[j].name, checklist[j].len) == 0)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Checks if file contains at least one lump which name starts with one of strings in checklist
|
||||
static int W_CheckWADContains(FILE *fp, lumpchecklist_t *checklist)
|
||||
{
|
||||
size_t i, j;
|
||||
// if we're here it's a WAD file
|
||||
wadinfo_t header;
|
||||
filelump_t lumpinfo;
|
||||
|
||||
// read the header
|
||||
if (fread(&header, 1, sizeof header, fp) == sizeof header
|
||||
&& header.numlumps < INT16_MAX
|
||||
&& strncmp(header.identification, "ZWAD", 4)
|
||||
&& strncmp(header.identification, "IWAD", 4)
|
||||
&& strncmp(header.identification, "PWAD", 4)
|
||||
&& strncmp(header.identification, "SDLL", 4))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
header.numlumps = LONG(header.numlumps);
|
||||
header.infotableofs = LONG(header.infotableofs);
|
||||
|
||||
// let seek to the lumpinfo list
|
||||
if (fseek(fp, header.infotableofs, SEEK_SET) == -1)
|
||||
return true;
|
||||
|
||||
for (i = 0; i < header.numlumps; i++)
|
||||
{
|
||||
// fill in lumpinfo for this wad file directory
|
||||
if (fread(&lumpinfo, sizeof (lumpinfo), 1 , fp) != 1)
|
||||
return -1;
|
||||
|
||||
lumpinfo.filepos = LONG(lumpinfo.filepos);
|
||||
lumpinfo.size = LONG(lumpinfo.size);
|
||||
|
||||
if (lumpinfo.size == 0)
|
||||
continue;
|
||||
|
||||
for (j = 0; j < NUMSPRITES; j++)
|
||||
if (!strncmp(lumpinfo.name, sprnames[j], 4)) // Sprites
|
||||
continue;
|
||||
|
||||
if (W_NameStartsWith(lumpinfo.name, checklist))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static int W_CheckPK3Contains(FILE *fp, lumpchecklist_t *checklist)
|
||||
{
|
||||
zend_t zend;
|
||||
zlentry_t zlentry;
|
||||
|
||||
long file_size;/* size of zip file */
|
||||
long data_size;/* size of data inside zip file */
|
||||
|
||||
UINT16 numlumps;
|
||||
size_t i;
|
||||
|
||||
char pat_central[] = {0x50, 0x4b, 0x01, 0x02, 0x00};
|
||||
char pat_end[] = {0x50, 0x4b, 0x05, 0x06, 0x00};
|
||||
|
||||
char lumpname[9];
|
||||
|
||||
// Haha the ResGetLumpsZip function doesn't
|
||||
// check for file errors, so neither will I.
|
||||
|
||||
// Central directory bullshit
|
||||
|
||||
fseek(fp, 0, SEEK_END);
|
||||
file_size = ftell(fp);
|
||||
|
||||
if (!ResFindSignature(fp, pat_end, max(0, ftell(fp) - (22 + 65536))))
|
||||
return true;
|
||||
|
||||
fseek(fp, -4, SEEK_CUR);
|
||||
if (fread(&zend, 1, sizeof zend, fp) < sizeof zend)
|
||||
return true;
|
||||
|
||||
data_size = sizeof zend;
|
||||
|
||||
numlumps = SHORT(zend.entries);
|
||||
|
||||
fseek(fp, LONG(zend.cdiroffset), SEEK_SET);
|
||||
|
||||
char *cdir = (char*)(malloc(LONG(zend.cdirsize)));
|
||||
|
||||
if (fread(cdir, 1, LONG(zend.cdirsize), fp) < (UINT32)(LONG(zend.cdirsize)))
|
||||
return true;
|
||||
|
||||
size_t offset = 0;
|
||||
|
||||
for (i = 0; i < numlumps; i++)
|
||||
{
|
||||
zentry_t *zentry = (zentry_t*)(cdir + offset);
|
||||
char* fullname;
|
||||
char* trimname;
|
||||
char* dotpos;
|
||||
|
||||
if (memcmp(zentry->signature, pat_central, 4) != 0)
|
||||
return false;
|
||||
|
||||
fullname = (char*)(malloc(SHORT(zentry->namelen) + 1));
|
||||
strlcpy(fullname, (char*)(zentry + 1), SHORT(zentry->namelen) + 1);
|
||||
|
||||
// Strip away file address and extension for the 8char name.
|
||||
if ((trimname = strrchr(fullname, '/')) != 0)
|
||||
trimname++;
|
||||
else
|
||||
trimname = fullname; // Care taken for root files.
|
||||
|
||||
if (*trimname) // Ignore directories, well kinda
|
||||
{
|
||||
if ((dotpos = strrchr(trimname, '.')) == 0)
|
||||
dotpos = fullname + strlen(fullname); // Watch for files without extension.
|
||||
|
||||
memset(lumpname, '\0', 9); // Making sure they're initialized to 0. Is it necessary?
|
||||
strncpy(lumpname, trimname, min(8, dotpos - trimname));
|
||||
|
||||
if (W_NameStartsWith(lumpname, checklist))
|
||||
return true;
|
||||
}
|
||||
|
||||
if (W_NameStartsWith(fullname, checklist))
|
||||
return true;
|
||||
|
||||
free(fullname);
|
||||
|
||||
offset += sizeof *zentry + SHORT(zentry->namelen) + SHORT(zentry->xtralen) + SHORT(zentry->commlen);
|
||||
|
||||
data_size +=
|
||||
sizeof *zentry + SHORT(zentry->namelen) + SHORT(zentry->xtralen) + SHORT(zentry->commlen);
|
||||
|
||||
if (fseek(fp, LONG(zentry->offset), SEEK_SET) != 0)
|
||||
return false;
|
||||
|
||||
if (fread(&zlentry, 1, sizeof(zlentry_t), fp) < sizeof (zlentry_t))
|
||||
return false;
|
||||
|
||||
data_size +=
|
||||
sizeof zlentry + SHORT(zlentry.namelen) + SHORT(zlentry.xtralen) + LONG(zlentry.compsize);
|
||||
}
|
||||
|
||||
free(cdir);
|
||||
|
||||
if (data_size < file_size)
|
||||
{
|
||||
const char * error = "ZIP file has holes (%ld extra bytes)\n";
|
||||
CONS_Alert(CONS_ERROR, error, (file_size - data_size));
|
||||
return -1;
|
||||
}
|
||||
else if (data_size > file_size)
|
||||
{
|
||||
const char * error = "Reported size of ZIP file contents exceeds file size (%ld extra bytes)\n";
|
||||
CONS_Alert(CONS_ERROR, error, (data_size - file_size));
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
static int W_CheckFileContains(const char *filename, lumpchecklist_t *checklist)
|
||||
{
|
||||
FILE *handle;
|
||||
int contains = false;
|
||||
|
||||
if (!checklist)
|
||||
I_Error("No checklist for %s\n", filename);
|
||||
// open wad file
|
||||
if ((handle = W_OpenWadFile(&filename, false)) == NULL)
|
||||
return -1;
|
||||
|
||||
if (stricmp(&filename[strlen(filename) - 4], ".pk3") == 0)
|
||||
contains = W_CheckPK3Contains(handle, checklist);
|
||||
else
|
||||
{
|
||||
// detect wad file by the absence of the other supported extensions
|
||||
if (stricmp(&filename[strlen(filename) - 4], ".soc")
|
||||
&& stricmp(&filename[strlen(filename) - 4], ".lua"))
|
||||
{
|
||||
contains = W_CheckWADContains(handle, checklist);
|
||||
}
|
||||
}
|
||||
fclose(handle);
|
||||
return contains;
|
||||
}
|
||||
|
||||
int W_CheckPostLoadList(const char *filename)
|
||||
{
|
||||
static lumpchecklist_t postloadlist[] =
|
||||
{
|
||||
{"Lua/", 4},
|
||||
{"SOC/", 4},
|
||||
{"Skins/", 6},
|
||||
{"S_SKIN", 6},
|
||||
{"LUA_", 4},
|
||||
{"SOC_", 4},
|
||||
{"MAINCFG", 7},
|
||||
{"OBJCTCFG", 8},
|
||||
{"MAP", 3},
|
||||
|
||||
{NULL, 0},
|
||||
};
|
||||
return W_CheckFileContains(filename, postloadlist);
|
||||
}
|
||||
|
||||
/** \brief Generates a virtual resource used for level data loading.
|
||||
*
|
||||
* \param lumpnum_t reference
|
||||
|
||||
@@ -226,4 +226,6 @@ void W_VerifyFileMD5(UINT16 wadfilenum, const char *matchmd5);
|
||||
|
||||
int W_VerifyNMUSlumps(const char *filename);
|
||||
|
||||
int W_CheckPostLoadList(const char *filename);
|
||||
|
||||
#endif // __W_WAD__
|
||||
+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