forked from suyu/suyu
fix: Clang fix
This commit is contained in:
parent
09c26cac1c
commit
777587ef0e
93 changed files with 254 additions and 253 deletions
|
@ -8,8 +8,8 @@
|
|||
namespace AudioCore::AudioIn {
|
||||
|
||||
In::In(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
|
||||
: manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
|
||||
session_id_} {}
|
||||
: manager{manager_}, parent_mutex{manager.mutex}, event{event_},
|
||||
system{system_, event, session_id_} {}
|
||||
|
||||
void In::Free() {
|
||||
std::scoped_lock l{parent_mutex};
|
||||
|
|
|
@ -14,8 +14,8 @@
|
|||
namespace AudioCore::AudioIn {
|
||||
|
||||
System::System(Core::System& system_, Kernel::KEvent* event_, const size_t session_id_)
|
||||
: system{system_}, buffer_event{event_},
|
||||
session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}
|
||||
: system{system_}, buffer_event{event_}, session_id{session_id_},
|
||||
session{std::make_unique<DeviceSession>(system_)} {}
|
||||
|
||||
System::~System() {
|
||||
Finalize();
|
||||
|
|
|
@ -8,8 +8,8 @@
|
|||
namespace AudioCore::AudioOut {
|
||||
|
||||
Out::Out(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
|
||||
: manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
|
||||
session_id_} {}
|
||||
: manager{manager_}, parent_mutex{manager.mutex}, event{event_},
|
||||
system{system_, event, session_id_} {}
|
||||
|
||||
void Out::Free() {
|
||||
std::scoped_lock l{parent_mutex};
|
||||
|
|
|
@ -14,8 +14,8 @@
|
|||
namespace AudioCore::AudioOut {
|
||||
|
||||
System::System(Core::System& system_, Kernel::KEvent* event_, size_t session_id_)
|
||||
: system{system_}, buffer_event{event_},
|
||||
session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}
|
||||
: system{system_}, buffer_event{event_}, session_id{session_id_},
|
||||
session{std::make_unique<DeviceSession>(system_)} {}
|
||||
|
||||
System::~System() {
|
||||
Finalize();
|
||||
|
|
|
@ -19,10 +19,9 @@ namespace AudioCore::Renderer {
|
|||
|
||||
InfoUpdater::InfoUpdater(std::span<const u8> input_, std::span<u8> output_,
|
||||
Kernel::KProcess* process_handle_, BehaviorInfo& behaviour_)
|
||||
: input{input_.data() + sizeof(UpdateDataHeader)},
|
||||
input_origin{input_}, output{output_.data() + sizeof(UpdateDataHeader)},
|
||||
output_origin{output_}, in_header{reinterpret_cast<const UpdateDataHeader*>(
|
||||
input_origin.data())},
|
||||
: input{input_.data() + sizeof(UpdateDataHeader)}, input_origin{input_},
|
||||
output{output_.data() + sizeof(UpdateDataHeader)}, output_origin{output_},
|
||||
in_header{reinterpret_cast<const UpdateDataHeader*>(input_origin.data())},
|
||||
out_header{reinterpret_cast<UpdateDataHeader*>(output_origin.data())},
|
||||
expected_input_size{input_.size()}, expected_output_size{output_.size()},
|
||||
process_handle{process_handle_}, behaviour{behaviour_} {
|
||||
|
|
|
@ -13,8 +13,8 @@ PoolMapper::PoolMapper(Kernel::KProcess* process_handle_, bool force_map_)
|
|||
|
||||
PoolMapper::PoolMapper(Kernel::KProcess* process_handle_, std::span<MemoryPoolInfo> pool_infos_,
|
||||
u32 pool_count_, bool force_map_)
|
||||
: process_handle{process_handle_}, pool_infos{pool_infos_.data()},
|
||||
pool_count{pool_count_}, force_map{force_map_} {}
|
||||
: process_handle{process_handle_}, pool_infos{pool_infos_.data()}, pool_count{pool_count_},
|
||||
force_map{force_map_} {}
|
||||
|
||||
void PoolMapper::ClearUseState(std::span<MemoryPoolInfo> pools, const u32 count) {
|
||||
for (u32 i = 0; i < count; i++) {
|
||||
|
|
|
@ -12,8 +12,7 @@
|
|||
|
||||
namespace Common {
|
||||
template <typename VaType, size_t AddressSpaceBits>
|
||||
concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >=
|
||||
AddressSpaceBits;
|
||||
concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >= AddressSpaceBits;
|
||||
|
||||
struct EmptyStruct {};
|
||||
|
||||
|
|
|
@ -16,9 +16,9 @@ concept IsContiguousContainer = std::contiguous_iterator<typename T::iterator>;
|
|||
// is available on all supported platforms.
|
||||
template <typename Derived, typename Base>
|
||||
concept DerivedFrom = requires {
|
||||
std::is_base_of_v<Base, Derived>;
|
||||
std::is_convertible_v<const volatile Derived*, const volatile Base*>;
|
||||
};
|
||||
std::is_base_of_v<Base, Derived>;
|
||||
std::is_convertible_v<const volatile Derived*, const volatile Base*>;
|
||||
};
|
||||
|
||||
// TODO: Replace with std::convertible_to when libc++ implements it.
|
||||
template <typename From, typename To>
|
||||
|
|
|
@ -598,14 +598,14 @@ public:
|
|||
template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
|
||||
std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
|
||||
constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
|
||||
: impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
|
||||
detail::default_constructor_tag{}} {}
|
||||
: impl_base{unexpect_t{}, std::move(e.value())},
|
||||
ctor_base{detail::default_constructor_tag{}} {}
|
||||
|
||||
template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
|
||||
std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
|
||||
constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
|
||||
: impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
|
||||
detail::default_constructor_tag{}} {}
|
||||
: impl_base{unexpect_t{}, std::move(e.value())},
|
||||
ctor_base{detail::default_constructor_tag{}} {}
|
||||
|
||||
template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
|
||||
constexpr explicit Expected(unexpect_t, Args&&... args)
|
||||
|
|
|
@ -238,10 +238,8 @@ public:
|
|||
|
||||
template <typename T>
|
||||
concept HasRedBlackKeyType = requires {
|
||||
{
|
||||
std::is_same<typename T::RedBlackKeyType, void>::value
|
||||
} -> std::convertible_to<bool>;
|
||||
};
|
||||
{ std::is_same<typename T::RedBlackKeyType, void>::value } -> std::convertible_to<bool>;
|
||||
};
|
||||
|
||||
namespace impl {
|
||||
|
||||
|
|
|
@ -25,12 +25,12 @@ public:
|
|||
|
||||
MultiLevelPageTable(MultiLevelPageTable&& other) noexcept
|
||||
: address_space_bits{std::exchange(other.address_space_bits, 0)},
|
||||
first_level_bits{std::exchange(other.first_level_bits, 0)}, page_bits{std::exchange(
|
||||
other.page_bits, 0)},
|
||||
first_level_bits{std::exchange(other.first_level_bits, 0)},
|
||||
page_bits{std::exchange(other.page_bits, 0)},
|
||||
first_level_shift{std::exchange(other.first_level_shift, 0)},
|
||||
first_level_chunk_size{std::exchange(other.first_level_chunk_size, 0)},
|
||||
first_level_map{std::move(other.first_level_map)}, base_ptr{std::exchange(other.base_ptr,
|
||||
nullptr)} {}
|
||||
first_level_map{std::move(other.first_level_map)},
|
||||
base_ptr{std::exchange(other.base_ptr, nullptr)} {}
|
||||
|
||||
MultiLevelPageTable& operator=(MultiLevelPageTable&& other) noexcept {
|
||||
address_space_bits = std::exchange(other.address_space_bits, 0);
|
||||
|
|
|
@ -18,9 +18,9 @@ namespace ranges {
|
|||
|
||||
template <typename T>
|
||||
concept range = requires(T& t) {
|
||||
begin(t);
|
||||
end(t);
|
||||
};
|
||||
begin(t);
|
||||
end(t);
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
concept input_range = range<T>;
|
||||
|
|
|
@ -103,9 +103,9 @@ concept IsRBEntry = CheckRBEntry<T>::value;
|
|||
|
||||
template <typename T>
|
||||
concept HasRBEntry = requires(T& t, const T& ct) {
|
||||
{ t.GetRBEntry() } -> std::same_as<RBEntry<T>&>;
|
||||
{ ct.GetRBEntry() } -> std::same_as<const RBEntry<T>&>;
|
||||
};
|
||||
{ t.GetRBEntry() } -> std::same_as<RBEntry<T>&>;
|
||||
{ ct.GetRBEntry() } -> std::same_as<const RBEntry<T>&>;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
requires HasRBEntry<T>
|
||||
|
|
|
@ -362,7 +362,9 @@ public:
|
|||
// _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all
|
||||
// component names (x<->r) and permutations (xy<->yx)
|
||||
#define _DEFINE_SWIZZLER2(a, b, name) \
|
||||
[[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
|
||||
[[nodiscard]] constexpr Vec2<T> name() const { \
|
||||
return Vec2<T>(a, b); \
|
||||
}
|
||||
#define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4) \
|
||||
_DEFINE_SWIZZLER2(a, b, a##b); \
|
||||
_DEFINE_SWIZZLER2(a, b, a2##b2); \
|
||||
|
@ -555,7 +557,9 @@ public:
|
|||
// DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and
|
||||
// permutations (xy<->yx)
|
||||
#define _DEFINE_SWIZZLER2(a, b, name) \
|
||||
[[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
|
||||
[[nodiscard]] constexpr Vec2<T> name() const { \
|
||||
return Vec2<T>(a, b); \
|
||||
}
|
||||
#define DEFINE_SWIZZLER2_COMP1(a, a2) \
|
||||
_DEFINE_SWIZZLER2(a, a, a##a); \
|
||||
_DEFINE_SWIZZLER2(a, a, a2##a2)
|
||||
|
@ -580,7 +584,9 @@ public:
|
|||
#undef _DEFINE_SWIZZLER2
|
||||
|
||||
#define _DEFINE_SWIZZLER3(a, b, c, name) \
|
||||
[[nodiscard]] constexpr Vec3<T> name() const { return Vec3<T>(a, b, c); }
|
||||
[[nodiscard]] constexpr Vec3<T> name() const { \
|
||||
return Vec3<T>(a, b, c); \
|
||||
}
|
||||
#define DEFINE_SWIZZLER3_COMP1(a, a2) \
|
||||
_DEFINE_SWIZZLER3(a, a, a, a##a##a); \
|
||||
_DEFINE_SWIZZLER3(a, a, a, a2##a2##a2)
|
||||
|
|
|
@ -33,8 +33,8 @@ public:
|
|||
VirtualBuffer& operator=(const VirtualBuffer&) = delete;
|
||||
|
||||
VirtualBuffer(VirtualBuffer&& other) noexcept
|
||||
: alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr),
|
||||
nullptr} {}
|
||||
: alloc_size{std::exchange(other.alloc_size, 0)},
|
||||
base_ptr{std::exchange(other.base_ptr), nullptr} {}
|
||||
|
||||
VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
|
||||
alloc_size = std::exchange(other.alloc_size, 0);
|
||||
|
|
|
@ -8,8 +8,8 @@
|
|||
namespace Common::X64 {
|
||||
|
||||
NativeClock::NativeClock(u64 rdtsc_frequency_)
|
||||
: rdtsc_frequency{rdtsc_frequency_}, ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den,
|
||||
rdtsc_frequency)},
|
||||
: rdtsc_frequency{rdtsc_frequency_},
|
||||
ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency)},
|
||||
us_rdtsc_factor{GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency)},
|
||||
ms_rdtsc_factor{GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency)},
|
||||
cntpct_rdtsc_factor{GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency)},
|
||||
|
|
|
@ -16,8 +16,8 @@ using namespace Common::Literals;
|
|||
class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
|
||||
public:
|
||||
explicit DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess* process)
|
||||
: m_parent{parent}, m_memory(process->GetMemory()),
|
||||
m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()},
|
||||
: m_parent{parent}, m_memory(process->GetMemory()), m_process(process),
|
||||
m_debugger_enabled{parent.m_system.DebuggerEnabled()},
|
||||
m_check_memory_access{m_debugger_enabled ||
|
||||
!Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
|
||||
|
||||
|
|
|
@ -16,8 +16,8 @@ using namespace Common::Literals;
|
|||
class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
|
||||
public:
|
||||
explicit DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess* process)
|
||||
: m_parent{parent}, m_memory(process->GetMemory()),
|
||||
m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()},
|
||||
: m_parent{parent}, m_memory(process->GetMemory()), m_process(process),
|
||||
m_debugger_enabled{parent.m_system.DebuggerEnabled()},
|
||||
m_check_memory_access{m_debugger_enabled ||
|
||||
!Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
|
||||
|
||||
|
|
|
@ -29,8 +29,8 @@ constexpr std::array partition_names{
|
|||
|
||||
XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index)
|
||||
: file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
|
||||
partitions(partition_names.size()),
|
||||
partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} {
|
||||
partitions(partition_names.size()), partitions_raw(partition_names.size()),
|
||||
keys{Core::Crypto::KeyManager::Instance()} {
|
||||
const auto header_status = TryReadHeader();
|
||||
if (header_status != Loader::ResultStatus::Success) {
|
||||
status = header_status;
|
||||
|
|
|
@ -91,8 +91,12 @@ public:
|
|||
}
|
||||
|
||||
#define DECLARE_PATH_FLAG_HANDLER(__WHICH__) \
|
||||
constexpr bool Is##__WHICH__##Allowed() const { return (m_value & __WHICH__##Flag) != 0; } \
|
||||
constexpr void Allow##__WHICH__() { m_value |= __WHICH__##Flag; }
|
||||
constexpr bool Is##__WHICH__##Allowed() const { \
|
||||
return (m_value & __WHICH__##Flag) != 0; \
|
||||
} \
|
||||
constexpr void Allow##__WHICH__() { \
|
||||
m_value |= __WHICH__##Flag; \
|
||||
}
|
||||
|
||||
DECLARE_PATH_FLAG_HANDLER(WindowsPath)
|
||||
DECLARE_PATH_FLAG_HANDLER(RelativePath)
|
||||
|
|
|
@ -19,9 +19,9 @@
|
|||
namespace FileSys {
|
||||
|
||||
NSP::NSP(VirtualFile file_, u64 title_id_, std::size_t program_index_)
|
||||
: file(std::move(file_)), expected_program_id(title_id_),
|
||||
program_index(program_index_), status{Loader::ResultStatus::Success},
|
||||
pfs(std::make_shared<PartitionFilesystem>(file)), keys{Core::Crypto::KeyManager::Instance()} {
|
||||
: file(std::move(file_)), expected_program_id(title_id_), program_index(program_index_),
|
||||
status{Loader::ResultStatus::Success}, pfs(std::make_shared<PartitionFilesystem>(file)),
|
||||
keys{Core::Crypto::KeyManager::Instance()} {
|
||||
if (pfs->GetStatus() != Loader::ResultStatus::Success) {
|
||||
status = pfs->GetStatus();
|
||||
return;
|
||||
|
|
|
@ -44,8 +44,8 @@ static bool CalculateHMAC256(Destination* out, const SourceKey* key, std::size_t
|
|||
}
|
||||
|
||||
NAX::NAX(VirtualFile file_)
|
||||
: header(std::make_unique<NAXHeader>()),
|
||||
file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
|
||||
: header(std::make_unique<NAXHeader>()), file(std::move(file_)),
|
||||
keys{Core::Crypto::KeyManager::Instance()} {
|
||||
std::string path = Common::FS::SanitizePath(file->GetFullPath());
|
||||
static const std::regex nax_path_regex("/registered/(000000[0-9A-F]{2})/([0-9A-F]{32})\\.nca",
|
||||
std::regex_constants::ECMAScript |
|
||||
|
@ -62,8 +62,8 @@ NAX::NAX(VirtualFile file_)
|
|||
}
|
||||
|
||||
NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
|
||||
: header(std::make_unique<NAXHeader>()),
|
||||
file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
|
||||
: header(std::make_unique<NAXHeader>()), file(std::move(file_)),
|
||||
keys{Core::Crypto::KeyManager::Instance()} {
|
||||
Core::Crypto::SHA256Hash hash{};
|
||||
mbedtls_sha256_ret(nca_id.data(), nca_id.size(), hash.data(), 0);
|
||||
status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],
|
||||
|
|
|
@ -24,7 +24,9 @@ private:
|
|||
friend class ::Kernel::KClassTokenGenerator; \
|
||||
static constexpr inline auto ObjectType = ::Kernel::KClassTokenGenerator::ObjectType::CLASS; \
|
||||
static constexpr inline const char* const TypeName = #CLASS; \
|
||||
static constexpr inline ClassTokenType ClassToken() { return ::Kernel::ClassToken<CLASS>; } \
|
||||
static constexpr inline ClassTokenType ClassToken() { \
|
||||
return ::Kernel::ClassToken<CLASS>; \
|
||||
} \
|
||||
\
|
||||
public: \
|
||||
SUYU_NON_COPYABLE(CLASS); \
|
||||
|
@ -35,9 +37,15 @@ public:
|
|||
constexpr ClassTokenType Token = ClassToken(); \
|
||||
return TypeObj(TypeName, Token); \
|
||||
} \
|
||||
static constexpr const char* GetStaticTypeName() { return TypeName; } \
|
||||
virtual TypeObj GetTypeObj() ATTRIBUTE { return GetStaticTypeObj(); } \
|
||||
virtual const char* GetTypeName() ATTRIBUTE { return GetStaticTypeName(); } \
|
||||
static constexpr const char* GetStaticTypeName() { \
|
||||
return TypeName; \
|
||||
} \
|
||||
virtual TypeObj GetTypeObj() ATTRIBUTE { \
|
||||
return GetStaticTypeObj(); \
|
||||
} \
|
||||
virtual const char* GetTypeName() ATTRIBUTE { \
|
||||
return GetStaticTypeName(); \
|
||||
} \
|
||||
\
|
||||
private: \
|
||||
constexpr bool operator!=(const TypeObj& rhs)
|
||||
|
|
|
@ -128,8 +128,8 @@ KVirtualAddress KMemoryRegionTree::GetRandomAlignedRegion(size_t size, size_t al
|
|||
|
||||
KMemoryLayout::KMemoryLayout()
|
||||
: m_virtual_tree{m_memory_region_allocator}, m_physical_tree{m_memory_region_allocator},
|
||||
m_virtual_linear_tree{m_memory_region_allocator}, m_physical_linear_tree{
|
||||
m_memory_region_allocator} {}
|
||||
m_virtual_linear_tree{m_memory_region_allocator},
|
||||
m_physical_linear_tree{m_memory_region_allocator} {}
|
||||
|
||||
void KMemoryLayout::InitializeLinearMemoryRegionTrees(KPhysicalAddress aligned_linear_phys_start,
|
||||
KVirtualAddress linear_virtual_start) {
|
||||
|
|
|
@ -17,38 +17,32 @@ namespace Kernel {
|
|||
class KThread;
|
||||
|
||||
template <typename T>
|
||||
concept KPriorityQueueAffinityMask = !
|
||||
std::is_reference_v<T>&& requires(T& t) {
|
||||
{ t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
|
||||
{ t.SetAffinityMask(0) };
|
||||
concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T& t) {
|
||||
{ t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
|
||||
{ t.SetAffinityMask(0) };
|
||||
|
||||
{ t.GetAffinity(0) } -> std::same_as<bool>;
|
||||
{ t.SetAffinity(0, false) };
|
||||
{ t.SetAll() };
|
||||
};
|
||||
{ t.GetAffinity(0) } -> std::same_as<bool>;
|
||||
{ t.SetAffinity(0, false) };
|
||||
{ t.SetAll() };
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
concept KPriorityQueueMember = !
|
||||
std::is_reference_v<T>&& requires(T& t) {
|
||||
{ typename T::QueueEntry() };
|
||||
{ (typename T::QueueEntry()).Initialize() };
|
||||
{ (typename T::QueueEntry()).SetPrev(std::addressof(t)) };
|
||||
{ (typename T::QueueEntry()).SetNext(std::addressof(t)) };
|
||||
{ (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>;
|
||||
{ (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>;
|
||||
{
|
||||
t.GetPriorityQueueEntry(0)
|
||||
} -> std::same_as<typename T::QueueEntry&>;
|
||||
concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T& t) {
|
||||
{ typename T::QueueEntry() };
|
||||
{ (typename T::QueueEntry()).Initialize() };
|
||||
{ (typename T::QueueEntry()).SetPrev(std::addressof(t)) };
|
||||
{ (typename T::QueueEntry()).SetNext(std::addressof(t)) };
|
||||
{ (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>;
|
||||
{ (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>;
|
||||
{ t.GetPriorityQueueEntry(0) } -> std::same_as<typename T::QueueEntry&>;
|
||||
|
||||
{ t.GetAffinityMask() };
|
||||
{
|
||||
std::remove_cvref_t<decltype(t.GetAffinityMask())>()
|
||||
} -> KPriorityQueueAffinityMask;
|
||||
{ t.GetAffinityMask() };
|
||||
{ std::remove_cvref_t<decltype(t.GetAffinityMask())>() } -> KPriorityQueueAffinityMask;
|
||||
|
||||
{ t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
|
||||
{ t.GetPriority() } -> Common::ConvertibleTo<s32>;
|
||||
{ t.IsDummyThread() } -> Common::ConvertibleTo<bool>;
|
||||
};
|
||||
{ t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
|
||||
{ t.GetPriority() } -> Common::ConvertibleTo<s32>;
|
||||
{ t.IsDummyThread() } -> Common::ConvertibleTo<bool>;
|
||||
};
|
||||
|
||||
template <typename Member, size_t NumCores_, int LowestPriority, int HighestPriority>
|
||||
requires KPriorityQueueMember<Member>
|
||||
|
|
|
@ -10,11 +10,10 @@
|
|||
namespace Kernel {
|
||||
|
||||
template <typename T>
|
||||
concept KLockable = !
|
||||
std::is_reference_v<T>&& requires(T& t) {
|
||||
{ t.Lock() } -> std::same_as<void>;
|
||||
{ t.Unlock() } -> std::same_as<void>;
|
||||
};
|
||||
concept KLockable = !std::is_reference_v<T> && requires(T& t) {
|
||||
{ t.Lock() } -> std::same_as<void>;
|
||||
{ t.Unlock() } -> std::same_as<void>;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
requires KLockable<T>
|
||||
|
|
|
@ -458,9 +458,13 @@ constexpr inline Result __TmpCurrentResultReference = ResultSuccess;
|
|||
if (true)
|
||||
|
||||
#define R_CONVERT(catch_type, convert_type) \
|
||||
R_CATCH(catch_type) { R_THROW(static_cast<Result>(convert_type)); }
|
||||
R_CATCH(catch_type) { \
|
||||
R_THROW(static_cast<Result>(convert_type)); \
|
||||
}
|
||||
|
||||
#define R_CONVERT_ALL(convert_type) \
|
||||
R_CATCH_ALL() { R_THROW(static_cast<Result>(convert_type)); }
|
||||
R_CATCH_ALL() { \
|
||||
R_THROW(static_cast<Result>(convert_type)); \
|
||||
}
|
||||
|
||||
#define R_ASSERT(res_expr) ASSERT(R_SUCCEEDED(res_expr))
|
||||
|
|
|
@ -1028,8 +1028,8 @@ void Module::Interface::TrySelectUserWithoutInteraction(HLERequestContext& ctx)
|
|||
Module::Interface::Interface(std::shared_ptr<Module> module_,
|
||||
std::shared_ptr<ProfileManager> profile_manager_,
|
||||
Core::System& system_, const char* name)
|
||||
: ServiceFramework{system_, name}, module{std::move(module_)}, profile_manager{std::move(
|
||||
profile_manager_)} {}
|
||||
: ServiceFramework{system_, name}, module{std::move(module_)},
|
||||
profile_manager{std::move(profile_manager_)} {}
|
||||
|
||||
Module::Interface::~Interface() = default;
|
||||
|
||||
|
|
|
@ -18,9 +18,8 @@ namespace Service::AM::Frontend {
|
|||
|
||||
Cabinet::Cabinet(Core::System& system_, std::shared_ptr<Applet> applet_,
|
||||
LibraryAppletMode applet_mode_, const Core::Frontend::CabinetApplet& frontend_)
|
||||
: FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_}, service_context{
|
||||
system_,
|
||||
"CabinetApplet"} {
|
||||
: FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_},
|
||||
service_context{system_, "CabinetApplet"} {
|
||||
|
||||
availability_change_event =
|
||||
service_context.CreateEvent("CabinetApplet:AvailabilityChangeEvent");
|
||||
|
|
|
@ -18,8 +18,8 @@ namespace Service::AM {
|
|||
|
||||
IApplicationProxy::IApplicationProxy(Core::System& system_, std::shared_ptr<Applet> applet,
|
||||
Kernel::KProcess* process, WindowSystem& window_system)
|
||||
: ServiceFramework{system_, "IApplicationProxy"},
|
||||
m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
|
||||
: ServiceFramework{system_, "IApplicationProxy"}, m_window_system{window_system},
|
||||
m_process{process}, m_applet{std::move(applet)} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&IApplicationProxy::GetCommonStateGetter>, "GetCommonStateGetter"},
|
||||
|
|
|
@ -165,8 +165,8 @@ std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(Core::System& syste
|
|||
|
||||
ILibraryAppletCreator::ILibraryAppletCreator(Core::System& system_, std::shared_ptr<Applet> applet,
|
||||
WindowSystem& window_system)
|
||||
: ServiceFramework{system_, "ILibraryAppletCreator"},
|
||||
m_window_system{window_system}, m_applet{std::move(applet)} {
|
||||
: ServiceFramework{system_, "ILibraryAppletCreator"}, m_window_system{window_system},
|
||||
m_applet{std::move(applet)} {
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&ILibraryAppletCreator::CreateLibraryApplet>, "CreateLibraryApplet"},
|
||||
{1, nullptr, "TerminateAllLibraryApplets"},
|
||||
|
|
|
@ -20,8 +20,8 @@ namespace Service::AM {
|
|||
|
||||
ILibraryAppletProxy::ILibraryAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
|
||||
Kernel::KProcess* process, WindowSystem& window_system)
|
||||
: ServiceFramework{system_, "ILibraryAppletProxy"},
|
||||
m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
|
||||
: ServiceFramework{system_, "ILibraryAppletProxy"}, m_window_system{window_system},
|
||||
m_process{process}, m_applet{std::move(applet)} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&ILibraryAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},
|
||||
|
|
|
@ -16,8 +16,8 @@ namespace Service::AM {
|
|||
|
||||
ISelfController::ISelfController(Core::System& system_, std::shared_ptr<Applet> applet,
|
||||
Kernel::KProcess* process)
|
||||
: ServiceFramework{system_, "ISelfController"}, m_process{process}, m_applet{
|
||||
std::move(applet)} {
|
||||
: ServiceFramework{system_, "ISelfController"}, m_process{process},
|
||||
m_applet{std::move(applet)} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&ISelfController::Exit>, "Exit"},
|
||||
|
|
|
@ -20,8 +20,8 @@ namespace Service::AM {
|
|||
|
||||
ISystemAppletProxy::ISystemAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
|
||||
Kernel::KProcess* process, WindowSystem& window_system)
|
||||
: ServiceFramework{system_, "ISystemAppletProxy"},
|
||||
m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
|
||||
: ServiceFramework{system_, "ISystemAppletProxy"}, m_window_system{window_system},
|
||||
m_process{process}, m_applet{std::move(applet)} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&ISystemAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},
|
||||
|
|
|
@ -11,8 +11,8 @@ namespace Service::AM {
|
|||
|
||||
IWindowController::IWindowController(Core::System& system_, std::shared_ptr<Applet> applet,
|
||||
WindowSystem& window_system)
|
||||
: ServiceFramework{system_, "IWindowController"},
|
||||
m_window_system{window_system}, m_applet{std::move(applet)} {
|
||||
: ServiceFramework{system_, "IWindowController"}, m_window_system{window_system},
|
||||
m_applet{std::move(applet)} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, nullptr, "CreateWindow"},
|
||||
|
|
|
@ -9,8 +9,8 @@ namespace Service::AOC {
|
|||
constexpr Result ResultNoPurchasedProductInfoAvailable{ErrorModule::NIMShop, 400};
|
||||
|
||||
IPurchaseEventManager::IPurchaseEventManager(Core::System& system_)
|
||||
: ServiceFramework{system_, "IPurchaseEventManager"}, service_context{system,
|
||||
"IPurchaseEventManager"} {
|
||||
: ServiceFramework{system_, "IPurchaseEventManager"},
|
||||
service_context{system, "IPurchaseEventManager"} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"},
|
||||
|
|
|
@ -12,9 +12,8 @@ IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
|
|||
const std::string& device_name, const AudioInParameter& in_params,
|
||||
Kernel::KProcess* handle, u64 applet_resource_user_id)
|
||||
: ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"},
|
||||
event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_,
|
||||
manager, event,
|
||||
session_id)} {
|
||||
event{service_context.CreateEvent("AudioInEvent")},
|
||||
impl{std::make_shared<In>(system_, manager, event, session_id)} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&IAudioIn::GetAudioInState>, "GetAudioInState"},
|
||||
|
|
|
@ -10,8 +10,8 @@ namespace Service::Audio {
|
|||
using namespace AudioCore::AudioIn;
|
||||
|
||||
IAudioInManager::IAudioInManager(Core::System& system_)
|
||||
: ServiceFramework{system_, "audin:u"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
|
||||
system_)} {
|
||||
: ServiceFramework{system_, "audin:u"},
|
||||
impl{std::make_unique<AudioCore::AudioIn::Manager>(system_)} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&IAudioInManager::ListAudioIns>, "ListAudioIns"},
|
||||
|
|
|
@ -14,8 +14,8 @@ IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
|
|||
s32 session_id)
|
||||
: ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
|
||||
rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
|
||||
impl{std::make_unique<Renderer>(system_, manager, rendered_event)}, process_handle{
|
||||
process_handle_} {
|
||||
impl{std::make_unique<Renderer>(system_, manager, rendered_event)},
|
||||
process_handle{process_handle_} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&IAudioRenderer::GetSampleRate>, "GetSampleRate"},
|
||||
|
|
|
@ -7,9 +7,8 @@
|
|||
namespace Service::News {
|
||||
|
||||
INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_)
|
||||
: ServiceFramework{system_, "INewlyArrivedEventHolder"}, service_context{
|
||||
system_,
|
||||
"INewlyArrivedEventHolder"} {
|
||||
: ServiceFramework{system_, "INewlyArrivedEventHolder"},
|
||||
service_context{system_, "INewlyArrivedEventHolder"} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&INewlyArrivedEventHolder::Get>, "Get"},
|
||||
|
|
|
@ -7,8 +7,8 @@
|
|||
namespace Service::News {
|
||||
|
||||
IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
|
||||
: ServiceFramework{system_, "IOverwriteEventHolder"}, service_context{system_,
|
||||
"IOverwriteEventHolder"} {
|
||||
: ServiceFramework{system_, "IOverwriteEventHolder"},
|
||||
service_context{system_, "IOverwriteEventHolder"} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&IOverwriteEventHolder::Get>, "Get"},
|
||||
|
|
|
@ -11,8 +11,8 @@
|
|||
namespace Service::FileSystem {
|
||||
|
||||
IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGetter size_getter_)
|
||||
: ServiceFramework{system_, "IFileSystem"}, backend{std::make_unique<FileSys::Fsa::IFileSystem>(
|
||||
dir_)},
|
||||
: ServiceFramework{system_, "IFileSystem"},
|
||||
backend{std::make_unique<FileSys::Fsa::IFileSystem>(dir_)},
|
||||
size_getter{std::move(size_getter_)} {
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&IFileSystem::CreateFile>, "CreateFile"},
|
||||
|
|
|
@ -12,8 +12,8 @@ namespace Service::FileSystem {
|
|||
ISaveDataInfoReader::ISaveDataInfoReader(Core::System& system_,
|
||||
std::shared_ptr<SaveDataController> save_data_controller_,
|
||||
FileSys::SaveDataSpaceId space)
|
||||
: ServiceFramework{system_, "ISaveDataInfoReader"}, save_data_controller{
|
||||
save_data_controller_} {
|
||||
: ServiceFramework{system_, "ISaveDataInfoReader"},
|
||||
save_data_controller{save_data_controller_} {
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&ISaveDataInfoReader::ReadSaveDataInfo>, "ReadSaveDataInfo"},
|
||||
};
|
||||
|
|
|
@ -11,8 +11,8 @@
|
|||
namespace Service::Glue::Time {
|
||||
|
||||
AlarmWorker::AlarmWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource)
|
||||
: m_system{system}, m_ctx{system, "Glue:AlarmWorker"}, m_steady_clock_resource{
|
||||
steady_clock_resource} {}
|
||||
: m_system{system}, m_ctx{system, "Glue:AlarmWorker"},
|
||||
m_steady_clock_resource{steady_clock_resource} {}
|
||||
|
||||
AlarmWorker::~AlarmWorker() {
|
||||
m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event);
|
||||
|
|
|
@ -87,10 +87,8 @@ static Service::PSC::Time::LocationName GetTimeZoneString(
|
|||
}
|
||||
|
||||
TimeManager::TimeManager(Core::System& system)
|
||||
: m_steady_clock_resource{system}, m_time_zone_binary{system}, m_worker{
|
||||
system,
|
||||
m_steady_clock_resource,
|
||||
m_file_timestamp_worker} {
|
||||
: m_steady_clock_resource{system}, m_time_zone_binary{system},
|
||||
m_worker{system, m_steady_clock_resource, m_file_timestamp_worker} {
|
||||
m_time_m =
|
||||
system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true);
|
||||
|
||||
|
|
|
@ -22,9 +22,9 @@ TimeZoneService::TimeZoneService(
|
|||
std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service)
|
||||
: ServiceFramework{system_, "ITimeZoneService"}, m_system{system},
|
||||
m_can_write_timezone_device_location{can_write_timezone_device_location},
|
||||
m_file_timestamp_worker{file_timestamp_worker}, m_wrapped_service{std::move(
|
||||
time_zone_service)},
|
||||
m_operation_event{m_system}, m_time_zone_binary{time_zone_binary} {
|
||||
m_file_timestamp_worker{file_timestamp_worker},
|
||||
m_wrapped_service{std::move(time_zone_service)}, m_operation_event{m_system},
|
||||
m_time_zone_binary{time_zone_binary} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},
|
||||
|
|
|
@ -19,11 +19,11 @@ namespace Service::Glue::Time {
|
|||
|
||||
TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
|
||||
FileTimestampWorker& file_timestamp_worker)
|
||||
: m_system{system}, m_ctx{m_system, "Glue:TimeWorker"}, m_event{m_ctx.CreateEvent(
|
||||
"Glue:TimeWorker:Event")},
|
||||
: m_system{system}, m_ctx{m_system, "Glue:TimeWorker"},
|
||||
m_event{m_ctx.CreateEvent("Glue:TimeWorker:Event")},
|
||||
m_steady_clock_resource{steady_clock_resource},
|
||||
m_file_timestamp_worker{file_timestamp_worker}, m_timer_steady_clock{m_ctx.CreateEvent(
|
||||
"Glue:TimeWorker:SteadyClockTimerEvent")},
|
||||
m_file_timestamp_worker{file_timestamp_worker},
|
||||
m_timer_steady_clock{m_ctx.CreateEvent("Glue:TimeWorker:SteadyClockTimerEvent")},
|
||||
m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")},
|
||||
m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} {
|
||||
m_timer_steady_clock_timing_event = Core::Timing::CreateEvent(
|
||||
|
|
|
@ -17,8 +17,8 @@ namespace Service::HID {
|
|||
|
||||
IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<ResourceManager> resource,
|
||||
std::shared_ptr<HidFirmwareSettings> settings)
|
||||
: ServiceFramework{system_, "hid:dbg"}, resource_manager{resource}, firmware_settings{
|
||||
settings} {
|
||||
: ServiceFramework{system_, "hid:dbg"}, resource_manager{resource},
|
||||
firmware_settings{settings} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, nullptr, "DeactivateDebugPad"},
|
||||
|
|
|
@ -72,8 +72,8 @@ public:
|
|||
u32 num_handles_to_copy_ = 0, u32 num_objects_to_move_ = 0,
|
||||
Flags flags = Flags::None)
|
||||
: RequestHelperBase(ctx), normal_params_size(normal_params_size_),
|
||||
num_handles_to_copy(num_handles_to_copy_),
|
||||
num_objects_to_move(num_objects_to_move_), kernel{ctx.kernel} {
|
||||
num_handles_to_copy(num_handles_to_copy_), num_objects_to_move(num_objects_to_move_),
|
||||
kernel{ctx.kernel} {
|
||||
|
||||
memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);
|
||||
|
||||
|
|
|
@ -40,8 +40,8 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
|
|||
public:
|
||||
explicit DynarmicCallbacks64(Core::Memory::Memory& memory_, std::vector<u8>& local_memory_,
|
||||
IntervalSet& mapped_ranges_, JITContextImpl& parent_)
|
||||
: memory{memory_}, local_memory{local_memory_},
|
||||
mapped_ranges{mapped_ranges_}, parent{parent_} {}
|
||||
: memory{memory_}, local_memory{local_memory_}, mapped_ranges{mapped_ranges_},
|
||||
parent{parent_} {}
|
||||
|
||||
u8 MemoryRead8(u64 vaddr) override {
|
||||
return ReadMemory<u8>(vaddr);
|
||||
|
|
|
@ -23,8 +23,8 @@ class IDatabaseService final : public ServiceFramework<IDatabaseService> {
|
|||
public:
|
||||
explicit IDatabaseService(Core::System& system_, std::shared_ptr<MiiManager> mii_manager,
|
||||
bool is_system_)
|
||||
: ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager}, is_system{
|
||||
is_system_} {
|
||||
: ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager},
|
||||
is_system{is_system_} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&IDatabaseService::IsUpdated>, "IsUpdated"},
|
||||
|
|
|
@ -30,8 +30,8 @@ Alarm::~Alarm() {
|
|||
Alarms::Alarms(Core::System& system, StandardSteadyClockCore& steady_clock,
|
||||
PowerStateRequestManager& power_state_request_manager)
|
||||
: m_system{system}, m_ctx{system, "Psc:Alarms"}, m_steady_clock{steady_clock},
|
||||
m_power_state_request_manager{power_state_request_manager}, m_event{m_ctx.CreateEvent(
|
||||
"Psc:Alarms:Event")} {}
|
||||
m_power_state_request_manager{power_state_request_manager},
|
||||
m_event{m_ctx.CreateEvent("Psc:Alarms:Event")} {}
|
||||
|
||||
Alarms::~Alarms() {
|
||||
m_ctx.CloseEvent(m_event);
|
||||
|
|
|
@ -11,8 +11,8 @@ StandardUserSystemClockCore::StandardUserSystemClockCore(
|
|||
StandardNetworkSystemClockCore& network_clock)
|
||||
: SystemClockCore{local_clock.GetSteadyClock()}, m_system{system},
|
||||
m_ctx{m_system, "Psc:StandardUserSystemClockCore"}, m_local_system_clock{local_clock},
|
||||
m_network_system_clock{network_clock}, m_event{m_ctx.CreateEvent(
|
||||
"Psc:StandardUserSystemClockCore:Event")} {}
|
||||
m_network_system_clock{network_clock},
|
||||
m_event{m_ctx.CreateEvent("Psc:StandardUserSystemClockCore:Event")} {}
|
||||
|
||||
StandardUserSystemClockCore::~StandardUserSystemClockCore() {
|
||||
m_ctx.CloseEvent(m_event);
|
||||
|
|
|
@ -6,8 +6,8 @@
|
|||
|
||||
namespace Service::PSC::Time {
|
||||
OperationEvent::OperationEvent(Core::System& system)
|
||||
: m_ctx{system, "Time:OperationEvent"}, m_event{
|
||||
m_ctx.CreateEvent("Time:OperationEvent:Event")} {}
|
||||
: m_ctx{system, "Time:OperationEvent"},
|
||||
m_event{m_ctx.CreateEvent("Time:OperationEvent:Event")} {}
|
||||
|
||||
OperationEvent::~OperationEvent() {
|
||||
m_ctx.CloseEvent(m_event);
|
||||
|
|
|
@ -29,8 +29,8 @@ public:
|
|||
m_standard_user_system_clock{m_system, m_standard_local_system_clock,
|
||||
m_standard_network_system_clock},
|
||||
m_ephemeral_network_clock{m_tick_based_steady_clock}, m_shared_memory{m_system},
|
||||
m_power_state_request_manager{m_system}, m_alarms{m_system, m_standard_steady_clock,
|
||||
m_power_state_request_manager},
|
||||
m_power_state_request_manager{m_system},
|
||||
m_alarms{m_system, m_standard_steady_clock, m_power_state_request_manager},
|
||||
m_local_system_clock_context_writer{m_system, m_shared_memory},
|
||||
m_network_system_clock_context_writer{m_system, m_shared_memory,
|
||||
m_standard_user_system_clock},
|
||||
|
|
|
@ -8,8 +8,8 @@ namespace Service::PSC::Time {
|
|||
|
||||
IPowerStateRequestHandler::IPowerStateRequestHandler(
|
||||
Core::System& system_, PowerStateRequestManager& power_state_request_manager)
|
||||
: ServiceFramework{system_, "time:p"}, m_system{system}, m_power_state_request_manager{
|
||||
power_state_request_manager} {
|
||||
: ServiceFramework{system_, "time:p"}, m_system{system},
|
||||
m_power_state_request_manager{power_state_request_manager} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&IPowerStateRequestHandler::GetPowerStateRequestEventReadableHandle>, "GetPowerStateRequestEventReadableHandle"},
|
||||
|
|
|
@ -37,8 +37,8 @@ StaticService::StaticService(Core::System& system_, StaticServiceSetupInfo setup
|
|||
m_user_system_clock{m_time->m_standard_user_system_clock},
|
||||
m_network_system_clock{m_time->m_standard_network_system_clock},
|
||||
m_time_zone{m_time->m_time_zone},
|
||||
m_ephemeral_network_clock{m_time->m_ephemeral_network_clock}, m_shared_memory{
|
||||
m_time->m_shared_memory} {
|
||||
m_ephemeral_network_clock{m_time->m_ephemeral_network_clock},
|
||||
m_shared_memory{m_time->m_shared_memory} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&StaticService::GetStandardUserSystemClock>, "GetStandardUserSystemClock"},
|
||||
|
|
|
@ -12,8 +12,8 @@ SteadyClock::SteadyClock(Core::System& system_, std::shared_ptr<TimeManager> man
|
|||
bool can_write_steady_clock, bool can_write_uninitialized_clock)
|
||||
: ServiceFramework{system_, "ISteadyClock"}, m_system{system},
|
||||
m_clock_core{manager->m_standard_steady_clock},
|
||||
m_can_write_steady_clock{can_write_steady_clock}, m_can_write_uninitialized_clock{
|
||||
can_write_uninitialized_clock} {
|
||||
m_can_write_steady_clock{can_write_steady_clock},
|
||||
m_can_write_uninitialized_clock{can_write_uninitialized_clock} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&SteadyClock::GetCurrentTimePoint>, "GetCurrentTimePoint"},
|
||||
|
|
|
@ -11,8 +11,8 @@ namespace Service::PSC::Time {
|
|||
SystemClock::SystemClock(Core::System& system_, SystemClockCore& clock_core, bool can_write_clock,
|
||||
bool can_write_uninitialized_clock)
|
||||
: ServiceFramework{system_, "ISystemClock"}, m_system{system}, m_clock_core{clock_core},
|
||||
m_can_write_clock{can_write_clock}, m_can_write_uninitialized_clock{
|
||||
can_write_uninitialized_clock} {
|
||||
m_can_write_clock{can_write_clock},
|
||||
m_can_write_uninitialized_clock{can_write_uninitialized_clock} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&SystemClock::GetCurrentTime>, "GetCurrentTime"},
|
||||
|
|
|
@ -13,8 +13,8 @@ namespace Service::PSC::Time {
|
|||
TimeZoneService::TimeZoneService(Core::System& system_, StandardSteadyClockCore& clock_core,
|
||||
TimeZone& time_zone, bool can_write_timezone_device_location)
|
||||
: ServiceFramework{system_, "ITimeZoneService"}, m_system{system}, m_clock_core{clock_core},
|
||||
m_time_zone{time_zone}, m_can_write_timezone_device_location{
|
||||
can_write_timezone_device_location} {
|
||||
m_time_zone{time_zone},
|
||||
m_can_write_timezone_device_location{can_write_timezone_device_location} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{0, D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},
|
||||
|
|
|
@ -251,8 +251,8 @@ void SM::UnregisterService(HLERequestContext& ctx) {
|
|||
}
|
||||
|
||||
SM::SM(ServiceManager& service_manager_, Core::System& system_)
|
||||
: ServiceFramework{system_, "sm:", 4},
|
||||
service_manager{service_manager_}, kernel{system_.Kernel()} {
|
||||
: ServiceFramework{system_, "sm:", 4}, service_manager{service_manager_},
|
||||
kernel{system_.Kernel()} {
|
||||
RegisterHandlers({
|
||||
{0, &SM::Initialize, "Initialize"},
|
||||
{1, &SM::GetServiceCmif, "GetService"},
|
||||
|
|
|
@ -15,8 +15,8 @@ namespace Service::VI {
|
|||
|
||||
IApplicationDisplayService::IApplicationDisplayService(Core::System& system_,
|
||||
std::shared_ptr<Container> container)
|
||||
: ServiceFramework{system_, "IApplicationDisplayService"},
|
||||
m_container{std::move(container)}, m_context{system, "IApplicationDisplayService"} {
|
||||
: ServiceFramework{system_, "IApplicationDisplayService"}, m_container{std::move(container)},
|
||||
m_context{system, "IApplicationDisplayService"} {
|
||||
// clang-format off
|
||||
static const FunctionInfo functions[] = {
|
||||
{100, C<&IApplicationDisplayService::GetRelayService>, "GetRelayService"},
|
||||
|
|
|
@ -218,8 +218,8 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
|
|||
|
||||
CheatEngine::CheatEngine(System& system_, std::vector<CheatEntry> cheats_,
|
||||
const std::array<u8, 0x20>& build_id_)
|
||||
: vm{std::make_unique<StandardVmCallbacks>(system_, metadata)},
|
||||
cheats(std::move(cheats_)), core_timing{system_.CoreTiming()}, system{system_} {
|
||||
: vm{std::make_unique<StandardVmCallbacks>(system_, metadata)}, cheats(std::move(cheats_)),
|
||||
core_timing{system_.CoreTiming()}, system{system_} {
|
||||
metadata.main_nso_build_id = build_id_;
|
||||
}
|
||||
|
||||
|
|
|
@ -148,8 +148,8 @@ public:
|
|||
Common::Input::AnalogProperties properties_y_,
|
||||
InputEngine* input_engine_)
|
||||
: identifier(identifier_), axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_),
|
||||
properties_y(properties_y_),
|
||||
input_engine(input_engine_), invert_axis_y{input_engine_->GetEngineName() == "sdl"} {
|
||||
properties_y(properties_y_), input_engine(input_engine_),
|
||||
invert_axis_y{input_engine_->GetEngineName() == "sdl"} {
|
||||
UpdateCallback engine_callback{[this]() { OnChange(); }};
|
||||
const InputIdentifier x_input_identifier{
|
||||
.identifier = identifier,
|
||||
|
|
|
@ -186,8 +186,8 @@ Function::Function(ObjectPool<Block>& block_pool, Location start_address)
|
|||
|
||||
CFG::CFG(Environment& env_, ObjectPool<Block>& block_pool_, Location start_address,
|
||||
bool exits_to_dispatcher_)
|
||||
: env{env_}, block_pool{block_pool_}, program_start{start_address}, exits_to_dispatcher{
|
||||
exits_to_dispatcher_} {
|
||||
: env{env_}, block_pool{block_pool_}, program_start{start_address},
|
||||
exits_to_dispatcher{exits_to_dispatcher_} {
|
||||
if (exits_to_dispatcher) {
|
||||
dispatch_block = block_pool.Create(Block{});
|
||||
dispatch_block->begin = {};
|
||||
|
|
|
@ -112,8 +112,8 @@ struct Statement : ListBaseHook {
|
|||
Statement(SetVariable, u32 id_, Statement* op_, Statement* up_)
|
||||
: op{op_}, id{id_}, up{up_}, type{StatementType::SetVariable} {}
|
||||
Statement(SetIndirectBranchVariable, IR::Reg branch_reg_, s32 branch_offset_, Statement* up_)
|
||||
: branch_offset{branch_offset_},
|
||||
branch_reg{branch_reg_}, up{up_}, type{StatementType::SetIndirectBranchVariable} {}
|
||||
: branch_offset{branch_offset_}, branch_reg{branch_reg_}, up{up_},
|
||||
type{StatementType::SetIndirectBranchVariable} {}
|
||||
Statement(Variable, u32 id_, Statement* up_)
|
||||
: id{id_}, up{up_}, type{StatementType::Variable} {}
|
||||
Statement(IndirectBranchCond, u32 location_, Statement* up_)
|
||||
|
|
|
@ -54,8 +54,8 @@ QtNXWebEngineView::QtNXWebEngineView(QWidget* parent, Core::System& system,
|
|||
: QWebEngineView(parent), input_subsystem{input_subsystem_},
|
||||
url_interceptor(std::make_unique<UrlRequestInterceptor>()),
|
||||
input_interpreter(std::make_unique<InputInterpreter>(system)),
|
||||
default_profile{QWebEngineProfile::defaultProfile()}, global_settings{
|
||||
default_profile->settings()} {
|
||||
default_profile{QWebEngineProfile::defaultProfile()},
|
||||
global_settings{default_profile->settings()} {
|
||||
default_profile->setPersistentStoragePath(QString::fromStdString(Common::FS::PathToUTF8String(
|
||||
Common::FS::GetSuyuPath(Common::FS::SuyuPath::SuyuDir) / "qtwebengine")));
|
||||
|
||||
|
|
|
@ -284,8 +284,8 @@ struct NullRenderWidget : public RenderWidget {
|
|||
GRenderWindow::GRenderWindow(GMainWindow* parent, EmuThread* emu_thread_,
|
||||
std::shared_ptr<InputCommon::InputSubsystem> input_subsystem_,
|
||||
Core::System& system_)
|
||||
: QWidget(parent),
|
||||
emu_thread(emu_thread_), input_subsystem{std::move(input_subsystem_)}, system{system_} {
|
||||
: QWidget(parent), emu_thread(emu_thread_), input_subsystem{std::move(input_subsystem_)},
|
||||
system{system_} {
|
||||
setWindowTitle(QStringLiteral("suyu %1 | %2-%3")
|
||||
.arg(QString::fromUtf8(Common::g_build_name),
|
||||
QString::fromUtf8(Common::g_scm_branch),
|
||||
|
|
|
@ -32,9 +32,9 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
|
|||
InputCommon::InputSubsystem* input_subsystem,
|
||||
std::vector<VkDeviceInfo::Record>& vk_device_records,
|
||||
Core::System& system_, bool enable_web_config)
|
||||
: QDialog(parent), ui{std::make_unique<Ui::ConfigureDialog>()},
|
||||
registry(registry_), system{system_}, builder{std::make_unique<ConfigurationShared::Builder>(
|
||||
this, !system_.IsPoweredOn())},
|
||||
: QDialog(parent), ui{std::make_unique<Ui::ConfigureDialog>()}, registry(registry_),
|
||||
system{system_},
|
||||
builder{std::make_unique<ConfigurationShared::Builder>(this, !system_.IsPoweredOn())},
|
||||
applets_tab{std::make_unique<ConfigureApplets>(system_, nullptr, *builder, this)},
|
||||
audio_tab{std::make_unique<ConfigureAudio>(system_, nullptr, *builder, this)},
|
||||
cpu_tab{std::make_unique<ConfigureCpu>(system_, nullptr, *builder, this)},
|
||||
|
|
|
@ -293,11 +293,11 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
|
|||
InputCommon::InputSubsystem* input_subsystem_,
|
||||
InputProfiles* profiles_, Core::HID::HIDCore& hid_core_,
|
||||
bool is_powered_on_, bool debug_)
|
||||
: QWidget(parent),
|
||||
ui(std::make_unique<Ui::ConfigureInputPlayer>()), player_index{player_index_}, debug{debug_},
|
||||
is_powered_on{is_powered_on_}, input_subsystem{input_subsystem_}, profiles(profiles_),
|
||||
timeout_timer(std::make_unique<QTimer>()),
|
||||
poll_timer(std::make_unique<QTimer>()), bottom_row{bottom_row_}, hid_core{hid_core_} {
|
||||
: QWidget(parent), ui(std::make_unique<Ui::ConfigureInputPlayer>()),
|
||||
player_index{player_index_}, debug{debug_}, is_powered_on{is_powered_on_},
|
||||
input_subsystem{input_subsystem_}, profiles(profiles_),
|
||||
timeout_timer(std::make_unique<QTimer>()), poll_timer(std::make_unique<QTimer>()),
|
||||
bottom_row{bottom_row_}, hid_core{hid_core_} {
|
||||
if (player_index == 0) {
|
||||
auto* emulated_controller_p1 =
|
||||
hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1);
|
||||
|
|
|
@ -766,8 +766,8 @@ Widget::Widget(Settings::BasicSetting* setting_, const TranslationMap& translati
|
|||
|
||||
Builder::Builder(QWidget* parent_, bool runtime_lock_)
|
||||
: translations{InitializeTranslations(parent_)},
|
||||
combobox_translations{ComboboxEnumeration(parent_)}, parent{parent_}, runtime_lock{
|
||||
runtime_lock_} {}
|
||||
combobox_translations{ComboboxEnumeration(parent_)}, parent{parent_},
|
||||
runtime_lock{runtime_lock_} {}
|
||||
|
||||
Builder::~Builder() = default;
|
||||
|
||||
|
|
|
@ -24,8 +24,8 @@ enum class ConnectionType : u8 { TraversalServer, IP };
|
|||
|
||||
DirectConnectWindow::DirectConnectWindow(Core::System& system_, QWidget* parent)
|
||||
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
|
||||
ui(std::make_unique<Ui::DirectConnect>()), system{system_}, room_network{
|
||||
system.GetRoomNetwork()} {
|
||||
ui(std::make_unique<Ui::DirectConnect>()), system{system_},
|
||||
room_network{system.GetRoomNetwork()} {
|
||||
|
||||
ui->setupUi(this);
|
||||
|
||||
|
|
|
@ -31,9 +31,8 @@ HostRoomWindow::HostRoomWindow(QWidget* parent, QStandardItemModel* list,
|
|||
std::shared_ptr<Core::AnnounceMultiplayerSession> session,
|
||||
Core::System& system_)
|
||||
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
|
||||
ui(std::make_unique<Ui::HostRoom>()),
|
||||
announce_multiplayer_session(session), system{system_}, room_network{
|
||||
system.GetRoomNetwork()} {
|
||||
ui(std::make_unique<Ui::HostRoom>()), announce_multiplayer_session(session), system{system_},
|
||||
room_network{system.GetRoomNetwork()} {
|
||||
ui->setupUi(this);
|
||||
|
||||
// set up validation for all of the fields
|
||||
|
|
|
@ -27,9 +27,8 @@
|
|||
Lobby::Lobby(QWidget* parent, QStandardItemModel* list,
|
||||
std::shared_ptr<Core::AnnounceMultiplayerSession> session, Core::System& system_)
|
||||
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
|
||||
ui(std::make_unique<Ui::Lobby>()),
|
||||
announce_multiplayer_session(session), system{system_}, room_network{
|
||||
system.GetRoomNetwork()} {
|
||||
ui(std::make_unique<Ui::Lobby>()), announce_multiplayer_session(session), system{system_},
|
||||
room_network{system.GetRoomNetwork()} {
|
||||
ui->setupUi(this);
|
||||
|
||||
// setup the watcher for background connections
|
||||
|
|
|
@ -18,8 +18,8 @@ namespace Tegra {
|
|||
|
||||
CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id)
|
||||
: host1x{host1x_}, memory_manager{host1x.GMMU()},
|
||||
host_processor{std::make_unique<Host1x::Control>(host1x_)}, current_class{
|
||||
static_cast<ChClassId>(id)} {
|
||||
host_processor{std::make_unique<Host1x::Control>(host1x_)},
|
||||
current_class{static_cast<ChClassId>(id)} {
|
||||
thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); });
|
||||
}
|
||||
|
||||
|
|
|
@ -18,8 +18,8 @@ constexpr u32 ComputeInline = 0x6D;
|
|||
|
||||
DmaPusher::DmaPusher(Core::System& system_, GPU& gpu_, MemoryManager& memory_manager_,
|
||||
Control::ChannelState& channel_state_)
|
||||
: gpu{gpu_}, system{system_}, memory_manager{memory_manager_}, puller{gpu_, memory_manager_,
|
||||
*this, channel_state_} {}
|
||||
: gpu{gpu_}, system{system_}, memory_manager{memory_manager_},
|
||||
puller{gpu_, memory_manager_, *this, channel_state_} {}
|
||||
|
||||
DmaPusher::~DmaPusher() = default;
|
||||
|
||||
|
|
|
@ -24,9 +24,8 @@ constexpr u32 MacroRegistersStart = 0xE00;
|
|||
|
||||
Maxwell3D::Maxwell3D(Core::System& system_, MemoryManager& memory_manager_)
|
||||
: draw_manager{std::make_unique<DrawManager>(this)}, system{system_},
|
||||
memory_manager{memory_manager_}, macro_engine{GetMacroEngine(*this)}, upload_state{
|
||||
memory_manager,
|
||||
regs.upload} {
|
||||
memory_manager{memory_manager_}, macro_engine{GetMacroEngine(*this)},
|
||||
upload_state{memory_manager, regs.upload} {
|
||||
dirty.flags.flip();
|
||||
InitializeRegisterDefaults();
|
||||
execution_mask.reset();
|
||||
|
|
|
@ -21,8 +21,8 @@ namespace Tegra::Engines {
|
|||
|
||||
Puller::Puller(GPU& gpu_, MemoryManager& memory_manager_, DmaPusher& dma_pusher_,
|
||||
Control::ChannelState& channel_state_)
|
||||
: gpu{gpu_}, memory_manager{memory_manager_}, dma_pusher{dma_pusher_}, channel_state{
|
||||
channel_state_} {}
|
||||
: gpu{gpu_}, memory_manager{memory_manager_}, dma_pusher{dma_pusher_},
|
||||
channel_state{channel_state_} {}
|
||||
|
||||
Puller::~Puller() = default;
|
||||
|
||||
|
|
|
@ -11,8 +11,8 @@ namespace Tegra {
|
|||
|
||||
Decoder::Decoder(Host1x::Host1x& host1x_, s32 id_, const Host1x::NvdecCommon::NvdecRegisters& regs_,
|
||||
Host1x::FrameQueue& frame_queue_)
|
||||
: host1x(host1x_), memory_manager{host1x.GMMU()}, regs{regs_}, id{id_}, frame_queue{
|
||||
frame_queue_} {}
|
||||
: host1x(host1x_), memory_manager{host1x.GMMU()}, regs{regs_}, id{id_},
|
||||
frame_queue{frame_queue_} {}
|
||||
|
||||
Decoder::~Decoder() = default;
|
||||
|
||||
|
|
|
@ -9,8 +9,8 @@
|
|||
namespace Tegra::Host1x {
|
||||
|
||||
Host1x::Host1x(Core::System& system_)
|
||||
: system{system_}, syncpoint_manager{},
|
||||
memory_manager(system.DeviceMemory()), gmmu_manager{system, memory_manager, 32, 0, 12},
|
||||
: system{system_}, syncpoint_manager{}, memory_manager(system.DeviceMemory()),
|
||||
gmmu_manager{system, memory_manager, 32, 0, 12},
|
||||
allocator{std::make_unique<Common::FlatAllocator<u32, 0, 32>>(1 << 12)} {}
|
||||
|
||||
Host1x::~Host1x() = default;
|
||||
|
|
|
@ -94,8 +94,8 @@ void SwizzleSurface(std::span<u8> output, u32 out_stride, std::span<const u8> in
|
|||
} // namespace
|
||||
|
||||
Vic::Vic(Host1x& host1x_, s32 id_, u32 syncpt, FrameQueue& frame_queue_)
|
||||
: CDmaPusher{host1x_, id_}, id{id_}, syncpoint{syncpt},
|
||||
frame_queue{frame_queue_}, has_sse41{HasSSE41()} {
|
||||
: CDmaPusher{host1x_, id_}, id{id_}, syncpoint{syncpt}, frame_queue{frame_queue_},
|
||||
has_sse41{HasSSE41()} {
|
||||
LOG_INFO(HW_GPU, "Created vic {}", id);
|
||||
}
|
||||
|
||||
|
|
|
@ -28,8 +28,8 @@ MemoryManager::MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager&
|
|||
split_address{split_address_}, page_bits{page_bits_}, big_page_bits{big_page_bits_},
|
||||
entries{}, big_entries{}, page_table{address_space_bits, address_space_bits + page_bits - 38,
|
||||
page_bits != big_page_bits ? page_bits : 0},
|
||||
kind_map{PTEKind::INVALID}, unique_identifier{unique_identifier_generator.fetch_add(
|
||||
1, std::memory_order_acq_rel)},
|
||||
kind_map{PTEKind::INVALID},
|
||||
unique_identifier{unique_identifier_generator.fetch_add(1, std::memory_order_acq_rel)},
|
||||
accumulator{std::make_unique<VideoCommon::InvalidationAccumulator>()} {
|
||||
address_space_size = 1ULL << address_space_bits;
|
||||
page_size = 1ULL << page_bits;
|
||||
|
|
|
@ -115,8 +115,8 @@ struct QueryCacheBase<Traits>::QueryCacheBaseImpl {
|
|||
QueryCacheBaseImpl(QueryCacheBase<Traits>* owner_, VideoCore::RasterizerInterface& rasterizer_,
|
||||
Tegra::MaxwellDeviceMemoryManager& device_memory_, RuntimeType& runtime_,
|
||||
Tegra::GPU& gpu_)
|
||||
: owner{owner_}, rasterizer{rasterizer_},
|
||||
device_memory{device_memory_}, runtime{runtime_}, gpu{gpu_} {
|
||||
: owner{owner_}, rasterizer{rasterizer_}, device_memory{device_memory_}, runtime{runtime_},
|
||||
gpu{gpu_} {
|
||||
streamer_mask = 0;
|
||||
for (size_t i = 0; i < static_cast<size_t>(QueryType::MaxQueryTypes); i++) {
|
||||
streamers[i] = runtime.GetStreamerInterface(static_cast<QueryType>(i));
|
||||
|
|
|
@ -31,8 +31,8 @@ ComputePipeline::ComputePipeline(const Device& device, TextureCache& texture_cac
|
|||
BufferCache& buffer_cache_, ProgramManager& program_manager_,
|
||||
const Shader::Info& info_, std::string code,
|
||||
std::vector<u32> code_v, bool force_context_flush)
|
||||
: texture_cache{texture_cache_}, buffer_cache{buffer_cache_},
|
||||
program_manager{program_manager_}, info{info_} {
|
||||
: texture_cache{texture_cache_}, buffer_cache{buffer_cache_}, program_manager{program_manager_},
|
||||
info{info_} {
|
||||
switch (device.GetShaderBackend()) {
|
||||
case Settings::ShaderBackend::Glsl:
|
||||
source_program = CreateProgram(code, GL_COMPUTE_SHADER);
|
||||
|
|
|
@ -66,9 +66,8 @@ bool QueryCache::AnyCommandQueued() const noexcept {
|
|||
|
||||
HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
|
||||
VideoCore::QueryType type_)
|
||||
: HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_}, query{
|
||||
cache.AllocateQuery(
|
||||
type)} {
|
||||
: HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_},
|
||||
query{cache.AllocateQuery(type)} {
|
||||
glBeginQuery(GetTarget(type), query.handle);
|
||||
}
|
||||
|
||||
|
|
|
@ -24,8 +24,8 @@ using PushConstants = std::array<u32, 4 * 4>;
|
|||
|
||||
FSR::FSR(const Device& device, MemoryAllocator& memory_allocator, size_t image_count,
|
||||
VkExtent2D extent)
|
||||
: m_device{device}, m_memory_allocator{memory_allocator},
|
||||
m_image_count{image_count}, m_extent{extent} {
|
||||
: m_device{device}, m_memory_allocator{memory_allocator}, m_image_count{image_count},
|
||||
m_extent{extent} {
|
||||
|
||||
CreateImages();
|
||||
CreateRenderPasses();
|
||||
|
|
|
@ -531,8 +531,8 @@ ASTCDecoderPass::ASTCDecoderPass(const Device& device_, Scheduler& scheduler_,
|
|||
ASTC_PASS_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY, ASTC_BANK_INFO,
|
||||
COMPUTE_PUSH_CONSTANT_RANGE<sizeof(AstcPushConstants)>, ASTC_DECODER_COMP_SPV),
|
||||
scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
|
||||
compute_pass_descriptor_queue{compute_pass_descriptor_queue_}, memory_allocator{
|
||||
memory_allocator_} {}
|
||||
compute_pass_descriptor_queue{compute_pass_descriptor_queue_},
|
||||
memory_allocator{memory_allocator_} {}
|
||||
|
||||
ASTCDecoderPass::~ASTCDecoderPass() = default;
|
||||
|
||||
|
|
|
@ -31,8 +31,8 @@ ComputePipeline::ComputePipeline(const Device& device_, vk::PipelineCache& pipel
|
|||
PipelineStatistics* pipeline_statistics,
|
||||
VideoCore::ShaderNotify* shader_notify, const Shader::Info& info_,
|
||||
vk::ShaderModule spv_module_)
|
||||
: device{device_},
|
||||
pipeline_cache(pipeline_cache_), guest_descriptor_queue{guest_descriptor_queue_}, info{info_},
|
||||
: device{device_}, pipeline_cache(pipeline_cache_),
|
||||
guest_descriptor_queue{guest_descriptor_queue_}, info{info_},
|
||||
spv_module(std::move(spv_module_)) {
|
||||
if (shader_notify) {
|
||||
shader_notify->MarkShaderBuilding();
|
||||
|
|
|
@ -100,8 +100,8 @@ PresentManager::PresentManager(const vk::Instance& instance_,
|
|||
Swapchain& swapchain_, vk::SurfaceKHR& surface_)
|
||||
: instance{instance_}, render_window{render_window_}, device{device_},
|
||||
memory_allocator{memory_allocator_}, scheduler{scheduler_}, swapchain{swapchain_},
|
||||
surface{surface_}, blit_supported{CanBlitToSwapchain(device.GetPhysical(),
|
||||
swapchain.GetImageViewFormat())},
|
||||
surface{surface_},
|
||||
blit_supported{CanBlitToSwapchain(device.GetPhysical(), swapchain.GetImageViewFormat())},
|
||||
use_present_thread{Settings::values.async_presentation.GetValue()} {
|
||||
SetImageCount();
|
||||
|
||||
|
|
|
@ -1161,10 +1161,9 @@ struct QueryCacheRuntimeImpl {
|
|||
StagingBufferPool& staging_pool_,
|
||||
ComputePassDescriptorQueue& compute_pass_descriptor_queue,
|
||||
DescriptorPool& descriptor_pool)
|
||||
: rasterizer{rasterizer_}, device_memory{device_memory_},
|
||||
buffer_cache{buffer_cache_}, device{device_},
|
||||
memory_allocator{memory_allocator_}, scheduler{scheduler_}, staging_pool{staging_pool_},
|
||||
guest_streamer(0, runtime),
|
||||
: rasterizer{rasterizer_}, device_memory{device_memory_}, buffer_cache{buffer_cache_},
|
||||
device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
|
||||
staging_pool{staging_pool_}, guest_streamer(0, runtime),
|
||||
sample_streamer(static_cast<size_t>(QueryType::ZPassPixelCount64), runtime, rasterizer,
|
||||
device, scheduler, memory_allocator, compute_pass_descriptor_queue,
|
||||
descriptor_pool),
|
||||
|
|
|
@ -49,8 +49,8 @@ size_t GetStreamBufferSize(const Device& device) {
|
|||
StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& memory_allocator_,
|
||||
Scheduler& scheduler_)
|
||||
: device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
|
||||
stream_buffer_size{GetStreamBufferSize(device)}, region_size{stream_buffer_size /
|
||||
StagingBufferPool::NUM_SYNCS} {
|
||||
stream_buffer_size{GetStreamBufferSize(device)},
|
||||
region_size{stream_buffer_size / StagingBufferPool::NUM_SYNCS} {
|
||||
VkBufferCreateInfo stream_ci = {
|
||||
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
|
||||
.pNext = nullptr,
|
||||
|
|
|
@ -398,8 +398,8 @@ u32 GraphicsEnvironment::ReadViewportTransformState() {
|
|||
ComputeEnvironment::ComputeEnvironment(Tegra::Engines::KeplerCompute& kepler_compute_,
|
||||
Tegra::MemoryManager& gpu_memory_, GPUVAddr program_base_,
|
||||
u32 start_address_)
|
||||
: GenericEnvironment{gpu_memory_, program_base_, start_address_}, kepler_compute{
|
||||
&kepler_compute_} {
|
||||
: GenericEnvironment{gpu_memory_, program_base_, start_address_},
|
||||
kepler_compute{&kepler_compute_} {
|
||||
const auto& qmd{kepler_compute->launch_description};
|
||||
stage = Shader::Stage::Compute;
|
||||
local_memory_size = qmd.local_pos_alloc + qmd.local_crs_alloc;
|
||||
|
|
|
@ -625,8 +625,8 @@ class Image {
|
|||
public:
|
||||
explicit Image(VkImage handle_, VkDevice owner_, VmaAllocator allocator_,
|
||||
VmaAllocation allocation_, const DeviceDispatch& dld_) noexcept
|
||||
: handle{handle_}, owner{owner_}, allocator{allocator_},
|
||||
allocation{allocation_}, dld{&dld_} {}
|
||||
: handle{handle_}, owner{owner_}, allocator{allocator_}, allocation{allocation_},
|
||||
dld{&dld_} {}
|
||||
Image() = default;
|
||||
|
||||
Image(const Image&) = delete;
|
||||
|
@ -680,8 +680,8 @@ public:
|
|||
explicit Buffer(VkBuffer handle_, VkDevice owner_, VmaAllocator allocator_,
|
||||
VmaAllocation allocation_, std::span<u8> mapped_, bool is_coherent_,
|
||||
const DeviceDispatch& dld_) noexcept
|
||||
: handle{handle_}, owner{owner_}, allocator{allocator_},
|
||||
allocation{allocation_}, mapped{mapped_}, is_coherent{is_coherent_}, dld{&dld_} {}
|
||||
: handle{handle_}, owner{owner_}, allocator{allocator_}, allocation{allocation_},
|
||||
mapped{mapped_}, is_coherent{is_coherent_}, dld{&dld_} {}
|
||||
Buffer() = default;
|
||||
|
||||
Buffer(const Buffer&) = delete;
|
||||
|
@ -689,8 +689,8 @@ public:
|
|||
|
||||
Buffer(Buffer&& rhs) noexcept
|
||||
: handle{std::exchange(rhs.handle, nullptr)}, owner{rhs.owner}, allocator{rhs.allocator},
|
||||
allocation{rhs.allocation}, mapped{rhs.mapped},
|
||||
is_coherent{rhs.is_coherent}, dld{rhs.dld} {}
|
||||
allocation{rhs.allocation}, mapped{rhs.mapped}, is_coherent{rhs.is_coherent},
|
||||
dld{rhs.dld} {}
|
||||
|
||||
Buffer& operator=(Buffer&& rhs) noexcept {
|
||||
Release();
|
||||
|
|
Loading…
Reference in a new issue