From e2711a74e784a0980f7ca2085fe2af1406df1f34 Mon Sep 17 00:00:00 2001 From: Randy Heit Date: Tue, 29 Mar 2016 21:48:57 -0500 Subject: [PATCH 01/13] Add float user vars for DECORATE - PClass::Extend now takes alignment into consideration. --- src/dobjtype.cpp | 15 ++++++++------- src/dobjtype.h | 3 ++- src/thingdef/thingdef_parse.cpp | 10 +++++----- 3 files changed, 15 insertions(+), 13 deletions(-) diff --git a/src/dobjtype.cpp b/src/dobjtype.cpp index 609ec17211..121c0fb27d 100644 --- a/src/dobjtype.cpp +++ b/src/dobjtype.cpp @@ -2403,22 +2403,23 @@ PClass *PClass::CreateDerivedClass(FName name, unsigned int size) //========================================================================== // -// PClass:: Extend +// PClass :: Extend // -// Add bytes to the end of this class. Returns the previous -// size of the class. +// Add bytes to the end of this class and possibly more to meet +// alignment restrictions. Returns the start of the extended block. // //========================================================================== -unsigned int PClass::Extend(unsigned int extension) +unsigned int PClass::Extend(unsigned int extension, unsigned int alignment) { assert(this->bRuntimeClass); unsigned int oldsize = Size; - Size += extension; + unsigned int padto = (oldsize + alignment - 1) & ~(alignment - 1); + Size = padto + extension; Defaults = (BYTE *)M_Realloc(Defaults, Size); - memset(Defaults + oldsize, 0, extension); - return oldsize; + memset(Defaults + oldsize, 0, Size - oldsize); + return padto; } //========================================================================== diff --git a/src/dobjtype.h b/src/dobjtype.h index b482efe457..05097795bb 100644 --- a/src/dobjtype.h +++ b/src/dobjtype.h @@ -660,7 +660,8 @@ public: void InsertIntoHash(); DObject *CreateNew() const; PClass *CreateDerivedClass(FName name, unsigned int size); - unsigned int Extend(unsigned int extension); + unsigned int Extend(unsigned int extension, unsigned int alignment); + unsigned int Extend(const PType *type) { return Extend(type->Size, type->Align); } void InitializeActorInfo(); void BuildFlatPointers(); const PClass *NativeClass() const; diff --git a/src/thingdef/thingdef_parse.cpp b/src/thingdef/thingdef_parse.cpp index 97e22dc8c0..cc2c71e34b 100644 --- a/src/thingdef/thingdef_parse.cpp +++ b/src/thingdef/thingdef_parse.cpp @@ -531,14 +531,14 @@ static void ParseUserVariable (FScanner &sc, PSymbolTable *symt, PClassActor *cl sc.ScriptError("Native classes may not have user variables"); } - // Read the type and make sure it's int. + // Read the type and make sure it's acceptable. sc.MustGetAnyToken(); - if (sc.TokenType != TK_Int) + if (sc.TokenType != TK_Int && sc.TokenType != TK_Float) { - sc.ScriptMessage("User variables must be of type int"); + sc.ScriptMessage("User variables must be of type 'int' or 'float'"); FScriptPosition::ErrorCounter++; } - type = TypeSInt32; + type = sc.TokenType == TK_Int ? (PType *)TypeSInt32 : (PType *)TypeFloat64; sc.MustGetToken(TK_Identifier); // For now, restrict user variables to those that begin with "user_" to guarantee @@ -585,7 +585,7 @@ static void ParseUserVariable (FScanner &sc, PSymbolTable *symt, PClassActor *cl sc.MustGetToken(';'); PField *sym = new PField(symname, type, 0); - sym->Offset = cls->Extend(sizeof(int) * maxelems); + sym->Offset = cls->Extend(type); if (symt->AddSymbol(sym) == NULL) { delete sym; From feb5ab31cc920cdc1053d35cef907c83ec5e8592 Mon Sep 17 00:00:00 2001 From: Randy Heit Date: Tue, 29 Mar 2016 22:05:25 -0500 Subject: [PATCH 02/13] Add double variants of SetValue() for numeric PTypes --- src/dobjtype.cpp | 29 ++++++++++++++++++++++++++++- src/dobjtype.h | 5 +++++ 2 files changed, 33 insertions(+), 1 deletion(-) diff --git a/src/dobjtype.cpp b/src/dobjtype.cpp index 121c0fb27d..0a964917c1 100644 --- a/src/dobjtype.cpp +++ b/src/dobjtype.cpp @@ -392,7 +392,12 @@ bool PType::VisitedNodeSet::Check(const PType *node) void PType::SetValue(void *addr, int val) { - assert(0 && "Cannot set value for this type"); + assert(0 && "Cannot set int value for this type"); +} + +void PType::SetValue(void *addr, double val) +{ + assert(0 && "Cannot set float value for this type"); } //========================================================================== @@ -682,6 +687,11 @@ void PInt::SetValue(void *addr, int val) } } +void PInt::SetValue(void *addr, double val) +{ + SetValue(addr, (int)val); +} + //========================================================================== // // PInt :: GetValueInt @@ -927,6 +937,11 @@ void PFloat::SetSymbols(const PFloat::SymbolInitI *sym, size_t count) //========================================================================== void PFloat::SetValue(void *addr, int val) +{ + return SetValue(addr, (double)val); +} + +void PFloat::SetValue(void *addr, double val) { assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address"); if (Size == 4) @@ -1112,6 +1127,12 @@ void PFixed::SetValue(void *addr, int val) *(fixed_t *)addr = val << FRACBITS; } +void PFixed::SetValue(void *addr, double val) +{ + assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address"); + *(fixed_t *)addr = FLOAT2FIXED(val); +} + //========================================================================== // // PFixed :: GetValueInt @@ -1173,6 +1194,12 @@ void PAngle::SetValue(void *addr, int val) *(angle_t *)addr = Scale(val, ANGLE_90, 90); } +void PAngle::SetValue(void *addr, double val) +{ + assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address"); + *(angle_t *)addr = (angle_t)(val * ANGLE_90 / 90); +} + //========================================================================== // // PAngle :: GetValueInt diff --git a/src/dobjtype.h b/src/dobjtype.h index 05097795bb..a5e2ab2a24 100644 --- a/src/dobjtype.h +++ b/src/dobjtype.h @@ -188,6 +188,7 @@ public: // Sets the value of a variable of this type at (addr) virtual void SetValue(void *addr, int val); + virtual void SetValue(void *addr, double val); // Gets the value of a variable of this type at (addr) virtual int GetValueInt(void *addr) const; @@ -320,6 +321,7 @@ public: PInt(unsigned int size, bool unsign); virtual void SetValue(void *addr, int val); + virtual void SetValue(void *addr, double val); virtual int GetValueInt(void *addr) const; virtual int GetStoreOp() const; virtual int GetLoadOp() const; @@ -344,6 +346,7 @@ public: PFloat(unsigned int size); virtual void SetValue(void *addr, int val); + virtual void SetValue(void *addr, double val); virtual int GetValueInt(void *addr) const; virtual int GetStoreOp() const; virtual int GetLoadOp() const; @@ -410,6 +413,7 @@ public: PFixed(); virtual void SetValue(void *addr, int val); + virtual void SetValue(void *addr, double val); virtual int GetValueInt(void *addr) const; virtual int GetStoreOp() const; virtual int GetLoadOp() const; @@ -422,6 +426,7 @@ public: PAngle(); virtual void SetValue(void *addr, int val); + virtual void SetValue(void *addr, double val); virtual int GetValueInt(void *addr) const; virtual int GetStoreOp() const; virtual int GetLoadOp() const; From 299019ea158d794e599e5bdf739d98285e64d9f6 Mon Sep 17 00:00:00 2001 From: Randy Heit Date: Tue, 29 Mar 2016 22:24:59 -0500 Subject: [PATCH 03/13] Add GetValueFloat() for numeric PTypes --- src/dobjtype.cpp | 56 ++++++++++++++++++++++++++++++++++++++++++++++-- src/dobjtype.h | 5 +++++ 2 files changed, 59 insertions(+), 2 deletions(-) diff --git a/src/dobjtype.cpp b/src/dobjtype.cpp index 0a964917c1..552b8ee685 100644 --- a/src/dobjtype.cpp +++ b/src/dobjtype.cpp @@ -412,6 +412,12 @@ int PType::GetValueInt(void *addr) const return 0; } +double PType::GetValueFloat(void *addr) const +{ + assert(0 && "Cannot get value for this type"); + return 0; +} + //========================================================================== // // PType :: GetStoreOp @@ -724,6 +730,17 @@ int PInt::GetValueInt(void *addr) const } } +//========================================================================== +// +// PInt :: GetValueFloat +// +//========================================================================== + +double PInt::GetValueFloat(void *addr) const +{ + return GetValueInt(addr); +} + //========================================================================== // // PInt :: GetStoreOp @@ -962,16 +979,27 @@ void PFloat::SetValue(void *addr, double val) //========================================================================== int PFloat::GetValueInt(void *addr) const +{ + return xs_ToInt(GetValueFloat(addr)); +} + +//========================================================================== +// +// PFloat :: GetValueFloat +// +//========================================================================== + +double PFloat::GetValueFloat(void *addr) const { assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address"); if (Size == 4) { - return xs_ToInt(*(float *)addr); + return *(float *)addr; } else { assert(Size == 8); - return xs_ToInt(*(double *)addr); + return *(double *)addr; } } @@ -1145,6 +1173,18 @@ int PFixed::GetValueInt(void *addr) const return *(fixed_t *)addr >> FRACBITS; } +//========================================================================== +// +// PFixed :: GetValueFloat +// +//========================================================================== + +double PFixed::GetValueFloat(void *addr) const +{ + assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address"); + return FIXED2DBL(*(fixed_t *)addr); +} + //========================================================================== // // PFixed :: GetStoreOp @@ -1212,6 +1252,18 @@ int PAngle::GetValueInt(void *addr) const return *(angle_t *)addr / ANGLE_1; } +//========================================================================== +// +// PAngle :: GetValueFloat +// +//========================================================================== + +double PAngle::GetValueFloat(void *addr) const +{ + assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address"); + return (double)(*(angle_t *)addr) / ANGLE_1; +} + //========================================================================== // // PAngle :: GetStoreOp diff --git a/src/dobjtype.h b/src/dobjtype.h index a5e2ab2a24..e9ff982454 100644 --- a/src/dobjtype.h +++ b/src/dobjtype.h @@ -192,6 +192,7 @@ public: // Gets the value of a variable of this type at (addr) virtual int GetValueInt(void *addr) const; + virtual double GetValueFloat(void *addr) const; // Gets the opcode to store from a register to memory virtual int GetStoreOp() const; @@ -323,6 +324,7 @@ public: virtual void SetValue(void *addr, int val); virtual void SetValue(void *addr, double val); virtual int GetValueInt(void *addr) const; + virtual double GetValueFloat(void *addr) const; virtual int GetStoreOp() const; virtual int GetLoadOp() const; virtual int GetRegType() const; @@ -348,6 +350,7 @@ public: virtual void SetValue(void *addr, int val); virtual void SetValue(void *addr, double val); virtual int GetValueInt(void *addr) const; + virtual double GetValueFloat(void *addr) const; virtual int GetStoreOp() const; virtual int GetLoadOp() const; virtual int GetRegType() const; @@ -415,6 +418,7 @@ public: virtual void SetValue(void *addr, int val); virtual void SetValue(void *addr, double val); virtual int GetValueInt(void *addr) const; + virtual double GetValueFloat(void *addr) const; virtual int GetStoreOp() const; virtual int GetLoadOp() const; }; @@ -428,6 +432,7 @@ public: virtual void SetValue(void *addr, int val); virtual void SetValue(void *addr, double val); virtual int GetValueInt(void *addr) const; + virtual double GetValueFloat(void *addr) const; virtual int GetStoreOp() const; virtual int GetLoadOp() const; }; From b6e3358b1cf62e39bd4f6c7d54ffacf546bd3cec Mon Sep 17 00:00:00 2001 From: Randy Heit Date: Tue, 29 Mar 2016 22:14:31 -0500 Subject: [PATCH 04/13] Add A_SetUserVarFloat and A_SetUserArrayFloat --- src/thingdef/thingdef_codeptr.cpp | 86 ++++++++++++++++++++++++------- wadsrc/static/actors/actor.txt | 2 + 2 files changed, 70 insertions(+), 18 deletions(-) diff --git a/src/thingdef/thingdef_codeptr.cpp b/src/thingdef/thingdef_codeptr.cpp index 6efbeb1671..9fa547f461 100644 --- a/src/thingdef/thingdef_codeptr.cpp +++ b/src/thingdef/thingdef_codeptr.cpp @@ -4681,22 +4681,46 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetSpecial) // //=========================================================================== -DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetUserVar) +static PField *GetVar(AActor *self, FName varname) { - PARAM_ACTION_PROLOGUE; - PARAM_NAME (varname); - PARAM_INT (value); - PField *var = dyn_cast(self->GetClass()->Symbols.FindSymbol(varname, true)); if (var == NULL || (var->Flags & VARF_Native) || !var->Type->IsKindOf(RUNTIME_CLASS(PBasicType))) { Printf("%s is not a user variable in class %s\n", varname.GetChars(), self->GetClass()->TypeName.GetChars()); - return 0; + return nullptr; } + return var; +} + +DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetUserVar) +{ + PARAM_ACTION_PROLOGUE; + PARAM_NAME (varname); + PARAM_INT (value); + // Set the value of the specified user variable. - var->Type->SetValue(reinterpret_cast(self) + var->Offset, value); + PField *var = GetVar(self, varname); + if (var != nullptr) + { + var->Type->SetValue(reinterpret_cast(self) + var->Offset, value); + } + return 0; +} + +DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetUserVarFloat) +{ + PARAM_ACTION_PROLOGUE; + PARAM_NAME (varname); + PARAM_FLOAT (value); + + // Set the value of the specified user variable. + PField *var = GetVar(self, varname); + if (var != nullptr) + { + var->Type->SetValue(reinterpret_cast(self) + var->Offset, value); + } return 0; } @@ -4706,13 +4730,8 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetUserVar) // //=========================================================================== -DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetUserArray) +static PField *GetArrayVar(AActor *self, FName varname, int pos) { - PARAM_ACTION_PROLOGUE; - PARAM_NAME (varname); - PARAM_INT (pos); - PARAM_INT (value); - PField *var = dyn_cast(self->GetClass()->Symbols.FindSymbol(varname, true)); if (var == NULL || (var->Flags & VARF_Native) || @@ -4721,17 +4740,48 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetUserArray) { Printf("%s is not a user array in class %s\n", varname.GetChars(), self->GetClass()->TypeName.GetChars()); - return 0; + return nullptr; } - PArray *arraytype = static_cast(var->Type); - if ((unsigned)pos >= arraytype->ElementCount) + if ((unsigned)pos >= static_cast(var->Type)->ElementCount) { Printf("%d is out of bounds in array %s in class %s\n", pos, varname.GetChars(), self->GetClass()->TypeName.GetChars()); - return 0; + return nullptr; } + return var; +} + +DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetUserArray) +{ + PARAM_ACTION_PROLOGUE; + PARAM_NAME (varname); + PARAM_INT (pos); + PARAM_INT (value); + // Set the value of the specified user array at index pos. - arraytype->ElementType->SetValue(reinterpret_cast(self) + var->Offset + arraytype->ElementSize * pos, value); + PField *var = GetArrayVar(self, varname, pos); + if (var != nullptr) + { + PArray *arraytype = static_cast(var->Type); + arraytype->ElementType->SetValue(reinterpret_cast(self) + var->Offset + arraytype->ElementSize * pos, value); + } + return 0; +} + +DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetUserArrayFloat) +{ + PARAM_ACTION_PROLOGUE; + PARAM_NAME (varname); + PARAM_INT (pos); + PARAM_FLOAT (value); + + // Set the value of the specified user array at index pos. + PField *var = GetArrayVar(self, varname, pos); + if (var != nullptr) + { + PArray *arraytype = static_cast(var->Type); + arraytype->ElementType->SetValue(reinterpret_cast(self) + var->Offset + arraytype->ElementSize * pos, value); + } return 0; } diff --git a/wadsrc/static/actors/actor.txt b/wadsrc/static/actors/actor.txt index e3bb06fe74..7548cd6c91 100644 --- a/wadsrc/static/actors/actor.txt +++ b/wadsrc/static/actors/actor.txt @@ -275,6 +275,8 @@ ACTOR Actor native //: Thinker action native A_SetArg(int pos, int value); action native A_SetUserVar(name varname, int value); action native A_SetUserArray(name varname, int index, int value); + action native A_SetUserVarFloat(name varname, float value); + action native A_SetUserArrayFloat(name varname, int index, float value); action native A_SetSpecial(int spec, int arg0 = 0, int arg1 = 0, int arg2 = 0, int arg3 = 0, int arg4 = 0); action native A_Quake(int intensity, int duration, int damrad, int tremrad, sound sfx = "world/quake"); action native A_QuakeEx(int intensityX, int intensityY, int intensityZ, int duration, int damrad, int tremrad, sound sfx = "world/quake", int flags = 0, float mulWaveX = 1, float mulWaveY = 1, float mulWaveZ = 1, int falloff = 0, int highpoint = 0); From 35121544b4eb5d8dbdad1aedd9889b12db539cc7 Mon Sep 17 00:00:00 2001 From: Randy Heit Date: Tue, 29 Mar 2016 22:33:10 -0500 Subject: [PATCH 05/13] Add float support to ACS's Get/SetUserVariable functions - "Support" means that setting one will convert from fixed point to floating point, and reading one will do the reverse. --- src/p_acs.cpp | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/src/p_acs.cpp b/src/p_acs.cpp index fe10921d03..42048c159e 100644 --- a/src/p_acs.cpp +++ b/src/p_acs.cpp @@ -4567,7 +4567,14 @@ static void SetUserVariable(AActor *self, FName varname, int index, int value) if (GetVarAddrType(self, varname, index, addr, type)) { - type->SetValue(addr, value); + if (!type->IsKindOf(RUNTIME_CLASS(PFloat))) + { + type->SetValue(addr, value); + } + else + { + type->SetValue(addr, FIXED2DBL(value)); + } } } @@ -4578,7 +4585,14 @@ static int GetUserVariable(AActor *self, FName varname, int index) if (GetVarAddrType(self, varname, index, addr, type)) { - return type->GetValueInt(addr); + if (!type->IsKindOf(RUNTIME_CLASS(PFloat))) + { + return type->GetValueInt(addr); + } + else + { + return FLOAT2FIXED(type->GetValueFloat(addr)); + } } return 0; } From b37ef48e99a5729a21356e30ab36f1f671eebd5a Mon Sep 17 00:00:00 2001 From: Randy Heit Date: Tue, 29 Mar 2016 22:36:26 -0500 Subject: [PATCH 06/13] Allow ACS's GetUserVariable to access non-user variables - Since DECORATE already allows reading all declared variables in a class, where's the utility in keeping this restriction in ACS? - Variables must still be numeric types. - SetUserVariable is still restricted to user variables only. --- src/p_acs.cpp | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/p_acs.cpp b/src/p_acs.cpp index 42048c159e..9dbbd5eea4 100644 --- a/src/p_acs.cpp +++ b/src/p_acs.cpp @@ -4529,12 +4529,12 @@ int DLevelScript::LineFromID(int id) } } -bool GetVarAddrType(AActor *self, FName varname, int index, void *&addr, PType *&type) +bool GetVarAddrType(AActor *self, FName varname, int index, void *&addr, PType *&type, bool allownative) { PField *var = dyn_cast(self->GetClass()->Symbols.FindSymbol(varname, true)); PArray *arraytype; - if (var == NULL || (var->Flags & VARF_Native)) + if (var == NULL || (!allownative && (var->Flags & VARF_Native))) { return false; } @@ -4557,6 +4557,12 @@ bool GetVarAddrType(AActor *self, FName varname, int index, void *&addr, PType * return false; } addr = baddr; + // We don't want Int subclasses like Name or Color to be accessible, + // but we do want to support Float subclasses like Fixed. + if (!type->IsA(RUNTIME_CLASS(PInt)) || !type->IsKindOf(RUNTIME_CLASS(PFloat))) + { + return false; + } return true; } @@ -4565,7 +4571,7 @@ static void SetUserVariable(AActor *self, FName varname, int index, int value) void *addr; PType *type; - if (GetVarAddrType(self, varname, index, addr, type)) + if (GetVarAddrType(self, varname, index, addr, type, false)) { if (!type->IsKindOf(RUNTIME_CLASS(PFloat))) { @@ -4583,7 +4589,7 @@ static int GetUserVariable(AActor *self, FName varname, int index) void *addr; PType *type; - if (GetVarAddrType(self, varname, index, addr, type)) + if (GetVarAddrType(self, varname, index, addr, type, true)) { if (!type->IsKindOf(RUNTIME_CLASS(PFloat))) { From 1648a71e45c00296094f0505c79f8d8b2f7f8fa6 Mon Sep 17 00:00:00 2001 From: Randy Heit Date: Tue, 29 Mar 2016 22:49:12 -0500 Subject: [PATCH 07/13] Add support for Name and String types to ACS's GetUserVariable - Reading one of these types will copy its value into the global ACS string table and return the index. --- src/p_acs.cpp | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/src/p_acs.cpp b/src/p_acs.cpp index 9dbbd5eea4..1436836020 100644 --- a/src/p_acs.cpp +++ b/src/p_acs.cpp @@ -4529,12 +4529,12 @@ int DLevelScript::LineFromID(int id) } } -bool GetVarAddrType(AActor *self, FName varname, int index, void *&addr, PType *&type, bool allownative) +bool GetVarAddrType(AActor *self, FName varname, int index, void *&addr, PType *&type, bool readonly) { PField *var = dyn_cast(self->GetClass()->Symbols.FindSymbol(varname, true)); PArray *arraytype; - if (var == NULL || (!allownative && (var->Flags & VARF_Native))) + if (var == NULL || (!readonly && (var->Flags & VARF_Native))) { return false; } @@ -4561,6 +4561,11 @@ bool GetVarAddrType(AActor *self, FName varname, int index, void *&addr, PType * // but we do want to support Float subclasses like Fixed. if (!type->IsA(RUNTIME_CLASS(PInt)) || !type->IsKindOf(RUNTIME_CLASS(PFloat))) { + // For reading, we also support Name and String types. + if (readonly && (type->IsA(RUNTIME_CLASS(PName)) || type->IsA(RUNTIME_CLASS(PString)))) + { + return true; + } return false; } return true; @@ -4591,13 +4596,21 @@ static int GetUserVariable(AActor *self, FName varname, int index) if (GetVarAddrType(self, varname, index, addr, type, true)) { - if (!type->IsKindOf(RUNTIME_CLASS(PFloat))) + if (type->IsKindOf(RUNTIME_CLASS(PFloat))) { - return type->GetValueInt(addr); + return FLOAT2FIXED(type->GetValueFloat(addr)); + } + else if (type->IsA(RUNTIME_CLASS(PName))) + { + return GlobalACSStrings.AddString(FName(ENamedName(type->GetValueInt(addr))).GetChars()); + } + else if (type->IsA(RUNTIME_CLASS(PString))) + { + return GlobalACSStrings.AddString(*(FString *)addr); } else { - return FLOAT2FIXED(type->GetValueFloat(addr)); + return type->GetValueInt(addr); } } return 0; From 77f2530236c11476b3813aa416d13991f6fbe2eb Mon Sep 17 00:00:00 2001 From: Christoph Oelckers Date: Wed, 30 Mar 2016 09:41:46 +0200 Subject: [PATCH 08/13] - floatified the sector plane movers and removed some of the ZatPoint conversion cruft. --- src/b_func.cpp | 8 +- src/compatibility.cpp | 8 +- src/dsectoreffect.cpp | 24 ++--- src/dsectoreffect.h | 29 +++-- src/edata.cpp | 8 +- src/fragglescript/t_func.cpp | 66 ++++++------ src/g_heretic/a_hereticweaps.cpp | 6 +- src/g_strife/a_strifestuff.cpp | 2 +- src/g_strife/a_thingstoblowup.cpp | 6 +- src/p_3dfloors.cpp | 10 +- src/p_3dmidtex.cpp | 2 +- src/p_3dmidtex.h | 4 +- src/p_acs.cpp | 14 +-- src/p_ceiling.cpp | 18 ++-- src/p_doors.cpp | 54 +++++----- src/p_floor.cpp | 114 ++++++++++---------- src/p_linkedsectors.cpp | 6 +- src/p_lnspec.cpp | 94 ++++++++-------- src/p_local.h | 2 +- src/p_map.cpp | 16 +-- src/p_mobj.cpp | 42 ++++---- src/p_pillar.cpp | 32 +++--- src/p_plats.cpp | 60 +++++------ src/p_scroll.cpp | 6 +- src/p_sectors.cpp | 172 +++++++++++++++--------------- src/p_sight.cpp | 20 ++-- src/p_slopes.cpp | 4 +- src/p_spec.cpp | 6 +- src/p_spec.h | 132 +++++++++-------------- src/p_user.cpp | 2 +- src/po_man.cpp | 4 +- src/portal.cpp | 4 +- src/r_3dfloors.cpp | 4 +- src/r_bsp.cpp | 16 +-- src/r_defs.h | 111 ++++++++++--------- src/r_segs.cpp | 12 +-- 36 files changed, 552 insertions(+), 566 deletions(-) diff --git a/src/b_func.cpp b/src/b_func.cpp index e292fd67d0..ca9c0d7b27 100644 --- a/src/b_func.cpp +++ b/src/b_func.cpp @@ -34,13 +34,13 @@ bool DBot::Reachable (AActor *rtarget) if (player->mo == rtarget) return false; - if ((rtarget->Sector->ceilingplane.ZatPointF (rtarget) - - rtarget->Sector->floorplane.ZatPointF (rtarget)) + if ((rtarget->Sector->ceilingplane.ZatPoint (rtarget) - + rtarget->Sector->floorplane.ZatPoint (rtarget)) < player->mo->Height) //Where rtarget is, player->mo can't be. return false; sector_t *last_s = player->mo->Sector; - double last_z = last_s->floorplane.ZatPointF (player->mo); + double last_z = last_s->floorplane.ZatPoint (player->mo); double estimated_dist = player->mo->Distance2D(rtarget); bool reachable = true; @@ -100,7 +100,7 @@ bool DBot::Reachable (AActor *rtarget) thing = in->d.thing; if (thing == player->mo) //Can't reach self in this case. continue; - if (thing == rtarget && (rtarget->Sector->floorplane.ZatPointF (rtarget) <= (last_z+MAXMOVEHEIGHT))) + if (thing == rtarget && (rtarget->Sector->floorplane.ZatPoint (rtarget) <= (last_z+MAXMOVEHEIGHT))) { return true; } diff --git a/src/compatibility.cpp b/src/compatibility.cpp index 8157506fd1..e7121da8b5 100644 --- a/src/compatibility.cpp +++ b/src/compatibility.cpp @@ -290,7 +290,7 @@ void ParseCompatibility() sc.MustGetNumber(); CompatParams.Push(sc.Number); sc.MustGetFloat(); - CompatParams.Push(FLOAT2FIXED(sc.Float)); + CompatParams.Push(int(sc.Float*65536.)); } else if (sc.Compare("setwallyscale")) { @@ -303,7 +303,7 @@ void ParseCompatibility() sc.MustGetString(); CompatParams.Push(sc.MustMatchString(WallTiers)); sc.MustGetFloat(); - CompatParams.Push(FLOAT2FIXED(sc.Float)); + CompatParams.Push(int(sc.Float*65536.)); } else if (sc.Compare("setthingz")) { @@ -522,7 +522,7 @@ void SetCompatibilityParams() { sector_t *sec = §ors[CompatParams[i+1]]; sec->floorplane.ChangeHeight(CompatParams[i+2]); - sec->ChangePlaneTexZ(sector_t::floor, CompatParams[i+2]); + sec->ChangePlaneTexZ(sector_t::floor, CompatParams[i+2] / 65536.); } i += 3; break; @@ -534,7 +534,7 @@ void SetCompatibilityParams() side_t *side = lines[CompatParams[i+1]].sidedef[CompatParams[i+2]]; if (side != NULL) { - side->SetTextureYScale(CompatParams[i+3], CompatParams[i+4]); + side->SetTextureYScale(CompatParams[i+3], CompatParams[i+4] / 65536.); } } i += 5; diff --git a/src/dsectoreffect.cpp b/src/dsectoreffect.cpp index 2d0c029828..50909764f4 100644 --- a/src/dsectoreffect.cpp +++ b/src/dsectoreffect.cpp @@ -133,7 +133,7 @@ DMovingCeiling::DMovingCeiling (sector_t *sector) interpolation = sector->SetInterpolation(sector_t::CeilingMove, true); } -bool DMover::MoveAttached(int crush, fixed_t move, int floorOrCeiling, bool resetfailed) +bool DMover::MoveAttached(int crush, double move, int floorOrCeiling, bool resetfailed) { if (!P_Scroll3dMidtex(m_Sector, crush, move, !!floorOrCeiling) && resetfailed) { @@ -155,20 +155,20 @@ bool DMover::MoveAttached(int crush, fixed_t move, int floorOrCeiling, bool rese // (Use -1 to prevent it from trying to crush) // dest is the desired d value for the plane // -DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush, +DMover::EResult DMover::MovePlane (double speed, double dest, int crush, int floorOrCeiling, int direction, bool hexencrush) { bool flag; - fixed_t lastpos; - fixed_t movedest; - fixed_t move; - //fixed_t destheight; //jff 02/04/98 used to keep floors/ceilings + double lastpos; + double movedest; + double move; + //double destheight; //jff 02/04/98 used to keep floors/ceilings // from moving thru each other switch (floorOrCeiling) { case 0: // FLOOR - lastpos = m_Sector->floorplane.fixD(); + lastpos = m_Sector->floorplane.fD(); switch (direction) { case -1: @@ -223,9 +223,9 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush, // [RH] not so easy with arbitrary planes //destheight = (dest < m_Sector->ceilingheight) ? dest : m_Sector->ceilingheight; if (!m_Sector->ceilingplane.isSlope() && !m_Sector->floorplane.isSlope() && - (!(i_compatflags2 & COMPATF2_FLOORMOVE) && -dest > m_Sector->ceilingplane.fixD())) + (!(i_compatflags2 & COMPATF2_FLOORMOVE) && -dest > m_Sector->ceilingplane.fD())) { - dest = -m_Sector->ceilingplane.fixD(); + dest = -m_Sector->ceilingplane.fD(); } movedest = m_Sector->floorplane.GetChangedHeight (speed); @@ -282,7 +282,7 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush, case 1: // CEILING - lastpos = m_Sector->ceilingplane.fixD(); + lastpos = m_Sector->ceilingplane.fD(); switch (direction) { case -1: @@ -291,9 +291,9 @@ DMover::EResult DMover::MovePlane (fixed_t speed, fixed_t dest, int crush, // [RH] not so easy with arbitrary planes //destheight = (dest > m_Sector->floorheight) ? dest : m_Sector->floorheight; if (!m_Sector->ceilingplane.isSlope() && !m_Sector->floorplane.isSlope() && - (!(i_compatflags2 & COMPATF2_FLOORMOVE) && dest < -m_Sector->floorplane.fixD())) + (!(i_compatflags2 & COMPATF2_FLOORMOVE) && dest < -m_Sector->floorplane.fD())) { - dest = -m_Sector->floorplane.fixD(); + dest = -m_Sector->floorplane.fD(); } movedest = m_Sector->ceilingplane.GetChangedHeight (-speed); if (movedest <= dest) diff --git a/src/dsectoreffect.h b/src/dsectoreffect.h index 9aa3ccb505..6e52d27422 100644 --- a/src/dsectoreffect.h +++ b/src/dsectoreffect.h @@ -30,26 +30,43 @@ protected: enum EResult { ok, crushed, pastdest }; TObjPtr interpolation; private: - bool MoveAttached(int crush, fixed_t move, int floorOrCeiling, bool resetfailed); - EResult MovePlane (fixed_t speed, fixed_t dest, int crush, int floorOrCeiling, int direction, bool hexencrush); + bool MoveAttached(int crush, double move, int floorOrCeiling, bool resetfailed); + EResult MovePlane (double speed, double dest, int crush, int floorOrCeiling, int direction, bool hexencrush); protected: DMover (); void Serialize (FArchive &arc); void Destroy(); void StopInterpolation(bool force = false); - inline EResult MoveFloor (fixed_t speed, fixed_t dest, int crush, int direction, bool hexencrush) + inline EResult MoveFloor(fixed_t speed, fixed_t dest, int crush, int direction, bool hexencrush) + { + return MovePlane(FIXED2DBL(speed), FIXED2DBL(dest), crush, 0, direction, hexencrush); + } + inline EResult MoveFloor(fixed_t speed, fixed_t dest, int direction) + { + return MovePlane(FIXED2DBL(speed), FIXED2DBL(dest), -1, 0, direction, false); + } + inline EResult MoveCeiling(fixed_t speed, fixed_t dest, int crush, int direction, bool hexencrush) + { + return MovePlane(FIXED2DBL(speed), FIXED2DBL(dest), crush, 1, direction, hexencrush); + } + inline EResult MoveCeiling(fixed_t speed, fixed_t dest, int direction) + { + return MovePlane(FIXED2DBL(speed), FIXED2DBL(dest), -1, 1, direction, false); + } + + inline EResult MoveFloor (double speed, double dest, int crush, int direction, bool hexencrush) { return MovePlane (speed, dest, crush, 0, direction, hexencrush); } - inline EResult MoveFloor (fixed_t speed, fixed_t dest, int direction) + inline EResult MoveFloor (double speed, double dest, int direction) { return MovePlane (speed, dest, -1, 0, direction, false); } - inline EResult MoveCeiling (fixed_t speed, fixed_t dest, int crush, int direction, bool hexencrush) + inline EResult MoveCeiling (double speed, double dest, int crush, int direction, bool hexencrush) { return MovePlane (speed, dest, crush, 1, direction, hexencrush); } - inline EResult MoveCeiling (fixed_t speed, fixed_t dest, int direction) + inline EResult MoveCeiling (double speed, double dest, int direction) { return MovePlane (speed, dest, -1, 1, direction, false); } diff --git a/src/edata.cpp b/src/edata.cpp index da41400a8e..034c450868 100644 --- a/src/edata.cpp +++ b/src/edata.cpp @@ -105,7 +105,7 @@ struct EDLinedef int tag; int id; int args[5]; - fixed_t alpha; + double alpha; DWORD flags; DWORD activation; }; @@ -158,7 +158,7 @@ static void parseLinedef(FScanner &sc) bool argsset = false; memset(&ld, 0, sizeof(ld)); - ld.alpha = FRACUNIT; + ld.alpha = 1.; sc.MustGetStringName("{"); while (!sc.CheckString("}")) @@ -216,7 +216,7 @@ static void parseLinedef(FScanner &sc) { sc.CheckString("="); sc.MustGetFloat(); - ld.alpha = FLOAT2FIXED(sc.Float); + ld.alpha = sc.Float; } else if (sc.Compare("extflags")) { @@ -703,7 +703,7 @@ void ProcessEDLinedef(line_t *ld, int recordnum) ld->special = eld->special; ld->activation = eld->activation; ld->flags = (ld->flags&~fmask) | eld->flags; - ld->Alpha = eld->alpha; + ld->setAlpha(eld->alpha); memcpy(ld->args, eld->args, sizeof(ld->args)); tagManager.AddLineID(int(ld - lines), eld->tag); } diff --git a/src/fragglescript/t_func.cpp b/src/fragglescript/t_func.cpp index 9a2522256e..163a6b73b2 100644 --- a/src/fragglescript/t_func.cpp +++ b/src/fragglescript/t_func.cpp @@ -1537,16 +1537,13 @@ void FParser::SF_StartSectorSound(void) /************* Sector functions ***************/ -//DMover::EResult P_MoveFloor (sector_t * m_Sector, fixed_t speed, fixed_t dest, int crush, int direction, int flags=0); -//DMover::EResult P_MoveCeiling (sector_t * m_Sector, fixed_t speed, fixed_t dest, int crush, int direction, int flags=0); - class DFloorChanger : public DFloor { public: DFloorChanger(sector_t * sec) : DFloor(sec) {} - bool Move(fixed_t speed, fixed_t dest, int crush, int direction) + bool Move(double speed, double dest, int crush, int direction) { bool res = DMover::crushed != MoveFloor(speed, dest, crush, direction, false); Destroy(); @@ -1569,8 +1566,8 @@ void FParser::SF_FloorHeight(void) { int tagnum; int secnum; - fixed_t dest; - int returnval = 1; // haleyjd: SoM's fixes + double dest; + double returnval = 1; // haleyjd: SoM's fixes if (CheckArgs(1)) { @@ -1582,7 +1579,7 @@ void FParser::SF_FloorHeight(void) int crush = (t_argc >= 3) ? intvalue(t_argv[2]) : false; i = -1; - dest = fixedvalue(t_argv[1]); + dest = floatvalue(t_argv[1]); // set all sectors with tag @@ -1593,8 +1590,8 @@ void FParser::SF_FloorHeight(void) DFloorChanger * f = new DFloorChanger(§ors[i]); if (!f->Move( - abs(dest - sectors[i].CenterFloor()), - sectors[i].floorplane.PointToDist (sectors[i]._f_centerspot(), dest), + fabs(dest - sectors[i].CenterFloor()), + sectors[i].floorplane.PointToDist (sectors[i].centerspot, dest), crush? 10:-1, (dest > sectors[i].CenterFloor()) ? 1 : -1)) { @@ -1610,13 +1607,11 @@ void FParser::SF_FloorHeight(void) script_error("sector not found with tagnum %i\n", tagnum); return; } - returnval = sectors[secnum].CenterFloor() >> FRACBITS; + returnval = sectors[secnum].CenterFloor(); } // return floor height - - t_return.type = svt_int; - t_return.value.i = returnval; + t_return.setDouble(returnval); } } @@ -1628,7 +1623,7 @@ void FParser::SF_FloorHeight(void) class DMoveFloor : public DFloor { public: - DMoveFloor(sector_t * sec,int moveheight,int _m_Direction,int crush,int movespeed) + DMoveFloor(sector_t * sec,double moveheight,int _m_Direction,int crush,double movespeed) : DFloor(sec) { m_Type = floorRaiseByValue; @@ -1638,7 +1633,7 @@ public: m_FloorDestDist = moveheight; // Do not interpolate instant movement floors. - fixed_t movedist = abs(-sec->floorplane.fixD() - moveheight); + double movedist = fabs(-sec->floorplane.fD() - moveheight); if (m_Speed >= movedist) { StopInterpolation(true); @@ -1660,13 +1655,14 @@ void FParser::SF_MoveFloor(void) { int secnum = -1; sector_t *sec; - int tagnum, platspeed = 1, destheight, crush; + int tagnum, crush; + double platspeed = 1, destheight; if (CheckArgs(2)) { tagnum = intvalue(t_argv[0]); - destheight = intvalue(t_argv[1]) * FRACUNIT; - platspeed = t_argc > 2 ? fixedvalue(t_argv[2]) : FRACUNIT; + destheight = intvalue(t_argv[1]); + platspeed = t_argc > 2 ? floatvalue(t_argv[2]) : 1.; crush = (t_argc > 3 ? intvalue(t_argv[3]) : -1); // move all sectors with tag @@ -1678,8 +1674,8 @@ void FParser::SF_MoveFloor(void) // Don't start a second thinker on the same floor if (sec->floordata) continue; - new DMoveFloor(sec,sec->floorplane.PointToDist(sec->_f_centerspot(),destheight), - destheight < sec->CenterFloor() ? -1:1,crush,platspeed); + new DMoveFloor(sec, sec->floorplane.PointToDist(sec->centerspot, destheight), + destheight < sec->CenterFloor() ? -1 : 1, crush, platspeed); } } } @@ -1696,7 +1692,7 @@ public: DCeilingChanger(sector_t * sec) : DCeiling(sec) {} - bool Move(fixed_t speed, fixed_t dest, int crush, int direction) + bool Move(double speed, double dest, int crush, int direction) { bool res = DMover::crushed != MoveCeiling(speed, dest, crush, direction, false); Destroy(); @@ -1716,10 +1712,10 @@ public: // ceiling height of sector void FParser::SF_CeilingHeight(void) { - fixed_t dest; + double dest; int secnum; int tagnum; - int returnval = 1; + double returnval = 1; if (CheckArgs(1)) { @@ -1731,7 +1727,7 @@ void FParser::SF_CeilingHeight(void) int crush = (t_argc >= 3) ? intvalue(t_argv[2]) : false; i = -1; - dest = fixedvalue(t_argv[1]); + dest = floatvalue(t_argv[1]); // set all sectors with tag FSSectorTagIterator itr(tagnum); @@ -1741,8 +1737,8 @@ void FParser::SF_CeilingHeight(void) DCeilingChanger * c = new DCeilingChanger(§ors[i]); if (!c->Move( - abs(dest - sectors[i].CenterCeiling()), - sectors[i].ceilingplane.PointToDist (sectors[i]._f_centerspot(), dest), + fabs(dest - sectors[i].CenterCeiling()), + sectors[i].ceilingplane.PointToDist (sectors[i].centerspot, dest), crush? 10:-1, (dest > sectors[i].CenterCeiling()) ? 1 : -1)) { @@ -1758,12 +1754,11 @@ void FParser::SF_CeilingHeight(void) script_error("sector not found with tagnum %i\n", tagnum); return; } - returnval = sectors[secnum].CenterCeiling() >> FRACBITS; + returnval = sectors[secnum].CenterCeiling(); } // return ceiling height - t_return.type = svt_int; - t_return.value.i = returnval; + t_return.setDouble(returnval); } } @@ -1778,7 +1773,7 @@ class DMoveCeiling : public DCeiling { public: - DMoveCeiling(sector_t * sec,int tag,fixed_t destheight,fixed_t speed,int silent,int crush) + DMoveCeiling(sector_t * sec,int tag,double destheight,double speed,int silent,int crush) : DCeiling(sec) { m_Crush = crush; @@ -1786,11 +1781,11 @@ public: m_Silent = silent; m_Type = DCeiling::ceilLowerByValue; // doesn't really matter as long as it's no special value m_Tag=tag; - m_TopHeight=m_BottomHeight=sec->ceilingplane.PointToDist(sec->_f_centerspot(),destheight); + m_TopHeight=m_BottomHeight=sec->ceilingplane.PointToDist(sec->centerspot,destheight); m_Direction=destheight>sec->GetPlaneTexZ(sector_t::ceiling)? 1:-1; // Do not interpolate instant movement ceilings. - fixed_t movedist = abs(sec->ceilingplane.fixD() - m_BottomHeight); + double movedist = fabs(sec->ceilingplane.fD() - m_BottomHeight); if (m_Speed >= movedist) { StopInterpolation (true); @@ -1811,15 +1806,16 @@ void FParser::SF_MoveCeiling(void) { int secnum = -1; sector_t *sec; - int tagnum, platspeed = 1, destheight; + int tagnum; + double platspeed = 1, destheight; int crush; int silent; if (CheckArgs(2)) { tagnum = intvalue(t_argv[0]); - destheight = intvalue(t_argv[1]) * FRACUNIT; - platspeed = /*FLOORSPEED **/ (t_argc > 2 ? fixedvalue(t_argv[2]) : FRACUNIT); + destheight = intvalue(t_argv[1]); + platspeed = /*FLOORSPEED **/ (t_argc > 2 ? floatvalue(t_argv[2]) : 1); crush=t_argc>3 ? intvalue(t_argv[3]):-1; silent=t_argc>4 ? intvalue(t_argv[4]):1; diff --git a/src/g_heretic/a_hereticweaps.cpp b/src/g_heretic/a_hereticweaps.cpp index 5927778c50..5043210619 100644 --- a/src/g_heretic/a_hereticweaps.cpp +++ b/src/g_heretic/a_hereticweaps.cpp @@ -1065,9 +1065,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_SkullRodStorm) return 0; } if (self->bouncecount >= 0 && (unsigned)self->bouncecount < self->Sector->e->XFloor.ffloors.Size()) - pos.Z = self->Sector->e->XFloor.ffloors[self->bouncecount]->bottom.plane->ZatPointF(mo); + pos.Z = self->Sector->e->XFloor.ffloors[self->bouncecount]->bottom.plane->ZatPoint(mo); else - pos.Z = self->Sector->ceilingplane.ZatPointF(mo); + pos.Z = self->Sector->ceilingplane.ZatPoint(mo); int moceiling = P_Find3DFloor(NULL, pos, false, false, pos.Z); if (moceiling >= 0) mo->SetZ(pos.Z - mo->Height); mo->Translation = multiplayer ? TRANSLATION(TRANSLATION_RainPillar,self->special2) : 0; @@ -1120,7 +1120,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_HideInCeiling) F3DFloor * rover = self->Sector->e->XFloor.ffloors[i]; if (!(rover->flags & FF_SOLID) || !(rover->flags & FF_EXISTS)) continue; - if ((foo = rover->bottom.plane->ZatPointF(self)) >= self->Top()) + if ((foo = rover->bottom.plane->ZatPoint(self)) >= self->Top()) { self->SetZ(foo + 4, false); self->bouncecount = i; diff --git a/src/g_strife/a_strifestuff.cpp b/src/g_strife/a_strifestuff.cpp index 7e59369727..097965e345 100644 --- a/src/g_strife/a_strifestuff.cpp +++ b/src/g_strife/a_strifestuff.cpp @@ -306,7 +306,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_CheckTerrain) sector_t *sec = self->Sector; - if (self->Z() == sec->floorplane.ZatPointF(self) && sec->PortalBlocksMovement(sector_t::floor)) + if (self->Z() == sec->floorplane.ZatPoint(self) && sec->PortalBlocksMovement(sector_t::floor)) { if (sec->special == Damage_InstantDeath) { diff --git a/src/g_strife/a_thingstoblowup.cpp b/src/g_strife/a_thingstoblowup.cpp index ce31a6eab4..3644bb54c9 100644 --- a/src/g_strife/a_thingstoblowup.cpp +++ b/src/g_strife/a_thingstoblowup.cpp @@ -95,14 +95,14 @@ DEFINE_ACTION_FUNCTION(AActor, A_LightGoesOut) AActor *foo; sector_t *sec = self->Sector; vertex_t *spot; - fixed_t newheight; + double newheight; sec->SetLightLevel(0); - fixed_t oldtheight = sec->floorplane.Zat0(); + double oldtheight = sec->floorplane.fD(); newheight = sec->FindLowestFloorSurrounding(&spot); sec->floorplane.setD(sec->floorplane.PointToDist (spot, newheight)); - fixed_t newtheight = sec->floorplane.Zat0(); + double newtheight = sec->floorplane.fD(); sec->ChangePlaneTexZ(sector_t::floor, newtheight - oldtheight); sec->CheckPortalPlane(sector_t::floor); diff --git a/src/p_3dfloors.cpp b/src/p_3dfloors.cpp index 6203f65171..04d12739e7 100644 --- a/src/p_3dfloors.cpp +++ b/src/p_3dfloors.cpp @@ -329,13 +329,13 @@ void P_PlayerOnSpecial3DFloor(player_t* player) if(rover->flags & FF_SOLID) { // Player must be on top of the floor to be affected... - if(player->mo->Z() != rover->top.plane->ZatPointF(player->mo)) continue; + if(player->mo->Z() != rover->top.plane->ZatPoint(player->mo)) continue; } else { //Water and DEATH FOG!!! heh - if (player->mo->Z() > rover->top.plane->ZatPointF(player->mo) || - player->mo->Top() < rover->bottom.plane->ZatPointF(player->mo)) + if (player->mo->Z() > rover->top.plane->ZatPoint(player->mo) || + player->mo->Top() < rover->bottom.plane->ZatPoint(player->mo)) continue; } @@ -366,7 +366,7 @@ bool P_CheckFor3DFloorHit(AActor * mo) if(rover->flags & FF_SOLID && rover->model->SecActTarget) { - if(mo->Z() == rover->top.plane->ZatPointF(mo)) + if(mo->Z() == rover->top.plane->ZatPoint(mo)) { rover->model->SecActTarget->TriggerAction (mo, SECSPAC_HitFloor); return true; @@ -392,7 +392,7 @@ bool P_CheckFor3DCeilingHit(AActor * mo) if(rover->flags & FF_SOLID && rover->model->SecActTarget) { - if(mo->Top() == rover->bottom.plane->ZatPointF(mo)) + if(mo->Top() == rover->bottom.plane->ZatPoint(mo)) { rover->model->SecActTarget->TriggerAction (mo, SECSPAC_HitCeiling); return true; diff --git a/src/p_3dmidtex.cpp b/src/p_3dmidtex.cpp index fda17dc84c..4bb9ec4ba6 100644 --- a/src/p_3dmidtex.cpp +++ b/src/p_3dmidtex.cpp @@ -51,7 +51,7 @@ // //============================================================================ -bool P_Scroll3dMidtex(sector_t *sector, int crush, fixed_t move, bool ceiling) +bool P_Scroll3dMidtex(sector_t *sector, int crush, double move, bool ceiling) { extsector_t::midtex::plane &scrollplane = ceiling? sector->e->Midtex.Ceiling : sector->e->Midtex.Floor; diff --git a/src/p_3dmidtex.h b/src/p_3dmidtex.h index 641e057ee3..a24daff832 100644 --- a/src/p_3dmidtex.h +++ b/src/p_3dmidtex.h @@ -9,14 +9,14 @@ struct sector_t; struct line_t; class AActor; -bool P_Scroll3dMidtex(sector_t *sector, int crush, fixed_t move, bool ceiling); +bool P_Scroll3dMidtex(sector_t *sector, int crush, double move, bool ceiling); void P_Start3dMidtexInterpolations(TArray &list, sector_t *sec, bool ceiling); void P_Attach3dMidtexLinesToSector(sector_t *dest, int lineid, int tag, bool ceiling); bool P_GetMidTexturePosition(const line_t *line, int sideno, double *ptextop, double *ptexbot); bool P_Check3dMidSwitch(AActor *actor, line_t *line, int side); bool P_LineOpening_3dMidtex(AActor *thing, const line_t *linedef, struct FLineOpening &open, bool restrict=false); -bool P_MoveLinkedSectors(sector_t *sector, int crush, fixed_t move, bool ceiling); +bool P_MoveLinkedSectors(sector_t *sector, int crush, double move, bool ceiling); void P_StartLinkedSectorInterpolations(TArray &list, sector_t *sector, bool ceiling); bool P_AddSectorLinks(sector_t *control, int tag, INTBOOL ceiling, int movetype); void P_AddSectorLinksByID(sector_t *control, int id, INTBOOL ceiling); diff --git a/src/p_acs.cpp b/src/p_acs.cpp index 4eb26fce47..65165494b3 100644 --- a/src/p_acs.cpp +++ b/src/p_acs.cpp @@ -1390,7 +1390,7 @@ public: void Serialize (FArchive &arc); private: sector_t *Sector; - fixed_t WatchD, LastD; + double WatchD, LastD; int Special, Arg0, Arg1, Arg2, Arg3, Arg4; TObjPtr Activator; line_t *Line; @@ -1426,9 +1426,9 @@ DPlaneWatcher::DPlaneWatcher (AActor *it, line_t *line, int lineSide, bool ceili { plane = Sector->floorplane; } - LastD = plane.fixD(); - plane.ChangeHeight (height << FRACBITS); - WatchD = plane.fixD(); + LastD = plane.fD(); + plane.ChangeHeight (height); + WatchD = plane.fD(); } else { @@ -1454,15 +1454,15 @@ void DPlaneWatcher::Tick () return; } - fixed_t newd; + double newd; if (bCeiling) { - newd = Sector->ceilingplane.fixD(); + newd = Sector->ceilingplane.fD(); } else { - newd = Sector->floorplane.fixD(); + newd = Sector->floorplane.fD(); } if ((LastD < WatchD && newd >= WatchD) || diff --git a/src/p_ceiling.cpp b/src/p_ceiling.cpp index 96f773baee..096333bbbd 100644 --- a/src/p_ceiling.cpp +++ b/src/p_ceiling.cpp @@ -228,7 +228,7 @@ DCeiling::DCeiling (sector_t *sec) { } -DCeiling::DCeiling (sector_t *sec, fixed_t speed1, fixed_t speed2, int silent) +DCeiling::DCeiling (sector_t *sec, double speed1, double speed2, int silent) : DMovingCeiling (sec) { m_Crush = -1; @@ -245,10 +245,10 @@ DCeiling::DCeiling (sector_t *sec, fixed_t speed1, fixed_t speed2, int silent) //============================================================================ DCeiling *DCeiling::Create(sector_t *sec, DCeiling::ECeiling type, line_t *line, int tag, - fixed_t speed, fixed_t speed2, fixed_t height, + double speed, double speed2, double height, int crush, int silent, int change, ECrushMode hexencrush) { - fixed_t targheight = 0; // Silence, GCC + double targheight = 0; // Silence, GCC // if ceiling already moving, don't start a second function on it if (sec->PlaneMoving(sector_t::ceiling)) @@ -264,7 +264,7 @@ DCeiling *DCeiling::Create(sector_t *sec, DCeiling::ECeiling type, line_t *line, { case ceilCrushAndRaise: case ceilCrushRaiseAndStay: - ceiling->m_TopHeight = sec->ceilingplane.fixD(); + ceiling->m_TopHeight = sec->ceilingplane.fD(); case ceilLowerAndCrush: targheight = sec->FindHighestFloorPoint (&spot); targheight += height; @@ -292,7 +292,7 @@ DCeiling *DCeiling::Create(sector_t *sec, DCeiling::ECeiling type, line_t *line, case ceilMoveToValue: { - int diff = height - sec->ceilingplane.ZatPoint (spot); + double diff = height - sec->ceilingplane.ZatPoint (spot); targheight = height; if (diff < 0) @@ -400,15 +400,15 @@ DCeiling *DCeiling::Create(sector_t *sec, DCeiling::ECeiling type, line_t *line, // Do not interpolate instant movement ceilings. // Note for ZDoomGL: Check to make sure that you update the sector // after the ceiling moves, because it hasn't actually moved yet. - fixed_t movedist; + double movedist; if (ceiling->m_Direction < 0) { - movedist = sec->ceilingplane.fixD() - ceiling->m_BottomHeight; + movedist = sec->ceilingplane.fD() - ceiling->m_BottomHeight; } else { - movedist = ceiling->m_TopHeight - sec->ceilingplane.fixD(); + movedist = ceiling->m_TopHeight - sec->ceilingplane.fD(); } if (ceiling->m_Speed >= movedist) { @@ -483,7 +483,7 @@ DCeiling *DCeiling::Create(sector_t *sec, DCeiling::ECeiling type, line_t *line, //============================================================================ bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line, - int tag, fixed_t speed, fixed_t speed2, fixed_t height, + int tag, double speed, double speed2, double height, int crush, int silent, int change, DCeiling::ECrushMode hexencrush) { int secnum; diff --git a/src/p_doors.cpp b/src/p_doors.cpp index 6497254bc3..24af771942 100644 --- a/src/p_doors.cpp +++ b/src/p_doors.cpp @@ -82,14 +82,14 @@ void DDoor::Tick () { EResult res; - if (m_Sector->floorplane.fixD() != m_OldFloorDist) + // Adjust bottom height - but only if there isn't an active lift attached to the floor. + if (m_Sector->floorplane.fD() != m_OldFloorDist) { if (!m_Sector->floordata || !m_Sector->floordata->IsKindOf(RUNTIME_CLASS(DPlat)) || !(barrier_cast(m_Sector->floordata))->IsLift()) { - m_OldFloorDist = m_Sector->floorplane.fixD(); - m_BotDist = m_Sector->ceilingplane.PointToDist (m_BotSpot, - m_Sector->floorplane.ZatPoint (m_BotSpot)); + m_OldFloorDist = m_Sector->floorplane.fD(); + m_BotDist = m_Sector->ceilingplane.PointToDist (m_BotSpot, m_Sector->floorplane.ZatPoint (m_BotSpot)); } } @@ -140,10 +140,10 @@ void DDoor::Tick () res = MoveCeiling (m_Speed, m_BotDist, -1, m_Direction, false); // killough 10/98: implement gradual lighting effects - if (m_LightTag != 0 && m_TopDist != -m_Sector->floorplane.fixD()) + if (m_LightTag != 0 && m_TopDist != -m_Sector->floorplane.fD()) { EV_LightTurnOnPartway (m_LightTag, - FIXED2DBL(FixedDiv (m_Sector->ceilingplane.fixD() + m_Sector->floorplane.fixD(), m_TopDist + m_Sector->floorplane.fixD()))); + (m_Sector->ceilingplane.fD() + m_Sector->floorplane.fD()) / (m_TopDist + m_Sector->floorplane.fD())); } if (res == pastdest) @@ -186,10 +186,10 @@ void DDoor::Tick () res = MoveCeiling (m_Speed, m_TopDist, -1, m_Direction, false); // killough 10/98: implement gradual lighting effects - if (m_LightTag != 0 && m_TopDist != -m_Sector->floorplane.fixD()) + if (m_LightTag != 0 && m_TopDist != -m_Sector->floorplane.fD()) { EV_LightTurnOnPartway (m_LightTag, - FIXED2DBL(FixedDiv (m_Sector->ceilingplane.fixD() + m_Sector->floorplane.fixD(), m_TopDist + m_Sector->floorplane.fixD()))); + (m_Sector->ceilingplane.fD() + m_Sector->floorplane.fD()) / (m_TopDist + m_Sector->floorplane.fD())); } if (res == pastdest) @@ -350,12 +350,12 @@ DDoor::DDoor (sector_t *sector) // //============================================================================ -DDoor::DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTag, int topcountdown) +DDoor::DDoor (sector_t *sec, EVlDoor type, double speed, int delay, int lightTag, int topcountdown) : DMovingCeiling (sec), m_Type (type), m_Speed (speed), m_TopWait (delay), m_TopCountdown(topcountdown), m_LightTag (lightTag) { vertex_t *spot; - fixed_t height; + double height; if (i_compatflags & COMPATF_NODOORLIGHT) { @@ -367,7 +367,7 @@ DDoor::DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTa case doorClose: m_Direction = -1; height = sec->FindLowestCeilingSurrounding (&spot); - m_TopDist = sec->ceilingplane.PointToDist (spot, height - 4*FRACUNIT); + m_TopDist = sec->ceilingplane.PointToDist (spot, height - 4); DoorSound (false); break; @@ -375,13 +375,13 @@ DDoor::DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTa case doorRaise: m_Direction = 1; height = sec->FindLowestCeilingSurrounding (&spot); - m_TopDist = sec->ceilingplane.PointToDist (spot, height - 4*FRACUNIT); - if (m_TopDist != sec->ceilingplane.fixD()) + m_TopDist = sec->ceilingplane.PointToDist (spot, height - 4); + if (m_TopDist != sec->ceilingplane.fD()) DoorSound (true); break; case doorCloseWaitOpen: - m_TopDist = sec->ceilingplane.fixD(); + m_TopDist = sec->ceilingplane.fD(); m_Direction = -1; DoorSound (false); break; @@ -389,7 +389,7 @@ DDoor::DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTa case doorWaitRaise: m_Direction = 2; height = sec->FindLowestCeilingSurrounding (&spot); - m_TopDist = sec->ceilingplane.PointToDist (spot, height - 4*FRACUNIT); + m_TopDist = sec->ceilingplane.PointToDist (spot, height - 4); break; case doorWaitClose: @@ -397,8 +397,8 @@ DDoor::DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTa m_Type = DDoor::doorRaise; height = sec->FindHighestFloorPoint (&m_BotSpot); m_BotDist = sec->ceilingplane.PointToDist (m_BotSpot, height); - m_OldFloorDist = sec->floorplane.fixD(); - m_TopDist = sec->ceilingplane.fixD(); + m_OldFloorDist = sec->floorplane.fD(); + m_TopDist = sec->ceilingplane.fD(); break; } @@ -414,7 +414,7 @@ DDoor::DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTa height = sec->FindLowestCeilingPoint(&m_BotSpot); m_BotDist = sec->ceilingplane.PointToDist (m_BotSpot, height); } - m_OldFloorDist = sec->floorplane.fixD(); + m_OldFloorDist = sec->floorplane.fD(); } //============================================================================ @@ -425,7 +425,7 @@ DDoor::DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTa //============================================================================ bool EV_DoDoor (DDoor::EVlDoor type, line_t *line, AActor *thing, - int tag, int speed, int delay, int lock, int lightTag, bool boomgen, int topcountdown) + int tag, double speed, int delay, int lock, int lightTag, bool boomgen, int topcountdown) { bool rtn = false; int secnum; @@ -559,13 +559,13 @@ bool DAnimatedDoor::StartClosing () return false; } - fixed_t topdist = m_Sector->ceilingplane.fixD(); - if (MoveCeiling (2048*FRACUNIT, m_BotDist, 0, -1, false) == crushed) + double topdist = m_Sector->ceilingplane.fD(); + if (MoveCeiling (2048., m_BotDist, 0, -1, false) == crushed) { return false; } - MoveCeiling (2048*FRACUNIT, topdist, 1); + MoveCeiling (2048., topdist, 1); m_Line1->flags |= ML_BLOCKING; m_Line2->flags |= ML_BLOCKING; @@ -650,7 +650,7 @@ void DAnimatedDoor::Tick () if (--m_Frame < 0) { // IF DOOR IS DONE CLOSING... - MoveCeiling (2048*FRACUNIT, m_BotDist, -1); + MoveCeiling (2048., m_BotDist, -1); m_Sector->ceilingdata = NULL; Destroy (); // Unset blocking flags on lines that didn't start with them. Since the @@ -690,7 +690,7 @@ void DAnimatedDoor::Tick () DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay, FDoorAnimation *anim) : DMovingCeiling (sec) { - fixed_t topdist; + double topdist; FTextureID picnum; // The DMovingCeiling constructor automatically sets up an interpolation for us. @@ -722,7 +722,7 @@ DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay, FTexture *tex = TexMan[picnum]; topdist = tex ? tex->GetScaledHeight() : 64; - topdist = m_Sector->ceilingplane.fixD() - topdist * m_Sector->ceilingplane.fixC(); + topdist = m_Sector->ceilingplane.fD() - topdist * m_Sector->ceilingplane.fC(); m_Status = Opening; m_Speed = speed; @@ -733,8 +733,8 @@ DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay, m_SetBlocking2 = !!(m_Line2->flags & ML_BLOCKING); m_Line1->flags |= ML_BLOCKING; m_Line2->flags |= ML_BLOCKING; - m_BotDist = m_Sector->ceilingplane.fixD(); - MoveCeiling (2048*FRACUNIT, topdist, 1); + m_BotDist = m_Sector->ceilingplane.fD(); + MoveCeiling (2048., topdist, 1); if (m_DoorAnim->OpenSound != NAME_None) { SN_StartSequence (m_Sector, CHAN_INTERIOR, m_DoorAnim->OpenSound, 1); diff --git a/src/p_floor.cpp b/src/p_floor.cpp index 3b26eaf0cd..54b66a8a83 100644 --- a/src/p_floor.cpp +++ b/src/p_floor.cpp @@ -280,14 +280,14 @@ DFloor::DFloor (sector_t *sec) //========================================================================== bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, - fixed_t speed, fixed_t height, int crush, int change, bool hexencrush, bool hereticlower) + double speed, double height, int crush, int change, bool hexencrush, bool hereticlower) { int secnum; bool rtn; sector_t* sec; DFloor* floor; - fixed_t ceilingheight; - fixed_t newheight; + double ceilingheight; + double newheight; vertex_t *spot, *spot2; rtn = false; @@ -312,7 +312,7 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, floor->m_Hexencrush = hexencrush; floor->m_Speed = speed; floor->m_ResetCount = 0; // [RH] - floor->m_OrgDist = sec->floorplane.fixD(); // [RH] + floor->m_OrgDist = sec->floorplane.fD(); // [RH] switch (floortype) { @@ -322,7 +322,7 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, floor->m_FloorDestDist = sec->floorplane.PointToDist (spot, newheight); // [RH] DOOM's turboLower type did this. I've just extended it // to be applicable to all LowerToHighest types. - if (hereticlower || floor->m_FloorDestDist != sec->floorplane.fixD()) + if (hereticlower || floor->m_FloorDestDist != sec->floorplane.fD()) floor->m_FloorDestDist = sec->floorplane.PointToDist (spot, newheight+height); break; @@ -344,7 +344,7 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, case DFloor::floorLowerByValue: floor->m_Direction = -1; newheight = sec->CenterFloor() - height; - floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->_f_centerspot(), newheight); + floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->centerspot, newheight); break; case DFloor::floorRaiseInstant: @@ -352,13 +352,13 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, case DFloor::floorRaiseByValue: floor->m_Direction = 1; newheight = sec->CenterFloor() + height; - floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->_f_centerspot(), newheight); + floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->centerspot, newheight); break; case DFloor::floorMoveToValue: sec->FindHighestFloorPoint (&spot); floor->m_FloorDestDist = sec->floorplane.PointToDist (spot, height); - floor->m_Direction = (floor->m_FloorDestDist > sec->floorplane.fixD()) ? -1 : 1; + floor->m_Direction = (floor->m_FloorDestDist > sec->floorplane.fD()) ? -1 : 1; break; case DFloor::floorRaiseAndCrushDoom: @@ -366,12 +366,12 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, floor->m_Direction = 1; newheight = sec->FindLowestCeilingSurrounding (&spot); if (floortype == DFloor::floorRaiseAndCrushDoom) - newheight -= 8 * FRACUNIT; + newheight -= 8; ceilingheight = sec->FindLowestCeilingPoint (&spot2); floor->m_FloorDestDist = sec->floorplane.PointToDist (spot, newheight); if (sec->floorplane.ZatPointDist (spot2, floor->m_FloorDestDist) > ceilingheight) floor->m_FloorDestDist = sec->floorplane.PointToDist (spot2, - floortype == DFloor::floorRaiseAndCrushDoom ? ceilingheight - 8*FRACUNIT : ceilingheight); + floortype == DFloor::floorRaiseAndCrushDoom ? ceilingheight - 8 : ceilingheight); break; case DFloor::floorRaiseToHighest: @@ -394,7 +394,7 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, case DFloor::floorRaiseAndCrush: floor->m_Direction = 1; - newheight = sec->FindLowestCeilingPoint (&spot) - 8*FRACUNIT; + newheight = sec->FindLowestCeilingPoint (&spot) - 8; floor->m_FloorDestDist = sec->floorplane.PointToDist (spot, newheight); break; @@ -413,7 +413,7 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, case DFloor::floorLowerByTexture: floor->m_Direction = -1; newheight = sec->CenterFloor() - sec->FindShortestTextureAround (); - floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->_f_centerspot(), newheight); + floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->centerspot, newheight); break; case DFloor::floorLowerToCeiling: @@ -430,13 +430,13 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, // enough, BOOM preserved the code here even though it // also had this function.) newheight = sec->CenterFloor() + sec->FindShortestTextureAround (); - floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->_f_centerspot(), newheight); + floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->centerspot, newheight); break; case DFloor::floorRaiseAndChange: floor->m_Direction = 1; - newheight = sec->CenterFloor() + height; - floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->_f_centerspot(), newheight); + newheight = sec->_f_CenterFloor() + height; + floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->centerspot, newheight); if (line != NULL) { FTextureID oldpic = sec->GetTexture(sector_t::floor); @@ -475,9 +475,9 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, // Do not interpolate instant movement floors. bool silent = false; - if ((floor->m_Direction>0 && floor->m_FloorDestDist>sec->floorplane.fixD()) || // moving up but going down - (floor->m_Direction<0 && floor->m_FloorDestDistfloorplane.fixD()) || // moving down but going up - (floor->m_Speed >= abs(sec->floorplane.fixD() - floor->m_FloorDestDist))) // moving in one step + if ((floor->m_Direction>0 && floor->m_FloorDestDist>sec->floorplane.fD()) || // moving up but going down + (floor->m_Direction<0 && floor->m_FloorDestDistfloorplane.fD()) || // moving down but going up + (floor->m_Speed >= fabs(sec->floorplane.fD() - floor->m_FloorDestDist))) // moving in one step { floor->StopInterpolation(true); @@ -560,13 +560,13 @@ bool EV_FloorCrushStop (int tag) //========================================================================== bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, - fixed_t stairsize, fixed_t speed, int delay, int reset, int igntxt, + double stairsize, double speed, int delay, int reset, int igntxt, int usespecials) { int secnum = -1; int osecnum; //jff 3/4/98 save old loop index - int height; - fixed_t stairstep; + double height; + double stairstep; int i; int newsecnum = -1; FTextureID texture; @@ -583,7 +583,7 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, if (speed == 0) return false; - persteptime = FixedDiv (stairsize, speed) >> FRACBITS; + persteptime = int(stairsize / speed); // check if a manual trigger, if so do just the sector on the backside FSectorTagIterator itr(tag, line); @@ -609,7 +609,7 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, stairstep = stairsize * floor->m_Direction; floor->m_Type = DFloor::buildStair; //jff 3/31/98 do not leave uninited floor->m_ResetCount = reset; // [RH] Tics until reset (0 if never) - floor->m_OrgDist = sec->floorplane.fixD(); // [RH] Height to reset to + floor->m_OrgDist = sec->floorplane.fD(); // [RH] Height to reset to // [RH] Set up delay values floor->m_Delay = delay; floor->m_PauseTime = 0; @@ -620,7 +620,7 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, floor->m_Speed = speed; height = sec->CenterFloor() + stairstep; - floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->_f_centerspot(), height); + floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->centerspot, height); texture = sec->GetTexture(sector_t::floor); osecnum = secnum; //jff 3/4/98 preserve loop index @@ -710,7 +710,7 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, floor = new DFloor (sec); floor->StartFloorSound (); floor->m_Direction = (type == DFloor::buildUp) ? 1 : -1; - floor->m_FloorDestDist = sec->floorplane.PointToDist (0, 0, height); + floor->m_FloorDestDist = sec->floorplane.PointToDist (DVector2(0, 0), height); // [RH] Set up delay values floor->m_Delay = delay; floor->m_PauseTime = 0; @@ -719,8 +719,8 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, if (usespecials & DFloor::stairSync) { // [RH] - fixed_t rise = height - sec->CenterFloor(); - floor->m_Speed = Scale (speed, rise, stairstep); + double rise = height - sec->CenterFloor(); + floor->m_Speed = speed * rise / stairstep; } else { @@ -728,10 +728,10 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, } floor->m_Type = DFloor::buildStair; //jff 3/31/98 do not leave uninited //jff 2/27/98 fix uninitialized crush field - floor->m_Crush = (!(usespecials & DFloor::stairUseSpecials) && speed == 4*FRACUNIT) ? 10 : -1; //jff 2/27/98 fix uninitialized crush field + floor->m_Crush = (!(usespecials & DFloor::stairUseSpecials) && speed == 4) ? 10 : -1; //jff 2/27/98 fix uninitialized crush field floor->m_Hexencrush = false; floor->m_ResetCount = reset; // [RH] Tics until reset (0 if never) - floor->m_OrgDist = sec->floorplane.fixD(); // [RH] Height to reset to + floor->m_OrgDist = sec->floorplane.fD(); // [RH] Height to reset to } } while (ok); // [RH] make sure the first sector doesn't point to a previous one, otherwise @@ -747,7 +747,7 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, // //========================================================================== -bool EV_DoDonut (int tag, line_t *line, fixed_t pillarspeed, fixed_t slimespeed) +bool EV_DoDonut (int tag, line_t *line, double pillarspeed, double slimespeed) { sector_t* s1; sector_t* s2; @@ -757,7 +757,7 @@ bool EV_DoDonut (int tag, line_t *line, fixed_t pillarspeed, fixed_t slimespeed) int i; DFloor* floor; vertex_t* spot; - fixed_t height; + double height; rtn = false; @@ -900,10 +900,10 @@ void DElevator::Tick () { EResult res; - fixed_t oldfloor, oldceiling; + double oldfloor, oldceiling; - oldfloor = m_Sector->floorplane.fixD(); - oldceiling = m_Sector->ceilingplane.fixD(); + oldfloor = m_Sector->floorplane.fD(); + oldceiling = m_Sector->ceilingplane.fD(); if (m_Direction < 0) // moving down { @@ -966,14 +966,14 @@ void DElevator::StartFloorSound () //========================================================================== bool EV_DoElevator (line_t *line, DElevator::EElevator elevtype, - fixed_t speed, fixed_t height, int tag) + double speed, double height, int tag) { int secnum; bool rtn; sector_t* sec; DElevator* elevator; - fixed_t floorheight, ceilingheight; - fixed_t newheight; + double floorheight, ceilingheight; + double newheight; vertex_t* spot; if (!line && (elevtype == DElevator::elevateCurrent)) @@ -1010,7 +1010,7 @@ bool EV_DoElevator (line_t *line, DElevator::EElevator elevtype, elevator->m_Direction = -1; newheight = sec->FindNextLowestFloor (&spot); elevator->m_FloorDestDist = sec->floorplane.PointToDist (spot, newheight); - newheight += sec->ceilingplane.ZatPoint (spot) - sec->floorplane.ZatPoint (spot); + newheight += sec->ceilingplane.ZatPoint(spot) - sec->floorplane.ZatPoint(spot); elevator->m_CeilingDestDist = sec->ceilingplane.PointToDist (spot, newheight); break; @@ -1019,7 +1019,7 @@ bool EV_DoElevator (line_t *line, DElevator::EElevator elevtype, elevator->m_Direction = 1; newheight = sec->FindNextHighestFloor (&spot); elevator->m_FloorDestDist = sec->floorplane.PointToDist (spot, newheight); - newheight += sec->ceilingplane.ZatPoint (spot) - sec->floorplane.ZatPoint (spot); + newheight += sec->ceilingplane.ZatPoint(spot) - sec->floorplane.ZatPoint(spot); elevator->m_CeilingDestDist = sec->ceilingplane.PointToDist (spot, newheight); break; @@ -1027,25 +1027,25 @@ bool EV_DoElevator (line_t *line, DElevator::EElevator elevtype, case DElevator::elevateCurrent: newheight = line->frontsector->floorplane.ZatPoint (line->v1); elevator->m_FloorDestDist = sec->floorplane.PointToDist (line->v1, newheight); - newheight += sec->ceilingplane.ZatPoint (line->v1) - sec->floorplane.ZatPoint (line->v1); + newheight += sec->ceilingplane.ZatPoint(line->v1) - sec->floorplane.ZatPoint(line->v1); elevator->m_CeilingDestDist = sec->ceilingplane.PointToDist (line->v1, newheight); elevator->m_Direction = - elevator->m_FloorDestDist > sec->floorplane.fixD() ? -1 : 1; + elevator->m_FloorDestDist > sec->floorplane.fD() ? -1 : 1; break; // [RH] elevate up by a specific amount case DElevator::elevateRaise: elevator->m_Direction = 1; - elevator->m_FloorDestDist = sec->floorplane.PointToDist (sec->_f_centerspot(), floorheight + height); - elevator->m_CeilingDestDist = sec->ceilingplane.PointToDist (sec->_f_centerspot(), ceilingheight + height); + elevator->m_FloorDestDist = sec->floorplane.PointToDist (sec->centerspot, floorheight + height); + elevator->m_CeilingDestDist = sec->ceilingplane.PointToDist (sec->centerspot, ceilingheight + height); break; // [RH] elevate down by a specific amount case DElevator::elevateLower: elevator->m_Direction = -1; - elevator->m_FloorDestDist = sec->floorplane.PointToDist (sec->_f_centerspot(), floorheight - height); - elevator->m_CeilingDestDist = sec->ceilingplane.PointToDist (sec->_f_centerspot(), ceilingheight - height); + elevator->m_FloorDestDist = sec->floorplane.PointToDist (sec->centerspot, floorheight - height); + elevator->m_CeilingDestDist = sec->ceilingplane.PointToDist (sec->centerspot, ceilingheight - height); break; } } @@ -1178,7 +1178,7 @@ void DWaggleBase::DoWaggle (bool ceiling) { secplane_t *plane; int pos; - fixed_t dist; + double dist; if (ceiling) { @@ -1204,7 +1204,7 @@ void DWaggleBase::DoWaggle (bool ceiling) case WGLSTATE_REDUCE: if ((m_Scale -= m_ScaleDelta) <= 0) { // Remove - dist = FixedDiv (m_OriginalDist - plane->fixD(), plane->fixC()); + dist = (m_OriginalDist - plane->fD()) / plane->fC(); m_Sector->ChangePlaneTexZ(pos, -plane->HeightDiff (m_OriginalDist)); plane->setD(m_OriginalDist); P_ChangeSector (m_Sector, true, dist, ceiling, false); @@ -1233,11 +1233,8 @@ void DWaggleBase::DoWaggle (bool ceiling) } m_Accumulator += m_AccDelta; - - fixed_t mag = finesine[(m_Accumulator>>9)&8191]*8; - - dist = plane->fixD(); - plane->setD(m_OriginalDist + plane->PointToDist (0, 0, FixedMul (mag, m_Scale))); + dist = plane->fD(); + plane->setD(m_OriginalDist + plane->PointToDist (DVector2(0, 0), BobSin(m_Accumulator) *m_Scale)); m_Sector->ChangePlaneTexZ(pos, plane->HeightDiff (dist)); dist = plane->HeightDiff (dist); @@ -1322,19 +1319,18 @@ bool EV_StartWaggle (int tag, line_t *line, int height, int speed, int offset, if (ceiling) { waggle = new DCeilingWaggle (sector); - waggle->m_OriginalDist = sector->ceilingplane.fixD(); + waggle->m_OriginalDist = sector->ceilingplane.fD(); } else { waggle = new DFloorWaggle (sector); - waggle->m_OriginalDist = sector->floorplane.fixD(); + waggle->m_OriginalDist = sector->floorplane.fD(); } - waggle->m_Accumulator = offset*FRACUNIT; - waggle->m_AccDelta = speed << (FRACBITS-6); + waggle->m_Accumulator = offset; + waggle->m_AccDelta = speed / 64.; waggle->m_Scale = 0; - waggle->m_TargetScale = height << (FRACBITS-6); - waggle->m_ScaleDelta = waggle->m_TargetScale - /(TICRATE+((3*TICRATE)*height)/255); + waggle->m_TargetScale = height / 64.; + waggle->m_ScaleDelta = waggle->m_TargetScale / (TICRATE + ((3 * TICRATE)*height) / 255); waggle->m_Ticker = timer ? timer*TICRATE : -1; waggle->m_State = WGLSTATE_EXPAND; } diff --git a/src/p_linkedsectors.cpp b/src/p_linkedsectors.cpp index d502372916..944a41aa92 100644 --- a/src/p_linkedsectors.cpp +++ b/src/p_linkedsectors.cpp @@ -93,7 +93,7 @@ bool sector_t::IsLinked(sector_t *other, bool ceiling) const // //============================================================================ -static bool MoveCeiling(sector_t *sector, int crush, fixed_t move) +static bool MoveCeiling(sector_t *sector, int crush, double move) { sector->ceilingplane.ChangeHeight (move); sector->ChangePlaneTexZ(sector_t::ceiling, move); @@ -107,7 +107,7 @@ static bool MoveCeiling(sector_t *sector, int crush, fixed_t move) return true; } -static bool MoveFloor(sector_t *sector, int crush, fixed_t move) +static bool MoveFloor(sector_t *sector, int crush, double move) { sector->floorplane.ChangeHeight (move); sector->ChangePlaneTexZ(sector_t::floor, move); @@ -131,7 +131,7 @@ static bool MoveFloor(sector_t *sector, int crush, fixed_t move) // //============================================================================ -bool P_MoveLinkedSectors(sector_t *sector, int crush, fixed_t move, bool ceiling) +bool P_MoveLinkedSectors(sector_t *sector, int crush, double move, bool ceiling) { extsector_t::linked::plane &scrollplane = ceiling? sector->e->Linked.Ceiling : sector->e->Linked.Floor; bool ok = true; diff --git a/src/p_lnspec.cpp b/src/p_lnspec.cpp index c608c102ff..802541f497 100644 --- a/src/p_lnspec.cpp +++ b/src/p_lnspec.cpp @@ -510,7 +510,7 @@ FUNC(LS_Floor_TransferNumeric) FUNC(LS_Floor_Donut) // Floor_Donut (pillartag, pillarspeed, slimespeed) { - return EV_DoDonut (arg0, ln, _f_SPEED(arg1), _f_SPEED(arg2)); + return EV_DoDonut (arg0, ln, SPEED(arg1), SPEED(arg2)); } FUNC(LS_Generic_Floor) @@ -554,56 +554,56 @@ FUNC(LS_Stairs_BuildDown) // Stair_BuildDown (tag, speed, height, delay, reset) { return EV_BuildStairs (arg0, DFloor::buildDown, ln, - arg2 * FRACUNIT, _f_SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairUseSpecials); + arg2, SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairUseSpecials); } FUNC(LS_Stairs_BuildUp) // Stairs_BuildUp (tag, speed, height, delay, reset) { return EV_BuildStairs (arg0, DFloor::buildUp, ln, - arg2 * FRACUNIT, _f_SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairUseSpecials); + arg2, SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairUseSpecials); } FUNC(LS_Stairs_BuildDownSync) // Stairs_BuildDownSync (tag, speed, height, reset) { return EV_BuildStairs (arg0, DFloor::buildDown, ln, - arg2 * FRACUNIT, _f_SPEED(arg1), 0, arg3, 0, DFloor::stairUseSpecials|DFloor::stairSync); + arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairUseSpecials|DFloor::stairSync); } FUNC(LS_Stairs_BuildUpSync) // Stairs_BuildUpSync (tag, speed, height, reset) { return EV_BuildStairs (arg0, DFloor::buildUp, ln, - arg2 * FRACUNIT, _f_SPEED(arg1), 0, arg3, 0, DFloor::stairUseSpecials|DFloor::stairSync); + arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairUseSpecials|DFloor::stairSync); } FUNC(LS_Stairs_BuildUpDoom) // Stairs_BuildUpDoom (tag, speed, height, delay, reset) { return EV_BuildStairs (arg0, DFloor::buildUp, ln, - arg2 * FRACUNIT, _f_SPEED(arg1), TICS(arg3), arg4, 0, 0); + arg2, SPEED(arg1), TICS(arg3), arg4, 0, 0); } FUNC(LS_Stairs_BuildDownDoom) // Stair_BuildDownDoom (tag, speed, height, delay, reset) { return EV_BuildStairs (arg0, DFloor::buildDown, ln, - arg2 * FRACUNIT, _f_SPEED(arg1), TICS(arg3), arg4, 0, 0); + arg2, SPEED(arg1), TICS(arg3), arg4, 0, 0); } FUNC(LS_Stairs_BuildDownDoomSync) // Stairs_BuildDownDoomSync (tag, speed, height, reset) { return EV_BuildStairs (arg0, DFloor::buildDown, ln, - arg2 * FRACUNIT, _f_SPEED(arg1), 0, arg3, 0, DFloor::stairSync); + arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairSync); } FUNC(LS_Stairs_BuildUpDoomSync) // Stairs_BuildUpDoomSync (tag, speed, height, reset) { return EV_BuildStairs (arg0, DFloor::buildUp, ln, - arg2 * FRACUNIT, _f_SPEED(arg1), 0, arg3, 0, DFloor::stairSync); + arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairSync); } @@ -612,7 +612,7 @@ FUNC(LS_Generic_Stairs) { DFloor::EStair type = (arg3 & 1) ? DFloor::buildUp : DFloor::buildDown; bool res = EV_BuildStairs (arg0, type, ln, - arg2 * FRACUNIT, _f_SPEED(arg1), 0, arg4, arg3 & 2, 0); + arg2, SPEED(arg1), 0, arg4, arg3 & 2, 0); if (res && ln && (ln->flags & ML_REPEAT_SPECIAL) && ln->special == Generic_Stairs) // Toggle direction of next activation of repeatable stairs @@ -624,61 +624,61 @@ FUNC(LS_Generic_Stairs) FUNC(LS_Pillar_Build) // Pillar_Build (tag, speed, height) { - return EV_DoPillar (DPillar::pillarBuild, ln, arg0, _f_SPEED(arg1), arg2*FRACUNIT, 0, -1, false); + return EV_DoPillar (DPillar::pillarBuild, ln, arg0, SPEED(arg1), arg2, 0, -1, false); } FUNC(LS_Pillar_BuildAndCrush) // Pillar_BuildAndCrush (tag, speed, height, crush, crushtype) { - return EV_DoPillar (DPillar::pillarBuild, ln, arg0, _f_SPEED(arg1), arg2*FRACUNIT, 0, arg3, CRUSHTYPE(arg4)); + return EV_DoPillar (DPillar::pillarBuild, ln, arg0, SPEED(arg1), arg2, 0, arg3, CRUSHTYPE(arg4)); } FUNC(LS_Pillar_Open) // Pillar_Open (tag, speed, f_height, c_height) { - return EV_DoPillar (DPillar::pillarOpen, ln, arg0, _f_SPEED(arg1), arg2*FRACUNIT, arg3*FRACUNIT, -1, false); + return EV_DoPillar (DPillar::pillarOpen, ln, arg0, SPEED(arg1), arg2, arg3, -1, false); } FUNC(LS_Ceiling_LowerByValue) // Ceiling_LowerByValue (tag, speed, height, change, crush) { - return EV_DoCeiling (DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2*FRACUNIT, CRUSH(arg4), 0, CHANGE(arg3)); + return EV_DoCeiling (DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2, CRUSH(arg4), 0, CHANGE(arg3)); } FUNC(LS_Ceiling_RaiseByValue) // Ceiling_RaiseByValue (tag, speed, height, change) { - return EV_DoCeiling (DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2*FRACUNIT, CRUSH(arg4), 0, CHANGE(arg3)); + return EV_DoCeiling (DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2, CRUSH(arg4), 0, CHANGE(arg3)); } FUNC(LS_Ceiling_LowerByValueTimes8) // Ceiling_LowerByValueTimes8 (tag, speed, height, change, crush) { - return EV_DoCeiling (DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2*FRACUNIT*8, -1, 0, CHANGE(arg3)); + return EV_DoCeiling (DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2*8, -1, 0, CHANGE(arg3)); } FUNC(LS_Ceiling_RaiseByValueTimes8) // Ceiling_RaiseByValueTimes8 (tag, speed, height, change) { - return EV_DoCeiling (DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2*FRACUNIT*8, -1, 0, CHANGE(arg3)); + return EV_DoCeiling (DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2*8, -1, 0, CHANGE(arg3)); } FUNC(LS_Ceiling_CrushAndRaise) // Ceiling_CrushAndRaise (tag, speed, crush, crushtype) { - return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8*FRACUNIT, arg2, 0, 0, CRUSHTYPE(arg3, false)); + return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8, arg2, 0, 0, CRUSHTYPE(arg3, false)); } FUNC(LS_Ceiling_LowerAndCrush) // Ceiling_LowerAndCrush (tag, speed, crush, crushtype) { - return EV_DoCeiling (DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), 8*FRACUNIT, arg2, 0, 0, CRUSHTYPE(arg3, arg1 == 8)); + return EV_DoCeiling (DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), 8, arg2, 0, 0, CRUSHTYPE(arg3, arg1 == 8)); } FUNC(LS_Ceiling_LowerAndCrushDist) // Ceiling_LowerAndCrush (tag, speed, crush, dist, crushtype) { - return EV_DoCeiling (DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), arg3*FRACUNIT, arg2, 0, 0, CRUSHTYPE(arg4, arg1 == 8)); + return EV_DoCeiling (DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), arg3, arg2, 0, 0, CRUSHTYPE(arg4, arg1 == 8)); } FUNC(LS_Ceiling_CrushStop) @@ -690,21 +690,21 @@ FUNC(LS_Ceiling_CrushStop) FUNC(LS_Ceiling_CrushRaiseAndStay) // Ceiling_CrushRaiseAndStay (tag, speed, crush, crushtype) { - return EV_DoCeiling (DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8*FRACUNIT, arg2, 0, 0, CRUSHTYPE(arg3, false)); + return EV_DoCeiling (DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8, arg2, 0, 0, CRUSHTYPE(arg3, false)); } FUNC(LS_Ceiling_MoveToValueTimes8) // Ceiling_MoveToValueTimes8 (tag, speed, height, negative, change) { return EV_DoCeiling (DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0, - arg2*FRACUNIT*8*((arg3) ? -1 : 1), -1, 0, CHANGE(arg4)); + arg2*8*((arg3) ? -1 : 1), -1, 0, CHANGE(arg4)); } FUNC(LS_Ceiling_MoveToValue) // Ceiling_MoveToValue (tag, speed, height, negative, change) { return EV_DoCeiling (DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0, - arg2*FRACUNIT*((arg3) ? -1 : 1), -1, 0, CHANGE(arg4)); + arg2*((arg3) ? -1 : 1), -1, 0, CHANGE(arg4)); } FUNC(LS_Ceiling_LowerToHighestFloor) @@ -716,13 +716,13 @@ FUNC(LS_Ceiling_LowerToHighestFloor) FUNC(LS_Ceiling_LowerInstant) // Ceiling_LowerInstant (tag, unused, height, change, crush) { - return EV_DoCeiling (DCeiling::ceilLowerInstant, ln, arg0, 0, 0, arg2*FRACUNIT*8, CRUSH(arg4), 0, CHANGE(arg3)); + return EV_DoCeiling (DCeiling::ceilLowerInstant, ln, arg0, 0, 0, arg2*8, CRUSH(arg4), 0, CHANGE(arg3)); } FUNC(LS_Ceiling_RaiseInstant) // Ceiling_RaiseInstant (tag, unused, height, change) { - return EV_DoCeiling (DCeiling::ceilRaiseInstant, ln, arg0, 0, 0, arg2*FRACUNIT*8, -1, 0, CHANGE(arg3)); + return EV_DoCeiling (DCeiling::ceilRaiseInstant, ln, arg0, 0, 0, arg2*8, -1, 0, CHANGE(arg3)); } FUNC(LS_Ceiling_CrushRaiseAndStayA) @@ -746,7 +746,7 @@ FUNC(LS_Ceiling_CrushAndRaiseA) FUNC(LS_Ceiling_CrushAndRaiseDist) // Ceiling_CrushAndRaiseDist (tag, dist, speed, damage, crushtype) { - return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1*FRACUNIT, arg3, 0, 0, CRUSHTYPE(arg4, arg2 == 8)); + return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1, arg3, 0, 0, CRUSHTYPE(arg4, arg2 == 8)); } FUNC(LS_Ceiling_CrushAndRaiseSilentA) @@ -758,7 +758,7 @@ FUNC(LS_Ceiling_CrushAndRaiseSilentA) FUNC(LS_Ceiling_CrushAndRaiseSilentDist) // Ceiling_CrushAndRaiseSilentDist (tag, dist, upspeed, damage, crushtype) { - return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1*FRACUNIT, arg3, 1, 0, CRUSHTYPE(arg4, arg2 == 8)); + return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1, arg3, 1, 0, CRUSHTYPE(arg4, arg2 == 8)); } FUNC(LS_Ceiling_RaiseToNearest) @@ -854,7 +854,7 @@ FUNC(LS_Generic_Ceiling) } } - return EV_DoCeiling (type, ln, arg0, SPEED(arg1), SPEED(arg1), arg2*FRACUNIT, + return EV_DoCeiling (type, ln, arg0, SPEED(arg1), SPEED(arg1), arg2, (arg4 & 16) ? 20 : -1, 0, arg4 & 7); } @@ -876,13 +876,13 @@ FUNC(LS_Generic_Crusher2) FUNC(LS_Plat_PerpetualRaise) // Plat_PerpetualRaise (tag, speed, delay) { - return EV_DoPlat (arg0, ln, DPlat::platPerpetualRaise, 0, _f_SPEED(arg1), TICS(arg2), 8, 0); + return EV_DoPlat (arg0, ln, DPlat::platPerpetualRaise, 0, SPEED(arg1), TICS(arg2), 8, 0); } FUNC(LS_Plat_PerpetualRaiseLip) // Plat_PerpetualRaiseLip (tag, speed, delay, lip) { - return EV_DoPlat (arg0, ln, DPlat::platPerpetualRaise, 0, _f_SPEED(arg1), TICS(arg2), arg3, 0); + return EV_DoPlat (arg0, ln, DPlat::platPerpetualRaise, 0, SPEED(arg1), TICS(arg2), arg3, 0); } FUNC(LS_Plat_Stop) @@ -895,7 +895,7 @@ FUNC(LS_Plat_Stop) FUNC(LS_Plat_DownWaitUpStay) // Plat_DownWaitUpStay (tag, speed, delay) { - return EV_DoPlat (arg0, ln, DPlat::platDownWaitUpStay, 0, _f_SPEED(arg1), TICS(arg2), 8, 0); + return EV_DoPlat (arg0, ln, DPlat::platDownWaitUpStay, 0, SPEED(arg1), TICS(arg2), 8, 0); } FUNC(LS_Plat_DownWaitUpStayLip) @@ -903,31 +903,31 @@ FUNC(LS_Plat_DownWaitUpStayLip) { return EV_DoPlat (arg0, ln, arg4 ? DPlat::platDownWaitUpStayStone : DPlat::platDownWaitUpStay, - 0, _f_SPEED(arg1), TICS(arg2), arg3, 0); + 0, SPEED(arg1), TICS(arg2), arg3, 0); } FUNC(LS_Plat_DownByValue) // Plat_DownByValue (tag, speed, delay, height) { - return EV_DoPlat (arg0, ln, DPlat::platDownByValue, FRACUNIT*arg3*8, _f_SPEED(arg1), TICS(arg2), 0, 0); + return EV_DoPlat (arg0, ln, DPlat::platDownByValue, arg3*8, SPEED(arg1), TICS(arg2), 0, 0); } FUNC(LS_Plat_UpByValue) // Plat_UpByValue (tag, speed, delay, height) { - return EV_DoPlat (arg0, ln, DPlat::platUpByValue, FRACUNIT*arg3*8, _f_SPEED(arg1), TICS(arg2), 0, 0); + return EV_DoPlat (arg0, ln, DPlat::platUpByValue, arg3*8, SPEED(arg1), TICS(arg2), 0, 0); } FUNC(LS_Plat_UpWaitDownStay) // Plat_UpWaitDownStay (tag, speed, delay) { - return EV_DoPlat (arg0, ln, DPlat::platUpWaitDownStay, 0, _f_SPEED(arg1), TICS(arg2), 0, 0); + return EV_DoPlat (arg0, ln, DPlat::platUpWaitDownStay, 0, SPEED(arg1), TICS(arg2), 0, 0); } FUNC(LS_Plat_UpNearestWaitDownStay) // Plat_UpNearestWaitDownStay (tag, speed, delay) { - return EV_DoPlat (arg0, ln, DPlat::platUpNearestWaitDownStay, 0, _f_SPEED(arg1), TICS(arg2), 0, 0); + return EV_DoPlat (arg0, ln, DPlat::platUpNearestWaitDownStay, 0, SPEED(arg1), TICS(arg2), 0, 0); } FUNC(LS_Plat_RaiseAndStayTx0) @@ -949,13 +949,13 @@ FUNC(LS_Plat_RaiseAndStayTx0) } - return EV_DoPlat (arg0, ln, type, 0, _f_SPEED(arg1), 0, 0, 1); + return EV_DoPlat (arg0, ln, type, 0, SPEED(arg1), 0, 0, 1); } FUNC(LS_Plat_UpByValueStayTx) // Plat_UpByValueStayTx (tag, speed, height) { - return EV_DoPlat (arg0, ln, DPlat::platUpByValueStay, FRACUNIT*arg2*8, _f_SPEED(arg1), 0, 0, 2); + return EV_DoPlat (arg0, ln, DPlat::platUpByValueStay, arg2*8, SPEED(arg1), 0, 0, 2); } FUNC(LS_Plat_ToggleCeiling) @@ -988,7 +988,7 @@ FUNC(LS_Generic_Lift) break; } - return EV_DoPlat (arg0, ln, type, arg4*8*FRACUNIT, _f_SPEED(arg1), OCTICS(arg2), 0, 0); + return EV_DoPlat (arg0, ln, type, arg4*8, SPEED(arg1), OCTICS(arg2), 0, 0); } FUNC(LS_Exit_Normal) @@ -1943,13 +1943,13 @@ FUNC(LS_FS_Execute) FUNC(LS_FloorAndCeiling_LowerByValue) // FloorAndCeiling_LowerByValue (tag, speed, height) { - return EV_DoElevator (ln, DElevator::elevateLower, _f_SPEED(arg1), arg2*FRACUNIT, arg0); + return EV_DoElevator (ln, DElevator::elevateLower, SPEED(arg1), arg2, arg0); } FUNC(LS_FloorAndCeiling_RaiseByValue) // FloorAndCeiling_RaiseByValue (tag, speed, height) { - return EV_DoElevator (ln, DElevator::elevateRaise, _f_SPEED(arg1), arg2*FRACUNIT, arg0); + return EV_DoElevator (ln, DElevator::elevateRaise, SPEED(arg1), arg2, arg0); } FUNC(LS_FloorAndCeiling_LowerRaise) @@ -1962,7 +1962,7 @@ FUNC(LS_FloorAndCeiling_LowerRaise) // more or less unintuitive value for the fourth arg to trigger Boom's broken behavior if (arg3 != 1998 || !res) // (1998 for the year in which Boom was released... :P) { - res |= EV_DoFloor (DFloor::floorLowerToLowest, ln, arg0, _f_SPEED(arg1), 0, -1, 0, false); + res |= EV_DoFloor (DFloor::floorLowerToLowest, ln, arg0, SPEED(arg1), 0, -1, 0, false); } return res; } @@ -1970,19 +1970,19 @@ FUNC(LS_FloorAndCeiling_LowerRaise) FUNC(LS_Elevator_MoveToFloor) // Elevator_MoveToFloor (tag, speed) { - return EV_DoElevator (ln, DElevator::elevateCurrent, _f_SPEED(arg1), 0, arg0); + return EV_DoElevator (ln, DElevator::elevateCurrent, SPEED(arg1), 0, arg0); } FUNC(LS_Elevator_RaiseToNearest) // Elevator_RaiseToNearest (tag, speed) { - return EV_DoElevator (ln, DElevator::elevateUp, _f_SPEED(arg1), 0, arg0); + return EV_DoElevator (ln, DElevator::elevateUp, SPEED(arg1), 0, arg0); } FUNC(LS_Elevator_LowerToNearest) // Elevator_LowerToNearest (tag, speed) { - return EV_DoElevator (ln, DElevator::elevateDown, _f_SPEED(arg1), 0, arg0); + return EV_DoElevator (ln, DElevator::elevateDown, SPEED(arg1), 0, arg0); } FUNC(LS_Light_ForceLightning) @@ -2760,7 +2760,7 @@ enum PROP_FLIGHT, PROP_UNUSED1, PROP_UNUSED2, - PROP__f_SPEED, + PROP_SPEED, PROP_BUDDHA, }; @@ -2775,7 +2775,7 @@ FUNC(LS_SetPlayerProperty) return false; // Add or remove a power - if (arg2 >= PROP_INVULNERABILITY && arg2 <= PROP__f_SPEED) + if (arg2 >= PROP_INVULNERABILITY && arg2 <= PROP_SPEED) { static PClass * const *powers[11] = { diff --git a/src/p_local.h b/src/p_local.h index 95df53116a..fec4a636db 100644 --- a/src/p_local.h +++ b/src/p_local.h @@ -45,7 +45,7 @@ struct FTranslatedLineTarget; #include -#define STEEPSLOPE 46342 // [RH] Minimum floorplane.fixC() value for walking +#define STEEPSLOPE (46342/65536.) // [RH] Minimum floorplane.c value for walking #define BONUSADD 6 diff --git a/src/p_map.cpp b/src/p_map.cpp index 4d00663042..bd19a228f7 100644 --- a/src/p_map.cpp +++ b/src/p_map.cpp @@ -526,8 +526,8 @@ double P_GetFriction(const AActor *mo, double *frictionfactor) if (!(rover->flags & FF_EXISTS)) continue; if (!(rover->flags & FF_SWIMMABLE)) continue; - if (mo->Z() > rover->top.plane->ZatPointF(mo) || - mo->Z() < rover->bottom.plane->ZatPointF(mo)) + if (mo->Z() > rover->top.plane->ZatPoint(mo) || + mo->Z() < rover->bottom.plane->ZatPoint(mo)) continue; newfriction = rover->model->GetFriction(rover->top.isceiling, &newmf); @@ -808,7 +808,7 @@ bool PIT_CheckLine(FMultiBlockLinesIterator &mit, FMultiBlockLinesIterator::Chec if (!(tm.thing->flags & MF_DROPOFF) && !(tm.thing->flags & (MF_NOGRAVITY | MF_NOCLIP))) { - if ((open.frontfloorplane.fixC() < STEEPSLOPE) != (open.backfloorplane.fixC() < STEEPSLOPE)) + if ((open.frontfloorplane.fC() < STEEPSLOPE) != (open.backfloorplane.fC() < STEEPSLOPE)) { // on the boundary of a steep slope return false; @@ -2913,7 +2913,7 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, DVector2 &move) { if (!(rover->flags & FF_SOLID) || !(rover->flags & FF_EXISTS)) continue; - double thisplanez = rover->top.plane->ZatPointF(actor); + double thisplanez = rover->top.plane->ZatPoint(actor); if (thisplanez > planezhere && thisplanez <= actor->Z() + actor->MaxStepHeight) { @@ -2958,12 +2958,12 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, DVector2 &move) const msecnode_t *node; bool dopush = true; - if (plane->fixC() > STEEPSLOPE * 2 / 3) + if (plane->fC() > STEEPSLOPE * 2 / 3) { for (node = actor->touching_sectorlist; node; node = node->m_tnext) { sector_t *sec = node->m_sector; - if (sec->floorplane.fixC() >= STEEPSLOPE) + if (sec->floorplane.fC() >= STEEPSLOPE) { DVector3 pos = actor->PosRelative(sec) +move; @@ -3741,7 +3741,7 @@ struct aim_t { if (lastceilingplane) { - double ff_top = lastceilingplane->ZatPointF(th); + double ff_top = lastceilingplane->ZatPoint(th); DAngle pitch = -VecToAngle(dist, ff_top - shootz); // upper slope intersects with this 3d-floor if (pitch > toppitch) @@ -3751,7 +3751,7 @@ struct aim_t } if (lastfloorplane) { - double ff_bottom = lastfloorplane->ZatPointF(th); + double ff_bottom = lastfloorplane->ZatPoint(th); DAngle pitch = -VecToAngle(dist, ff_bottom - shootz); // lower slope intersects with this 3d-floor if (pitch < bottompitch) diff --git a/src/p_mobj.cpp b/src/p_mobj.cpp index 4876114493..a96194426e 100644 --- a/src/p_mobj.cpp +++ b/src/p_mobj.cpp @@ -2175,7 +2175,7 @@ explode: { // Don't stop sliding if halfway off a step with some velocity if (fabs(mo->Vel.X) > 0.25 || fabs(mo->Vel.Y) > 0.25) { - if (mo->floorz > mo->Sector->floorplane.ZatPointF(mo)) + if (mo->floorz > mo->Sector->floorplane.ZatPoint(mo)) { if (mo->dropoffz != mo->floorz) // 3DMidtex or other special cases that must be excluded { @@ -2186,7 +2186,7 @@ explode: // if the floor comes from one in the current sector stop sliding the corpse! F3DFloor * rover=mo->Sector->e->XFloor.ffloors[i]; if (!(rover->flags&FF_EXISTS)) continue; - if (rover->flags&FF_SOLID && rover->top.plane->ZatPointF(mo) == mo->floorz) break; + if (rover->flags&FF_SOLID && rover->top.plane->ZatPoint(mo) == mo->floorz) break; } if (i==mo->Sector->e->XFloor.ffloors.Size()) return Oldfloorz; @@ -2427,8 +2427,8 @@ void P_ZMovement (AActor *mo, double oldfloorz) if (!(rover->flags & FF_EXISTS)) continue; if (!(rover->flags & FF_SWIMMABLE)) continue; - if (mo->Z() >= rover->top.plane->ZatPointF(mo) || - mo->Center() < rover->bottom.plane->ZatPointF(mo)) + if (mo->Z() >= rover->top.plane->ZatPoint(mo) || + mo->Center() < rover->bottom.plane->ZatPoint(mo)) continue; friction = rover->model->GetFriction(rover->top.isceiling); @@ -2447,7 +2447,7 @@ void P_ZMovement (AActor *mo, double oldfloorz) { // Hit the floor if ((!mo->player || !(mo->player->cheats & CF_PREDICTING)) && mo->Sector->SecActTarget != NULL && - mo->Sector->floorplane.ZatPointF(mo) == mo->floorz) + mo->Sector->floorplane.ZatPoint(mo) == mo->floorz) { // [RH] Let the sector do something to the actor mo->Sector->SecActTarget->TriggerAction (mo, SECSPAC_HitFloor); } @@ -2547,7 +2547,7 @@ void P_ZMovement (AActor *mo, double oldfloorz) { // hit the ceiling if ((!mo->player || !(mo->player->cheats & CF_PREDICTING)) && mo->Sector->SecActTarget != NULL && - mo->Sector->ceilingplane.ZatPointF(mo) == mo->ceilingz) + mo->Sector->ceilingplane.ZatPoint(mo) == mo->ceilingz) { // [RH] Let the sector do something to the actor mo->Sector->SecActTarget->TriggerAction (mo, SECSPAC_HitCeiling); } @@ -2602,7 +2602,7 @@ void P_CheckFakeFloorTriggers (AActor *mo, double oldz, bool oldz_has_viewheight if (sec->heightsec != NULL && sec->SecActTarget != NULL) { sector_t *hs = sec->heightsec; - double waterz = hs->floorplane.ZatPointF(mo); + double waterz = hs->floorplane.ZatPoint(mo); double newz; double viewheight; @@ -2637,7 +2637,7 @@ void P_CheckFakeFloorTriggers (AActor *mo, double oldz, bool oldz_has_viewheight if (!(hs->MoreFlags & SECF_FAKEFLOORONLY)) { - waterz = hs->ceilingplane.ZatPointF(mo); + waterz = hs->ceilingplane.ZatPoint(mo); if (oldz <= waterz && newz > waterz) { // View went above fake ceiling sec->SecActTarget->TriggerAction (mo, SECSPAC_EyesAboveC); @@ -3644,18 +3644,18 @@ void AActor::Tick () // Check 3D floors as well floorplane = P_FindFloorPlane(floorsector, PosAtZ(floorz)); - if (floorplane.fixC() < STEEPSLOPE && + if (floorplane.fC() < STEEPSLOPE && floorplane.ZatPoint (PosRelative(floorsector)) <= floorz) { const msecnode_t *node; bool dopush = true; - if (floorplane.fixC() > STEEPSLOPE*2/3) + if (floorplane.fC() > STEEPSLOPE*2/3) { for (node = touching_sectorlist; node; node = node->m_tnext) { const sector_t *sec = node->m_sector; - if (sec->floorplane.fixC() >= STEEPSLOPE) + if (sec->floorplane.fC() >= STEEPSLOPE) { if (floorplane.ZatPoint(PosRelative(node->m_sector)) >= Z() - MaxStepHeight) { @@ -3897,15 +3897,15 @@ void AActor::CheckSectorTransition(sector_t *oldsec) if (Sector->SecActTarget != NULL) { int act = SECSPAC_Enter; - if (Z() <= Sector->floorplane.ZatPointF(this)) + if (Z() <= Sector->floorplane.ZatPoint(this)) { act |= SECSPAC_HitFloor; } - if (Top() >= Sector->ceilingplane.ZatPointF(this)) + if (Top() >= Sector->ceilingplane.ZatPoint(this)) { act |= SECSPAC_HitCeiling; } - if (Sector->heightsec != NULL && Z() == Sector->heightsec->floorplane.ZatPointF(this)) + if (Sector->heightsec != NULL && Z() == Sector->heightsec->floorplane.ZatPoint(this)) { act |= SECSPAC_HitFakeFloor; } @@ -3952,7 +3952,7 @@ bool AActor::UpdateWaterLevel (bool dosplash) const sector_t *hsec = Sector->GetHeightSec(); if (hsec != NULL) { - fh = hsec->floorplane.ZatPointF (this); + fh = hsec->floorplane.ZatPoint (this); //if (hsec->MoreFlags & SECF_UNDERWATERMASK) // also check Boom-style non-swimmable sectors { if (Z() < fh) @@ -3968,7 +3968,7 @@ bool AActor::UpdateWaterLevel (bool dosplash) } } } - else if (!(hsec->MoreFlags & SECF_FAKEFLOORONLY) && (Top() > hsec->ceilingplane.ZatPointF (this))) + else if (!(hsec->MoreFlags & SECF_FAKEFLOORONLY) && (Top() > hsec->ceilingplane.ZatPoint (this))) { waterlevel = 3; } @@ -3992,8 +3992,8 @@ bool AActor::UpdateWaterLevel (bool dosplash) if (!(rover->flags & FF_EXISTS)) continue; if(!(rover->flags & FF_SWIMMABLE) || rover->flags & FF_SOLID) continue; - double ff_bottom=rover->bottom.plane->ZatPointF(this); - double ff_top=rover->top.plane->ZatPointF(this); + double ff_bottom=rover->bottom.plane->ZatPoint(this); + double ff_top=rover->top.plane->ZatPoint(this); if(ff_top <= Z() || ff_bottom > (Center())) continue; @@ -4174,7 +4174,7 @@ AActor *AActor::StaticSpawn (PClassActor *type, const DVector3 &pos, replace_t a } else { - actor->SpawnPoint.Z = (actor->Z() - actor->Sector->floorplane.ZatPointF(actor)); + actor->SpawnPoint.Z = (actor->Z() - actor->Sector->floorplane.ZatPoint(actor)); } if (actor->FloatBobPhase == (BYTE)-1) actor->FloatBobPhase = rng(); // Don't make everything bob in sync (unless deliberately told to do) @@ -4420,7 +4420,7 @@ void AActor::AdjustFloorClip () const msecnode_t *m; // possibly standing on a 3D-floor - if (Sector->e->XFloor.ffloors.Size() && Z() > Sector->floorplane.ZatPointF(this)) Floorclip = 0; + if (Sector->e->XFloor.ffloors.Size() && Z() > Sector->floorplane.ZatPoint(this)) Floorclip = 0; // [RH] clip based on shallowest floor player is standing on // If the sector has a deep water effect, then let that effect @@ -5522,7 +5522,7 @@ foundone: if (smallsplash && splash->SmallSplash) { mo = Spawn (splash->SmallSplash, pos, ALLOW_REPLACE); - if (mo) mo->Floorclip += FIXED2DBL(splash->SmallSplashClip); + if (mo) mo->Floorclip += splash->SmallSplashClip; } else { diff --git a/src/p_pillar.cpp b/src/p_pillar.cpp index e585702c6c..da939abb0b 100644 --- a/src/p_pillar.cpp +++ b/src/p_pillar.cpp @@ -89,10 +89,10 @@ void DPillar::Serialize (FArchive &arc) void DPillar::Tick () { int r, s; - fixed_t oldfloor, oldceiling; + double oldfloor, oldceiling; - oldfloor = m_Sector->floorplane.fixD(); - oldceiling = m_Sector->ceilingplane.fixD(); + oldfloor = m_Sector->floorplane.fD(); + oldceiling = m_Sector->ceilingplane.fD(); if (m_Type == pillarBuild) { @@ -123,11 +123,11 @@ void DPillar::Tick () } } -DPillar::DPillar (sector_t *sector, EPillar type, fixed_t speed, - fixed_t floordist, fixed_t ceilingdist, int crush, bool hexencrush) +DPillar::DPillar (sector_t *sector, EPillar type, double speed, + double floordist, double ceilingdist, int crush, bool hexencrush) : DMover (sector) { - fixed_t newheight; + double newheight; vertex_t *spot; sector->floordata = sector->ceilingdata = this; @@ -144,15 +144,15 @@ DPillar::DPillar (sector_t *sector, EPillar type, fixed_t speed, if (floordist == 0) { newheight = (sector->CenterFloor () + sector->CenterCeiling ()) / 2; - m_FloorTarget = sector->floorplane.PointToDist (sector->_f_centerspot(), newheight); - m_CeilingTarget = sector->ceilingplane.PointToDist (sector->_f_centerspot(), newheight); + m_FloorTarget = sector->floorplane.PointToDist (sector->centerspot, newheight); + m_CeilingTarget = sector->ceilingplane.PointToDist (sector->centerspot, newheight); floordist = newheight - sector->CenterFloor (); } else { newheight = sector->CenterFloor () + floordist; - m_FloorTarget = sector->floorplane.PointToDist (sector->_f_centerspot(), newheight); - m_CeilingTarget = sector->ceilingplane.PointToDist (sector->_f_centerspot(), newheight); + m_FloorTarget = sector->floorplane.PointToDist (sector->centerspot, newheight); + m_CeilingTarget = sector->ceilingplane.PointToDist (sector->centerspot, newheight); } ceilingdist = sector->CenterCeiling () - newheight; } @@ -169,7 +169,7 @@ DPillar::DPillar (sector_t *sector, EPillar type, fixed_t speed, else { newheight = sector->CenterFloor() - floordist; - m_FloorTarget = sector->floorplane.PointToDist (sector->_f_centerspot(), newheight); + m_FloorTarget = sector->floorplane.PointToDist (sector->centerspot, newheight); } if (ceilingdist == 0) { @@ -180,7 +180,7 @@ DPillar::DPillar (sector_t *sector, EPillar type, fixed_t speed, else { newheight = sector->CenterCeiling() + ceilingdist; - m_CeilingTarget = sector->ceilingplane.PointToDist (sector->_f_centerspot(), newheight); + m_CeilingTarget = sector->ceilingplane.PointToDist (sector->centerspot, newheight); } } @@ -190,12 +190,12 @@ DPillar::DPillar (sector_t *sector, EPillar type, fixed_t speed, if (floordist > ceilingdist) { m_FloorSpeed = speed; - m_CeilingSpeed = Scale (speed, ceilingdist, floordist); + m_CeilingSpeed = speed * ceilingdist / floordist; } else { m_CeilingSpeed = speed; - m_FloorSpeed = Scale (speed, floordist, ceilingdist); + m_FloorSpeed = speed * floordist / ceilingdist; } if (!(m_Sector->Flags & SECF_SILENTMOVE)) @@ -216,7 +216,7 @@ DPillar::DPillar (sector_t *sector, EPillar type, fixed_t speed, } bool EV_DoPillar (DPillar::EPillar type, line_t *line, int tag, - fixed_t speed, fixed_t height, fixed_t height2, int crush, bool hexencrush) + double speed, double height, double height2, int crush, bool hexencrush) { int secnum; sector_t *sec; @@ -231,7 +231,7 @@ bool EV_DoPillar (DPillar::EPillar type, line_t *line, int tag, if (sec->PlaneMoving(sector_t::floor) || sec->PlaneMoving(sector_t::ceiling)) continue; - fixed_t flor, ceil; + double flor, ceil; flor = sec->CenterFloor (); ceil = sec->CenterCeiling (); diff --git a/src/p_plats.cpp b/src/p_plats.cpp index 22d6b54edc..7d2754d2c7 100644 --- a/src/p_plats.cpp +++ b/src/p_plats.cpp @@ -198,7 +198,7 @@ void DPlat::Tick () case waiting: if (m_Count > 0 && !--m_Count) { - if (m_Sector->floorplane.fixD() == m_Low) + if (m_Sector->floorplane.fD() == m_Low) m_Status = up; else m_Status = down; @@ -225,15 +225,15 @@ DPlat::DPlat (sector_t *sector) // [RH] Changed amount to height and added delay, // lip, change, tag, and speed parameters. // -bool EV_DoPlat (int tag, line_t *line, DPlat::EPlatType type, int height, - int speed, int delay, int lip, int change) +bool EV_DoPlat (int tag, line_t *line, DPlat::EPlatType type, double height, + double speed, int delay, int lip, int change) { DPlat *plat; int secnum; sector_t *sec; bool rtn = false; bool manual = false; - fixed_t newheight = 0; + double newheight = 0; vertex_t *spot; if (tag != 0) @@ -277,7 +277,7 @@ bool EV_DoPlat (int tag, line_t *line, DPlat::EPlatType type, int height, //jff 1/26/98 Avoid raise plat bouncing a head off a ceiling and then //going down forever -- default lower to plat height when triggered - plat->m_Low = sec->floorplane.fixD(); + plat->m_Low = sec->floorplane.fD(); if (change) { @@ -292,7 +292,7 @@ bool EV_DoPlat (int tag, line_t *line, DPlat::EPlatType type, int height, case DPlat::platRaiseAndStayLockout: newheight = sec->FindNextHighestFloor (&spot); plat->m_High = sec->floorplane.PointToDist (spot, newheight); - plat->m_Low = sec->floorplane.fixD(); + plat->m_Low = sec->floorplane.fD(); plat->m_Status = DPlat::up; plat->PlayPlatSound ("Floor"); sec->ClearSpecial(); @@ -300,30 +300,30 @@ bool EV_DoPlat (int tag, line_t *line, DPlat::EPlatType type, int height, case DPlat::platUpByValue: case DPlat::platUpByValueStay: - newheight = sec->floorplane.ZatPoint (0, 0) + height; - plat->m_High = sec->floorplane.PointToDist (0, 0, newheight); - plat->m_Low = sec->floorplane.fixD(); + newheight = sec->floorplane.ZatPoint (sec->centerspot) + height; + plat->m_High = sec->floorplane.PointToDist (sec->centerspot, newheight); + plat->m_Low = sec->floorplane.fD(); plat->m_Status = DPlat::up; plat->PlayPlatSound ("Floor"); break; case DPlat::platDownByValue: - newheight = sec->floorplane.ZatPoint (0, 0) - height; - plat->m_Low = sec->floorplane.PointToDist (0, 0, newheight); - plat->m_High = sec->floorplane.fixD(); + newheight = sec->floorplane.ZatPoint (sec->centerspot) - height; + plat->m_Low = sec->floorplane.PointToDist (sec->centerspot, newheight); + plat->m_High = sec->floorplane.fD(); plat->m_Status = DPlat::down; plat->PlayPlatSound ("Floor"); break; case DPlat::platDownWaitUpStay: case DPlat::platDownWaitUpStayStone: - newheight = sec->FindLowestFloorSurrounding (&spot) + lip*FRACUNIT; + newheight = sec->FindLowestFloorSurrounding (&spot) + lip; plat->m_Low = sec->floorplane.PointToDist (spot, newheight); - if (plat->m_Low < sec->floorplane.fixD()) - plat->m_Low = sec->floorplane.fixD(); + if (plat->m_Low < sec->floorplane.fD()) + plat->m_Low = sec->floorplane.fD(); - plat->m_High = sec->floorplane.fixD(); + plat->m_High = sec->floorplane.fD(); plat->m_Status = DPlat::down; plat->PlayPlatSound (type == DPlat::platDownWaitUpStay ? "Platform" : "Floor"); break; @@ -338,27 +338,27 @@ bool EV_DoPlat (int tag, line_t *line, DPlat::EPlatType type, int height, newheight = sec->FindHighestFloorSurrounding (&spot); } plat->m_High = sec->floorplane.PointToDist (spot, newheight); - plat->m_Low = sec->floorplane.fixD(); + plat->m_Low = sec->floorplane.fD(); - if (plat->m_High > sec->floorplane.fixD()) - plat->m_High = sec->floorplane.fixD(); + if (plat->m_High > sec->floorplane.fD()) + plat->m_High = sec->floorplane.fD(); plat->m_Status = DPlat::up; plat->PlayPlatSound ("Platform"); break; case DPlat::platPerpetualRaise: - newheight = sec->FindLowestFloorSurrounding (&spot) + lip*FRACUNIT; + newheight = sec->FindLowestFloorSurrounding (&spot) + lip; plat->m_Low = sec->floorplane.PointToDist (spot, newheight); - if (plat->m_Low < sec->floorplane.fixD()) - plat->m_Low = sec->floorplane.fixD(); + if (plat->m_Low < sec->floorplane.fD()) + plat->m_Low = sec->floorplane.fD(); newheight = sec->FindHighestFloorSurrounding (&spot); plat->m_High = sec->floorplane.PointToDist (spot, newheight); - if (plat->m_High > sec->floorplane.fixD()) - plat->m_High = sec->floorplane.fixD(); + if (plat->m_High > sec->floorplane.fD()) + plat->m_High = sec->floorplane.fD(); plat->m_Status = pr_doplat() & 1 ? DPlat::up : DPlat::down; @@ -371,26 +371,26 @@ bool EV_DoPlat (int tag, line_t *line, DPlat::EPlatType type, int height, // set up toggling between ceiling, floor inclusive newheight = sec->FindLowestCeilingPoint (&spot); plat->m_Low = sec->floorplane.PointToDist (spot, newheight); - plat->m_High = sec->floorplane.fixD(); + plat->m_High = sec->floorplane.fD(); plat->m_Status = DPlat::down; SN_StartSequence (sec, CHAN_FLOOR, "Silence", 0); break; case DPlat::platDownToNearestFloor: - newheight = sec->FindNextLowestFloor (&spot) + lip*FRACUNIT; + newheight = sec->FindNextLowestFloor (&spot) + lip; plat->m_Low = sec->floorplane.PointToDist (spot, newheight); plat->m_Status = DPlat::down; - plat->m_High = sec->floorplane.fixD(); + plat->m_High = sec->floorplane.fD(); plat->PlayPlatSound ("Platform"); break; case DPlat::platDownToLowestCeiling: newheight = sec->FindLowestCeilingSurrounding (&spot); plat->m_Low = sec->floorplane.PointToDist (spot, newheight); - plat->m_High = sec->floorplane.fixD(); + plat->m_High = sec->floorplane.fD(); - if (plat->m_Low < sec->floorplane.fixD()) - plat->m_Low = sec->floorplane.fixD(); + if (plat->m_Low < sec->floorplane.fD()) + plat->m_Low = sec->floorplane.fD(); plat->m_Status = DPlat::down; plat->PlayPlatSound ("Platform"); diff --git a/src/p_scroll.cpp b/src/p_scroll.cpp index aad56aa67e..01fbba3c5f 100644 --- a/src/p_scroll.cpp +++ b/src/p_scroll.cpp @@ -183,8 +183,8 @@ void DScroller::Tick () if (m_Control != -1) { // compute scroll amounts based on a sector's height changes - double height = sectors[m_Control].CenterFloorF () + - sectors[m_Control].CenterCeilingF (); + double height = sectors[m_Control].CenterFloor () + + sectors[m_Control].CenterCeiling (); double delta = height - m_LastHeight; m_LastHeight = height; dx *= delta; @@ -277,7 +277,7 @@ DScroller::DScroller (EScroll type, double dx, double dy, m_vdx = m_vdy = 0; if ((m_Control = control) != -1) m_LastHeight = - sectors[control].CenterFloorF () + sectors[control].CenterCeilingF (); + sectors[control].CenterFloor () + sectors[control].CenterCeiling (); m_Affectee = affectee; m_Interpolations[0] = m_Interpolations[1] = m_Interpolations[2] = NULL; diff --git a/src/p_sectors.cpp b/src/p_sectors.cpp index 4533fb138f..b92c23de48 100644 --- a/src/p_sectors.cpp +++ b/src/p_sectors.cpp @@ -63,19 +63,19 @@ sector_t *sector_t::NextSpecialSector (int type, sector_t *nogood) const // P_FindLowestFloorSurrounding() // FIND LOWEST FLOOR HEIGHT IN SURROUNDING SECTORS // -fixed_t sector_t::FindLowestFloorSurrounding (vertex_t **v) const +double sector_t::FindLowestFloorSurrounding (vertex_t **v) const { int i; sector_t *other; line_t *check; - fixed_t floor; - fixed_t ofloor; + double floor; + double ofloor; vertex_t *spot; - if (linecount == 0) return GetPlaneTexZ(sector_t::floor); + if (linecount == 0) return GetPlaneTexZF(sector_t::floor); spot = lines[0]->v1; - floor = floorplane.ZatPoint (spot); + floor = floorplane.ZatPoint(spot); for (i = 0; i < linecount; i++) { @@ -107,19 +107,19 @@ fixed_t sector_t::FindLowestFloorSurrounding (vertex_t **v) const // P_FindHighestFloorSurrounding() // FIND HIGHEST FLOOR HEIGHT IN SURROUNDING SECTORS // -fixed_t sector_t::FindHighestFloorSurrounding (vertex_t **v) const +double sector_t::FindHighestFloorSurrounding (vertex_t **v) const { int i; line_t *check; sector_t *other; - fixed_t floor; - fixed_t ofloor; + double floor; + double ofloor; vertex_t *spot; - if (linecount == 0) return GetPlaneTexZ(sector_t::floor); + if (linecount == 0) return GetPlaneTexZF(sector_t::floor); spot = lines[0]->v1; - floor = FIXED_MIN; + floor = -FLT_MAX; for (i = 0; i < linecount; i++) { @@ -157,21 +157,21 @@ fixed_t sector_t::FindHighestFloorSurrounding (vertex_t **v) const // // Rewritten by Lee Killough to avoid fixed array and to be faster // -fixed_t sector_t::FindNextHighestFloor (vertex_t **v) const +double sector_t::FindNextHighestFloor (vertex_t **v) const { - fixed_t height; - fixed_t heightdiff; - fixed_t ofloor, floor; + double height; + double heightdiff; + double ofloor, floor; sector_t *other; vertex_t *spot; line_t *check; int i; - if (linecount == 0) return GetPlaneTexZ(sector_t::floor); + if (linecount == 0) return GetPlaneTexZF(sector_t::floor); spot = lines[0]->v1; - height = floorplane.ZatPoint (spot); - heightdiff = FIXED_MAX; + height = floorplane.ZatPoint(spot); + heightdiff = FLT_MAX; for (i = 0; i < linecount; i++) { @@ -212,21 +212,21 @@ fixed_t sector_t::FindNextHighestFloor (vertex_t **v) const // // jff 02/03/98 Twiddled Lee's P_FindNextHighestFloor to make this // -fixed_t sector_t::FindNextLowestFloor (vertex_t **v) const +double sector_t::FindNextLowestFloor (vertex_t **v) const { - fixed_t height; - fixed_t heightdiff; - fixed_t ofloor, floor; + double height; + double heightdiff; + double ofloor, floor; sector_t *other; vertex_t *spot; line_t *check; int i; - if (linecount == 0) return GetPlaneTexZ(sector_t::floor); + if (linecount == 0) return GetPlaneTexZF(sector_t::floor); spot = lines[0]->v1; height = floorplane.ZatPoint (spot); - heightdiff = FIXED_MAX; + heightdiff = FLT_MAX; for (i = 0; i < linecount; i++) { @@ -242,7 +242,7 @@ fixed_t sector_t::FindNextLowestFloor (vertex_t **v) const spot = check->v1; } ofloor = other->floorplane.ZatPoint (check->v2); - floor = floorplane.ZatPoint (check->v2); + floor = floorplane.ZatPoint(check->v2); if (ofloor < floor && floor - ofloor < heightdiff && !IsLinked(other, false)) { heightdiff = floor - ofloor; @@ -266,38 +266,38 @@ fixed_t sector_t::FindNextLowestFloor (vertex_t **v) const // // jff 02/03/98 Twiddled Lee's P_FindNextHighestFloor to make this // -fixed_t sector_t::FindNextLowestCeiling (vertex_t **v) const +double sector_t::FindNextLowestCeiling (vertex_t **v) const { - fixed_t height; - fixed_t heightdiff; - fixed_t oceil, ceil; + double height; + double heightdiff; + double oceil, ceil; sector_t *other; vertex_t *spot; line_t *check; int i; - if (linecount == 0) return GetPlaneTexZ(sector_t::ceiling); + if (linecount == 0) return GetPlaneTexZF(sector_t::ceiling); spot = lines[0]->v1; - height = ceilingplane.ZatPoint (spot); - heightdiff = FIXED_MAX; + height = ceilingplane.ZatPoint(spot); + heightdiff = FLT_MAX; for (i = 0; i < linecount; i++) { check = lines[i]; if (NULL != (other = getNextSector (check, this))) { - oceil = other->ceilingplane.ZatPoint (check->v1); - ceil = ceilingplane.ZatPoint (check->v1); + oceil = other->ceilingplane.ZatPoint(check->v1); + ceil = ceilingplane.ZatPoint(check->v1); if (oceil < ceil && ceil - oceil < heightdiff && !IsLinked(other, true)) { heightdiff = ceil - oceil; height = oceil; spot = check->v1; } - oceil = other->ceilingplane.ZatPoint (check->v2); - ceil = ceilingplane.ZatPoint (check->v2); + oceil = other->ceilingplane.ZatPoint(check->v2); + ceil = ceilingplane.ZatPoint(check->v2); if (oceil < ceil && ceil - oceil < heightdiff && !IsLinked(other, true)) { heightdiff = ceil - oceil; @@ -321,37 +321,37 @@ fixed_t sector_t::FindNextLowestCeiling (vertex_t **v) const // // jff 02/03/98 Twiddled Lee's P_FindNextHighestFloor to make this // -fixed_t sector_t::FindNextHighestCeiling (vertex_t **v) const +double sector_t::FindNextHighestCeiling (vertex_t **v) const { - fixed_t height; - fixed_t heightdiff; - fixed_t oceil, ceil; + double height; + double heightdiff; + double oceil, ceil; sector_t *other; vertex_t *spot; line_t *check; int i; - if (linecount == 0) return GetPlaneTexZ(sector_t::ceiling); + if (linecount == 0) return GetPlaneTexZF(sector_t::ceiling); spot = lines[0]->v1; - height = ceilingplane.ZatPoint (spot); - heightdiff = FIXED_MAX; + height = ceilingplane.ZatPoint(spot); + heightdiff = FLT_MAX; for (i = 0; i < linecount; i++) { check = lines[i]; if (NULL != (other = getNextSector (check, this))) { - oceil = other->ceilingplane.ZatPoint (check->v1); - ceil = ceilingplane.ZatPoint (check->v1); + oceil = other->ceilingplane.ZatPoint(check->v1); + ceil = ceilingplane.ZatPoint(check->v1); if (oceil > ceil && oceil - ceil < heightdiff && !IsLinked(other, true)) { heightdiff = oceil - ceil; height = oceil; spot = check->v1; } - oceil = other->ceilingplane.ZatPoint (check->v2); - ceil = ceilingplane.ZatPoint (check->v2); + oceil = other->ceilingplane.ZatPoint(check->v2); + ceil = ceilingplane.ZatPoint(check->v2); if (oceil > ceil && oceil - ceil < heightdiff && !IsLinked(other, true)) { heightdiff = oceil - ceil; @@ -368,32 +368,32 @@ fixed_t sector_t::FindNextHighestCeiling (vertex_t **v) const // // FIND LOWEST CEILING IN THE SURROUNDING SECTORS // -fixed_t sector_t::FindLowestCeilingSurrounding (vertex_t **v) const +double sector_t::FindLowestCeilingSurrounding (vertex_t **v) const { - fixed_t height; - fixed_t oceil; + double height; + double oceil; sector_t *other; vertex_t *spot; line_t *check; int i; - if (linecount == 0) return GetPlaneTexZ(sector_t::ceiling); + if (linecount == 0) return GetPlaneTexZF(sector_t::ceiling); spot = lines[0]->v1; - height = FIXED_MAX; + height = FLT_MAX; for (i = 0; i < linecount; i++) { check = lines[i]; if (NULL != (other = getNextSector (check, this))) { - oceil = other->ceilingplane.ZatPoint (check->v1); + oceil = other->ceilingplane.ZatPoint(check->v1); if (oceil < height) { height = oceil; spot = check->v1; } - oceil = other->ceilingplane.ZatPoint (check->v2); + oceil = other->ceilingplane.ZatPoint(check->v2); if (oceil < height) { height = oceil; @@ -410,32 +410,32 @@ fixed_t sector_t::FindLowestCeilingSurrounding (vertex_t **v) const // // FIND HIGHEST CEILING IN THE SURROUNDING SECTORS // -fixed_t sector_t::FindHighestCeilingSurrounding (vertex_t **v) const +double sector_t::FindHighestCeilingSurrounding (vertex_t **v) const { - fixed_t height; - fixed_t oceil; + double height; + double oceil; sector_t *other; vertex_t *spot; line_t *check; int i; - if (linecount == 0) return GetPlaneTexZ(sector_t::ceiling); + if (linecount == 0) return GetPlaneTexZF(sector_t::ceiling); spot = lines[0]->v1; - height = FIXED_MIN; + height = -FLT_MAX; for (i = 0; i < linecount; i++) { check = lines[i]; if (NULL != (other = getNextSector (check, this))) { - oceil = other->ceilingplane.ZatPoint (check->v1); + oceil = other->ceilingplane.ZatPoint(check->v1); if (oceil > height) { height = oceil; spot = check->v1; } - oceil = other->ceilingplane.ZatPoint (check->v2); + oceil = other->ceilingplane.ZatPoint(check->v2); if (oceil > height) { height = oceil; @@ -457,14 +457,14 @@ fixed_t sector_t::FindHighestCeilingSurrounding (vertex_t **v) const // jff 02/03/98 Add routine to find shortest lower texture // -static inline void CheckShortestTex (FTextureID texnum, fixed_t &minsize) +static inline void CheckShortestTex (FTextureID texnum, double &minsize) { if (texnum.isValid() || (texnum.isNull() && (i_compatflags & COMPATF_SHORTTEX))) { FTexture *tex = TexMan[texnum]; if (tex != NULL) { - fixed_t h = tex->GetScaledHeight()<GetScaledHeight(); if (h < minsize) { minsize = h; @@ -473,9 +473,9 @@ static inline void CheckShortestTex (FTextureID texnum, fixed_t &minsize) } } -fixed_t sector_t::FindShortestTextureAround () const +double sector_t::FindShortestTextureAround () const { - fixed_t minsize = FIXED_MAX; + double minsize = FLT_MAX; for (int i = 0; i < linecount; i++) { @@ -485,7 +485,7 @@ fixed_t sector_t::FindShortestTextureAround () const CheckShortestTex (lines[i]->sidedef[1]->GetTexture(side_t::bottom), minsize); } } - return minsize < FIXED_MAX ? minsize : TexMan[0]->GetHeight() * FRACUNIT; + return minsize < FLT_MAX ? minsize : TexMan[0]->GetHeight(); } @@ -499,9 +499,9 @@ fixed_t sector_t::FindShortestTextureAround () const // // jff 03/20/98 Add routine to find shortest upper texture // -fixed_t sector_t::FindShortestUpperAround () const +double sector_t::FindShortestUpperAround () const { - fixed_t minsize = FIXED_MAX; + double minsize = FLT_MAX; for (int i = 0; i < linecount; i++) { @@ -511,7 +511,7 @@ fixed_t sector_t::FindShortestUpperAround () const CheckShortestTex (lines[i]->sidedef[1]->GetTexture(side_t::top), minsize); } } - return minsize < FIXED_MAX ? minsize : TexMan[0]->GetHeight() * FRACUNIT; + return minsize < FLT_MAX ? minsize : TexMan[0]->GetHeight(); } @@ -529,7 +529,7 @@ fixed_t sector_t::FindShortestUpperAround () const // jff 3/14/98 change first parameter to plain height to allow call // from routine not using floormove_t // -sector_t *sector_t::FindModelFloorSector (fixed_t floordestheight) const +sector_t *sector_t::FindModelFloorSector (double floordestheight) const { int i; sector_t *sec; @@ -540,8 +540,8 @@ sector_t *sector_t::FindModelFloorSector (fixed_t floordestheight) const { sec = getNextSector (lines[i], this); if (sec != NULL && - (sec->floorplane.ZatPoint (lines[i]->v1) == floordestheight || - sec->floorplane.ZatPoint (lines[i]->v2) == floordestheight)) + (sec->floorplane.ZatPoint(lines[i]->v1) == floordestheight || + sec->floorplane.ZatPoint(lines[i]->v2) == floordestheight)) { return sec; } @@ -565,7 +565,7 @@ sector_t *sector_t::FindModelFloorSector (fixed_t floordestheight) const // jff 3/14/98 change first parameter to plain height to allow call // from routine not using ceiling_t // -sector_t *sector_t::FindModelCeilingSector (fixed_t floordestheight) const +sector_t *sector_t::FindModelCeilingSector (double floordestheight) const { int i; sector_t *sec; @@ -576,8 +576,8 @@ sector_t *sector_t::FindModelCeilingSector (fixed_t floordestheight) const { sec = getNextSector (lines[i], this); if (sec != NULL && - (sec->ceilingplane.ZatPoint (lines[i]->v1) == floordestheight || - sec->ceilingplane.ZatPoint (lines[i]->v2) == floordestheight)) + (sec->ceilingplane.ZatPoint(lines[i]->v1) == floordestheight || + sec->ceilingplane.ZatPoint(lines[i]->v2) == floordestheight)) { return sec; } @@ -609,12 +609,12 @@ int sector_t::FindMinSurroundingLight (int min) const // // Find the highest point on the floor of the sector // -fixed_t sector_t::FindHighestFloorPoint (vertex_t **v) const +double sector_t::FindHighestFloorPoint (vertex_t **v) const { int i; line_t *line; - fixed_t height = FIXED_MIN; - fixed_t probeheight; + double height = -FLT_MAX; + double probeheight; vertex_t *spot = NULL; if (!floorplane.isSlope()) @@ -624,19 +624,19 @@ fixed_t sector_t::FindHighestFloorPoint (vertex_t **v) const if (linecount == 0) *v = &vertexes[0]; else *v = lines[0]->v1; } - return floorplane.Zat0(); + return floorplane.fD(); } for (i = 0; i < linecount; i++) { line = lines[i]; - probeheight = floorplane.ZatPoint (line->v1); + probeheight = floorplane.ZatPoint(line->v1); if (probeheight > height) { height = probeheight; spot = line->v1; } - probeheight = floorplane.ZatPoint (line->v2); + probeheight = floorplane.ZatPoint(line->v2); if (probeheight > height) { height = probeheight; @@ -651,12 +651,12 @@ fixed_t sector_t::FindHighestFloorPoint (vertex_t **v) const // // Find the lowest point on the ceiling of the sector // -fixed_t sector_t::FindLowestCeilingPoint (vertex_t **v) const +double sector_t::FindLowestCeilingPoint (vertex_t **v) const { int i; line_t *line; - fixed_t height = FIXED_MAX; - fixed_t probeheight; + double height = FLT_MAX; + double probeheight; vertex_t *spot = NULL; if (!ceilingplane.isSlope()) @@ -666,19 +666,19 @@ fixed_t sector_t::FindLowestCeilingPoint (vertex_t **v) const if (linecount == 0) *v = &vertexes[0]; else *v = lines[0]->v1; } - return ceilingplane.fixD(); + return ceilingplane.fD(); } for (i = 0; i < linecount; i++) { line = lines[i]; - probeheight = ceilingplane.ZatPoint (line->v1); + probeheight = ceilingplane.ZatPoint(line->v1); if (probeheight < height) { height = probeheight; spot = line->v1; } - probeheight = ceilingplane.ZatPoint (line->v2); + probeheight = ceilingplane.ZatPoint(line->v2); if (probeheight < height) { height = probeheight; diff --git a/src/p_sight.cpp b/src/p_sight.cpp index b812e0f633..c29b4e6acc 100644 --- a/src/p_sight.cpp +++ b/src/p_sight.cpp @@ -561,8 +561,8 @@ bool SightCheck::P_SightTraverseIntercepts () if ((rover->flags & FF_SOLID) == myseethrough || !(rover->flags & FF_EXISTS)) continue; if ((Flags & SF_IGNOREWATERBOUNDARY) && (rover->flags & FF_SOLID) == 0) continue; - double ff_bottom = rover->bottom.plane->ZatPointF(seeingthing); - double ff_top = rover->top.plane->ZatPointF(seeingthing); + double ff_bottom = rover->bottom.plane->ZatPoint(seeingthing); + double ff_top = rover->top.plane->ZatPoint(seeingthing); if (Lastztop <= ff_bottom && topz > ff_bottom && Lastzbottom <= ff_bottom && bottomz > ff_bottom) return false; if (Lastzbottom >= ff_top && bottomz < ff_top && Lastztop >= ff_top && topz < ff_top) return false; @@ -849,16 +849,16 @@ sightcounts[0]++; if (!(flags & SF_IGNOREWATERBOUNDARY)) { if ((s1->GetHeightSec() && - ((t1->Top() <= s1->heightsec->floorplane.ZatPointF(t1) && - t2->Z() >= s1->heightsec->floorplane.ZatPointF(t2)) || - (t1->Z() >= s1->heightsec->ceilingplane.ZatPointF(t1) && - t2->Top() <= s1->heightsec->ceilingplane.ZatPointF(t2)))) + ((t1->Top() <= s1->heightsec->floorplane.ZatPoint(t1) && + t2->Z() >= s1->heightsec->floorplane.ZatPoint(t2)) || + (t1->Z() >= s1->heightsec->ceilingplane.ZatPoint(t1) && + t2->Top() <= s1->heightsec->ceilingplane.ZatPoint(t2)))) || (s2->GetHeightSec() && - ((t2->Top() <= s2->heightsec->floorplane.ZatPointF(t2) && - t1->Z() >= s2->heightsec->floorplane.ZatPointF(t1)) || - (t2->Z() >= s2->heightsec->ceilingplane.ZatPointF(t2) && - t1->Top() <= s2->heightsec->ceilingplane.ZatPointF(t1))))) + ((t2->Top() <= s2->heightsec->floorplane.ZatPoint(t2) && + t1->Z() >= s2->heightsec->floorplane.ZatPoint(t1)) || + (t2->Z() >= s2->heightsec->ceilingplane.ZatPoint(t2) && + t1->Top() <= s2->heightsec->ceilingplane.ZatPoint(t1))))) { res = false; goto done; diff --git a/src/p_slopes.cpp b/src/p_slopes.cpp index 49c9c5a358..f2dd4b7861 100644 --- a/src/p_slopes.cpp +++ b/src/p_slopes.cpp @@ -81,10 +81,10 @@ static void P_SlopeLineToPoint (int lineid, fixed_t x, fixed_t y, fixed_t z, boo p[0] = line->v1->fX(); p[1] = line->v1->fY(); - p[2] = plane->ZatPointF (line->v1); + p[2] = plane->ZatPoint (line->v1); v1[0] = line->Delta().X; v1[1] = line->Delta().Y; - v1[2] = plane->ZatPointF (line->v2) - p[2]; + v1[2] = plane->ZatPoint (line->v2) - p[2]; v2[0] = FIXED2DBL (x) - p[0]; v2[1] = FIXED2DBL (y) - p[1]; v2[2] = FIXED2DBL (z) - p[2]; diff --git a/src/p_spec.cpp b/src/p_spec.cpp index 3356def662..7eaab5dde2 100644 --- a/src/p_spec.cpp +++ b/src/p_spec.cpp @@ -453,7 +453,7 @@ static void DoSectorDamage(AActor *actor, sector_t *sec, int amount, FName type, if (!(flags & DAMAGE_PLAYERS) && actor->player != NULL) return; - if (!(flags & DAMAGE_IN_AIR) && !actor->isAtZ(sec->floorplane.ZatPointF(actor)) && !actor->waterlevel) + if (!(flags & DAMAGE_IN_AIR) && !actor->isAtZ(sec->floorplane.ZatPoint(actor)) && !actor->waterlevel) return; if (protectClass != NULL) @@ -490,8 +490,8 @@ void P_SectorDamage(int tag, int amount, FName type, PClassActor *protectClass, { next = actor->snext; // Only affect actors touching the 3D floor - double z1 = sec->floorplane.ZatPointF(actor); - double z2 = sec->ceilingplane.ZatPointF(actor); + double z1 = sec->floorplane.ZatPoint(actor); + double z2 = sec->ceilingplane.ZatPoint(actor); if (z2 < z1) { // Account for Vavoom-style 3D floors diff --git a/src/p_spec.h b/src/p_spec.h index f5c4d49e03..bb7f1c64f8 100644 --- a/src/p_spec.h +++ b/src/p_spec.h @@ -357,9 +357,9 @@ public: protected: DPlat (sector_t *sector); - fixed_t m_Speed; - fixed_t m_Low; - fixed_t m_High; + double m_Speed; + double m_Low; + double m_High; int m_Wait; int m_Count; EPlatState m_Status; @@ -376,13 +376,13 @@ private: DPlat (); friend bool EV_DoPlat (int tag, line_t *line, EPlatType type, - int height, int speed, int delay, int lip, int change); + double height, double speed, int delay, int lip, int change); friend void EV_StopPlat (int tag); friend void P_ActivateInStasis (int tag); }; bool EV_DoPlat (int tag, line_t *line, DPlat::EPlatType type, - int height, int speed, int delay, int lip, int change); + double height, double speed, int delay, int lip, int change); void EV_StopPlat (int tag); void P_ActivateInStasis (int tag); @@ -403,8 +403,8 @@ public: }; - DPillar (sector_t *sector, EPillar type, fixed_t speed, fixed_t height, - fixed_t height2, int crush, bool hexencrush); + DPillar (sector_t *sector, EPillar type, double speed, double height, + double height2, int crush, bool hexencrush); void Serialize (FArchive &arc); void Tick (); @@ -412,10 +412,10 @@ public: protected: EPillar m_Type; - fixed_t m_FloorSpeed; - fixed_t m_CeilingSpeed; - fixed_t m_FloorTarget; - fixed_t m_CeilingTarget; + double m_FloorSpeed; + double m_CeilingSpeed; + double m_FloorTarget; + double m_CeilingTarget; int m_Crush; bool m_Hexencrush; TObjPtr m_Interp_Ceiling; @@ -426,7 +426,7 @@ private: }; bool EV_DoPillar (DPillar::EPillar type, line_t *line, int tag, - fixed_t speed, fixed_t height, fixed_t height2, int crush, bool hexencrush); + double speed, double height, double height2, int crush, bool hexencrush); // // P_DOORS @@ -446,16 +446,16 @@ public: }; DDoor (sector_t *sector); - DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTag, int topcountdown); + DDoor (sector_t *sec, EVlDoor type, double speed, int delay, int lightTag, int topcountdown); void Serialize (FArchive &arc); void Tick (); protected: EVlDoor m_Type; - fixed_t m_TopDist; - fixed_t m_BotDist, m_OldFloorDist; + double m_TopDist; + double m_BotDist, m_OldFloorDist; vertex_t *m_BotSpot; - fixed_t m_Speed; + double m_Speed; // 1 = up, 0 = waiting at top, -1 = down int m_Direction; @@ -471,7 +471,7 @@ protected: void DoorSound (bool raise, class DSeqNode *curseq=NULL) const; friend bool EV_DoDoor (DDoor::EVlDoor type, line_t *line, AActor *thing, - int tag, int speed, int delay, int lock, + int tag, double speed, int delay, int lock, int lightTag, bool boomgen, int topcountdown); private: DDoor (); @@ -479,16 +479,9 @@ private: }; bool EV_DoDoor (DDoor::EVlDoor type, line_t *line, AActor *thing, - int tag, int speed, int delay, int lock, + int tag, double speed, int delay, int lock, int lightTag, bool boomgen = false, int topcountdown = 0); -inline bool EV_DoDoor(DDoor::EVlDoor type, line_t *line, AActor *thing, - int tag, double speed, int delay, int lock, - int lightTag, bool boomgen = false, int topcountdown = 0) -{ - return EV_DoDoor(type, line, thing, tag, FLOAT2FIXED(speed), delay, lock, lightTag, boomgen, topcountdown); -} - class DAnimatedDoor : public DMovingCeiling { @@ -506,7 +499,7 @@ protected: int m_Frame; FDoorAnimation *m_DoorAnim; int m_Timer; - fixed_t m_BotDist; + double m_BotDist; int m_Status; enum { @@ -575,22 +568,22 @@ public: DCeiling (sector_t *sec); - DCeiling (sector_t *sec, fixed_t speed1, fixed_t speed2, int silent); + DCeiling (sector_t *sec, double speed1, double speed2, int silent); void Serialize (FArchive &arc); void Tick (); static DCeiling *Create(sector_t *sec, DCeiling::ECeiling type, line_t *line, int tag, - fixed_t speed, fixed_t speed2, fixed_t height, + double speed, double speed2, double height, int crush, int silent, int change, ECrushMode hexencrush); protected: ECeiling m_Type; - fixed_t m_BottomHeight; - fixed_t m_TopHeight; - fixed_t m_Speed; - fixed_t m_Speed1; // [RH] dnspeed of crushers - fixed_t m_Speed2; // [RH] upspeed of crushers + double m_BottomHeight; + double m_TopHeight; + double m_Speed; + double m_Speed1; // [RH] dnspeed of crushers + double m_Speed2; // [RH] upspeed of crushers int m_Crush; ECrushMode m_CrushMode; int m_Silent; @@ -614,23 +607,9 @@ private: }; bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line, - int tag, fixed_t speed, fixed_t speed2, fixed_t height, + int tag, double speed, double speed2, double height, int crush, int silent, int change, DCeiling::ECrushMode hexencrush = DCeiling::ECrushMode::crushDoom); -inline bool EV_DoCeiling(DCeiling::ECeiling type, line_t *line, - int tag, double speed, double speed2, fixed_t height, - int crush, int silent, int change, DCeiling::ECrushMode hexencrush = DCeiling::ECrushMode::crushDoom) -{ - return EV_DoCeiling(type, line, tag, FLOAT2FIXED(speed), FLOAT2FIXED(speed2), height, crush, silent, change, hexencrush); -} - -inline bool EV_DoCeiling(DCeiling::ECeiling type, line_t *line, - int tag, double speed, int speed2, fixed_t height, - int crush, int silent, int change, DCeiling::ECrushMode hexencrush = DCeiling::ECrushMode::crushDoom) -{ - return EV_DoCeiling(type, line, tag, FLOAT2FIXED(speed), speed2, height, crush, silent, change, hexencrush); -} - bool EV_CeilingCrushStop (int tag); void P_ActivateInStasisCeiling (int tag); @@ -701,19 +680,19 @@ public: void Serialize (FArchive &arc); void Tick (); -protected: +//protected: EFloor m_Type; int m_Crush; bool m_Hexencrush; int m_Direction; secspecial_t m_NewSpecial; FTextureID m_Texture; - fixed_t m_FloorDestDist; - fixed_t m_Speed; + double m_FloorDestDist; + double m_Speed; // [RH] New parameters used to reset and delay stairs + double m_OrgDist; int m_ResetCount; - int m_OrgDist; int m_Delay; int m_PauseTime; int m_StepTime; @@ -723,33 +702,24 @@ protected: void SetFloorChangeType (sector_t *sec, int change); friend bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, - fixed_t stairsize, fixed_t speed, int delay, int reset, int igntxt, + double stairsize, double speed, int delay, int reset, int igntxt, int usespecials); friend bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, - fixed_t speed, fixed_t height, int crush, int change, bool hexencrush, bool hereticlower); + double speed, double height, int crush, int change, bool hexencrush, bool hereticlower); friend bool EV_FloorCrushStop (int tag); - friend bool EV_DoDonut (int tag, line_t *line, fixed_t pillarspeed, fixed_t slimespeed); + friend bool EV_DoDonut (int tag, line_t *line, double pillarspeed, double slimespeed); private: DFloor (); }; bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line, - fixed_t stairsize, fixed_t speed, int delay, int reset, int igntxt, + double stairsize, double speed, int delay, int reset, int igntxt, int usespecials); -bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, - fixed_t speed, fixed_t height, int crush, int change, bool hexencrush, bool hereticlower=false); -inline bool EV_DoFloor(DFloor::EFloor floortype, line_t *line, int tag, - double speed, double height, int crush, int change, bool hexencrush, bool hereticlower = false) -{ - return EV_DoFloor(floortype, line, tag, FLOAT2FIXED(speed), FLOAT2FIXED(height), crush, change, hexencrush, hereticlower); -} -inline bool EV_DoFloor(DFloor::EFloor floortype, line_t *line, int tag, - double speed, int height, int crush, int change, bool hexencrush, bool hereticlower = false) -{ - return EV_DoFloor(floortype, line, tag, FLOAT2FIXED(speed), height< m_Interp_Ceiling; TObjPtr m_Interp_Floor; void StartFloorSound (); - friend bool EV_DoElevator (line_t *line, DElevator::EElevator type, fixed_t speed, - fixed_t height, int tag); + friend bool EV_DoElevator (line_t *line, DElevator::EElevator type, double speed, double height, int tag); private: DElevator (); }; -bool EV_DoElevator (line_t *line, DElevator::EElevator type, fixed_t speed, - fixed_t height, int tag); +bool EV_DoElevator (line_t *line, DElevator::EElevator type, double speed, double height, int tag); class DWaggleBase : public DMover { @@ -802,12 +770,12 @@ public: void Serialize (FArchive &arc); protected: - fixed_t m_OriginalDist; - fixed_t m_Accumulator; - fixed_t m_AccDelta; - fixed_t m_TargetScale; - fixed_t m_Scale; - fixed_t m_ScaleDelta; + double m_OriginalDist; + double m_Accumulator; + double m_AccDelta; + double m_TargetScale; + double m_Scale; + double m_ScaleDelta; int m_Ticker; int m_State; TObjPtr m_Interpolation; diff --git a/src/p_user.cpp b/src/p_user.cpp index 23223a3d31..9b8e5de8f3 100644 --- a/src/p_user.cpp +++ b/src/p_user.cpp @@ -2609,7 +2609,7 @@ void P_PlayerThink (player_t *player) P_PlayerOnSpecial3DFloor (player); P_PlayerInSpecialSector (player); - if (!player->mo->isAbove(player->mo->Sector->floorplane.ZatPointF(player->mo)) || + if (!player->mo->isAbove(player->mo->Sector->floorplane.ZatPoint(player->mo)) || player->mo->waterlevel) { // Player must be touching the floor diff --git a/src/po_man.cpp b/src/po_man.cpp index 5d397c7241..6e0563e13e 100644 --- a/src/po_man.cpp +++ b/src/po_man.cpp @@ -1239,8 +1239,8 @@ bool FPolyObj::CheckMobjBlocking (side_t *sd) } // [BL] See if we hit below the floor/ceiling of the poly. else if(!performBlockingThrust && ( - mobj->_f_Z() < ld->sidedef[!side]->sector->GetSecPlane(sector_t::floor).ZatPoint(mobj) || - mobj->_f_Top() > ld->sidedef[!side]->sector->GetSecPlane(sector_t::ceiling).ZatPoint(mobj) + mobj->Z() < ld->sidedef[!side]->sector->GetSecPlane(sector_t::floor).ZatPoint(mobj) || + mobj->Top() > ld->sidedef[!side]->sector->GetSecPlane(sector_t::ceiling).ZatPoint(mobj) )) { performBlockingThrust = true; diff --git a/src/portal.cpp b/src/portal.cpp index a4d46c5f02..882b4da526 100644 --- a/src/portal.cpp +++ b/src/portal.cpp @@ -1096,8 +1096,8 @@ void P_CreateLinkedPortals() { // This is a fatal condition. We have to remove one of the two portals. Choose the one that doesn't match the current plane Printf("Error in sector %d: Ceiling portal at z=%d is below floor portal at z=%d\n", i, cz, fz); - fixed_t cp = sectors[i].ceilingplane.Zat0(); - fixed_t fp = sectors[i].ceilingplane.Zat0(); + fixed_t cp = -sectors[i].ceilingplane.fixD(); + fixed_t fp = -sectors[i].ceilingplane.fixD(); if (cp < fp || fz == fp) { sectors[i].SkyBoxes[sector_t::ceiling] = NULL; diff --git a/src/r_3dfloors.cpp b/src/r_3dfloors.cpp index fbdc34edce..5f91fc6b6e 100644 --- a/src/r_3dfloors.cpp +++ b/src/r_3dfloors.cpp @@ -55,8 +55,8 @@ void R_3D_AddHeight(secplane_t *add, sector_t *sec) fixed_t height; height = add->ZatPoint(viewx, viewy); - if(height >= sec->CenterCeiling()) return; - if(height <= sec->CenterFloor()) return; + if(height >= sec->_f_CenterCeiling()) return; + if(height <= sec->_f_CenterFloor()) return; fakeActive = 1; diff --git a/src/r_bsp.cpp b/src/r_bsp.cpp index abfb5ce1c3..d6de05d552 100644 --- a/src/r_bsp.cpp +++ b/src/r_bsp.cpp @@ -426,7 +426,7 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, tempsec->floorplane = sec->floorplane; tempsec->ceilingplane = s->floorplane; tempsec->ceilingplane.FlipVert (); - tempsec->ceilingplane.ChangeHeight (-1); + tempsec->ceilingplane.ChangeHeight(-1 / 65536.); tempsec->ColorMap = s->ColorMap; } @@ -438,12 +438,12 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, tempsec->ceilingplane = s->floorplane; tempsec->ceilingplane.FlipVert (); - tempsec->ceilingplane.ChangeHeight (-1); + tempsec->ceilingplane.ChangeHeight (-1 / 65536.); if (s->GetTexture(sector_t::ceiling) == skyflatnum) { tempsec->floorplane = tempsec->ceilingplane; tempsec->floorplane.FlipVert (); - tempsec->floorplane.ChangeHeight (+1); + tempsec->floorplane.ChangeHeight (+1 / 65536.); tempsec->SetTexture(sector_t::ceiling, tempsec->GetTexture(sector_t::floor), false); tempsec->planes[sector_t::ceiling].xform = tempsec->planes[sector_t::floor].xform; } @@ -475,7 +475,7 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, tempsec->ceilingplane = s->ceilingplane; tempsec->floorplane = s->ceilingplane; tempsec->floorplane.FlipVert (); - tempsec->floorplane.ChangeHeight (+1); + tempsec->floorplane.ChangeHeight (+1 / 65536.); tempsec->ColorMap = s->ColorMap; tempsec->ColorMap = s->ColorMap; @@ -1260,14 +1260,14 @@ void R_Subsector (subsector_t *sub) } else position = sector_t::ceiling; frontsector = &tempsec; - tempsec.ceilingplane.ChangeHeight(-1); + tempsec.ceilingplane.ChangeHeight(-1 / 65536.); if (fixedlightlev < 0 && sub->sector->e->XFloor.lightlist.Size()) { light = P_GetPlaneLight(sub->sector, &frontsector->ceilingplane, false); basecolormap = light->extra_colormap; ceilinglightlevel = *light->p_lightlevel; } - tempsec.ceilingplane.ChangeHeight(1); + tempsec.ceilingplane.ChangeHeight(1 / 65536.); floorplane = NULL; ceilingplane = R_FindPlane(frontsector->ceilingplane, // killough 3/8/98 @@ -1345,11 +1345,11 @@ void R_Subsector (subsector_t *sub) fakeFloor->validcount = validcount; R_3D_NewClip(); } - if (frontsector->CenterFloor() >= backsector->CenterFloor()) + if (frontsector->_f_CenterFloor() >= backsector->_f_CenterFloor()) { fake3D |= FAKE3D_CLIPBOTFRONT; } - if (frontsector->CenterCeiling() <= backsector->CenterCeiling()) + if (frontsector->_f_CenterCeiling() <= backsector->_f_CenterCeiling()) { fake3D |= FAKE3D_CLIPTOPFRONT; } diff --git a/src/r_defs.h b/src/r_defs.h index ec7caebce9..cd77381830 100644 --- a/src/r_defs.h +++ b/src/r_defs.h @@ -357,6 +357,10 @@ public: { return FIXED2DBL(d); } + double fiC() const + { + return FIXED2DBL(ic); + } bool isSlope() const { @@ -390,11 +394,6 @@ public: return FixedMul(ic, -d - DMulScale16(a, spot.x, b, spot.y)); } - double ZatPointF(const fixedvec3 &spot) const - { - return FIXED2DBL(FixedMul(ic, -d - DMulScale16(a, spot.x, b, spot.y))); - } - // Returns the value of z at (x,y) fixed_t ZatPoint (fixed_t x, fixed_t y) const { @@ -412,39 +411,21 @@ public: return (d + a*pos.X + b*pos.Y) * ic / (-65536.0 * 65536.0); } - // Returns the value of z at vertex v - fixed_t ZatPoint (const vertex_t *v) const - { - return FixedMul (ic, -d - DMulScale16 (a, v->fixX(), b, v->fixY())); - } - - double ZatPointF(const vertex_t *v) const + double ZatPoint(const vertex_t *v) const { return FIXED2DBL(FixedMul(ic, -d - DMulScale16(a, v->fixX(), b, v->fixY()))); } - fixed_t ZatPoint (const AActor *ac) const - { - return FixedMul (ic, -d - DMulScale16 (a, ac->_f_X(), b, ac->_f_Y())); - } - - double ZatPointF(const AActor *ac) const + double ZatPoint(const AActor *ac) const { return (d + a*ac->X() + b*ac->Y()) * ic / (-65536.0 * 65536.0); } - // Returns the value of z at (x,y) if d is equal to dist - fixed_t ZatPointDist (fixed_t x, fixed_t y, fixed_t dist) const - { - return FixedMul (ic, -dist - DMulScale16 (a, x, b, y)); - } - // Returns the value of z at vertex v if d is equal to dist - fixed_t ZatPointDist (const vertex_t *v, fixed_t dist) + double ZatPointDist(const vertex_t *v, double dist) { - return FixedMul (ic, -dist - DMulScale16 (a, v->fixX(), b, v->fixY())); + return FIXED2DBL(FixedMul(ic, -FLOAT2FIXED(dist) - DMulScale16(a, v->fixX(), b, v->fixY()))); } - // Flips the plane's vertical orientiation, so that if it pointed up, // it will point down, and vice versa. void FlipVert () @@ -469,15 +450,15 @@ public: } // Moves a plane up/down by hdiff units - void ChangeHeight (fixed_t hdiff) + void ChangeHeight(double hdiff) { - d = d - FixedMul (hdiff, c); + d = d - fixed_t(hdiff * c); } // Moves a plane up/down by hdiff units - fixed_t GetChangedHeight (fixed_t hdiff) + double GetChangedHeight(double hdiff) { - return d - FixedMul (hdiff, c); + return fD() - hdiff * fC(); } // Returns how much this plane's height would change if d were set to oldd @@ -487,9 +468,15 @@ public: } // Returns how much this plane's height would change if d were set to oldd - fixed_t HeightDiff (fixed_t oldd, fixed_t newd) const + double HeightDiff(double oldd) const { - return FixedMul (oldd - newd, ic); + return (oldd - fD()) * fiC(); + } + + // Returns how much this plane's height would change if d were set to oldd + double HeightDiff(double oldd, double newd) const + { + return (oldd - newd) * fiC(); } fixed_t PointToDist (fixed_t x, fixed_t y, fixed_t z) const @@ -507,6 +494,16 @@ public: return -TMulScale16 (a, v->fixX(), b, v->fixY(), z, c); } + double PointToDist(const DVector2 &xy, double z) const + { + return -(a * xy.X + b * xy.Y + c * z) / 65536.; + } + + double PointToDist(const vertex_t *v, double z) const + { + return -(a * v->fX() + b * v->fY() + c * z) / 65536.; + } + void SetAtHeight(fixed_t height, int ceiling) { a = b = 0; @@ -684,22 +681,23 @@ struct sector_t { // Member functions bool IsLinked(sector_t *other, bool ceiling) const; - fixed_t FindLowestFloorSurrounding (vertex_t **v) const; - fixed_t FindHighestFloorSurrounding (vertex_t **v) const; - fixed_t FindNextHighestFloor (vertex_t **v) const; - fixed_t FindNextLowestFloor (vertex_t **v) const; - fixed_t FindLowestCeilingSurrounding (vertex_t **v) const; // jff 2/04/98 - fixed_t FindHighestCeilingSurrounding (vertex_t **v) const; // jff 2/04/98 - fixed_t FindNextLowestCeiling (vertex_t **v) const; // jff 2/04/98 - fixed_t FindNextHighestCeiling (vertex_t **v) const; // jff 2/04/98 - fixed_t FindShortestTextureAround () const; // jff 2/04/98 - fixed_t FindShortestUpperAround () const; // jff 2/04/98 - sector_t *FindModelFloorSector (fixed_t floordestheight) const; // jff 2/04/98 - sector_t *FindModelCeilingSector (fixed_t floordestheight) const; // jff 2/04/98 + double FindLowestFloorSurrounding(vertex_t **v) const; + double FindHighestFloorSurrounding(vertex_t **v) const; + double FindNextHighestFloor(vertex_t **v) const; + double FindNextLowestFloor(vertex_t **v) const; + double FindLowestCeilingSurrounding(vertex_t **v) const; // jff 2/04/98 + double FindHighestCeilingSurrounding(vertex_t **v) const; // jff 2/04/98 + double FindNextLowestCeiling(vertex_t **v) const; // jff 2/04/98 + double FindNextHighestCeiling(vertex_t **v) const; // jff 2/04/98 + double FindShortestTextureAround() const; // jff 2/04/98 + double FindShortestUpperAround() const; // jff 2/04/98 + sector_t *FindModelFloorSector(double floordestheight) const; // jff 2/04/98 + sector_t *FindModelCeilingSector(double floordestheight) const; // jff 2/04/98 int FindMinSurroundingLight (int max) const; sector_t *NextSpecialSector (int type, sector_t *prev) const; // [RH] - fixed_t FindLowestCeilingPoint (vertex_t **v) const; - fixed_t FindHighestFloorPoint (vertex_t **v) const; + double FindLowestCeilingPoint(vertex_t **v) const; + double FindHighestFloorPoint(vertex_t **v) const; + void AdjustFloorClip () const; void SetColor(int r, int g, int b, int desat); void SetFade(int r, int g, int b); @@ -1088,10 +1086,10 @@ struct sector_t } // Member variables - fixed_t CenterFloor () const { return floorplane.ZatPoint (_f_centerspot()); } - fixed_t CenterCeiling () const { return ceilingplane.ZatPoint (_f_centerspot()); } - double CenterFloorF() const { return floorplane.ZatPoint(centerspot); } - double CenterCeilingF() const { return ceilingplane.ZatPoint(centerspot); } + fixed_t _f_CenterFloor () const { return floorplane.ZatPoint (_f_centerspot()); } + fixed_t _f_CenterCeiling () const { return ceilingplane.ZatPoint (_f_centerspot()); } + double CenterFloor() const { return floorplane.ZatPoint(centerspot); } + double CenterCeiling() const { return ceilingplane.ZatPoint(centerspot); } // [RH] store floor and ceiling planes instead of heights secplane_t floorplane, ceilingplane; @@ -1335,6 +1333,12 @@ struct side_t { textures[which].yscale = scale == 0 ? FRACUNIT : scale; } + + void SetTextureYScale(int which, double scale) + { + textures[which].yscale = scale == 0 ? FRACUNIT : FLOAT2FIXED(scale); + } + void SetTextureYScale(fixed_t scale) { textures[top].yscale = textures[mid].yscale = textures[bottom].yscale = scale == 0 ? FRACUNIT : scale; @@ -1416,6 +1420,11 @@ public: dy = FLOAT2FIXED(y); } + void setAlpha(double a) + { + Alpha = FLOAT2FIXED(a); + } + FLinePortal *getPortal() const { return portalindex >= linePortals.Size() ? (FLinePortal*)NULL : &linePortals[portalindex]; diff --git a/src/r_segs.cpp b/src/r_segs.cpp index 8a1cf29149..e6d841df13 100644 --- a/src/r_segs.cpp +++ b/src/r_segs.cpp @@ -687,16 +687,16 @@ void R_RenderFakeWallRange (drawseg_t *ds, int x1, int x2) frontsector = sec; } - floorheight = backsector->CenterFloor(); - ceilingheight = backsector->CenterCeiling(); + floorheight = backsector->_f_CenterFloor(); + ceilingheight = backsector->_f_CenterCeiling(); // maybe fix clipheights if (!(fake3D & FAKE3D_CLIPBOTTOM)) sclipBottom = floorheight; if (!(fake3D & FAKE3D_CLIPTOP)) sclipTop = ceilingheight; // maybe not visible - if (sclipBottom >= frontsector->CenterCeiling()) return; - if (sclipTop <= frontsector->CenterFloor()) return; + if (sclipBottom >= frontsector->_f_CenterCeiling()) return; + if (sclipTop <= frontsector->_f_CenterFloor()) return; if (fake3D & FAKE3D_DOWN2UP) { // bottom to viewz @@ -2266,7 +2266,7 @@ void R_NewWall (bool needlights) int planeside; planeside = frontsector->floorplane.PointOnSide(viewx, viewy, viewz); - if (frontsector->floorplane.fixC() < 0) // 3D floors have the floor backwards + if (frontsector->floorplane.fC() < 0) // 3D floors have the floor backwards planeside = -planeside; if (planeside <= 0) // above view plane markfloor = false; @@ -2274,7 +2274,7 @@ void R_NewWall (bool needlights) if (frontsector->GetTexture(sector_t::ceiling) != skyflatnum) { planeside = frontsector->ceilingplane.PointOnSide(viewx, viewy, viewz); - if (frontsector->ceilingplane.fixC() > 0) // 3D floors have the ceiling backwards + if (frontsector->ceilingplane.fC() > 0) // 3D floors have the ceiling backwards planeside = -planeside; if (planeside <= 0) // below view plane markceiling = false; From c2e291039996f49e06da2cca0725cd0d8e945395 Mon Sep 17 00:00:00 2001 From: Christoph Oelckers Date: Wed, 30 Mar 2016 10:08:06 +0200 Subject: [PATCH 09/13] - fixed copy/paste error in P_GetFriction resulting in incorrect calculation of movefactor. --- src/actor.h | 2 +- src/p_map.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/actor.h b/src/actor.h index 9f9f5efb8e..4380564fbb 100644 --- a/src/actor.h +++ b/src/actor.h @@ -1305,7 +1305,7 @@ public: { return Z() < checkz - Z_Epsilon; } - bool isAtZ(double checkz) + bool isAtZ(double checkz) const { return fabs(Z() - checkz) < Z_Epsilon; } diff --git a/src/p_map.cpp b/src/p_map.cpp index bd19a228f7..36e9aeb3f7 100644 --- a/src/p_map.cpp +++ b/src/p_map.cpp @@ -557,7 +557,7 @@ double P_GetFriction(const AActor *mo, double *frictionfactor) if (rover->flags & FF_SOLID) { // Must be standing on a solid floor - if (mo->Z() != rover->top.plane->ZatPoint(pos)) continue; + if (!mo->isAtZ(rover->top.plane->ZatPoint(pos))) continue; } else if (rover->flags & FF_SWIMMABLE) { @@ -573,7 +573,7 @@ double P_GetFriction(const AActor *mo, double *frictionfactor) if (newfriction < friction || friction == ORIG_FRICTION) { friction = newfriction; - movefactor = newmf * 0.5; + movefactor = newmf; } } From ced30e7bbb5e3f12071f5ca88fe799a40e02ae02 Mon Sep 17 00:00:00 2001 From: Christoph Oelckers Date: Wed, 30 Mar 2016 11:25:02 +0200 Subject: [PATCH 10/13] - fixed a few oversights. - switched p_buildmap to use the floating point variants of the linedef/sector init methods. --- src/d_netinfo.cpp | 33 ----------------------- src/dsectoreffect.h | 17 ------------ src/p_acs.cpp | 4 +-- src/p_buildmap.cpp | 66 ++++++++++++++++++++++----------------------- src/p_floor.cpp | 2 +- src/p_map.cpp | 6 ++--- src/r_defs.h | 38 ++++++++++++++++++++++++++ 7 files changed, 77 insertions(+), 89 deletions(-) diff --git a/src/d_netinfo.cpp b/src/d_netinfo.cpp index 012dea399b..c20b2aff6c 100644 --- a/src/d_netinfo.cpp +++ b/src/d_netinfo.cpp @@ -878,33 +878,6 @@ void D_ReadUserInfoStrings (int pnum, BYTE **stream, bool update) *stream += strlen (*((char **)stream)) + 1; } -void ReadCompatibleUserInfo(FArchive &arc, userinfo_t &info) -{ - char netname[MAXPLAYERNAME + 1]; - BYTE team; - int aimdist, color, colorset, skin, gender; - bool neverswitch; - //fxed_t movebob, stillbob; These were never serialized! - //int playerclass; " - - info.Reset(); - - arc.Read(&netname, sizeof(netname)); - arc << team << aimdist << color << skin << gender << neverswitch << colorset; - - *static_cast(info[NAME_Name]) = netname; - *static_cast(info[NAME_Team]) = team; - *static_cast(info[NAME_Autoaim]) = ANGLE2FLOAT(aimdist); - *static_cast(info[NAME_Skin]) = skin; - *static_cast(info[NAME_Gender]) = gender; - *static_cast(info[NAME_NeverSwitchOnPickup]) = neverswitch; - *static_cast(info[NAME_ColorSet]) = colorset; - - UCVarValue val; - val.Int = color; - static_cast(info[NAME_Color])->SetGenericRep(val, CVAR_Int); -} - void WriteUserInfo(FArchive &arc, userinfo_t &info) { TMapIterator it(info); @@ -945,12 +918,6 @@ void ReadUserInfo(FArchive &arc, userinfo_t &info, FString &skin) char *str = NULL; UCVarValue val; - if (SaveVersion < 4253) - { - ReadCompatibleUserInfo(arc, info); - return; - } - info.Reset(); skin = NULL; for (arc << name; name != NAME_None; arc << name) diff --git a/src/dsectoreffect.h b/src/dsectoreffect.h index 6e52d27422..bbafd898d5 100644 --- a/src/dsectoreffect.h +++ b/src/dsectoreffect.h @@ -37,23 +37,6 @@ protected: void Serialize (FArchive &arc); void Destroy(); void StopInterpolation(bool force = false); - inline EResult MoveFloor(fixed_t speed, fixed_t dest, int crush, int direction, bool hexencrush) - { - return MovePlane(FIXED2DBL(speed), FIXED2DBL(dest), crush, 0, direction, hexencrush); - } - inline EResult MoveFloor(fixed_t speed, fixed_t dest, int direction) - { - return MovePlane(FIXED2DBL(speed), FIXED2DBL(dest), -1, 0, direction, false); - } - inline EResult MoveCeiling(fixed_t speed, fixed_t dest, int crush, int direction, bool hexencrush) - { - return MovePlane(FIXED2DBL(speed), FIXED2DBL(dest), crush, 1, direction, hexencrush); - } - inline EResult MoveCeiling(fixed_t speed, fixed_t dest, int direction) - { - return MovePlane(FIXED2DBL(speed), FIXED2DBL(dest), -1, 1, direction, false); - } - inline EResult MoveFloor (double speed, double dest, int crush, int direction, bool hexencrush) { return MovePlane (speed, dest, crush, 0, direction, hexencrush); diff --git a/src/p_acs.cpp b/src/p_acs.cpp index bffe01bfd0..6fb16aefcd 100644 --- a/src/p_acs.cpp +++ b/src/p_acs.cpp @@ -4620,7 +4620,7 @@ static void SetUserVariable(AActor *self, FName varname, int index, int value) } else { - type->SetValue(addr, FIXED2DBL(value)); + type->SetValue(addr, ACSToDouble(value)); } } } @@ -4634,7 +4634,7 @@ static int GetUserVariable(AActor *self, FName varname, int index) { if (type->IsKindOf(RUNTIME_CLASS(PFloat))) { - return FLOAT2FIXED(type->GetValueFloat(addr)); + return DoubleToACS(type->GetValueFloat(addr)); } else if (type->IsA(RUNTIME_CLASS(PName))) { diff --git a/src/p_buildmap.cpp b/src/p_buildmap.cpp index c98a5463e9..f7adf2cdd8 100644 --- a/src/p_buildmap.cpp +++ b/src/p_buildmap.cpp @@ -402,19 +402,21 @@ static void LoadSectors (sectortype *bsec) bsec->floorstat = WORD(bsec->floorstat); sec->e = §ors[0].e[i]; - sec->SetPlaneTexZ(sector_t::floor, -(LittleLong(bsec->floorZ) << 8)); - sec->floorplane.set(0, 0, -FRACUNIT, -sec->GetPlaneTexZ(sector_t::floor)); + double floorheight = -LittleLong(bsec->floorZ) / 256.; + sec->SetPlaneTexZ(sector_t::floor, floorheight); + sec->floorplane.SetAtHeight(floorheight, sector_t::floor); mysnprintf (tnam, countof(tnam), "BTIL%04d", LittleShort(bsec->floorpicnum)); sec->SetTexture(sector_t::floor, TexMan.GetTexture (tnam, FTexture::TEX_Build)); - sec->SetXScale(sector_t::floor, (bsec->floorstat & 8) ? FRACUNIT*2 : FRACUNIT); - sec->SetYScale(sector_t::floor, (bsec->floorstat & 8) ? FRACUNIT*2 : FRACUNIT); - sec->SetXOffset(sector_t::floor, (bsec->floorxpanning << FRACBITS) + (32 << FRACBITS)); - sec->SetYOffset(sector_t::floor, bsec->floorypanning << FRACBITS); + sec->SetXScale(sector_t::floor, (bsec->floorstat & 8) ? 2. : 1.); + sec->SetYScale(sector_t::floor, (bsec->floorstat & 8) ? 2. : 1.); + sec->SetXOffset(sector_t::floor, bsec->floorxpanning + 32.); + sec->SetYOffset(sector_t::floor, bsec->floorypanning + 0.); sec->SetPlaneLight(sector_t::floor, SHADE2LIGHT (bsec->floorshade)); sec->ChangeFlags(sector_t::floor, 0, PLANEF_ABSLIGHTING); - sec->SetPlaneTexZ(sector_t::ceiling, -(LittleLong(bsec->ceilingZ) << 8)); - sec->ceilingplane.set(0, 0, -FRACUNIT, sec->GetPlaneTexZ(sector_t::ceiling)); + double ceilingheight = -LittleLong(bsec->ceilingZ) / 256.; + sec->SetPlaneTexZ(sector_t::ceiling, ceilingheight); + sec->ceilingplane.SetAtHeight(ceilingheight, sector_t::ceiling); mysnprintf (tnam, countof(tnam), "BTIL%04d", LittleShort(bsec->ceilingpicnum)); sec->SetTexture(sector_t::ceiling, TexMan.GetTexture (tnam, FTexture::TEX_Build)); if (bsec->ceilingstat & 1) @@ -422,10 +424,10 @@ static void LoadSectors (sectortype *bsec) sky1texture = sky2texture = sec->GetTexture(sector_t::ceiling); sec->SetTexture(sector_t::ceiling, skyflatnum); } - sec->SetXScale(sector_t::ceiling, (bsec->ceilingstat & 8) ? FRACUNIT*2 : FRACUNIT); - sec->SetYScale(sector_t::ceiling, (bsec->ceilingstat & 8) ? FRACUNIT*2 : FRACUNIT); - sec->SetXOffset(sector_t::ceiling, (bsec->ceilingxpanning << FRACBITS) + (32 << FRACBITS)); - sec->SetYOffset(sector_t::ceiling, bsec->ceilingypanning << FRACBITS); + sec->SetXScale(sector_t::ceiling, (bsec->ceilingstat & 8) ? 2. : 1.); + sec->SetYScale(sector_t::ceiling, (bsec->ceilingstat & 8) ? 2. : 1.); + sec->SetXOffset(sector_t::ceiling, bsec->ceilingxpanning + 32.); + sec->SetYOffset(sector_t::ceiling, bsec->ceilingypanning + 0.); sec->SetPlaneLight(sector_t::ceiling, SHADE2LIGHT (bsec->ceilingshade)); sec->ChangeFlags(sector_t::ceiling, 0, PLANEF_ABSLIGHTING); @@ -444,30 +446,30 @@ static void LoadSectors (sectortype *bsec) if (bsec->floorstat & 4) { - sec->SetAngle(sector_t::floor, ANGLE_90); - sec->SetXScale(sector_t::floor, -sec->GetXScale(sector_t::floor)); + sec->SetAngle(sector_t::floor, DAngle(90.)); + sec->SetXScale(sector_t::floor, -sec->GetXScaleF(sector_t::floor)); } if (bsec->floorstat & 16) { - sec->SetXScale(sector_t::floor, -sec->GetXScale(sector_t::floor)); + sec->SetXScale(sector_t::floor, -sec->GetXScaleF(sector_t::floor)); } if (bsec->floorstat & 32) { - sec->SetYScale(sector_t::floor, -sec->GetYScale(sector_t::floor)); + sec->SetYScale(sector_t::floor, -sec->GetYScaleF(sector_t::floor)); } if (bsec->ceilingstat & 4) { - sec->SetAngle(sector_t::ceiling, ANGLE_90); - sec->SetYScale(sector_t::ceiling, -sec->GetYScale(sector_t::ceiling)); + sec->SetAngle(sector_t::ceiling, DAngle(90.)); + sec->SetYScale(sector_t::ceiling, -sec->GetYScaleF(sector_t::ceiling)); } if (bsec->ceilingstat & 16) { - sec->SetXScale(sector_t::ceiling, -sec->GetXScale(sector_t::ceiling)); + sec->SetXScale(sector_t::ceiling, -sec->GetXScaleF(sector_t::ceiling)); } if (bsec->ceilingstat & 32) { - sec->SetYScale(sector_t::ceiling, -sec->GetYScale(sector_t::ceiling)); + sec->SetYScale(sector_t::ceiling, -sec->GetYScaleF(sector_t::ceiling)); } } } @@ -523,8 +525,8 @@ static void LoadWalls (walltype *walls, int numwalls, sectortype *bsec) walls[i].nextwall = LittleShort(walls[i].nextwall); walls[i].nextsector = LittleShort(walls[i].nextsector); - sides[i].SetTextureXOffset(walls[i].xpanning << FRACBITS); - sides[i].SetTextureYOffset(walls[i].ypanning << FRACBITS); + sides[i].SetTextureXOffset((double)walls[i].xpanning); + sides[i].SetTextureYOffset((double)walls[i].ypanning); sides[i].SetTexture(side_t::top, pic); sides[i].SetTexture(side_t::bottom, pic); @@ -542,8 +544,8 @@ static void LoadWalls (walltype *walls, int numwalls, sectortype *bsec) } sides[i].TexelLength = walls[i].xrepeat * 8; - sides[i].SetTextureYScale(walls[i].yrepeat << (FRACBITS - 3)); - sides[i].SetTextureXScale(FRACUNIT); + sides[i].SetTextureYScale(walls[i].yrepeat / 8.); + sides[i].SetTextureXScale(1.); sides[i].SetLight(SHADE2LIGHT(walls[i].shade)); sides[i].Flags = WALLF_ABSLIGHTING; sides[i].RightSide = walls[i].point2; @@ -751,16 +753,16 @@ static int LoadSprites (spritetype *sprites, Xsprite *xsprites, int numsprites, // //========================================================================== -vertex_t *FindVertex (SDWORD x, SDWORD y) +vertex_t *FindVertex (SDWORD xx, SDWORD yy) { int i; - x <<= 12; - y = -(y << 12); + double x = xx / 64.; + double y = -yy / 64.; for (i = 0; i < numvertexes; ++i) { - if (vertexes[i].fixX() == x && vertexes[i].fixY() == y) + if (vertexes[i].fX() == x && vertexes[i].fY() == y) { return &vertexes[i]; } @@ -814,8 +816,7 @@ static void CalcPlane (SlopeWork &slope, secplane_t &plane) slope.x[2] = slope.x[0]; slope.y[2] = slope.y[0] + 64; } - j = DMulScale3 (slope.dx, slope.y[2]-slope.wal->y, - -slope.dy, slope.x[2]-slope.wal->x); + j = DMulScale3 (slope.dx, slope.y[2]-slope.wal->y, -slope.dy, slope.x[2]-slope.wal->x); slope.z[2] += Scale (slope.heinum, j, slope.i); pt[0] = DVector3(slope.dx, -slope.dy, 0); @@ -827,9 +828,8 @@ static void CalcPlane (SlopeWork &slope, secplane_t &plane) pt[2] = -pt[2]; } - plane.set(pt[2][0], pt[2][1], pt[2][2], 0.); - plane.setD(-TMulScale8 - (plane.fixA(), slope.x[0]<<4, plane.fixB(), (-slope.y[0])<<4, plane.fixC(), slope.z[0])); + double dist = -pt[2][0] * slope.x[0] * 16 + pt[2][1] * slope.y[0] * 16 - pt[2][2] * slope.z[0]; + plane.set(pt[2][0], pt[2][1], pt[2][2], dist); } //========================================================================== diff --git a/src/p_floor.cpp b/src/p_floor.cpp index 54b66a8a83..9588e8e1ce 100644 --- a/src/p_floor.cpp +++ b/src/p_floor.cpp @@ -435,7 +435,7 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag, case DFloor::floorRaiseAndChange: floor->m_Direction = 1; - newheight = sec->_f_CenterFloor() + height; + newheight = sec->CenterFloor() + height; floor->m_FloorDestDist = sec->floorplane.PointToDist (sec->centerspot, newheight); if (line != NULL) { diff --git a/src/p_map.cpp b/src/p_map.cpp index 36e9aeb3f7..a2e7603d3f 100644 --- a/src/p_map.cpp +++ b/src/p_map.cpp @@ -2122,12 +2122,12 @@ bool P_TryMove(AActor *thing, const DVector2 &pos, // it slopes or the player's eyes are bobbing in and out. bool oldAboveFakeFloor, oldAboveFakeCeiling; - double _viewheight = thing->player ? thing->player->viewheight : thing->Height / 2; + double viewheight = thing->player ? thing->player->viewheight : thing->Height / 2; oldAboveFakeFloor = oldAboveFakeCeiling = false; // pacify GCC if (oldsec->heightsec) { - double eyez = oldz + FIXED2DBL(viewheight); + double eyez = oldz + viewheight; oldAboveFakeFloor = eyez > oldsec->heightsec->floorplane.ZatPoint(thing); oldAboveFakeCeiling = eyez > oldsec->heightsec->ceilingplane.ZatPoint(thing); @@ -2333,7 +2333,7 @@ bool P_TryMove(AActor *thing, const DVector2 &pos, if (newsec->heightsec && oldsec->heightsec && newsec->SecActTarget) { const sector_t *hs = newsec->heightsec; - double eyez = thing->Z() + FIXED2DBL(viewheight); + double eyez = thing->Z() + viewheight; double fakez = hs->floorplane.ZatPoint(pos); if (!oldAboveFakeFloor && eyez > fakez) diff --git a/src/r_defs.h b/src/r_defs.h index cd77381830..6d808618ed 100644 --- a/src/r_defs.h +++ b/src/r_defs.h @@ -810,6 +810,11 @@ struct sector_t planes[pos].xform.xscale = o; } + void SetXScale(int pos, double o) + { + planes[pos].xform.xscale = FLOAT2FIXED(o); + } + fixed_t GetXScale(int pos) const { return planes[pos].xform.xscale; @@ -825,6 +830,11 @@ struct sector_t planes[pos].xform.yscale = o; } + void SetYScale(int pos, double o) + { + planes[pos].xform.yscale = FLOAT2FIXED(o); + } + fixed_t GetYScale(int pos) const { return planes[pos].xform.yscale; @@ -1267,6 +1277,16 @@ struct side_t textures[mid].xoffset = textures[bottom].xoffset = offset; } + void SetTextureXOffset(int which, double offset) + { + textures[which].xoffset = FLOAT2FIXED(offset); + } + void SetTextureXOffset(double offset) + { + textures[top].xoffset = + textures[mid].xoffset = + textures[bottom].xoffset = FLOAT2FIXED(offset); + } fixed_t GetTextureXOffset(int which) const { return textures[which].xoffset; @@ -1294,6 +1314,16 @@ struct side_t textures[mid].yoffset = textures[bottom].yoffset = offset; } + void SetTextureYOffset(int which, double offset) + { + textures[which].yoffset = FLOAT2FIXED(offset); + } + void SetTextureYOffset(double offset) + { + textures[top].yoffset = + textures[mid].yoffset = + textures[bottom].yoffset = FLOAT2FIXED(offset); + } fixed_t GetTextureYOffset(int which) const { return textures[which].yoffset; @@ -1319,6 +1349,10 @@ struct side_t { textures[top].xscale = textures[mid].xscale = textures[bottom].xscale = scale == 0 ? FRACUNIT : scale; } + void SetTextureXScale(double scale) + { + textures[top].xscale = textures[mid].xscale = textures[bottom].xscale = scale == 0 ? FRACUNIT : FLOAT2FIXED(scale); + } fixed_t GetTextureXScale(int which) const { return textures[which].xscale; @@ -1343,6 +1377,10 @@ struct side_t { textures[top].yscale = textures[mid].yscale = textures[bottom].yscale = scale == 0 ? FRACUNIT : scale; } + void SetTextureYScale(double scale) + { + textures[top].yscale = textures[mid].yscale = textures[bottom].yscale = scale == 0 ? FRACUNIT : FLOAT2FIXED(scale); + } fixed_t GetTextureYScale(int which) const { return textures[which].yscale; From 66929cbaffced136ed8f2d7dde65bf932da55fb7 Mon Sep 17 00:00:00 2001 From: Christoph Oelckers Date: Wed, 30 Mar 2016 16:30:22 +0200 Subject: [PATCH 11/13] - floatified p_trace, p_slopes and p_udmf.cpp. - major cleanup of unused code. --- src/actor.h | 17 +-- src/am_map.cpp | 4 +- src/b_move.cpp | 2 +- src/c_cmds.cpp | 6 +- src/doomdata.h | 4 - src/f_wipe.cpp | 11 +- src/m_fixed.h | 31 +++-- src/p_acs.cpp | 6 +- src/p_effect.cpp | 6 +- src/p_enemy.cpp | 2 +- src/p_local.h | 20 +--- src/p_map.cpp | 2 +- src/p_maputl.cpp | 5 +- src/p_setup.h | 2 +- src/p_slopes.cpp | 138 +++++++++------------- src/p_trace.cpp | 256 ++++++++++++++++------------------------ src/p_trace.h | 16 +-- src/p_udmf.cpp | 111 +++++++++-------- src/p_udmf.h | 3 +- src/p_user.cpp | 1 - src/po_man.cpp | 2 +- src/r_3dfloors.cpp | 4 +- src/r_bsp.cpp | 4 +- src/r_defs.h | 31 +---- src/r_draw.cpp | 2 +- src/r_plane.cpp | 12 +- src/r_segs.cpp | 8 +- src/r_things.cpp | 22 ++-- src/r_utility.cpp | 18 +-- src/s_sndseq.cpp | 19 +-- src/s_sound.cpp | 2 +- src/textures/textures.h | 1 + src/v_draw.cpp | 4 +- src/vectors.h | 103 +++++----------- src/win32/fb_d3d9.cpp | 4 +- 35 files changed, 350 insertions(+), 529 deletions(-) diff --git a/src/actor.h b/src/actor.h index 4380564fbb..e8f871b029 100644 --- a/src/actor.h +++ b/src/actor.h @@ -850,11 +850,7 @@ public: return VecToAngle(otherpos - Pos().XY()); } - DAngle AngleTo(AActor *other, fixed_t oxofs, fixed_t oyofs, bool absolute = false) const - { - fixedvec3 otherpos = absolute ? other->_f_Pos() : other->_f_PosRelative(this); - return VecToAngle(otherpos.x + oxofs - _f_X(), otherpos.y + oyofs - _f_Y()); - } + DAngle AngleTo(AActor *other, fixed_t oxofs, fixed_t oyofs, bool absolute = false) const = delete; DAngle AngleTo(AActor *other, double oxofs, double oyofs, bool absolute = false) const { @@ -1008,12 +1004,6 @@ public: double Speed; double FloatSpeed; - // intentionally stange names so that searching for them is easier. - angle_t _f_angle() { return FLOAT2ANGLE(Angles.Yaw.Degrees); } - int _f_pitch() { return FLOAT2ANGLE(Angles.Pitch.Degrees); } - fixed_t _f_speed() { return FLOAT2FIXED(Speed); } - - WORD sprite; // used to find patch_t and flip value BYTE frame; // sprite frame to draw DVector2 Scale; // Scaling values; 1 is normal size @@ -1310,11 +1300,6 @@ public: return fabs(Z() - checkz) < Z_Epsilon; } - fixedvec3 _f_PosRelative(int grp) const; - fixedvec3 _f_PosRelative(const AActor *other) const; - fixedvec3 _f_PosRelative(sector_t *sec) const; - fixedvec3 _f_PosRelative(line_t *line) const; - DVector3 PosRelative(int grp) const; DVector3 PosRelative(const AActor *other) const; DVector3 PosRelative(sector_t *sec) const; diff --git a/src/am_map.cpp b/src/am_map.cpp index a07556ccc3..0c1f837cfc 100644 --- a/src/am_map.cpp +++ b/src/am_map.cpp @@ -2533,8 +2533,8 @@ void AM_rotate(double *xp, double *yp, DAngle a) if (angle_saved != a) { angle_saved = a; - sinrot = sin(ToRadians(a)); - cosrot = cos(ToRadians(a)); + sinrot = sin(a.Radians()); + cosrot = cos(a.Radians()); } double x = *xp; diff --git a/src/b_move.cpp b/src/b_move.cpp index 643002968f..b31e4acbef 100644 --- a/src/b_move.cpp +++ b/src/b_move.cpp @@ -350,7 +350,7 @@ void DBot::Pitch (AActor *target) diff = target->Z() - player->mo->Z(); aim = g_atan(diff / player->mo->Distance2D(target)); - player->mo->Angles.Pitch = ToDegrees(aim); + player->mo->Angles.Pitch = DAngle::ToDegrees(aim); } //Checks if a sector is dangerous. diff --git a/src/c_cmds.cpp b/src/c_cmds.cpp index 2ebaca1f6f..aed83658ba 100644 --- a/src/c_cmds.cpp +++ b/src/c_cmds.cpp @@ -1244,9 +1244,9 @@ CCMD(angleconvtest) Printf("Testing degrees to angle conversion:\n"); for (double ang = -5 * 180.; ang < 5 * 180.; ang += 45.) { - angle_t ang1 = FLOAT2ANGLE(ang); - angle_t ang2 = (angle_t)(ang * (ANGLE_90 / 90.)); - angle_t ang3 = (angle_t)(int)(ang * (ANGLE_90 / 90.)); + unsigned ang1 = DAngle(ang).BAMs(); + unsigned ang2 = (unsigned)(ang * (0x40000000 / 90.)); + unsigned ang3 = (unsigned)(int)(ang * (0x40000000 / 90.)); Printf("Angle = %.5f: xs_RoundToInt = %08x, unsigned cast = %08x, signed cast = %08x\n", ang, ang1, ang2, ang3); } diff --git a/src/doomdata.h b/src/doomdata.h index 9c86e4f3c5..4e4976800a 100644 --- a/src/doomdata.h +++ b/src/doomdata.h @@ -435,10 +435,6 @@ struct FPlayerStart angle(mthing->angle), type(pnum) { } - - fixed_t _f_X() { return FLOAT2FIXED(pos.X); } - fixed_t _f_Y() { return FLOAT2FIXED(pos.Y); } - fixed_t _f_Z() { return FLOAT2FIXED(pos.Z); } }; // Player spawn spots for deathmatch. extern TArray deathmatchstarts; diff --git a/src/f_wipe.cpp b/src/f_wipe.cpp index b81aecb388..a3ceb8d508 100644 --- a/src/f_wipe.cpp +++ b/src/f_wipe.cpp @@ -269,12 +269,13 @@ bool wipe_doBurn (int ticks) } // Draw the screen - fixed_t xstep, ystep, firex, firey; + int xstep, ystep, firex, firey; int x, y; BYTE *to, *fromold, *fromnew; + const int SHIFT = 16; - xstep = (FIREWIDTH * FRACUNIT) / SCREENWIDTH; - ystep = (FIREHEIGHT * FRACUNIT) / SCREENHEIGHT; + xstep = (FIREWIDTH << SHIFT) / SCREENWIDTH; + ystep = (FIREHEIGHT << SHIFT) / SCREENHEIGHT; to = screen->GetBuffer(); fromold = (BYTE *)wipe_scr_start; fromnew = (BYTE *)wipe_scr_end; @@ -285,7 +286,7 @@ bool wipe_doBurn (int ticks) { int fglevel; - fglevel = burnarray[(firex>>FRACBITS)+(firey>>FRACBITS)*FIREWIDTH] / 2; + fglevel = burnarray[(firex>>SHIFT)+(firey>>SHIFT)*FIREWIDTH] / 2; if (fglevel >= 63) { to[x] = fromnew[x]; @@ -340,7 +341,7 @@ bool wipe_doFade (int ticks) else { int x, y; - fixed_t bglevel = 64 - fade; + int bglevel = 64 - fade; DWORD *fg2rgb = Col2RGB8[fade]; DWORD *bg2rgb = Col2RGB8[bglevel]; BYTE *fromnew = (BYTE *)wipe_scr_end; diff --git a/src/m_fixed.h b/src/m_fixed.h index 58d13123af..1a2e8b7803 100644 --- a/src/m_fixed.h +++ b/src/m_fixed.h @@ -136,17 +136,30 @@ inline SDWORD ModDiv (SDWORD num, SDWORD den, SDWORD *dmval) return num % den; } +inline fixed_t FloatToFixed(double f) +{ + return xs_Fix<16>::ToFix(f); +} -#define FLOAT2FIXED(f) ((fixed_t)xs_Fix<16>::ToFix(f)) -#define FIXED2FLOAT(f) ((f) / float(65536)) -#define FIXED2DBL(f) ((f) / double(65536)) +inline double FixedToFloat(fixed_t f) +{ + return f / 65536.; +} -#define ANGLE2DBL(f) ((f) * (90./ANGLE_90)) -#define ANGLE2FLOAT(f) (float((f) * (90./ANGLE_90))) -#define FLOAT2ANGLE(f) ((angle_t)xs_CRoundToInt((f) * (ANGLE_90/90.))) +inline unsigned FloatToAngle(double f) +{ + return xs_CRoundToInt((f)* (0x40000000 / 90.)); +} -#define ANGLE2RAD(f) ((f) * (M_PI/ANGLE_180)) -#define ANGLE2RADF(f) ((f) * float(M_PI/ANGLE_180)) -#define RAD2ANGLE(f) ((angle_t)xs_CRoundToInt((f) * (ANGLE_180/M_PI))) +inline double AngleToFloat(unsigned f) +{ + return f * (90. / 0x40000000); +} + +#define FLOAT2FIXED(f) FloatToFixed(f) +#define FIXED2FLOAT(f) float(FixedToFloat(f)) +#define FIXED2DBL(f) FixedToFloat(f) + +#define ANGLE2DBL(f) AngleToFloat(f) #endif diff --git a/src/p_acs.cpp b/src/p_acs.cpp index 6fb16aefcd..d287a47bdb 100644 --- a/src/p_acs.cpp +++ b/src/p_acs.cpp @@ -4949,7 +4949,7 @@ int DLevelScript::CallFunction(int argCount, int funcIndex, SDWORD *args) return GetUDMFInt(UDMF_Line, LineFromID(args[0]), FBehavior::StaticLookupString(args[1])); case ACSF_GetLineUDMFFixed: - return GetUDMFFixed(UDMF_Line, LineFromID(args[0]), FBehavior::StaticLookupString(args[1])); + return DoubleToACS(GetUDMFFloat(UDMF_Line, LineFromID(args[0]), FBehavior::StaticLookupString(args[1]))); case ACSF_GetThingUDMFInt: case ACSF_GetThingUDMFFixed: @@ -4959,13 +4959,13 @@ int DLevelScript::CallFunction(int argCount, int funcIndex, SDWORD *args) return GetUDMFInt(UDMF_Sector, P_FindFirstSectorFromTag(args[0]), FBehavior::StaticLookupString(args[1])); case ACSF_GetSectorUDMFFixed: - return GetUDMFFixed(UDMF_Sector, P_FindFirstSectorFromTag(args[0]), FBehavior::StaticLookupString(args[1])); + return DoubleToACS(GetUDMFFloat(UDMF_Sector, P_FindFirstSectorFromTag(args[0]), FBehavior::StaticLookupString(args[1]))); case ACSF_GetSideUDMFInt: return GetUDMFInt(UDMF_Side, SideFromID(args[0], args[1]), FBehavior::StaticLookupString(args[2])); case ACSF_GetSideUDMFFixed: - return GetUDMFFixed(UDMF_Side, SideFromID(args[0], args[1]), FBehavior::StaticLookupString(args[2])); + return DoubleToACS(GetUDMFFloat(UDMF_Side, SideFromID(args[0], args[1]), FBehavior::StaticLookupString(args[2]))); case ACSF_GetActorVelX: actor = SingleActorFromTID(args[0], activator); diff --git a/src/p_effect.cpp b/src/p_effect.cpp index 11e09e5dd4..3bbf165021 100644 --- a/src/p_effect.cpp +++ b/src/p_effect.cpp @@ -883,9 +883,9 @@ void P_DisconnectEffect (AActor *actor) break; - fixed_t xo = ((M_Random() - 128) << 9) * (actor->_f_radius() >> FRACBITS); - fixed_t yo = ((M_Random() - 128) << 9) * (actor->_f_radius() >> FRACBITS); - fixed_t zo = (M_Random() << 8) * (actor->_f_height() >> FRACBITS); + fixed_t xo = ((M_Random() - 128) << 9) * int(actor->radius); + fixed_t yo = ((M_Random() - 128) << 9) * int(actor->radius); + fixed_t zo = (M_Random() << 8) * int(actor->Height); fixedvec3 pos = actor->Vec3Offset(xo, yo, zo); p->x = pos.x; p->y = pos.y; diff --git a/src/p_enemy.cpp b/src/p_enemy.cpp index 4e62b09c11..67ebdbfca9 100644 --- a/src/p_enemy.cpp +++ b/src/p_enemy.cpp @@ -2874,7 +2874,7 @@ void A_Face(AActor *self, AActor *other, DAngle max_turn, DAngle max_pitch, DAng double dist_z = target_z - source_z; double ddist = g_sqrt(dist.X*dist.X + dist.Y*dist.Y + dist_z*dist_z); - DAngle other_pitch = DAngle(ToDegrees(g_asin(dist_z / ddist))).Normalized180(); + DAngle other_pitch = DAngle::ToDegrees(g_asin(dist_z / ddist)).Normalized180(); if (max_pitch != 0) { diff --git a/src/p_local.h b/src/p_local.h index fec4a636db..e8a18742e8 100644 --- a/src/p_local.h +++ b/src/p_local.h @@ -293,10 +293,7 @@ enum void P_FindFloorCeiling (AActor *actor, int flags=0); bool P_ChangeSector (sector_t* sector, int crunch, double amt, int floorOrCeil, bool isreset); -inline bool P_ChangeSector(sector_t* sector, int crunch, int amt, int floorOrCeil, bool isreset) -{ - return P_ChangeSector(sector, crunch, FIXED2DBL(amt), floorOrCeil, isreset); -} +inline bool P_ChangeSector(sector_t* sector, int crunch, int amt, int floorOrCeil, bool isreset) = delete; DAngle P_AimLineAttack(AActor *t1, DAngle angle, double distance, FTranslatedLineTarget *pLineTarget = NULL, DAngle vrange = 0., int flags = 0, AActor *target = NULL, AActor *friender = NULL); @@ -328,11 +325,7 @@ void P_TraceBleed(int damage, FTranslatedLineTarget *t, AActor *puff); // hitsc void P_TraceBleed (int damage, AActor *target); // random direction version bool P_HitFloor (AActor *thing); bool P_HitWater (AActor *thing, sector_t *sec, const DVector3 &pos, bool checkabove = false, bool alert = true, bool force = false); -inline bool P_HitWater(AActor *thing, sector_t *sec, const fixedvec3 &pos, bool checkabove = false, bool alert = true, bool force = false) -{ - DVector3 fpos(FIXED2DBL(pos.x), FIXED2DBL(pos.y), FIXED2DBL(pos.z)); - return P_HitWater(thing, sec, fpos, checkabove, alert, force); -} +inline bool P_HitWater(AActor *thing, sector_t *sec, const fixedvec3 &pos, bool checkabove = false, bool alert = true, bool force = false) = delete; void P_CheckSplash(AActor *self, double distance); struct FRailParams @@ -396,14 +389,7 @@ bool Check_Sides(AActor *, int, int); // phares // [RH] const secplane_t * P_CheckSlopeWalk(AActor *actor, DVector2 &move); -inline const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymove) -{ - DVector2 move = { FIXED2DBL(xmove), FIXED2DBL(ymove) }; - const secplane_t *ret = P_CheckSlopeWalk(actor, move); - xmove = FLOAT2FIXED(move.X); - ymove = FLOAT2FIXED(move.Y); - return ret; -} +inline const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymove) = delete; // // P_SETUP diff --git a/src/p_map.cpp b/src/p_map.cpp index a2e7603d3f..71cca8303a 100644 --- a/src/p_map.cpp +++ b/src/p_map.cpp @@ -4411,7 +4411,7 @@ void P_TraceBleed(int damage, AActor *target, AActor *missile) double aim; aim = g_atan(missile->Vel.Z / target->Distance2D(missile)); - pitch = -ToDegrees(aim); + pitch = -DAngle::ToDegrees(aim); } else { diff --git a/src/p_maputl.cpp b/src/p_maputl.cpp index 39953bf665..f6246b7a43 100644 --- a/src/p_maputl.cpp +++ b/src/p_maputl.cpp @@ -427,7 +427,7 @@ bool AActor::FixMapthingPos() DPrintf("%s at (%f,%f) lies on %s line %td, distance = %f\n", this->GetClass()->TypeName.GetChars(), X(), Y(), ldef->Delta().X == 0 ? "vertical" : ldef->Delta().Y == 0 ? "horizontal" : "diagonal", - ldef - lines, FIXED2DBL(distance)); + ldef - lines, distance); DAngle ang = ldef->Delta().Angle(); if (ldef->backsector != NULL && ldef->backsector == secstart) { @@ -519,7 +519,8 @@ void AActor::LinkToWorld(bool spawningmapthing, sector_t *sector) for (int i = -1; i < (int)check.Size(); i++) { - fixedvec3 pos = i==-1? _f_Pos() : _f_PosRelative(check[i]); + DVector3 _pos = i==-1? Pos() : PosRelative(check[i]); + fixedvec3 pos = { FLOAT2FIXED(_pos.X), FLOAT2FIXED(_pos.Y),FLOAT2FIXED(_pos.Z) }; int x1 = GetSafeBlockX(pos.x - _f_radius() - bmaporgx); int x2 = GetSafeBlockX(pos.x + _f_radius() - bmaporgx); diff --git a/src/p_setup.h b/src/p_setup.h index 321e0bc119..38d61c1eb1 100644 --- a/src/p_setup.h +++ b/src/p_setup.h @@ -119,7 +119,7 @@ void P_TranslateLineDef (line_t *ld, maplinedef_t *mld, int lineindexforid = -1) int P_TranslateSectorSpecial (int); int GetUDMFInt(int type, int index, const char *key); -fixed_t GetUDMFFixed(int type, int index, const char *key); +double GetUDMFFloat(int type, int index, const char *key); bool P_LoadGLNodes(MapData * map); bool P_CheckNodes(MapData * map, bool rebuilt, int buildtime); diff --git a/src/p_slopes.cpp b/src/p_slopes.cpp index f2dd4b7861..1ee992d5ec 100644 --- a/src/p_slopes.cpp +++ b/src/p_slopes.cpp @@ -45,7 +45,7 @@ // //=========================================================================== -static void P_SlopeLineToPoint (int lineid, fixed_t x, fixed_t y, fixed_t z, bool slopeCeil) +static void P_SlopeLineToPoint (int lineid, const DVector3 &pos, bool slopeCeil) { int linenum; @@ -56,7 +56,7 @@ static void P_SlopeLineToPoint (int lineid, fixed_t x, fixed_t y, fixed_t z, boo sector_t *sec; secplane_t *plane; - if (P_PointOnLineSidePrecise (x, y, line) == 0) + if (P_PointOnLineSidePrecise (pos, line) == 0) { sec = line->frontsector; } @@ -85,15 +85,15 @@ static void P_SlopeLineToPoint (int lineid, fixed_t x, fixed_t y, fixed_t z, boo v1[0] = line->Delta().X; v1[1] = line->Delta().Y; v1[2] = plane->ZatPoint (line->v2) - p[2]; - v2[0] = FIXED2DBL (x) - p[0]; - v2[1] = FIXED2DBL (y) - p[1]; - v2[2] = FIXED2DBL (z) - p[2]; + v2[0] = pos.X - p[0]; + v2[1] = pos.Y - p[1]; + v2[2] = pos.Z - p[2]; cross = v1 ^ v2; double len = cross.Length(); if (len == 0) { - Printf ("Slope thing at (%d,%d) lies directly on its target line.\n", int(x>>16), int(y>>16)); + Printf ("Slope thing at (%f,%f) lies directly on its target line.\n", pos.X, pos.Y); return; } cross /= len; @@ -103,10 +103,8 @@ static void P_SlopeLineToPoint (int lineid, fixed_t x, fixed_t y, fixed_t z, boo cross = -cross; } - plane->set(cross[0], cross[1], cross[2], 0.); - plane->setD(-TMulScale16 (plane->fixA(), x, - plane->fixB(), y, - plane->fixC(), z)); + double dist = -cross[0] * pos.X - cross[1] * pos.Y - cross[2] * pos.Z; + plane->set(cross[0], cross[1], cross[2], dist); } } @@ -120,7 +118,6 @@ static void P_CopyPlane (int tag, sector_t *dest, bool copyCeil) { sector_t *source; int secnum; - size_t planeofs; secnum = P_FindFirstSectorFromTag (tag); if (secnum == -1) @@ -132,18 +129,17 @@ static void P_CopyPlane (int tag, sector_t *dest, bool copyCeil) if (copyCeil) { - planeofs = myoffsetof(sector_t, ceilingplane); + dest->ceilingplane = source->ceilingplane; } else { - planeofs = myoffsetof(sector_t, floorplane); + dest->floorplane = source->floorplane; } - *(secplane_t *)((BYTE *)dest + planeofs) = *(secplane_t *)((BYTE *)source + planeofs); } -static void P_CopyPlane (int tag, fixed_t x, fixed_t y, bool copyCeil) +static void P_CopyPlane (int tag, const DVector2 &pos, bool copyCeil) { - sector_t *dest = P_PointInSector (x, y); + sector_t *dest = P_PointInSector (pos); P_CopyPlane(tag, dest, copyCeil); } @@ -153,54 +149,47 @@ static void P_CopyPlane (int tag, fixed_t x, fixed_t y, bool copyCeil) // //=========================================================================== -void P_SetSlope (secplane_t *plane, bool setCeil, int xyangi, int zangi, - fixed_t x, fixed_t y, fixed_t z) +void P_SetSlope (secplane_t *plane, bool setCeil, int xyangi, int zangi, const DVector3 &pos) { - angle_t xyang; - angle_t zang; + DAngle xyang; + DAngle zang; if (zangi >= 180) { - zang = ANGLE_180-ANGLE_1; + zang = 179.; } else if (zangi <= 0) { - zang = ANGLE_1; + zang = 1.; } else { - zang = Scale (zangi, ANGLE_90, 90); + zang = (double)zangi; } if (setCeil) { - zang += ANGLE_180; + zang += 180.; } - zang >>= ANGLETOFINESHIFT; - // Sanitize xyangi to [0,360) range - xyangi = xyangi % 360; - if (xyangi < 0) - { - xyangi = 360 + xyangi; - } - xyang = (angle_t)Scale (xyangi, ANGLE_90, 90 << ANGLETOFINESHIFT); + xyang = (double)xyangi; DVector3 norm; if (ib_compatflags & BCOMPATF_SETSLOPEOVERFLOW) { - norm[0] = double(finecosine[zang] * finecosine[xyang]); - norm[1] = double(finecosine[zang] * finesine[xyang]); + // We have to consider an integer multiplication overflow here. + norm[0] = FixedToFloat(FloatToFixed(zang.Cos()) * FloatToFixed(xyang.Cos())); + norm[1] = FixedToFloat(FloatToFixed(zang.Cos()) * FloatToFixed(xyang.Sin())); } else { - norm[0] = double(finecosine[zang]) * double(finecosine[xyang]); - norm[1] = double(finecosine[zang]) * double(finesine[xyang]); + norm[0] = zang.Cos() * xyang.Cos(); + norm[1] = zang.Cos() * xyang.Sin(); } - norm[2] = double(finesine[zang]) * 65536.f; + norm[2] = zang.Sin(); norm.MakeUnit(); - plane->set(norm[0], norm[1], norm[2], 0.); - plane->setD(-TMulScale16(plane->fixA(), x, plane->fixB(), y, plane->fixC(), z)); + double dist = -norm[0] * pos.X - norm[1] * pos.Y - norm[2] * pos.Z; + plane->set(norm[0], norm[1], norm[2], dist); } @@ -210,7 +199,7 @@ void P_SetSlope (secplane_t *plane, bool setCeil, int xyangi, int zangi, // //=========================================================================== -void P_VavoomSlope(sector_t * sec, int id, fixed_t x, fixed_t y, fixed_t z, int which) +void P_VavoomSlope(sector_t * sec, int id, const DVector3 &pos, int which) { for (int i=0;ilinecount;i++) { @@ -220,21 +209,21 @@ void P_VavoomSlope(sector_t * sec, int id, fixed_t x, fixed_t y, fixed_t z, int { DVector3 v1, v2, cross; secplane_t *srcplane = (which == 0) ? &sec->floorplane : &sec->ceilingplane; - fixed_t srcheight = (which == 0) ? sec->GetPlaneTexZ(sector_t::floor) : sec->GetPlaneTexZ(sector_t::ceiling); + double srcheight = (which == 0) ? sec->GetPlaneTexZF(sector_t::floor) : sec->GetPlaneTexZF(sector_t::ceiling); - v1[0] = FIXED2DBL (x - l->v2->fixX()); - v1[1] = FIXED2DBL (y - l->v2->fixY()); - v1[2] = FIXED2DBL (z - srcheight); + v1[0] = pos.X - l->v2->fX(); + v1[1] = pos.Y - l->v2->fY(); + v1[2] = pos.Z - srcheight; - v2[0] = FIXED2DBL (x - l->v1->fixX()); - v2[1] = FIXED2DBL (y - l->v1->fixY()); - v2[2] = FIXED2DBL (z - srcheight); + v2[0] = pos.X - l->v1->fX(); + v2[1] = pos.Y - l->v1->fY(); + v2[2] = pos.Z - srcheight; cross = v1 ^ v2; double len = cross.Length(); if (len == 0) { - Printf ("Slope thing at (%d,%d) lies directly on its target line.\n", int(x>>16), int(y>>16)); + Printf ("Slope thing at (%f,%f) lies directly on its target line.\n", pos.X, pos.Y); return; } cross /= len; @@ -245,8 +234,8 @@ void P_VavoomSlope(sector_t * sec, int id, fixed_t x, fixed_t y, fixed_t z, int cross = -cross; } - srcplane->set(cross[0], cross[1], cross[2], 0.); - srcplane->setD(-TMulScale16(srcplane->fixA(), x, srcplane->fixB(), y, srcplane->fixC(), z)); + double dist = -cross[0] * pos.X - cross[1] * pos.Y - cross[2] * pos.Z; + srcplane->set(cross[0], cross[1], cross[2], dist); return; } } @@ -337,13 +326,13 @@ static void P_SetSlopesFromVertexHeights(FMapThing *firstmt, FMapThing *lastmt, double *h1 = vt_heights[j].CheckKey(vi1); double *h2 = vt_heights[j].CheckKey(vi2); double *h3 = vt_heights[j].CheckKey(vi3); - if (h1==NULL && h2==NULL && h3==NULL) continue; + if (h1 == NULL && h2 == NULL && h3 == NULL) continue; vt1.Z = h1? *h1 : j==0? sec->GetPlaneTexZF(sector_t::floor) : sec->GetPlaneTexZF(sector_t::ceiling); vt2.Z = h2? *h2 : j==0? sec->GetPlaneTexZF(sector_t::floor) : sec->GetPlaneTexZF(sector_t::ceiling); vt3.Z = h3? *h3 : j==0? sec->GetPlaneTexZF(sector_t::floor) : sec->GetPlaneTexZF(sector_t::ceiling); - if (P_PointOnLineSidePrecise(vertexes[vi3].fixX(), vertexes[vi3].fixY(), sec->lines[0]) == 0) + if (P_PointOnLineSidePrecise(vertexes[vi3].fX(), vertexes[vi3].fY(), sec->lines[0]) == 0) { vec1 = vt2 - vt3; vec2 = vt1 - vt3; @@ -373,10 +362,8 @@ static void P_SetSlopesFromVertexHeights(FMapThing *firstmt, FMapThing *lastmt, secplane_t *plane = j==0? &sec->floorplane : &sec->ceilingplane; - plane->set(cross[0], cross[1], cross[2], 0.); - plane->setD(-TMulScale16 (plane->fixA(), vertexes[vi3].fixX(), - plane->fixB(), vertexes[vi3].fixY(), - plane->fixC(), FLOAT2FIXED(vt3.Z))); + double dist = -cross[0] * vertexes[vi3].fX() - cross[1] * vertexes[vi3].fY() - cross[2] * vt3.Z; + plane->set(cross[0], cross[1], cross[2], dist); } } } @@ -415,21 +402,17 @@ void P_SpawnSlopeMakers (FMapThing *firstmt, FMapThing *lastmt, const int *oldve } pos.Z = refplane->ZatPoint (mt->pos) + mt->pos.Z; - fixed_t x = FLOAT2FIXED(pos.X); - fixed_t y = FLOAT2FIXED(pos.Y); - fixed_t z = FLOAT2FIXED(pos.Z); - if (mt->info->Special <= SMT_SlopeCeilingPointLine) { // SlopeFloorPointLine and SlopCeilingPointLine - P_SlopeLineToPoint (mt->args[0], x, y, z, ceiling); + P_SlopeLineToPoint (mt->args[0], pos, ceiling); } else if (mt->info->Special <= SMT_SetCeilingSlope) { // SetFloorSlope and SetCeilingSlope - P_SetSlope (refplane, ceiling, mt->angle, mt->args[0], x, y, z); + P_SetSlope (refplane, ceiling, mt->angle, mt->args[0], pos); } else - { // VavoomFloor and VavoomCeiling - P_VavoomSlope(sec, mt->thingid, x, y, FLOAT2FIXED(mt->pos.Z), ceiling); + { // VavoomFloor and VavoomCeiling (these do not perform any sector height adjustment - z is absolute) + P_VavoomSlope(sec, mt->thingid, mt->pos, ceiling); } mt->EdNum = 0; } @@ -440,7 +423,7 @@ void P_SpawnSlopeMakers (FMapThing *firstmt, FMapThing *lastmt, const int *oldve if (mt->info != NULL && mt->info->Type == NULL && (mt->info->Special == SMT_CopyFloorPlane || mt->info->Special == SMT_CopyCeilingPlane)) { - P_CopyPlane (mt->args[0], FLOAT2FIXED(mt->pos.X), FLOAT2FIXED(mt->pos.Y), mt->info->Special == SMT_CopyCeilingPlane); + P_CopyPlane (mt->args[0], mt->pos, mt->info->Special == SMT_CopyCeilingPlane); mt->EdNum = 0; } } @@ -464,7 +447,7 @@ void P_SpawnSlopeMakers (FMapThing *firstmt, FMapThing *lastmt, const int *oldve // //=========================================================================== -static void P_AlignPlane (sector_t *sec, line_t *line, int which) +static void P_AlignPlane(sector_t *sec, line_t *line, int which) { sector_t *refsec; double bestdist; @@ -478,7 +461,7 @@ static void P_AlignPlane (sector_t *sec, line_t *line, int which) // Find furthest vertex from the reference line. It, along with the two ends // of the line, will define the plane. bestdist = 0; - for (i = sec->linecount*2, probe = sec->lines; i > 0; i--) + for (i = sec->linecount * 2, probe = sec->lines; i > 0; i--) { double dist; vertex_t *vert; @@ -487,8 +470,8 @@ static void P_AlignPlane (sector_t *sec, line_t *line, int which) vert = (*probe++)->v2; else vert = (*probe)->v1; - dist = fabs((double(line->v1->fixY()) - vert->fixY()) * line->fixDx() - - (double(line->v1->fixX()) - vert->fixX()) * line->fixDy()); + dist = fabs((line->v1->fY() - vert->fY()) * line->Delta().X - + (line->v1->fX() - vert->fX()) * line->Delta().Y); if (dist > bestdist) { @@ -502,21 +485,21 @@ static void P_AlignPlane (sector_t *sec, line_t *line, int which) DVector3 p, v1, v2, cross; secplane_t *srcplane; - fixed_t srcheight, destheight; + double srcheight, destheight; srcplane = (which == 0) ? &sec->floorplane : &sec->ceilingplane; - srcheight = (which == 0) ? sec->GetPlaneTexZ(sector_t::floor) : sec->GetPlaneTexZ(sector_t::ceiling); - destheight = (which == 0) ? refsec->GetPlaneTexZ(sector_t::floor) : refsec->GetPlaneTexZ(sector_t::ceiling); + srcheight = (which == 0) ? sec->GetPlaneTexZF(sector_t::floor) : sec->GetPlaneTexZF(sector_t::ceiling); + destheight = (which == 0) ? refsec->GetPlaneTexZF(sector_t::floor) : refsec->GetPlaneTexZF(sector_t::ceiling); p[0] = line->v1->fX(); p[1] = line->v1->fY(); - p[2] = FIXED2DBL(destheight); + p[2] = destheight; v1[0] = line->Delta().X; v1[1] = line->Delta().Y; v1[2] = 0; v2[0] = refvert->fX() - line->v1->fX(); v2[1] = refvert->fY() - line->v1->fY(); - v2[2] = FIXED2DBL(srcheight - destheight); + v2[2] = srcheight - destheight; cross = (v1 ^ v2).Unit(); @@ -526,10 +509,8 @@ static void P_AlignPlane (sector_t *sec, line_t *line, int which) cross = -cross; } - srcplane->set(cross[0], cross[1], cross[2], 0.); - srcplane->setD(-TMulScale16 (srcplane->fixA(), line->v1->fixX(), - srcplane->fixB(), line->v1->fixY(), - srcplane->fixC(), destheight)); + double dist = -cross[0] * line->v1->fX() - cross[1] * line->v1->fY() - cross[2] * destheight; + srcplane->set(cross[0], cross[1], cross[2], dist); } //=========================================================================== @@ -618,4 +599,3 @@ void P_CopySlopes() } } } - diff --git a/src/p_trace.cpp b/src/p_trace.cpp index 1d0e2b0bf1..543eaf3014 100644 --- a/src/p_trace.cpp +++ b/src/p_trace.cpp @@ -49,23 +49,23 @@ struct FTraceInfo { - fixed_t StartX, StartY, StartZ; - fixed_t Vx, Vy, Vz; + DVector3 Start; + DVector3 Vec; ActorFlags ActorMask; DWORD WallMask; AActor *IgnoreThis; FTraceResults *Results; FTraceResults *TempResults; sector_t *CurSector; - fixed_t MaxDist; - fixed_t EnterDist; + double MaxDist; + double EnterDist; ETraceStatus (*TraceCallback)(FTraceResults &res, void *data); void *TraceCallbackData; DWORD TraceFlags; int inshootthrough; - fixed_t startfrac; + double startfrac; int aimdir; - fixed_t limitz; + double limitz; // These are required for 3D-floor checking // to create a fake sector with a floor @@ -78,8 +78,8 @@ struct FTraceInfo bool ThingCheck(intercept_t *in); bool TraceTraverse (int ptflags); bool CheckPlane(const secplane_t &plane); - int EnterLinePortal(line_t *li, fixed_t frac); - void EnterSectorPortal(int position, fixed_t frac, sector_t *entersec); + int EnterLinePortal(line_t *li, double frac); + void EnterSectorPortal(int position, double frac, sector_t *entersec); bool CheckSectorPlane(const sector_t *sector, bool checkFloor) @@ -94,8 +94,8 @@ struct FTraceInfo void SetSourcePosition() { - Results->SrcFromTarget = { FIXED2DBL(StartX), FIXED2DBL(StartY), FIXED2DBL(StartZ) }; - Results->HitVector = { FIXED2DBL(Vx), FIXED2DBL(Vy), FIXED2DBL(Vz) }; + Results->SrcFromTarget = Start; + Results->HitVector = Vec; Results->SrcAngleFromTarget = Results->HitVector.Angle(); } @@ -111,11 +111,9 @@ static bool EditTraceResult (DWORD flags, FTraceResults &res); // //========================================================================== -bool Trace (fixed_t x, fixed_t y, fixed_t z, sector_t *sector, - fixed_t vx, fixed_t vy, fixed_t vz, fixed_t maxDist, - ActorFlags actorMask, DWORD wallMask, AActor *ignore, - FTraceResults &res, - DWORD flags, ETraceStatus (*callback)(FTraceResults &res, void *), void *callbackdata) +bool Trace(const DVector3 &start, sector_t *sector, const DVector3 &direction, double maxDist, + ActorFlags actorMask, DWORD wallMask, AActor *ignore, FTraceResults &res, DWORD flags, + ETraceStatus(*callback)(FTraceResults &res, void *), void *callbackdata) { int ptflags; FTraceInfo inf; @@ -126,12 +124,8 @@ bool Trace (fixed_t x, fixed_t y, fixed_t z, sector_t *sector, ptflags = actorMask ? PT_ADDLINES|PT_ADDTHINGS|PT_COMPATIBLE : PT_ADDLINES; - inf.StartX = x; - inf.StartY = y; - inf.StartZ = z; - inf.Vx = vx; - inf.Vy = vy; - inf.Vz = vz; + inf.Start = start; + inf.Vec = direction; inf.ActorMask = actorMask; inf.WallMask = wallMask; inf.IgnoreThis = ignore; @@ -149,30 +143,6 @@ bool Trace (fixed_t x, fixed_t y, fixed_t z, sector_t *sector, inf.startfrac = 0; memset(&res, 0, sizeof(res)); - // check for overflows and clip if necessary - SQWORD xd = (SQWORD)x + ((SQWORD(vx) * SQWORD(maxDist)) >> 16); - - if (xd>SQWORD(32767)*FRACUNIT) - { - inf.MaxDist = FixedDiv(FIXED_MAX - x, vx); - } - else if (xd<-SQWORD(32767)*FRACUNIT) - { - inf.MaxDist = FixedDiv(FIXED_MIN - x, vx); - } - - - SQWORD yd = (SQWORD)y + ((SQWORD(vy) * SQWORD(maxDist)) >> 16); - - if (yd>SQWORD(32767)*FRACUNIT) - { - inf.MaxDist = FixedDiv(FIXED_MAX - y, vy); - } - else if (yd<-SQWORD(32767)*FRACUNIT) - { - inf.MaxDist = FixedDiv(FIXED_MIN - y, vy); - } - if (inf.TraceTraverse (ptflags)) { return flags ? EditTraceResult(flags, res) : true; @@ -190,7 +160,7 @@ bool Trace (fixed_t x, fixed_t y, fixed_t z, sector_t *sector, // //============================================================================ -void FTraceInfo::EnterSectorPortal(int position, fixed_t frac, sector_t *entersec) +void FTraceInfo::EnterSectorPortal(int position, double frac, sector_t *entersec) { if (aimdir != -1 && aimdir != position) return; AActor *portal = entersec->SkyBoxes[position]; @@ -203,24 +173,19 @@ void FTraceInfo::EnterSectorPortal(int position, fixed_t frac, sector_t *enterse memset(&results, 0, sizeof(results)); - newtrace.StartX = StartX + FLOAT2FIXED(portal->Scale.X); - newtrace.StartY = StartY + FLOAT2FIXED(portal->Scale.Y); - newtrace.StartZ = StartZ; + newtrace.Start += portal->Scale; - frac += FixedDiv(FRACUNIT, MaxDist); - fixed_t enterdist = FixedMul(MaxDist, frac); - fixed_t enterX = newtrace.StartX + FixedMul(enterdist, Vx); - fixed_t enterY = newtrace.StartY + FixedMul(enterdist, Vy); + frac += 1 / MaxDist; + double enterdist = MaxDist * frac; + DVector2 enter = newtrace.Start.XY() + enterdist * Vec.XY(); - newtrace.Vx = Vx; - newtrace.Vy = Vy; - newtrace.Vz = Vz; + newtrace.Vec = Vec; newtrace.ActorMask = ActorMask; newtrace.WallMask = WallMask; newtrace.IgnoreThis = IgnoreThis; newtrace.Results = &results; newtrace.TempResults = TempResults; - newtrace.CurSector = P_PointInSector(enterX ,enterY); + newtrace.CurSector = P_PointInSector(enter); newtrace.MaxDist = MaxDist; newtrace.EnterDist = EnterDist; newtrace.TraceCallback = TraceCallback; @@ -229,7 +194,7 @@ void FTraceInfo::EnterSectorPortal(int position, fixed_t frac, sector_t *enterse newtrace.inshootthrough = true; newtrace.startfrac = frac; newtrace.aimdir = position; - newtrace.limitz = FLOAT2FIXED(portal->specialf1); + newtrace.limitz = portal->specialf1; newtrace.sectorsel = 0; if (newtrace.TraceTraverse(ActorMask ? PT_ADDLINES | PT_ADDTHINGS | PT_COMPATIBLE : PT_ADDLINES)) @@ -244,7 +209,7 @@ void FTraceInfo::EnterSectorPortal(int position, fixed_t frac, sector_t *enterse // //============================================================================ -int FTraceInfo::EnterLinePortal(line_t *li, fixed_t frac) +int FTraceInfo::EnterLinePortal(line_t *li, double frac) { FLinePortal *port = li->getPortal(); @@ -253,28 +218,23 @@ int FTraceInfo::EnterLinePortal(line_t *li, fixed_t frac) FTraceInfo newtrace; - newtrace.StartX = StartX; - newtrace.StartY = StartY; - newtrace.StartZ = StartZ; - newtrace.Vx = Vx; - newtrace.Vy = Vy; - newtrace.Vz = Vz; + newtrace.Start = Start; + newtrace.Vec = Vec; - P_TranslatePortalXY(li, newtrace.StartX, newtrace.StartY); - P_TranslatePortalZ(li, newtrace.StartZ); - P_TranslatePortalVXVY(li, newtrace.Vx, newtrace.Vy); + P_TranslatePortalXY(li, newtrace.Start.X, newtrace.Start.Y); + P_TranslatePortalZ(li, newtrace.Start.Z); + P_TranslatePortalVXVY(li, newtrace.Vec.X, newtrace.Vec.Y); - frac += FixedDiv(FRACUNIT, MaxDist); - fixed_t enterdist = FixedMul(MaxDist, frac); - fixed_t enterX = newtrace.StartX + FixedMul(enterdist, Vx); - fixed_t enterY = newtrace.StartY + FixedMul(enterdist, Vy); + frac += 1 / MaxDist; + double enterdist = MaxDist / frac; + DVector2 enter = newtrace.Start.XY() + enterdist * Vec.XY(); newtrace.ActorMask = ActorMask; newtrace.WallMask = WallMask; newtrace.IgnoreThis = IgnoreThis; newtrace.Results = Results; newtrace.TempResults = TempResults; - newtrace.CurSector = P_PointInSector(enterX, enterY); + newtrace.CurSector = P_PointInSector(enter); newtrace.MaxDist = MaxDist; newtrace.EnterDist = EnterDist; newtrace.TraceCallback = TraceCallback; @@ -306,14 +266,12 @@ void FTraceInfo::Setup3DFloors() CurSector = &DummySector[0]; sectorsel = 1; - fixed_t sdist = FixedMul(MaxDist, startfrac); - fixed_t x = StartX + FixedMul(Vx, sdist); - fixed_t y = StartY + FixedMul(Vy, sdist); - fixed_t z = StartZ + FixedMul(Vz, sdist); + double sdist = MaxDist * startfrac; + DVector3 pos = Start + Vec * sdist; - fixed_t bf = CurSector->floorplane.ZatPoint(x, y); - fixed_t bc = CurSector->ceilingplane.ZatPoint(x, y); + double bf = CurSector->floorplane.ZatPoint(pos); + double bc = CurSector->ceilingplane.ZatPoint(pos); for (auto rover : ff) { @@ -331,10 +289,10 @@ void FTraceInfo::Setup3DFloors() if (!(rover->flags&FF_SHOOTTHROUGH)) { - fixed_t ff_bottom = rover->bottom.plane->ZatPoint(x, y); - fixed_t ff_top = rover->top.plane->ZatPoint(x, y); + double ff_bottom = rover->bottom.plane->ZatPoint(pos); + double ff_top = rover->top.plane->ZatPoint(pos); // clip to the part of the sector we are in - if (z > ff_top) + if (pos.Z > ff_top) { // above if (bf < ff_top) @@ -345,7 +303,7 @@ void FTraceInfo::Setup3DFloors() bf = ff_top; } } - else if (z < ff_bottom) + else if (pos.Z < ff_bottom) { //below if (bc > ff_bottom) @@ -401,12 +359,10 @@ bool FTraceInfo::LineCheck(intercept_t *in) int lineside; sector_t *entersector; - fixed_t dist = FixedMul(MaxDist, in->frac); - fixed_t hitx = StartX + FixedMul(Vx, dist); - fixed_t hity = StartY + FixedMul(Vy, dist); - fixed_t hitz = StartZ + FixedMul(Vz, dist); + double dist = MaxDist * in->Frac; + DVector3 hit = Start + Vec * dist; - fixed_t ff, fc, bf = 0, bc = 0; + double ff, fc, bf = 0, bc = 0; if (in->d.line->frontsector->sectornum == CurSector->sectornum) { @@ -425,7 +381,7 @@ bool FTraceInfo::LineCheck(intercept_t *in) } else { - lineside = P_PointOnLineSide(StartX, StartY, in->d.line); + lineside = P_PointOnLineSide(Start, in->d.line); CurSector = lineside ? in->d.line->backsector : in->d.line->frontsector; } } @@ -455,20 +411,20 @@ bool FTraceInfo::LineCheck(intercept_t *in) } } - ff = CurSector->floorplane.ZatPoint(hitx, hity); - fc = CurSector->ceilingplane.ZatPoint(hitx, hity); + ff = CurSector->floorplane.ZatPoint(hit); + fc = CurSector->ceilingplane.ZatPoint(hit); if (entersector != NULL) { - bf = entersector->floorplane.ZatPoint(hitx, hity); - bc = entersector->ceilingplane.ZatPoint(hitx, hity); + bf = entersector->floorplane.ZatPoint(hit); + bc = entersector->ceilingplane.ZatPoint(hit); } sector_t *hsec = CurSector->GetHeightSec(); if (Results->CrossedWater == NULL && hsec != NULL && //CurSector->heightsec->waterzone && - hitz <= hsec->floorplane.ZatPoint(hitx, hity)) + hit.Z <= hsec->floorplane.ZatPoint(hit)) { // hit crossed a water plane if (CheckSectorPlane(hsec, true)) @@ -478,7 +434,7 @@ bool FTraceInfo::LineCheck(intercept_t *in) } } - if (hitz <= ff) + if (hit.Z <= ff) { if (CurSector->PortalBlocksMovement(sector_t::floor)) { @@ -493,7 +449,7 @@ bool FTraceInfo::LineCheck(intercept_t *in) return false; } } - else if (hitz >= fc) + else if (hit.Z >= fc) { if (CurSector->PortalBlocksMovement(sector_t::ceiling)) { @@ -510,9 +466,9 @@ bool FTraceInfo::LineCheck(intercept_t *in) } else if (in->d.line->isLinePortal()) { - if (entersector == NULL || (hitz >= bf && hitz <= bc)) + if (entersector == NULL || (hit.Z >= bf && hit.Z <= bc)) { - int res = EnterLinePortal(in->d.line, in->frac); + int res = EnterLinePortal(in->d.line, in->Frac); if (res != -1) { aimdir = INT_MAX; // flag for ending the traverse @@ -522,7 +478,7 @@ bool FTraceInfo::LineCheck(intercept_t *in) goto normalline; // hit upper or lower tier. } else if (entersector == NULL || - hitz < bf || hitz > bc || + hit.Z < bf || hit.Z > bc || in->d.line->flags & WallMask) { normalline: @@ -530,8 +486,8 @@ normalline: Results->HitType = TRACE_HitWall; Results->Tier = entersector == NULL ? TIER_Middle : - hitz <= bf ? TIER_Lower : - hitz >= bc ? TIER_Upper : TIER_Middle; + hit.Z <= bf ? TIER_Lower : + hit.Z >= bc ? TIER_Upper : TIER_Middle; if (TraceFlags & TRACE_Impact) { P_ActivateLine(in->d.line, IgnoreThis, lineside, SPAC_Impact); @@ -552,11 +508,11 @@ normalline: if (entershootthrough != inshootthrough && rover->flags&FF_EXISTS) { - fixed_t ff_bottom = rover->bottom.plane->ZatPoint(hitx, hity); - fixed_t ff_top = rover->top.plane->ZatPoint(hitx, hity); + double ff_bottom = rover->bottom.plane->ZatPoint(hit); + double ff_top = rover->top.plane->ZatPoint(hit); // clip to the part of the sector we are in - if (hitz > ff_top) + if (hit.Z > ff_top) { // above if (bf < ff_top) @@ -567,7 +523,7 @@ normalline: bf = ff_top; } } - else if (hitz < ff_bottom) + else if (hit.Z < ff_bottom) { //below if (bc > ff_bottom) @@ -631,12 +587,12 @@ cont: } else { - if (hitz <= bf || hitz >= bc) + if (hit.Z <= bf || hit.Z >= bc) { Results->HitType = TRACE_HitWall; Results->Tier = - hitz <= bf ? TIER_Lower : - hitz >= bc ? TIER_Upper : TIER_Middle; + hit.Z <= bf ? TIER_Lower : + hit.Z >= bc ? TIER_Upper : TIER_Middle; } else { @@ -651,10 +607,10 @@ cont: if (Results->HitType == TRACE_HitWall) { - Results->HitPos = { FIXED2DBL(hitx), FIXED2DBL(hity), FIXED2DBL(hitz) }; + Results->HitPos = hit; SetSourcePosition(); - Results->Distance = FIXED2DBL(dist); - Results->Fraction = FIXED2DBL(in->frac); + Results->Distance = dist; + Results->Fraction = in->Frac; Results->Line = in->d.line; Results->Side = lineside; } @@ -692,60 +648,54 @@ cont: bool FTraceInfo::ThingCheck(intercept_t *in) { - fixed_t dist = FixedMul(MaxDist, in->frac); - fixed_t hitx = StartX + FixedMul(Vx, dist); - fixed_t hity = StartY + FixedMul(Vy, dist); - fixed_t hitz = StartZ + FixedMul(Vz, dist); + double dist = MaxDist * in->Frac; + DVector3 hit = Start + Vec * dist; - if (hitz > in->d.thing->_f_Top()) + if (hit.Z > in->d.thing->Top()) { // trace enters above actor - if (Vz >= 0) return true; // Going up: can't hit + if (Vec.Z >= 0) return true; // Going up: can't hit // Does it hit the top of the actor? - dist = FixedDiv(in->d.thing->_f_Top() - StartZ, Vz); + dist = (in->d.thing->Top() - Start.Z) / Vec.Z; if (dist > MaxDist) return true; - in->frac = FixedDiv(dist, MaxDist); + in->Frac = dist / MaxDist; - hitx = StartX + FixedMul(Vx, dist); - hity = StartY + FixedMul(Vy, dist); - hitz = StartZ + FixedMul(Vz, dist); + hit = Start + Vec * dist; // calculated coordinate is outside the actor's bounding box - if (abs(hitx - in->d.thing->_f_X()) > in->d.thing->_f_radius() || - abs(hity - in->d.thing->_f_Y()) > in->d.thing->_f_radius()) return true; + if (fabs(hit.X - in->d.thing->X()) > in->d.thing->radius || + fabs(hit.Y - in->d.thing->Y()) > in->d.thing->radius) return true; } - else if (hitz < in->d.thing->_f_Z()) + else if (hit.Z < in->d.thing->Z()) { // trace enters below actor - if (Vz <= 0) return true; // Going down: can't hit + if (Vec.Z <= 0) return true; // Going down: can't hit // Does it hit the bottom of the actor? - dist = FixedDiv(in->d.thing->_f_Z() - StartZ, Vz); + dist = (in->d.thing->Z() - Start.Z) / Vec.Z; if (dist > MaxDist) return true; - in->frac = FixedDiv(dist, MaxDist); + in->Frac = dist / MaxDist; - hitx = StartX + FixedMul(Vx, dist); - hity = StartY + FixedMul(Vy, dist); - hitz = StartZ + FixedMul(Vz, dist); + hit = Start + Vec * dist; // calculated coordinate is outside the actor's bounding box - if (abs(hitx - in->d.thing->_f_X()) > in->d.thing->_f_radius() || - abs(hity - in->d.thing->_f_Y()) > in->d.thing->_f_radius()) return true; + if (fabs(hit.X - in->d.thing->X()) > in->d.thing->radius || + fabs(hit.Y - in->d.thing->Y()) > in->d.thing->radius) return true; } if (CurSector->e->XFloor.ffloors.Size()) { // check for 3D floor hits first. - fixed_t ff_floor = CurSector->floorplane.ZatPoint(hitx, hity); - fixed_t ff_ceiling = CurSector->ceilingplane.ZatPoint(hitx, hity); + double ff_floor = CurSector->floorplane.ZatPoint(hit); + double ff_ceiling = CurSector->ceilingplane.ZatPoint(hit); - if (hitz > ff_ceiling && CurSector->PortalBlocksMovement(sector_t::ceiling)) // actor is hit above the current ceiling + if (hit.Z > ff_ceiling && CurSector->PortalBlocksMovement(sector_t::ceiling)) // actor is hit above the current ceiling { Results->HitType = TRACE_HitCeiling; Results->HitTexture = CurSector->GetTexture(sector_t::ceiling); } - else if (hitz < ff_floor && CurSector->PortalBlocksMovement(sector_t::floor)) // actor is hit below the current floor + else if (hit.Z < ff_floor && CurSector->PortalBlocksMovement(sector_t::floor)) // actor is hit below the current floor { Results->HitType = TRACE_HitFloor; Results->HitTexture = CurSector->GetTexture(sector_t::floor); @@ -778,10 +728,10 @@ cont1: Results->HitType = TRACE_HitActor; - Results->HitPos = { FIXED2DBL(hitx), FIXED2DBL(hity), FIXED2DBL(hitz) }; + Results->HitPos = hit; SetSourcePosition(); - Results->Distance = FIXED2DBL(dist); - Results->Fraction = FIXED2DBL(in->frac); + Results->Distance = dist; + Results->Fraction = in->Frac; Results->Actor = in->d.thing; if (TraceCallback != NULL) @@ -811,7 +761,7 @@ bool FTraceInfo::TraceTraverse (int ptflags) // Do a 3D floor check in the starting sector Setup3DFloors(); - FPathTraverse it(StartX, StartY, FixedMul (Vx, MaxDist), FixedMul (Vy, MaxDist), ptflags | PT_DELTA, startfrac); + FPathTraverse it(Start.X, Start.Y, Vec.X * MaxDist, Vec.Y * MaxDist, ptflags | PT_DELTA, startfrac); intercept_t *in; int lastsplashsector = -1; @@ -911,12 +861,9 @@ bool FTraceInfo::TraceTraverse (int ptflags) } if (Results->HitType == TRACE_HitNone && Results->Distance == 0) { - Results->HitPos = { - FIXED2DBL(StartX + FixedMul(Vx, MaxDist)), - FIXED2DBL(StartY + FixedMul(Vy, MaxDist)), - FIXED2DBL(StartZ + FixedMul(Vz, MaxDist)) }; + Results->HitPos = Start + Vec * MaxDist; SetSourcePosition(); - Results->Distance = FIXED2DBL(MaxDist); + Results->Distance = MaxDist; Results->Fraction = 1.; } return Results->HitType != TRACE_HitNone; @@ -930,25 +877,20 @@ bool FTraceInfo::TraceTraverse (int ptflags) bool FTraceInfo::CheckPlane (const secplane_t &plane) { - fixed_t den = TMulScale16 (plane.fixA(), Vx, plane.fixB(), Vy, plane.fixC(), Vz); + double den = plane.fA() * Vec.X + plane.fB() * Vec.Y + plane.fC() * Vec.Z; if (den != 0) { - fixed_t num = TMulScale16 (plane.fixA(), StartX, - plane.fixB(), StartY, - plane.fixC(), StartZ) + plane.fixD(); + double num = plane.fA() * Start.X + plane.fB() * Start.Y + plane.fC() * Start.Z + plane.fD(); - fixed_t hitdist = FixedDiv (-num, den); + double hitdist = -num / den; if (hitdist > EnterDist && hitdist < MaxDist) { - Results->HitPos = { - FIXED2DBL(StartX + FixedMul(Vx, hitdist)), - FIXED2DBL(StartY + FixedMul(Vy, hitdist)), - FIXED2DBL(StartZ + FixedMul(Vz, hitdist)) }; + Results->HitPos = Start + Vec * hitdist; SetSourcePosition(); - Results->Distance = FIXED2DBL(hitdist); - Results->Fraction = FIXED2DBL(FixedDiv (hitdist, MaxDist)); + Results->Distance = hitdist; + Results->Fraction = hitdist / MaxDist; return true; } } diff --git a/src/p_trace.h b/src/p_trace.h index 01d308fd8e..2c817816ec 100644 --- a/src/p_trace.h +++ b/src/p_trace.h @@ -124,20 +124,8 @@ enum ETraceStatus TRACE_Abort, // stop the trace, returning no hits }; -bool Trace (fixed_t x, fixed_t y, fixed_t z, sector_t *sector, - fixed_t vx, fixed_t vy, fixed_t vz, fixed_t maxDist, - ActorFlags ActorMask, DWORD WallMask, AActor *ignore, - FTraceResults &res, - DWORD traceFlags=0, - ETraceStatus (*callback)(FTraceResults &res, void *)=NULL, void *callbackdata=NULL); - -inline bool Trace(const DVector3 &start, sector_t *sector, const DVector3 &direction, double maxDist, +bool Trace(const DVector3 &start, sector_t *sector, const DVector3 &direction, double maxDist, ActorFlags ActorMask, DWORD WallMask, AActor *ignore, FTraceResults &res, DWORD traceFlags = 0, - ETraceStatus(*callback)(FTraceResults &res, void *) = NULL, void *callbackdata = NULL) -{ - return Trace(FLOAT2FIXED(start.X), FLOAT2FIXED(start.Y), FLOAT2FIXED(start.Z), sector, - FLOAT2FIXED(direction.X), FLOAT2FIXED(direction.Y), FLOAT2FIXED(direction.Z), FLOAT2FIXED(maxDist), - ActorMask, WallMask, ignore, res, traceFlags, callback, callbackdata); -} + ETraceStatus(*callback)(FTraceResults &res, void *) = NULL, void *callbackdata = NULL); #endif //__P_TRACE_H__ diff --git a/src/p_udmf.cpp b/src/p_udmf.cpp index 6f0dc6a04f..35ad22f635 100644 --- a/src/p_udmf.cpp +++ b/src/p_udmf.cpp @@ -252,14 +252,9 @@ double UDMFParserBase::CheckFloat(const char *key) return sc.Float; } -fixed_t UDMFParserBase::CheckFixed(const char *key) +DAngle UDMFParserBase::CheckAngle(const char *key) { - return FLOAT2FIXED(CheckFloat(key)); -} - -angle_t UDMFParserBase::CheckAngle(const char *key) -{ - return FLOAT2ANGLE(CheckFloat(key)); + return DAngle(CheckFloat(key)).Normalized360(); } bool UDMFParserBase::CheckBool(const char *key) @@ -358,7 +353,7 @@ int GetUDMFInt(int type, int index, const char *key) return 0; } -fixed_t GetUDMFFixed(int type, int index, const char *key) +double GetUDMFFloat(int type, int index, const char *key) { assert(type >=0 && type <=3); @@ -369,7 +364,7 @@ fixed_t GetUDMFFixed(int type, int index, const char *key) FUDMFKey *pKey = pKeys->Find(key); if (pKey != NULL) { - return FLOAT2FIXED(pKey->FloatVal); + return pKey->FloatVal; } } return 0; @@ -970,7 +965,7 @@ public: if (namespace_bits & (Zd|Zdt|Va)) switch(key) { case NAME_Alpha: - ld->Alpha = CheckFixed(key); + ld->setAlpha(CheckFloat(key)); continue; case NAME_Renderstyle: @@ -1096,7 +1091,7 @@ public: { ld->Alpha = TRANSLUC75; } - if (strifetrans2 && ld->Alpha == FRACUNIT) + if (strifetrans2 && ld->Alpha == OPAQUE) { ld->Alpha = TRANSLUC25; } @@ -1127,14 +1122,14 @@ public: void ParseSidedef(side_t *sd, intmapsidedef_t *sdt, int index) { - fixed_t texofs[2]={0,0}; + double texOfs[2]={0,0}; memset(sd, 0, sizeof(*sd)); sdt->bottomtexture = "-"; sdt->toptexture = "-"; sdt->midtexture = "-"; - sd->SetTextureXScale(FRACUNIT); - sd->SetTextureYScale(FRACUNIT); + sd->SetTextureXScale(1.); + sd->SetTextureYScale(1.); sd->Index = index; sc.MustGetToken('{'); @@ -1144,11 +1139,11 @@ public: switch(key) { case NAME_Offsetx: - texofs[0] = CheckInt(key) << FRACBITS; + texOfs[0] = CheckInt(key); continue; case NAME_Offsety: - texofs[1] = CheckInt(key) << FRACBITS; + texOfs[1] = CheckInt(key); continue; case NAME_Texturetop: @@ -1174,51 +1169,51 @@ public: if (namespace_bits & (Zd|Zdt|Va)) switch(key) { case NAME_offsetx_top: - sd->SetTextureXOffset(side_t::top, CheckFixed(key)); + sd->SetTextureXOffset(side_t::top, CheckFloat(key)); continue; case NAME_offsety_top: - sd->SetTextureYOffset(side_t::top, CheckFixed(key)); + sd->SetTextureYOffset(side_t::top, CheckFloat(key)); continue; case NAME_offsetx_mid: - sd->SetTextureXOffset(side_t::mid, CheckFixed(key)); + sd->SetTextureXOffset(side_t::mid, CheckFloat(key)); continue; case NAME_offsety_mid: - sd->SetTextureYOffset(side_t::mid, CheckFixed(key)); + sd->SetTextureYOffset(side_t::mid, CheckFloat(key)); continue; case NAME_offsetx_bottom: - sd->SetTextureXOffset(side_t::bottom, CheckFixed(key)); + sd->SetTextureXOffset(side_t::bottom, CheckFloat(key)); continue; case NAME_offsety_bottom: - sd->SetTextureYOffset(side_t::bottom, CheckFixed(key)); + sd->SetTextureYOffset(side_t::bottom, CheckFloat(key)); continue; case NAME_scalex_top: - sd->SetTextureXScale(side_t::top, CheckFixed(key)); + sd->SetTextureXScale(side_t::top, CheckFloat(key)); continue; case NAME_scaley_top: - sd->SetTextureYScale(side_t::top, CheckFixed(key)); + sd->SetTextureYScale(side_t::top, CheckFloat(key)); continue; case NAME_scalex_mid: - sd->SetTextureXScale(side_t::mid, CheckFixed(key)); + sd->SetTextureXScale(side_t::mid, CheckFloat(key)); continue; case NAME_scaley_mid: - sd->SetTextureYScale(side_t::mid, CheckFixed(key)); + sd->SetTextureYScale(side_t::mid, CheckFloat(key)); continue; case NAME_scalex_bottom: - sd->SetTextureXScale(side_t::bottom, CheckFixed(key)); + sd->SetTextureXScale(side_t::bottom, CheckFloat(key)); continue; case NAME_scaley_bottom: - sd->SetTextureYScale(side_t::bottom, CheckFixed(key)); + sd->SetTextureYScale(side_t::bottom, CheckFloat(key)); continue; case NAME_light: @@ -1263,12 +1258,12 @@ public: } } // initialization of these is delayed to allow separate offsets and add them with the global ones. - sd->AddTextureXOffset(side_t::top, texofs[0]); - sd->AddTextureXOffset(side_t::mid, texofs[0]); - sd->AddTextureXOffset(side_t::bottom, texofs[0]); - sd->AddTextureYOffset(side_t::top, texofs[1]); - sd->AddTextureYOffset(side_t::mid, texofs[1]); - sd->AddTextureYOffset(side_t::bottom, texofs[1]); + sd->AddTextureXOffset(side_t::top, texOfs[0]); + sd->AddTextureXOffset(side_t::mid, texOfs[0]); + sd->AddTextureXOffset(side_t::bottom, texOfs[0]); + sd->AddTextureYOffset(side_t::top, texOfs[1]); + sd->AddTextureYOffset(side_t::mid, texOfs[1]); + sd->AddTextureYOffset(side_t::bottom, texOfs[1]); } //=========================================================================== @@ -1288,12 +1283,12 @@ public: memset(sec, 0, sizeof(*sec)); sec->lightlevel = 160; - sec->SetXScale(sector_t::floor, FRACUNIT); // [RH] floor and ceiling scaling - sec->SetYScale(sector_t::floor, FRACUNIT); - sec->SetXScale(sector_t::ceiling, FRACUNIT); - sec->SetYScale(sector_t::ceiling, FRACUNIT); - sec->SetAlpha(sector_t::floor, OPAQUE); - sec->SetAlpha(sector_t::ceiling, OPAQUE); + sec->SetXScale(sector_t::floor, 1.); // [RH] floor and ceiling scaling + sec->SetYScale(sector_t::floor, 1.); + sec->SetXScale(sector_t::ceiling, 1.); + sec->SetYScale(sector_t::ceiling, 1.); + sec->SetAlpha(sector_t::floor, 1.); + sec->SetAlpha(sector_t::ceiling, 1.); sec->thinglist = NULL; sec->touching_thinglist = NULL; // phares 3/14/98 sec->seqType = (level.flags & LEVEL_SNDSEQTOTALCTRL) ? 0 : -1; @@ -1320,11 +1315,11 @@ public: switch(key) { case NAME_Heightfloor: - sec->SetPlaneTexZ(sector_t::floor, CheckInt(key) << FRACBITS); + sec->SetPlaneTexZ(sector_t::floor, CheckFloat(key)); continue; case NAME_Heightceiling: - sec->SetPlaneTexZ(sector_t::ceiling, CheckInt(key) << FRACBITS); + sec->SetPlaneTexZ(sector_t::ceiling, CheckFloat(key)); continue; case NAME_Texturefloor: @@ -1360,35 +1355,35 @@ public: if (namespace_bits & (Zd|Zdt|Va)) switch(key) { case NAME_Xpanningfloor: - sec->SetXOffset(sector_t::floor, CheckFixed(key)); + sec->SetXOffset(sector_t::floor, CheckFloat(key)); continue; case NAME_Ypanningfloor: - sec->SetYOffset(sector_t::floor, CheckFixed(key)); + sec->SetYOffset(sector_t::floor, CheckFloat(key)); continue; case NAME_Xpanningceiling: - sec->SetXOffset(sector_t::ceiling, CheckFixed(key)); + sec->SetXOffset(sector_t::ceiling, CheckFloat(key)); continue; case NAME_Ypanningceiling: - sec->SetYOffset(sector_t::ceiling, CheckFixed(key)); + sec->SetYOffset(sector_t::ceiling, CheckFloat(key)); continue; case NAME_Xscalefloor: - sec->SetXScale(sector_t::floor, CheckFixed(key)); + sec->SetXScale(sector_t::floor, CheckFloat(key)); continue; case NAME_Yscalefloor: - sec->SetYScale(sector_t::floor, CheckFixed(key)); + sec->SetYScale(sector_t::floor, CheckFloat(key)); continue; case NAME_Xscaleceiling: - sec->SetXScale(sector_t::ceiling, CheckFixed(key)); + sec->SetXScale(sector_t::ceiling, CheckFloat(key)); continue; case NAME_Yscaleceiling: - sec->SetYScale(sector_t::ceiling, CheckFixed(key)); + sec->SetYScale(sector_t::ceiling, CheckFloat(key)); continue; case NAME_Rotationfloor: @@ -1408,11 +1403,11 @@ public: continue; case NAME_Alphafloor: - sec->SetAlpha(sector_t::floor, CheckFixed(key)); + sec->SetAlpha(sector_t::floor, CheckFloat(key)); continue; case NAME_Alphaceiling: - sec->SetAlpha(sector_t::ceiling, CheckFixed(key)); + sec->SetAlpha(sector_t::ceiling, CheckFloat(key)); continue; case NAME_Renderstylefloor: @@ -1600,7 +1595,7 @@ public: // Reset the planes to their defaults if not all of the plane equation's parameters were found. if (fplaneflags != 15) { - sec->floorplane.set(0, 0, FRACUNIT, -sec->GetPlaneTexZ(sector_t::floor)); + sec->floorplane.SetAtHeight(sec->GetPlaneTexZF(sector_t::floor), sector_t::floor); } else { @@ -1610,7 +1605,7 @@ public: } if (cplaneflags != 15) { - sec->ceilingplane.set(0, 0, -FRACUNIT, sec->GetPlaneTexZ(sector_t::ceiling)); + sec->ceilingplane.SetAtHeight(sec->GetPlaneTexZF(sector_t::ceiling), sector_t::ceiling); } else { @@ -1663,18 +1658,18 @@ public: vd->zCeiling = vd->zFloor = vd->flags = 0; sc.MustGetToken('{'); - fixed_t x, y; + double x, y; while (!sc.CheckToken('}')) { FName key = ParseKey(); switch (key) { case NAME_X: - x = CheckFixed(key); + x = CheckFloat(key); break; case NAME_Y: - y = CheckFixed(key); + y = CheckFloat(key); break; case NAME_ZCeiling: @@ -1714,7 +1709,7 @@ public: I_Error ("Line %d has invalid vertices: %zd and/or %zd.\nThe map only contains %d vertices.", i+skipped, v1i, v2i, numvertexes); } else if (v1i == v2i || - (vertexes[v1i].fixX() == vertexes[v2i].fixX() && vertexes[v1i].fixY() == vertexes[v2i].fixY())) + (vertexes[v1i].fX() == vertexes[v2i].fX() && vertexes[v1i].fY() == vertexes[v2i].fY())) { Printf ("Removing 0-length line %d\n", i+skipped); ParsedLines.Delete(i); diff --git a/src/p_udmf.h b/src/p_udmf.h index 7fa7cf614a..9e7bce5e22 100644 --- a/src/p_udmf.h +++ b/src/p_udmf.h @@ -17,8 +17,7 @@ protected: FName ParseKey(bool checkblock = false, bool *isblock = NULL); int CheckInt(const char *key); double CheckFloat(const char *key); - fixed_t CheckFixed(const char *key); - angle_t CheckAngle(const char *key); + DAngle CheckAngle(const char *key); bool CheckBool(const char *key); const char *CheckString(const char *key); diff --git a/src/p_user.cpp b/src/p_user.cpp index 9b8e5de8f3..07b9ca20d2 100644 --- a/src/p_user.cpp +++ b/src/p_user.cpp @@ -2500,7 +2500,6 @@ void P_PlayerThink (player_t *player) } if (player->centering) { - player->mo->Angles.Pitch.Normalize180(); // make sure we are in the proper range here for the following code. if (fabs(player->mo->Angles.Pitch) > 2.) { player->mo->Angles.Pitch *= (2. / 3.); diff --git a/src/po_man.cpp b/src/po_man.cpp index 6e0563e13e..e3c4ddecde 100644 --- a/src/po_man.cpp +++ b/src/po_man.cpp @@ -867,7 +867,7 @@ void FPolyObj::ThrustMobj (AActor *actor, side_t *side) } vertex_t *v1 = side->V1(); vertex_t *v2 = side->V2(); - thrustAngle = VecToAngle(v2->fixX() - v1->fixX(), v2->fixY() - v1->fixY()) - 90.; + thrustAngle = (v2->fPos() - v1->fPos()).Angle() - 90.; pe = static_cast(specialdata); if (pe) diff --git a/src/r_3dfloors.cpp b/src/r_3dfloors.cpp index 5f91fc6b6e..a6aa7d8b53 100644 --- a/src/r_3dfloors.cpp +++ b/src/r_3dfloors.cpp @@ -55,8 +55,8 @@ void R_3D_AddHeight(secplane_t *add, sector_t *sec) fixed_t height; height = add->ZatPoint(viewx, viewy); - if(height >= sec->_f_CenterCeiling()) return; - if(height <= sec->_f_CenterFloor()) return; + if(height >= FLOAT2FIXED(sec->CenterCeiling())) return; + if(height <= FLOAT2FIXED(sec->CenterFloor())) return; fakeActive = 1; diff --git a/src/r_bsp.cpp b/src/r_bsp.cpp index d6de05d552..a8cc942f55 100644 --- a/src/r_bsp.cpp +++ b/src/r_bsp.cpp @@ -1345,11 +1345,11 @@ void R_Subsector (subsector_t *sub) fakeFloor->validcount = validcount; R_3D_NewClip(); } - if (frontsector->_f_CenterFloor() >= backsector->_f_CenterFloor()) + if (frontsector->CenterFloor() >= backsector->CenterFloor()) { fake3D |= FAKE3D_CLIPBOTFRONT; } - if (frontsector->_f_CenterCeiling() <= backsector->_f_CenterCeiling()) + if (frontsector->CenterCeiling() <= backsector->CenterCeiling()) { fake3D |= FAKE3D_CLIPTOPFRONT; } diff --git a/src/r_defs.h b/src/r_defs.h index 6d808618ed..f77e317751 100644 --- a/src/r_defs.h +++ b/src/r_defs.h @@ -1096,8 +1096,6 @@ struct sector_t } // Member variables - fixed_t _f_CenterFloor () const { return floorplane.ZatPoint (_f_centerspot()); } - fixed_t _f_CenterCeiling () const { return ceilingplane.ZatPoint (_f_centerspot()); } double CenterFloor() const { return floorplane.ZatPoint(centerspot); } double CenterCeiling() const { return ceilingplane.ZatPoint(centerspot); } @@ -1345,6 +1343,10 @@ struct side_t { textures[which].xscale = scale == 0 ? FRACUNIT : scale; } + void SetTextureXScale(int which, double scale) + { + textures[which].xscale = scale == 0 ? FRACUNIT : FLOAT2FIXED(scale); + } void SetTextureXScale(fixed_t scale) { textures[top].xscale = textures[mid].xscale = textures[bottom].xscale = scale == 0 ? FRACUNIT : scale; @@ -1644,31 +1646,6 @@ inline sector_t *P_PointInSector(double X, double Y) return P_PointInSubsector(FLOAT2FIXED(X), FLOAT2FIXED(Y))->sector; } -inline fixedvec3 AActor::_f_PosRelative(int portalgroup) const -{ - return _f_Pos() + Displacements._f_getOffset(Sector->PortalGroup, portalgroup); -} - -inline fixedvec3 AActor::_f_PosRelative(const AActor *other) const -{ - return _f_Pos() + Displacements._f_getOffset(Sector->PortalGroup, other->Sector->PortalGroup); -} - -inline fixedvec3 AActor::_f_PosRelative(sector_t *sec) const -{ - return _f_Pos() + Displacements._f_getOffset(Sector->PortalGroup, sec->PortalGroup); -} - -inline fixedvec3 AActor::_f_PosRelative(line_t *line) const -{ - return _f_Pos() + Displacements._f_getOffset(Sector->PortalGroup, line->frontsector->PortalGroup); -} - -inline fixedvec3 _f_PosRelative(const fixedvec3 &pos, line_t *line, sector_t *refsec = NULL) -{ - return pos + Displacements._f_getOffset(refsec->PortalGroup, line->frontsector->PortalGroup); -} - inline DVector3 AActor::PosRelative(int portalgroup) const { return Pos() + Displacements.getOffset(Sector->PortalGroup, portalgroup); diff --git a/src/r_draw.cpp b/src/r_draw.cpp index 44ec0e46a6..24a48e3b38 100644 --- a/src/r_draw.cpp +++ b/src/r_draw.cpp @@ -1071,7 +1071,7 @@ void R_DrawSpanP_C (void) #ifdef RANGECHECK if (ds_x2 < ds_x1 || ds_x1 < 0 - || ds_x2 >= screen->width || ds_y > screen->_f_height()) + || ds_x2 >= screen->width || ds_y > screen->height) { I_Error ("R_DrawSpan: %i to %i at %i", ds_x1, ds_x2, ds_y); } diff --git a/src/r_plane.cpp b/src/r_plane.cpp index a8e283dda3..9423ca4ee1 100644 --- a/src/r_plane.cpp +++ b/src/r_plane.cpp @@ -1531,7 +1531,7 @@ void R_DrawNormalPlane (visplane_t *pl, fixed_t alpha, bool additive, bool maske yscale = pl->yscale << (16 - ds_ybits); if (planeang != 0) { - double rad = ANGLE2RAD(planeang); + double rad = planeang * (M_PI / ANGLE_180); double cosine = cos(rad), sine = sin(rad); pviewx = xs_RoundToInt(pl->xoffs + viewx * cosine - viewy * sine); @@ -1668,29 +1668,29 @@ void R_DrawTiltedPlane (visplane_t *pl, fixed_t alpha, bool additive, bool maske // p is the texture origin in view space // Don't add in the offsets at this stage, because doing so can result in // errors if the flat is rotated. - ang = ANGLE2RAD(ANG270 - viewangle); + ang = (ANG270 - viewangle) * (M_PI / ANGLE_180); p[0] = vx * cos(ang) - vy * sin(ang); p[2] = vx * sin(ang) + vy * cos(ang); p[1] = pl->height.ZatPoint(0.0, 0.0) - vz; // m is the v direction vector in view space - ang = ANGLE2RAD(ANG180 - viewangle - pl->angle); + ang = (ANG180 - viewangle - pl->angle) * (M_PI / ANGLE_180); m[0] = yscale * cos(ang); m[2] = yscale * sin(ang); -// m[1] = FIXED2FLOAT(pl->height.ZatPoint (0, iyscale) - pl->height.ZatPoint (0,0)); +// m[1] = pl->height.ZatPointF (0, iyscale) - pl->height.ZatPointF (0,0)); // VectorScale2 (m, 64.f/VectorLength(m)); // n is the u direction vector in view space ang += PI/2; n[0] = -xscale * cos(ang); n[2] = -xscale * sin(ang); -// n[1] = FIXED2FLOAT(pl->height.ZatPoint (ixscale, 0) - pl->height.ZatPoint (0,0)); +// n[1] = pl->height.ZatPointF (ixscale, 0) - pl->height.ZatPointF (0,0)); // VectorScale2 (n, 64.f/VectorLength(n)); // This code keeps the texture coordinates constant across the x,y plane no matter // how much you slope the surface. Use the commented-out code above instead to keep // the textures a constant size across the surface's plane instead. - ang = ANGLE2RAD(pl->angle); + ang = pl->angle * (M_PI / ANGLE_180); m[1] = pl->height.ZatPoint(vx + yscale * sin(ang), vy + yscale * cos(ang)) - zeroheight; ang += PI/2; n[1] = pl->height.ZatPoint(vx + xscale * sin(ang), vy + xscale * cos(ang)) - zeroheight; diff --git a/src/r_segs.cpp b/src/r_segs.cpp index e6d841df13..6b24103d9d 100644 --- a/src/r_segs.cpp +++ b/src/r_segs.cpp @@ -687,16 +687,16 @@ void R_RenderFakeWallRange (drawseg_t *ds, int x1, int x2) frontsector = sec; } - floorheight = backsector->_f_CenterFloor(); - ceilingheight = backsector->_f_CenterCeiling(); + floorheight = FLOAT2FIXED(backsector->CenterFloor()); + ceilingheight = FLOAT2FIXED(backsector->CenterCeiling()); // maybe fix clipheights if (!(fake3D & FAKE3D_CLIPBOTTOM)) sclipBottom = floorheight; if (!(fake3D & FAKE3D_CLIPTOP)) sclipTop = ceilingheight; // maybe not visible - if (sclipBottom >= frontsector->_f_CenterCeiling()) return; - if (sclipTop <= frontsector->_f_CenterFloor()) return; + if (sclipBottom >= FLOAT2FIXED(frontsector->CenterCeiling())) return; + if (sclipTop <= FLOAT2FIXED(frontsector->CenterFloor())) return; if (fake3D & FAKE3D_DOWN2UP) { // bottom to viewz diff --git a/src/r_things.cpp b/src/r_things.cpp index b63b15ae59..96d38e54d8 100644 --- a/src/r_things.cpp +++ b/src/r_things.cpp @@ -763,7 +763,7 @@ void R_ProjectSprite (AActor *thing, int fakeside, F3DFloor *fakefloor, F3DFloor // [ZZ] Or less definitely not visible (hue) // [ZZ] 10.01.2016: don't try to clip stuff inside a skybox against the current portal. - if (!CurrentPortalInSkybox && CurrentPortal && !!P_PointOnLineSidePrecise(thing->_f_X(), thing->_f_Y(), CurrentPortal->dst)) + if (!CurrentPortalInSkybox && CurrentPortal && !!P_PointOnLineSidePrecise(thing->Pos(), CurrentPortal->dst)) return; // [RH] Interpolate the sprite's position to make it look smooth @@ -806,11 +806,11 @@ void R_ProjectSprite (AActor *thing, int fakeside, F3DFloor *fakefloor, F3DFloor angle_t rot; if (sprframe->Texture[0] == sprframe->Texture[1]) { - rot = (ang - thing->_f_angle() + (angle_t)(ANGLE_45/2)*9) >> 28; + rot = (ang - thing->Angles.Yaw.BAMs() + (angle_t)(ANGLE_45/2)*9) >> 28; } else { - rot = (ang - thing->_f_angle() + (angle_t)(ANGLE_45/2)*9-(angle_t)(ANGLE_180/16)) >> 28; + rot = (ang - thing->Angles.Yaw.BAMs() + (angle_t)(ANGLE_45/2)*9-(angle_t)(ANGLE_180/16)) >> 28; } picnum = sprframe->Texture[rot]; if (sprframe->Flip & (1 << rot)) @@ -845,11 +845,11 @@ void R_ProjectSprite (AActor *thing, int fakeside, F3DFloor *fakefloor, F3DFloor angle_t rot; if (sprframe->Texture[0] == sprframe->Texture[1]) { - rot = (ang - thing->_f_angle() + (angle_t)(ANGLE_45/2)*9) >> 28; + rot = (ang - thing->Angles.Yaw.BAMs() + (angle_t)(ANGLE_45/2)*9) >> 28; } else { - rot = (ang - thing->_f_angle() + (angle_t)(ANGLE_45/2)*9-(angle_t)(ANGLE_180/16)) >> 28; + rot = (ang - thing->Angles.Yaw.BAMs() + (angle_t)(ANGLE_45/2)*9-(angle_t)(ANGLE_180/16)) >> 28; } picnum = sprframe->Texture[rot]; if (sprframe->Flip & (1 << rot)) @@ -1001,7 +1001,7 @@ void R_ProjectSprite (AActor *thing, int fakeside, F3DFloor *fakefloor, F3DFloor vis->texturemid = (tex->TopOffset << FRACBITS) - FixedDiv (viewz - fz + FLOAT2FIXED(thing->Floorclip), yscale); vis->x1 = x1 < WindowLeft ? WindowLeft : x1; vis->x2 = x2 > WindowRight ? WindowRight : x2; - vis->angle = thing->_f_angle(); + vis->angle = thing->Angles.Yaw.BAMs(); if (renderflags & RF_XFLIP) { @@ -1036,8 +1036,8 @@ void R_ProjectSprite (AActor *thing, int fakeside, F3DFloor *fakefloor, F3DFloor int voxelspin = (thing->flags & MF_DROPPED) ? voxel->DroppedSpin : voxel->PlacedSpin; if (voxelspin != 0) { - double ang = double(I_FPSTime()) * voxelspin / 1000; - vis->angle -= FLOAT2ANGLE(ang); + DAngle ang = double(I_FPSTime()) * voxelspin / 1000; + vis->angle -= ang.BAMs(); } vis->vx = viewx; @@ -1151,7 +1151,7 @@ static void R_ProjectWallSprite(AActor *thing, fixed_t fx, fixed_t fy, fixed_t f fixed_t lx1, lx2, ly1, ly2; fixed_t gzb, gzt, tz; FTexture *pic = TexMan(picnum, true); - angle_t ang = (thing->_f_angle() + ANGLE_90) >> ANGLETOFINESHIFT; + angle_t ang = (thing->Angles.Yaw.BAMs() + ANGLE_90) >> ANGLETOFINESHIFT; vissprite_t *vis; // Determine left and right edges of sprite. The sprite's angle is its normal, @@ -1256,12 +1256,12 @@ void R_AddSprites (sector_t *sec, int lightlevel, int fakeside) { if(!rover->top.plane->isSlope()) { - if(rover->top.plane->Zat0() <= thing->_f_Z()) fakefloor = rover; + if(rover->top.plane->ZatPoint(0., 0.) <= thing->Z()) fakefloor = rover; } } if(!rover->bottom.plane->isSlope()) { - if(rover->bottom.plane->Zat0() >= thing->_f_Top()) fakeceiling = rover; + if(rover->bottom.plane->ZatPoint(0., 0.) >= thing->Top()) fakeceiling = rover; } } R_ProjectSprite (thing, fakeside, fakefloor, fakeceiling); diff --git a/src/r_utility.cpp b/src/r_utility.cpp index 264e4b4478..8d0ac1fbe0 100644 --- a/src/r_utility.cpp +++ b/src/r_utility.cpp @@ -105,6 +105,7 @@ fixed_t viewx; fixed_t viewy; fixed_t viewz; int viewpitch; +angle_t viewangle; extern "C" { @@ -117,7 +118,6 @@ extern "C" int otic; -angle_t viewangle; sector_t *viewsector; fixed_t viewcos, viewtancos; @@ -619,7 +619,7 @@ void R_InterpolateView (player_t *player, fixed_t frac, InterpolationViewer *ivi DVector3a &end = InterpolationPath[i]; pathlen += FLOAT2FIXED((end.pos-start.pos).Length()); totalzdiff += FLOAT2FIXED(start.pos.Z); - totaladiff += FLOAT2ANGLE(start.angle.Degrees); + totaladiff += start.angle.BAMs(); } fixed_t interpolatedlen = FixedMul(frac, pathlen); @@ -629,7 +629,7 @@ void R_InterpolateView (player_t *player, fixed_t frac, InterpolationViewer *ivi DVector3a &end = InterpolationPath[i]; fixed_t fraglen = FLOAT2FIXED((end.pos - start.pos).Length()); zdiff += FLOAT2FIXED(start.pos.Z); - adiff += FLOAT2ANGLE(start.angle.Degrees); + adiff += start.angle.BAMs(); if (fraglen <= interpolatedlen) { interpolatedlen -= fraglen; @@ -683,11 +683,11 @@ void R_InterpolateView (player_t *player, fixed_t frac, InterpolationViewer *ivi // Avoid overflowing viewpitch (can happen when a netgame is stalled) if (viewpitch > INT_MAX - delta) { - viewpitch = FLOAT2ANGLE(player->MaxPitch.Degrees); + viewpitch = player->MaxPitch.BAMs(); } else { - viewpitch = MIN(viewpitch + delta, FLOAT2ANGLE(player->MaxPitch.Degrees)); + viewpitch = MIN(viewpitch + delta, player->MaxPitch.BAMs()); } } else if (delta < 0) @@ -695,11 +695,11 @@ void R_InterpolateView (player_t *player, fixed_t frac, InterpolationViewer *ivi // Avoid overflowing viewpitch (can happen when a netgame is stalled) if (viewpitch < INT_MIN - delta) { - viewpitch = FLOAT2ANGLE(player->MinPitch.Degrees); + viewpitch = player->MinPitch.BAMs(); } else { - viewpitch = MAX(viewpitch + delta, FLOAT2ANGLE(player->MinPitch.Degrees)); + viewpitch = MAX(viewpitch + delta, player->MinPitch.BAMs()); } } } @@ -994,13 +994,13 @@ void R_SetupFrame (AActor *actor) viewsector = camera->Sector; r_showviewer = false; } - iview->nviewpitch = camera->_f_pitch(); + iview->nviewpitch = camera->Angles.Pitch.BAMs(); if (camera->player != 0) { player = camera->player; } - iview->nviewangle = camera->_f_angle(); + iview->nviewangle = camera->Angles.Yaw.BAMs(); if (iview->otic == -1 || r_NoInterpolate) { R_ResetViewInterpolation (); diff --git a/src/s_sndseq.cpp b/src/s_sndseq.cpp index da1edca5dc..1864b3da01 100644 --- a/src/s_sndseq.cpp +++ b/src/s_sndseq.cpp @@ -34,6 +34,7 @@ #define GetCommand(a) ((a) & 255) #define GetData(a) (SDWORD(a) >> 8 ) +#define GetFloatData(a) float((SDWORD(a) >> 8 )/65536.f) #define MakeCommand(a,b) ((a) | ((b) << 8)) #define HexenPlatSeq(a) (a) #define HexenDoorSeq(a) ((a) | 0x40) @@ -675,18 +676,18 @@ void S_ParseSndSeq (int levellump) case SS_STRING_VOLUME: // volume is in range 0..100 sc.MustGetFloat (); - ScriptTemp.Push(MakeCommand(SS_CMD_VOLUME, int(sc.Float * (FRACUNIT/100.f)))); + ScriptTemp.Push(MakeCommand(SS_CMD_VOLUME, int(sc.Float * (65536.f / 100.f)))); break; case SS_STRING_VOLUMEREL: sc.MustGetFloat (); - ScriptTemp.Push(MakeCommand(SS_CMD_VOLUMEREL, int(sc.Float * (FRACUNIT/100.f)))); + ScriptTemp.Push(MakeCommand(SS_CMD_VOLUMEREL, int(sc.Float * (65536.f / 100.f)))); break; case SS_STRING_VOLUMERAND: sc.MustGetFloat (); volumebase = float(sc.Float); - ScriptTemp.Push(MakeCommand(SS_CMD_VOLUMERAND, int(sc.Float * (FRACUNIT/100.f)))); + ScriptTemp.Push(MakeCommand(SS_CMD_VOLUMERAND, int(sc.Float * (65536.f / 100.f)))); sc.MustGetFloat (); ScriptTemp.Push(int((sc.Float - volumebase) * (256/100.f))); break; @@ -705,12 +706,12 @@ void S_ParseSndSeq (int levellump) case SS_STRING_ATTENUATION: if (sc.CheckFloat()) { - val = FLOAT2FIXED(sc.Float); + val = int(sc.Float*65536.); } else { sc.MustGetString (); - val = sc.MustMatchString(&Attenuations[0].name, sizeof(Attenuations[0])) << FRACBITS; + val = sc.MustMatchString(&Attenuations[0].name, sizeof(Attenuations[0])) * 65536; } ScriptTemp.Push(MakeCommand(SS_CMD_ATTENUATION, val)); break; @@ -1179,19 +1180,19 @@ void DSeqNode::Tick () return; case SS_CMD_VOLUME: - m_Volume = GetData(*m_SequencePtr) / float(FRACUNIT); + m_Volume = GetFloatData(*m_SequencePtr); m_SequencePtr++; break; case SS_CMD_VOLUMEREL: // like SS_CMD_VOLUME, but the new volume is added to the old volume - m_Volume += GetData(*m_SequencePtr) / float(FRACUNIT); + m_Volume += GetFloatData(*m_SequencePtr); m_SequencePtr++; break; case SS_CMD_VOLUMERAND: // like SS_CMD_VOLUME, but the new volume is chosen randomly from a range - m_Volume = GetData(m_SequencePtr[0]) / float(FRACUNIT) + (pr_sndseq() % m_SequencePtr[1]) / 255.f; + m_Volume = GetFloatData(m_SequencePtr[0]) + (pr_sndseq() % m_SequencePtr[1]) / 255.f; m_SequencePtr += 2; break; @@ -1200,7 +1201,7 @@ void DSeqNode::Tick () return; case SS_CMD_ATTENUATION: - m_Atten = FIXED2FLOAT(GetData(*m_SequencePtr)); + m_Atten = GetFloatData(*m_SequencePtr); m_SequencePtr++; break; diff --git a/src/s_sound.cpp b/src/s_sound.cpp index 9f049fa000..2e41a54a79 100644 --- a/src/s_sound.cpp +++ b/src/s_sound.cpp @@ -1952,7 +1952,7 @@ static void S_SetListener(SoundListener &listener, AActor *listenactor) { if (listenactor != NULL) { - listener.angle = (float)ToRadians(listenactor->Angles.Yaw); + listener.angle = (float)listenactor->Angles.Yaw.Radians(); /* listener.velocity.X = listenactor->vel.x * (TICRATE/65536.f); listener.velocity.Y = listenactor->vel.z * (TICRATE/65536.f); diff --git a/src/textures/textures.h b/src/textures/textures.h index e77d4d5de2..318e32644f 100644 --- a/src/textures/textures.h +++ b/src/textures/textures.h @@ -1,6 +1,7 @@ #ifndef __TEXTURES_H #define __TEXTURES_H +#include "doomtype.h" #include "vectors.h" class FBitmap; diff --git a/src/v_draw.cpp b/src/v_draw.cpp index 4845fb6248..55ea7b8710 100644 --- a/src/v_draw.cpp +++ b/src/v_draw.cpp @@ -1205,8 +1205,8 @@ void DCanvas::FillSimplePoly(FTexture *tex, FVector2 *points, int npoints, scaley /= tex->Scale.Y; // Use the CRT's functions here. - cosrot = cos(ToRadians(rotation)); - sinrot = sin(ToRadians(rotation)); + cosrot = cos(rotation.Radians()); + sinrot = sin(rotation.Radians()); // Setup constant texture mapping parameters. R_SetupSpanBits(tex); diff --git a/src/vectors.h b/src/vectors.h index 7e22d59c9d..e6b512538f 100644 --- a/src/vectors.h +++ b/src/vectors.h @@ -42,16 +42,19 @@ #include #include -#include "m_fixed.h" -#include "tables.h" +#include "xs_Float.h" #include "math/cmath.h" #define EQUAL_EPSILON (1/65536.f) +// make this a local inline function to avoid any dependencies on other headers and not pollute the global namespace +namespace pi +{ + inline double pi() { return 3.14159265358979323846; } +} + -//#define DEG2RAD(d) ((d)*M_PI/180.) -//#define RAD2DEG(r) ((r)*180./M_PI) template struct TVector3; template struct TRotator; @@ -783,6 +786,10 @@ struct TAngle { vec_t Degrees; +private: + const double BAM_FACTOR = (90. / 0x40000000); +public: + // This is to catch any accidental attempt to assign an angle_t to this type. Any explicit exception will require a type cast. TAngle(int) = delete; @@ -990,51 +997,27 @@ struct TAngle } // Ensure the angle is between [0.0,360.0) degrees - TAngle &Normalize360() + TAngle Normalized360() const { // Normalizing the angle converts it to a BAM, which masks it, and converts it back to a float. // Note: We MUST use xs_Float here because it is the only method that guarantees reliable wraparound. - Degrees = (vec_t)ANGLE2DBL((unsigned int)FLOAT2ANGLE(Degrees)); - return *this; - } - - // Ensures the angle is between (-180.0,180.0] degrees - TAngle &Normalize180() - { - Degrees = (vec_t)ANGLE2DBL((signed int)FLOAT2ANGLE(Degrees)); - return *this; - } - - // Same as above but doesn't alter the calling object itself - - // Ensure the angle is between [0.0,360.0) degrees - TAngle Normalized360() const - { - - return (vec_t)ANGLE2DBL((unsigned int)FLOAT2ANGLE(Degrees)); + return (vec_t)(BAM_FACTOR * BAMs()); } // Ensures the angle is between (-180.0,180.0] degrees TAngle Normalized180() const { - return (vec_t)ANGLE2DBL((signed int)FLOAT2ANGLE(Degrees)); - } - - // Like Normalize360(), except the integer value is not converted back to a float. - // The steps parameter must be a power of 2. - int Quantize(int steps) const - { - return xs_CRoundToInt((Degrees * (steps/360.0)) & (steps-1)); + return (vec_t)(BAM_FACTOR * (signed int)BAMs()); } vec_t Radians() const { - return Degrees * (M_PI / 180.0); + return Degrees * (pi::pi() / 180.0); } unsigned BAMs() const { - return FLOAT2ANGLE(Degrees); + return xs_CRoundToInt(Degrees * (0x40000000 / 90.)); } TVector2 ToVector(vec_t length = 1) const @@ -1054,7 +1037,7 @@ struct TAngle double Tan() const { - return g_tan(Degrees * (M_PI / 180.)); + return g_tan(Degrees * (pi::pi() / 180.)); } // This is for calculating vertical velocity. For high pitches the tangent will become too large to be useful. @@ -1063,20 +1046,13 @@ struct TAngle return clamp(Tan(), -max, max); } + static inline TAngle ToDegrees(double rad) + { + return TAngle(double(rad * (180.0 / pi::pi()))); + } + }; -template -inline double ToRadians (const TAngle °) -{ - return double(deg.Degrees * (M_PI / 180.0)); -} - -// If this gets templated there will be countless instantiation errors. -inline TAngle ToDegrees (double rad) -{ - return TAngle (double(rad * (180.0 / M_PI))); -} - // Emulates the old floatbob offset table with direct calls to trig functions. inline double BobSin(double fb) { @@ -1092,48 +1068,48 @@ inline TAngle fabs (const TAngle °) template inline TAngle deltaangle(const TAngle &a1, const TAngle &a2) { - return (a2 - a1).Normalize180(); + return (a2 - a1).Normalized180(); } template inline TAngle deltaangle(const TAngle &a1, double a2) { - return (a2 - a1).Normalize180(); + return (a2 - a1).Normalized180(); } template inline TAngle deltaangle(double a1, const TAngle &a2) { - return (a2 - a1).Normalize180(); + return (a2 - a1).Normalized180(); } template inline TAngle absangle(const TAngle &a1, const TAngle &a2) { - return fabs((a1 - a2).Normalize180()); + return fabs((a1 - a2).Normalized180()); } template inline TAngle absangle(const TAngle &a1, double a2) { - return fabs((a1 - a2).Normalize180()); + return fabs((a1 - a2).Normalized180()); } inline TAngle VecToAngle(double x, double y) { - return g_atan2(y, x) * (180.0 / M_PI); + return g_atan2(y, x) * (180.0 / pi::pi()); } template inline TAngle VecToAngle (const TVector2 &vec) { - return (T)g_atan2(vec.Y, vec.X) * (180.0 / M_PI); + return (T)g_atan2(vec.Y, vec.X) * (180.0 / pi::pi()); } template inline TAngle VecToAngle (const TVector3 &vec) { - return (T)g_atan2(vec.Y, vec.X) * (180.0 / M_PI); + return (T)g_atan2(vec.Y, vec.X) * (180.0 / pi::pi()); } template @@ -1296,25 +1272,6 @@ struct TRotator { return TRotator(Pitch - other.Pitch, Yaw - other.Yaw, Roll - other.Roll); } - - // Normalize each component - TRotator &Normalize180 () - { - for (int i = -3; i; ++i) - { - (*this)[i+3].Normalize180(); - } - return *this; - } - - TRotator &Normalize360 () - { - for (int i = -3; i; ++i) - { - (*this)[i+3].Normalize360(); - } - return *this; - } }; // Create a forward vector from a rotation (ignoring roll) diff --git a/src/win32/fb_d3d9.cpp b/src/win32/fb_d3d9.cpp index 4bf3716e2b..7ec394d524 100644 --- a/src/win32/fb_d3d9.cpp +++ b/src/win32/fb_d3d9.cpp @@ -3105,8 +3105,8 @@ void D3DFB::FillSimplePoly(FTexture *texture, FVector2 *points, int npoints, return; } - cosrot = (float)cos(ToRadians(rotation)); - sinrot = (float)sin(ToRadians(rotation)); + cosrot = (float)cos(rotation.Radians()); + sinrot = (float)sin(rotation.Radians()); CheckQuadBatch(npoints - 2, npoints); quad = &QuadExtra[QuadBatchPos]; From 27bad66f61e460a29e78841c2923e0cd82e81c98 Mon Sep 17 00:00:00 2001 From: Christoph Oelckers Date: Wed, 30 Mar 2016 16:51:19 +0200 Subject: [PATCH 12/13] - floatified the remaining parts of p_sector.cpp. --- src/p_sectors.cpp | 78 +++++++++++++++++++++++------------------------ src/r_defs.h | 20 +++--------- 2 files changed, 43 insertions(+), 55 deletions(-) diff --git a/src/p_sectors.cpp b/src/p_sectors.cpp index b92c23de48..a636f585cd 100644 --- a/src/p_sectors.cpp +++ b/src/p_sectors.cpp @@ -892,14 +892,14 @@ void sector_t::CheckPortalPlane(int plane) double sector_t::HighestCeilingAt(const DVector2 &p, sector_t **resultsec) { sector_t *check = this; - fixed_t planeheight = FIXED_MIN; + double planeheight = -FLT_MAX; DVector2 pos = p; // Continue until we find a blocking portal or a portal below where we actually are. - while (!check->PortalBlocksMovement(ceiling) && planeheight < FLOAT2FIXED(check->SkyBoxes[ceiling]->specialf1)) + while (!check->PortalBlocksMovement(ceiling) && planeheight < check->SkyBoxes[ceiling]->specialf1) { pos += check->CeilingDisplacement(); - planeheight = FLOAT2FIXED(check->SkyBoxes[ceiling]->specialf1); + planeheight = check->SkyBoxes[ceiling]->specialf1; check = P_PointInSector(pos); } if (resultsec) *resultsec = check; @@ -915,14 +915,14 @@ double sector_t::HighestCeilingAt(const DVector2 &p, sector_t **resultsec) double sector_t::LowestFloorAt(const DVector2 &p, sector_t **resultsec) { sector_t *check = this; - fixed_t planeheight = FIXED_MAX; + double planeheight = FLT_MAX; DVector2 pos = p; // Continue until we find a blocking portal or a portal above where we actually are. - while (!check->PortalBlocksMovement(floor) && planeheight > FLOAT2FIXED(check->SkyBoxes[floor]->specialf1)) + while (!check->PortalBlocksMovement(floor) && planeheight > check->SkyBoxes[floor]->specialf1) { pos += check->FloorDisplacement(); - planeheight = FLOAT2FIXED(check->SkyBoxes[floor]->specialf1); + planeheight = check->SkyBoxes[floor]->specialf1; check = P_PointInSector(pos); } if (resultsec) *resultsec = check; @@ -930,34 +930,34 @@ double sector_t::LowestFloorAt(const DVector2 &p, sector_t **resultsec) } -fixed_t sector_t::NextHighestCeilingAt(fixed_t x, fixed_t y, fixed_t bottomz, fixed_t topz, int flags, sector_t **resultsec, F3DFloor **resultffloor) +double sector_t::NextHighestCeilingAt(double x, double y, double bottomz, double topz, int flags, sector_t **resultsec, F3DFloor **resultffloor) { sector_t *sec = this; - fixed_t planeheight = FIXED_MIN; + double planeheight = -FLT_MAX; while (true) { // Looking through planes from bottom to top - fixed_t realceil = sec->ceilingplane.ZatPoint(x, y); + double realceil = sec->ceilingplane.ZatPoint(x, y); for (int i = sec->e->XFloor.ffloors.Size() - 1; i >= 0; --i) { F3DFloor *rover = sec->e->XFloor.ffloors[i]; if (!(rover->flags & FF_SOLID) || !(rover->flags & FF_EXISTS)) continue; - fixed_t ff_bottom = rover->bottom.plane->ZatPoint(x, y); - fixed_t ff_top = rover->top.plane->ZatPoint(x, y); + double ff_bottom = rover->bottom.plane->ZatPoint(x, y); + double ff_top = rover->top.plane->ZatPoint(x, y); - fixed_t delta1 = bottomz - (ff_bottom + ((ff_top - ff_bottom) / 2)); - fixed_t delta2 = topz - (ff_bottom + ((ff_top - ff_bottom) / 2)); + double delta1 = bottomz - (ff_bottom + ((ff_top - ff_bottom) / 2)); + double delta2 = topz - (ff_bottom + ((ff_top - ff_bottom) / 2)); - if (ff_bottom < realceil && abs(delta1) > abs(delta2)) + if (ff_bottom < realceil && fabs(delta1) > fabs(delta2)) { if (resultsec) *resultsec = sec; if (resultffloor) *resultffloor = rover; return ff_bottom; } } - if ((flags & FFCF_NOPORTALS) || sec->PortalBlocksMovement(ceiling) || planeheight >= FLOAT2FIXED(sec->SkyBoxes[ceiling]->specialf1)) + if ((flags & FFCF_NOPORTALS) || sec->PortalBlocksMovement(ceiling) || planeheight >= sec->SkyBoxes[ceiling]->specialf1) { // Use sector's floor if (resultffloor) *resultffloor = NULL; if (resultsec) *resultsec = sec; @@ -966,23 +966,23 @@ fixed_t sector_t::NextHighestCeilingAt(fixed_t x, fixed_t y, fixed_t bottomz, fi else { DVector2 pos = sec->CeilingDisplacement(); - x += FLOAT2FIXED(pos.X); - y += FLOAT2FIXED(pos.Y); - planeheight = FLOAT2FIXED(sec->SkyBoxes[ceiling]->specialf1); + x += pos.X; + y += pos.Y; + planeheight = sec->SkyBoxes[ceiling]->specialf1; sec = P_PointInSector(x, y); } } } -fixed_t sector_t::NextLowestFloorAt(fixed_t x, fixed_t y, fixed_t z, int flags, fixed_t steph, sector_t **resultsec, F3DFloor **resultffloor) +double sector_t::NextLowestFloorAt(double x, double y, double z, int flags, double steph, sector_t **resultsec, F3DFloor **resultffloor) { sector_t *sec = this; - fixed_t planeheight = FIXED_MAX; + double planeheight = FLT_MAX; while (true) { // Looking through planes from top to bottom unsigned numff = sec->e->XFloor.ffloors.Size(); - fixed_t realfloor = sec->floorplane.ZatPoint(x, y); + double realfloor = sec->floorplane.ZatPoint(x, y); for (unsigned i = 0; i < numff; ++i) { F3DFloor *ff = sec->e->XFloor.ffloors[i]; @@ -991,8 +991,8 @@ fixed_t sector_t::NextLowestFloorAt(fixed_t x, fixed_t y, fixed_t z, int flags, // either with feet above the 3D floor or feet with less than 'stepheight' map units inside if ((ff->flags & (FF_EXISTS | FF_SOLID)) == (FF_EXISTS | FF_SOLID)) { - fixed_t ffz = ff->top.plane->ZatPoint(x, y); - fixed_t ffb = ff->bottom.plane->ZatPoint(x, y); + double ffz = ff->top.plane->ZatPoint(x, y); + double ffb = ff->bottom.plane->ZatPoint(x, y); if (ffz > realfloor && (z >= ffz || (!(flags & FFCF_3DRESTRICT) && (ffb < z && ffz < z + steph)))) { // This floor is beneath our feet. @@ -1002,7 +1002,7 @@ fixed_t sector_t::NextLowestFloorAt(fixed_t x, fixed_t y, fixed_t z, int flags, } } } - if ((flags & FFCF_NOPORTALS) || sec->PortalBlocksMovement(sector_t::floor) || planeheight <= FLOAT2FIXED(sec->SkyBoxes[floor]->specialf1)) + if ((flags & FFCF_NOPORTALS) || sec->PortalBlocksMovement(sector_t::floor) || planeheight <= sec->SkyBoxes[floor]->specialf1) { // Use sector's floor if (resultffloor) *resultffloor = NULL; if (resultsec) *resultsec = sec; @@ -1011,9 +1011,9 @@ fixed_t sector_t::NextLowestFloorAt(fixed_t x, fixed_t y, fixed_t z, int flags, else { DVector2 pos = sec->FloorDisplacement(); - x += FLOAT2FIXED(pos.X); - y += FLOAT2FIXED(pos.Y); - planeheight = FLOAT2FIXED(sec->SkyBoxes[floor]->specialf1); + x += pos.X; + y += pos.Y; + planeheight = sec->SkyBoxes[floor]->specialf1; sec = P_PointInSector(x, y); } } @@ -1087,18 +1087,18 @@ bool secplane_t::CopyPlaneIfValid (secplane_t *dest, const secplane_t *opp) cons // If the planes do not have matching slopes, then always copy them // because clipping would require creating new sectors. - if (a != dest->a || b != dest->b || c != dest->c) + if (fA() != dest->fA() || fB() != dest->fB() || fC() != dest->fC()) { copy = true; } - else if (opp->a != -dest->a || opp->b != -dest->b || opp->c != -dest->c) + else if (opp->fA() != -dest->fA() || opp->fB() != -dest->fB() || opp->fC() != -dest->fC()) { - if (d < dest->d) + if (fD() < dest->fD()) { copy = true; } } - else if (d < dest->d && d > -opp->d) + else if (fD() < dest->fD() && fD() > -opp->fD()) { copy = true; } @@ -1136,21 +1136,19 @@ bool P_AlignFlat (int linenum, int side, int fc) if (!sec) return false; - fixed_t x = line->v1->fixX(); - fixed_t y = line->v1->fixY(); - - angle_t angle = R_PointToAngle2 (x, y, line->v2->fixX(), line->v2->fixY()); - angle_t norm = (angle-ANGLE_90) >> ANGLETOFINESHIFT; - - fixed_t dist = -DMulScale16 (finecosine[norm], x, finesine[norm], y); + DVector2 pos = line->v1->fPos(); + DVector2 pos2 = line->v2->fPos(); + DAngle angle = (pos2 - pos).Angle(); + DAngle norm = angle - 90; + double dist = norm.Cos() * pos.X + norm.Sin() * pos.Y; if (side) { - angle = angle + ANGLE_180; + angle += 180.; dist = -dist; } - sec->SetBase(fc, dist & ((1<<(FRACBITS+8))-1), 0-angle); + sec->SetBase(fc, dist, -angle); return true; } diff --git a/src/r_defs.h b/src/r_defs.h index f77e317751..a41a9044b9 100644 --- a/src/r_defs.h +++ b/src/r_defs.h @@ -879,10 +879,10 @@ struct sector_t } } - void SetBase(int pos, fixed_t y, angle_t o) + void SetBase(int pos, double y, DAngle o) { - planes[pos].xform.base_yoffs = y; - planes[pos].xform.base_angle = o; + planes[pos].xform.base_yoffs = FLOAT2FIXED(y); + planes[pos].xform.base_angle = o.BAMs(); } void SetAlpha(int pos, fixed_t o) @@ -1082,18 +1082,8 @@ struct sector_t return LowestFloorAt(a->Pos(), resultsec); } - fixed_t NextHighestCeilingAt(fixed_t x, fixed_t y, fixed_t bottomz, fixed_t topz, int flags = 0, sector_t **resultsec = NULL, F3DFloor **resultffloor = NULL); - fixed_t NextLowestFloorAt(fixed_t x, fixed_t y, fixed_t z, int flags = 0, fixed_t steph = 0, sector_t **resultsec = NULL, F3DFloor **resultffloor = NULL); - - inline double NextHighestCeilingAt(double x, double y, double bottomz, double topz, int flags = 0, sector_t **resultsec = NULL, F3DFloor **resultffloor = NULL) - { - return FIXED2DBL(NextHighestCeilingAt(FLOAT2FIXED(x), FLOAT2FIXED(y), FLOAT2FIXED(bottomz), FLOAT2FIXED(topz), flags, resultsec, resultffloor)); - } - - double NextLowestFloorAt(double x, double y, double z, int flags = 0, double steph = 0, sector_t **resultsec = NULL, F3DFloor **resultffloor = NULL) - { - return FIXED2DBL(NextLowestFloorAt(FLOAT2FIXED(x), FLOAT2FIXED(y), FLOAT2FIXED(z), flags, FLOAT2FIXED(steph), resultsec, resultffloor)); - } + double NextHighestCeilingAt(double x, double y, double bottomz, double topz, int flags = 0, sector_t **resultsec = NULL, F3DFloor **resultffloor = NULL); + double NextLowestFloorAt(double x, double y, double z, int flags = 0, double steph = 0, sector_t **resultsec = NULL, F3DFloor **resultffloor = NULL); // Member variables double CenterFloor() const { return floorplane.ZatPoint(centerspot); } From d54a2364b9bcef99359705cfd29f5eb460ec0ec6 Mon Sep 17 00:00:00 2001 From: Christoph Oelckers Date: Wed, 30 Mar 2016 17:11:31 +0200 Subject: [PATCH 13/13] - floatified r_interpolate.cpp. --- src/r_data/r_interpolate.cpp | 78 ++++++++++++++++++------------------ src/r_data/r_interpolate.h | 4 +- src/r_utility.cpp | 11 ++--- src/r_utility.h | 1 - 4 files changed, 45 insertions(+), 49 deletions(-) diff --git a/src/r_data/r_interpolate.cpp b/src/r_data/r_interpolate.cpp index 284673e4b8..535173e307 100644 --- a/src/r_data/r_interpolate.cpp +++ b/src/r_data/r_interpolate.cpp @@ -52,8 +52,8 @@ class DSectorPlaneInterpolation : public DInterpolation DECLARE_CLASS(DSectorPlaneInterpolation, DInterpolation) sector_t *sector; - fixed_t oldheight, oldtexz; - fixed_t bakheight, baktexz; + double oldheight, oldtexz; + double bakheight, baktexz; bool ceiling; TArray attached; @@ -65,7 +65,7 @@ public: void Destroy(); void UpdateInterpolation(); void Restore(); - void Interpolate(fixed_t smoothratio); + void Interpolate(double smoothratio); void Serialize(FArchive &arc); size_t PointerSubstitution (DObject *old, DObject *notOld); size_t PropagateMark(); @@ -82,8 +82,8 @@ class DSectorScrollInterpolation : public DInterpolation DECLARE_CLASS(DSectorScrollInterpolation, DInterpolation) sector_t *sector; - fixed_t oldx, oldy; - fixed_t bakx, baky; + double oldx, oldy; + double bakx, baky; bool ceiling; public: @@ -93,7 +93,7 @@ public: void Destroy(); void UpdateInterpolation(); void Restore(); - void Interpolate(fixed_t smoothratio); + void Interpolate(double smoothratio); void Serialize(FArchive &arc); }; @@ -110,8 +110,8 @@ class DWallScrollInterpolation : public DInterpolation side_t *side; int part; - fixed_t oldx, oldy; - fixed_t bakx, baky; + double oldx, oldy; + double bakx, baky; public: @@ -120,7 +120,7 @@ public: void Destroy(); void UpdateInterpolation(); void Restore(); - void Interpolate(fixed_t smoothratio); + void Interpolate(double smoothratio); void Serialize(FArchive &arc); }; @@ -135,9 +135,9 @@ class DPolyobjInterpolation : public DInterpolation DECLARE_CLASS(DPolyobjInterpolation, DInterpolation) FPolyObj *poly; - TArray oldverts, bakverts; - fixed_t oldcx, oldcy; - fixed_t bakcx, bakcy; + TArray oldverts, bakverts; + double oldcx, oldcy; + double bakcx, bakcy; public: @@ -146,7 +146,7 @@ public: void Destroy(); void UpdateInterpolation(); void Restore(); - void Interpolate(fixed_t smoothratio); + void Interpolate(double smoothratio); void Serialize(FArchive &arc); }; @@ -251,9 +251,9 @@ void FInterpolator::RemoveInterpolation(DInterpolation *interp) // //========================================================================== -void FInterpolator::DoInterpolations(fixed_t smoothratio) +void FInterpolator::DoInterpolations(double smoothratio) { - if (smoothratio == FRACUNIT) + if (smoothratio >= 1.) { didInterp = false; return; @@ -440,13 +440,13 @@ void DSectorPlaneInterpolation::UpdateInterpolation() { if (!ceiling) { - oldheight = sector->floorplane.fixD(); - oldtexz = sector->GetPlaneTexZ(sector_t::floor); + oldheight = sector->floorplane.fD(); + oldtexz = sector->GetPlaneTexZF(sector_t::floor); } else { - oldheight = sector->ceilingplane.fixD(); - oldtexz = sector->GetPlaneTexZ(sector_t::ceiling); + oldheight = sector->ceilingplane.fD(); + oldtexz = sector->GetPlaneTexZF(sector_t::ceiling); } } @@ -478,7 +478,7 @@ void DSectorPlaneInterpolation::Restore() // //========================================================================== -void DSectorPlaneInterpolation::Interpolate(fixed_t smoothratio) +void DSectorPlaneInterpolation::Interpolate(double smoothratio) { secplane_t *pplane; int pos; @@ -503,8 +503,8 @@ void DSectorPlaneInterpolation::Interpolate(fixed_t smoothratio) } else { - pplane->setD(oldheight + FixedMul(bakheight - oldheight, smoothratio)); - sector->SetPlaneTexZ(pos, oldtexz + FixedMul(baktexz - oldtexz, smoothratio)); + pplane->setD(oldheight + (bakheight - oldheight) * smoothratio); + sector->SetPlaneTexZ(pos, oldtexz + (baktexz - oldtexz) * smoothratio); P_RecalculateAttached3DFloors(sector); sector->CheckPortalPlane(pos); } @@ -604,8 +604,8 @@ void DSectorScrollInterpolation::Destroy() void DSectorScrollInterpolation::UpdateInterpolation() { - oldx = sector->GetXOffset(ceiling); - oldy = sector->GetYOffset(ceiling, false); + oldx = sector->GetXOffsetF(ceiling); + oldy = sector->GetYOffsetF(ceiling, false); } //========================================================================== @@ -626,7 +626,7 @@ void DSectorScrollInterpolation::Restore() // //========================================================================== -void DSectorScrollInterpolation::Interpolate(fixed_t smoothratio) +void DSectorScrollInterpolation::Interpolate(double smoothratio) { bakx = sector->GetXOffset(ceiling); baky = sector->GetYOffset(ceiling, false); @@ -637,8 +637,8 @@ void DSectorScrollInterpolation::Interpolate(fixed_t smoothratio) } else { - sector->SetXOffset(ceiling, oldx + FixedMul(bakx - oldx, smoothratio)); - sector->SetYOffset(ceiling, oldy + FixedMul(baky - oldy, smoothratio)); + sector->SetXOffset(ceiling, oldx + (bakx - oldx) * smoothratio); + sector->SetYOffset(ceiling, oldy + (baky - oldy) * smoothratio); } } @@ -695,8 +695,8 @@ void DWallScrollInterpolation::Destroy() void DWallScrollInterpolation::UpdateInterpolation() { - oldx = side->GetTextureXOffset(part); - oldy = side->GetTextureYOffset(part); + oldx = side->GetTextureXOffsetF(part); + oldy = side->GetTextureYOffsetF(part); } //========================================================================== @@ -717,7 +717,7 @@ void DWallScrollInterpolation::Restore() // //========================================================================== -void DWallScrollInterpolation::Interpolate(fixed_t smoothratio) +void DWallScrollInterpolation::Interpolate(double smoothratio) { bakx = side->GetTextureXOffset(part); baky = side->GetTextureYOffset(part); @@ -728,8 +728,8 @@ void DWallScrollInterpolation::Interpolate(fixed_t smoothratio) } else { - side->SetTextureXOffset(part, oldx + FixedMul(bakx - oldx, smoothratio)); - side->SetTextureYOffset(part, oldy + FixedMul(baky - oldy, smoothratio)); + side->SetTextureXOffset(part, oldx + (bakx - oldx) * smoothratio); + side->SetTextureYOffset(part, oldy + (baky - oldy) * smoothratio); } } @@ -788,8 +788,8 @@ void DPolyobjInterpolation::UpdateInterpolation() { for(unsigned int i = 0; i < poly->Vertices.Size(); i++) { - oldverts[i*2 ] = poly->Vertices[i]->fixX(); - oldverts[i*2+1] = poly->Vertices[i]->fixY(); + oldverts[i*2 ] = poly->Vertices[i]->fX(); + oldverts[i*2+1] = poly->Vertices[i]->fY(); } oldcx = poly->CenterSpot.x; oldcy = poly->CenterSpot.y; @@ -818,7 +818,7 @@ void DPolyobjInterpolation::Restore() // //========================================================================== -void DPolyobjInterpolation::Interpolate(fixed_t smoothratio) +void DPolyobjInterpolation::Interpolate(double smoothratio) { bool changed = false; for(unsigned int i = 0; i < poly->Vertices.Size(); i++) @@ -830,8 +830,8 @@ void DPolyobjInterpolation::Interpolate(fixed_t smoothratio) { changed = true; poly->Vertices[i]->set( - oldverts[i * 2] + FixedMul(bakverts[i * 2] - oldverts[i * 2], smoothratio), - oldverts[i * 2 + 1] + FixedMul(bakverts[i * 2 + 1] - oldverts[i * 2 + 1], smoothratio)); + oldverts[i * 2] + (bakverts[i * 2] - oldverts[i * 2]) * smoothratio, + oldverts[i * 2 + 1] + (bakverts[i * 2 + 1] - oldverts[i * 2 + 1]) * smoothratio); } } if (refcount == 0 && !changed) @@ -842,8 +842,8 @@ void DPolyobjInterpolation::Interpolate(fixed_t smoothratio) { bakcx = poly->CenterSpot.x; bakcy = poly->CenterSpot.y; - poly->CenterSpot.x = bakcx + FixedMul(bakcx - oldcx, smoothratio); - poly->CenterSpot.y = bakcy + FixedMul(bakcy - oldcy, smoothratio); + poly->CenterSpot.x = bakcx + (bakcx - oldcx) * smoothratio; + poly->CenterSpot.y = bakcy + (bakcy - oldcy) * smoothratio; poly->ClearSubsectorLinks(); } diff --git a/src/r_data/r_interpolate.h b/src/r_data/r_interpolate.h index 4da89451c4..e49500e571 100644 --- a/src/r_data/r_interpolate.h +++ b/src/r_data/r_interpolate.h @@ -30,7 +30,7 @@ public: virtual void Destroy(); virtual void UpdateInterpolation() = 0; virtual void Restore() = 0; - virtual void Interpolate(fixed_t smoothratio) = 0; + virtual void Interpolate(double smoothratio) = 0; virtual void Serialize(FArchive &arc); }; @@ -58,7 +58,7 @@ public: void UpdateInterpolations(); void AddInterpolation(DInterpolation *); void RemoveInterpolation(DInterpolation *); - void DoInterpolations(fixed_t smoothratio); + void DoInterpolations(double smoothratio); void RestoreInterpolations(); void ClearInterpolations(); }; diff --git a/src/r_utility.cpp b/src/r_utility.cpp index 8d0ac1fbe0..4fd9a1ca40 100644 --- a/src/r_utility.cpp +++ b/src/r_utility.cpp @@ -125,7 +125,6 @@ fixed_t viewsin, viewtansin; AActor *camera; // [RH] camera to draw from. doesn't have to be a player -fixed_t r_TicFrac; // [RH] Fractional tic to render double r_TicFracF; // same as floating point DWORD r_FrameTime; // [RH] Time this frame started drawing (in ms) bool r_NoInterpolate; @@ -572,9 +571,9 @@ static void R_Shutdown () //CVAR (Int, tf, 0, 0) EXTERN_CVAR (Bool, cl_noprediction) -void R_InterpolateView (player_t *player, fixed_t frac, InterpolationViewer *iview) +void R_InterpolateView (player_t *player, double Frac, InterpolationViewer *iview) { -// frac = tf; + fixed_t frac = FLOAT2FIXED(Frac); if (NoInterpolateView) { InterpolationPath.Clear(); @@ -1012,9 +1011,7 @@ void R_SetupFrame (AActor *actor) { r_TicFracF = 1.; } - r_TicFrac = FLOAT2FIXED(r_TicFracF); - - R_InterpolateView (player, r_TicFrac, iview); + R_InterpolateView (player, r_TicFracF, iview); #ifdef TEST_X viewx = TEST_X; @@ -1025,7 +1022,7 @@ void R_SetupFrame (AActor *actor) R_SetViewAngle (); - interpolator.DoInterpolations (r_TicFrac); + interpolator.DoInterpolations (r_TicFracF); // Keep the view within the sector's floor and ceiling if (viewsector->PortalBlocksMovement(sector_t::ceiling)) diff --git a/src/r_utility.h b/src/r_utility.h index ff7d552af8..b3cfb10ad1 100644 --- a/src/r_utility.h +++ b/src/r_utility.h @@ -33,7 +33,6 @@ extern int LocalViewPitch; // [RH] Used directly instead of consoleplayer's extern bool LocalKeyboardTurner; // [RH] The local player used the keyboard to turn, so interpolate extern int WidescreenRatio; -extern fixed_t r_TicFrac; extern double r_TicFracF; extern DWORD r_FrameTime; extern int extralight;