mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-05 20:39:09 +01:00
Fix/sonar maintainability rebased (#209)
* refactor(sonar): use override instead of redundant virtual (cpp:S3471) * refactor(sonar): remove empty statements, one declaration per statement (cpp:S1116, cpp:S1659) * refactor(sonar): drop redundant lambda return types (cpp:S3574) * refactor(sonar): prefer using over typedef (cpp:S5416) * refactor(sonar): use =default for trivial special members (cpp:S3490) * refactor(sonar): use nullptr literal (cpp:S4962) * refactor(sonar): remove redundant access specifiers (cpp:S3539) * refactor(sonar): remove redundant casts (cpp:S1905) * refactor(sonar): use std::scoped_lock instead of std::lock_guard (cpp:S5997) * refactor(sonar): construct elements in place with emplace_back (cpp:S6003) * refactor(sonar): make narrowing conversions explicit (cpp:S5276) * refactor(sonar): mark unused parameters (cpp:S1172) Unused names are commented out; parameters used only on some platforms are marked [[maybe_unused]]. * refactor(sonar): declare non-mutating member functions const (cpp:S5817) Virtual functions are left untouched so overrides keep matching. * refactor(sonar): merge collapsible nested if statements (cpp:S1066) Comments that preceded the inner if are kept above the merged statement. * refactor(sonar): scope single-use variables in if init-statements (cpp:S6004) * fix(sonar): give polymorphic base classes virtual destructors (cpp:S1235) * refactor(sonar): use try_emplace for map insertion (cpp:S6030) * refactor(sonar): use auto where the type is spelled out on the right (cpp:S5827) * refactor(sonar): remove redundant parentheses (cpp:S1110) * refactor(sonar): document intentionally empty functions (cpp:S1186) * refactor(sonar): remove dead stores (cpp:S1854) Side effects (e.g. LISTLINE++) are kept. * refactor(sonar): remove unused variables, captures and private fields (cpp:S1481, cpp:S1068) * refactor(sonar): use structured bindings for pair access (cpp:S6005) * refactor(sonar): use range-based loops and ranges algorithms (cpp:S5566) * refactor(sonar): split chained assignments (cpp:S1121) * refactor(sonar): add default cases to switch statements (cpp:S3562) * refactor(sonar): use std::size for array lengths (cpp:S7127) * refactor(sonar): use std::ranges algorithms and std::erase(_if) (cpp:S6197) * refactor(sonar): access static members through the class (cpp:S2209) * refactor(sonar): add braces around nested if-else (cpp:S5261) * refactor(sonar): avoid side effects inside typeid operands (cpp:S5279) * refactor(sonar): drop top-level const from by-value return types (cpp:S5951) * refactor(sonar): declare variables separately from their type definitions (cpp:S3646) * refactor(sonar): declare loop counters in the for statement (cpp:S5955) * refactor(sonar): rely on class template argument deduction (cpp:S6012) * refactor(sonar): inherit base constructors instead of forwarding them (cpp:S5952) * refactor(sonar): rename locals that shadow outer declarations (cpp:S1117) Only local variables and definition parameters are renamed; shadowing struct fields and enumerators in headers are left for a separate change. * refactor(sonar): reduce enum qualification with using enum (cpp:S6177) Applied only where no unqualified name in the block could be captured by the introduced enumerators. * refactor(sonar): mark converting constructors explicit (cpp:S1709) sound_source and the gl::object conversion operators stay implicit; they are relied upon by copy-list-initialisation and GL calls. * refactor(sonar): initialise members in initialiser lists or declarations (cpp:S3230) * refactor(sonar): make read-only local references and pointers const (cpp:S5350) * refactor(sonar): take read-only pointer and reference parameters as const (cpp:S995) TTrain command handlers keep their signature, it is fixed by the handler table. * refactor(sonar): pass expensive-to-copy parameters by const reference (cpp:S1238) Signatures declared in files touched by PR 206 (Driver.h, EU07.cpp) and virtual overrides are left unchanged. * refactor(sonar): use transparent comparators for string-keyed maps (cpp:S6045) std::unordered_map instances and map types exposed in headers used by other modules are left as they are. * fix(sonar): do not use UI text as a printf format string (cpp:S5281) Text lines containing '%' would otherwise be interpreted as format specifiers by ImGui::TextColored. * refactor(sonar): use std::bind_front for callbacks (cpp:S5995) * refactor(sonar): drop const_cast on string literals passed to the Python C API (cpp:S859) * refactor(sonar): take read-only string parameters as std::string_view (cpp:S6009) The Windows messaging helpers keep std::string, they need c_str(). * refactor(sonar): make read-only global tables const (cpp:S5421) Mutable global state (flags, timers, singletons) is left as is. * refactor(sonar): replace single-case switch statements with if (cpp:S1301) * refactor(sonar): format UUIDs and log timestamps with std::format (cpp:S6494, cpp:S5945) * refactor(sonar): use std::array for local fixed-size arrays (cpp:S5945) Arrays that are class members or part of headers are left unchanged. * fix(sonar): test the bearing damage bit, not bit 0 (cpp:S872) 'DamageFlag & dtrain_bearing > 0' parsed as 'DamageFlag & (dtrain_bearing > 0)', i.e. DamageFlag & 1, so bearing friction reacted to the wrong damage flag. * refactor(sonar): assorted small fixes - empty() instead of size() comparisons (cpp:S1155) - member initialisers in declaration order (cpp:S3229) - no redundant c_str() when a std::string is accepted (cpp:S7121) - contains() on associative containers (cpp:S6171) - const reference instead of a copying range-for (cpp:S6032) - starts_with() for prefix checks (cpp:S6178) - no std::move on temporaries (cpp:S5274) - has_value() on std::optional (cpp:S7172) - bool literals for bool members (cpp:S5820) - inline only on the definition (cpp:S3548) - explicit base access specifier (cpp:S5965) - explicit element access instead of dereferencing an array (cpp:S7116) - rely on the C++20 rewritten operator!= (cpp:S6186) * refactor(sonar): more small fixes - std::format instead of iostream manipulators in to_string/to_hex_str (cpp:S6495); output verified identical, negative hex values keep the unsigned form - remove an empty compound statement (cpp:S108) - drop an always-false unsigned < 0 branch (cpp:S1768) - explicit lambda capture (cpp:S3608) - std::make_unique (cpp:S5950) * chore: strip stray carriage returns left in TTrain constructor comments * fix: keep quantize() in its own value type The S5276 change cast the result of the generic quantize<Type_>() to unsigned int, which truncated float/double callers (shadow angle slider, editor rotation snapping, AI speed control steps) and broke negative values. * fix(sonar): use integer loop counters in segment sampling (cpp:S2193) * refactor(sonar): clean up issues reported on PR 209 - remove locals left unused after the dead-store cleanup (cpp:S1481, cpp:S1854) - unnamed unused parameter (cpp:S1172) - single-use declarations moved into if init-statements (cpp:S6004) - auto for casted initialisers (cpp:S5827) - const references and pointers where nothing is modified (cpp:S5350) - rename structured bindings shadowed by inner declarations (cpp:S1117)
This commit is contained in:
jerrrrycho
@@ -15,14 +15,11 @@ http://mozilla.org/MPL/2.0/.
|
||||
class float3
|
||||
{ // wapółrzędne wierchołka 3D o pojedynczej precyzji
|
||||
public:
|
||||
float x, y, z;
|
||||
float3(void){};
|
||||
float3(float a, float b, float c)
|
||||
{
|
||||
x = a;
|
||||
y = b;
|
||||
z = c;
|
||||
};
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
float3() = default;
|
||||
float3(float a, float b, float c) : x(a), y(b), z(c) {}
|
||||
float Length() const;
|
||||
float LengthSquared() const;
|
||||
|
||||
@@ -74,7 +71,11 @@ inline float3 SafeNormalize(const float3 &v)
|
||||
auto const l = v.Length();
|
||||
float3 retVal;
|
||||
if (l == 0)
|
||||
retVal.x = retVal.y = retVal.z = 0;
|
||||
{
|
||||
retVal.x = 0;
|
||||
retVal.y = 0;
|
||||
retVal.z = 0;
|
||||
}
|
||||
else
|
||||
retVal = v / l;
|
||||
return retVal;
|
||||
@@ -96,26 +97,19 @@ inline float3 Interpolate( float3 const &First, float3 const &Second, float cons
|
||||
class float4
|
||||
{ // kwaternion obrotu
|
||||
public:
|
||||
float x, y, z, w;
|
||||
float4()
|
||||
{
|
||||
x = y = z = 0.f;
|
||||
w = 1.f;
|
||||
};
|
||||
float4(float a, float b, float c, float d)
|
||||
{
|
||||
x = a;
|
||||
y = b;
|
||||
z = c;
|
||||
w = d;
|
||||
};
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
float w;
|
||||
float4() : x(0.f), y(0.f), z(0.f), w(1.f) {}
|
||||
float4(float a, float b, float c, float d) : x(a), y(b), z(c), w(d) {}
|
||||
float inline LengthSquared() const
|
||||
{
|
||||
return x * x + y * y + z * z + w * w;
|
||||
};
|
||||
float inline Length() const
|
||||
{
|
||||
return sqrt(x * x + y * y + z * z + w * w);
|
||||
return static_cast<float>(sqrt(x * x + y * y + z * z + w * w));
|
||||
};
|
||||
};
|
||||
inline float4 operator*(const float4 &q1, const float4 &q2)
|
||||
@@ -177,7 +171,8 @@ inline float4 Slerp(const float4 &q0, const float4 &q1, float t)
|
||||
new_q1.w = -new_q1.w;
|
||||
cosOmega = -cosOmega;
|
||||
}
|
||||
float k0, k1;
|
||||
float k0;
|
||||
float k1;
|
||||
if (cosOmega > 0.9999f)
|
||||
{ // jeśli jesteśmy z (t) na maksimum kosinusa, to tam prawie liniowo jest
|
||||
k0 = 1.0f - t;
|
||||
@@ -188,8 +183,8 @@ inline float4 Slerp(const float4 &q0, const float4 &q1, float t)
|
||||
auto const sinOmega = std::sqrt(1.0f - cosOmega * cosOmega); // sinus z jedynki tryg.
|
||||
auto const omega = std::atan2(sinOmega, cosOmega); // wyznaczenie kąta
|
||||
auto const oneOverSinOmega = 1.0f / sinOmega; // odwrotność sinusa, bo sinus w mianowniku
|
||||
k0 = sin((1.0f - t) * omega) * oneOverSinOmega;
|
||||
k1 = sin(t * omega) * oneOverSinOmega;
|
||||
k0 = static_cast<float>(sin((1.0f - t) * omega) * oneOverSinOmega);
|
||||
k1 = static_cast<float>(sin(t * omega) * oneOverSinOmega);
|
||||
}
|
||||
return float4(q0.x * k0 + new_q1.x * k1, q0.y * k0 + new_q1.y * k1, q0.z * k0 + new_q1.z * k1,
|
||||
q0.w * k0 + new_q1.w * k1);
|
||||
@@ -200,7 +195,8 @@ struct float8
|
||||
public:
|
||||
float3 Point;
|
||||
float3 Normal;
|
||||
float tu, tv;
|
||||
float tu;
|
||||
float tv;
|
||||
};
|
||||
|
||||
class float4x4
|
||||
@@ -210,9 +206,9 @@ public:
|
||||
|
||||
void deserialize_float32(std::istream&);
|
||||
void deserialize_float64(std::istream&);
|
||||
void serialize_float32(std::ostream&);
|
||||
float4x4(void){};
|
||||
float4x4(const float f[16])
|
||||
void serialize_float32(std::ostream&) const;
|
||||
float4x4() = default;
|
||||
explicit float4x4(const float f[16])
|
||||
{
|
||||
for (int i = 0; i < 16; ++i)
|
||||
e[i] = f[i];
|
||||
@@ -227,9 +223,12 @@ public:
|
||||
}
|
||||
void Identity()
|
||||
{
|
||||
for (int i = 0; i < 16; ++i)
|
||||
e[i] = 0;
|
||||
e[0] = e[5] = e[10] = e[15] = 1.0f;
|
||||
for (auto &element : e)
|
||||
element = 0;
|
||||
e[0] = 1.0f;
|
||||
e[5] = 1.0f;
|
||||
e[10] = 1.0f;
|
||||
e[15] = 1.0f;
|
||||
}
|
||||
const float *operator[](int i) const
|
||||
{
|
||||
@@ -246,15 +245,15 @@ public:
|
||||
e[i + 2] = f; // zamiana Y i Z
|
||||
}
|
||||
};
|
||||
inline float4x4 &Rotation(float const angle, float3 const &axis);
|
||||
inline bool IdentityIs()
|
||||
float4x4 &Rotation(float const angle, float3 const &axis);
|
||||
inline bool IdentityIs() const
|
||||
{ // sprawdzenie jednostkowości
|
||||
for (int i = 0; i < 16; ++i)
|
||||
if (e[i] != (i % 5 ? 0.0 : 1.0)) // jedynki tylko na 0, 5, 10 i 15
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
void Quaternion(float4 *q);
|
||||
void Quaternion(float4 const *q);
|
||||
inline float3 *TranslationGet()
|
||||
{
|
||||
return (float3 *)(e + 12);
|
||||
@@ -345,10 +344,22 @@ inline float Det3x3(float a1, float a2, float a3, float b1, float b2, float b3,
|
||||
inline
|
||||
float Det(const float4x4 &m)
|
||||
{ // obliczenie wyznacznika macierzy 4×4
|
||||
float a1 = m[0][0], a2 = m[1][0], a3 = m[2][0], a4 = m[3][0];
|
||||
float b1 = m[0][1], b2 = m[1][1], b3 = m[2][1], b4 = m[3][1];
|
||||
float c1 = m[0][2], c2 = m[1][2], c3 = m[2][2], c4 = m[3][2];
|
||||
float d1 = m[0][3], d2 = m[1][3], d3 = m[2][3], d4 = m[3][3];
|
||||
float a1 = m[0][0];
|
||||
float a2 = m[1][0];
|
||||
float a3 = m[2][0];
|
||||
float a4 = m[3][0];
|
||||
float b1 = m[0][1];
|
||||
float b2 = m[1][1];
|
||||
float b3 = m[2][1];
|
||||
float b4 = m[3][1];
|
||||
float c1 = m[0][2];
|
||||
float c2 = m[1][2];
|
||||
float c3 = m[2][2];
|
||||
float c4 = m[3][2];
|
||||
float d1 = m[0][3];
|
||||
float d2 = m[1][3];
|
||||
float d3 = m[2][3];
|
||||
float d4 = m[3][3];
|
||||
return +a1 * Det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4) -
|
||||
b1 * Det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4) +
|
||||
c1 * Det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4) -
|
||||
|
||||
Reference in New Issue
Block a user