Compare commits

..
Author SHA1 Message Date
alufolie91 f332e21fa7 adjust shader vhs fuzzyness to match software at default res
the shader looks the same no matter the resolution, so we shouldnt scale this at all
thisll now treat rows for offsetting like its always default resolution (1280x800)
also readjusted the upwards bar since its actually the same size as the downwards bar lul
2026-11-16 00:04:48 +01:00
alufolie91 bc4c1637ad use menu rendertimefrac for shader vhs
forgor abt this, fixes interp in replay hut lulul
2026-11-15 16:41:51 +01:00
alufolie91 d9e3dd979e Merge branch 'Saturn-Next' into shadercrap 2026-11-15 01:27:02 +01:00
alufolie91 6b84c86197 fix vhs effect bars when rewinding
noticed while doing the shader thing
basically the effect is supposed to stack
but both calls being recursive, updated just the same bar positions, so both sets of bars would just draw over each other
this basically just like, keeps seperate positions for when rewind it true
this is probably how it was intended to work, otherwise that code makes not much sense
2026-11-15 01:26:57 +01:00
alufolie91 df8f167549 combine both vhs shaders
not sure why i didnt think of this lul
saves us another screen texture copy and draw
so shit is even faster
2026-11-15 00:33:46 +01:00
alufolie91 d60d9d5611 make vhs shader bars use triangle instead of sine
also adjust the color since they were too dark compared to software
idk maths for shit so this is pieced together from shit i found on the interwebs
this matches software since it also does the trongle for this ugh
the rest was also retuned and basically matches software at default res almost 1:1
2026-11-15 00:08:02 +01:00
alufolie91 b5f4db5131 wrap vhs shader distortion horizontally instead of clamping
matches software aswell!
thisll take the screen from the opposite site instead of "stretching" it
always forget modulo is a thing lul
2026-11-14 22:47:13 +01:00
alufolie91 f74a7e3f07 flip shader vhs horizontal distortion direction
matches software
2026-11-14 22:46:36 +01:00
alufolie91 8e1212d9d5 fix uv clamps in the RR screen shaders
forgor
this makes sure the shaders dont sample outside the screen region as the screen textures may not be exactly screen sized
2026-11-14 21:55:28 +01:00
alufolie91 cc952dfd52 use software wall/slope contrast checks in gl paletterendering mode
simple enough change which should make this match up more, tho shouldnt be super different
2026-11-14 06:40:07 +01:00
alufolie91 063f94da8b fix slope contrast
missed a fix when ported it so the contrast direction was off by 90 degrees
also apparently i moved the software contrast part to never apply to fofs for some reason?
rechecked against the srb2 code for this and now properly matches up
2026-11-14 06:40:07 +01:00
alufolie91 457cae0ed9 adjust floor fudge for palette render
this significantly more matches software especially when drawing horizonlines
as gl was too dark in the distance compared to software
theres still some things left to recheck to better match software lighting (ex. wallcontrast) but too lazy atm
2026-11-14 06:40:07 +01:00
alufolie91 b990589e66 smol style fixes lua mobj and player lib 2026-11-14 06:40:07 +01:00
alufolie91 59a4627911 gl: use shaders for vhs effect
this is a fuckton faster lol
the old one did a gazillion draw calls now we do two, one for the fuzzy and the 2nd for the bars as both are handled within a single shader
thanks to RRs heat effect being super similar to the vhs bars lul
2026-11-12 21:02:07 +01:00
indev 546fae5110 Merge branch 'remove-lua-udata-lib' into Saturn-Next 2026-11-12 22:43:23 +03:00
alufolie91 ecab383078 gl: use shaders for underwater / heatwave effect
basically ported over from RR
water was massively toned down and adjusted, it visually almost matches software at default res (note that the software effects are not properly scaled lol)
the heat effect is just the water effect adjusted to look like the fixed function version from before but slightly slower to accomidate the slower water effect here

this should speed things up a little since we now only need ONE draw call instead of 20 per effect
small note: this does not zoom into the image like the shaderless version, which was quite jarring tbh but there can be some very slight "stretch" marks at screen border, but theyre extremely unnoticable
2026-11-12 20:32:38 +01:00
alufolie91 ee4c060cc8 add rumble type for wallbonks
yoinked from blan
will also look into drift release rumble, but we have that per lua in sg anyways
2026-11-12 20:31:27 +01:00
alufolie91 ebd5b86e87 use screen_width/height for scr_resolution uniform
those are meant for this kinda crap
2026-11-12 19:39:50 +01:00
alufolie91 9321036049 further simplify downsample stuff
man idk why i even did the whole desktop res shit
somehow kept forgetting we should just check against the drawable/window size as it determines the main framebuffer size
so we just can use SDL_GetWindowSize and get rid of all the other crap
2026-11-11 12:26:53 +01:00
alufolie91 12f43ae504 move horizonline stuff back to plane preprocessor
well "back" we still had it there, but the subsector marking logic can just be there
was kinda too lazy before to do this lul
saves some time as we dont need to go thru all subsectors again at mapload, which there can be many of
2026-11-11 12:25:20 +01:00
alufolie91 cfc94c0f9e fix horizonlines on fofs in opengl
not super cool but seems to work just fine
the new subsector flag may even improve performance in some cases since the horizonspecial check seems to mess up the branch predictor often lol
2026-11-11 00:55:41 +01:00
alufolie91 3385df4c7e allow gl fbo to be enabled at all times
not just when downsampling
as this may improve performance in some cases
2026-11-10 17:48:30 +01:00
alufolie91 561f871e61 fix downsample state not refreshing in the right place
needs to be done before refreshing the surface, as OglSdlSurface needs to determine the state to toggle the fbo
2026-11-10 17:48:27 +01:00
alufolie91 bffafa0540 make screen fbo msaa compatible
quite a mess but "works"
the reason this didnt work before was
i mostly tried doing this per multisample textures which you cant really copy from
now we do it per color rbo which you also cant really copy from, but is the recommended way
so now each time we try to copy from the screen (screentextures, screenshots, etc.) we blit the msaa fbo into the normal fbo so we can copy from that
its probably a little slow, but cant really do much about it besides getting rid of screen textures and replacing them with more fbo logic.....
2026-11-10 17:27:11 +01:00
21 changed files with 1210 additions and 534 deletions

No files matched your search

