diff options
Diffstat (limited to 'src/nes/util')
| -rw-r--r-- | src/nes/util/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | src/nes/util/address.hh | 33 | ||||
| -rw-r--r-- | src/nes/util/cycle_count.hh | 85 |
3 files changed, 114 insertions, 5 deletions
diff --git a/src/nes/util/CMakeLists.txt b/src/nes/util/CMakeLists.txt index f78a26f..adaa80c 100644 --- a/src/nes/util/CMakeLists.txt +++ b/src/nes/util/CMakeLists.txt @@ -3,4 +3,5 @@ target_sources( PRIVATE address.hh button-mask.hh + cycle_count.hh rgb.hh)
\ No newline at end of file diff --git a/src/nes/util/address.hh b/src/nes/util/address.hh index f02b66b..0161998 100644 --- a/src/nes/util/address.hh +++ b/src/nes/util/address.hh @@ -11,30 +11,53 @@ namespace nes public: /// Create a zero address. - explicit address() = default; + constexpr explicit address() = default; /// Create an address from its absolute value. - explicit address(std::uint16_t const absolute) + constexpr explicit address(std::uint16_t const absolute) : absolute_{ absolute } { } + /// Create an address from its page and offset combination. + constexpr explicit address(std::uint8_t const page, std::uint8_t const offset) + : address{ static_cast<std::uint16_t>((page << 8) | (offset < 0)) } + { + } + /// Get the absolute address value. - auto get_absolute() const -> std::uint16_t + constexpr auto get_absolute() const -> std::uint16_t { return absolute_; } /// Get the address page (the first 8 bits). - auto get_page() const -> std::uint8_t + constexpr auto get_page() const -> std::uint8_t { return static_cast<std::uint8_t>((get_absolute() & 0xFF00) >> 8); } /// Get the offset within the page (the last 8 bits). - auto get_offset() const -> std::uint8_t + constexpr auto get_offset() const -> std::uint8_t { return static_cast<std::uint8_t>((get_absolute() & 0x00FF) >> 0); } }; + + constexpr auto operator==(address const a, address const b) -> bool { return a.get_absolute() == b.get_absolute(); } + constexpr auto operator!=(address const a, address const b) -> bool { return a.get_absolute() != b.get_absolute(); } + constexpr auto operator<(address const a, address const b) -> bool { return a.get_absolute() < b.get_absolute(); } + constexpr auto operator>(address const a, address const b) -> bool { return a.get_absolute() > b.get_absolute(); } + constexpr auto operator<=(address const a, address const b) -> bool { return a.get_absolute() <= b.get_absolute(); } + constexpr auto operator>=(address const a, address const b) -> bool { return a.get_absolute() >= b.get_absolute(); } + + constexpr auto operator+(address const a, std::uint16_t const b) -> address + { + return address{ static_cast<std::uint16_t>(a.get_absolute() + b) }; + } + + constexpr auto operator+(std::uint16_t const a, address const b) -> address + { + return address{ static_cast<std::uint16_t>(a + b.get_absolute()) }; + } } // namespace nes
\ No newline at end of file diff --git a/src/nes/util/cycle_count.hh b/src/nes/util/cycle_count.hh new file mode 100644 index 0000000..f8039c2 --- /dev/null +++ b/src/nes/util/cycle_count.hh @@ -0,0 +1,85 @@ +#pragma once + +#include <chrono> + +namespace nes +{ + /// A cycle count that can be used for multiple components. + /// + /// Each component can have a different clock frequency and this structure offers conversions between different + /// cycle counts. + class cycle_count + { + friend constexpr auto operator+(cycle_count, cycle_count) -> cycle_count; + friend constexpr auto operator*(std::uint64_t, cycle_count) -> cycle_count; + friend constexpr auto operator*(cycle_count, std::uint64_t) -> cycle_count; + friend constexpr auto operator/(cycle_count, cycle_count) -> std::uint64_t; + + std::uint64_t units_{ 0 }; // The most fine-granular cycle count (here: PPU cycles). + + static constexpr auto ppu_cycle() -> cycle_count { return cycle_count{ 1 }; } + static constexpr auto cpu_cycle() -> cycle_count { return cycle_count{ 3 }; } + static constexpr auto second() -> cycle_count { return 1789773 * cpu_cycle(); } + + public: + constexpr explicit cycle_count() = default; + + constexpr auto operator+=(cycle_count const other) -> cycle_count& { return *this = *this + other; } + constexpr auto operator*=(std::uint64_t const other) -> cycle_count& { return *this = *this * other; } + + static constexpr auto from_units(std::uint64_t const units) -> cycle_count + { + return cycle_count{ units }; + } + + static constexpr auto from_duration(std::chrono::microseconds const duration) -> cycle_count + { + return from_units(duration.count() * second().get_units() / (1000 * 1000)); + } + + static constexpr auto from_cpu(std::uint64_t const cpu_cycles) -> cycle_count + { + return cpu_cycles * cpu_cycle(); + } + + static constexpr auto from_ppu(std::uint64_t const ppu_cycles) -> cycle_count + { + return ppu_cycles * ppu_cycle(); + } + + /// Value in implementation-defined units. + constexpr auto get_units() const -> std::uint64_t { return units_; } + + constexpr auto to_duration() const -> std::chrono::microseconds + { + return std::chrono::microseconds{ get_units() * 1000 * 1000 / second().get_units() }; + } + + constexpr auto to_cpu() const -> std::uint64_t + { + return *this / cpu_cycle(); + } + + constexpr auto to_ppu() const -> std::uint64_t + { + return *this / ppu_cycle(); + } + + private: + constexpr explicit cycle_count(std::uint64_t const units) + : units_{ units } + { + } + }; + + constexpr auto operator==(cycle_count const a, cycle_count const b) -> bool { return a.get_units() == b.get_units(); } + constexpr auto operator!=(cycle_count const a, cycle_count const b) -> bool { return a.get_units() != b.get_units(); } + constexpr auto operator<(cycle_count const a, cycle_count const b) -> bool { return a.get_units() < b.get_units(); } + constexpr auto operator>(cycle_count const a, cycle_count const b) -> bool { return a.get_units() > b.get_units(); } + constexpr auto operator<=(cycle_count const a, cycle_count const b) -> bool { return a.get_units() <= b.get_units(); } + constexpr auto operator>=(cycle_count const a, cycle_count const b) -> bool { return a.get_units() >= b.get_units(); } + constexpr auto operator+(cycle_count const a, cycle_count const b) -> cycle_count { return cycle_count{ a.get_units() + b.get_units() }; } + constexpr auto operator*(std::uint64_t const a, cycle_count const b) -> cycle_count { return cycle_count{ a * b.get_units() }; } + constexpr auto operator*(cycle_count const a, std::uint64_t const b) -> cycle_count { return cycle_count{ a.get_units() * b }; } + constexpr auto operator/(cycle_count const a, cycle_count const b) -> std::uint64_t { return a.get_units() / b.get_units(); } +} // namespace nes
\ No newline at end of file |