vfs_real: Remove redundant copying of std::vector instances in GetFiles() and GetSubdirectories()

We already return by value, so we don't explicitly need to make the
copy.

src/common/string_util.cpp

@@ -196,13 +196,27 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 #ifdef _WIN32
 
 std::string UTF16ToUTF8(const std::u16string& input) {
+#if _MSC_VER >= 1900
+    // Workaround for missing char16_t/char32_t instantiations in MSVC2015
+    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
+    std::basic_string<__int16> tmp_buffer(input.cbegin(), input.cend());
+    return convert.to_bytes(tmp_buffer);
+#else
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
     return convert.to_bytes(input);
+#endif
 }
 
 std::u16string UTF8ToUTF16(const std::string& input) {
+#if _MSC_VER >= 1900
+    // Workaround for missing char16_t/char32_t instantiations in MSVC2015
+    std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
+    auto tmp_buffer = convert.from_bytes(input);
+    return std::u16string(tmp_buffer.cbegin(), tmp_buffer.cend());
+#else
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
     return convert.from_bytes(input);
+#endif
 }
 
 static std::wstring CPToUTF16(u32 code_page, const std::string& input) {

src/core/arm/arm_interface.h

@@ -104,10 +104,6 @@ public:
 
     virtual void SetTlsAddress(VAddr address) = 0;
 
-    virtual u64 GetTPIDR_EL0() const = 0;
-
-    virtual void SetTPIDR_EL0(u64 value) = 0;
-
     /**
      * Saves the current CPU context
      * @param ctx Thread context to save

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -196,14 +196,6 @@ void ARM_Dynarmic::SetTlsAddress(u64 address) {
     cb->tpidrro_el0 = address;
 }
 
-u64 ARM_Dynarmic::GetTPIDR_EL0() const {
-    return cb->tpidr_el0;
-}
-
-void ARM_Dynarmic::SetTPIDR_EL0(u64 value) {
-    cb->tpidr_el0 = value;
-}
-
 void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
     ctx.cpu_registers = jit->GetRegisters();
     ctx.sp = jit->GetSP();

src/core/arm/dynarmic/arm_dynarmic.h

@@ -34,8 +34,6 @@ public:
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
-    void SetTPIDR_EL0(u64 value) override;
-    u64 GetTPIDR_EL0() const override;
 
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;

src/core/arm/unicorn/arm_unicorn.cpp

@@ -169,16 +169,6 @@ void ARM_Unicorn::SetTlsAddress(VAddr base) {
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
 }
 
-u64 ARM_Unicorn::GetTPIDR_EL0() const {
-    u64 value{};
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_TPIDR_EL0, &value));
-    return value;
-}
-
-void ARM_Unicorn::SetTPIDR_EL0(u64 value) {
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDR_EL0, &value));
-}
-
 void ARM_Unicorn::Run() {
     if (GDBStub::IsServerEnabled()) {
         ExecuteInstructions(std::max(4000000, 0));

src/core/arm/unicorn/arm_unicorn.h

@@ -28,8 +28,6 @@ public:
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
-    void SetTPIDR_EL0(u64 value) override;
-    u64 GetTPIDR_EL0() const override;
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
     void PrepareReschedule() override;

src/core/file_sys/errors.h

@@ -20,13 +20,13 @@ enum {
 constexpr ResultCode ERROR_PATH_NOT_FOUND(ErrorModule::FS, ErrCodes::NotFound);
 
 // TODO(bunnei): Replace these with correct errors for Switch OS
-constexpr ResultCode ERROR_INVALID_PATH(-1);
-constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(-1);
-constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(-1);
-constexpr ResultCode ERROR_FILE_NOT_FOUND(-1);
-constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(-1);
-constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(-1);
-constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(-1);
-constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(-1);
+constexpr ResultCode ERROR_INVALID_PATH(ResultCode(-1));
+constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(ResultCode(-1));
+constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(ResultCode(-1));
+constexpr ResultCode ERROR_FILE_NOT_FOUND(ResultCode(-1));
+constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(ResultCode(-1));
+constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(ResultCode(-1));
+constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(ResultCode(-1));
+constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(ResultCode(-1));
 
 } // namespace FileSys

src/core/file_sys/partition_filesystem.cpp

@@ -2,7 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <iterator>
 #include <utility>
+
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/partition_filesystem.h"
@@ -99,14 +104,15 @@ void PartitionFilesystem::PrintDebugInfo() const {
 }
 
 bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
+    const auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
     if (iter == pfs_files.end())
         return false;
 
-    pfs_files[iter - pfs_files.begin()] = pfs_files.back();
+    const std::ptrdiff_t offset = std::distance(pfs_files.begin(), iter);
+    pfs_files[offset] = pfs_files.back();
     pfs_files.pop_back();
 
-    pfs_dirs.emplace_back(dir);
+    pfs_dirs.emplace_back(std::move(dir));
 
     return true;
 }

src/core/file_sys/vfs.cpp

@@ -42,7 +42,7 @@ bool VfsFile::WriteByte(u8 data, size_t offset) {
     return Write(&data, 1, offset) == 1;
 }
 
-size_t VfsFile::WriteBytes(const std::vector<u8>& data, size_t offset) {
+size_t VfsFile::WriteBytes(std::vector<u8> data, size_t offset) {
     return Write(data.data(), data.size(), offset);
 }
 

src/core/file_sys/vfs.h

@@ -59,7 +59,8 @@ struct VfsFile : NonCopyable {
     // Returns the number of bytes (sizeof(T)*number_elements) read successfully.
     template <typename T>
     size_t ReadArray(T* data, size_t number_elements, size_t offset = 0) const {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
 
         return Read(reinterpret_cast<u8*>(data), number_elements * sizeof(T), offset);
     }
@@ -68,7 +69,8 @@ struct VfsFile : NonCopyable {
     // Returns the number of bytes read successfully.
     template <typename T>
     size_t ReadBytes(T* data, size_t size, size_t offset = 0) const {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
         return Read(reinterpret_cast<u8*>(data), size, offset);
     }
 
@@ -76,7 +78,8 @@ struct VfsFile : NonCopyable {
     // Returns the number of bytes read successfully (sizeof(T)).
     template <typename T>
     size_t ReadObject(T* data, size_t offset = 0) const {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
         return Read(reinterpret_cast<u8*>(data), sizeof(T), offset);
     }
 
@@ -85,29 +88,33 @@ struct VfsFile : NonCopyable {
     virtual bool WriteByte(u8 data, size_t offset = 0);
     // Writes a vector of bytes to offset in file and returns the number of bytes successfully
     // written.
-    virtual size_t WriteBytes(const std::vector<u8>& data, size_t offset = 0);
+    virtual size_t WriteBytes(std::vector<u8> data, size_t offset = 0);
 
     // Writes an array of type T, size number_elements to offset in file.
     // Returns the number of bytes (sizeof(T)*number_elements) written successfully.
     template <typename T>
-    size_t WriteArray(const T* data, size_t number_elements, size_t offset = 0) {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+    size_t WriteArray(T* data, size_t number_elements, size_t offset = 0) {
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
+
         return Write(data, number_elements * sizeof(T), offset);
     }
 
     // Writes size bytes starting at memory location data to offset in file.
     // Returns the number of bytes written successfully.
     template <typename T>
-    size_t WriteBytes(const T* data, size_t size, size_t offset = 0) {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
-        return Write(reinterpret_cast<const u8*>(data), size, offset);
+    size_t WriteBytes(T* data, size_t size, size_t offset = 0) {
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
+        return Write(reinterpret_cast<u8*>(data), size, offset);
     }
 
     // Writes one object of type T to offset in file.
     // Returns the number of bytes written successfully (sizeof(T)).
     template <typename T>
     size_t WriteObject(const T& data, size_t offset = 0) {
-        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
         return Write(&data, sizeof(T), offset);
     }
 

src/core/file_sys/vfs_offset.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <utility>
 
 #include "core/file_sys/vfs_offset.h"
@@ -76,7 +75,7 @@ bool OffsetVfsFile::WriteByte(u8 data, size_t r_offset) {
     return false;
 }
 
-size_t OffsetVfsFile::WriteBytes(const std::vector<u8>& data, size_t r_offset) {
+size_t OffsetVfsFile::WriteBytes(std::vector<u8> data, size_t r_offset) {
     return file->Write(data.data(), TrimToFit(data.size(), r_offset), offset + r_offset);
 }
 
@@ -89,7 +88,7 @@ size_t OffsetVfsFile::GetOffset() const {
 }
 
 size_t OffsetVfsFile::TrimToFit(size_t r_size, size_t r_offset) const {
-    return std::clamp(r_size, size_t{0}, size - r_offset);
+    return std::max<size_t>(std::min<size_t>(size - r_offset, r_size), 0);
 }
 
 } // namespace FileSys

src/core/file_sys/vfs_offset.h

@@ -28,7 +28,7 @@ struct OffsetVfsFile : public VfsFile {
     std::vector<u8> ReadBytes(size_t size, size_t offset) const override;
     std::vector<u8> ReadAllBytes() const override;
     bool WriteByte(u8 data, size_t offset) override;
-    size_t WriteBytes(const std::vector<u8>& data, size_t offset) override;
+    size_t WriteBytes(std::vector<u8> data, size_t offset) override;
 
     bool Rename(const std::string& name) override;
 

src/core/file_sys/vfs_real.cpp

@@ -2,6 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <utility>
+
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "core/file_sys/vfs_real.h"
@@ -104,11 +109,11 @@ RealVfsDirectory::RealVfsDirectory(const std::string& path_, Mode perms_)
 }
 
 std::vector<std::shared_ptr<VfsFile>> RealVfsDirectory::GetFiles() const {
-    return std::vector<std::shared_ptr<VfsFile>>(files);
+    return files;
 }
 
 std::vector<std::shared_ptr<VfsDirectory>> RealVfsDirectory::GetSubdirectories() const {
-    return std::vector<std::shared_ptr<VfsDirectory>>(subdirectories);
+    return subdirectories;
 }
 
 bool RealVfsDirectory::IsWritable() const {
@@ -163,14 +168,15 @@ bool RealVfsDirectory::Rename(const std::string& name) {
 }
 
 bool RealVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    auto iter = std::find(files.begin(), files.end(), file);
+    const auto iter = std::find(files.begin(), files.end(), file);
     if (iter == files.end())
         return false;
 
-    files[iter - files.begin()] = files.back();
+    const std::ptrdiff_t offset = std::distance(files.begin(), iter);
+    files[offset] = files.back();
     files.pop_back();
 
-    subdirectories.emplace_back(dir);
+    subdirectories.emplace_back(std::move(dir));
 
     return true;
 }

src/core/hle/kernel/scheduler.cpp

@@ -56,8 +56,6 @@ void Scheduler::SwitchContext(Thread* new_thread) {
     if (previous_thread) {
         previous_thread->last_running_ticks = CoreTiming::GetTicks();
         cpu_core->SaveContext(previous_thread->context);
-        // Save the TPIDR_EL0 system register in case it was modified.
-        previous_thread->tpidr_el0 = cpu_core->GetTPIDR_EL0();
 
         if (previous_thread->status == ThreadStatus::Running) {
             // This is only the case when a reschedule is triggered without the current thread
@@ -89,7 +87,6 @@ void Scheduler::SwitchContext(Thread* new_thread) {
 
         cpu_core->LoadContext(new_thread->context);
         cpu_core->SetTlsAddress(new_thread->GetTLSAddress());
-        cpu_core->SetTPIDR_EL0(new_thread->GetTPIDR_EL0());
         cpu_core->ClearExclusiveState();
     } else {
         current_thread = nullptr;

src/core/hle/kernel/thread.cpp

@@ -312,7 +312,6 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
     thread->status = ThreadStatus::Dormant;
     thread->entry_point = entry_point;
     thread->stack_top = stack_top;
-    thread->tpidr_el0 = 0;
     thread->nominal_priority = thread->current_priority = priority;
     thread->last_running_ticks = CoreTiming::GetTicks();
     thread->processor_id = processor_id;

src/core/hle/kernel/thread.h

@@ -182,14 +182,6 @@ public:
         return tls_address;
     }
 
-    /*
-     * Returns the value of the TPIDR_EL0 Read/Write system register for this thread.
-     * @returns The value of the TPIDR_EL0 register.
-     */
-    u64 GetTPIDR_EL0() const {
-        return tpidr_el0;
-    }
-
     /*
      * Returns the address of the current thread's command buffer, located in the TLS.
      * @returns VAddr of the thread's command buffer.
@@ -221,7 +213,6 @@ public:
     s32 processor_id;
 
     VAddr tls_address; ///< Virtual address of the Thread Local Storage of the thread
-    u64 tpidr_el0;     ///< TPIDR_EL0 read/write system register.
 
     SharedPtr<Process> owner_process; ///< Process that owns this thread
 

src/core/loader/deconstructed_rom_directory.cpp

@@ -83,13 +83,16 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
     VAddr next_load_addr{Memory::PROCESS_IMAGE_VADDR};
     for (const auto& module : {"rtld", "main", "subsdk0", "subsdk1", "subsdk2", "subsdk3",
                                "subsdk4", "subsdk5", "subsdk6", "subsdk7", "sdk"}) {
+        const VAddr load_addr = next_load_addr;
         const FileSys::VirtualFile module_file = dir->GetFile(module);
-        if (module_file != nullptr) {
-            const VAddr load_addr = next_load_addr;
+        if (module_file != nullptr)
             next_load_addr = AppLoader_NSO::LoadModule(module_file, load_addr);
+        if (next_load_addr) {
             LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
             // Register module with GDBStub
             GDBStub::RegisterModule(module, load_addr, next_load_addr - 1, false);
+        } else {
+            next_load_addr = load_addr;
         }
     }
 

src/tests/core/arm/arm_test_common.cpp

@@ -10,6 +10,8 @@
 
 namespace ArmTests {
 
+static Memory::PageTable* page_table = nullptr;
+
 TestEnvironment::TestEnvironment(bool mutable_memory_)
     : mutable_memory(mutable_memory_), test_memory(std::make_shared<TestMemory>(this)) {
 
@@ -65,13 +67,10 @@ boost::optional<bool> TestEnvironment::TestMemory::IsValidAddress(VAddr addr) {
 }
 
 boost::optional<u8> TestEnvironment::TestMemory::Read8(VAddr addr) {
-    const auto iter = data.find(addr);
-
+    auto iter = data.find(addr);
     if (iter == data.end()) {
-        // Some arbitrary data
-        return static_cast<u8>(addr);
+        return addr; // Some arbitrary data
     }
-
     return iter->second;
 }
 

src/tests/core/arm/arm_test_common.h

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#pragma once
-
 #include <tuple>
 #include <unordered_map>
 #include <vector>
@@ -11,10 +9,6 @@
 #include "common/common_types.h"
 #include "core/memory_hook.h"
 
-namespace Memory {
-struct PageTable;
-}
-
 namespace ArmTests {
 
 struct WriteRecord {
@@ -85,7 +79,6 @@ private:
     bool mutable_memory;
     std::shared_ptr<TestMemory> test_memory;
     std::vector<WriteRecord> write_records;
-    Memory::PageTable* page_table = nullptr;
 };
 
 } // namespace ArmTests

src/video_core/gpu.cpp

@@ -20,11 +20,7 @@ GPU::GPU() {
 
 GPU::~GPU() = default;
 
-const Engines::Maxwell3D& GPU::Maxwell3D() const {
-    return *maxwell_3d;
-}
-
-Engines::Maxwell3D& GPU::Maxwell3D() {
+const Tegra::Engines::Maxwell3D& GPU::Get3DEngine() const {
     return *maxwell_3d;
 }
 

src/video_core/gpu.h

@@ -93,14 +93,15 @@ public:
     /// Processes a command list stored at the specified address in GPU memory.
     void ProcessCommandList(GPUVAddr address, u32 size);
 
-    /// Returns a const reference to the Maxwell3D GPU engine.
-    const Engines::Maxwell3D& Maxwell3D() const;
-
     /// Returns a reference to the Maxwell3D GPU engine.
-    Engines::Maxwell3D& Maxwell3D();
+    const Engines::Maxwell3D& Get3DEngine() const;
 
     std::unique_ptr<MemoryManager> memory_manager;
 
+    Engines::Maxwell3D& Maxwell3D() {
+        return *maxwell_3d;
+    }
+
 private:
     /// Writes a single register in the engine bound to the specified subchannel
     void WriteReg(u32 method, u32 subchannel, u32 value, u32 remaining_params);

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -634,8 +634,8 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntr
 u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, GLuint program,
                                         u32 current_bindpoint,
                                         const std::vector<GLShader::ConstBufferEntry>& entries) {
-    const auto& gpu = Core::System::GetInstance().GPU();
-    const auto& maxwell3d = gpu.Maxwell3D();
+    auto& gpu = Core::System::GetInstance().GPU();
+    auto& maxwell3d = gpu.Get3DEngine();
 
     // Reset all buffer draw state for this stage.
     for (auto& buffer : state.draw.const_buffers[static_cast<size_t>(stage)]) {
@@ -644,7 +644,7 @@ u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, GLuint progr
     }
 
     // Upload only the enabled buffers from the 16 constbuffers of each shader stage
-    const auto& shader_stage = maxwell3d.state.shader_stages[static_cast<size_t>(stage)];
+    auto& shader_stage = maxwell3d.state.shader_stages[static_cast<size_t>(stage)];
 
     for (u32 bindpoint = 0; bindpoint < entries.size(); ++bindpoint) {
         const auto& used_buffer = entries[bindpoint];
@@ -700,8 +700,8 @@ u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, GLuint progr
 
 u32 RasterizerOpenGL::SetupTextures(Maxwell::ShaderStage stage, GLuint program, u32 current_unit,
                                     const std::vector<GLShader::SamplerEntry>& entries) {
-    const auto& gpu = Core::System::GetInstance().GPU();
-    const auto& maxwell3d = gpu.Maxwell3D();
+    auto& gpu = Core::System::GetInstance().GPU();
+    auto& maxwell3d = gpu.Get3DEngine();
 
     ASSERT_MSG(current_unit + entries.size() <= std::size(state.texture_units),
                "Exceeded the number of active textures.");

src/video_core/renderer_opengl/gl_shader_manager.cpp

@@ -10,9 +10,8 @@
 namespace GLShader {
 
 namespace Impl {
-static void SetShaderUniformBlockBinding(GLuint shader, const char* name,
-                                         Maxwell3D::Regs::ShaderStage binding,
-                                         size_t expected_size) {
+void SetShaderUniformBlockBinding(GLuint shader, const char* name,
+                                  Maxwell3D::Regs::ShaderStage binding, size_t expected_size) {
     GLuint ub_index = glGetUniformBlockIndex(shader, name);
     if (ub_index != GL_INVALID_INDEX) {
         GLint ub_size = 0;

src/video_core/renderer_opengl/gl_shader_manager.h

@@ -21,6 +21,7 @@ using Tegra::Engines::Maxwell3D;
 
 namespace Impl {
 void SetShaderUniformBlockBindings(GLuint shader);
+void SetShaderSamplerBindings(GLuint shader);
 } // namespace Impl
 
 /// Uniform structure for the Uniform Buffer Object, all vectors must be 16-byte aligned

src/yuzu/debugger/graphics/graphics_surface.cpp

@@ -336,9 +336,9 @@ void GraphicsSurfaceWidget::OnUpdate() {
         // TODO: Store a reference to the registers in the debug context instead of accessing them
         // directly...
 
-        const auto& registers = gpu.Maxwell3D().regs;
-        const auto& rt = registers.rt[static_cast<size_t>(surface_source) -
-                                      static_cast<size_t>(Source::RenderTarget0)];
+        auto& registers = gpu.Get3DEngine().regs;
+        auto& rt = registers.rt[static_cast<size_t>(surface_source) -
+                                static_cast<size_t>(Source::RenderTarget0)];
 
         surface_address = rt.Address();
         surface_width = rt.width;