From d7d76d5fc416dfa1df698b3be4e87d70c3e0a300 Mon Sep 17 00:00:00 2001 From: Mitchell Richters Date: Sun, 27 Nov 2022 14:48:37 +1100 Subject: [PATCH] - Move all PlayerAngles view angle properties into new DRotator objects. --- source/core/gameinput.cpp | 24 ++++++++++-------------- source/core/gameinput.h | 26 +++++++++++++++----------- source/games/blood/src/player.cpp | 3 ++- source/games/blood/src/view.cpp | 2 +- source/games/duke/src/gameexec.cpp | 18 +++++++++--------- source/games/duke/src/player.cpp | 18 +++++++++--------- source/games/duke/src/player_d.cpp | 1 + source/games/duke/src/player_r.cpp | 1 + source/games/duke/src/prediction.cpp | 2 +- source/games/duke/src/premap.cpp | 6 +++--- source/games/duke/src/render.cpp | 2 +- source/games/exhumed/src/player.cpp | 1 + source/games/exhumed/src/view.cpp | 2 +- source/games/sw/src/draw.cpp | 2 +- source/games/sw/src/player.cpp | 3 ++- 15 files changed, 58 insertions(+), 53 deletions(-) diff --git a/source/core/gameinput.cpp b/source/core/gameinput.cpp index 17ddd69dc..551f60f3d 100644 --- a/source/core/gameinput.cpp +++ b/source/core/gameinput.cpp @@ -225,14 +225,14 @@ void PlayerAngles::applyPitch(float const horz, ESyncBits* actions, double const void PlayerAngles::applyYaw(float const avel, ESyncBits* actions, double const scaleAdjust) { // Process angle return to zeros. - scaletozero(ZzROTSCRNANG, YAW_LOOKRETURN, scaleAdjust); - scaletozero(ZzLOOKANG, YAW_LOOKRETURN, scaleAdjust); + scaletozero(ViewAngles.Roll, YAW_LOOKRETURN, scaleAdjust); + scaletozero(ViewAngles.Yaw, YAW_LOOKRETURN, scaleAdjust); // Process keyboard input. if (auto looking = !!(*actions & SB_LOOK_RIGHT) - !!(*actions & SB_LOOK_LEFT)) { - ZzLOOKANG += getTicrateScale(YAW_LOOKINGSPEED) * getCorrectedScale(scaleAdjust) * looking; - ZzROTSCRNANG += getTicrateScale(YAW_ROTATESPEED) * getCorrectedScale(scaleAdjust) * looking; + ViewAngles.Yaw += getTicrateScale(YAW_LOOKINGSPEED) * getCorrectedScale(scaleAdjust) * looking; + ViewAngles.Roll += getTicrateScale(YAW_ROTATESPEED) * getCorrectedScale(scaleAdjust) * looking; } if (!lockedYaw()) @@ -302,7 +302,7 @@ void PlayerAngles::doViewPitch(const DVector2& pos, DAngle const ang, bool const // accordingly if (cursectnum == tempsect || (!isBlood() && abs(getflorzofslopeptr(tempsect, rotpt) - k) <= 4)) { - ZzHORIZOFF -= maphoriz(scaleAdjust * ((j - k) * (!isBlood() ? 0.625 : 5.5))); + ViewAngles.Pitch -= maphoriz(scaleAdjust * ((j - k) * (!isBlood() ? 0.625 : 5.5))); } } } @@ -310,16 +310,16 @@ void PlayerAngles::doViewPitch(const DVector2& pos, DAngle const ang, bool const if (climbing) { // tilt when climbing but you can't even really tell it. - if (ZzHORIZOFF > PITCH_HORIZOFFCLIMB) ZzHORIZOFF += getscaledangle(PITCH_HORIZOFFSPEED, scaleAdjust, deltaangle(ZzHORIZOFF, PITCH_HORIZOFFCLIMB), PITCH_HORIZOFFPUSH); + if (ViewAngles.Pitch > PITCH_HORIZOFFCLIMB) ViewAngles.Pitch += getscaledangle(PITCH_HORIZOFFSPEED, scaleAdjust, deltaangle(ViewAngles.Pitch, PITCH_HORIZOFFCLIMB), PITCH_HORIZOFFPUSH); } else { // Make horizoff grow towards 0 since horizoff is not modified when you're not on a slope. - scaletozero(ZzHORIZOFF, PITCH_HORIZOFFSPEED, scaleAdjust, PITCH_HORIZOFFPUSH); + scaletozero(ViewAngles.Pitch, PITCH_HORIZOFFSPEED, scaleAdjust, PITCH_HORIZOFFPUSH); } // Clamp off against the maximum allowed pitch. - ZzHORIZOFF = ClampViewPitch(ZzHORIZOFF); + ViewAngles.Pitch = ClampViewPitch(ViewAngles.Pitch); } } @@ -334,19 +334,15 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, PlayerAngles& w, P { if (arc.BeginObject(keyname)) { - arc("lookang", w.ZzLOOKANG) - ("rotscrnang", w.ZzROTSCRNANG) + arc("viewangles", w.ViewAngles) ("spin", w.YawSpin) ("actor", w.pActor) ("anglelocks", w.AngleLocks) - ("horizoff", w.ZzHORIZOFF) .EndObject(); if (arc.isReading()) { - w.ZzOLDLOOKANG = w.ZzLOOKANG; - w.ZzOLDROTSCRNANG = w.ZzROTSCRNANG; - w.ZzOHORIZOFF = w.ZzHORIZOFF; + w.backupViewAngles(); w.resetAdjustments(); } } diff --git a/source/core/gameinput.h b/source/core/gameinput.h index 28dab1d93..871fa1ad1 100644 --- a/source/core/gameinput.h +++ b/source/core/gameinput.h @@ -8,6 +8,12 @@ struct PlayerAngles { + // Player viewing angles, separate from the camera. + DRotator PrevViewAngles, ViewAngles; + + // Holder of current yaw spin state for the 180 degree turn. + DAngle YawSpin; + // Temporary wrappers. DAngle& ZzHORIZON() { return pActor->spr.Angles.Pitch; } DAngle& ZzOLDHORIZON() { return pActor->PrevAngles.Pitch; } @@ -25,6 +31,7 @@ struct PlayerAngles // General methods. void resetAdjustments() { Adjustments = {}; } + void backupViewAngles() { PrevViewAngles = ViewAngles; } void setActor(DCoreActor* const actor) { pActor = actor; } // Pitch methods. @@ -93,20 +100,17 @@ struct PlayerAngles // Legacy, to be removed. - DAngle ZzHORIZOFF, ZzOHORIZOFF; - DAngle horizOLDSUM() { return ZzOLDHORIZON() + ZzOHORIZOFF; } - DAngle horizSUM() { return ZzHORIZON() + ZzHORIZOFF; } + DAngle horizOLDSUM() { return ZzOLDHORIZON() + PrevViewAngles.Pitch; } + DAngle horizSUM() { return ZzHORIZON() + ViewAngles.Pitch; } DAngle horizLERPSUM(double const interpfrac) { return interpolatedvalue(horizOLDSUM(), horizSUM(), interpfrac); } - - DAngle ZzLOOKANG, ZzOLDLOOKANG, ZzROTSCRNANG, ZzOLDROTSCRNANG, YawSpin; - DAngle angOLDSUM() { return ZzOLDANGLE() + ZzOLDLOOKANG; } - DAngle angSUM() { return ZzANGLE() + ZzLOOKANG; } + DAngle angOLDSUM() { return ZzOLDANGLE() + PrevViewAngles.Yaw; } + DAngle angSUM() { return ZzANGLE() + ViewAngles.Yaw; } DAngle angLERPSUM(double const interpfrac) { return interpolatedvalue(angOLDSUM(), angSUM(), interpfrac); } DAngle angLERPANG(double const interpfrac) { return interpolatedvalue(ZzOLDANGLE(), ZzANGLE(), interpfrac); } - DAngle angLERPLOOKANG(double const interpfrac) { return interpolatedvalue(ZzOLDLOOKANG, ZzLOOKANG, interpfrac); } - DAngle angLERPROTSCRN(double const interpfrac) { return interpolatedvalue(ZzOLDROTSCRNANG, ZzROTSCRNANG, interpfrac); } - DAngle angRENDERLOOKANG(double const interpfrac) { return !SyncInput() ? ZzLOOKANG : angLERPLOOKANG(interpfrac); } - DAngle angRENDERROTSCRN(double const interpfrac) { return !SyncInput() ? ZzROTSCRNANG : angLERPROTSCRN(interpfrac); } + DAngle angLERPLOOKANG(double const interpfrac) { return interpolatedvalue(PrevViewAngles.Yaw, ViewAngles.Yaw, interpfrac); } + DAngle angLERPROTSCRN(double const interpfrac) { return interpolatedvalue(PrevViewAngles.Roll, ViewAngles.Roll, interpfrac); } + DAngle angRENDERLOOKANG(double const interpfrac) { return !SyncInput() ? ViewAngles.Yaw : angLERPLOOKANG(interpfrac); } + DAngle angRENDERROTSCRN(double const interpfrac) { return !SyncInput() ? ViewAngles.Roll : angLERPROTSCRN(interpfrac); } private: // DRotator indices. diff --git a/source/games/blood/src/player.cpp b/source/games/blood/src/player.cpp index e967e83ea..39cba8e11 100644 --- a/source/games/blood/src/player.cpp +++ b/source/games/blood/src/player.cpp @@ -822,7 +822,7 @@ void playerStart(int nPlayer, int bNewLevel) pPlayer->actor->xspr.health = pDudeInfo->startHealth << 4; pPlayer->actor->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE; pPlayer->bloodlust = 0; - pPlayer->Angles.ZzHORIZON() = pPlayer->Angles.ZzHORIZOFF = nullAngle; + pPlayer->Angles.ZzHORIZON() = pPlayer->Angles.ViewAngles.Pitch = nullAngle; pPlayer->slope = 0; pPlayer->fragger = nullptr; pPlayer->underwaterTime = 1200; @@ -1523,6 +1523,7 @@ void ProcessInput(PLAYER* pPlayer) }; pPlayer->Angles.resetAdjustments(); + pPlayer->Angles.backupViewAngles(); DBloodActor* actor = pPlayer->actor; POSTURE* pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture]; diff --git a/source/games/blood/src/view.cpp b/source/games/blood/src/view.cpp index 526acaa0e..bd982fcdb 100644 --- a/source/games/blood/src/view.cpp +++ b/source/games/blood/src/view.cpp @@ -503,7 +503,7 @@ static void SetupView(PLAYER* pPlayer, DVector3& cPos, DAngle& cA, DAngle& cH, s { cA = pPlayer->Angles.angSUM(); cH = pPlayer->Angles.horizSUM(); - rotscrnang = pPlayer->Angles.ZzROTSCRNANG; + rotscrnang = pPlayer->Angles.ViewAngles.Roll; } else { diff --git a/source/games/duke/src/gameexec.cpp b/source/games/duke/src/gameexec.cpp index 8524dcd93..d91d07b16 100644 --- a/source/games/duke/src/gameexec.cpp +++ b/source/games/duke/src/gameexec.cpp @@ -354,12 +354,12 @@ void DoPlayer(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor, break; case PLAYER_HORIZOFF: - if (bSet) ps[iPlayer].Angles.ZzHORIZOFF = maphoriz(-lValue); - else SetGameVarID(lVar2, int(ps[iPlayer].Angles.ZzHORIZOFF.Tan() * -128.), sActor, sPlayer); + if (bSet) ps[iPlayer].Angles.ViewAngles.Pitch = maphoriz(-lValue); + else SetGameVarID(lVar2, int(ps[iPlayer].Angles.ViewAngles.Pitch.Tan() * -128.), sActor, sPlayer); break; case PLAYER_OHORIZOFF: - if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].Angles.ZzOHORIZOFF.Tan() * -128.), sActor, sPlayer); + if (!bSet) SetGameVarID(lVar2, int(ps[iPlayer].Angles.PrevViewAngles.Pitch.Tan() * -128.), sActor, sPlayer); break; case PLAYER_INVDISPTIME: @@ -490,8 +490,8 @@ void DoPlayer(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor, break; case PLAYER_LOOK_ANG: - if (bSet) ps[iPlayer].Angles.ZzLOOKANG = mapangle(lValue); - else SetGameVarID(lVar2, ps[iPlayer].Angles.ZzLOOKANG.Buildang(), sActor, sPlayer); + if (bSet) ps[iPlayer].Angles.ViewAngles.Yaw = mapangle(lValue); + else SetGameVarID(lVar2, ps[iPlayer].Angles.ViewAngles.Yaw.Buildang(), sActor, sPlayer); break; case PLAYER_LAST_EXTRA: @@ -710,8 +710,8 @@ void DoPlayer(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor, break; case PLAYER_ROTSCRNANG: - if (bSet) ps[iPlayer].Angles.ZzOLDROTSCRNANG = ps[iPlayer].Angles.ZzROTSCRNANG = -mapangle(lValue); - else SetGameVarID(lVar2, -ps[iPlayer].Angles.ZzROTSCRNANG.Buildang(), sActor, sPlayer); + if (bSet) ps[iPlayer].Angles.PrevViewAngles.Roll = ps[iPlayer].Angles.ViewAngles.Roll = -mapangle(lValue); + else SetGameVarID(lVar2, -ps[iPlayer].Angles.ViewAngles.Roll.Buildang(), sActor, sPlayer); break; case PLAYER_DEAD_FLAG: @@ -2249,7 +2249,7 @@ int ParseState::parse(void) ps[g_p].Angles.ZzOLDHORIZON() = ps[g_p].Angles.ZzHORIZON() = nullAngle; ps[g_p].on_crane = nullptr; ps[g_p].frag_ps = g_p; - ps[g_p].Angles.ZzOHORIZOFF = ps[g_p].Angles.ZzHORIZOFF = nullAngle; + ps[g_p].Angles.PrevViewAngles.Pitch = ps[g_p].Angles.ViewAngles.Pitch = nullAngle; ps[g_p].opyoff = 0; ps[g_p].wackedbyactor = nullptr; ps[g_p].shield_amount = gs.max_armour_amount; @@ -2260,7 +2260,7 @@ int ParseState::parse(void) ps[g_p].weapreccnt = 0; ps[g_p].ftq = 0; ps[g_p].vel.X = ps[g_p].vel.Y = 0; - if (!isRR()) ps[g_p].Angles.ZzOLDROTSCRNANG = ps[g_p].Angles.ZzROTSCRNANG = nullAngle; + if (!isRR()) ps[g_p].Angles.PrevViewAngles.Roll = ps[g_p].Angles.ViewAngles.Roll = nullAngle; ps[g_p].falling_counter = 0; diff --git a/source/games/duke/src/player.cpp b/source/games/duke/src/player.cpp index 53ecde665..68d677d3b 100644 --- a/source/games/duke/src/player.cpp +++ b/source/games/duke/src/player.cpp @@ -120,8 +120,8 @@ void forceplayerangle(int snum) p->Angles.addPitch(DAngle::fromDeg(-26.566)); p->sync.actions |= SB_CENTERVIEW; - p->Angles.ZzLOOKANG = ang; - p->Angles.ZzROTSCRNANG = -ang; + p->Angles.ViewAngles.Yaw = ang; + p->Angles.ViewAngles.Roll = -ang; } //--------------------------------------------------------------------------- @@ -617,14 +617,14 @@ void playerisdead(int snum, int psectlotag, double floorz, double ceilingz) actor->backuploc(); - p->Angles.ZzHORIZOFF = p->Angles.ZzHORIZON() = nullAngle; + p->Angles.ViewAngles.Pitch = p->Angles.ZzHORIZON() = nullAngle; updatesector(p->GetActor()->getPosWithOffsetZ(), &p->cursector); pushmove(p->GetActor()->spr.pos.XY(), p->GetActor()->getOffsetZ(), &p->cursector, 8, 4, 20, CLIPMASK0); if (floorz > ceilingz + 16 && actor->spr.pal != 1) - p->Angles.ZzROTSCRNANG = DAngle::fromBuild(-(p->dead_flag + ((floorz + p->GetActor()->getOffsetZ()) * 2))); + p->Angles.ViewAngles.Roll = DAngle::fromBuild(-(p->dead_flag + ((floorz + p->GetActor()->getOffsetZ()) * 2))); p->on_warping_sector = 0; @@ -736,16 +736,16 @@ void player_struct::apply_seasick(double factor) if (SeaSick < 250) { if (SeaSick >= 180) - Angles.ZzROTSCRNANG -= DAngle::fromDeg(24 * factor * BAngToDegree); + Angles.ViewAngles.Roll -= DAngle::fromDeg(24 * factor * BAngToDegree); else if (SeaSick >= 130) - Angles.ZzROTSCRNANG += DAngle::fromDeg(24 * factor * BAngToDegree); + Angles.ViewAngles.Roll += DAngle::fromDeg(24 * factor * BAngToDegree); else if (SeaSick >= 70) - Angles.ZzROTSCRNANG -= DAngle::fromDeg(24 * factor * BAngToDegree); + Angles.ViewAngles.Roll -= DAngle::fromDeg(24 * factor * BAngToDegree); else if (SeaSick >= 20) - Angles.ZzROTSCRNANG += DAngle::fromDeg(24 * factor * BAngToDegree); + Angles.ViewAngles.Roll += DAngle::fromDeg(24 * factor * BAngToDegree); } if (SeaSick < 250) - Angles.ZzLOOKANG = DAngle::fromDeg(((krand() & 255) - 128) * factor * BAngToDegree); + Angles.ViewAngles.Yaw = DAngle::fromDeg(((krand() & 255) - 128) * factor * BAngToDegree); } } diff --git a/source/games/duke/src/player_d.cpp b/source/games/duke/src/player_d.cpp index 713fdd7f4..759061137 100644 --- a/source/games/duke/src/player_d.cpp +++ b/source/games/duke/src/player_d.cpp @@ -2726,6 +2726,7 @@ void processinput_d(int snum) auto pact = p->GetActor(); p->Angles.resetAdjustments(); + p->Angles.backupViewAngles(); ESyncBits& actions = p->sync.actions; diff --git a/source/games/duke/src/player_r.cpp b/source/games/duke/src/player_r.cpp index bc4751b5f..acea553e4 100644 --- a/source/games/duke/src/player_r.cpp +++ b/source/games/duke/src/player_r.cpp @@ -3273,6 +3273,7 @@ void processinput_r(int snum) auto pact = p->GetActor(); p->Angles.resetAdjustments(); + p->Angles.backupViewAngles(); ESyncBits& actions = p->sync.actions; diff --git a/source/games/duke/src/prediction.cpp b/source/games/duke/src/prediction.cpp index 0e4557716..cfd631f8b 100644 --- a/source/games/duke/src/prediction.cpp +++ b/source/games/duke/src/prediction.cpp @@ -55,7 +55,7 @@ void resetmys() myxvel = myyvel = myzvel = 0; myang = ps[myconnectindex].Angles.ZzANGLE(); myhoriz = omyhoriz = ps[myconnectindex].Angles.ZzHORIZON(); - myhorizoff = omyhorizoff = ps[myconnectindex].Angles.ZzHORIZOFF; + myhorizoff = omyhorizoff = ps[myconnectindex].Angles.ViewAngles.Pitch; mycursectnum = sectindex(ps[myconnectindex].cursector); myjumpingcounter = ps[myconnectindex].jumping_counter; myjumpingtoggle = ps[myconnectindex].jumping_toggle; diff --git a/source/games/duke/src/premap.cpp b/source/games/duke/src/premap.cpp index cce9f2305..5e8fced22 100644 --- a/source/games/duke/src/premap.cpp +++ b/source/games/duke/src/premap.cpp @@ -125,7 +125,7 @@ void resetplayerstats(int snum) p->footprintpal = 0; p->footprintshade = 0; p->jumping_toggle = 0; - p->Angles.ZzOHORIZOFF = p->Angles.ZzHORIZOFF = nullAngle; + p->Angles.PrevViewAngles.Pitch = p->Angles.ViewAngles.Pitch = nullAngle; p->bobcounter = 0; p->on_ground = 0; p->player_par = 0; @@ -150,8 +150,8 @@ void resetplayerstats(int snum) p->jetpack_on = 0; p->holoduke_on = nullptr; - p->Angles.ZzOLDLOOKANG = p->Angles.ZzLOOKANG = (currentLevel->levelNumber & 1)? DAngle90 : -DAngle90; - p->Angles.ZzOLDROTSCRNANG = p->Angles.ZzROTSCRNANG = nullAngle; + p->Angles.PrevViewAngles.Yaw = p->Angles.ViewAngles.Yaw = (currentLevel->levelNumber & 1)? DAngle90 : -DAngle90; + p->Angles.PrevViewAngles.Roll = p->Angles.ViewAngles.Roll = nullAngle; p->newOwner =nullptr; p->jumping_counter = 0; diff --git a/source/games/duke/src/render.cpp b/source/games/duke/src/render.cpp index c5a0be8fd..9f4cc10c2 100644 --- a/source/games/duke/src/render.cpp +++ b/source/games/duke/src/render.cpp @@ -271,7 +271,7 @@ void displayrooms(int snum, double interpfrac, bool sceneonly) setgamepalette(setpal(p)); // set screen rotation. - rotscrnang = !SyncInput() ? p->Angles.ZzROTSCRNANG : p->Angles.angLERPROTSCRN(interpfrac); + rotscrnang = !SyncInput() ? p->Angles.ViewAngles.Roll : p->Angles.angLERPROTSCRN(interpfrac); // use player's actor initially. viewer = p->GetActor(); diff --git a/source/games/exhumed/src/player.cpp b/source/games/exhumed/src/player.cpp index 475bd8b90..d97cc82df 100644 --- a/source/games/exhumed/src/player.cpp +++ b/source/games/exhumed/src/player.cpp @@ -905,6 +905,7 @@ void AIPlayer::Tick(RunListEvent* ev) int nActionB = PlayerList[nPlayer].nAction; PlayerList[nPlayer].Angles.resetAdjustments(); + PlayerList[nPlayer].Angles.backupViewAngles(); pPlayerActor->vel.XY() = sPlayerInput[nPlayer].vel; diff --git a/source/games/exhumed/src/view.cpp b/source/games/exhumed/src/view.cpp index ceba85e9c..145862eca 100644 --- a/source/games/exhumed/src/view.cpp +++ b/source/games/exhumed/src/view.cpp @@ -236,7 +236,7 @@ void DrawView(double interpfrac, bool sceneonly) { nCamerapan = PlayerList[nLocalPlayer].Angles.horizSUM(); nCameraang = PlayerList[nLocalPlayer].Angles.angSUM(); - rotscrnang = PlayerList[nLocalPlayer].Angles.ZzROTSCRNANG; + rotscrnang = PlayerList[nLocalPlayer].Angles.ViewAngles.Roll; } else { diff --git a/source/games/sw/src/draw.cpp b/source/games/sw/src/draw.cpp index bf67fb0ad..0a64d22c6 100644 --- a/source/games/sw/src/draw.cpp +++ b/source/games/sw/src/draw.cpp @@ -1252,7 +1252,7 @@ void drawscreen(PLAYER* pp, double interpfrac, bool sceneonly) { tang = pp->Angles.angSUM(); thoriz = pp->Angles.horizSUM(); - trotscrnang = pp->Angles.ZzROTSCRNANG; + trotscrnang = pp->Angles.ViewAngles.Roll; } tsect = camerapp->cursector; diff --git a/source/games/sw/src/player.cpp b/source/games/sw/src/player.cpp index df44583c6..37a5dec27 100644 --- a/source/games/sw/src/player.cpp +++ b/source/games/sw/src/player.cpp @@ -6972,6 +6972,7 @@ void domovethings(void) // Reset flags used while tying input to framerate pp->Flags2 &= ~(PF2_INPUT_CAN_AIM|PF2_INPUT_CAN_TURN_GENERAL|PF2_INPUT_CAN_TURN_VEHICLE|PF2_INPUT_CAN_TURN_TURRET); pp->Angles.resetAdjustments(); + pp->Angles.backupViewAngles(); // disable synchronised input if set by game. resetForcedSyncInput(); @@ -7062,7 +7063,7 @@ void InitAllPlayers(void) pp->FadeAmt = 0; pp->FadeTics = 0; pp->StartColor = 0; - pp->Angles.ZzHORIZOFF = nullAngle; + pp->Angles.ViewAngles.Pitch = nullAngle; INITLIST(&pp->PanelSpriteList); }