From 9dd7e9a25f2c8a34702f2b56a0f16a32ffeb790e Mon Sep 17 00:00:00 2001 From: Alug Date: Tue, 23 Jul 2024 18:54:27 +0200 Subject: [PATCH] fix up bird screen tilting removes old lerp variables that did nothing properly interpolated viewroll made it proper adjust to mobjscale doesent roll view when spectating general cleanup --- src/d_main.c | 3 +++ src/d_player.h | 5 ----- src/hardware/hw_main.c | 22 +++++++++++++-------- src/p_user.c | 35 +++++++++++++------------------- src/r_fps.c | 8 ++++++-- src/r_fps.h | 3 +++ src/r_main.c | 45 ++++++++++++++++++++++++++++++++++++++++-- src/r_main.h | 1 + src/r_state.h | 2 +- 9 files changed, 85 insertions(+), 39 deletions(-) diff --git a/src/d_main.c b/src/d_main.c index d7f56ae23..e4b32cdfb 100644 --- a/src/d_main.c +++ b/src/d_main.c @@ -264,7 +264,10 @@ static boolean D_Display(void) SCR_Recalc(); // NOTE! setsizeneeded is set by SCR_Recalc() if (rendermode == render_soft && !splitscreen) + { + R_InterpolateViewRollAngle(rendertimefrac); R_CheckViewMorph(); + } // change the view size if needed if (setsizeneeded) diff --git a/src/d_player.h b/src/d_player.h index 4d61474fb..183991606 100644 --- a/src/d_player.h +++ b/src/d_player.h @@ -541,11 +541,6 @@ typedef struct player_s #ifdef HWRENDER fixed_t fovadd; // adjust FOV for hw rendering #endif - - struct { - angle_t aiming, awayviewaiming, frameangle; - angle_t viewrollangle; - } lerp; } player_t; #endif diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c index d89bf5eb7..5e7c09aa2 100644 --- a/src/hardware/hw_main.c +++ b/src/hardware/hw_main.c @@ -68,6 +68,8 @@ static boolean gr_palette_rendering_state = false; // Commands and console variables // ========================================================================== +static void HWR_RollTransform(FTransform *tr, angle_t roll); + #ifdef USE_FBO_OGL static void CV_grframebuffer_OnChange(void); #endif @@ -5262,8 +5264,7 @@ void HWR_DrawSkyBackground(float fpov) dometransform.scalez = 1; dometransform.fovxangle = fpov; // Tails dometransform.fovyangle = fpov; // Tails - dometransform.rollangle = atransform.rollangle; - dometransform.roll = atransform.roll; + HWR_RollTransform(&dometransform, viewroll); dometransform.splitscreen = splitscreen; HWR_GetTexture(texturetranslation[skytexture], false); @@ -5358,12 +5359,7 @@ void HWR_SetTransform(float fpov, player_t *player) atransform.fovxangle = fpov; // Tails atransform.fovyangle = fpov; // Tails - if (player->viewrollangle != 0) - { - fixed_t rol = AngleFixed(player->viewrollangle); - atransform.rollangle = FIXED_TO_FLOAT(rol); - atransform.roll = true; - } + HWR_RollTransform(&atransform, viewroll); atransform.splitscreen = splitscreen; for (i = 0; i <= splitscreen; i++) @@ -5697,6 +5693,16 @@ void HWR_RenderFrame(INT32 viewnumber, player_t *player, boolean skybox) // ========================================================================== // Render the player view. // ========================================================================== + +static void HWR_RollTransform(FTransform *tr, angle_t roll) +{ + if (roll != 0) + { + tr->rollangle = roll / (float)ANG1; + tr->roll = true; + } +} + void HWR_RenderPlayerView(INT32 viewnumber, player_t *player) { const boolean skybox = (skyboxmo[0] && cv_skybox.value); // True if there's a skybox object and skyboxes are on diff --git a/src/p_user.c b/src/p_user.c index 1d8b7e3f8..da464d6e7 100644 --- a/src/p_user.c +++ b/src/p_user.c @@ -4226,6 +4226,7 @@ Quaketilt (player_t *player) tilt = ANGLE_22h; lowb = 10*FRACUNIT; } + lowb = FixedMul(lowb, player->mo->scale); moma = FixedMul(FixedDiv(delta, ANGLE_90), tilt); speed = abs( player->mo->momx + player->mo->momy ); if (speed < lowb) @@ -4242,6 +4243,13 @@ DoABarrelRoll (player_t *player) angle_t slope; angle_t delta; + fixed_t smoothing; + + if (player->exiting) + { + return; + } + if (player->mo->standingslope) { slope = player->mo->standingslope->real_zangle; @@ -4266,26 +4274,16 @@ DoABarrelRoll (player_t *player) slope -= Quaketilt(player); } - delta = (INT32)( slope - player->tilt )/ cv_tiltsmoothing.value; + delta = slope - player->tilt; + smoothing = FixedDiv(AbsAngle(slope), ANGLE_45); + + delta = FixedDiv(delta, cv_tiltsmoothing.value * + FixedDiv(FRACUNIT, FRACUNIT + smoothing)); if (delta) player->tilt += delta; else - player->tilt = slope; - - if (cv_tilting.value) - { - player->viewrollangle = player->tilt; - - if (cv_actionmovie.value) - { - player->viewrollangle += quake.roll; - } - } - else - { - player->viewrollangle = 0; - } + player->tilt = slope; } // @@ -4297,11 +4295,6 @@ void P_PlayerThink(player_t *player) ticcmd_t *cmd; const size_t playeri = (size_t)(player - players); - player->lerp.aiming = player->aiming; - player->lerp.awayviewaiming = player->awayviewaiming; - player->lerp.frameangle = player->frameangle; - player->lerp.viewrollangle = player->viewrollangle; - #ifdef PARANOIA if (!player->mo) I_Error("p_playerthink: players[%s].mo == NULL", sizeu1(playeri)); diff --git a/src/r_fps.c b/src/r_fps.c index b3634d79d..b84d07993 100644 --- a/src/r_fps.c +++ b/src/r_fps.c @@ -145,6 +145,11 @@ static void R_SetupFreelook(void) #undef AIMINGTODY +void R_InterpolateViewRollAngle(fixed_t frac) +{ + viewroll = oldview->roll + R_LerpAngle(oldview->roll, newview->roll, frac); +} + void R_InterpolateView(fixed_t frac, boolean forceinvalid) { viewvars_t* prevview = oldview; @@ -176,12 +181,11 @@ void R_InterpolateView(fixed_t frac, boolean forceinvalid) viewangle = R_LerpAngle(prevview->angle, newview->angle, frac); aimingangle = R_LerpAngle(prevview->aim, newview->aim, frac); + viewroll = R_LerpAngle(prevview->roll, newview->roll, frac); viewsin = FINESINE(viewangle>>ANGLETOFINESHIFT); viewcos = FINECOSINE(viewangle>>ANGLETOFINESHIFT); - // this is gonna create some interesting visual errors for long distance teleports... - // might want to recalculate the view sector every frame instead... viewplayer = newview->player; viewsector = R_PointInSubsector(viewx, viewy)->sector; diff --git a/src/r_fps.h b/src/r_fps.h index 1b7b02cac..a4aef71cd 100644 --- a/src/r_fps.h +++ b/src/r_fps.h @@ -47,6 +47,7 @@ typedef struct { angle_t angle; angle_t aim; + angle_t roll; fixed_t cos; fixed_t sin; mobj_t *mobj; @@ -118,6 +119,8 @@ typedef struct levelinterpolator_s { // Interpolates the current view variables (r_state.h) against the selected view context in R_SetViewContext void R_InterpolateView(fixed_t frac, boolean forceinvalid); +// Special function just for software +void R_InterpolateViewRollAngle(fixed_t frac); // Buffer the current new views into the old views. Call once after each real tic. void R_UpdateViewInterpolation(void); // Reset the view states (e.g. after level load) so R_InterpolateView doesn't interpolate invalid data diff --git a/src/r_main.c b/src/r_main.c index e5f0df5aa..aca5b00e6 100644 --- a/src/r_main.c +++ b/src/r_main.c @@ -57,7 +57,7 @@ size_t framecount; size_t loopcount; fixed_t viewx, viewy, viewz; -angle_t viewangle, aimingangle; +angle_t viewangle, aimingangle, viewroll; UINT8 viewssnum; fixed_t viewcos, viewsin; boolean skyVisible; @@ -733,7 +733,7 @@ void R_CheckViewMorph(void) INT32 end, vx, vy, pos, usedpos; INT32 usedx, usedy, halfwidth = vid.width/2, halfheight = vid.height/2; - angle_t rollangle = players[displayplayers[0]].viewrollangle; + angle_t rollangle = viewroll; rollangle >>= ANGLETOFINESHIFT; rollangle = ((rollangle+2) & ~3) & FINEMASK; // Limit the distinct number of angles to reduce recalcs from angles changing a lot. @@ -917,6 +917,45 @@ void R_ApplyViewMorph(void) vid.width*vid.bpp, vid.height, vid.width*vid.bpp, vid.width); } +static inline int intsign(int n) { + return n < 0 ? -1 : n > 0 ? 1 : 0; +} + +angle_t R_ViewRollAngle(const player_t *player) +{ + angle_t roll = 0; + + if (gamestate != GS_LEVEL) + { + // FIXME: The way this is implemented is totally + // incompatible with cameras that aren't directly + // tied to the player. (podium, titlemap, + // MT_ALTVIEWMAN in general) + + // All of these player variables should affect their + // camera_t in P_MoveChaseCamera, and then this + // just returns that variable instead. + return 0; + } + + roll = player->viewrollangle; + + if (cv_tilting.value) + { + if (!player->spectator && !demo.freecam) + roll += player->tilt; + + if (cv_actionmovie.value) + { + int xs = intsign(quake.x), + ys = intsign(quake.y), + zs = intsign(quake.z); + roll += (xs ^ ys ^ zs) * ANG1; + } + } + + return roll; +} // // R_SetViewSize @@ -1187,6 +1226,7 @@ void R_SkyboxFrame(player_t *player) } } newview->angle += viewmobj->angle; + newview->roll = R_ViewRollAngle(player); newview->player = player; @@ -1470,6 +1510,7 @@ void R_SetupFrame(player_t *player, boolean skybox) } } } + newview->roll = R_ViewRollAngle(player); newview->z += quake.z; newview->player = player; diff --git a/src/r_main.h b/src/r_main.h index 1a589088d..6c59d9961 100644 --- a/src/r_main.h +++ b/src/r_main.h @@ -126,6 +126,7 @@ void R_Init(void); void R_CheckViewMorph(void); void R_ApplyViewMorph(void); +angle_t R_ViewRollAngle(const player_t *player); // just sets setsizeneeded true extern boolean setsizeneeded; diff --git a/src/r_state.h b/src/r_state.h index 670f800d1..5234d1d62 100644 --- a/src/r_state.h +++ b/src/r_state.h @@ -88,7 +88,7 @@ extern side_t *sides; // POV data. // extern fixed_t viewx, viewy, viewz; -extern angle_t viewangle, aimingangle; +extern angle_t viewangle, aimingangle, viewroll; extern UINT8 viewssnum; // splitscreen view number extern boolean viewsky, skyVisible; extern boolean skyVisiblePerPlayer[MAXSPLITSCREENPLAYERS]; // saved values of skyVisible of each splitscreen player