gpu: Rename Get3DEngine() to Maxwell3D()

This makes it match its const qualified equivalent.

externals/glad/include/KHR/khrplatform.h

@@ -2,7 +2,7 @@
 #define __khrplatform_h_
 
 /*
-** Copyright (c) 2008-2009 The Khronos Group Inc.
+** Copyright (c) 2008-2018 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
@@ -26,18 +26,16 @@
 
 /* Khronos platform-specific types and definitions.
  *
- * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
  *
  * Adopters may modify this file to suit their platform. Adopters are
  * encouraged to submit platform specific modifications to the Khronos
  * group so that they can be included in future versions of this file.
- * Please submit changes by sending them to the public Khronos Bugzilla
- * (http://khronos.org/bugzilla) by filing a bug against product
- * "Khronos (general)" component "Registry".
- *
- * A predefined template which fills in some of the bug fields can be
- * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
- * must create a Bugzilla login first.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
  *
  *
  * See the Implementer's Guidelines for information about where this file

src/core/file_sys/partition_filesystem.cpp

@@ -76,7 +76,7 @@ std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
 }
 
 std::vector<std::shared_ptr<VfsDirectory>> PartitionFilesystem::GetSubdirectories() const {
-    return {};
+    return pfs_dirs;
 }
 
 std::string PartitionFilesystem::GetName() const {

src/core/file_sys/vfs_offset.cpp

@@ -2,13 +2,15 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <utility>
+
 #include "core/file_sys/vfs_offset.h"
 
 namespace FileSys {
 
 OffsetVfsFile::OffsetVfsFile(std::shared_ptr<VfsFile> file_, size_t size_, size_t offset_,
-                             const std::string& name_)
-    : file(file_), offset(offset_), size(size_), name(name_) {}
+                             std::string name_)
+    : file(std::move(file_)), offset(offset_), size(size_), name(std::move(name_)) {}
 
 std::string OffsetVfsFile::GetName() const {
     return name.empty() ? file->GetName() : name;

src/core/file_sys/vfs_offset.h

@@ -14,7 +14,7 @@ namespace FileSys {
 // the size of this wrapper.
 struct OffsetVfsFile : public VfsFile {
     OffsetVfsFile(std::shared_ptr<VfsFile> file, size_t size, size_t offset = 0,
-                  const std::string& new_name = "");
+                  std::string new_name = "");
 
     std::string GetName() const override;
     size_t GetSize() const override;

src/core/hle/ipc_helpers.h

@@ -174,6 +174,25 @@ public:
     template <typename First, typename... Other>
     void Push(const First& first_value, const Other&... other_values);
 
+    /**
+     * Helper function for pushing strongly-typed enumeration values.
+     *
+     * @tparam Enum The enumeration type to be pushed
+     *
+     * @param value The value to push.
+     *
+     * @note The underlying size of the enumeration type is the size of the
+     *       data that gets pushed. e.g. "enum class SomeEnum : u16" will
+     *       push a u16-sized amount of data.
+     */
+    template <typename Enum>
+    void PushEnum(Enum value) {
+        static_assert(std::is_enum_v<Enum>, "T must be an enum type within a PushEnum call.");
+        static_assert(!std::is_convertible_v<Enum, int>,
+                      "enum type in PushEnum must be a strongly typed enum.");
+        Push(static_cast<std::underlying_type_t<Enum>>(value));
+    }
+
     /**
      * @brief Copies the content of the given trivially copyable class to the buffer as a normal
      * param

src/core/hle/service/acc/acc.cpp

@@ -82,14 +82,16 @@ private:
         LOG_WARNING(Service_ACC, "(STUBBED) called");
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push(true); // TODO: Check when this is supposed to return true and when not
+        rb.Push(false); // TODO: Check when this is supposed to return true and when not
     }
 
     void GetAccountId(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(0x12345678ABCDEF);
+        // TODO(Subv): Find out what this actually does and implement it. Stub it as an error for
+        // now since we do not implement NNID. Returning a bogus id here will cause games to send
+        // invalid IPC requests after ListOpenUsers is called.
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultCode(-1));
     }
 };
 
@@ -104,7 +106,7 @@ void Module::Interface::ListAllUsers(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_ACC, "(STUBBED) called");
     // TODO(Subv): There is only one user for now.
     const std::vector<u128> user_ids = {DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids.data(), user_ids.size() * sizeof(u128));
+    ctx.WriteBuffer(user_ids);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
@@ -113,7 +115,7 @@ void Module::Interface::ListOpenUsers(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_ACC, "(STUBBED) called");
     // TODO(Subv): There is only one user for now.
     const std::vector<u128> user_ids = {DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids.data(), user_ids.size() * sizeof(u128));
+    ctx.WriteBuffer(user_ids);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }

src/core/hle/service/apm/interface.cpp

@@ -20,6 +20,21 @@ public:
     }
 
 private:
+    enum class PerformanceConfiguration : u32 {
+        Config1 = 0x00010000,
+        Config2 = 0x00010001,
+        Config3 = 0x00010002,
+        Config4 = 0x00020000,
+        Config5 = 0x00020001,
+        Config6 = 0x00020002,
+        Config7 = 0x00020003,
+        Config8 = 0x00020004,
+        Config9 = 0x00020005,
+        Config10 = 0x00020006,
+        Config11 = 0x92220007,
+        Config12 = 0x92220008,
+    };
+
     void SetPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
@@ -40,7 +55,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(0); // Performance configuration
+        rb.Push<u32>(static_cast<u32>(PerformanceConfiguration::Config1));
 
         LOG_WARNING(Service_APM, "(STUBBED) called mode={}", static_cast<u32>(mode));
     }

src/core/hle/service/audio/audout_u.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
 #include <vector>
 #include "common/logging/log.h"
 #include "core/core_timing.h"
@@ -167,7 +168,7 @@ void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_Audio, "(STUBBED) called");
     IPC::RequestParser rp{ctx};
 
-    const std::string audio_interface = "AudioInterface";
+    constexpr std::array<char, 15> audio_interface{{"AudioInterface"}};
     ctx.WriteBuffer(audio_interface);
 
     IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);

src/core/hle/service/audio/audren_u.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
+
 #include "common/alignment.h"
 #include "common/logging/log.h"
 #include "core/core_timing.h"
@@ -298,7 +300,7 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
 
-        const std::string audio_interface = "AudioInterface";
+        constexpr std::array<char, 15> audio_interface{{"AudioInterface"}};
         ctx.WriteBuffer(audio_interface);
 
         IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);
@@ -323,7 +325,7 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
 
-        const std::string audio_interface = "AudioDevice";
+        constexpr std::array<char, 12> audio_interface{{"AudioDevice"}};
         ctx.WriteBuffer(audio_interface);
 
         IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);

src/core/hle/service/ns/pl_u.cpp

@@ -132,9 +132,9 @@ void PL_U::GetSharedFontInOrderOfPriority(Kernel::HLERequestContext& ctx) {
         font_sizes.push_back(SHARED_FONT_REGIONS[i].size);
     }
 
-    ctx.WriteBuffer(font_codes.data(), font_codes.size() * sizeof(u32), 0);
-    ctx.WriteBuffer(font_offsets.data(), font_offsets.size() * sizeof(u32), 1);
-    ctx.WriteBuffer(font_sizes.data(), font_sizes.size() * sizeof(u32), 2);
+    ctx.WriteBuffer(font_codes, 0);
+    ctx.WriteBuffer(font_offsets, 1);
+    ctx.WriteBuffer(font_sizes, 2);
 
     rb.Push(RESULT_SUCCESS);
     rb.Push<u8>(static_cast<u8>(LoadState::Done)); // Fonts Loaded

src/core/loader/nca.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <utility>
 #include <vector>
 
 #include "common/file_util.h"
@@ -21,7 +22,7 @@
 
 namespace Loader {
 
-AppLoader_NCA::AppLoader_NCA(FileSys::VirtualFile file) : AppLoader(file) {}
+AppLoader_NCA::AppLoader_NCA(FileSys::VirtualFile file) : AppLoader(std::move(file)) {}
 
 FileType AppLoader_NCA::IdentifyType(const FileSys::VirtualFile& file) {
     // TODO(DarkLordZach): Assuming everything is decrypted. Add crypto support.

src/core/loader/nro.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <utility>
 #include <vector>
 
 #include "common/common_funcs.h"
@@ -48,7 +49,7 @@ struct ModHeader {
 };
 static_assert(sizeof(ModHeader) == 0x1c, "ModHeader has incorrect size.");
 
-AppLoader_NRO::AppLoader_NRO(FileSys::VirtualFile file) : AppLoader(file) {}
+AppLoader_NRO::AppLoader_NRO(FileSys::VirtualFile file) : AppLoader(std::move(file)) {}
 
 FileType AppLoader_NRO::IdentifyType(const FileSys::VirtualFile& file) {
     // Read NSO header

src/core/loader/nso.cpp

@@ -69,29 +69,18 @@ FileType AppLoader_NSO::IdentifyType(const FileSys::VirtualFile& file) {
 static std::vector<u8> DecompressSegment(const std::vector<u8>& compressed_data,
                                          const NsoSegmentHeader& header) {
     std::vector<u8> uncompressed_data(header.size);
-    const int bytes_uncompressed = LZ4_decompress_safe(
-        reinterpret_cast<const char*>(compressed_data.data()),
-        reinterpret_cast<char*>(uncompressed_data.data()), compressed_data.size(), header.size);
+    const int bytes_uncompressed =
+        LZ4_decompress_safe(reinterpret_cast<const char*>(compressed_data.data()),
+                            reinterpret_cast<char*>(uncompressed_data.data()),
+                            static_cast<int>(compressed_data.size()), header.size);
 
-    ASSERT_MSG(bytes_uncompressed == header.size && bytes_uncompressed == uncompressed_data.size(),
+    ASSERT_MSG(bytes_uncompressed == static_cast<int>(header.size) &&
+                   bytes_uncompressed == static_cast<int>(uncompressed_data.size()),
                "{} != {} != {}", bytes_uncompressed, header.size, uncompressed_data.size());
 
     return uncompressed_data;
 }
 
-static std::vector<u8> ReadSegment(FileUtil::IOFile& file, const NsoSegmentHeader& header,
-                                   size_t compressed_size) {
-    std::vector<u8> compressed_data(compressed_size);
-
-    file.Seek(header.offset, SEEK_SET);
-    if (compressed_size != file.ReadBytes(compressed_data.data(), compressed_size)) {
-        LOG_CRITICAL(Loader, "Failed to read {} NSO LZ4 compressed bytes", compressed_size);
-        return {};
-    }
-
-    return DecompressSegment(compressed_data, header);
-}
-
 static constexpr u32 PageAlignSize(u32 size) {
     return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
 }

src/video_core/engines/maxwell_3d.cpp

@@ -317,8 +317,6 @@ std::vector<Texture::FullTextureInfo> Maxwell3D::GetStageTextures(Regs::ShaderSt
     auto& tex_info_buffer = fragment_shader.const_buffers[regs.tex_cb_index];
     ASSERT(tex_info_buffer.enabled && tex_info_buffer.address != 0);
 
-    GPUVAddr tic_base_address = regs.tic.TICAddress();
-
     GPUVAddr tex_info_buffer_end = tex_info_buffer.address + tex_info_buffer.size;
 
     // Offset into the texture constbuffer where the texture info begins.

src/video_core/gpu.cpp

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

src/video_core/gpu.h

@@ -93,15 +93,14 @@ 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.
-    const Engines::Maxwell3D& Get3DEngine() const;
+    Engines::Maxwell3D& Maxwell3D();
 
     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) {
-    auto& gpu = Core::System::GetInstance().GPU();
-    auto& maxwell3d = gpu.Get3DEngine();
+    const auto& gpu = Core::System::GetInstance().GPU();
+    const auto& maxwell3d = gpu.Maxwell3D();
 
     // 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
-    auto& shader_stage = maxwell3d.state.shader_stages[static_cast<size_t>(stage)];
+    const 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) {
-    auto& gpu = Core::System::GetInstance().GPU();
-    auto& maxwell3d = gpu.Get3DEngine();
+    const auto& gpu = Core::System::GetInstance().GPU();
+    const auto& maxwell3d = gpu.Maxwell3D();
 
     ASSERT_MSG(current_unit + entries.size() <= std::size(state.texture_units),
                "Exceeded the number of active textures.");

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -216,7 +216,7 @@ public:
     }
 
     /// Returns a GLSL string representing the current state of the register
-    const std::string GetActiveString() {
+    std::string GetActiveString() {
         declr_type.insert(active_type);
         return GetPrefixString(active_type) + std::to_string(index) + '_' + suffix;
     }
@@ -518,7 +518,7 @@ public:
 
 private:
     /// Build GLSL conversion function, e.g. floatBitsToInt, intBitsToFloat, etc.
-    const std::string GetGLSLConversionFunc(GLSLRegister::Type src, GLSLRegister::Type dest) const {
+    std::string GetGLSLConversionFunc(GLSLRegister::Type src, GLSLRegister::Type dest) const {
         const std::string src_type = GLSLRegister::GetTypeString(src);
         std::string dest_type = GLSLRegister::GetTypeString(dest);
         dest_type[0] = toupper(dest_type[0]);
@@ -1405,7 +1405,7 @@ private:
 
                 // TEXS has two destination registers. RG goes into gpr0+0 and gpr0+1, and BA
                 // goes into gpr28+0 and gpr28+1
-                size_t offset{};
+                size_t texs_offset{};
 
                 for (const auto& dest : {instr.gpr0.Value(), instr.gpr28.Value()}) {
                     for (unsigned elem = 0; elem < 2; ++elem) {
@@ -1413,7 +1413,8 @@ private:
                             // Skip disabled components
                             continue;
                         }
-                        regs.SetRegisterToFloat(dest, elem + offset, texture, 1, 4, false, elem);
+                        regs.SetRegisterToFloat(dest, elem + texs_offset, texture, 1, 4, false,
+                                                elem);
                     }
 
                     if (!instr.texs.HasTwoDestinations()) {
@@ -1421,7 +1422,7 @@ private:
                         break;
                     }
 
-                    offset += 2;
+                    texs_offset += 2;
                 }
                 --shader.scope;
                 shader.AddLine("}");
@@ -1463,7 +1464,6 @@ private:
                 op_b = "abs(" + op_b + ')';
             }
 
-            using Tegra::Shader::Pred;
             // We can't use the constant predicate as destination.
             ASSERT(instr.fsetp.pred3 != static_cast<u64>(Pred::UnusedIndex));
 
@@ -1500,7 +1500,6 @@ private:
                 }
             }
 
-            using Tegra::Shader::Pred;
             // We can't use the constant predicate as destination.
             ASSERT(instr.isetp.pred3 != static_cast<u64>(Pred::UnusedIndex));
 
@@ -1528,7 +1527,6 @@ private:
             std::string op_b =
                 GetPredicateCondition(instr.psetp.pred29, instr.psetp.neg_pred29 != 0);
 
-            using Tegra::Shader::Pred;
             // We can't use the constant predicate as destination.
             ASSERT(instr.psetp.pred3 != static_cast<u64>(Pred::UnusedIndex));
 

src/video_core/renderer_opengl/gl_state.cpp

@@ -181,30 +181,34 @@ void OpenGLState::Apply() const {
     }
 
     // Textures
-    for (int i = 0; i < std::size(texture_units); ++i) {
-        if (texture_units[i].texture_2d != cur_state.texture_units[i].texture_2d) {
-            glActiveTexture(TextureUnits::MaxwellTexture(i).Enum());
-            glBindTexture(GL_TEXTURE_2D, texture_units[i].texture_2d);
+    for (std::size_t i = 0; i < std::size(texture_units); ++i) {
+        const auto& texture_unit = texture_units[i];
+        const auto& cur_state_texture_unit = cur_state.texture_units[i];
+
+        if (texture_unit.texture_2d != cur_state_texture_unit.texture_2d) {
+            glActiveTexture(TextureUnits::MaxwellTexture(static_cast<int>(i)).Enum());
+            glBindTexture(GL_TEXTURE_2D, texture_unit.texture_2d);
         }
-        if (texture_units[i].sampler != cur_state.texture_units[i].sampler) {
-            glBindSampler(static_cast<GLuint>(i), texture_units[i].sampler);
+        if (texture_unit.sampler != cur_state_texture_unit.sampler) {
+            glBindSampler(static_cast<GLuint>(i), texture_unit.sampler);
         }
         // Update the texture swizzle
-        if (texture_units[i].swizzle.r != cur_state.texture_units[i].swizzle.r ||
-            texture_units[i].swizzle.g != cur_state.texture_units[i].swizzle.g ||
-            texture_units[i].swizzle.b != cur_state.texture_units[i].swizzle.b ||
-            texture_units[i].swizzle.a != cur_state.texture_units[i].swizzle.a) {
-            std::array<GLint, 4> mask = {texture_units[i].swizzle.r, texture_units[i].swizzle.g,
-                                         texture_units[i].swizzle.b, texture_units[i].swizzle.a};
+        if (texture_unit.swizzle.r != cur_state_texture_unit.swizzle.r ||
+            texture_unit.swizzle.g != cur_state_texture_unit.swizzle.g ||
+            texture_unit.swizzle.b != cur_state_texture_unit.swizzle.b ||
+            texture_unit.swizzle.a != cur_state_texture_unit.swizzle.a) {
+            std::array<GLint, 4> mask = {texture_unit.swizzle.r, texture_unit.swizzle.g,
+                                         texture_unit.swizzle.b, texture_unit.swizzle.a};
             glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, mask.data());
         }
     }
 
     // Constbuffers
-    for (u32 stage = 0; stage < draw.const_buffers.size(); ++stage) {
-        for (u32 buffer_id = 0; buffer_id < draw.const_buffers[stage].size(); ++buffer_id) {
-            auto& current = cur_state.draw.const_buffers[stage][buffer_id];
-            auto& new_state = draw.const_buffers[stage][buffer_id];
+    for (std::size_t stage = 0; stage < draw.const_buffers.size(); ++stage) {
+        for (std::size_t buffer_id = 0; buffer_id < draw.const_buffers[stage].size(); ++buffer_id) {
+            const auto& current = cur_state.draw.const_buffers[stage][buffer_id];
+            const auto& new_state = draw.const_buffers[stage][buffer_id];
+
             if (current.enabled != new_state.enabled || current.bindpoint != new_state.bindpoint ||
                 current.ssbo != new_state.ssbo) {
                 if (new_state.enabled) {

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...
 
-        auto& registers = gpu.Get3DEngine().regs;
-        auto& rt = registers.rt[static_cast<size_t>(surface_source) -
-                                static_cast<size_t>(Source::RenderTarget0)];
+        const auto& registers = gpu.Maxwell3D().regs;
+        const auto& rt = registers.rt[static_cast<size_t>(surface_source) -
+                                      static_cast<size_t>(Source::RenderTarget0)];
 
         surface_address = rt.Address();
         surface_width = rt.width;