+2
View File
@@ -1043,6 +1043,8 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_rumble[i]); CV_RegisterVar(&cv_rumble[i]);
CV_RegisterVar(&cv_rumble_strength[i]); CV_RegisterVar(&cv_rumble_strength[i]);
CV_RegisterVar(&cv_rumble_wallbonk[i]);
CV_RegisterVar(&cv_rumble_spinout[i]); CV_RegisterVar(&cv_rumble_spinout[i]);
CV_RegisterVar(&cv_rumble_sneakerboost[i]); CV_RegisterVar(&cv_rumble_sneakerboost[i]);
CV_RegisterVar(&cv_rumble_offroad[i]); CV_RegisterVar(&cv_rumble_offroad[i]);
+39 -62
View File
@@ -17,14 +17,9 @@
#include "g_game.h" #include "g_game.h"
#include "keys.h" #include "keys.h"
#include "hu_stuff.h" // need HUFONT start & end #include "hu_stuff.h" // need HUFONT start & end
#include "d_net.h"
#include "console.h" #include "console.h"
#include "m_menu.h"
#include "i_system.h" #include "i_system.h"
#include "i_video.h"
#include "r_draw.h"
#include "v_video.h" #include "v_video.h"
#define MAXMOUSESENSITIVITY 100 // sensitivity steps #define MAXMOUSESENSITIVITY 100 // sensitivity steps
@@ -36,10 +31,11 @@ static CV_PossibleValue_t turnsmooth_cons_t[] = {{2, "Slow"}, {1, "Fast"}, {0, "
// mouse values are used once // mouse values are used once
consvar_t cv_mousexsens = {"mousexsens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_mousexsens = {"mousexsens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_mouseysens = {"mouseysens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_mouseysens = {"mouseysens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_controlperkey = {"controlperkey", "One", CV_SAVE, onecontrolperkey_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_controlperkey = {"controlperkey", "One", CV_SAVE, onecontrolperkey_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_turnsmooth[MAXSPLITSCREENPLAYERS] = { consvar_t cv_turnsmooth[MAXSPLITSCREENPLAYERS] = {
{"turnsmoothing", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}, {"turnsmoothing", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"turnsmoothing2", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}, {"turnsmoothing2", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"turnsmoothing3", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}, {"turnsmoothing3", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"turnsmoothing4", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL} {"turnsmoothing4", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}
@@ -81,6 +77,7 @@ consvar_t cv_rumble_##type [MAXSPLITSCREENPLAYERS] = {\
{"rumble4_" #type, "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}\ {"rumble4_" #type, "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}\
}; };
IMPL_RUMBLE_TYPE(wallbonk);
IMPL_RUMBLE_TYPE(spinout); IMPL_RUMBLE_TYPE(spinout);
IMPL_RUMBLE_TYPE(sneakerboost); IMPL_RUMBLE_TYPE(sneakerboost);
IMPL_RUMBLE_TYPE(offroad); IMPL_RUMBLE_TYPE(offroad);
@@ -89,7 +86,6 @@ IMPL_RUMBLE_TYPE(stairjank);
IMPL_RUMBLE_TYPE(brakedrift); IMPL_RUMBLE_TYPE(brakedrift);
IMPL_RUMBLE_TYPE(driftcharge); IMPL_RUMBLE_TYPE(driftcharge);
static CV_PossibleValue_t gamepadled_cons_t[] = {{0, "Off"}, {1, "Skincolor"}, {2, "Mobjcolor"}, {0, NULL}}; static CV_PossibleValue_t gamepadled_cons_t[] = {{0, "Off"}, {1, "Skincolor"}, {2, "Mobjcolor"}, {0, NULL}};
consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS] = { consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS] = {
{"gamepadled", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle, 0, NULL, NULL, 0, 0, NULL}, {"gamepadled", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle, 0, NULL, NULL, 0, 0, NULL},
@@ -195,7 +191,6 @@ void G_MapEventsToControls(event_t *ev)
{ {
CONS_Debug(DBG_GAMELOGIC, "Bad downkey input %d\n",ev->data1); CONS_Debug(DBG_GAMELOGIC, "Bad downkey input %d\n",ev->data1);
} }
#endif #endif
break; break;
@@ -951,16 +946,15 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS); I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
if (cv_gamepadled[playernum].value == 0 || (window_notinfocus && cv_gamepadledifunfocused.value == 0) if (cv_gamepadled[playernum].value == 0 ||
|| color >= MAXTRANSLATIONS) (window_notinfocus && cv_gamepadledifunfocused.value == 0) ||
color >= MAXTRANSLATIONS)
{ {
return; return;
} }
if (!I_GamepadHasLED(playernum)) if (!I_GamepadHasLED(playernum))
{
return; return;
}
// so we can override this // so we can override this
skincolor = color ? color : G_GetSkinColorForGamepad(playernum); skincolor = color ? color : G_GetSkinColorForGamepad(playernum);
@@ -990,29 +984,21 @@ void G_DeviceLEDTick(void)
UINT8 i, newcolor; UINT8 i, newcolor;
if (numcontrollers == 0) if (numcontrollers == 0)
{
return; return;
}
for (i = 0; i <= splitscreen; i++) for (i = 0; i <= splitscreen; i++)
{ {
if (!cv_usejoystick[i].value || !cv_gamepadled[i].value) if (!cv_usejoystick[i].value || !cv_gamepadled[i].value)
{
continue; continue;
}
// does not have a configurable led! :c // does not have a configurable led! :c
if (!I_GamepadHasLED(i)) if (!I_GamepadHasLED(i))
{
continue; continue;
}
newcolor = G_GetSkinColorForGamepad(i); newcolor = G_GetSkinColorForGamepad(i);
if (curcolor[i] == newcolor) // dont update if same colour if (curcolor[i] == newcolor) // dont update if same colour
{
continue; continue;
}
G_SetPlayerGamepadIndicatorColor(i, newcolor); G_SetPlayerGamepadIndicatorColor(i, newcolor);
curcolor[i] = newcolor; curcolor[i] = newcolor;
@@ -1046,9 +1032,7 @@ void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_stre
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS); I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
if (cv_rumble[playernum].value == 0 || (window_notinfocus && cv_rumbleifunfocused.value == 0)) if (cv_rumble[playernum].value == 0 || (window_notinfocus && cv_rumbleifunfocused.value == 0))
{
return; return;
}
// doesent need to be super precise // doesent need to be super precise
// but ensure this is within range (0-65535) // but ensure this is within range (0-65535)
@@ -1077,46 +1061,34 @@ void G_DeviceRumbleTick(void)
UINT8 i; UINT8 i;
if (dedicated || numcontrollers == 0 || gamestate != GS_LEVEL || demo.playback) if (dedicated || numcontrollers == 0 || gamestate != GS_LEVEL || demo.playback)
{
return; return;
}
for (i = 0; i <= splitscreen; i++) for (i = 0; i <= splitscreen; i++)
{ {
if (!cv_usejoystick[i].value || !cv_rumble[i].value) if (!cv_usejoystick[i].value || !cv_rumble[i].value)
{
continue; continue;
}
// does not support rumble! :c // does not support rumble! :c
if (!I_GamepadHasRumble(i)) if (!I_GamepadHasRumble(i))
{
continue; continue;
}
if (camera[i].freecam) if (camera[i].freecam)
{
continue; continue;
}
// SDL rumble strength goes from a range or 0-65535 respectively // SDL rumble strength goes from a range or 0-65535 respectively
// the higher, the stronger it is // the higher, the stronger it is
UINT16 low = 0, high = 0; UINT16 low = 0, high = 0;
// for how long the action should rumble, in ms // for how long the action should rumble, in ms
UINT16 lenght = 57; // 57ms is a short pulse, matches super well with this updating once per tic UINT16 length = 57; // 57ms is a short pulse, matches super well with this updating once per tic
const player_t *player = P_GetLocalPlayerForNum(i); const player_t *player = P_GetLocalPlayerForNum(i);
if (!player) if (!player)
{
continue; continue;
}
// allow lua to do some crap for spectators // allow lua to do some crap for spectators
if (player->spectator || !player->mo) if (player->spectator || !player->mo)
{
continue; continue;
}
// reset the rumble if you exit or are ded lel // reset the rumble if you exit or are ded lel
if (player->exiting || if (player->exiting ||
@@ -1127,21 +1099,28 @@ void G_DeviceRumbleTick(void)
continue; continue;
} }
if (cv_rumble_spinout[i].value if (cv_rumble_wallbonk[i].value &&
&& player->kartstuff[k_spinouttimer]) (player->mo->eflags & MFE_JUSTBOUNCEDWALL))
{
high = RUMBLE_STRONG;
low = RUMBLE_MODERATE;
}
else if (cv_rumble_spinout[i].value &&
player->kartstuff[k_spinouttimer])
{ {
//low = high = FRACUNIT / 6; //low = high = FRACUNIT / 6;
low = high = FixedMul((RUMBLE_VERYSTRONG), (FixedDiv(player->kartstuff[k_spinouttimer], (3*TICRATE / 2)))); // try do some some kinda fadeout, 3*TICRATE / 2 is the "default" spinout time // try do some some kinda fadeout, 3*TICRATE / 2 is the "default" spinout time
low = high = FixedMul(RUMBLE_VERYSTRONG, FixedDiv(player->kartstuff[k_spinouttimer], (3*TICRATE / 2)));
} }
else if (cv_rumble_sneakerboost[i].value else if (cv_rumble_sneakerboost[i].value &&
&& (player->kartstuff[k_sneakertimer] > (sneakertime-(TICRATE/2)))) (player->kartstuff[k_sneakertimer] > (sneakertime-(TICRATE/2))))
{ {
low = high = RUMBLE_STRONG; low = high = RUMBLE_STRONG;
} }
else if (cv_rumble_offroad[i].value else if (cv_rumble_offroad[i].value &&
&& (player->kartstuff[k_offroad]) (player->kartstuff[k_offroad]) &&
&& (player->speed != 0) (player->speed != 0) &&
&& P_IsObjectOnGround(player->mo)) P_IsObjectOnGround(player->mo))
{ {
// weaken this depending on if you got hyu or invinc // weaken this depending on if you got hyu or invinc
if (player->kartstuff[k_hyudorotimer]) if (player->kartstuff[k_hyudorotimer])
@@ -1157,50 +1136,48 @@ void G_DeviceRumbleTick(void)
low = high = RUMBLE_MODERATE; low = high = RUMBLE_MODERATE;
} }
} }
else if (cv_rumble_bananadrag[i].value else if (cv_rumble_bananadrag[i].value &&
&& (player->kartstuff[k_bananadrag] > TICRATE) (player->kartstuff[k_bananadrag] > TICRATE) &&
&& (player->speed != 0) (player->speed != 0) &&
&& P_IsObjectOnGround(player->mo)) P_IsObjectOnGround(player->mo))
{ {
if (leveltime & 1) // this is actually funny lel if (leveltime & 1) // this is actually funny lel
high = RUMBLE_MODERATE; high = RUMBLE_MODERATE;
} }
else if (cv_rumble_stairjank[i].value else if (cv_rumble_stairjank[i].value &&
&& (player->stairjank > 8) (player->stairjank > 8) &&
&& (player->speed != 0) (player->speed != 0) &&
&& P_IsObjectOnGround(player->mo)) P_IsObjectOnGround(player->mo))
{ {
low = high = RUMBLE_VERYWEAK; low = high = RUMBLE_VERYWEAK;
} }
if (cv_rumble_brakedrift[i].value if (cv_rumble_brakedrift[i].value &&
&& player->kartstuff[k_brakedrift]) player->kartstuff[k_brakedrift])
{ {
high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX); high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX);
} }
// pulse when gettin new driftlevel // pulse when gettin new driftlevel
// let this come last // let this come last
if (cv_rumble_driftcharge[i].value if (cv_rumble_driftcharge[i].value &&
&& player->kartstuff[k_driftcharge] player->kartstuff[k_driftcharge] &&
&& player->driftlevel) player->driftlevel)
{ {
high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX); high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX);
// make it rumble slightly longer the higher your driftlevel! // make it rumble slightly longer the higher your driftlevel!
if (player->driftlevel == 2) if (player->driftlevel == 2)
lenght = 114; length = 114;
else if (player->driftlevel == 3) else if (player->driftlevel == 3)
lenght = 174; length = 174;
} }
// hack alert! i just dont want this thing constantly resetting the rumble lol // hack alert! i just dont want this thing constantly resetting the rumble lol
if (low == 0 && high == 0) if (low == 0 && high == 0)
{
continue; continue;
}
G_PlayerDeviceRumble(i, low, high, lenght); G_PlayerDeviceRumble(i, low, high, length);
} }
} }
+2
View File
@@ -118,6 +118,8 @@ extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble_strength[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble_strength[MAXSPLITSCREENPLAYERS];
// rumble types
extern consvar_t cv_rumble_wallbonk[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble_spinout[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble_spinout[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble_sneakerboost[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble_sneakerboost[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble_offroad[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble_offroad[MAXSPLITSCREENPLAYERS];
+15 -18
View File
@@ -54,10 +54,6 @@ typedef struct {
// if no portals are found, the portal scanning phase can be skipped while rendering, saving a bit of time. // if no portals are found, the portal scanning phase can be skipped while rendering, saving a bit of time.
boolean gl_maphasportals = false; boolean gl_maphasportals = false;
// Determine on mapload if current map has any Horizonlines present
// avoids doing a bunch of work during rendering
boolean gl_maphashorizonlines = false;
// ========================================================================== // ==========================================================================
// FLOOR & CEILING CONVEX POLYS GENERATION // FLOOR & CEILING CONVEX POLYS GENERATION
// ========================================================================== // ==========================================================================
@@ -405,7 +401,7 @@ static void SplitPoly (fdivline_t *dlnp, // splitting parametric line
} }
// checks if any line is a portal or horizonline, for optimization // checks if any line is a portal or horizonline, for optimization
static inline void CheckForPortalsAndHorizonLines(boolean firstside, const line_t *line) static inline void CheckForPortalsAndHorizonLines(boolean firstside, const line_t *line, subsector_t *sub)
{ {
// portal check // portal check
if (!gl_maphasportals && firstside && line->special == PORTALSPECIAL) if (!gl_maphasportals && firstside && line->special == PORTALSPECIAL)
@@ -421,8 +417,8 @@ static inline void CheckForPortalsAndHorizonLines(boolean firstside, const line_
} }
// horizonline check // horizonline check
if (!gl_maphashorizonlines && line->special == HORIZONSPECIAL) if (line->special == HORIZONSPECIAL)
gl_maphashorizonlines = true; sub->hashorizon = true;
} }
// Use each seg of the poly as a partition line, keep only the // Use each seg of the poly as a partition line, keep only the
@@ -435,7 +431,7 @@ static inline void CheckForPortalsAndHorizonLines(boolean firstside, const line_
// segcount : number of seg in the array // segcount : number of seg in the array
// Return frontpoly, which may be new or ptr to poly. // Return frontpoly, which may be new or ptr to poly.
// Called from: HWR_SubsecPoly // Called from: HWR_SubsecPoly
static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly) static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly, subsector_t *sub)
{ {
INT32 i, j; INT32 i, j;
poly_t* frontpoly = poly; // default, return same poly poly_t* frontpoly = poly; // default, return same poly
@@ -447,10 +443,6 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly)
vertex_t *v1, *v2; vertex_t *v1, *v2;
fdivline_t cutseg; // x, y, dx, dy as start of node_t struct fdivline_t cutseg; // x, y, dx, dy as start of node_t struct
// empty poly? just save us some time then
if (poly->numpts <= 0)
return frontpoly;
// for each seg of the subsector // for each seg of the subsector
for (; segcount--; lseg++) for (; segcount--; lseg++)
{ {
@@ -460,7 +452,7 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly)
if (!line) if (!line)
continue; continue;
CheckForPortalsAndHorizonLines(lseg->side == 0, line); CheckForPortalsAndHorizonLines(lseg->side == 0, line, sub);
if (line->sidenum[1] != NO_INDEX) if (line->sidenum[1] != NO_INDEX)
{ {
@@ -623,7 +615,7 @@ static inline void HWR_SubsecPoly(INT32 ssindex, poly_t *poly)
if (poly) if (poly)
{ {
poly = CutOutSubsecPoly(lseg, segcount, poly); poly = CutOutSubsecPoly(lseg, segcount, poly, sub);
#ifdef DEBUG_HWBSP #ifdef DEBUG_HWBSP
totalsubsecpolys++; totalsubsecpolys++;
#endif #endif
@@ -752,7 +744,7 @@ static void WalkBSPNode(INT32 bspnum, poly_t *poly, UINT16 *leafnode, fixed_t *b
#endif #endif
// Recursively divide front space. // Recursively divide front space.
if (LIKELY(frontpoly)) if (frontpoly)
{ {
WalkBSPNode(bsp->children[0], frontpoly, &bsp->children[0],bsp->bbox[0]); WalkBSPNode(bsp->children[0], frontpoly, &bsp->children[0],bsp->bbox[0]);
@@ -879,7 +871,9 @@ static boolean PointInSeg(polyvertex_t *va, polyvertex_t *v1, polyvertex_t *v2)
#endif #endif
} }
#ifdef DEBUG_HWBSP
static INT32 numsplitpoly; static INT32 numsplitpoly;
#endif
static void SearchSegInBSP(INT32 bspnum, polyvertex_t *p, poly_t *poly) static void SearchSegInBSP(INT32 bspnum, polyvertex_t *p, poly_t *poly)
{ {
@@ -918,8 +912,9 @@ static void SearchSegInBSP(INT32 bspnum, polyvertex_t *p, poly_t *poly)
for (n = k+1; n < newpoly->numpts; n++) for (n = k+1; n < newpoly->numpts; n++)
newpoly->pts[n] = q->pts[n-1]; newpoly->pts[n] = q->pts[n-1];
#ifdef DEBUG_HWBSP
numsplitpoly++; numsplitpoly++;
#endif
extrasubsectors[bspnum].planepoly = newpoly; extrasubsectors[bspnum].planepoly = newpoly;
HWR_FreePoly(q); HWR_FreePoly(q);
return; return;
@@ -965,7 +960,9 @@ static void SolveTProblem(void)
I_FinishUpdate(); // page flip or blit buffer I_FinishUpdate(); // page flip or blit buffer
#endif #endif
#ifdef DEBUG_HWBSP
numsplitpoly = 0; numsplitpoly = 0;
#endif
for (ssnum = 0; ssnum < num_extra_subsector; ssnum++) for (ssnum = 0; ssnum < num_extra_subsector; ssnum++)
{ {
@@ -1002,8 +999,8 @@ void HWR_CreatePlanePolygons(INT32 bspnum)
I_FinishUpdate(); // page flip or blit buffer I_FinishUpdate(); // page flip or blit buffer
#endif #endif
// reset the portal and horizonline flag // reset the portal flag
gl_maphasportals = gl_maphashorizonlines = false; gl_maphasportals = false;
// find min/max boundaries of map // find min/max boundaries of map
#ifdef DEBUG_HWBSP #ifdef DEBUG_HWBSP
+5
View File
@@ -196,6 +196,11 @@ enum
SHADER_PALETTE_POSTPROCESS, SHADER_PALETTE_POSTPROCESS,
SHADER_UI_COLORMAP_FADE, SHADER_UI_COLORMAP_FADE,
SHADER_POSTPROCESS_WATER,
SHADER_POSTPROCESS_HEAT,
SHADER_VHS,
NUMSHADERTARGETS NUMSHADERTARGETS
}; };
+2 -1
View File
@@ -66,10 +66,11 @@ void GL_FlushScreenTextures(void);
void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags); void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags);
void GL_DoScreenWipe(int wipeStart, int wipeEnd); void GL_DoScreenWipe(int wipeStart, int wipeEnd);
void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize); void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize, boolean rewind);
void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height); void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height);
void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2]); void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2]);
void GL_DoPostProcessor(INT32 type);
boolean GL_InitShaders(void); boolean GL_InitShaders(void);
void GL_LoadShader(int slot, char *code, hwdshaderstage_t stage); void GL_LoadShader(int slot, char *code, hwdshaderstage_t stage);
+328 -43
View File
@@ -16,6 +16,7 @@
#include <algorithm> #include <algorithm>
#include <vector> #include <vector>
#include "../d_main.h"
#include "../doomstat.h" #include "../doomstat.h"
#include "../doomdef.h" #include "../doomdef.h"
@@ -120,7 +121,7 @@ ps_metric_t ps_hw_batchdrawtime = {};
static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum, boolean noencore, FSurfaceInfo* Surf, INT32 cutflag, ffloor_t *pfloor, FBITFIELD polyflags); static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum, boolean noencore, FSurfaceInfo* Surf, INT32 cutflag, ffloor_t *pfloor, FBITFIELD polyflags);
static void HWR_RenderWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap); static void HWR_RenderWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
static 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); static 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, subsector_t *subsector);
static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, INT32 texnum, boolean noencore, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap); static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, INT32 texnum, boolean noencore, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
static 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); static 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);
@@ -204,7 +205,8 @@ static CV_PossibleValue_t glpalettedepth_cons_t[] = {{16, "16 bits"}, {24, "24 b
consvar_t cv_glscreentextures = {"gr_screentextures", "All", CV_CALL|CV_SAVE, glscreentextures_cons_t, CV_screentextures_OnChange, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_glscreentextures = {"gr_screentextures", "All", CV_CALL|CV_SAVE, glscreentextures_cons_t, CV_screentextures_OnChange, 0, NULL, NULL, 0, 0, NULL};
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
consvar_t cv_glframebuffer = {"gr_framebuffer", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, CV_glframebuffer_OnChange, 0, NULL, NULL, 0, 0, NULL}; static CV_PossibleValue_t glframebuffer_cons_t[] = {{0, "Off"}, {1, "Downsample"}, {2, "Always"}, {0, NULL}};
consvar_t cv_glframebuffer = {"gr_framebuffer", "Off", CV_SAVE|CV_CALL, glframebuffer_cons_t, CV_glframebuffer_OnChange, 0, NULL, NULL, 0, 0, NULL};
#endif #endif
consvar_t cv_glmdls = {"gr_mdls", "Off", CV_SAVE|CV_CALL, CV_OnOff, M_UpdateOGLMenu, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_glmdls = {"gr_mdls", "Off", CV_SAVE|CV_CALL, CV_OnOff, M_UpdateOGLMenu, 0, NULL, NULL, 0, 0, NULL};
@@ -267,8 +269,8 @@ static void CV_glframebuffer_OnChange(void)
// screen FBO needs screen textures currently // screen FBO needs screen textures currently
if (cv_glframebuffer.value != 0 && ((cv_glscreentextures.value != 2) || !supportFBO)) if (cv_glframebuffer.value != 0 && ((cv_glscreentextures.value != 2) || !supportFBO))
CV_StealthSetValue(&cv_glframebuffer, 0); // dont recursively call this lul CV_StealthSetValue(&cv_glframebuffer, 0); // dont recursively call this lul
if (loaded_config) // dont do this crap on startup, this is handled elsewhere
I_CheckDownSampleState(true); I_CheckDownSampleState(true);
M_UpdateOGLMenu(); M_UpdateOGLMenu();
intermissionbginit = false; intermissionbginit = false;
} }
@@ -502,6 +504,13 @@ static UINT8 HWR_FogBlockAlpha(INT32 light, extracolormap_t *colormap) // Let's
return surfcolor.s.alpha; return surfcolor.s.alpha;
} }
static boolean HWR_ApplyLightOffset(UINT8 baselightnum, const sector_t *sector)
{
if (HWR_ShouldUsePaletteRendering())
return P_ApplyLightOffset(baselightnum >> LIGHTSEGSHIFT, sector);
return P_ApplyLightOffsetFine(baselightnum, sector);
}
static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colormap) static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colormap)
{ {
INT16 finallight = lightnum; INT16 finallight = lightnum;
@@ -509,7 +518,7 @@ static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colo
if (cv_glfakecontrast.value == 0 || (colormap && HWR_ShouldUsePaletteRendering())) if (cv_glfakecontrast.value == 0 || (colormap && HWR_ShouldUsePaletteRendering()))
return (FUINT)finallight; return (FUINT)finallight;
if (seg != NULL && P_ApplyLightOffsetFine(lightnum, seg->frontsector)) if (seg != NULL && HWR_ApplyLightOffset(lightnum, seg->frontsector))
{ {
const INT16 offset = (cv_glfakecontrast.value == 2) ? seg->hwLightOffset : ((INT16)seg->lightOffset * 8); const INT16 offset = (cv_glfakecontrast.value == 2) ? seg->hwLightOffset : ((INT16)seg->lightOffset * 8);
@@ -527,10 +536,9 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t
if (cv_glfakecontrast.value == 0 || cv_glslopecontrast.value == 0) if (cv_glfakecontrast.value == 0 || cv_glslopecontrast.value == 0)
return (FUINT)finallight; return (FUINT)finallight;
if (slope != NULL && sector != NULL && P_ApplyLightOffsetFine(lightnum, sector)) if (slope != NULL && sector != NULL && HWR_ApplyLightOffset(lightnum, sector))
{ {
const INT16 offset = (cv_glfakecontrast.value == 2) ? slope->hwLightOffset : ((INT16)slope->lightOffset * 8); const INT16 offset = (cv_glfakecontrast.value == 2) ? slope->hwLightOffset : ((INT16)slope->lightOffset * 8);
finallight += (fof ? -offset : offset); finallight += (fof ? -offset : offset);
finallight = CLAMP(finallight, 0, 255); finallight = CLAMP(finallight, 0, 255);
} }
@@ -721,7 +729,7 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
HWR_ProcessPolygon(&Surf, planeVerts, nrPlaneVerts, PolyFlags, shader, false); HWR_ProcessPolygon(&Surf, planeVerts, nrPlaneVerts, PolyFlags, shader, false);
if (gl_maphashorizonlines && subsector && !FOFsector && cv_glhorizonlines.value) if (subsector && subsector->hashorizon && cv_glhorizonlines.value)
{ {
// Horizon lines // Horizon lines
FOutVector horizonpts[6]; FOutVector horizonpts[6];
@@ -806,6 +814,268 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
#undef SETUP3DVERT #undef SETUP3DVERT
} }
static void HWR_RenderFOFHorizonPlane(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)
{
FSurfaceInfo Surf = {};
polyvertex_t *pv;
pslope_t *slope = NULL;
INT32 shader = SHADER_NONE;
size_t nrPlaneVerts;
INT32 i;
float height; // constant y for all points on the convex flat polygon
static float flatxref = 0.0f, flatyref = 0.0f;
static float fflatsize = 64.0f;
static INT32 flatflag = 63;
size_t len;
float tempxsow, tempytow;
float scrollx = 0.0f, scrolly = 0.0f;
float anglef = 0.0f, cosangf = 0.0f, sinangf = 0.0f;
angle_t angle = 0;
static FOutVector *planeVerts = NULL;
static UINT16 numAllocedPlaneVerts = 0;
poly_t *planepoly = xsub->planepoly;
if (!cv_glhorizonlines.value)
return;
if (!subsector || !subsector->hashorizon)
return;
// no convex poly were generated for this subsector
if (!planepoly)
return;
nrPlaneVerts = planepoly->numpts;
if (nrPlaneVerts < 3) // not even a triangle ?
return;
const sector_t *sec = FOFsector;
if (!(PolyFlags & PF_NoTexture))
{
HWR_GetFlat(lumpnum, R_NoEncore(FOFsector, !isceiling));
}
// Get the slope pointer to simplify future code
if (!isceiling && sec->f_slope)
slope = sec->f_slope;
else if (isceiling && sec->c_slope)
slope = sec->c_slope;
height = FixedToFloat(fixedheight);
// Allocate plane-vertex buffer if we need to
if (!planeVerts || nrPlaneVerts > numAllocedPlaneVerts)
{
numAllocedPlaneVerts = (UINT16)nrPlaneVerts;
Z_Free(planeVerts);
Z_Malloc(numAllocedPlaneVerts * sizeof (FOutVector), PU_LEVEL, &planeVerts);
}
len = W_LumpLength(lumpnum);
switch (len)
{
case 4194304: // 2048x2048 lump
fflatsize = 2048.0f;
flatflag = 2047;
break;
case 1048576: // 1024x1024 lump
fflatsize = 1024.0f;
flatflag = 1023;
break;
case 262144: // 512x512 lump
fflatsize = 512.0f;
flatflag = 511;
break;
case 65536: // 256x256 lump
fflatsize = 256.0f;
flatflag = 255;
break;
case 16384: // 128x128 lump
fflatsize = 128.0f;
flatflag = 127;
break;
case 1024: // 32x32 lump
fflatsize = 32.0f;
flatflag = 31;
break;
default: // 64x64 lump
fflatsize = 64.0f;
flatflag = 63;
break;
}
pv = planepoly->pts;
// reference point for flat texture coord for each vertex around the polygon
flatxref = static_cast<float>(static_cast<fixed_t>(pv->x) & (~flatflag)) / fflatsize;
flatyref = static_cast<float>(static_cast<fixed_t>(pv->y) & (~flatflag)) / fflatsize;
if (!isceiling) // it's a floor
{
scrollx = FixedToFloat(sec->floor_xoffs)/fflatsize;
scrolly = FixedToFloat(sec->floor_yoffs)/fflatsize;
angle = sec->floorpic_angle;
}
else // it's a ceiling
{
scrollx = FixedToFloat(sec->ceiling_xoffs)/fflatsize;
scrolly = FixedToFloat(sec->ceiling_yoffs)/fflatsize;
angle = sec->ceilingpic_angle;
}
if (angle) // Only needs to be done if there's an altered angle
{
// This needs to be done so that it scrolls in a different direction after rotation like software
tempxsow = flatxref;
tempytow = flatyref;
anglef = ANG2RAD(InvAngle(angle));
// This needs to be done so everything aligns after rotation
// It would be done so that rotation is done, THEN the translation, but I couldn't get it to rotate AND scroll like software does
cosangf = cosf(anglef);
sinangf = sinf(anglef);
flatxref = (tempxsow * cosangf) - (tempytow * sinangf);
flatyref = (tempxsow * sinangf) + (tempytow * cosangf);
}
#define SETUP3DVERT(vert, vx, vy) {\
/* Hurdler: add scrolling texture on floor/ceiling */\
vert->s = (float)(((vx) / fflatsize) - flatxref + scrollx);\
vert->t = (float)(flatyref - ((vy) / fflatsize) + scrolly);\
\
/* Need to rotate before translate */\
if (angle) /* Only needs to be done if there's an altered angle */\
{\
tempxsow = vert->s;\
tempytow = vert->t;\
vert->s = (tempxsow * cosangf) - (tempytow * sinangf);\
vert->t = (tempxsow * sinangf) + (tempytow * cosangf);\
}\
\
if (slope)\
{\
fixedheight = P_GetSlopeZAt(slope, FloatToFixed((vx)), FloatToFixed((vy)));\
height = FixedToFloat(fixedheight);\
}\
\
vert->x = (vx);\
vert->y = height;\
vert->z = (vy);\
\
}
HWR_Lighting(&Surf, lightlevel, planecolormap, false);
if (PolyFlags & (PF_Translucent|PF_Fog|PF_Additive|PF_Subtractive|PF_ReverseSubtract|PF_Multiplicative|PF_Environment))
{
Surf.PolyColor.s.alpha = (UINT8)alpha;
PolyFlags |= PF_Modulated;
}
else
PolyFlags |= PF_Masked|PF_Modulated;
if (HWR_UseShader())
{
if (PolyFlags & PF_Fog)
shader = SHADER_FOG;
else if (cv_ripplewater.value && (PolyFlags & PF_Ripple))
shader = SHADER_WATER;
else
shader = SHADER_FLOOR;
PolyFlags |= PF_ColorMapped;
}
// Horizon lines
FOutVector horizonpts[6];
float dist, vx, vy;
float x1, y1, xd, yd;
UINT8 numplanes, j;
vertex_t v; // For determining the closest distance from the line to the camera, to split render planes for minimum distortion;
static constexpr float renderdist = 27000.0f; // How far out to properly render the plane
static constexpr float farrenderdist = 32768.0f; // From here, raise plane to horizon level to fill in the line with some texture distortion
const seg_t *line = &segs[subsector->firstline];
for (i = 0; i < subsector->numlines; i++, line++)
{
if (line->polyseg)
continue;
line_t* ld = line->linedef;
if (LIKELY(ld->special != HORIZONSPECIAL))
continue;
if (R_PointOnSegSide(viewx, viewy, line) != 0)
continue;
P_ClosestPointOnLine(viewx, viewy, ld, &v);
dist = FixedToFloat(R_PointToDist(v.x, v.y));
x1 = (line->fv1.x);
y1 = (line->fv1.y);
xd = (line->fv2.x) - x1;
yd = (line->fv2.y) - y1;
// Based on the seg length and the distance from the line, split horizon into multiple poly sets to reduce distortion
dist = sqrtf((xd*xd) + (yd*yd)) / dist / 16.0f;
if (dist > 100.0f)
numplanes = 100;
else
numplanes = (UINT8)dist + 1;
for (j = 0; j < numplanes; j++)
{
// Left side
vx = x1 + xd * j / numplanes;
vy = y1 + yd * j / numplanes;
SETUP3DVERT((&horizonpts[1]), vx, vy);
dist = sqrtf(powf(vx - gl_viewx, 2) + powf(vy - gl_viewy, 2));
vx = (vx - gl_viewx) * renderdist / dist + gl_viewx;
vy = (vy - gl_viewy) * renderdist / dist + gl_viewy;
SETUP3DVERT((&horizonpts[0]), vx, vy);
// Right side
vx = x1 + xd * (j+1) / numplanes;
vy = y1 + yd * (j+1) / numplanes;
SETUP3DVERT((&horizonpts[2]), vx, vy);
dist = sqrtf(powf(vx - gl_viewx, 2) + powf(vy - gl_viewy, 2));
vx = (vx - gl_viewx) * renderdist / dist + gl_viewx;
vy = (vy - gl_viewy) * renderdist / dist + gl_viewy;
SETUP3DVERT((&horizonpts[3]), vx, vy);
// Horizon fills
vx = (horizonpts[0].x - gl_viewx) * farrenderdist / renderdist + gl_viewx;
vy = (horizonpts[0].z - gl_viewy) * farrenderdist / renderdist + gl_viewy;
SETUP3DVERT((&horizonpts[5]), vx, vy);
horizonpts[5].y = gl_viewz;
vx = (horizonpts[3].x - gl_viewx) * farrenderdist / renderdist + gl_viewx;
vy = (horizonpts[3].z - gl_viewy) * farrenderdist / renderdist + gl_viewy;
SETUP3DVERT((&horizonpts[4]), vx, vy);
horizonpts[4].y = gl_viewz;
// Draw
HWR_ProcessPolygon(&Surf, horizonpts, 6, PolyFlags, shader, true);
}
}
#undef SETUP3DVERT
}
#ifdef WALLSPLATS #ifdef WALLSPLATS
static void HWR_DrawSegsSplats(FSurfaceInfo * pSurf) static void HWR_DrawSegsSplats(FSurfaceInfo * pSurf)
{ {
@@ -2960,16 +3230,14 @@ static void HWR_Subsector(size_t num)
UINT8 alpha; UINT8 alpha;
light = R_GetPlaneLight(gl_frontsector, centerHeight, underside); light = R_GetPlaneLight(gl_frontsector, centerHeight, underside);
alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap); alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap);
HWR_AddTransparentFloor(0, HWR_AddTransparentFloor(0,
&extrasubsectors[num], &extrasubsectors[num],
!bottom, !bottom,
roverheight, roverheight,
*gl_frontsector->lightlist[light].lightlevel, *gl_frontsector->lightlist[light].lightlevel,
alpha, rover->master->frontsector, PF_Fog|PF_NoTexture, alpha, rover->master->frontsector, PF_Fog|PF_NoTexture,
true, rover->master->frontsector->extra_colormap); true, rover->master->frontsector->extra_colormap, sub);
} }
else if ((rover->flags & FF_TRANSLUCENT && rover->alpha < 256) || rover->blend) // SoM: Flags are more efficient else if ((rover->flags & FF_TRANSLUCENT && rover->alpha < 256) || rover->blend) // SoM: Flags are more efficient
{ {
@@ -2981,13 +3249,12 @@ static void HWR_Subsector(size_t num)
roverheight, roverheight,
*gl_frontsector->lightlist[light].lightlevel, *gl_frontsector->lightlist[light].lightlevel,
CLAMP(rover->alpha, 0, 255), rover->master->frontsector, HWR_RippleBlend(gl_frontsector, rover, false) | (rover->blend ? HWR_GetBlendModeFlag(rover->blend) : static_cast<FBITFIELD>(PF_Translucent)), CLAMP(rover->alpha, 0, 255), rover->master->frontsector, HWR_RippleBlend(gl_frontsector, rover, false) | (rover->blend ? HWR_GetBlendModeFlag(rover->blend) : static_cast<FBITFIELD>(PF_Translucent)),
false, gl_frontsector->lightlist[light].extra_colormap); false, gl_frontsector->lightlist[light].extra_colormap, sub);
} }
else else
{ {
HWR_GetFlat(flatlump, R_NoEncore(rover->master->frontsector, bottom)); HWR_GetFlat(flatlump, R_NoEncore(rover->master->frontsector, bottom));
light = R_GetPlaneLight(gl_frontsector, centerHeight, underside); light = R_GetPlaneLight(gl_frontsector, centerHeight, underside);
HWR_RenderPlane(sub, &extrasubsectors[num], !bottom, roverheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, flatlump, HWR_RenderPlane(sub, &extrasubsectors[num], !bottom, roverheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, flatlump,
rover->master->frontsector, 255, gl_frontsector->lightlist[light].extra_colormap); rover->master->frontsector, 255, gl_frontsector->lightlist[light].extra_colormap);
} }
@@ -4191,7 +4458,7 @@ static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, I
wallinfo->wallcolormap = wallcolormap; wallinfo->wallcolormap = wallcolormap;
} }
static 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) static 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, subsector_t *subsector)
{ {
planeinfo_t *planeinfo = static_cast<planeinfo_t*>(HWR_CreateDrawNode(DRAWNODE_PLANE)); planeinfo_t *planeinfo = static_cast<planeinfo_t*>(HWR_CreateDrawNode(DRAWNODE_PLANE));
@@ -4205,6 +4472,9 @@ static void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, b
planeinfo->blend = blend; planeinfo->blend = blend;
planeinfo->fogplane = fogplane; planeinfo->fogplane = fogplane;
planeinfo->planecolormap = planecolormap; planeinfo->planecolormap = planecolormap;
// horizonplanes need to be drawn BEFORE skywalls, so lets hope this works without too many issues....
HWR_RenderFOFHorizonPlane(subsector, planeinfo->xsub, planeinfo->isceiling, planeinfo->fixedheight, planeinfo->blend, planeinfo->lightlevel, planeinfo->lumpnum, planeinfo->FOFSector, (UINT8)planeinfo->alpha, planeinfo->planecolormap);
} }
// Adding this for now until I can create extrasubsector info for polyobjects // Adding this for now until I can create extrasubsector info for polyobjects
@@ -5728,8 +5998,7 @@ void HWR_RenderPlayerView(void)
if (HWR_UseShader()) if (HWR_UseShader())
{ {
if (cv_ripplewater.value) GL_SetShaderInfo(HWD_SHADERINFO_LEVELTIME, (INT32)leveltime); // The water surface shader needs the leveltime.
GL_SetShaderInfo(HWD_SHADERINFO_LEVELTIME, (INT32)leveltime); // The water surface shader needs the leveltime.
if (cv_glmdls.value) if (cv_glmdls.value)
{ {
@@ -5738,7 +6007,7 @@ void HWR_RenderPlayerView(void)
const angle_t light_angle = maplighting.angle - viewangle + ANGLE_90; // I fucking hate OGL's coordinate system const angle_t light_angle = maplighting.angle - viewangle + ANGLE_90; // I fucking hate OGL's coordinate system
GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_X, FINECOSINE(light_angle >> ANGLETOFINESHIFT)); GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_X, FINECOSINE(light_angle >> ANGLETOFINESHIFT));
GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_Y, 0); GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_Y, 0);
GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_Z, -FINESINE(light_angle >> ANGLETOFINESHIFT)); GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_Z, -FINESINE(light_angle >> ANGLETOFINESHIFT));
} }
GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_CONTRAST, maplighting.contrast); GL_SetShaderInfo(HWD_SHADERINFO_LIGHT_CONTRAST, maplighting.contrast);
@@ -6088,42 +6357,58 @@ static void HWR_DoPostProcessor(void)
GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1); GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);
// Drunken vision! WooOOooo~ // Drunken vision! WooOOooo~
// 10 by 10 grid. 2 coordinates (xy)
float v[SCREENVERTS][SCREENVERTS][2];
float disStart = (leveltime-1) + FixedToFloat(R_GetTimeFrac(RTF_LEVEL));
UINT8 x, y; // shader based, should be a bit faster!
float WAVELENGTH; if (HWR_UseShader())
float AMPLITUDE;
float FREQUENCY;
// Modifies the wave.
if (thiscam->postimg & POSTIMG_WATER)
{ {
WAVELENGTH = 5.0f; if (thiscam->postimg & POSTIMG_WATER)
AMPLITUDE = 40.0f; {
FREQUENCY = 8.0f; GL_DoPostProcessor(POSTIMG_WATER);
}
else if (thiscam->postimg & POSTIMG_HEAT)
{
GL_DoPostProcessor(POSTIMG_HEAT);
}
} }
else else
{ {
WAVELENGTH = 10.0f; // 10 by 10 grid. 2 coordinates (xy)
AMPLITUDE = 60.0f; float v[SCREENVERTS][SCREENVERTS][2];
FREQUENCY = 4.0f; float disStart = (leveltime-1) + FixedToFloat(R_GetTimeFrac(RTF_LEVEL));
}
//static constexpr float scale = ((float)SCREENVERTS - 1.0f) / 9.0f; // well this evals to just 1.0f and what is x / 1? kek UINT8 x, y;
float WAVELENGTH;
float AMPLITUDE;
float FREQUENCY;
for (x = 0; x < SCREENVERTS; x++) // Modifies the wave.
{ if (thiscam->postimg & POSTIMG_WATER)
for (y = 0; y < SCREENVERTS; y++)
{ {
// Change X position based on its Y position. WAVELENGTH = 5.0f;
v[x][y][0] = x-4.5f + sinf(((disStart+(static_cast<float>(y) * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale) AMPLITUDE = 40.0f;
v[x][y][1] = y-4.5f; // (y / scale) FREQUENCY = 8.0f;
}
else
{
WAVELENGTH = 10.0f;
AMPLITUDE = 60.0f;
FREQUENCY = 4.0f;
} }
}
GL_PostImgRedraw(v); //static constexpr float scale = ((float)SCREENVERTS - 1.0f) / 9.0f; // well this evals to just 1.0f and what is x / 1? kek
for (x = 0; x < SCREENVERTS; x++)
{
for (y = 0; y < SCREENVERTS; y++)
{
// Change X position based on its Y position.
v[x][y][0] = x-4.5f + sinf(((disStart+(static_cast<float>(y) * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale)
v[x][y][1] = y-4.5f; // (y / scale)
}
}
GL_PostImgRedraw(v);
}
// Capture the screen again for screen waving on the intermission // Capture the screen again for screen waving on the intermission
if (gamestate != GS_INTERMISSION) if (gamestate != GS_INTERMISSION)
+2 -3
View File
@@ -145,9 +145,9 @@ FUNCINLINE static ATTRINLINE void HWR_DrawIntermissionBG(void)
GL_DrawScreenTexture(HWD_SCREENTEXTURE_GENERIC1, NULL, 0); GL_DrawScreenTexture(HWD_SCREENTEXTURE_GENERIC1, NULL, 0);
} }
FUNCINLINE static ATTRINLINE void HWR_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize) FUNCINLINE static ATTRINLINE void HWR_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize, boolean rewind)
{ {
GL_RenderVhsEffect(upbary, downbary, updistort, downdistort, barsize); GL_RenderVhsEffect(upbary, downbary, updistort, downdistort, barsize, rewind);
} }
FUNCINLINE static ATTRINLINE void HWR_MakeScreenTexture(void) FUNCINLINE static ATTRINLINE void HWR_MakeScreenTexture(void)
@@ -171,7 +171,6 @@ void HWR_ProcessSeg(void); // Sort of like GLWall::Process in GZDoom
// hw_bsp.c // hw_bsp.c
void HWR_CreatePlanePolygons(INT32 bspnum); void HWR_CreatePlanePolygons(INT32 bspnum);
extern boolean gl_maphasportals; extern boolean gl_maphasportals;
extern boolean gl_maphashorizonlines;
// Console variables // Console variables
extern CV_PossibleValue_t glanisotropicmode_cons_t[]; extern CV_PossibleValue_t glanisotropicmode_cons_t[];
+12
View File
@@ -53,6 +53,15 @@ static struct {
// UI colormap fade shader // UI colormap fade shader
{GLSL_DEFAULT_VERTEX_SHADER, GLSL_UI_COLORMAP_FADE_FRAGMENT_SHADER}, {GLSL_DEFAULT_VERTEX_SHADER, GLSL_UI_COLORMAP_FADE_FRAGMENT_SHADER},
// water postprocess shader
{GLSL_DEFAULT_VERTEX_SHADER, GLSL_POSTPROCESS_FRAGMENT_WATER},
// heat postprocess shader
{GLSL_DEFAULT_VERTEX_SHADER, GLSL_POSTPROCESS_FRAGMENT_HEAT},
// VHS effect
{GLSL_DEFAULT_VERTEX_SHADER, GLSL_VHS_SHADER},
{NULL, NULL}, {NULL, NULL},
}; };
@@ -444,6 +453,9 @@ customshaderxlat_t shaderxlat[] =
{"Sky", SHADER_SKY}, {"Sky", SHADER_SKY},
{"PalettePostprocess", SHADER_PALETTE_POSTPROCESS}, {"PalettePostprocess", SHADER_PALETTE_POSTPROCESS},
{"UIColormapFade", SHADER_UI_COLORMAP_FADE}, {"UIColormapFade", SHADER_UI_COLORMAP_FADE},
{"PostProcessWater", SHADER_POSTPROCESS_WATER},
{"PostProcessHeat", SHADER_POSTPROCESS_HEAT},
{"VHS", SHADER_VHS},
{NULL, 0}, {NULL, 0},
}; };
+118 -1
View File
@@ -196,7 +196,11 @@
// hand tuned adjustments for light level calculation // hand tuned adjustments for light level calculation
#define GLSL_FLOOR_FUDGES \ #define GLSL_FLOOR_FUDGES \
"#define STARTMAP_FUDGE 1.06\n" \ "#define STARTMAP_FUDGE 1.06\n" \
"#define SCALE_FUDGE 1.15\n" "#ifdef SRB2_PALETTE_RENDERING\n" \
"#define SCALE_FUDGE 1.3\n" \
"#else\n" \
"#define SCALE_FUDGE 1.15\n" \
"#endif\n"
#define GLSL_WALL_FUDGES \ #define GLSL_WALL_FUDGES \
"#define STARTMAP_FUDGE 1.05\n" \ "#define STARTMAP_FUDGE 1.05\n" \
@@ -337,6 +341,119 @@
"gl_FragColor = texture2D(lighttable_tex, lighttable_coord);\n" \ "gl_FragColor = texture2D(lighttable_tex, lighttable_coord);\n" \
"}\0" \ "}\0" \
// these are RRs postprocess shaders
// for water and heat
/*
#define GLSL_POSTPROCESS_FRAGMENT_WATER \
"uniform sampler2D tex;\n" \
"uniform vec2 scr_resolution;\n" \
"uniform vec2 scr_tex_size;\n" \
"uniform float leveltime;\n" \
"void main(void) {\n" \
"vec2 uv = gl_TexCoord[0].st;\n" \
"vec2 maxuv = scr_resolution / scr_tex_size;\n" \
"float y = 1.0 - uv.y;\n" \
"uv.x += sin(leveltime * 2.0 + y * 20.0) * 0.01;\n" \
"uv = clamp(uv, vec2(0.0), maxuv - vec2(0.0001));\n" \
"gl_FragColor = texture2D(tex, uv);\n" \
"}\0"
#define GLSL_POSTPROCESS_FRAGMENT_HEAT \
"uniform sampler2D tex;\n" \
"uniform vec2 scr_resolution;\n" \
"uniform vec2 scr_tex_size;\n" \
"uniform float leveltime;\n" \
"void main(void) {\n" \
"vec2 uv = gl_TexCoord[0].st;\n" \
"vec2 maxuv = scr_resolution / scr_tex_size;\n" \
"float y = 1.0 - uv.y;\n" \
"float time = leveltime * 35.0;\n" \
"uv.x += max(sin((time / 35.0) * 1.2 - y * 5.0) - 0.995, 0.0);\n" \
"uv.x -= max(sin(((time + 24.0) / 35.0) * 0.2 - y * 1.5) - 0.990, 0.0);\n" \
"uv = clamp(uv, vec2(0.0), maxuv - vec2(0.0001));\n" \
"gl_FragColor = texture2D(tex, uv);\n" \
"}\0"
*/
// for reference
// sin(leveltime * X + (y) + Y) * Z
// X = Speed, Y = Vertical phase, Z = Amplitude
// this matches software at 720p wonderfully
#define GLSL_POSTPROCESS_FRAGMENT_WATER \
"#version 120\n" \
"uniform sampler2D tex;\n" \
"uniform vec2 scr_resolution;\n" \
"uniform vec2 scr_tex_size;\n" \
"uniform float leveltime;\n" \
"void main(void) {\n" \
"vec2 uv = gl_TexCoord[0].st;\n" \
"vec2 maxuv = scr_resolution / scr_tex_size;\n" \
"float y = 1.0 - uv.y;\n" \
"uv.x += sin(leveltime * 3.0 + y * 15.0) * 0.0025;\n" \
"uv = clamp(uv, vec2(0.0), maxuv - vec2(0.0001));\n" \
"gl_FragColor = texture2D(tex, uv);\n" \
"}\0"
// like the fixed function version, this is just the water wave again
// a bit readjusted since the shader wave is more lean
// makes it less neausiating anyways :p
#define GLSL_POSTPROCESS_FRAGMENT_HEAT \
"#version 120\n" \
"uniform sampler2D tex;\n" \
"uniform vec2 scr_resolution;\n" \
"uniform vec2 scr_tex_size;\n" \
"uniform float leveltime;\n" \
"void main(void) {\n" \
"vec2 uv = gl_TexCoord[0].st;\n" \
"vec2 maxuv = scr_resolution / scr_tex_size;\n" \
"float y = 1.0 - uv.y;\n" \
"uv.x += sin(leveltime * 6.0 + y * 22.5) * 0.00125;\n" \
"uv = clamp(uv, vec2(0.0), maxuv - vec2(0.0001));\n" \
"gl_FragColor = texture2D(tex, uv);\n" \
"}\0"
// VHS effect as a shader
// basically just what we did before as a shader lul
// the bars are just the RR heat shader repurposed
// thanks "stackoverflow.com/a/4275343" for the pseudo random stuff for glsl
// and thanks "thndl.com/triangle-waves" and "gamedev.stackexchange.com/q/191829"
// for the maths since im super bad at stuff
// 0.159155 = 1/pi*2
#define GLSL_VHS_SHADER \
"#version 120\n" \
"uniform sampler2D tex;\n" \
"uniform vec2 scr_resolution;\n" \
"uniform vec2 scr_tex_size;\n" \
"uniform float vhs_time;\n" \
"uniform float vhs_rewind;\n" \
"void main(void) {\n" \
"vec2 uv = gl_TexCoord[0].st;\n" \
"vec2 maxuv = scr_resolution / scr_tex_size;\n" \
"float y = (1.0 - uv.y);\n" \
"float ystep = floor(y * (800 / 2.0));\n" \
"float rand = fract(sin((ystep + vhs_time) * 12.9898 + 78.233) * 43758.5453);\n" \
"uv.x -= floor(rand * 128.0) / -22000.0;\n" \
"float updistort = (vhs_rewind > 0.5) ? 0.266667 : 0.16;\n" \
"float downdistort = updistort / 2.0;\n" \
"float downspd = (vhs_rewind > 0.5) ? 2.0 : 1.0;\n" \
"float upspd = (vhs_rewind > 0.5) ? 3.0 : 1.8;\n" \
"float downbar = max((1.0 - abs(2.0 * fract((vhs_time * downspd - y * 5.0) * 0.159155) - 1.0)) - 0.87, 0.0);\n" \
"float upbar = max((1.0 - abs(2.0 * fract(((vhs_time * -1.0) * upspd - y * 5.0) * 0.159155) - 1.0)) - 0.87, 0.0);\n" \
"uv.x -= downbar * downdistort;\n" \
"uv.x += upbar * updistort;\n" \
"uv.y = clamp(uv.y, 0.0, maxuv.y - 0.0001);\n" \
"uv.x = mod(uv.x, maxuv.x - 0.0001);\n" \
"vec4 color = texture2D(tex, uv);\n" \
"float downcol = step(0.00001, downbar);\n" \
"float upcol = step(0.00001, upbar);\n" \
"color.rgb = mix(color.rgb, color.rgb * (210.0 / 255.0), downcol);\n" \
"color.rgb = mix(color.rgb, color.rgb * (210.0 / 255.0), upcol);\n" \
"color.a = mix(color.a, color.a * (250.0 / 255.0), downcol);\n" \
"color.a = mix(color.a, color.a * (250.0 / 255.0), upcol);\n" \
"gl_FragColor = color;\n" \
"}\0"
// ================ // ================
// Fallback shaders // Fallback shaders
// ================ // ================
+427 -107
View File
@@ -141,26 +141,56 @@ enum
typedef struct typedef struct
{ {
GLuint fboobj; // actual Framebuffer Object GLuint fboobj; // normal single sample fbo
GLuint rboobj; // Renderbuffer Object GLuint rboobj; // normal single sample rbo for depth and stencil stuff
GLuint tex; // Framebuffer texture GLuint tex; // fbo texture for color
GLuint msaa_fboobj; // msaa fbo
GLuint msaa_rboobj; // msaa rbo for color this time
GLuint msaa_depthrboobj; // msaa rbo for depth and stencil stuff
boolean init; boolean init;
boolean msaa; // true if the msaa fbo is the render target ugh
boolean bound; // true if the fbo is currently bound as the framebuffer
} fboobj_t; } fboobj_t;
// this is a little messy but less messy than having two of those tbh
static fboobj_t framebufferobject = {}; static fboobj_t framebufferobject = {};
int supportFBO = FBO_NONE; int supportFBO = FBO_NONE;
// older gl versions might not have these, so prevent compile errors // older gl versions might not have these, so prevent compile errors
// this should still give a simple depth only rbo #ifndef GL_DEPTH_COMPONENT
#define GL_DEPTH_COMPONENT 0x1902
#endif
#ifndef GL_DEPTH_ATTACHMENT_EXT
#define GL_DEPTH_ATTACHMENT_EXT 0x8D00
#endif
#ifndef GL_DEPTH24_STENCIL8 #ifndef GL_DEPTH24_STENCIL8
GL_DEPTH24_STENCIL8 GL_DEPTH_COMPONENT_EXT #define GL_DEPTH24_STENCIL8 0x88F0
#endif #endif
#ifndef GL_DEPTH_STENCIL_ATTACHMENT #ifndef GL_DEPTH_STENCIL_ATTACHMENT
GL_DEPTH_STENCIL_ATTACHMENT GL_DEPTH_ATTACHMENT_EXT #define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
#endif
#ifndef GL_COLOR_ATTACHMENT0_EXT
#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0
#endif
#ifndef GL_READ_FRAMEBUFFER_EXT
#define GL_READ_FRAMEBUFFER_EXT 0x8CA8
#endif
#ifndef GL_DRAW_FRAMEBUFFER_EXT
#define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9
#endif
#ifndef GL_FRAMEBUFFER_EXT
#define GL_FRAMEBUFFER_EXT 0x8D40
#endif
#ifndef GL_RENDERBUFFER_EXT
#define GL_RENDERBUFFER_EXT 0x8D41
#endif
#ifndef GL_FRAMEBUFFER_COMPLETE_EXT
#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5
#endif #endif
static void GL_FBO_DeleteAttachments(void); static void GL_FBO_DeleteAttachments(void);
static void GL_FBO_Resolve(GLbitfield mask);
#endif #endif
// needed for glportals // needed for glportals
@@ -478,6 +508,10 @@ typedef void (APIENTRY * PFNglRenderbufferStorage) (GLenum target, GLenum intern
static PFNglRenderbufferStorage pglRenderbufferStorage; static PFNglRenderbufferStorage pglRenderbufferStorage;
typedef void (APIENTRY * PFNglFramebufferRenderbuffer) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLenum renderbuffer); typedef void (APIENTRY * PFNglFramebufferRenderbuffer) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLenum renderbuffer);
static PFNglFramebufferRenderbuffer pglFramebufferRenderbuffer; static PFNglFramebufferRenderbuffer pglFramebufferRenderbuffer;
typedef void (APIENTRY * PFNglRenderbufferStorageMultisample) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
static PFNglRenderbufferStorageMultisample pglRenderbufferStorageMultisample;
typedef void (APIENTRY * PFNglBlitFramebuffer) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
static PFNglBlitFramebuffer pglBlitFramebuffer;
/* 2.1 extension functions for framebuffers and renderbuffers */ /* 2.1 extension functions for framebuffers and renderbuffers */
typedef void (APIENTRY * PFNglGenFramebuffersEXT) (GLsizei n, GLuint *ids); typedef void (APIENTRY * PFNglGenFramebuffersEXT) (GLsizei n, GLuint *ids);
@@ -727,6 +761,13 @@ typedef enum
gluniform_scr_resolution, gluniform_scr_resolution,
// postprocess stuff
gluniform_scr_tex_size,
// vhs
gluniform_vhs_rewind,
gluniform_vhs_time,
gluniform_max, gluniform_max,
} gluniform_t; } gluniform_t;
@@ -759,6 +800,9 @@ static float shader_light_z = 0.0f;
static INT32 shader_light_contrast = 0; static INT32 shader_light_contrast = 0;
static INT32 shader_light_backlight = 0; static INT32 shader_light_backlight = 0;
static float shader_vhs_rewind = 1.0f;
static float shader_vhs_time = 0.0f;
// Lactozilla: Shader functions // Lactozilla: Shader functions
static boolean GL_Shader_CompileProgram(gl_shader_t *shader, GLint i); static boolean GL_Shader_CompileProgram(gl_shader_t *shader, GLint i);
static void GL_Shader_SetUniforms(FSurfaceInfo *Surface, GLRGBAFloat *poly, GLRGBAFloat *tint, GLRGBAFloat *fade); static void GL_Shader_SetUniforms(FSurfaceInfo *Surface, GLRGBAFloat *poly, GLRGBAFloat *tint, GLRGBAFloat *fade);
@@ -899,6 +943,17 @@ void SetupGLFunc4(void)
GetGLfunc(glRenderbufferStorage); GetGLfunc(glRenderbufferStorage);
GetGLfunc(glFramebufferRenderbuffer); GetGLfunc(glFramebufferRenderbuffer);
// multisample support, this should be in core per gl 3.0 and newer
pglRenderbufferStorageMultisample = GetGLFunc("glRenderbufferStorageMultisample");
pglBlitFramebuffer = GetGLFunc("glBlitFramebuffer");
if (!pglRenderbufferStorageMultisample || !pglBlitFramebuffer)
{
pglRenderbufferStorageMultisample = NULL;
pglBlitFramebuffer = NULL;
GL_DBG_Printf("\nFBO: No multisample support\n");
}
GL_DBG_Printf("\nFBO: ARB extensions found\n"); GL_DBG_Printf("\nFBO: ARB extensions found\n");
} }
else if (fbocheck == FBO_EXT) // uh oh only support old fbo extensions... else if (fbocheck == FBO_EXT) // uh oh only support old fbo extensions...
@@ -935,6 +990,21 @@ void SetupGLFunc4(void)
GetGLfunc(glFramebufferRenderbufferEXT); GetGLfunc(glFramebufferRenderbufferEXT);
pglFramebufferRenderbuffer = pglFramebufferRenderbufferEXT; pglFramebufferRenderbuffer = pglFramebufferRenderbufferEXT;
// multisample support needs the EXT multisample and blit extensions
if (GL_isExtAvailable("GL_EXT_framebuffer_multisample", gl_extensions) &&
GL_isExtAvailable("GL_EXT_framebuffer_blit", gl_extensions))
{
pglRenderbufferStorageMultisample = GetGLFunc("glRenderbufferStorageMultisampleEXT");
pglBlitFramebuffer = GetGLFunc("glBlitFramebufferEXT");
}
if (!pglRenderbufferStorageMultisample || !pglBlitFramebuffer)
{
pglRenderbufferStorageMultisample = NULL;
pglBlitFramebuffer = NULL;
GL_DBG_Printf("\nFBO: No multisample support\n");
}
GL_DBG_Printf("\nFBO: EXT extensions with packed depth-stencil\n"); GL_DBG_Printf("\nFBO: EXT extensions with packed depth-stencil\n");
} }
@@ -1455,6 +1525,15 @@ void GL_ReadScreenTexture(int tex, UINT8 *restrict dest, INT32 scale)
const INT32 stride = (screen_width/scale)*3; const INT32 stride = (screen_width/scale)*3;
INT32 scanlines = screen_height; INT32 scanlines = screen_height;
GLubyte * restrict image; GLubyte * restrict image;
#ifdef USE_FBO_OGL
const boolean msaa_fbo = (framebufferobject.bound && framebufferobject.msaa);
#endif
#ifdef USE_FBO_OGL
// cant read from the msaa fbo, so gotta blit it first into either the single sample fbo or the screen framebuffer....
if (msaa_fbo)
GL_FBO_Resolve(GL_COLOR_BUFFER_BIT);
#endif
// at the time this function is called, generic2 can be found drawn on the framebuffer // at the time this function is called, generic2 can be found drawn on the framebuffer
// if some other screen texture is needed, draw it to the framebuffer // if some other screen texture is needed, draw it to the framebuffer
@@ -1496,9 +1575,16 @@ void GL_ReadScreenTexture(int tex, UINT8 *restrict dest, INT32 scale)
memcpy(dest + i, image + i*scale, 3); memcpy(dest + i, image + i*scale, 3);
dest += stride; dest += stride;
} }
// this probably could be done with fbos, might mess around with that some time :3
// ...yet still, restrict doesn't make the inner loop any faster // ...yet still, restrict doesn't make the inner loop any faster
free(image - ((screen_height % scale) * screen_width*3)); free(image - ((screen_height % scale) * screen_width*3));
#ifdef USE_FBO_OGL
// this´ll reenable the msaa fbo....
if (msaa_fbo)
GL_FBO_Enable();
#endif
} }
// -----------------+ // -----------------+
@@ -2252,7 +2338,13 @@ static void GL_Shader_SetUniforms(FSurfaceInfo *Surface, GLRGBAFloat *poly, GLRG
UNIFORM_1(shader->uniforms[gluniform_leveltime], shader_leveltime, pglUniform1f); UNIFORM_1(shader->uniforms[gluniform_leveltime], shader_leveltime, pglUniform1f);
UNIFORM_2(shader->uniforms[gluniform_scr_resolution], (GLfloat)vid.width, (GLfloat)vid.height, pglUniform2f); UNIFORM_2(shader->uniforms[gluniform_scr_resolution], (GLfloat)screen_width, (GLfloat)screen_height, pglUniform2f);
// grrrrr stupid 2.0 support.. used similar to yfix, xfix
UNIFORM_2(shader->uniforms[gluniform_scr_tex_size], (GLfloat)screen_texsizew, (GLfloat)screen_texsizeh, pglUniform2f);
UNIFORM_1(shader->uniforms[gluniform_vhs_rewind], shader_vhs_rewind, pglUniform1f);
UNIFORM_1(shader->uniforms[gluniform_vhs_time], shader_vhs_time, pglUniform1f);
#undef UNIFORM_1 #undef UNIFORM_1
#undef UNIFORM_2 #undef UNIFORM_2
@@ -2385,6 +2477,14 @@ static boolean GL_Shader_CompileProgram(gl_shader_t *shader, GLint i)
// misc. // misc.
shader->uniforms[gluniform_leveltime] = GETUNI("leveltime"); shader->uniforms[gluniform_leveltime] = GETUNI("leveltime");
// postprocessor stuff (water/heat effect)
shader->uniforms[gluniform_scr_tex_size] = GETUNI("scr_tex_size");
// vhs stuff
shader->uniforms[gluniform_vhs_rewind] = GETUNI("vhs_rewind");
shader->uniforms[gluniform_vhs_time] = GETUNI("vhs_time");
#undef GETUNI #undef GETUNI
// set permanent uniform values // set permanent uniform values
@@ -3242,7 +3342,7 @@ void GL_SetTransform(FTransform *stransform)
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
static void GL_FBO_DeleteAttachments(void) static void GL_FBO_DeleteAttachments(void)
{ {
if (supportFBO == FBO_NONE || !framebufferobject.init) if (supportFBO == FBO_NONE)
return; return;
// Unbind the framebuffer // Unbind the framebuffer
@@ -3255,13 +3355,44 @@ static void GL_FBO_DeleteAttachments(void)
if (framebufferobject.rboobj) if (framebufferobject.rboobj)
pglDeleteRenderbuffers(1, &framebufferobject.rboobj); pglDeleteRenderbuffers(1, &framebufferobject.rboobj);
if (framebufferobject.msaa_rboobj)
pglDeleteRenderbuffers(1, &framebufferobject.msaa_rboobj);
if (framebufferobject.msaa_depthrboobj)
pglDeleteRenderbuffers(1, &framebufferobject.msaa_depthrboobj);
framebufferobject.tex = 0; framebufferobject.tex = 0;
framebufferobject.rboobj = 0; framebufferobject.rboobj = 0;
framebufferobject.msaa_rboobj = 0;
framebufferobject.msaa_depthrboobj = 0;
framebufferobject.init = false; framebufferobject.init = false;
framebufferobject.bound = false;
}
// blit the msaa fbo into the normal single sample fbo
// so we can use it to copy from and stuff
static void GL_FBO_Resolve(GLbitfield mask)
{
if (supportFBO == FBO_NONE || !framebufferobject.init || !framebufferobject.msaa)
return;
if (!pglBlitFramebuffer)
return;
pglBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, framebufferobject.msaa_fboobj);
pglBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, framebufferobject.fboobj);
pglBlitFramebuffer(0, 0, screen_width, screen_height,
0, 0, screen_width, screen_height,
mask, GL_NEAREST);
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj);
} }
static void GL_FBO_Generate(void) static void GL_FBO_Generate(void)
{ {
GLint msaasamples;
if (supportFBO == FBO_NONE || framebufferobject.init) if (supportFBO == FBO_NONE || framebufferobject.init)
return; return;
@@ -3321,12 +3452,76 @@ static void GL_FBO_Generate(void)
GL_MSG_Error("GL_FBO_Generate: Failed to create Framebuffer Object"); GL_MSG_Error("GL_FBO_Generate: Failed to create Framebuffer Object");
// if this fails, dont retry it a gazillion times // if this fails, dont retry it a gazillion times
// this wouldnt recover // this probably wouldnt recover and we dont want any more black screens...
supportFBO = FBO_NONE; supportFBO = FBO_NONE;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
return; return;
} }
// Try to set up a multisampled render target for MSAA
framebufferobject.msaa = false;
msaasamples = (GLint)msaa;
// maybe should just make more "supportFBO" cases or smth but :chaosleep:
if (msaasamples > 1 && pglRenderbufferStorageMultisample && pglBlitFramebuffer)
{
if (!framebufferobject.msaa_fboobj)
pglGenFramebuffers(1, &framebufferobject.msaa_fboobj);
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.msaa_fboobj);
// Generate the multisampled color renderbuffer
if (!framebufferobject.msaa_rboobj)
{
pglGenRenderbuffers(1, &framebufferobject.msaa_rboobj);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.msaa_rboobj);
pglRenderbufferStorageMultisample(GL_RENDERBUFFER_EXT, msaasamples, GL_RGBA8, screen_width, screen_height);
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, framebufferobject.msaa_rboobj);
}
// Generate the multisampled depth/stencil renderbuffer
if (!framebufferobject.msaa_depthrboobj)
{
pglGenRenderbuffers(1, &framebufferobject.msaa_depthrboobj);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.msaa_depthrboobj);
if (supportFBO == FBO_ARB)
{
pglRenderbufferStorageMultisample(GL_RENDERBUFFER_EXT, msaasamples, GL_DEPTH24_STENCIL8, screen_width, screen_height);
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, framebufferobject.msaa_depthrboobj);
}
else if (supportFBO == FBO_EXT)
{
pglRenderbufferStorageMultisample(GL_RENDERBUFFER_EXT, msaasamples, GL_DEPTH_STENCIL_EXT, screen_width, screen_height);
// attach a renderbuffer to depth attachment point
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.msaa_depthrboobj);
// attach a renderbuffer to stencil attachment point
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.msaa_depthrboobj);
}
}
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0);
if (pglCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT)
{
framebufferobject.msaa = true;
GL_ClearBuffer(true, true, true, NULL);
GL_DBG_Printf("\nGL_FBO_Generate: Multisampled framebuffer created with %d samples\n", msaasamples);
}
else
{
GL_MSG_Warning("GL_FBO_Generate: Failed to create multisampled Framebuffer Object, falling back to no MSAA");
if (framebufferobject.msaa_rboobj)
pglDeleteRenderbuffers(1, &framebufferobject.msaa_rboobj);
if (framebufferobject.msaa_depthrboobj)
pglDeleteRenderbuffers(1, &framebufferobject.msaa_depthrboobj);
framebufferobject.msaa_rboobj = 0;
framebufferobject.msaa_depthrboobj = 0;
}
}
// Unbind the framebuffer // Unbind the framebuffer
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
@@ -3335,11 +3530,13 @@ static void GL_FBO_Generate(void)
void GL_FBO_BindMainFrameBuffer(void) void GL_FBO_BindMainFrameBuffer(void)
{ {
if (supportFBO == FBO_NONE || !framebufferobject.init) if (supportFBO == FBO_NONE)
return; return;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0); pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0);
framebufferobject.bound = false;
} }
void GL_FBO_Enable(void) void GL_FBO_Enable(void)
@@ -3353,13 +3550,23 @@ void GL_FBO_Enable(void)
if (!framebufferobject.init) if (!framebufferobject.init)
return; return;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj); if (framebufferobject.msaa)
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.rboobj); {
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.msaa_fboobj);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.msaa_rboobj);
}
else
{
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
}
framebufferobject.bound = true;
} }
void GL_FBO_Disable(void) void GL_FBO_Disable(void)
{ {
if (supportFBO == FBO_NONE || !framebufferobject.init) if (supportFBO == FBO_NONE)
return; return;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
@@ -3370,7 +3577,14 @@ void GL_FBO_Disable(void)
pglDeleteFramebuffers(1, &framebufferobject.fboobj); pglDeleteFramebuffers(1, &framebufferobject.fboobj);
framebufferobject.fboobj = 0; framebufferobject.fboobj = 0;
if (framebufferobject.msaa_fboobj)
pglDeleteFramebuffers(1, &framebufferobject.msaa_fboobj);
framebufferobject.msaa_fboobj = 0;
GL_FBO_DeleteAttachments(); GL_FBO_DeleteAttachments();
framebufferobject.msaa = false;
framebufferobject.bound = false;
} }
#endif #endif
@@ -3407,6 +3621,55 @@ INT32 GL_GetTextureUsed(void)
return res; return res;
} }
void GL_DoPostProcessor(INT32 type)
{
float fix[8];
float xfix, yfix;
if (gl_enable_screen_textures != 2)
return;
xfix = 1/((float)screen_texsizew/(float)screen_width);
yfix = 1/((float)screen_texsizeh/(float)screen_height);
fix[0] = fix[1] =
fix[2] = fix[7] = 0.0f;
fix[3] = fix[5] = yfix;
fix[4] = fix[6] = xfix;
// this shouldnt be necessary, since this comes after level draw
// but somehow it breaks without this??
pglMatrixMode(GL_PROJECTION);
pglPushMatrix();
pglLoadIdentity();
pglMatrixMode(GL_MODELVIEW);
pglPushMatrix();
pglLoadIdentity();
GL_SetBlend(PF_NoDepthTest);
pglActiveTexture(GL_TEXTURE0);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_GENERIC1]);
tex_downloaded = screenTextures[HWD_SCREENTEXTURE_GENERIC1];
int shader = (type == POSTIMG_WATER) ? SHADER_POSTPROCESS_WATER : SHADER_POSTPROCESS_HEAT;
GL_SetShader(HWR_GetShaderFromTarget(shader));
GL_Shader_SetUniforms(NULL, NULL, NULL, NULL);
pglColor4ubv(white);
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, defaultscreenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
GL_UnSetShader();
pglMatrixMode(GL_PROJECTION);
pglPopMatrix();
pglMatrixMode(GL_MODELVIEW);
pglPopMatrix();
}
void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2]) void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2])
{ {
INT32 x, y; INT32 x, y;
@@ -3526,7 +3789,6 @@ void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags)
tex_downloaded = screenTextures[tex]; tex_downloaded = screenTextures[tex];
} }
// Do screen fades! // Do screen fades!
void GL_DoScreenWipe(int wipeStart, int wipeEnd) void GL_DoScreenWipe(int wipeStart, int wipeEnd)
{ {
@@ -3601,120 +3863,164 @@ void GL_DoScreenWipe(int wipeStart, int wipeEnd)
tex_downloaded = screenTextures[wipeEnd]; tex_downloaded = screenTextures[wipeEnd];
} }
void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize) void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize, boolean rewind)
{ {
float xfix, yfix; float xfix, yfix;
float fix[8]; float fix[8];
float i;
if (gl_enable_screen_textures != 2) if (gl_enable_screen_textures != 2)
return; return;
GLubyte color[4] = {255, 255, 255, 255};
float screenVerts[12] =
{
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 1.0f
};
const GLfloat scrwf = (float)screen_width; const GLfloat scrwf = (float)screen_width;
const GLfloat scrwh = (float)screen_height; const GLfloat scrhf = (float)screen_height;
xfix = 1/((float)screen_texsizew/scrwf); xfix = 1/((float)screen_texsizew/scrwf);
yfix = 1/((float)screen_texsizeh/scrwh); yfix = 1/((float)screen_texsizeh/scrhf);
GL_SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest); // uses shaders to replicate the effect
// thanks RR for their heat effect being basically the vhs bars, made this lots easier lul
// Slight fuzziness if (HWR_UseShader())
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
uint32_t r = rand();
const float ystep = 2.f/scrwh * (float)vid.udup/4.f;
for (i = 0; i < 1; i += ystep)
{ {
// avoid calling rand thousands of times // leveltime pauses with the game so we need to keep our own counter here
r ^= r >> 13; static tic_t lleveltime = 0;
r ^= r >> 11; if (renderisnewtic) lleveltime++;
r ^= r << 21; shader_vhs_time = (((float)(lleveltime-1)) + FIXED_TO_FLOAT(R_GetTimeFrac(RTF_MENU))) / TICRATE;
fix[2] = (float)(r & 127) / -22000.f * xfix; // easier to account for within the shader
fix[0] = fix[2]; shader_vhs_rewind = rewind ? 1.0f : 0.0f;
fix[6] = fix[0] + xfix;
fix[4] = fix[2] + xfix;
fix[1] = fix[7] = i*yfix;
fix[3] = fix[5] = (i+0.015f)*yfix;
screenVerts[1] = screenVerts[10] = 2*i - 1.0f; fix[0] = fix[1] =
screenVerts[4] = screenVerts[7] = screenVerts[1] + 0.03f; fix[2] = fix[7] = 0.0f;
fix[3] = fix[5] = yfix;
fix[4] = fix[6] = xfix;
GL_SetBlend(PF_NoDepthTest);
// Slight fuzziness
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
pglActiveTexture(GL_TEXTURE0);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
tex_downloaded = screenTextures[HWD_SCREENTEXTURE_VHS];
GL_SetShader(HWR_GetShaderFromTarget(SHADER_VHS));
GL_Shader_SetUniforms(NULL, NULL, NULL, NULL);
pglColor4ubv(white);
pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, defaultscreenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
GL_UnSetShader();
}
else // fallback fixed function version, this is quite slow
{
float i;
GLubyte color[4] = {255, 255, 255, 255};
float screenVerts[12] =
{
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 1.0f
};
xfix = 1/((float)screen_texsizew/scrwf);
yfix = 1/((float)screen_texsizeh/scrhf);
GL_SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest);
// Slight fuzziness
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
uint32_t r = rand();
const float ystep = 2.f/scrhf * (float)vid.udup/4.f;
for (i = 0.0; i < 1.0; i += ystep)
{
// avoid calling rand thousands of times
r ^= r >> 13;
r ^= r >> 11;
r ^= r << 21;
fix[2] = (float)(r & 127) / -22000.f * xfix;
fix[0] = fix[2];
fix[6] = fix[0] + xfix;
fix[4] = fix[2] + xfix;
fix[1] = fix[7] = i*yfix;
fix[3] = fix[5] = (i+0.015f)*yfix;
screenVerts[1] = screenVerts[10] = 2*i - 1.0f;
screenVerts[4] = screenVerts[7] = screenVerts[1] + 0.03f;
pglColor4ubv(color);
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
// Upward bar
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
color[0] = color[1] = color[2] = 190;
color[3] = 250;
pglColor4ubv(color); pglColor4ubv(color);
fix[0] = 0.0f;
fix[6] = xfix;
fix[2] = (float)updistort / scrwf * xfix;
fix[4] = fix[2] + fix[6];
screenVerts[1] = screenVerts[10] = 2.0f*upbary/scrhf - 1.0f;
screenVerts[4] = screenVerts[7] = screenVerts[1] + (float)barsize/scrhf;
fix[1] = fix[7] = (float)upbary/scrhf * yfix;
fix[3] = fix[5] = fix[1] + (float)barsize/2/scrhf * yfix;
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
fix[1] = fix[7] += (fix[3] - fix[7])*2;
screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
// Downward bar
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
fix[0] = 0.0f;
fix[6] = xfix;
fix[2] = (float)downdistort / scrwf * -xfix;
fix[4] = fix[2] + fix[6];
screenVerts[1] = screenVerts[10] = 2.0f*downbary/scrhf - 1.0f;
screenVerts[4] = screenVerts[7] = screenVerts[1] + (float)barsize/scrhf;
fix[1] = fix[7] = (float)downbary/scrhf * yfix;
fix[3] = fix[5] = fix[1] + (float)barsize/2/scrhf * yfix;
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
fix[1] = fix[7] += (fix[3] - fix[7])*2;
screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
pglTexCoordPointer(2, GL_FLOAT, 0, fix); pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts); pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4); pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
} }
// Upward bar
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
color[0] = color[1] = color[2] = 190;
color[3] = 250;
pglColor4ubv(color);
fix[0] = 0.0f;
fix[6] = xfix;
fix[2] = (float)updistort / scrwf * xfix;
fix[4] = fix[2] + fix[6];
screenVerts[1] = screenVerts[10] = 2.0f*upbary/scrwh - 1.0f;
screenVerts[4] = screenVerts[7] = screenVerts[1] + (float)barsize/scrwh;
fix[1] = fix[7] = (float)upbary/scrwh * yfix;
fix[3] = fix[5] = fix[1] + (float)barsize/2/scrwh * yfix;
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
fix[1] = fix[7] += (fix[3] - fix[7])*2;
screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
// Downward bar
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
fix[0] = 0.0f;
fix[6] = xfix;
fix[2] = (float)downdistort / scrwf * -xfix;
fix[4] = fix[2] + fix[6];
screenVerts[1] = screenVerts[10] = 2.0f*downbary/scrwh - 1.0f;
screenVerts[4] = screenVerts[7] = screenVerts[1] + (float)barsize/scrwh;
fix[1] = fix[7] = (float)downbary/scrwh * yfix;
fix[3] = fix[5] = fix[1] + (float)barsize/2/scrwh * yfix;
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
fix[1] = fix[7] += (fix[3] - fix[7])*2;
screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
} }
// Create a texture from the screen. // Create a texture from the screen.
@@ -3722,10 +4028,19 @@ void GL_MakeScreenTexture(int tex)
{ {
boolean firstTime; boolean firstTime;
static GLint lastfiltermode[NUMSCREENTEXTURES] = {-1, -1, -1, -1, -1}; static GLint lastfiltermode[NUMSCREENTEXTURES] = {-1, -1, -1, -1, -1};
#ifdef USE_FBO_OGL
const boolean msaa_fbo = (framebufferobject.bound && framebufferobject.msaa);
#endif
if (!gl_enable_screen_textures) if (!gl_enable_screen_textures)
return; return;
#ifdef USE_FBO_OGL
// cant read from the msaa fbo, so gotta blit it first into either the single sample fbo or the screen framebuffer....
if (msaa_fbo)
GL_FBO_Resolve(GL_COLOR_BUFFER_BIT);
#endif
firstTime = (screenTextures[tex] == 0); firstTime = (screenTextures[tex] == 0);
// Create screen texture // Create screen texture
@@ -3759,6 +4074,11 @@ void GL_MakeScreenTexture(int tex)
} }
tex_downloaded = screenTextures[tex]; tex_downloaded = screenTextures[tex];
#ifdef USE_FBO_OGL
if (msaa_fbo)
GL_FBO_Enable();
#endif
} }
void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height) void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height)
-3
View File
@@ -118,11 +118,8 @@ void I_UpdateNoVsync(void);
*/ */
void I_ReadScreen(UINT8 * restrict scr, INT32 scale); void I_ReadScreen(UINT8 * restrict scr, INT32 scale);
UINT32 I_GetRefreshRate(void); UINT32 I_GetRefreshRate(void);
boolean I_CheckNativeRes(void);
void I_SetBorderlessWindow(void); void I_SetBorderlessWindow(void);
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
+141 -148
View File
@@ -344,19 +344,16 @@ static int mobj_get(lua_State *L)
lua_pushangle(L, mo->slopepitch); lua_pushangle(L, mo->slopepitch);
break; break;
case mobj_rollsum: case mobj_rollsum:
{
angle_t pitchnroll = P_MobjPitchAndRoll(mo);
angle_t rollsum = mo->rollangle + pitchnroll;
if (mo->player)
{ {
rollsum += R_PlayerSliptideAngle(mo->player); angle_t pitchnroll = P_MobjPitchAndRoll(mo);
angle_t rollsum = mo->rollangle + pitchnroll;
if (mo->player)
{
rollsum += R_PlayerSliptideAngle(mo->player);
}
lua_pushangle(L, rollsum);
} }
lua_pushangle(L, rollsum);
break; break;
}
case mobj_spritexscale: case mobj_spritexscale:
lua_pushfixed(L, mo->spritexscale); lua_pushfixed(L, mo->spritexscale);
break; break;
@@ -431,30 +428,24 @@ static int mobj_set(lua_State *L)
case mobj_y: case mobj_y:
return NOSETPOS; return NOSETPOS;
case mobj_z: case mobj_z:
{ {
// z doesn't cross sector bounds so it's okay. // z doesn't cross sector bounds so it's okay.
mobj_t *ptmthing = tmthing; mobj_t *ptmthing = tmthing;
mo->z = luaL_checkfixed(L, 3); mo->z = luaL_checkfixed(L, 3);
P_CheckPosition(mo, mo->x, mo->y); P_CheckPosition(mo, mo->x, mo->y);
mo->floorz = tmfloorz; mo->floorz = tmfloorz;
mo->ceilingz = tmceilingz; mo->ceilingz = tmceilingz;
P_SetTarget(&tmthing, ptmthing); P_SetTarget(&tmthing, ptmthing);
}
break; break;
}
case mobj_snext: case mobj_snext:
return NOSETPOS; return NOSETPOS;
case mobj_sprev: case mobj_sprev:
return UNIMPLEMENTED; return UNIMPLEMENTED;
case mobj_angle: case mobj_angle:
mo->angle = luaL_checkangle(L, 3); mo->angle = luaL_checkangle(L, 3);
if (mo->player == &players[consoleplayer]) if (mo->player)
localangle[0] = mo->angle; P_ForceLocalAngle(mo->player, mo->angle);
else if (mo->player == &players[displayplayers[1]])
localangle[1] = mo->angle;
else if (mo->player == &players[displayplayers[2]])
localangle[2] = mo->angle;
else if (mo->player == &players[displayplayers[3]])
localangle[3] = mo->angle;
break; break;
case mobj_sprite: case mobj_sprite:
mo->sprite = luaL_checkinteger(L, 3); mo->sprite = luaL_checkinteger(L, 3);
@@ -474,29 +465,29 @@ static int mobj_set(lua_State *L)
case mobj_ceilingz: case mobj_ceilingz:
return NOSETPOS; return NOSETPOS;
case mobj_radius: case mobj_radius:
{ {
mobj_t *ptmthing = tmthing; mobj_t *ptmthing = tmthing;
mo->radius = luaL_checkfixed(L, 3); mo->radius = luaL_checkfixed(L, 3);
if (mo->radius < 0) if (mo->radius < 0)
mo->radius = 0; mo->radius = 0;
P_CheckPosition(mo, mo->x, mo->y); P_CheckPosition(mo, mo->x, mo->y);
mo->floorz = tmfloorz; mo->floorz = tmfloorz;
mo->ceilingz = tmceilingz; mo->ceilingz = tmceilingz;
P_SetTarget(&tmthing, ptmthing); P_SetTarget(&tmthing, ptmthing);
}
break; break;
}
case mobj_height: case mobj_height:
{ {
mobj_t *ptmthing = tmthing; mobj_t *ptmthing = tmthing;
mo->height = luaL_checkfixed(L, 3); mo->height = luaL_checkfixed(L, 3);
if (mo->height < 0) if (mo->height < 0)
mo->height = 0; mo->height = 0;
P_CheckPosition(mo, mo->x, mo->y); P_CheckPosition(mo, mo->x, mo->y);
mo->floorz = tmfloorz; mo->floorz = tmfloorz;
mo->ceilingz = tmceilingz; mo->ceilingz = tmceilingz;
P_SetTarget(&tmthing, ptmthing); P_SetTarget(&tmthing, ptmthing);
}
break; break;
}
case mobj_momx: case mobj_momx:
mo->momx = luaL_checkfixed(L, 3); mo->momx = luaL_checkfixed(L, 3);
break; break;
@@ -520,25 +511,25 @@ static int mobj_set(lua_State *L)
P_SetMobjState(mo, luaL_checkinteger(L, 3)); P_SetMobjState(mo, luaL_checkinteger(L, 3));
break; break;
case mobj_flags: // special handling for MF_NOBLOCKMAP and MF_NOSECTOR case mobj_flags: // special handling for MF_NOBLOCKMAP and MF_NOSECTOR
{
UINT32 flags = luaL_checkinteger(L, 3);
if ((flags & (MF_NOBLOCKMAP|MF_NOSECTOR)) != (mo->flags & (MF_NOBLOCKMAP|MF_NOSECTOR)))
{ {
P_UnsetThingPosition(mo); UINT32 flags = luaL_checkinteger(L, 3);
mo->flags = flags; if ((flags & (MF_NOBLOCKMAP|MF_NOSECTOR)) != (mo->flags & (MF_NOBLOCKMAP|MF_NOSECTOR)))
if (flags & MF_NOSECTOR && sector_list)
{ {
P_DelSeclist(sector_list); P_UnsetThingPosition(mo);
sector_list = NULL; mo->flags = flags;
if (flags & MF_NOSECTOR && sector_list)
{
P_DelSeclist(sector_list);
sector_list = NULL;
}
mo->snext = NULL, mo->sprev = NULL;
mo->bnext = NULL, mo->bprev = NULL;
P_SetThingPosition(mo);
} }
mo->snext = NULL, mo->sprev = NULL; else
mo->bnext = NULL, mo->bprev = NULL; mo->flags = flags;
P_SetThingPosition(mo);
} }
else
mo->flags = flags;
break; break;
}
case mobj_flags2: case mobj_flags2:
mo->flags2 = (UINT32)luaL_checkinteger(L, 3); mo->flags2 = (UINT32)luaL_checkinteger(L, 3);
break; break;
@@ -546,27 +537,29 @@ static int mobj_set(lua_State *L)
mo->eflags = (UINT32)luaL_checkinteger(L, 3); mo->eflags = (UINT32)luaL_checkinteger(L, 3);
break; break;
case mobj_skin: // set skin by name case mobj_skin: // set skin by name
{ {
INT32 i; INT32 i;
char skin[SKINNAMESIZE+1]; // all skin names are limited to this length char skin[SKINNAMESIZE+1]; // all skin names are limited to this length
strlcpy(skin, luaL_checkstring(L, 3), sizeof skin); strlcpy(skin, luaL_checkstring(L, 3), sizeof skin);
strlwr(skin); // all skin names are lowercase strlwr(skin); // all skin names are lowercase
for (i = 0; i < numskins; i++) for (i = 0; i < numskins; i++)
if (fastcmp(skins[i].name, skin))
{ {
mo->skin = &skins[i]; if (fastcmp(skins[i].name, skin))
return 0; {
mo->skin = &skins[i];
return 0;
}
} }
return luaL_error(L, "mobj.skin '%s' not found!", skin); return luaL_error(L, "mobj.skin '%s' not found!", skin);
} }
case mobj_color: case mobj_color:
{ {
UINT8 newcolor = (UINT8)luaL_checkinteger(L,3); UINT8 newcolor = (UINT8)luaL_checkinteger(L,3);
if (newcolor >= MAXTRANSLATIONS) if (newcolor >= MAXTRANSLATIONS)
return luaL_error(L, "mobj.color %d out of range (0 - %d).", newcolor, MAXTRANSLATIONS-1); return luaL_error(L, "mobj.color %d out of range (0 - %d).", newcolor, MAXTRANSLATIONS-1);
mo->color = newcolor; mo->color = newcolor;
}
break; break;
}
case mobj_bnext: case mobj_bnext:
return NOSETPOS; return NOSETPOS;
case mobj_bprev: case mobj_bprev:
@@ -590,15 +583,15 @@ static int mobj_set(lua_State *L)
} }
break; break;
case mobj_type: // yeah sure, we'll let you change the mobj's type. case mobj_type: // yeah sure, we'll let you change the mobj's type.
{ {
mobjtype_t newtype = luaL_checkinteger(L, 3); mobjtype_t newtype = luaL_checkinteger(L, 3);
if (newtype >= NUMMOBJTYPES) if (newtype >= NUMMOBJTYPES)
return luaL_error(L, "mobj.type %d out of range (0 - %d).", newtype, NUMMOBJTYPES-1); return luaL_error(L, "mobj.type %d out of range (0 - %d).", newtype, NUMMOBJTYPES-1);
mo->type = newtype; mo->type = newtype;
mo->info = &mobjinfo[newtype]; mo->info = &mobjinfo[newtype];
P_SetScale(mo, mo->scale); P_SetScale(mo, mo->scale);
}
break; break;
}
case mobj_info: case mobj_info:
return NOSET; return NOSET;
case mobj_health: case mobj_health:
@@ -666,23 +659,23 @@ static int mobj_set(lua_State *L)
case mobj_mobjnum: case mobj_mobjnum:
return UNIMPLEMENTED; return UNIMPLEMENTED;
case mobj_scale: case mobj_scale:
{ {
fixed_t scale = luaL_checkfixed(L, 3); fixed_t scale = luaL_checkfixed(L, 3);
if (scale < FRACUNIT/100) if (scale < FRACUNIT/100)
scale = FRACUNIT/100; scale = FRACUNIT/100;
mo->destscale = scale; mo->destscale = scale;
P_SetScale(mo, scale); P_SetScale(mo, scale);
mo->old_scale = scale; mo->old_scale = scale;
}
break; break;
}
case mobj_destscale: case mobj_destscale:
{ {
fixed_t scale = luaL_checkfixed(L, 3); fixed_t scale = luaL_checkfixed(L, 3);
if (scale < FRACUNIT/100) if (scale < FRACUNIT/100)
scale = FRACUNIT/100; scale = FRACUNIT/100;
mo->destscale = scale; mo->destscale = scale;
}
break; break;
}
case mobj_scalespeed: case mobj_scalespeed:
mo->scalespeed = luaL_checkfixed(L, 3); mo->scalespeed = luaL_checkfixed(L, 3);
break; break;
@@ -747,58 +740,58 @@ static int mobj_set(lua_State *L)
mo->lightlevel = (INT16)luaL_checkinteger(L, 3); mo->lightlevel = (INT16)luaL_checkinteger(L, 3);
break; break;
case mobj_localskin: case mobj_localskin:
{
if (mo->player)
{ {
SetLocalPlayerSkin(mo->player - players, luaL_optstring(L, 3, "none"), NULL); if (mo->player)
}
else
{
INT32 i;
char skin[SKINNAMESIZE+1]; // all skin names are limited to this length
strlcpy(skin, luaL_optstring(L, 3, "none"), sizeof skin);
strlwr(skin); // all skin names are lowercase
if (!fasticmp(skin, "none"))
{ {
// Try localskins SetLocalPlayerSkin(mo->player - players, luaL_optstring(L, 3, "none"), NULL);
for (i = 0; i < numlocalskins; i++)
{
if (fasticmp(localskins[i].name, skin))
{
mo->localskin = &localskins[i];
mo->skinlocal = true;
return 0;
}
}
// Try other skins
for (i = 0; i < numskins; i++)
{
if (fasticmp(skins[i].name, skin))
{
mo->localskin = &skins[i];
mo->skinlocal = false;
return 0;
}
}
} }
else else
{ {
mo->localskin = NULL; INT32 i;
mo->skinlocal = false; char skin[SKINNAMESIZE+1]; // all skin names are limited to this length
strlcpy(skin, luaL_optstring(L, 3, "none"), sizeof skin);
strlwr(skin); // all skin names are lowercase
if (!fasticmp(skin, "none"))
{
// Try localskins
for (i = 0; i < numlocalskins; i++)
{
if (fasticmp(localskins[i].name, skin))
{
mo->localskin = &localskins[i];
mo->skinlocal = true;
return 0;
}
}
// Try other skins
for (i = 0; i < numskins; i++)
{
if (fasticmp(skins[i].name, skin))
{
mo->localskin = &skins[i];
mo->skinlocal = false;
return 0;
}
}
}
else
{
mo->localskin = NULL;
mo->skinlocal = false;
}
} }
} }
break; break;
}
case mobj_blendmode: case mobj_blendmode:
{ {
INT32 blendmode = (INT32)luaL_checkinteger(L, 3); INT32 blendmode = (INT32)luaL_checkinteger(L, 3);
if (blendmode < 0 || blendmode > AST_OVERLAY) if (blendmode < 0 || blendmode > AST_OVERLAY)
return luaL_error(L, "mobj.blendmode %d out of range (0 - %d).", blendmode, AST_OVERLAY); return luaL_error(L, "mobj.blendmode %d out of range (0 - %d).", blendmode, AST_OVERLAY);
mo->blendmode = blendmode; mo->blendmode = blendmode;
}
break; break;
}
case mobj_mirrored: case mobj_mirrored:
mo->mirrored = luaL_checkboolean(L, 3); mo->mirrored = luaL_checkboolean(L, 3);
break; break;
@@ -950,13 +943,13 @@ static int mapthing_set(lua_State *L)
mt->z = (INT16)luaL_checkinteger(L, 3); mt->z = (INT16)luaL_checkinteger(L, 3);
break; break;
case mapthing_extrainfo: case mapthing_extrainfo:
{ {
INT32 extrainfo = luaL_checkinteger(L, 3); INT32 extrainfo = luaL_checkinteger(L, 3);
if (extrainfo & ~15) if (extrainfo & ~15)
return luaL_error(L, "mapthing_t extrainfo set %d out of range (%d - %d)", extrainfo, 0, 15); return luaL_error(L, "mapthing_t extrainfo set %d out of range (%d - %d)", extrainfo, 0, 15);
mt->extrainfo = (UINT8)extrainfo; mt->extrainfo = (UINT8)extrainfo;
}
break; break;
}
case mapthing_mobj: case mapthing_mobj:
mt->mobj = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); mt->mobj = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
break; break;
+45 -45
View File
@@ -298,12 +298,12 @@ static int player_get(lua_State *L)
lua_pushstring(L, player_names[plr-players]); lua_pushstring(L, player_names[plr-players]);
break; break;
case player_mo: case player_mo:
{ {
if (plr->spectator) if (plr->spectator)
lua_pushnil(L); lua_pushnil(L);
else else
LUA_PushUserdata(L, plr->mo, META_MOBJ); LUA_PushUserdata(L, plr->mo, META_MOBJ);
} }
break; break;
case player_cmd: case player_cmd:
LUA_PushUserdata(L, &plr->cmd, META_TICCMD); LUA_PushUserdata(L, &plr->cmd, META_TICCMD);
@@ -668,11 +668,11 @@ static int player_set(lua_State *L)
return 0; // In vanilla those are not handled and are added into player fields table, but they aren't accessible anyway so we can just ignore them return 0; // In vanilla those are not handled and are added into player fields table, but they aren't accessible anyway so we can just ignore them
break; break;
case player_mo: case player_mo:
{ {
mobj_t *newmo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); mobj_t *newmo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
plr->mo->player = NULL; // remove player pointer from old mobj plr->mo->player = NULL; // remove player pointer from old mobj
(newmo->player = plr)->mo = newmo; // set player pointer for new mobj, and set new mobj as the player's mobj (newmo->player = plr)->mo = newmo; // set player pointer for new mobj, and set new mobj as the player's mobj
} }
break; break;
case player_cmd: case player_cmd:
return NOSET; return NOSET;
@@ -692,17 +692,17 @@ static int player_set(lua_State *L)
case player_bob: case player_bob:
plr->bob = luaL_checkfixed(L, 3);*/ plr->bob = luaL_checkfixed(L, 3);*/
break; break;
case player_aiming: { case player_aiming:
plr->aiming = luaL_checkangle(L, 3); {
if (plr == &players[consoleplayer]) plr->aiming = luaL_checkangle(L, 3);
localaiming[0] = plr->aiming; for (UINT8 i = 0; i <= splitscreen; i++)
else if (plr == &players[displayplayers[1]]) {
localaiming[1] = plr->aiming; if (plr == &players[displayplayers[i]])
else if (plr == &players[displayplayers[2]]) {
localaiming[2] = plr->aiming; localaiming[i] = plr->aiming;
else if (plr == &players[displayplayers[3]]) }
localaiming[3] = plr->aiming; }
} }
break; break;
case player_health: case player_health:
plr->health = (INT32)luaL_checkinteger(L, 3); plr->health = (INT32)luaL_checkinteger(L, 3);
@@ -732,12 +732,12 @@ static int player_set(lua_State *L)
plr->flashpal = (UINT16)luaL_checkinteger(L, 3); plr->flashpal = (UINT16)luaL_checkinteger(L, 3);
break; break;
case player_skincolor: case player_skincolor:
{ {
UINT8 newcolor = (UINT8)luaL_checkinteger(L,3); UINT8 newcolor = (UINT8)luaL_checkinteger(L,3);
if (newcolor >= MAXSKINCOLORS) if (newcolor >= MAXSKINCOLORS)
return luaL_error(L, "player.skincolor %d out of range (0 - %d).", newcolor, MAXSKINCOLORS-1); return luaL_error(L, "player.skincolor %d out of range (0 - %d).", newcolor, MAXSKINCOLORS-1);
plr->skincolor = newcolor; plr->skincolor = newcolor;
} }
break; break;
case player_score: case player_score:
plr->score = (UINT32)luaL_checkinteger(L, 3); plr->score = (UINT32)luaL_checkinteger(L, 3);
@@ -907,12 +907,12 @@ static int player_set(lua_State *L)
plr->bonustime = luaL_checkboolean(L, 3); plr->bonustime = luaL_checkboolean(L, 3);
break; break;
case player_capsule: case player_capsule:
{ {
mobj_t *mo = NULL; mobj_t *mo = NULL;
if (!lua_isnil(L, 3)) if (!lua_isnil(L, 3))
mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
P_SetTarget(&plr->capsule, mo); P_SetTarget(&plr->capsule, mo);
} }
break; break;
case player_mare: case player_mare:
plr->mare = (UINT8)luaL_checkinteger(L, 3); plr->mare = (UINT8)luaL_checkinteger(L, 3);
@@ -963,19 +963,19 @@ static int player_set(lua_State *L)
plr->onconveyor = (INT32)luaL_checkinteger(L, 3); plr->onconveyor = (INT32)luaL_checkinteger(L, 3);
break; break;
case player_awayviewmobj: case player_awayviewmobj:
{ {
mobj_t *mo = NULL; mobj_t *mo = NULL;
if (!lua_isnil(L, 3)) if (!lua_isnil(L, 3))
mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)); mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
P_SetTarget(&plr->awayviewmobj, mo); P_SetTarget(&plr->awayviewmobj, mo);
} }
break; break;
case player_awayviewtics: case player_awayviewtics:
{ {
plr->awayviewtics = (INT32)luaL_checkinteger(L, 3); plr->awayviewtics = (INT32)luaL_checkinteger(L, 3);
if (plr->awayviewtics && !plr->awayviewmobj) // awayviewtics must ALWAYS have an awayviewmobj set!! if (plr->awayviewtics && !plr->awayviewmobj) // awayviewtics must ALWAYS have an awayviewmobj set!!
P_SetTarget(&plr->awayviewmobj, plr->mo); // but since the script might set awayviewmobj immediately AFTER setting awayviewtics, use player mobj as filler for now. P_SetTarget(&plr->awayviewmobj, plr->mo); // but since the script might set awayviewmobj immediately AFTER setting awayviewtics, use player mobj as filler for now.
} }
break; break;
case player_awayviewaiming: case player_awayviewaiming:
plr->awayviewaiming = luaL_checkangle(L, 3); plr->awayviewaiming = luaL_checkangle(L, 3);
+2 -2
View File
@@ -1004,7 +1004,7 @@ static menuitem_t OP_ExpOptionsMenu[] =
#ifdef HWRENDER #ifdef HWRENDER
{IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 95}, {IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 95},
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
{IT_STRING | IT_CVAR, NULL, "FBO Downsampling support", &cv_glframebuffer, 100}, {IT_STRING | IT_CVAR, NULL, "FBO support", &cv_glframebuffer, 100},
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 110}, {IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 110},
{IT_DISABLED, NULL, "", NULL, 120}, // dummy text {IT_DISABLED, NULL, "", NULL, 120}, // dummy text
#else #else
@@ -1030,7 +1030,7 @@ static const char* OP_ExpTooltips[] =
#ifdef HWRENDER #ifdef HWRENDER
"Disabling Screen Textures may result in a performance boost\nbut will break certain effects.\nScreen textures are required at resolutions lower than your desktop resolution!", "Disabling Screen Textures may result in a performance boost\nbut will break certain effects.\nScreen textures are required at resolutions lower than your desktop resolution!",
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
"Allows the game to downsample from a higher resolution\nthan your display in OpenGL renderer mode.\nRequires a GPU with atleast OpenGL 2.1 support.", "Allows the game to downsample from a higher resolution\nthan your display in OpenGL renderer mode.\nThis can be set to automatically enable if the game resolution\nis higher than the current Display Resolution\nor enabled at all times.\nThis may improve performance in some cases.\nRequires a GPU with atleast OpenGL 2.1 support.",
#endif #endif
"Change the bit depth of the Lookup Palette in Palette rendering mode\n 16 bits is like software looks ingame\nwhile 24 bits is how software looks in screenshots.", "Change the bit depth of the Lookup Palette in Palette rendering mode\n 16 bits is like software looks ingame\nwhile 24 bits is how software looks in screenshots.",
#endif #endif
+10 -10
View File
@@ -66,22 +66,22 @@ static void P_UpdateSlopeLightOffset(pslope_t *slope)
nY = FixedDiv(nY, nLen); nY = FixedDiv(nY, nLen);
/* /*
* if (slope is ceiling) if (slope is ceiling)
* { {
* // There is no good way to calculate this condition here. // There is no good way to calculate this condition here.
* // We reverse it in R_FindPlane now. // We reverse it in R_FindPlane now.
* nX = -nX; nX = -nX;
* nY = -nY; nY = -nY;
* } }
*/ */
light = FixedMul(nX, FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT)) light = FixedMul(nX, FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT))
+ FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT)); + FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
light = (light + FRACUNIT) / 2; light = (light + FRACUNIT) / 2;
} }
else else
{ {
light = FixedDiv(R_PointToAngle2(0, 0, abs(slope->d.x), abs(slope->d.y)), ANGLE_90); light = FixedDiv(R_PointToAngle2(0, 0, abs(slope->normal.y), abs(slope->normal.x)), ANGLE_90);
} }
const int delta = abs(slope->zdelta)*3/2; // *3/2, to make 60 degree slopes match walls. const int delta = abs(slope->zdelta)*3/2; // *3/2, to make 60 degree slopes match walls.
+3
View File
@@ -504,6 +504,9 @@ typedef struct subsector_s
void *splats; // floorsplat_t list void *splats; // floorsplat_t list
#endif #endif
size_t validcount; size_t validcount;
#ifdef HWRENDER
boolean hashorizon; // not really needed for software, this stuff works differently there
#endif
} subsector_t; } subsector_t;
// Sector list node showing all sectors an object appears in. // Sector list node showing all sectors an object appears in.
+14 -14
View File
@@ -350,8 +350,8 @@ void R_ClearPlanes(void)
angle = (viewangle-ANGLE_90)>>ANGLETOFINESHIFT; angle = (viewangle-ANGLE_90)>>ANGLETOFINESHIFT;
// scale will be unit scale at SCREENWIDTH/2 distance // scale will be unit scale at SCREENWIDTH/2 distance
basexscale = FixedDiv (FINECOSINE(angle), centerxfrac); basexscale = FixedDiv(FINECOSINE(angle), centerxfrac);
baseyscale = -FixedDiv (FINESINE(angle), centerxfrac); baseyscale = -FixedDiv(FINESINE(angle), centerxfrac);
} }
static visplane_t *new_visplane(unsigned hash) static visplane_t *new_visplane(unsigned hash)
@@ -440,20 +440,20 @@ visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
} }
} }
if (slope != NULL && P_ApplyLightOffset(lightlevel >> LIGHTSEGSHIFT, lighting_sector))
{
if (reverseLight && maplighting.directional == true)
{
lightlevel -= slope->lightOffset * 8;
}
else
{
lightlevel += slope->lightOffset * 8;
}
}
if (!pfloor) if (!pfloor)
{ {
if (slope != NULL && P_ApplyLightOffset(lightlevel >> LIGHTSEGSHIFT, lighting_sector))
{
if (reverseLight)
{
lightlevel -= slope->lightOffset * 8;
}
else
{
lightlevel += slope->lightOffset * 8;
}
}
hash = visplane_hash(picnum, lightlevel, height >> FRACBITS); hash = visplane_hash(picnum, lightlevel, height >> FRACBITS);
for (check = visplanes[hash]; check; check = check->next) for (check = visplanes[hash]; check; check = check->next)
+19 -54
View File
@@ -113,10 +113,6 @@ consvar_t cv_keyboardlayout = {"keyboardlayout", "Default US", CV_SAVE|CV_CALL,
static void Impl_SetVsync(void); static void Impl_SetVsync(void);
static INT32 desktopwidth = 0, desktopheight = 0;
static void I_CheckDesktopRes(void);
// synchronize page flipping with screen refresh // synchronize page flipping with screen refresh
consvar_t cv_vidwait = {"vid_wait", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, Impl_SetVsync, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_vidwait = {"vid_wait", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, Impl_SetVsync, 0, NULL, NULL, 0, 0, NULL};
static consvar_t cv_stretch = {"stretch", "Off", CV_SAVE|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; static consvar_t cv_stretch = {"stretch", "Off", CV_SAVE|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -512,10 +508,10 @@ static void Impl_HandleWindowEvent(SDL_WindowEvent evt)
return; return;
} }
if (windowmoved && rendermode == render_opengl) if (windowmoved)
{ {
I_CheckDesktopRes();
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
if (rendermode == render_opengl)
I_CheckDownSampleState(false); I_CheckDownSampleState(false);
#endif #endif
windowmoved = SDL_FALSE; windowmoved = SDL_FALSE;
@@ -1223,9 +1219,7 @@ static void VID_Command_ModeList_f(void)
// List windowed modes // List windowed modes
INT32 i = 0; INT32 i = 0;
CONS_Printf("NOTE: Under SDL2, all modes are supported on all platforms.\n" CONS_Printf("NOTE: Under SDL2, all modes are supported on all platforms.\n");
"Under opengl, fullscreen only supports native desktop resolution.\n"
"Under software, the mode is stretched up to desktop resolution.\n");
for (i = 0; i < MAXWINMODES; i++) for (i = 0; i < MAXWINMODES; i++)
{ {
@@ -1251,44 +1245,6 @@ static void VID_Command_Mode_f (void)
setmodeneeded = modenum+1; // request vid mode change setmodeneeded = modenum+1; // request vid mode change
} }
// Get the desktop resolution from the current display the gamewindow resides on
static void I_CheckDesktopRes(void)
{
int currentDisplayIndex = -1;
SDL_DisplayMode curmode;
// just fallback to game res ig?
desktopwidth = vid.width;
desktopheight = vid.height;
currentDisplayIndex = SDL_GetWindowDisplayIndex(window);
// No valid index
if (currentDisplayIndex < 0)
{
return;
}
if (SDL_GetCurrentDisplayMode(currentDisplayIndex, &curmode) < 0)
{
return;
}
desktopwidth = curmode.w;
desktopheight = curmode.h;
}
// Check if the game resolution matches the desktop resolution
boolean I_CheckNativeRes(void)
{
return (vid.width == desktopwidth && vid.height == desktopheight);
}
static boolean I_CheckAboveDesktopRes(INT32 width, INT32 height)
{
return (width > desktopwidth || height > desktopheight);
}
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
static boolean vid_downsampling = false; static boolean vid_downsampling = false;
@@ -1307,16 +1263,24 @@ void I_CheckDownSampleState(boolean forcerefresh)
} }
// no sense to do this crap if we cant benefit from it // no sense to do this crap if we cant benefit from it
const boolean newdownsamplestate = cv_glframebuffer.value && (cv_glscreentextures.value == 2) && I_CheckAboveDesktopRes(vid.width, vid.height); boolean newdownsamplestate = false;
if (cv_glframebuffer.value && (cv_glscreentextures.value == 2))
{
int sdlw, sdlh;
SDL_GetWindowSize(window, &sdlw, &sdlh);
if (vid.width > sdlw || vid.height > sdlh)
newdownsamplestate = true;
}
// state changed or fbo was toggled // state changed or fbo was toggled
if (vid_downsampling != newdownsamplestate || forcerefresh) if (vid_downsampling != newdownsamplestate || forcerefresh)
{ {
//printf("downsample changed from %d to %d\n", vid_downsampling, curdownsamplestate); //printf("downsample changed from %d to %d\n", vid_downsampling, newdownsamplestate);
// needs to be reset before refreshing the gl surface!
vid_downsampling = newdownsamplestate;
OglSdlSurface(vid.width, vid.height); OglSdlSurface(vid.width, vid.height);
} }
vid_downsampling = newdownsamplestate;
} }
#endif #endif
@@ -1346,8 +1310,8 @@ static void SDLSetMode(INT32 width, INT32 height, SDL_bool fullscreen)
} }
// Reposition window only in windowed mode // Reposition window only in windowed mode
const int windowpos = SDL_GetWindowDisplayIndex(window);
SDL_SetWindowSize(window, width, height); SDL_SetWindowSize(window, width, height);
const int windowpos = SDL_GetWindowDisplayIndex(window);
SDL_SetWindowPosition(window, SDL_SetWindowPosition(window,
SDL_WINDOWPOS_CENTERED_DISPLAY(windowpos), SDL_WINDOWPOS_CENTERED_DISPLAY(windowpos),
SDL_WINDOWPOS_CENTERED_DISPLAY(windowpos) SDL_WINDOWPOS_CENTERED_DISPLAY(windowpos)
@@ -1370,7 +1334,6 @@ static void SDLSetMode(INT32 width, INT32 height, SDL_bool fullscreen)
#ifdef HWRENDER #ifdef HWRENDER
if (rendermode == render_opengl) if (rendermode == render_opengl)
{ {
I_CheckDesktopRes();
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
I_CheckDownSampleState(false); I_CheckDownSampleState(false);
#endif #endif
@@ -1568,7 +1531,7 @@ void VID_PrepareModeList(void)
static UINT32 refresh_rate; static UINT32 refresh_rate;
static UINT32 VID_GetRefreshRate(void) static UINT32 VID_GetRefreshRate(void)
{ {
int index = SDL_GetWindowDisplayIndex(window); int index;
SDL_DisplayMode m; SDL_DisplayMode m;
if (SDL_WasInit(SDL_INIT_VIDEO) == 0) if (SDL_WasInit(SDL_INIT_VIDEO) == 0)
@@ -1577,6 +1540,8 @@ static UINT32 VID_GetRefreshRate(void)
return 0; return 0;
} }
index = SDL_GetWindowDisplayIndex(window);
if (SDL_GetDesktopDisplayMode(index, &m) != 0) if (SDL_GetDesktopDisplayMode(index, &m) != 0)
{ {
// Error has occurred. // Error has occurred.
+3 -5
View File
@@ -65,7 +65,7 @@ PFNglGetString pglGetString;
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
boolean UseScreenFBO(void) boolean UseScreenFBO(void)
{ {
return (supportFBO && cv_glframebuffer.value && I_IsDownsampling() && (cv_glscreentextures.value == 2)); return (supportFBO && cv_glframebuffer.value && (cv_glscreentextures.value == 2) && (cv_glframebuffer.value == 2 || I_IsDownsampling()));
} }
#endif #endif
@@ -225,7 +225,6 @@ boolean OglSdlSurface(INT32 w, INT32 h)
void OglSdlFinishUpdate(SDL_Window *window) void OglSdlFinishUpdate(SDL_Window *window)
{ {
int sdlw, sdlh; int sdlw, sdlh;
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
const boolean usefbo = UseScreenFBO(); const boolean usefbo = UseScreenFBO();
#endif #endif
@@ -262,11 +261,10 @@ void OglSdlFinishUpdate(SDL_Window *window)
// Sryder: We need to draw the final screen texture again into the other buffer in the original position so that // Sryder: We need to draw the final screen texture again into the other buffer in the original position so that
// effects that want to take the old screen can do so after this // effects that want to take the old screen can do so after this
// well we dont need it on native res it seems
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
if (!usefbo && (!I_CheckNativeRes() || WipeInAction)) if (!usefbo && (realwidth != sdlw || realheight != sdlh)) // not needed if fbo is in use
#else #else
if (!I_CheckNativeRes() || WipeInAction) if (realwidth != sdlw || realheight != sdlh) // this is not needed if the render size matches window size
#endif #endif
HWR_DrawScreenFinalTexture(realwidth, realheight); HWR_DrawScreenFinalTexture(realwidth, realheight);
} }
+21 -18
View File
@@ -1839,8 +1839,11 @@ void V_DrawHorizontallyScaledFullScreenPatch(patch_t *patch)
void V_DrawVhsEffect(boolean rewind) void V_DrawVhsEffect(boolean rewind)
{ {
fixed_t uby, dby; fixed_t uby, dby;
// upbary is the bar going from top to bottom for some reason static fixed_t upbary_normal = 100*FRACUNIT, downbary_normal = 150*FRACUNIT;
static fixed_t upbary = 100*FRACUNIT, downbary = 150*FRACUNIT; static fixed_t upbary_rewind = 100*FRACUNIT, downbary_rewind = 150*FRACUNIT;
fixed_t *upbary = rewind ? &upbary_rewind : &upbary_normal;
fixed_t *downbary = rewind ? &downbary_rewind : &downbary_normal;
UINT8 barsize, updistort, downdistort; UINT8 barsize, updistort, downdistort;
@@ -1864,25 +1867,25 @@ void V_DrawVhsEffect(boolean rewind)
if (rewind) if (rewind)
V_DrawVhsEffect(false); // experimentation V_DrawVhsEffect(false); // experimentation
upbary -= renderdeltatics * (fixed_t)(vid.udup * (rewind ? 3 : 1.8f)); *upbary -= renderdeltatics * (fixed_t)(vid.udup * (rewind ? 3 : 1.8f));
downbary += renderdeltatics * (vid.udup * (rewind ? 2 : 1)); *downbary += renderdeltatics * (vid.udup * (rewind ? 2 : 1));
if (upbary < -barsize*FRACUNIT) if (*upbary < -barsize*FRACUNIT)
upbary = vid.height << FRACBITS; *upbary = vid.height << FRACBITS;
if (upbary > vid.height << FRACBITS) if (*upbary > vid.height << FRACBITS)
upbary = -barsize*FRACUNIT; *upbary = -barsize*FRACUNIT;
if (downbary > vid.height << FRACBITS) if (*downbary > vid.height << FRACBITS)
downbary = -barsize*FRACUNIT; *downbary = -barsize*FRACUNIT;
if (downbary < -barsize*FRACUNIT) if (*downbary < -barsize*FRACUNIT)
downbary = vid.height << FRACBITS; *downbary = vid.height << FRACBITS;
uby = upbary >> FRACBITS; uby = *upbary >> FRACBITS;
dby = downbary >> FRACBITS; dby = *downbary >> FRACBITS;
#ifdef HWRENDER #ifdef HWRENDER
if (rendermode == render_opengl) if (rendermode == render_opengl)
{ {
HWR_RenderVhsEffect(uby, dby, updistort, downdistort, barsize); HWR_RenderVhsEffect(uby, dby, updistort, downdistort, barsize, rewind);
return; return;
} }
#endif #endif
@@ -3619,7 +3622,7 @@ void V_DoPostProcessor(INT32 view, INT32 param)
for (y = yoffset; y < yoffset+viewheight; y++) for (y = yoffset; y < yoffset+viewheight; y++)
{ {
sine = (FINESINE(disStart)*5)>>FRACBITS; sine = (FINESINE(disStart) * 5) >> FRACBITS;
newpix = abs(sine); newpix = abs(sine);
if (sine < 0) if (sine < 0)
@@ -3659,8 +3662,8 @@ void V_DoPostProcessor(INT32 view, INT32 param)
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 += 22; // the offset into the displacement map, increment each game loop
disStart &= FINEMASK; //clip it to FINEMASK disStart &= FINEMASK; // clip it to FINEMASK
} }
UINT8 *tmp = tmpscr; UINT8 *tmp = tmpscr;