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
This commit is contained in:
1 parent
1648273ddd
commit
9dd7e9a25f
9 files changed
+85
-39
No files matched your search
@@ -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)
|
||||
|
||||
@@ -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
|
||||
+14
-8
@@ -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
|
||||
|
||||
+14
-21
@@ -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));
|
||||
|
||||
+6
-2
@@ -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;
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
+43
-2
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
+1
-1
@@ -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
|
||||
|
||||
Reference in new issue
Block a user