eu07/maszyna
17
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-10-17 01:39:20 +02:00
Code Issues 150 Wiki Activity

Fix/sonar maintainability rebased (#209)

Browse Source 
* 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
2026-10-11 13:22:33 +02:00
committed by GitHub
parent c26041f2e7
commit 6263fe539b
162 changed files with 4220 additions and 4598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
audio/sound.cpp
View File

@@ -47,19 +47,18 @@ sound_source::deserialize( cParser &Input, sound_type const Legacytype, int cons
if( Input.peek() == "{" ) {
// block type config
while( true == deserialize_mapping( Input ) ) {
; // all work done by while()
// all work done by while()
}
if( false == m_soundchunks.empty() ) {
// arrange loaded sound chunks in requested order
std::sort(
std::begin( m_soundchunks ), std::end( m_soundchunks ),
[]( soundchunk_pair const &Left, soundchunk_pair const &Right ) {
std::ranges::sort(
m_soundchunks, []( soundchunk_pair const &Left, soundchunk_pair const &Right ) {
return Left.second.threshold < Right.second.threshold; } );
// calculate and cache full range points for each chunk, including crossfade sections:
// on the far end the crossfade section extends to the threshold point of the next chunk...
for( std::size_t idx = 0; idx < m_soundchunks.size() - 1; ++idx ) {
m_soundchunks[ idx ].second.fadeout = m_soundchunks[ idx + 1 ].second.threshold;
m_soundchunks[ idx ].second.fadeout = static_cast<float>(m_soundchunks[ idx + 1 ].second.threshold);
/*
m_soundchunks[ idx ].second.fadeout =
interpolate<float>(
@@ -69,11 +68,11 @@ sound_source::deserialize( cParser &Input, sound_type const Legacytype, int cons
*/
}
// ...and on the other end from the threshold point back into the range of previous chunk
m_soundchunks.front().second.fadein = std::max( 0, m_soundchunks.front().second.threshold );
m_soundchunks.front().second.fadein = static_cast<float>(std::max( 0, m_soundchunks.front().second.threshold ));
// m_soundchunks.front().second.fadein = m_soundchunks.front().second.threshold;
for( std::size_t idx = 1; idx < m_soundchunks.size(); ++idx ) {
auto const previouschunkwidth { m_soundchunks[ idx ].second.threshold - m_soundchunks[ idx - 1 ].second.threshold };
m_soundchunks[ idx ].second.fadein = m_soundchunks[ idx ].second.threshold - 0.01f * m_crossfaderange * previouschunkwidth;
m_soundchunks[ idx ].second.fadein = static_cast<float>(m_soundchunks[ idx ].second.threshold) - 0.01f * static_cast<float>(m_crossfaderange) * static_cast<float>(previouschunkwidth);
/*
m_soundchunks[ idx ].second.fadein =
interpolate<float>(
@@ -82,11 +81,11 @@ sound_source::deserialize( cParser &Input, sound_type const Legacytype, int cons
m_crossfaderange * 0.01f );
*/
}
m_soundchunks.back().second.fadeout = std::max( Chunkrange, m_soundchunks.back().second.threshold );
m_soundchunks.back().second.fadeout = static_cast<float>(std::max( Chunkrange, m_soundchunks.back().second.threshold ));
// m_soundchunks.back().second.fadeout = m_soundchunks.back().second.threshold;
// test if the chunk table contains any actual samples while at it
for( auto &soundchunk : m_soundchunks ) {
if( soundchunk.first.buffer != null_handle ) {
for( auto &[chunkbuffer, chunkdata] : m_soundchunks ) {
if( chunkbuffer.buffer != null_handle ) {
m_soundchunksempty = false;
break;
}
@@ -117,24 +116,18 @@ sound_source::deserialize( cParser &Input, sound_type const Legacytype, int cons
}
}
if( Legacyparameters & sound_parameters::range ) {
if( Input.getTokens( 1, false ) ) {
Input >> m_range;
}
if (Legacyparameters & sound_parameters::range && Input.getTokens( 1, false )) {
Input >> m_range;
}
if( Legacyparameters & sound_parameters::amplitude ) {
if( Input.getTokens( 2, false ) ) {
Input
>> m_amplitudefactor
>> m_amplitudeoffset;
}
if (Legacyparameters & sound_parameters::amplitude && Input.getTokens( 2, false )) {
Input
>> m_amplitudefactor
>> m_amplitudeoffset;
}
if( Legacyparameters & sound_parameters::frequency ) {
if( Input.getTokens( 2, false ) ) {
Input
>> m_frequencyfactor
>> m_frequencyoffset;
}
if (Legacyparameters & sound_parameters::frequency && Input.getTokens( 2, false )) {
Input
>> m_frequencyfactor
>> m_frequencyoffset;
}
}
// restore parser behaviour
@@ -225,9 +218,9 @@ sound_source::deserialize_mapping( cParser &Input ) {
if( indexstart != std::string::npos ) {
auto const index { std::stoi( key.substr( indexstart, indexend - indexstart ) ) };
auto const pitch { Input.getToken<float>( false, "\n\r\t ,;" ) };
for( auto &chunk : m_soundchunks ) {
if( chunk.second.threshold == index ) {
chunk.second.pitch = pitch > 0.f ? pitch : 1.f;
for( auto &[chunkbuffer, chunkdata] : m_soundchunks ) {
if( chunkdata.threshold == index ) {
chunkdata.pitch = pitch > 0.f ? pitch : 1.f;
break;
}
}
@@ -240,13 +233,14 @@ sound_source::deserialize_mapping( cParser &Input ) {
m_crossfaderange = std::clamp( m_crossfaderange, 0, 100 );
}
else if( key == "placement:" ) {
using enum sound_placement;
auto const value { Input.getToken<std::string>( true, "\n\r\t ,;" ) };
std::map<std::string, sound_placement> const placements {
{ "internal", sound_placement::internal },
{ "engine", sound_placement::engine },
{ "external", sound_placement::external },
{ "custom", sound_placement::custom },
{ "general", sound_placement::general } };
std::map<std::string, sound_placement, std::less<>> const placements {
{ "internal", internal },
{ "engine", engine },
{ "external", external },
{ "custom", custom },
{ "general", general } };
auto lookup{ placements.find( value ) };
if( lookup != placements.end() ) {
m_placement = lookup->second;
@@ -262,7 +256,7 @@ sound_source::deserialize_mapping( cParser &Input ) {
}
else {
// floating point properties
std::map<std::string, float &> const properties {
std::map<std::string, float &, std::less<>> const properties {
{ "frequencyfactor:", m_frequencyfactor },
{ "frequencyoffset:", m_frequencyoffset },
{ "amplitudefactor:", m_amplitudefactor },
@@ -339,8 +333,8 @@ sound_source::copy_sounds( sound_source const &Source ) {
for( auto &sound : m_sounds ) {
sound.playing = 0;
}
for( auto &sound : m_soundchunks ) {
sound.first.playing = 0;
for( auto &[chunkbuffer, chunkdata] : m_soundchunks ) {
chunkbuffer.playing = 0;
}
return *this;
}
@@ -400,7 +394,7 @@ sound_source::play_basic() {
// dispatch appropriate sound
if( true == m_playbeginning
&& sound(sound_id::begin).buffer != null_handle) {
std::vector<sound_id> sounds { sound_id::begin, sound_id::main };
std::vector sounds { sound_id::begin, sound_id::main };
insert( std::begin( sounds ), std::end( sounds ) );
m_playbeginning = false;
}
@@ -424,14 +418,14 @@ sound_source::play_combined() {
auto const soundpoint { compute_combined_point() };
for( std::uint32_t idx = 0; idx < m_soundchunks.size(); ++idx ) {
auto const &soundchunk { m_soundchunks[ idx ] };
auto const &[chunkbuffer, chunkdata]{ m_soundchunks[ idx ] };
// a chunk covers range from fade in point, where it starts rising in volume over crossfade distance,
// lasts until fadeout - crossfade distance point, past which it grows quiet until fade out point where it ends
if( soundpoint < soundchunk.second.fadein ) { break; }
if( soundpoint >= soundchunk.second.fadeout ) { continue; }
if( soundpoint < chunkdata.fadein ) { break; }
if( soundpoint >= chunkdata.fadeout ) { continue; }
if( soundchunk.first.buffer == null_handle || ( (m_flags & (sound_flags::exclusive | sound_flags::looping)) != 0
&& soundchunk.first.playing > 0 ) ) {
if( chunkbuffer.buffer == null_handle || ( (m_flags & (sound_flags::exclusive | sound_flags::looping)) != 0
&& chunkbuffer.playing > 0 ) ) {
// combined sounds only play looped, single copy of each activated chunk
continue;
}
@@ -675,9 +669,9 @@ sound_source::update_combined( audio::openal_source &Source ) {
// for sound chunks, test whether the chunk should still be active given current value of the controlling variable
if( ( m_flags & ( sound_flags::exclusive | sound_flags::looping ) ) != 0 ) {
auto const soundpoint { compute_combined_point() };
auto const &soundchunk { m_soundchunks[ soundhandle ^ sound_id::chunk ] };
if( soundpoint < soundchunk.second.fadein
|| soundpoint >= soundchunk.second.fadeout ) {
auto const &[chunkbuffer, chunkdata]{ m_soundchunks[ soundhandle ^ sound_id::chunk ] };
if( soundpoint < chunkdata.fadein
|| soundpoint >= chunkdata.fadeout ) {
Source.stop();
update_counter( soundhandle, -1 );
return;
@@ -761,7 +755,7 @@ sound_source::update_crossfade( sound_handle const Chunk ) {
// relative pitch adjustment
// pitch of each chunk is modified based on ratio of the chunk's pitch to that of its neighbour
if( soundpoint < chunkdata.threshold ) {
if( soundpoint < static_cast<float>(chunkdata.threshold) ) {
if( chunkindex > 0 ) {
// interpolate between the pitch of previous chunk and this chunk's base pitch,
@@ -772,7 +766,7 @@ sound_source::update_crossfade( sound_handle const Chunk ) {
previouschunkdata.pitch / chunkdata.pitch,
1.f,
std::clamp(
( soundpoint - previouschunkdata.threshold ) / ( chunkdata.threshold - previouschunkdata.threshold ),
( soundpoint - static_cast<float>(previouschunkdata.threshold) ) / ( static_cast<float>(chunkdata.threshold - previouschunkdata.threshold) ),
0.f, 1.f ) );
}
}
@@ -787,7 +781,7 @@ sound_source::update_crossfade( sound_handle const Chunk ) {
1.f,
nextchunkdata.pitch / chunkdata.pitch,
std::clamp(
( soundpoint - chunkdata.threshold ) / ( nextchunkdata.threshold - chunkdata.threshold ),
( soundpoint - static_cast<float>(chunkdata.threshold) ) / ( static_cast<float>(nextchunkdata.threshold - chunkdata.threshold) ),
0.f, 1.f ) );
}
else {
@@ -801,7 +795,7 @@ sound_source::update_crossfade( sound_handle const Chunk ) {
if( chunkindex > 0 ) {
// chunks other than the first can have fadein
auto const fadeinwidth { chunkdata.threshold - chunkdata.fadein };
if( soundpoint < chunkdata.threshold ) {
if( soundpoint < static_cast<float>(chunkdata.threshold) ) {
float lineargain =
std::lerp(
0.f, 1.f,
@@ -809,8 +803,8 @@ sound_source::update_crossfade( sound_handle const Chunk ) {
( soundpoint - chunkdata.fadein ) / fadeinwidth,
0.f, 1.f ) );
m_properties.gain *=
lineargain /
(1 + (1 - lineargain) * -0.57); // approximation of logarytmic fade in
static_cast<float>(lineargain /
(1 + (1 - lineargain) * -0.57)); // approximation of logarytmic fade in
return;
}
}
@@ -828,8 +822,8 @@ sound_source::update_crossfade( sound_handle const Chunk ) {
std::clamp(
( soundpoint - fadeoutstart ) / fadeoutwidth,
0.f, 1.f ) );
m_properties.gain *= (-lineargain + 1) /
(1 + lineargain * -0.57); // approximation of logarytmic fade out
m_properties.gain *= static_cast<float>((-lineargain + 1) /
(1 + lineargain * -0.57)); // approximation of logarytmic fade out
return;
}
}
@@ -867,14 +861,14 @@ sound_source::empty() const {
// returns true if the source is emitting any sound
bool
sound_source::is_playing( bool const Includesoundends ) const {
sound_source::is_playing( bool const /*Includesoundends*/ ) const {
auto isplaying { sound(sound_id::begin).playing > 0 || sound(sound_id::main).playing > 0 };
if( false == isplaying
&& false == m_soundchunks.empty() ) {
// for emitters with sample tables check also if any of the chunks is active
for( auto const &soundchunk : m_soundchunks ) {
if( soundchunk.first.playing > 0 ) {
for( auto const &[chunkbuffer, chunkdata] : m_soundchunks ) {
if( chunkbuffer.playing > 0 ) {
isplaying = true;
break; // one will do
}
@@ -905,7 +899,7 @@ sound_source::has_bookends() const {
}
// returns location of the sound source in simulation region space
glm::dvec3 const
glm::dvec3
sound_source::location() const {
if( m_owner == nullptr ) {
@@ -927,7 +921,7 @@ sound_source::range( float const Range ) {
}
// returns defined range of the sound
float const
float
sound_source::range() const {
return m_range;
@@ -1016,7 +1010,7 @@ sound_source::update_soundproofing() {
void
sound_source::insert( sound_handle const Sound ) {
std::vector<sound_handle> sounds { Sound };
std::vector sounds { Sound };
return insert( std::begin( sounds ), std::end( sounds ) );
}

8
audio/sound.h
View File

@@ -108,7 +108,7 @@ public:
offset() const;
// sound source name setter/getter
void
name( std::string Name );
name( std::string const &Name );
std::string const &
name() const;
// playback starting point shift setter/getter
@@ -137,12 +137,12 @@ public:
bool
has_bookends() const;
// returns location of the sound source in simulation region space
glm::dvec3 const
glm::dvec3
location() const;
// returns defined range of the sound
void
range( float const Range );
float const
float
range() const;
// members
@@ -252,7 +252,7 @@ inline TDynamicObject const * sound_source::owner() const { return m_owner; }
inline void sound_source::offset( glm::vec3 const Offset ) { m_offset = Offset; }
inline glm::vec3 const & sound_source::offset() const { return m_offset; }
// sound source name setter/getter
inline void sound_source::name( std::string Name ) { m_name = Name; }
inline void sound_source::name( std::string const &Name ) { m_name = Name; }
inline std::string const & sound_source::name() const { return m_name; }
// playback starting point shift setter/getter
inline void sound_source::start( float const Offset ) { m_startoffset = Offset; }