diff options
Diffstat (limited to 'src')
75 files changed, 1556 insertions, 8175 deletions
diff --git a/src/xenia/app/premake5.lua b/src/xenia/app/premake5.lua index a999512c4..3b4b4b9c6 100644 --- a/src/xenia/app/premake5.lua +++ b/src/xenia/app/premake5.lua @@ -17,7 +17,7 @@ project("xenia-app") "libavutil", "snappy", "spirv-tools", - "vulkan-loader", + "volk", "xenia-apu", "xenia-apu-nop", "xenia-base", @@ -26,14 +26,12 @@ project("xenia-app") "xenia-cpu-backend-x64", "xenia-debug-ui", "xenia-gpu", - "xenia-gpu-gl4", "xenia-gpu-null", "xenia-gpu-vulkan", "xenia-hid", "xenia-hid-nop", "xenia-kernel", "xenia-ui", - "xenia-ui-gl", "xenia-ui-spirv", "xenia-ui-vulkan", "xenia-vfs", @@ -60,6 +58,15 @@ project("xenia-app") project_root, }) + filter("platforms:Linux") + links({ + "X11", + "xcb", + "X11-xcb", + "GL", + "vulkan", + }) + filter("platforms:Windows") links({ "xenia-apu-xaudio2", diff --git a/src/xenia/app/xenia_main.cc b/src/xenia/app/xenia_main.cc index 7b20892a7..be2f3d34b 100644 --- a/src/xenia/app/xenia_main.cc +++ b/src/xenia/app/xenia_main.cc @@ -26,7 +26,6 @@ #endif // XE_PLATFORM_WIN32 // Available graphics systems: -#include "xenia/gpu/gl4/gl4_graphics_system.h" #include "xenia/gpu/null/null_graphics_system.h" #include "xenia/gpu/vulkan/vulkan_graphics_system.h" @@ -38,7 +37,7 @@ #endif // XE_PLATFORM_WIN32 DEFINE_string(apu, "any", "Audio system. Use: [any, nop, xaudio2]"); -DEFINE_string(gpu, "any", "Graphics system. Use: [any, gl4, vulkan, null]"); +DEFINE_string(gpu, "any", "Graphics system. Use: [any, vulkan, null]"); DEFINE_string(hid, "any", "Input system. Use: [any, nop, winkey, xinput]"); DEFINE_string(target, "", "Specifies the target .xex or .iso to execute."); @@ -71,10 +70,7 @@ std::unique_ptr<apu::AudioSystem> CreateAudioSystem(cpu::Processor* processor) { } std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem() { - if (FLAGS_gpu.compare("gl4") == 0) { - return std::unique_ptr<gpu::GraphicsSystem>( - new xe::gpu::gl4::GL4GraphicsSystem()); - } else if (FLAGS_gpu.compare("vulkan") == 0) { + if (FLAGS_gpu.compare("vulkan") == 0) { return std::unique_ptr<gpu::GraphicsSystem>( new xe::gpu::vulkan::VulkanGraphicsSystem()); } else if (FLAGS_gpu.compare("null") == 0) { diff --git a/src/xenia/base/bit_field.h b/src/xenia/base/bit_field.h index 034f43d9e..98a8bfbf8 100644 --- a/src/xenia/base/bit_field.h +++ b/src/xenia/base/bit_field.h @@ -19,20 +19,28 @@ namespace xe { // Bitfield, where position starts at the LSB. template <typename T, size_t position, size_t n_bits> struct bf { + // For enum values, we strip them down to an underlying type. + typedef + typename std::conditional<std::is_enum<T>::value, std::underlying_type<T>, + std::remove_reference<T>>::type::type + value_type; + bf() = default; inline operator T() const { return value(); } inline T value() const { - return static_cast<T>((storage & mask()) >> position); + auto value = (storage & mask()) >> position; + if (std::is_signed<value_type>::value) { + // If the value is signed, sign-extend it. + value_type sign_mask = value_type(1) << (n_bits - 1); + value = (sign_mask ^ value) - sign_mask; + } + + return static_cast<T>(value); } - // For enum values, we strip them down to an underlying type. - typedef - typename std::conditional<std::is_enum<T>::value, std::underlying_type<T>, - std::remove_reference<T>>::type::type - value_type; inline value_type mask() const { - return (((value_type)~0) >> (8 * sizeof(value_type) - n_bits)) << position; + return ((value_type(1) << n_bits) - 1) << position; } value_type storage; diff --git a/src/xenia/base/memory.cc b/src/xenia/base/memory.cc index bdc0ea7f1..1f9d654a1 100644 --- a/src/xenia/base/memory.cc +++ b/src/xenia/base/memory.cc @@ -26,7 +26,9 @@ void copy_128_aligned(void* dest, const void* src, size_t count) { #if XE_ARCH_AMD64 void copy_and_swap_16_aligned(void* dest_ptr, const void* src_ptr, size_t count) { - assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x1); + assert_zero(reinterpret_cast<uintptr_t>(dest_ptr) & 0xF); + assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0xF); + auto dest = reinterpret_cast<uint16_t*>(dest_ptr); auto src = reinterpret_cast<const uint16_t*>(src_ptr); __m128i shufmask = @@ -34,12 +36,7 @@ void copy_and_swap_16_aligned(void* dest_ptr, const void* src_ptr, 0x04, 0x05, 0x02, 0x03, 0x00, 0x01); size_t i = 0; - size_t unaligned_words = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 2; - for (; unaligned_words > 0 && i < count; unaligned_words--, i++) { - // Copy up to 16 byte alignment. - dest[i] = byte_swap(src[i]); - } - for (; i + 8 <= count; i += 8) { + for (i = 0; i + 8 <= count; i += 8) { __m128i input = _mm_load_si128(reinterpret_cast<const __m128i*>(&src[i])); __m128i output = _mm_shuffle_epi8(input, shufmask); _mm_store_si128(reinterpret_cast<__m128i*>(&dest[i]), output); @@ -70,20 +67,17 @@ void copy_and_swap_16_unaligned(void* dest_ptr, const void* src_ptr, void copy_and_swap_32_aligned(void* dest_ptr, const void* src_ptr, size_t count) { - assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x3); + assert_zero(reinterpret_cast<uintptr_t>(dest_ptr) & 0xF); + assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0xF); + auto dest = reinterpret_cast<uint32_t*>(dest_ptr); auto src = reinterpret_cast<const uint32_t*>(src_ptr); __m128i shufmask = _mm_set_epi8(0x0C, 0x0D, 0x0E, 0x0F, 0x08, 0x09, 0x0A, 0x0B, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03); - size_t i = 0; - size_t unaligned_dwords = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 4; - for (; unaligned_dwords > 0 && i < count; unaligned_dwords--, i++) { - // Copy up to 16 byte alignment. - dest[i] = byte_swap(src[i]); - } - for (; i + 4 <= count; i += 4) { + size_t i; + for (i = 0; i + 4 <= count; i += 4) { __m128i input = _mm_load_si128(reinterpret_cast<const __m128i*>(&src[i])); __m128i output = _mm_shuffle_epi8(input, shufmask); _mm_store_si128(reinterpret_cast<__m128i*>(&dest[i]), output); @@ -114,20 +108,17 @@ void copy_and_swap_32_unaligned(void* dest_ptr, const void* src_ptr, void copy_and_swap_64_aligned(void* dest_ptr, const void* src_ptr, size_t count) { - assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x7); + assert_zero(reinterpret_cast<uintptr_t>(dest_ptr) & 0xF); + assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0xF); + auto dest = reinterpret_cast<uint64_t*>(dest_ptr); auto src = reinterpret_cast<const uint64_t*>(src_ptr); __m128i shufmask = _mm_set_epi8(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07); - size_t i = 0; - size_t unaligned_qwords = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 8; - for (; unaligned_qwords > 0 && i < count; unaligned_qwords--, i++) { - // Copy up to 16 byte alignment. - dest[i] = byte_swap(src[i]); - } - for (; i + 2 <= count; i += 2) { + size_t i; + for (i = 0; i + 2 <= count; i += 2) { __m128i input = _mm_load_si128(reinterpret_cast<const __m128i*>(&src[i])); __m128i output = _mm_shuffle_epi8(input, shufmask); _mm_store_si128(reinterpret_cast<__m128i*>(&dest[i]), output); diff --git a/src/xenia/base/memory_test.cc b/src/xenia/base/memory_test.cc deleted file mode 100644 index 427f132a3..000000000 --- a/src/xenia/base/memory_test.cc +++ /dev/null @@ -1,17 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/base/memory.h" - -#include "third_party/catch/include/catch.hpp" - -TEST_CASE("copy_and_swap_16_aligned", "Copy and Swap") { - // TODO(benvanik): tests. - REQUIRE(true == true); -} diff --git a/src/xenia/base/platform_linux.h b/src/xenia/base/platform_linux.h index 345be94ab..ac64879e5 100644 --- a/src/xenia/base/platform_linux.h +++ b/src/xenia/base/platform_linux.h @@ -13,6 +13,7 @@ // NOTE: if you're including this file it means you are explicitly depending // on Linux headers. Including this file outside of linux platform specific // source code will break portability +#include <cstddef> #include "xenia/base/platform.h" diff --git a/src/xenia/base/premake5.lua b/src/xenia/base/premake5.lua index 29a0799ca..960a6500c 100644 --- a/src/xenia/base/premake5.lua +++ b/src/xenia/base/premake5.lua @@ -16,11 +16,4 @@ project("xenia-base") "debug_visualizers.natvis", }) -test_suite("xenia-base-tests", project_root, ".", { - includedirs = { - project_root.."/third_party/gflags/src", - }, - links = { - "xenia-base", - }, -}) +include("testing") diff --git a/src/xenia/base/testing/memory_test.cc b/src/xenia/base/testing/memory_test.cc new file mode 100644 index 000000000..5433dc118 --- /dev/null +++ b/src/xenia/base/testing/memory_test.cc @@ -0,0 +1,419 @@ +/** + ****************************************************************************** + * Xenia : Xbox 360 Emulator Research Project * + ****************************************************************************** + * Copyright 2015 Ben Vanik. All rights reserved. * + * Released under the BSD license - see LICENSE in the root for more details. * + ****************************************************************************** + */ + +#include "xenia/base/memory.h" + +#include "third_party/catch/include/catch.hpp" + +namespace xe { +namespace base { +namespace test { + +TEST_CASE("copy_128_aligned", "Copy and Swap") { + alignas(128) uint8_t src[256], dest[256]; + for (uint8_t i = 0; i < 255; ++i) { + src[i] = 255 - i; + } + std::memset(dest, 0, sizeof(dest)); + copy_128_aligned(dest, src, 1); + REQUIRE(std::memcmp(dest, src, 128)); + REQUIRE(dest[128] == 0); + + std::memset(dest, 0, sizeof(dest)); + copy_128_aligned(dest, src, 2); + REQUIRE(std::memcmp(dest, src, 256)); + + std::memset(dest, 0, sizeof(dest)); + copy_128_aligned(dest, src + 1, 1); + REQUIRE(std::memcmp(dest, src + 1, 128)); +} + +TEST_CASE("copy_and_swap_16_aligned", "Copy and Swap") { + alignas(16) uint16_t a = 0x1111, b = 0xABCD; + copy_and_swap_16_aligned(&a, &b, 1); + REQUIRE(a == 0xCDAB); + REQUIRE(b == 0xABCD); + + alignas(16) uint16_t c[] = {0x0000, 0x0000, 0x0000, 0x0000}; + alignas(16) uint16_t d[] = {0x0123, 0x4567, 0x89AB, 0xCDEF}; + copy_and_swap_16_aligned(c, d, 1); + REQUIRE(c[0] == 0x2301); + REQUIRE(c[1] == 0x0000); + REQUIRE(c[2] == 0x0000); + REQUIRE(c[3] == 0x0000); + + copy_and_swap_16_aligned(c, d, 3); + REQUIRE(c[0] == 0x2301); + REQUIRE(c[1] == 0x6745); + REQUIRE(c[2] == 0xAB89); + REQUIRE(c[3] == 0x0000); + + copy_and_swap_16_aligned(c, d, 4); + REQUIRE(c[0] == 0x2301); + REQUIRE(c[1] == 0x6745); + REQUIRE(c[2] == 0xAB89); + REQUIRE(c[3] == 0xEFCD); + + alignas(16) uint64_t e; + copy_and_swap_16_aligned(&e, d, 4); + REQUIRE(e == 0xEFCDAB8967452301); + + alignas(16) char f[85] = {0x00}; + alignas(16) char g[] = + "This is a 85 byte long string... " + "It's supposed to be longer than standard alignment."; + copy_and_swap_16_aligned(f, g, 42); + REQUIRE(std::strcmp(f, + "hTsii s a58b ty eolgns rtni.g..I 't susppsodet oebl " + "noeg rhtnas atdnra dlagimnne.t") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_16_aligned(f, g + 16, 34); + REQUIRE(std::strcmp(f, + " eolgns rtni.g..I 't susppsodet oebl " + "noeg rhtnas atdnra dlagimnne.t") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_16_aligned(f, g + 32, 26); + REQUIRE(std::strcmp(f, + "I 't susppsodet oebl " + "noeg rhtnas atdnra dlagimnne.t") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_16_aligned(f, g + 64, 10); + REQUIRE(std::strcmp(f, "s atdnra dlagimnne.t") == 0); +} + +TEST_CASE("copy_and_swap_16_unaligned", "Copy and Swap") { + uint16_t a = 0x1111, b = 0xABCD; + copy_and_swap_16_unaligned(&a, &b, 1); + REQUIRE(a == 0xCDAB); + REQUIRE(b == 0xABCD); + + uint16_t c[] = {0x0000, 0x0000, 0x0000, 0x0000}; + uint16_t d[] = {0x0123, 0x4567, 0x89AB, 0xCDEF}; + copy_and_swap_16_unaligned(c, d, 1); + REQUIRE(c[0] == 0x2301); + REQUIRE(c[1] == 0x0000); + REQUIRE(c[2] == 0x0000); + REQUIRE(c[3] == 0x0000); + + copy_and_swap_16_unaligned(c, d, 4); + REQUIRE(c[0] == 0x2301); + REQUIRE(c[1] == 0x6745); + REQUIRE(c[2] == 0xAB89); + REQUIRE(c[3] == 0xEFCD); + + uint64_t e; + copy_and_swap_16_unaligned(&e, d, 4); + REQUIRE(e == 0xEFCDAB8967452301); + + char f[85] = {0x00}; + char g[] = + "This is a 85 byte long string... " + "It's supposed to be longer than standard alignment."; + copy_and_swap_16_unaligned(f, g, 42); + REQUIRE(std::strcmp(f, + "hTsii s a58b ty eolgns rtni.g..I 't susppsodet oebl " + "noeg rhtnas atdnra dlagimnne.t") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_16_unaligned(f, g + 1, 41); + REQUIRE(std::strcmp(f, + "ih ssia 8 5ybetl no gtsirgn.. .tIs's puopes dotb " + "eolgnret ah ntsnaaddra ilngemtn") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_16_unaligned(f, g + 2, 41); + REQUIRE(std::strcmp(f, + "sii s a58b ty eolgns rtni.g..I 't susppsodet oebl " + "noeg rhtnas atdnra dlagimnne.t") == 0); +} + +TEST_CASE("copy_and_swap_32_aligned", "Copy and Swap") { + alignas(32) uint32_t a = 0x11111111, b = 0x89ABCDEF; + copy_and_swap_32_aligned(&a, &b, 1); + REQUIRE(a == 0xEFCDAB89); + REQUIRE(b == 0x89ABCDEF); + + alignas(32) uint32_t c[] = {0x00000000, 0x00000000, 0x00000000, 0x00000000}; + alignas(32) uint32_t d[] = {0x01234567, 0x89ABCDEF, 0xE887EEED, 0xD8514199}; + copy_and_swap_32_aligned(c, d, 1); + REQUIRE(c[0] == 0x67452301); + REQUIRE(c[1] == 0x00000000); + REQUIRE(c[2] == 0x00000000); + REQUIRE(c[3] == 0x00000000); + + copy_and_swap_32_aligned(c, d, 3); + REQUIRE(c[0] == 0x67452301); + REQUIRE(c[1] == 0xEFCDAB89); + REQUIRE(c[2] == 0xEDEE87E8); + REQUIRE(c[3] == 0x00000000); + + copy_and_swap_32_aligned(c, d, 4); + REQUIRE(c[0] == 0x67452301); + REQUIRE(c[1] == 0xEFCDAB89); + REQUIRE(c[2] == 0xEDEE87E8); + REQUIRE(c[3] == 0x994151D8); + + alignas(32) uint64_t e; + copy_and_swap_32_aligned(&e, d, 2); + REQUIRE(e == 0xEFCDAB8967452301); + + alignas(32) char f[85] = {0x00}; + alignas(32) char g[] = + "This is a 85 byte long string... " + "It's supposed to be longer than standard alignment."; + copy_and_swap_32_aligned(f, g, 21); + REQUIRE(std::strcmp(f, + "sihT si 58 atyb ol es gnnirt...g'tI us ssoppt deeb " + "onol regnahtats radnla dmngi.tne") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_32_aligned(f, g + 16, 17); + REQUIRE(std::strcmp(f, + "ol es gnnirt...g'tI us ssoppt deeb " + "onol regnahtats radnla dmngi.tne") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_32_aligned(f, g + 32, 13); + REQUIRE(std::strcmp(f, + "'tI us ssoppt deeb " + "onol regnahtats radnla dmngi.tne") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_32_aligned(f, g + 64, 5); + REQUIRE(std::strcmp(f, "ats radnla dmngi.tne") == 0); +} + +TEST_CASE("copy_and_swap_32_unaligned", "Copy and Swap") { + uint32_t a = 0x11111111, b = 0x89ABCDEF; + copy_and_swap_32_unaligned(&a, &b, 1); + REQUIRE(a == 0xEFCDAB89); + REQUIRE(b == 0x89ABCDEF); + + uint32_t c[] = {0x00000000, 0x00000000, 0x00000000, 0x00000000}; + uint32_t d[] = {0x01234567, 0x89ABCDEF, 0xE887EEED, 0xD8514199}; + copy_and_swap_32_unaligned(c, d, 1); + REQUIRE(c[0] == 0x67452301); + REQUIRE(c[1] == 0x00000000); + REQUIRE(c[2] == 0x00000000); + REQUIRE(c[3] == 0x00000000); + + copy_and_swap_32_unaligned(c, d, 3); + REQUIRE(c[0] == 0x67452301); + REQUIRE(c[1] == 0xEFCDAB89); + REQUIRE(c[2] == 0xEDEE87E8); + REQUIRE(c[3] == 0x00000000); + + copy_and_swap_32_unaligned(c, d, 4); + REQUIRE(c[0] == 0x67452301); + REQUIRE(c[1] == 0xEFCDAB89); + REQUIRE(c[2] == 0xEDEE87E8); + REQUIRE(c[3] == 0x994151D8); + + uint64_t e; + copy_and_swap_32_unaligned(&e, d, 2); + REQUIRE(e == 0xEFCDAB8967452301); + + char f[85] = {0x00}; + char g[] = + "This is a 85 byte long string... " + "It's supposed to be longer than standard alignment."; + copy_and_swap_32_unaligned(f, g, 21); + REQUIRE(std::strcmp(f, + "sihT si 58 atyb ol es gnnirt...g'tI us ssoppt deeb " + "onol regnahtats radnla dmngi.tne") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_32_unaligned(f, g + 1, 20); + REQUIRE(std::strcmp(f, + " siha si 58 etybnol ts ggnir ...s'tIpus esopot d eb " + "gnolt re nahnatsdradila emng") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_32_unaligned(f, g + 2, 20); + REQUIRE(std::strcmp(f, + "i si a sb 58 etygnolrts .gniI .. s'tppusdeso ot l " + "ebegnoht rs nadnat dragilanemn") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_32_unaligned(f, g + 3, 20); + REQUIRE(std::strcmp(f, + "si s8 a yb 5l et gnoirts..gntI .s s'oppu desb otol " + "eregnaht ts nadnaa drngiltnem") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_32_unaligned(f, g + 4, 20); + REQUIRE(std::strcmp(f, + " si 58 atyb ol es gnnirt...g'tI us ssoppt deeb onol " + "regnahtats radnla dmngi.tne") == 0); +} + +TEST_CASE("copy_and_swap_64_aligned", "Copy and Swap") { + alignas(64) uint64_t a = 0x1111111111111111, b = 0x0123456789ABCDEF; + copy_and_swap_64_aligned(&a, &b, 1); + REQUIRE(a == 0xEFCDAB8967452301); + REQUIRE(b == 0x0123456789ABCDEF); + + alignas(64) uint64_t c[] = {0x0000000000000000, 0x0000000000000000, + 0x0000000000000000, 0x0000000000000000}; + alignas(64) uint64_t d[] = {0x0123456789ABCDEF, 0xE887EEEDD8514199, + 0x21D4745A1D4A7706, 0xA4174FED675766E3}; + copy_and_swap_64_aligned(c, d, 1); + REQUIRE(c[0] == 0xEFCDAB8967452301); + REQUIRE(c[1] == 0x0000000000000000); + REQUIRE(c[2] == 0x0000000000000000); + REQUIRE(c[3] == 0x0000000000000000); + + copy_and_swap_64_aligned(c, d, 3); + REQUIRE(c[0] == 0xEFCDAB8967452301); + REQUIRE(c[1] == 0x994151D8EDEE87E8); + REQUIRE(c[2] == 0x06774A1D5A74D421); + REQUIRE(c[3] == 0x0000000000000000); + + copy_and_swap_64_aligned(c, d, 4); + REQUIRE(c[0] == 0xEFCDAB8967452301); + REQUIRE(c[1] == 0x994151D8EDEE87E8); + REQUIRE(c[2] == 0x06774A1D5A74D421); + REQUIRE(c[3] == 0xE3665767ED4F17A4); + + alignas(64) uint64_t e; + copy_and_swap_64_aligned(&e, d, 1); + REQUIRE(e == 0xEFCDAB8967452301); + + alignas(64) char f[85] = {0x00}; + alignas(64) char g[] = + "This is a 85 byte long string... " + "It's supposed to be longer than standard alignment."; + copy_and_swap_64_aligned(f, g, 10); + REQUIRE(std::strcmp(f, + " si sihTtyb 58 as gnol e...gnirtus s'tI t desoppnol eb " + "onaht regradnats mngila d") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_aligned(f, g + 16, 8); + REQUIRE(std::strcmp(f, + "s gnol e...gnirtus s'tI t desoppnol eb " + "onaht regradnats mngila d") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_aligned(f, g + 32, 6); + REQUIRE(std::strcmp(f, + "us s'tI t desoppnol eb " + "onaht regradnats mngila d") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_aligned(f, g + 64, 2); + REQUIRE(std::strcmp(f, "radnats mngila d") == 0); +} + +TEST_CASE("copy_and_swap_64_unaligned", "Copy and Swap") { + uint64_t a = 0x1111111111111111, b = 0x0123456789ABCDEF; + copy_and_swap_64_unaligned(&a, &b, 1); + REQUIRE(a == 0xEFCDAB8967452301); + REQUIRE(b == 0x0123456789ABCDEF); + + uint64_t c[] = {0x0000000000000000, 0x0000000000000000, 0x0000000000000000, + 0x0000000000000000}; + uint64_t d[] = {0x0123456789ABCDEF, 0xE887EEEDD8514199, 0x21D4745A1D4A7706, + 0xA4174FED675766E3}; + copy_and_swap_64_unaligned(c, d, 1); + REQUIRE(c[0] == 0xEFCDAB8967452301); + REQUIRE(c[1] == 0x0000000000000000); + REQUIRE(c[2] == 0x0000000000000000); + REQUIRE(c[3] == 0x0000000000000000); + + copy_and_swap_64_unaligned(c, d, 3); + REQUIRE(c[0] == 0xEFCDAB8967452301); + REQUIRE(c[1] == 0x994151D8EDEE87E8); + REQUIRE(c[2] == 0x06774A1D5A74D421); + REQUIRE(c[3] == 0x0000000000000000); + + copy_and_swap_64_unaligned(c, d, 4); + REQUIRE(c[0] == 0xEFCDAB8967452301); + REQUIRE(c[1] == 0x994151D8EDEE87E8); + REQUIRE(c[2] == 0x06774A1D5A74D421); + REQUIRE(c[3] == 0xE3665767ED4F17A4); + + uint64_t e; + copy_and_swap_64_unaligned(&e, d, 1); + REQUIRE(e == 0xEFCDAB8967452301); + + char f[85] = {0x00}; + char g[] = + "This is a 85 byte long string... " + "It's supposed to be longer than standard alignment."; + copy_and_swap_64_unaligned(f, g, 10); + REQUIRE(std::strcmp(f, + " si sihTtyb 58 as gnol e...gnirtus s'tI t desoppnol eb " + "onaht regradnats mngila d") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_unaligned(f, g + 1, 10); + REQUIRE(std::strcmp(f, + "a si sihetyb 58 ts gnol ...gnirpus s'tIot desopgnol " + "eb naht redradnatsemngila ") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_unaligned(f, g + 2, 10); + REQUIRE(std::strcmp(f, + " a si si etyb 58rts gnolI ...gnippus s't ot desoegnol " + "ebs naht r dradnatnemngila") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_unaligned(f, g + 3, 10); + REQUIRE(std::strcmp(f, + "8 a si sl etyb 5irts gnotI ...gnoppus s'b ot desregnol " + "ets naht a dradnatnemngil") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_unaligned(f, g + 4, 10); + REQUIRE(std::strcmp(f, + "58 a si ol etyb nirts gn'tI ...gsoppus seb ot de " + "regnol ats nahtla dradn.tnemngi") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_unaligned(f, g + 5, 9); + REQUIRE(std::strcmp(f, + " 58 a sinol etybgnirts gs'tI ...esoppus eb ot dt " + "regnolnats nahila drad") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_unaligned(f, g + 6, 9); + REQUIRE(std::strcmp(f, + "b 58 a sgnol ety.gnirts s'tI ..desoppusl eb ot ht " + "regnodnats nagila dra") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_unaligned(f, g + 7, 9); + REQUIRE(std::strcmp(f, + "yb 58 a gnol et..gnirtss s'tI . desoppuol eb otaht " + "regnadnats nngila dr") == 0); + + std::memset(f, 0, sizeof(f)); + copy_and_swap_64_unaligned(f, g + 8, 9); + REQUIRE(std::strcmp(f, + "tyb 58 as gnol e...gnirtus s'tI t desoppnol eb onaht " + "regradnats mngila d") == 0); +} + +TEST_CASE("copy_and_swap_16_in_32_aligned", "Copy and Swap") { + // TODO(bwrsandman): test once properly understood. + REQUIRE(true == true); +} + +TEST_CASE("copy_and_swap_16_in_32_unaligned", "Copy and Swap") { + // TODO(bwrsandman): test once properly understood. + REQUIRE(true == true); +} + +} // namespace test +} // namespace base +} // namespace xe diff --git a/src/xenia/base/testing/premake5.lua b/src/xenia/base/testing/premake5.lua new file mode 100644 index 000000000..e432d7ec4 --- /dev/null +++ b/src/xenia/base/testing/premake5.lua @@ -0,0 +1,11 @@ +project_root = "../../../.." +include(project_root.."/tools/build") + +test_suite("xenia-base-tests", project_root, ".", { + includedirs = { + project_root.."/third_party/gflags/src", + }, + links = { + "xenia-base", + }, +}) diff --git a/src/xenia/cpu/backend/x64/x64_backend.cc b/src/xenia/cpu/backend/x64/x64_backend.cc index 7739c9519..3390869e5 100644 --- a/src/xenia/cpu/backend/x64/x64_backend.cc +++ b/src/xenia/cpu/backend/x64/x64_backend.cc @@ -13,7 +13,9 @@ #include "third_party/capstone/include/capstone.h" #include "third_party/capstone/include/x86.h" + #include "xenia/base/exception_handler.h" +#include "xenia/base/logging.h" #include "xenia/cpu/backend/x64/x64_assembler.h" #include "xenia/cpu/backend/x64/x64_code_cache.h" #include "xenia/cpu/backend/x64/x64_emitter.h" @@ -65,11 +67,16 @@ bool X64Backend::Initialize(Processor* processor) { return false; } + Xbyak::util::Cpu cpu; + if (!cpu.has(Xbyak::util::Cpu::tAVX)) { + XELOGE("This CPU does not support AVX. The emulator will now crash."); + return false; + } + RegisterSequences(); // Need movbe to do advanced LOAD/STORE tricks. if (FLAGS_enable_haswell_instructions) { - Xbyak::util::Cpu cpu; machine_info_.supports_extended_load_store = cpu.has(Xbyak::util::Cpu::tMOVBE); } else { diff --git a/src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc b/src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc index 28ba3887b..25934f252 100644 --- a/src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc +++ b/src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc @@ -189,7 +189,7 @@ class TestRunner { ~TestRunner() { memory::DeallocFixed(memory_, memory_size_, - memory::DeallocationType::kDecommitRelease); + memory::DeallocationType::kRelease); memory::AlignedFree(context_); } diff --git a/src/xenia/gpu/command_processor.cc b/src/xenia/gpu/command_processor.cc index d957f432c..37f416646 100644 --- a/src/xenia/gpu/command_processor.cc +++ b/src/xenia/gpu/command_processor.cc @@ -236,7 +236,7 @@ void CommandProcessor::ShutdownContext() { context_.reset(); } void CommandProcessor::InitializeRingBuffer(uint32_t ptr, uint32_t log2_size) { read_ptr_index_ = 0; primary_buffer_ptr_ = ptr; - primary_buffer_size_ = uint32_t(std::pow(2u, log2_size)); + primary_buffer_size_ = 1 << log2_size; } void CommandProcessor::EnableReadPointerWriteBack(uint32_t ptr, @@ -695,7 +695,11 @@ bool CommandProcessor::ExecutePacketType3_ME_INIT(RingBuffer* reader, uint32_t packet, uint32_t count) { // initialize CP's micro-engine - reader->AdvanceRead(count * sizeof(uint32_t)); + me_bin_.clear(); + for (uint32_t i = 0; i < count; i++) { + me_bin_.push_back(reader->ReadAndSwap<uint32_t>()); + } + return true; } @@ -1047,8 +1051,8 @@ bool CommandProcessor::ExecutePacketType3_EVENT_WRITE_EXT(RingBuffer* reader, 1, // max z }; assert_true(endianness == Endian::k8in16); - xe::copy_and_swap_16_aligned(memory_->TranslatePhysical(address), extents, - xe::countof(extents)); + xe::copy_and_swap_16_unaligned(memory_->TranslatePhysical(address), extents, + xe::countof(extents)); trace_writer_.WriteMemoryWrite(CpuToGpu(address), sizeof(extents)); return true; } diff --git a/src/xenia/gpu/command_processor.h b/src/xenia/gpu/command_processor.h index a418dd683..7cfedb0f9 100644 --- a/src/xenia/gpu/command_processor.h +++ b/src/xenia/gpu/command_processor.h @@ -215,6 +215,9 @@ class CommandProcessor { std::function<void()> swap_request_handler_; std::queue<std::function<void()>> pending_fns_; + // MicroEngine binary from PM4_ME_INIT + std::vector<uint32_t> me_bin_; + uint32_t counter_ = 0; uint32_t primary_buffer_ptr_ = 0; diff --git a/src/xenia/gpu/gl4/draw_batcher.cc b/src/xenia/gpu/gl4/draw_batcher.cc deleted file mode 100644 index fa2368884..000000000 --- a/src/xenia/gpu/gl4/draw_batcher.cc +++ /dev/null @@ -1,535 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/gpu/gl4/draw_batcher.h" - -#include <cstring> - -#include "xenia/base/logging.h" -#include "xenia/base/math.h" -#include "xenia/gpu/gl4/gl4_gpu_flags.h" -#include "xenia/gpu/gpu_flags.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -using namespace xe::gpu::xenos; - -const size_t kCommandBufferCapacity = 16 * (1024 * 1024); -const size_t kCommandBufferAlignment = 4; -const size_t kStateBufferCapacity = 64 * (1024 * 1024); -const size_t kStateBufferAlignment = 256; - -DrawBatcher::DrawBatcher(RegisterFile* register_file) - : register_file_(register_file), - command_buffer_(kCommandBufferCapacity, kCommandBufferAlignment), - state_buffer_(kStateBufferCapacity, kStateBufferAlignment), - array_data_buffer_(nullptr), - draw_open_(false) { - std::memset(&batch_state_, 0, sizeof(batch_state_)); - batch_state_.needs_reconfigure = true; - batch_state_.command_range_start = batch_state_.state_range_start = - UINTPTR_MAX; - std::memset(&active_draw_, 0, sizeof(active_draw_)); -} - -bool DrawBatcher::Initialize(CircularBuffer* array_data_buffer) { - array_data_buffer_ = array_data_buffer; - if (!command_buffer_.Initialize()) { - return false; - } - if (!state_buffer_.Initialize()) { - return false; - } - if (!InitializeTFB()) { - return false; - } - - glBindBuffer(GL_DRAW_INDIRECT_BUFFER, command_buffer_.handle()); - return true; -} - -// Initializes a transform feedback object -// We use this to capture vertex data straight from the vertex/geometry shader. -bool DrawBatcher::InitializeTFB() { - glCreateBuffers(1, &tfvbo_); - if (!tfvbo_) { - return false; - } - - glCreateTransformFeedbacks(1, &tfbo_); - if (!tfbo_) { - return false; - } - - glCreateQueries(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 1, &tfqo_); - if (!tfqo_) { - return false; - } - - // TODO(DrChat): Calculate this based on the number of primitives drawn. - glNamedBufferData(tfvbo_, 16384 * 4, nullptr, GL_STATIC_READ); - - return true; -} - -void DrawBatcher::ShutdownTFB() { - glDeleteBuffers(1, &tfvbo_); - glDeleteTransformFeedbacks(1, &tfbo_); - glDeleteQueries(1, &tfqo_); - - tfvbo_ = 0; - tfbo_ = 0; - tfqo_ = 0; -} - -size_t DrawBatcher::QueryTFBSize() { - if (!tfb_enabled_) { - return 0; - } - - size_t size = 0; - switch (tfb_prim_type_gl_) { - case GL_POINTS: - size = tfb_prim_count_ * 1 * 4 * 4; - break; - case GL_LINES: - size = tfb_prim_count_ * 2 * 4 * 4; - break; - case GL_TRIANGLES: - size = tfb_prim_count_ * 3 * 4 * 4; - break; - } - - return size; -} - -bool DrawBatcher::ReadbackTFB(void* buffer, size_t size) { - if (!tfb_enabled_) { - XELOGW("DrawBatcher::ReadbackTFB called when TFB was disabled!"); - return false; - } - - void* data = glMapNamedBufferRange(tfvbo_, 0, size, GL_MAP_READ_BIT); - std::memcpy(buffer, data, size); - glUnmapNamedBuffer(tfvbo_); - - return true; -} - -void DrawBatcher::Shutdown() { - command_buffer_.Shutdown(); - state_buffer_.Shutdown(); - ShutdownTFB(); -} - -bool DrawBatcher::ReconfigurePipeline(GL4Shader* vertex_shader, - GL4Shader* pixel_shader, - GLuint pipeline) { - if (batch_state_.pipeline == pipeline) { - // No-op. - return true; - } - if (!Flush(FlushMode::kReconfigure)) { - return false; - } - - batch_state_.vertex_shader = vertex_shader; - batch_state_.pixel_shader = pixel_shader; - batch_state_.pipeline = pipeline; - - return true; -} - -bool DrawBatcher::BeginDrawArrays(PrimitiveType prim_type, - uint32_t index_count) { - assert_false(draw_open_); - if (batch_state_.prim_type != prim_type || batch_state_.indexed) { - if (!Flush(FlushMode::kReconfigure)) { - return false; - } - } - batch_state_.prim_type = prim_type; - batch_state_.indexed = false; - - if (!BeginDraw()) { - return false; - } - - auto cmd = active_draw_.draw_arrays_cmd; - cmd->base_instance = 0; - cmd->instance_count = 1; - cmd->count = index_count; - cmd->first_index = 0; - - return true; -} - -bool DrawBatcher::BeginDrawElements(PrimitiveType prim_type, - uint32_t index_count, - IndexFormat index_format) { - assert_false(draw_open_); - GLenum index_type = - index_format == IndexFormat::kInt32 ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT; - if (batch_state_.prim_type != prim_type || !batch_state_.indexed || - batch_state_.index_type != index_type) { - if (!Flush(FlushMode::kReconfigure)) { - return false; - } - } - batch_state_.prim_type = prim_type; - batch_state_.indexed = true; - batch_state_.index_type = index_type; - - if (!BeginDraw()) { - return false; - } - - uint32_t start_index = register_file_->values[XE_GPU_REG_VGT_INDX_OFFSET].u32; - assert_zero(start_index); - - auto cmd = active_draw_.draw_elements_cmd; - cmd->base_instance = 0; - cmd->instance_count = 1; - cmd->count = index_count; - cmd->first_index = start_index; - cmd->base_vertex = 0; - - return true; -} - -bool DrawBatcher::BeginDraw() { - draw_open_ = true; - - if (batch_state_.needs_reconfigure) { - batch_state_.needs_reconfigure = false; - // Have been reconfigured since last draw - need to compute state size. - // Layout: - // [draw command] - // [common header] - // [consts] - - // Padded to max. - GLsizei command_size = 0; - if (batch_state_.indexed) { - command_size = sizeof(DrawElementsIndirectCommand); - } else { - command_size = sizeof(DrawArraysIndirectCommand); - } - batch_state_.command_stride = - xe::round_up(command_size, GLsizei(kCommandBufferAlignment)); - - GLsizei header_size = sizeof(CommonHeader); - - // TODO(benvanik): consts sizing. - // GLsizei float_consts_size = sizeof(float4) * 512; - // GLsizei bool_consts_size = sizeof(uint32_t) * 8; - // GLsizei loop_consts_size = sizeof(uint32_t) * 32; - // GLsizei consts_size = - // float_consts_size + bool_consts_size + loop_consts_size; - // batch_state_.float_consts_offset = batch_state_.header_offset + - // header_size; - // batch_state_.bool_consts_offset = - // batch_state_.float_consts_offset + float_consts_size; - // batch_state_.loop_consts_offset = - // batch_state_.bool_consts_offset + bool_consts_size; - GLsizei consts_size = 0; - - batch_state_.state_stride = header_size + consts_size; - } - - // Allocate a command data block. - // We should treat it as write-only. - if (!command_buffer_.CanAcquire(batch_state_.command_stride)) { - Flush(FlushMode::kMakeCoherent); - } - active_draw_.command_allocation = - command_buffer_.Acquire(batch_state_.command_stride); - assert_not_null(active_draw_.command_allocation.host_ptr); - - // Allocate a state data block. - // We should treat it as write-only. - if (!state_buffer_.CanAcquire(batch_state_.state_stride)) { - Flush(FlushMode::kMakeCoherent); - } - active_draw_.state_allocation = - state_buffer_.Acquire(batch_state_.state_stride); - assert_not_null(active_draw_.state_allocation.host_ptr); - - active_draw_.command_address = - reinterpret_cast<uintptr_t>(active_draw_.command_allocation.host_ptr); - auto state_host_ptr = - reinterpret_cast<uintptr_t>(active_draw_.state_allocation.host_ptr); - active_draw_.header = reinterpret_cast<CommonHeader*>(state_host_ptr); - active_draw_.header->ps_param_gen = -1; - // active_draw_.float_consts = - // reinterpret_cast<float4*>(state_host_ptr + - // batch_state_.float_consts_offset); - // active_draw_.bool_consts = - // reinterpret_cast<uint32_t*>(state_host_ptr + - // batch_state_.bool_consts_offset); - // active_draw_.loop_consts = - // reinterpret_cast<uint32_t*>(state_host_ptr + - // batch_state_.loop_consts_offset); - return true; -} - -void DrawBatcher::DiscardDraw() { - if (!draw_open_) { - // No-op. - return; - } - draw_open_ = false; - - command_buffer_.Discard(std::move(active_draw_.command_allocation)); - state_buffer_.Discard(std::move(active_draw_.state_allocation)); -} - -bool DrawBatcher::CommitDraw() { - assert_true(draw_open_); - draw_open_ = false; - - // Copy over required constants. - CopyConstants(); - - if (batch_state_.state_range_start == UINTPTR_MAX) { - batch_state_.command_range_start = active_draw_.command_allocation.offset; - batch_state_.state_range_start = active_draw_.state_allocation.offset; - } - batch_state_.command_range_length += - active_draw_.command_allocation.aligned_length; - batch_state_.state_range_length += - active_draw_.state_allocation.aligned_length; - - command_buffer_.Commit(std::move(active_draw_.command_allocation)); - state_buffer_.Commit(std::move(active_draw_.state_allocation)); - - ++batch_state_.draw_count; - return true; -} - -void DrawBatcher::TFBBegin(PrimitiveType prim_type) { - if (!tfb_enabled_) { - return; - } - - // Translate the primitive typename to something compatible with TFB. - GLenum gl_prim_type = 0; - switch (prim_type) { - case PrimitiveType::kLineList: - gl_prim_type = GL_LINES; - break; - case PrimitiveType::kLineStrip: - gl_prim_type = GL_LINES; - break; - case PrimitiveType::kLineLoop: - gl_prim_type = GL_LINES; - break; - case PrimitiveType::kPointList: - // The geometry shader associated with this writes out triangles. - gl_prim_type = GL_TRIANGLES; - break; - case PrimitiveType::kTriangleList: - gl_prim_type = GL_TRIANGLES; - break; - case PrimitiveType::kTriangleStrip: - gl_prim_type = GL_TRIANGLES; - break; - case PrimitiveType::kRectangleList: - gl_prim_type = GL_TRIANGLES; - break; - case PrimitiveType::kTriangleFan: - gl_prim_type = GL_TRIANGLES; - break; - case PrimitiveType::kQuadList: - // FIXME: In some cases the geometry shader will output lines. - // See: GL4CommandProcessor::UpdateShaders - gl_prim_type = GL_TRIANGLES; - break; - default: - assert_unhandled_case(prim_type); - break; - } - - // TODO(DrChat): Resize the TFVBO here. - // Could draw a 2nd time with the rasterizer disabled once we have a primitive - // count. - - tfb_prim_type_ = prim_type; - tfb_prim_type_gl_ = gl_prim_type; - - glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfbo_); - - // Bind the buffer to the TFB object. - glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfvbo_); - - // Begin a query for # prims written - glBeginQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 0, tfqo_); - - // Begin capturing. - glBeginTransformFeedback(gl_prim_type); -} - -void DrawBatcher::TFBEnd() { - if (!tfb_enabled_) { - return; - } - - glEndTransformFeedback(); - glEndQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 0); - glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0); - glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); - - // Cache the query size as query objects aren't shared. - GLint prim_count = 0; - glGetQueryObjectiv(tfqo_, GL_QUERY_RESULT, &prim_count); - tfb_prim_count_ = prim_count; -} - -bool DrawBatcher::Flush(FlushMode mode) { - GLboolean cull_enabled = 0; - if (batch_state_.draw_count) { -#if FINE_GRAINED_DRAW_SCOPES - SCOPE_profile_cpu_f("gpu"); -#endif // FINE_GRAINED_DRAW_SCOPES - - assert_not_zero(batch_state_.command_stride); - assert_not_zero(batch_state_.state_stride); - - // Flush pending buffer changes. - command_buffer_.Flush(); - state_buffer_.Flush(); - array_data_buffer_->Flush(); - - // State data is indexed by draw ID. - glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 0, state_buffer_.handle(), - batch_state_.state_range_start, - batch_state_.state_range_length); - - GLenum prim_type = 0; - bool valid_prim = true; - switch (batch_state_.prim_type) { - case PrimitiveType::kPointList: - prim_type = GL_POINTS; - break; - case PrimitiveType::kLineList: - prim_type = GL_LINES; - break; - case PrimitiveType::kLineStrip: - prim_type = GL_LINE_STRIP; - break; - case PrimitiveType::kLineLoop: - prim_type = GL_LINE_LOOP; - break; - case PrimitiveType::kTriangleList: - prim_type = GL_TRIANGLES; - break; - case PrimitiveType::kTriangleStrip: - prim_type = GL_TRIANGLE_STRIP; - break; - case PrimitiveType::kTriangleFan: - prim_type = GL_TRIANGLE_FAN; - break; - case PrimitiveType::kRectangleList: - prim_type = GL_TRIANGLES; - // Rect lists aren't culled. There may be other things they skip too. - // assert_true( - // (register_file_->values[XE_GPU_REG_PA_SU_SC_MODE_CNTL].u32 - // & 0x3) == 0); - break; - case PrimitiveType::kQuadList: - prim_type = GL_LINES_ADJACENCY; - break; - default: - case PrimitiveType::kTriangleWithWFlags: - prim_type = GL_TRIANGLES; - valid_prim = false; - XELOGE("unsupported primitive type %d", batch_state_.prim_type); - assert_unhandled_case(batch_state_.prim_type); - break; - } - - // Fast path for single draws. - void* indirect_offset = - reinterpret_cast<void*>(batch_state_.command_range_start); - - if (tfb_enabled_) { - TFBBegin(batch_state_.prim_type); - } - - if (valid_prim && batch_state_.draw_count == 1) { - // Fast path for one draw. Removes MDI overhead when not required. - if (batch_state_.indexed) { - auto& cmd = active_draw_.draw_elements_cmd; - glDrawElementsInstancedBaseVertexBaseInstance( - prim_type, cmd->count, batch_state_.index_type, - reinterpret_cast<void*>( - uintptr_t(cmd->first_index) * - (batch_state_.index_type == GL_UNSIGNED_SHORT ? 2 : 4)), - cmd->instance_count, cmd->base_vertex, cmd->base_instance); - } else { - auto& cmd = active_draw_.draw_arrays_cmd; - glDrawArraysInstancedBaseInstance(prim_type, cmd->first_index, - cmd->count, cmd->instance_count, - cmd->base_instance); - } - } else if (valid_prim) { - // Full multi-draw. - if (batch_state_.indexed) { - glMultiDrawElementsIndirect(prim_type, batch_state_.index_type, - indirect_offset, batch_state_.draw_count, - batch_state_.command_stride); - } else { - glMultiDrawArraysIndirect(prim_type, indirect_offset, - batch_state_.draw_count, - batch_state_.command_stride); - } - } - - if (tfb_enabled_) { - TFBEnd(); - } - - batch_state_.command_range_start = UINTPTR_MAX; - batch_state_.command_range_length = 0; - batch_state_.state_range_start = UINTPTR_MAX; - batch_state_.state_range_length = 0; - batch_state_.draw_count = 0; - } - - if (mode == FlushMode::kReconfigure) { - // Reset - we'll update it as soon as we have all the information. - batch_state_.needs_reconfigure = true; - } - - return true; -} - -void DrawBatcher::CopyConstants() { - // TODO(benvanik): partial updates, etc. We could use shader constant access - // knowledge that we get at compile time to only upload those constants - // required. If we did this as a variable length then we could really cut - // down on state block sizes. - - std::memcpy(active_draw_.header->float_consts, - ®ister_file_->values[XE_GPU_REG_SHADER_CONSTANT_000_X].f32, - sizeof(active_draw_.header->float_consts)); - std::memcpy( - active_draw_.header->bool_consts, - ®ister_file_->values[XE_GPU_REG_SHADER_CONSTANT_BOOL_000_031].f32, - sizeof(active_draw_.header->bool_consts)); - std::memcpy(active_draw_.header->loop_consts, - ®ister_file_->values[XE_GPU_REG_SHADER_CONSTANT_LOOP_00].f32, - sizeof(active_draw_.header->loop_consts)); -} - -} // namespace gl4 -} // namespace gpu -} // namespace xe diff --git a/src/xenia/gpu/gl4/draw_batcher.h b/src/xenia/gpu/gl4/draw_batcher.h deleted file mode 100644 index fdecfb9da..000000000 --- a/src/xenia/gpu/gl4/draw_batcher.h +++ /dev/null @@ -1,191 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_GPU_GL4_DRAW_BATCHER_H_ -#define XENIA_GPU_GL4_DRAW_BATCHER_H_ - -#include "xenia/gpu/gl4/gl4_shader.h" -#include "xenia/gpu/register_file.h" -#include "xenia/gpu/xenos.h" -#include "xenia/ui/gl/circular_buffer.h" -#include "xenia/ui/gl/gl_context.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -using xe::ui::gl::CircularBuffer; - -union float4 { - float v[4]; - struct { - float x, y, z, w; - }; -}; - -#pragma pack(push, 4) -struct DrawArraysIndirectCommand { - GLuint count; - GLuint instance_count; - GLuint first_index; - GLuint base_instance; -}; -struct DrawElementsIndirectCommand { - GLuint count; - GLuint instance_count; - GLuint first_index; - GLint base_vertex; - GLuint base_instance; -}; -#pragma pack(pop) - -class DrawBatcher { - public: - enum class FlushMode { - kMakeCoherent, - kStateChange, - kReconfigure, - }; - - explicit DrawBatcher(RegisterFile* register_file); - - bool Initialize(CircularBuffer* array_data_buffer); - void Shutdown(); - - PrimitiveType prim_type() const { return batch_state_.prim_type; } - - void set_window_scalar(float width_scalar, float height_scalar) { - active_draw_.header->window_scale.x = width_scalar; - active_draw_.header->window_scale.y = height_scalar; - } - void set_vtx_fmt(float xy, float z, float w) { - active_draw_.header->vtx_fmt.x = xy; - active_draw_.header->vtx_fmt.y = xy; - active_draw_.header->vtx_fmt.z = z; - active_draw_.header->vtx_fmt.w = w; - } - void set_alpha_test(bool enabled, uint32_t func, float ref) { - active_draw_.header->alpha_test.x = enabled ? 1.0f : 0.0f; - active_draw_.header->alpha_test.y = static_cast<float>(func); - active_draw_.header->alpha_test.z = ref; - } - void set_ps_param_gen(int register_index) { - active_draw_.header->ps_param_gen = register_index; - } - void set_texture_sampler(int index, GLuint64 handle, uint32_t swizzle) { - active_draw_.header->texture_samplers[index] = handle; - active_draw_.header->texture_swizzles[index] = swizzle; - } - void set_index_buffer(const CircularBuffer::Allocation& allocation) { - // Offset is used in glDrawElements. - auto& cmd = active_draw_.draw_elements_cmd; - size_t index_size = batch_state_.index_type == GL_UNSIGNED_SHORT ? 2 : 4; - cmd->first_index = GLuint(allocation.offset / index_size); - } - - bool ReconfigurePipeline(GL4Shader* vertex_shader, GL4Shader* pixel_shader, - GLuint pipeline); - - bool BeginDrawArrays(PrimitiveType prim_type, uint32_t index_count); - bool BeginDrawElements(PrimitiveType prim_type, uint32_t index_count, - IndexFormat index_format); - void DiscardDraw(); - bool CommitDraw(); - bool Flush(FlushMode mode); - - // TFB - Filled with vertex shader output from the last flush. - size_t QueryTFBSize(); - bool ReadbackTFB(void* buffer, size_t size); - - GLuint tfvbo() { return tfvbo_; } - bool is_tfb_enabled() const { return tfb_enabled_; } - void set_tfb_enabled(bool enabled) { tfb_enabled_ = enabled; } - - private: - bool InitializeTFB(); - void ShutdownTFB(); - - void TFBBegin(PrimitiveType prim_type); - void TFBEnd(); - - bool BeginDraw(); - void CopyConstants(); - - RegisterFile* register_file_; - CircularBuffer command_buffer_; - CircularBuffer state_buffer_; - CircularBuffer* array_data_buffer_; - - GLuint tfbo_ = 0; - GLuint tfvbo_ = 0; - GLuint tfqo_ = 0; - PrimitiveType tfb_prim_type_ = PrimitiveType::kNone; - GLenum tfb_prim_type_gl_ = 0; - GLint tfb_prim_count_ = 0; - bool tfb_enabled_ = false; - - struct BatchState { - bool needs_reconfigure; - PrimitiveType prim_type; - bool indexed; - GLenum index_type; - - GL4Shader* vertex_shader; - GL4Shader* pixel_shader; - GLuint pipeline; - - GLsizei command_stride; - GLsizei state_stride; - GLsizei float_consts_offset; - GLsizei bool_consts_offset; - GLsizei loop_consts_offset; - - uintptr_t command_range_start; - uintptr_t command_range_length; - uintptr_t state_range_start; - uintptr_t state_range_length; - GLsizei draw_count; - } batch_state_; - - // This must match GL4Shader's header. - struct CommonHeader { - float4 window_scale; // sx,sy, ?, ? - float4 vtx_fmt; // - float4 alpha_test; // alpha test enable, func, ref, ? - int ps_param_gen; - int padding[3]; - - // TODO(benvanik): pack tightly - GLuint64 texture_samplers[32]; - GLuint texture_swizzles[32]; - - float4 float_consts[512]; - uint32_t bool_consts[8]; - uint32_t loop_consts[32]; - }; - struct { - CircularBuffer::Allocation command_allocation; - CircularBuffer::Allocation state_allocation; - - union { - DrawArraysIndirectCommand* draw_arrays_cmd; - DrawElementsIndirectCommand* draw_elements_cmd; - uintptr_t command_address; - }; - - CommonHeader* header; - } active_draw_; - bool draw_open_; -}; - -} // namespace gl4 -} // namespace gpu -} // namespace xe - -#endif // XENIA_GPU_GL4_DRAW_BATCHER_H_ diff --git a/src/xenia/gpu/gl4/gl4_command_processor.cc b/src/xenia/gpu/gl4/gl4_command_processor.cc deleted file mode 100644 index 5392c22d2..000000000 --- a/src/xenia/gpu/gl4/gl4_command_processor.cc +++ /dev/null @@ -1,2131 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/gpu/gl4/gl4_command_processor.h" - -#include <algorithm> - -#include "xenia/base/logging.h" -#include "xenia/base/math.h" -#include "xenia/base/profiling.h" -#include "xenia/gpu/gl4/gl4_gpu_flags.h" -#include "xenia/gpu/gl4/gl4_graphics_system.h" -#include "xenia/gpu/gpu_flags.h" -#include "xenia/gpu/sampler_info.h" -#include "xenia/gpu/texture_info.h" -#include "xenia/gpu/xenos.h" - -#include "third_party/xxhash/xxhash.h" - -DEFINE_bool(draw_all_framebuffers, false, - "Copy all render targets to screen on swap"); - -namespace xe { -namespace gpu { -namespace gl4 { - -using namespace xe::gpu::xenos; - -const GLuint kAnyTarget = UINT_MAX; - -// All uncached vertex/index data goes here. If it fills up we need to sync -// with the GPU, so this should be large enough to prevent that in a normal -// frame. -const size_t kScratchBufferCapacity = 256 * 1024 * 1024; -const size_t kScratchBufferAlignment = 256; - -GL4CommandProcessor::CachedPipeline::CachedPipeline() - : vertex_program(0), fragment_program(0), handles({0}) {} - -GL4CommandProcessor::CachedPipeline::~CachedPipeline() { - glDeleteProgramPipelines(1, &handles.default_pipeline); - glDeleteProgramPipelines(1, &handles.point_list_pipeline); - glDeleteProgramPipelines(1, &handles.rect_list_pipeline); - glDeleteProgramPipelines(1, &handles.quad_list_pipeline); - glDeleteProgramPipelines(1, &handles.line_quad_list_pipeline); -} - -GL4CommandProcessor::GL4CommandProcessor(GL4GraphicsSystem* graphics_system, - kernel::KernelState* kernel_state) - : CommandProcessor(graphics_system, kernel_state), - shader_translator_(GlslShaderTranslator::Dialect::kGL45), - draw_batcher_(graphics_system_->register_file()), - scratch_buffer_(kScratchBufferCapacity, kScratchBufferAlignment), - shader_cache_(&shader_translator_) {} - -GL4CommandProcessor::~GL4CommandProcessor() = default; - -void GL4CommandProcessor::ClearCaches() { - texture_cache()->Clear(); - - for (auto& cached_framebuffer : cached_framebuffers_) { - glDeleteFramebuffers(1, &cached_framebuffer.framebuffer); - } - cached_framebuffers_.clear(); - - for (auto& cached_color_render_target : cached_color_render_targets_) { - glDeleteTextures(1, &cached_color_render_target.texture); - } - cached_color_render_targets_.clear(); - - for (auto& cached_depth_render_target : cached_depth_render_targets_) { - glDeleteTextures(1, &cached_depth_render_target.texture); - } - cached_depth_render_targets_.clear(); - - CommandProcessor::ClearCaches(); -} - -bool GL4CommandProcessor::SetupContext() { - if (!CommandProcessor::SetupContext()) { - XELOGE("Unable to initialize base command processor context"); - return false; - } - - // Circular buffer holding scratch vertex/index data. - if (!scratch_buffer_.Initialize()) { - XELOGE("Unable to initialize scratch buffer"); - return false; - } - - // Command buffer. - if (!draw_batcher_.Initialize(&scratch_buffer_)) { - XELOGE("Unable to initialize command buffer"); - return false; - } - - // Texture cache that keeps track of any textures/samplers used. - if (!texture_cache_.Initialize(memory_, &scratch_buffer_)) { - XELOGE("Unable to initialize texture cache"); - return false; - } - - const std::string geometry_header = - "#version 450\n" - "#extension all : warn\n" - "#extension GL_ARB_explicit_uniform_location : require\n" - "#extension GL_ARB_shading_language_420pack : require\n" - "in gl_PerVertex {\n" - " vec4 gl_Position;\n" - " float gl_PointSize;\n" - " float gl_ClipDistance[];\n" - "} gl_in[];\n" - "out gl_PerVertex {\n" - " vec4 gl_Position;\n" - " float gl_PointSize;\n" - " float gl_ClipDistance[];\n" - "};\n" - "struct VertexData {\n" - " vec4 o[16];\n" - "};\n" - "\n" - "layout(location = 1) in VertexData in_vtx[];\n" - "layout(location = 1) out VertexData out_vtx;\n"; - // TODO(benvanik): fetch default point size from register and use that if - // the VS doesn't write oPointSize. - // TODO(benvanik): clamp to min/max. - // TODO(benvanik): figure out how to see which interpolator gets adjusted. - std::string point_list_shader = - geometry_header + - "layout(points) in;\n" - "layout(triangle_strip, max_vertices = 4) out;\n" - "void main() {\n" - " const vec2 offsets[4] = {\n" - " vec2(-1.0, 1.0),\n" - " vec2( 1.0, 1.0),\n" - " vec2(-1.0, -1.0),\n" - " vec2( 1.0, -1.0),\n" - " };\n" - " vec4 pos = gl_in[0].gl_Position;\n" - " float psize = gl_in[0].gl_PointSize;\n" - " for (int i = 0; i < 4; ++i) {\n" - " gl_Position = vec4(pos.xy + offsets[i] * psize, pos.zw);\n" - " out_vtx = in_vtx[0];\n" - " EmitVertex();\n" - " }\n" - " EndPrimitive();\n" - "}\n"; - std::string rect_list_shader = - geometry_header + - "layout(triangles) in;\n" - "layout(triangle_strip, max_vertices = 6) out;\n" - "void main() {\n" - // Most games use the left-aligned form. - " bool left_aligned = gl_in[0].gl_Position.x == \n" - " gl_in[2].gl_Position.x;\n" - " if (left_aligned) {\n" - // 0 ------ 1 - // | - | - // | // | - // | - | - // 2 ----- [3] - " gl_Position = gl_in[0].gl_Position;\n" - " gl_PointSize = gl_in[0].gl_PointSize;\n" - " out_vtx = in_vtx[0];\n" - " EmitVertex();\n" - " gl_Position = gl_in[1].gl_Position;\n" - " gl_PointSize = gl_in[1].gl_PointSize;\n" - " out_vtx = in_vtx[1];\n" - " EmitVertex();\n" - " gl_Position = gl_in[2].gl_Position;\n" - " gl_PointSize = gl_in[2].gl_PointSize;\n" - " out_vtx = in_vtx[2];\n" - " EmitVertex();\n" - " EndPrimitive();\n" - " gl_Position = gl_in[2].gl_Position;\n" - " gl_PointSize = gl_in[2].gl_PointSize;\n" - " out_vtx = in_vtx[2];\n" - " EmitVertex();\n" - " gl_Position = gl_in[1].gl_Position;\n" - " gl_PointSize = gl_in[1].gl_PointSize;\n" - " out_vtx = in_vtx[1];\n" - " EmitVertex();\n" - " gl_Position = \n" - " (gl_in[1].gl_Position + gl_in[2].gl_Position) - \n" - " gl_in[0].gl_Position;\n" - " gl_PointSize = gl_in[2].gl_PointSize;\n" - " for (int i = 0; i < 16; ++i) {\n" - " out_vtx.o[i] = -in_vtx[0].o[i] + in_vtx[1].o[i] + \n" - " in_vtx[2].o[i];\n" - " }\n" - " EmitVertex();\n" - " EndPrimitive();\n" - " } else {\n" - // 0 ------ 1 - // | - | - // | \\ | - // | - | - // [3] ----- 2 - " gl_Position = gl_in[0].gl_Position;\n" - " gl_PointSize = gl_in[0].gl_PointSize;\n" - " out_vtx = in_vtx[0];\n" - " EmitVertex();\n" - " gl_Position = gl_in[1].gl_Position;\n" - " gl_PointSize = gl_in[1].gl_PointSize;\n" - " out_vtx = in_vtx[1];\n" - " EmitVertex();\n" - " gl_Position = gl_in[2].gl_Position;\n" - " gl_PointSize = gl_in[2].gl_PointSize;\n" - " out_vtx = in_vtx[2];\n" - " EmitVertex();\n" - " EndPrimitive();\n" - " gl_Position = gl_in[0].gl_Position;\n" - " gl_PointSize = gl_in[0].gl_PointSize;\n" - " out_vtx = in_vtx[0];\n" - " EmitVertex();\n" - " gl_Position = gl_in[2].gl_Position;\n" - " gl_PointSize = gl_in[2].gl_PointSize;\n" - " out_vtx = in_vtx[2];\n" - " EmitVertex();\n" - " gl_Position = (gl_in[0].gl_Position + gl_in[2].gl_Position) - \n" - " gl_in[1].gl_Position;\n" - " gl_PointSize = gl_in[2].gl_PointSize;\n" - " for (int i = 0; i < 16; ++i) {\n" - " out_vtx.o[i] = in_vtx[0].o[i] + -in_vtx[1].o[i] + \n" - " in_vtx[2].o[i];\n" - " }\n" - " EmitVertex();\n" - " EndPrimitive();\n" - " }\n" - "}\n"; - std::string quad_list_shader = - geometry_header + - "layout(lines_adjacency) in;\n" - "layout(triangle_strip, max_vertices = 4) out;\n" - "void main() {\n" - " const int order[4] = { 0, 1, 3, 2 };\n" - " for (int i = 0; i < 4; ++i) {\n" - " int input_index = order[i];\n" - " gl_Position = gl_in[input_index].gl_Position;\n" - " gl_PointSize = gl_in[input_index].gl_PointSize;\n" - " out_vtx = in_vtx[input_index];\n" - " EmitVertex();\n" - " }\n" - " EndPrimitive();\n" - "}\n"; - std::string line_quad_list_shader = - geometry_header + - "layout(lines_adjacency) in;\n" - "layout(line_strip, max_vertices = 5) out;\n" - "void main() {\n" - " gl_Position = gl_in[0].gl_Position;\n" - " gl_PointSize = gl_in[0].gl_PointSize;\n" - " out_vtx = in_vtx[0];\n" - " EmitVertex();\n" - " gl_Position = gl_in[1].gl_Position;\n" - " gl_PointSize = gl_in[1].gl_PointSize;\n" - " out_vtx = in_vtx[1];\n" - " EmitVertex();\n" - " gl_Position = gl_in[2].gl_Position;\n" - " gl_PointSize = gl_in[2].gl_PointSize;\n" - " out_vtx = in_vtx[2];\n" - " EmitVertex();\n" - " gl_Position = gl_in[3].gl_Position;\n" - " gl_PointSize = gl_in[3].gl_PointSize;\n" - " out_vtx = in_vtx[3];\n" - " EmitVertex();\n" - " gl_Position = gl_in[0].gl_Position;\n" - " gl_PointSize = gl_in[0].gl_PointSize;\n" - " out_vtx = in_vtx[0];\n" - " EmitVertex();\n" - " EndPrimitive();\n" - "}\n"; - point_list_geometry_program_ = CreateGeometryProgram(point_list_shader); - rect_list_geometry_program_ = CreateGeometryProgram(rect_list_shader); - quad_list_geometry_program_ = CreateGeometryProgram(quad_list_shader); - line_quad_list_geometry_program_ = - CreateGeometryProgram(line_quad_list_shader); - if (!point_list_geometry_program_ || !rect_list_geometry_program_ || - !quad_list_geometry_program_ || !line_quad_list_geometry_program_) { - return false; - } - - glEnable(GL_SCISSOR_TEST); - glClipControl(GL_UPPER_LEFT, GL_ZERO_TO_ONE); - glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_UPPER_LEFT); - - return true; -} - -GLuint GL4CommandProcessor::CreateGeometryProgram(const std::string& source) { - auto source_str = source.c_str(); - GLuint program = glCreateShaderProgramv(GL_GEOMETRY_SHADER, 1, &source_str); - - // Get error log, if we failed to link. - GLint link_status = 0; - glGetProgramiv(program, GL_LINK_STATUS, &link_status); - if (!link_status) { - GLint log_length = 0; - glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length); - std::string info_log; - info_log.resize(log_length - 1); - glGetProgramInfoLog(program, log_length, &log_length, - const_cast<char*>(info_log.data())); - XELOGE("Unable to link program: %s", info_log.c_str()); - glDeleteProgram(program); - return 0; - } - - return program; -} - -void GL4CommandProcessor::ShutdownContext() { - glDeleteProgram(point_list_geometry_program_); - glDeleteProgram(rect_list_geometry_program_); - glDeleteProgram(quad_list_geometry_program_); - glDeleteProgram(line_quad_list_geometry_program_); - texture_cache_.Shutdown(); - draw_batcher_.Shutdown(); - scratch_buffer_.Shutdown(); - - all_pipelines_.clear(); - shader_cache_.Reset(); - - CommandProcessor::ShutdownContext(); -} - -void GL4CommandProcessor::MakeCoherent() { - RegisterFile* regs = register_file_; - auto status_host = regs->values[XE_GPU_REG_COHER_STATUS_HOST].u32; - - CommandProcessor::MakeCoherent(); - - if (status_host & 0x80000000ul) { - scratch_buffer_.ClearCache(); - } -} - -void GL4CommandProcessor::PrepareForWait() { - SCOPE_profile_cpu_f("gpu"); - - CommandProcessor::PrepareForWait(); - - // TODO(benvanik): fences and fancy stuff. We should figure out a way to - // make interrupt callbacks from the GPU so that we don't have to do a full - // synchronize here. - glFlush(); - // glFinish(); - - if (FLAGS_thread_safe_gl) { - context_->ClearCurrent(); - } -} - -void GL4CommandProcessor::ReturnFromWait() { - if (FLAGS_thread_safe_gl) { - context_->MakeCurrent(); - } - - CommandProcessor::ReturnFromWait(); -} - -void GL4CommandProcessor::PerformSwap(uint32_t frontbuffer_ptr, - uint32_t frontbuffer_width, - uint32_t frontbuffer_height) { - // Ensure we issue any pending draws. - draw_batcher_.Flush(DrawBatcher::FlushMode::kMakeCoherent); - - // One-time initialization. - // TODO(benvanik): move someplace more sane? - if (!swap_state_.front_buffer_texture) { - std::lock_guard<std::mutex> lock(swap_state_.mutex); - swap_state_.width = frontbuffer_width; - swap_state_.height = frontbuffer_height; - GLuint front_buffer_texture; - GLuint back_buffer_texture; - glCreateTextures(GL_TEXTURE_2D, 1, &front_buffer_texture); - glCreateTextures(GL_TEXTURE_2D, 1, &back_buffer_texture); - swap_state_.front_buffer_texture = front_buffer_texture; - swap_state_.back_buffer_texture = back_buffer_texture; - glTextureStorage2D(front_buffer_texture, 1, GL_RGBA8, swap_state_.width, - swap_state_.height); - glTextureStorage2D(back_buffer_texture, 1, GL_RGBA8, swap_state_.width, - swap_state_.height); - } - - // Lookup the framebuffer in the recently-resolved list. - // TODO(benvanik): make this much more sophisticated. - // TODO(benvanik): handle not found cases. - // TODO(benvanik): handle dirty cases (resolved to sysmem, touched). - // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - // HACK: just use whatever our current framebuffer is. - GLuint framebuffer_texture = last_framebuffer_texture_; - - if (last_framebuffer_texture_ == 0) { - framebuffer_texture = - active_framebuffer_ ? active_framebuffer_->color_targets[0] : 0; - } - - // Copy the the given framebuffer to the current backbuffer. - Rect2D src_rect(0, 0, frontbuffer_width ? frontbuffer_width : 1280, - frontbuffer_height ? frontbuffer_height : 720); - Rect2D dest_rect(0, 0, swap_state_.width, swap_state_.height); - if (framebuffer_texture != 0) { - reinterpret_cast<xe::ui::gl::GLContext*>(context_.get()) - ->blitter() - ->CopyColorTexture2D( - framebuffer_texture, src_rect, - static_cast<GLuint>(swap_state_.back_buffer_texture), dest_rect, - GL_LINEAR, true); - } - - if (FLAGS_draw_all_framebuffers) { - int32_t offsetx = (1280 - (1280 / 5)); - int32_t offsety = 0; - int32_t doffsetx = 0; - for (int i = 0; i < cached_framebuffers_.size(); i++) { - bool has_colortargets = false; - - // Copy color targets to top right corner - for (int j = 0; j < 4; j++) { - GLuint tex = cached_framebuffers_[i].color_targets[j]; - if (!tex) { - continue; - } - has_colortargets = true; - - dest_rect = {offsetx, offsety, 1280 / 5, 720 / 5}; - reinterpret_cast<ui::gl::GLContext*>(context_.get()) - ->blitter() - ->CopyColorTexture2D( - tex, src_rect, - static_cast<GLuint>(swap_state_.back_buffer_texture), dest_rect, - GL_LINEAR, true); - - offsety += 720 / 5; - } - - if (has_colortargets) { - offsetx -= 1280 / 5; - } - - offsety = 0; - - GLuint tex = cached_framebuffers_[i].depth_target; - if (!tex) { - continue; - } - - // Copy depth targets to bottom left corner of screen - dest_rect = {doffsetx, (int32_t)swap_state_.height - (720 / 5), 1280 / 5, - 720 / 5}; - reinterpret_cast<ui::gl::GLContext*>(context_.get()) - ->blitter() - ->CopyColorTexture2D( - tex, src_rect, - static_cast<GLuint>(swap_state_.back_buffer_texture), dest_rect, - GL_LINEAR, false); - - doffsetx += 1280 / 5; - } - } - - // Need to finish to be sure the other context sees the right data. - // TODO(benvanik): prevent this? fences? - glFinish(); - - if (context_->WasLost()) { - // We've lost the context due to a TDR. - // TODO: Dump the current commands to a tracefile. - assert_always(); - } - - // Remove any dead textures, etc. - texture_cache_.Scavenge(); -} - -Shader* GL4CommandProcessor::LoadShader(ShaderType shader_type, - uint32_t guest_address, - const uint32_t* host_address, - uint32_t dword_count) { - return shader_cache_.LookupOrInsertShader(shader_type, host_address, - dword_count); -} - -bool GL4CommandProcessor::IssueDraw(PrimitiveType prim_type, - uint32_t index_count, - IndexBufferInfo* index_buffer_info) { -#if FINE_GRAINED_DRAW_SCOPES - SCOPE_profile_cpu_f("gpu"); -#endif // FINE_GRAINED_DRAW_SCOPES - - bool draw_valid; - if (index_buffer_info) { - draw_valid = draw_batcher_.BeginDrawElements(prim_type, index_count, - index_buffer_info->format); - } else { - draw_valid = draw_batcher_.BeginDrawArrays(prim_type, index_count); - } - if (!draw_valid) { - return false; - } - - auto& regs = *register_file_; - - auto enable_mode = - static_cast<ModeControl>(regs[XE_GPU_REG_RB_MODECONTROL].u32 & 0x7); - if (enable_mode == ModeControl::kIgnore) { - // Ignored. - draw_batcher_.DiscardDraw(); - return true; - } else if (enable_mode == ModeControl::kCopy) { - // Special copy handling. - draw_batcher_.DiscardDraw(); - return IssueCopy(); - } - -#define CHECK_ISSUE_UPDATE_STATUS(status, mismatch, error_message) \ - { \ - if (status == UpdateStatus::kError) { \ - XELOGE(error_message); \ - draw_batcher_.DiscardDraw(); \ - return false; \ - } else if (status == UpdateStatus::kMismatch) { \ - mismatch = true; \ - } \ - } - - UpdateStatus status; - bool mismatch = false; - status = UpdateShaders(draw_batcher_.prim_type()); - CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to prepare draw shaders"); - status = UpdateRenderTargets(); - CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to setup render targets"); - if (!active_framebuffer_) { - // No framebuffer, so nothing we do will actually have an effect. - // Treat it as a no-op. - // TODO(benvanik): if we have a vs export, still allow it to go. - draw_batcher_.DiscardDraw(); - return true; - } - - status = UpdateState(draw_batcher_.prim_type()); - CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to setup render state"); - status = PopulateSamplers(); - CHECK_ISSUE_UPDATE_STATUS(status, mismatch, - "Unable to prepare draw samplers"); - - status = PopulateIndexBuffer(index_buffer_info); - CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to setup index buffer"); - status = PopulateVertexBuffers(); - CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to setup vertex buffers"); - - if (!draw_batcher_.CommitDraw()) { - return false; - } - - // TODO(benvanik): find a way to get around glVertexArrayVertexBuffer below. - draw_batcher_.Flush(DrawBatcher::FlushMode::kMakeCoherent); - if (context_->WasLost()) { - // This draw lost us the context. This typically isn't hit. - assert_always(); - return false; - } - - return true; -} - -bool GL4CommandProcessor::SetShadowRegister(uint32_t* dest, - uint32_t register_name) { - uint32_t value = register_file_->values[register_name].u32; - if (*dest == value) { - return false; - } - *dest = value; - return true; -} - -bool GL4CommandProcessor::SetShadowRegister(float* dest, - uint32_t register_name) { - float value = register_file_->values[register_name].f32; - if (*dest == value) { - return false; - } - *dest = value; - return true; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateShaders( - PrimitiveType prim_type) { - auto& regs = update_shaders_regs_; - - // These are the constant base addresses/ranges for shaders. - // We have these hardcoded right now cause nothing seems to differ. - assert_true(register_file_->values[XE_GPU_REG_SQ_VS_CONST].u32 == - 0x000FF000 || - register_file_->values[XE_GPU_REG_SQ_VS_CONST].u32 == 0x00000000); - assert_true(register_file_->values[XE_GPU_REG_SQ_PS_CONST].u32 == - 0x000FF100 || - register_file_->values[XE_GPU_REG_SQ_PS_CONST].u32 == 0x00000000); - - bool dirty = false; - dirty |= SetShadowRegister(®s.pa_su_sc_mode_cntl, - XE_GPU_REG_PA_SU_SC_MODE_CNTL); - dirty |= SetShadowRegister(®s.sq_program_cntl, XE_GPU_REG_SQ_PROGRAM_CNTL); - dirty |= SetShadowRegister(®s.sq_context_misc, XE_GPU_REG_SQ_CONTEXT_MISC); - dirty |= regs.vertex_shader != active_vertex_shader_; - dirty |= regs.pixel_shader != active_pixel_shader_; - dirty |= regs.prim_type != prim_type; - if (!dirty) { - return UpdateStatus::kCompatible; - } - regs.vertex_shader = static_cast<GL4Shader*>(active_vertex_shader_); - regs.pixel_shader = static_cast<GL4Shader*>(active_pixel_shader_); - regs.prim_type = prim_type; - - SCOPE_profile_cpu_f("gpu"); - - draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange); - - xe_gpu_program_cntl_t program_cntl; - program_cntl.dword_0 = regs.sq_program_cntl; - - // Populate a register in the pixel shader with frag coord. - int ps_param_gen = (regs.sq_context_misc >> 8) & 0xFF; - draw_batcher_.set_ps_param_gen(program_cntl.param_gen ? ps_param_gen : -1); - - // Normal vertex shaders only, for now. - // TODO(benvanik): transform feedback/memexport. - // https://github.com/freedreno/freedreno/blob/master/includes/a2xx.xml.h - // 0 = normal - // 2 = point size - assert_true(program_cntl.vs_export_mode == 0 || - program_cntl.vs_export_mode == 2); - - if (!regs.vertex_shader->is_valid()) { - XELOGE("Vertex shader invalid"); - return UpdateStatus::kError; - } - if (!regs.pixel_shader->is_valid()) { - XELOGE("Pixel shader invalid"); - return UpdateStatus::kError; - } - - GLuint vertex_program = regs.vertex_shader->program(); - GLuint fragment_program = regs.pixel_shader->program(); - - uint64_t key = (uint64_t(vertex_program) << 32) | fragment_program; - CachedPipeline* cached_pipeline = nullptr; - auto it = cached_pipelines_.find(key); - if (it == cached_pipelines_.end()) { - // Existing pipeline for these programs not found - create it. - auto new_pipeline = std::make_unique<CachedPipeline>(); - new_pipeline->vertex_program = vertex_program; - new_pipeline->fragment_program = fragment_program; - new_pipeline->handles.default_pipeline = 0; - cached_pipeline = new_pipeline.get(); - all_pipelines_.emplace_back(std::move(new_pipeline)); - cached_pipelines_.insert({key, cached_pipeline}); - } else { - // Found a pipeline container - it may or may not have what we want. - cached_pipeline = it->second; - } - if (!cached_pipeline->handles.default_pipeline) { - // Perhaps it's a bit wasteful to do all of these, but oh well. - GLuint pipelines[5]; - glCreateProgramPipelines(GLsizei(xe::countof(pipelines)), pipelines); - - glUseProgramStages(pipelines[0], GL_VERTEX_SHADER_BIT, vertex_program); - glUseProgramStages(pipelines[0], GL_FRAGMENT_SHADER_BIT, fragment_program); - cached_pipeline->handles.default_pipeline = pipelines[0]; - - glUseProgramStages(pipelines[1], GL_VERTEX_SHADER_BIT, vertex_program); - glUseProgramStages(pipelines[1], GL_GEOMETRY_SHADER_BIT, - point_list_geometry_program_); - glUseProgramStages(pipelines[1], GL_FRAGMENT_SHADER_BIT, fragment_program); - cached_pipeline->handles.point_list_pipeline = pipelines[1]; - - glUseProgramStages(pipelines[2], GL_VERTEX_SHADER_BIT, vertex_program); - glUseProgramStages(pipelines[2], GL_GEOMETRY_SHADER_BIT, - rect_list_geometry_program_); - glUseProgramStages(pipelines[2], GL_FRAGMENT_SHADER_BIT, fragment_program); - cached_pipeline->handles.rect_list_pipeline = pipelines[2]; - - glUseProgramStages(pipelines[3], GL_VERTEX_SHADER_BIT, vertex_program); - glUseProgramStages(pipelines[3], GL_GEOMETRY_SHADER_BIT, - quad_list_geometry_program_); - glUseProgramStages(pipelines[3], GL_FRAGMENT_SHADER_BIT, fragment_program); - cached_pipeline->handles.quad_list_pipeline = pipelines[3]; - - glUseProgramStages(pipelines[4], GL_VERTEX_SHADER_BIT, vertex_program); - glUseProgramStages(pipelines[4], GL_GEOMETRY_SHADER_BIT, - line_quad_list_geometry_program_); - glUseProgramStages(pipelines[4], GL_FRAGMENT_SHADER_BIT, fragment_program); - cached_pipeline->handles.line_quad_list_pipeline = pipelines[4]; - - // This can be set once, as the buffer never changes. - glVertexArrayElementBuffer(regs.vertex_shader->vao(), - scratch_buffer_.handle()); - } - - bool line_mode = false; - if (((regs.pa_su_sc_mode_cntl >> 3) & 0x3) != 0) { - uint32_t front_poly_mode = (regs.pa_su_sc_mode_cntl >> 5) & 0x7; - if (front_poly_mode == 1) { - line_mode = true; - } - } - - GLuint pipeline; - switch (regs.prim_type) { - default: - // Default pipeline used. - pipeline = cached_pipeline->handles.default_pipeline; - break; - case PrimitiveType::kPointList: - pipeline = cached_pipeline->handles.point_list_pipeline; - break; - case PrimitiveType::kRectangleList: - pipeline = cached_pipeline->handles.rect_list_pipeline; - break; - case PrimitiveType::kQuadList: { - if (line_mode) { - pipeline = cached_pipeline->handles.line_quad_list_pipeline; - } else { - pipeline = cached_pipeline->handles.quad_list_pipeline; - } - break; - } - } - - draw_batcher_.ReconfigurePipeline(regs.vertex_shader, regs.pixel_shader, - pipeline); - - glBindProgramPipeline(pipeline); - glBindVertexArray(regs.vertex_shader->vao()); - - return UpdateStatus::kMismatch; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateRenderTargets() { - auto& regs = update_render_targets_regs_; - - bool dirty = false; - dirty |= SetShadowRegister(®s.rb_modecontrol, XE_GPU_REG_RB_MODECONTROL); - dirty |= SetShadowRegister(®s.rb_surface_info, XE_GPU_REG_RB_SURFACE_INFO); - dirty |= SetShadowRegister(®s.rb_color_info, XE_GPU_REG_RB_COLOR_INFO); - dirty |= SetShadowRegister(®s.rb_color1_info, XE_GPU_REG_RB_COLOR1_INFO); - dirty |= SetShadowRegister(®s.rb_color2_info, XE_GPU_REG_RB_COLOR2_INFO); - dirty |= SetShadowRegister(®s.rb_color3_info, XE_GPU_REG_RB_COLOR3_INFO); - dirty |= SetShadowRegister(®s.rb_color_mask, XE_GPU_REG_RB_COLOR_MASK); - dirty |= SetShadowRegister(®s.rb_depthcontrol, XE_GPU_REG_RB_DEPTHCONTROL); - dirty |= - SetShadowRegister(®s.rb_stencilrefmask, XE_GPU_REG_RB_STENCILREFMASK); - dirty |= SetShadowRegister(®s.rb_depth_info, XE_GPU_REG_RB_DEPTH_INFO); - if (!dirty) { - return UpdateStatus::kCompatible; - } - - SCOPE_profile_cpu_f("gpu"); - - draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange); - - auto enable_mode = static_cast<ModeControl>(regs.rb_modecontrol & 0x7); - - // RB_SURFACE_INFO - // http://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html - uint32_t surface_pitch = regs.rb_surface_info & 0x3FFF; - auto surface_msaa = - static_cast<MsaaSamples>((regs.rb_surface_info >> 16) & 0x3); - - // Get/create all color render targets, if we are using them. - // In depth-only mode we don't need them. - // Note that write mask may be more permissive than we want, so we mix that - // with the actual targets the pixel shader writes to. - GLenum draw_buffers[4] = {GL_NONE, GL_NONE, GL_NONE, GL_NONE}; - GLuint color_targets[4] = {kAnyTarget, kAnyTarget, kAnyTarget, kAnyTarget}; - if (enable_mode == ModeControl::kColorDepth) { - uint32_t color_info[4] = { - regs.rb_color_info, - regs.rb_color1_info, - regs.rb_color2_info, - regs.rb_color3_info, - }; - // A2XX_RB_COLOR_MASK_WRITE_* == D3DRS_COLORWRITEENABLE - for (int n = 0; n < xe::countof(color_info); n++) { - uint32_t write_mask = (regs.rb_color_mask >> (n * 4)) & 0xF; - if (!write_mask || !active_pixel_shader_->writes_color_target(n)) { - // Unused, so keep disabled and set to wildcard so we'll take any - // framebuffer that has it. - continue; - } - uint32_t color_base = color_info[n] & 0xFFF; - auto color_format = - static_cast<ColorRenderTargetFormat>((color_info[n] >> 16) & 0xF); - color_targets[n] = GetColorRenderTarget(surface_pitch, surface_msaa, - color_base, color_format); - draw_buffers[n] = GL_COLOR_ATTACHMENT0 + n; - glColorMaski(n, !!(write_mask & 0x1), !!(write_mask & 0x2), - !!(write_mask & 0x4), !!(write_mask & 0x8)); - } - } - - // Get/create depth buffer, but only if we are going to use it. - bool uses_depth = (regs.rb_depthcontrol & 0x00000002) || - (regs.rb_depthcontrol & 0x00000004); - uint32_t stencil_write_mask = (regs.rb_stencilrefmask & 0x00FF0000) >> 16; - bool uses_stencil = - (regs.rb_depthcontrol & 0x00000001) || (stencil_write_mask != 0); - GLuint depth_target = kAnyTarget; - if (uses_depth || uses_stencil) { - uint32_t depth_base = regs.rb_depth_info & 0xFFF; - auto depth_format = - static_cast<DepthRenderTargetFormat>((regs.rb_depth_info >> 16) & 0x1); - depth_target = GetDepthRenderTarget(surface_pitch, surface_msaa, depth_base, - depth_format); - // TODO(benvanik): when a game switches does it expect to keep the same - // depth buffer contents? - } - - // Get/create a framebuffer with the required targets. - // Note that none may be returned if we really don't need one. - auto cached_framebuffer = GetFramebuffer(color_targets, depth_target); - active_framebuffer_ = cached_framebuffer; - if (active_framebuffer_) { - // Setup just the targets we want. - glNamedFramebufferDrawBuffers(cached_framebuffer->framebuffer, 4, - draw_buffers); - - // Make active. - // TODO(benvanik): can we do this all named? - // TODO(benvanik): do we want this on READ too? - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, cached_framebuffer->framebuffer); - } - - return UpdateStatus::kMismatch; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateState( - PrimitiveType prim_type) { - bool mismatch = false; - -#define CHECK_UPDATE_STATUS(status, mismatch, error_message) \ - { \ - if (status == UpdateStatus::kError) { \ - XELOGE(error_message); \ - return status; \ - } else if (status == UpdateStatus::kMismatch) { \ - mismatch = true; \ - } \ - } - - UpdateStatus status; - status = UpdateViewportState(); - CHECK_UPDATE_STATUS(status, mismatch, "Unable to update viewport state"); - status = UpdateRasterizerState(prim_type); - CHECK_UPDATE_STATUS(status, mismatch, "Unable to update rasterizer state"); - status = UpdateBlendState(); - CHECK_UPDATE_STATUS(status, mismatch, "Unable to update blend state"); - status = UpdateDepthStencilState(); - CHECK_UPDATE_STATUS(status, mismatch, "Unable to update depth/stencil state"); - - return mismatch ? UpdateStatus::kMismatch : UpdateStatus::kCompatible; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateViewportState() { - auto& regs = update_viewport_state_regs_; - - bool dirty = false; - // dirty |= SetShadowRegister(&state_regs.pa_cl_clip_cntl, - // XE_GPU_REG_PA_CL_CLIP_CNTL); - dirty |= SetShadowRegister(®s.rb_surface_info, XE_GPU_REG_RB_SURFACE_INFO); - dirty |= SetShadowRegister(®s.pa_cl_vte_cntl, XE_GPU_REG_PA_CL_VTE_CNTL); - dirty |= SetShadowRegister(®s.pa_su_sc_mode_cntl, - XE_GPU_REG_PA_SU_SC_MODE_CNTL); - dirty |= SetShadowRegister(®s.pa_sc_window_offset, - XE_GPU_REG_PA_SC_WINDOW_OFFSET); - dirty |= SetShadowRegister(®s.pa_sc_window_scissor_tl, - XE_GPU_REG_PA_SC_WINDOW_SCISSOR_TL); - dirty |= SetShadowRegister(®s.pa_sc_window_scissor_br, - XE_GPU_REG_PA_SC_WINDOW_SCISSOR_BR); - dirty |= SetShadowRegister(®s.pa_cl_vport_xoffset, - XE_GPU_REG_PA_CL_VPORT_XOFFSET); - dirty |= SetShadowRegister(®s.pa_cl_vport_yoffset, - XE_GPU_REG_PA_CL_VPORT_YOFFSET); - dirty |= SetShadowRegister(®s.pa_cl_vport_zoffset, - XE_GPU_REG_PA_CL_VPORT_ZOFFSET); - dirty |= SetShadowRegister(®s.pa_cl_vport_xscale, - XE_GPU_REG_PA_CL_VPORT_XSCALE); - dirty |= SetShadowRegister(®s.pa_cl_vport_yscale, - XE_GPU_REG_PA_CL_VPORT_YSCALE); - dirty |= SetShadowRegister(®s.pa_cl_vport_zscale, - XE_GPU_REG_PA_CL_VPORT_ZSCALE); - - // Much of this state machine is extracted from: - // https://github.com/freedreno/mesa/blob/master/src/mesa/drivers/dri/r200/r200_state.c - // http://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html - // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf - - // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf - // VTX_XY_FMT = true: the incoming X, Y have already been multiplied by 1/W0. - // = false: multiply the X, Y coordinates by 1/W0. - // VTX_Z_FMT = true: the incoming Z has already been multiplied by 1/W0. - // = false: multiply the Z coordinate by 1/W0. - // VTX_W0_FMT = true: the incoming W0 is not 1/W0. Perform the reciprocal to - // get 1/W0. - draw_batcher_.set_vtx_fmt((regs.pa_cl_vte_cntl >> 8) & 0x1 ? 1.0f : 0.0f, - (regs.pa_cl_vte_cntl >> 9) & 0x1 ? 1.0f : 0.0f, - (regs.pa_cl_vte_cntl >> 10) & 0x1 ? 1.0f : 0.0f); - - // Done in VS, no need to flush state. - if ((regs.pa_cl_vte_cntl & (1 << 0)) > 0) { - draw_batcher_.set_window_scalar(1.0f, 1.0f); - } else { - draw_batcher_.set_window_scalar(1.0f / 2560.0f, -1.0f / 2560.0f); - } - - if (!dirty) { - return UpdateStatus::kCompatible; - } - - draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange); - - // Clipping. - // https://github.com/freedreno/amd-gpu/blob/master/include/reg/yamato/14/yamato_genenum.h#L1587 - // bool clip_enabled = ((regs.pa_cl_clip_cntl >> 17) & 0x1) == 0; - // bool dx_clip = ((regs.pa_cl_clip_cntl >> 19) & 0x1) == 0x1; - //// TODO(benvanik): depth range? - // if (dx_clip) { - // glClipControl(GL_UPPER_LEFT, GL_ZERO_TO_ONE); - //} else { - // glClipControl(GL_LOWER_LEFT, GL_NEGATIVE_ONE_TO_ONE); - //} - - // Window parameters. - // http://ftp.tku.edu.tw/NetBSD/NetBSD-current/xsrc/external/mit/xf86-video-ati/dist/src/r600_reg_auto_r6xx.h - // See r200UpdateWindow: - // https://github.com/freedreno/mesa/blob/master/src/mesa/drivers/dri/r200/r200_state.c - int16_t window_offset_x = 0; - int16_t window_offset_y = 0; - if ((regs.pa_su_sc_mode_cntl >> 16) & 1) { - window_offset_x = regs.pa_sc_window_offset & 0x7FFF; - window_offset_y = (regs.pa_sc_window_offset >> 16) & 0x7FFF; - if (window_offset_x & 0x4000) { - window_offset_x |= 0x8000; - } - if (window_offset_y & 0x4000) { - window_offset_y |= 0x8000; - } - } - - GLint ws_x = regs.pa_sc_window_scissor_tl & 0x7FFF; - GLint ws_y = (regs.pa_sc_window_scissor_tl >> 16) & 0x7FFF; - GLsizei ws_w = (regs.pa_sc_window_scissor_br & 0x7FFF) - ws_x; - GLsizei ws_h = ((regs.pa_sc_window_scissor_br >> 16) & 0x7FFF) - ws_y; - ws_x += window_offset_x; - ws_y += window_offset_y; - glScissorIndexed(0, ws_x, ws_y, ws_w, ws_h); - - // HACK: no clue where to get these values. - // RB_SURFACE_INFO - auto surface_msaa = - static_cast<MsaaSamples>((regs.rb_surface_info >> 16) & 0x3); - // TODO(benvanik): ?? - float window_width_scalar = 1; - float window_height_scalar = 1; - switch (surface_msaa) { - case MsaaSamples::k1X: - break; - case MsaaSamples::k2X: - window_width_scalar = 2; - break; - case MsaaSamples::k4X: - window_width_scalar = 2; - window_height_scalar = 2; - break; - } - - // Whether each of the viewport settings are enabled. - // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf - bool vport_xscale_enable = (regs.pa_cl_vte_cntl & (1 << 0)) > 0; - bool vport_xoffset_enable = (regs.pa_cl_vte_cntl & (1 << 1)) > 0; - bool vport_yscale_enable = (regs.pa_cl_vte_cntl & (1 << 2)) > 0; - bool vport_yoffset_enable = (regs.pa_cl_vte_cntl & (1 << 3)) > 0; - bool vport_zscale_enable = (regs.pa_cl_vte_cntl & (1 << 4)) > 0; - bool vport_zoffset_enable = (regs.pa_cl_vte_cntl & (1 << 5)) > 0; - assert_true(vport_xscale_enable == vport_yscale_enable == - vport_zscale_enable == vport_xoffset_enable == - vport_yoffset_enable == vport_zoffset_enable); - - if (vport_xscale_enable) { - float texel_offset_x = 0.0f; - float texel_offset_y = 0.0f; - float vox = vport_xoffset_enable ? regs.pa_cl_vport_xoffset : 0; - float voy = vport_yoffset_enable ? regs.pa_cl_vport_yoffset : 0; - float vsx = vport_xscale_enable ? regs.pa_cl_vport_xscale : 1; - float vsy = vport_yscale_enable ? regs.pa_cl_vport_yscale : 1; - window_width_scalar = window_height_scalar = 1; - float vpw = 2 * window_width_scalar * vsx; - float vph = -2 * window_height_scalar * vsy; - float vpx = window_width_scalar * vox - vpw / 2 + window_offset_x; - float vpy = window_height_scalar * voy - vph / 2 + window_offset_y; - glViewportIndexedf(0, vpx + texel_offset_x, vpy + texel_offset_y, vpw, vph); - - // TODO(benvanik): depth range adjustment? - // float voz = vport_zoffset_enable ? regs.pa_cl_vport_zoffset : 0; - // float vsz = vport_zscale_enable ? regs.pa_cl_vport_zscale : 1; - } else { - float texel_offset_x = 0.0f; - float texel_offset_y = 0.0f; - float vpw = 2 * 2560.0f * window_width_scalar; - float vph = 2 * 2560.0f * window_height_scalar; - float vpx = -2560.0f * window_width_scalar + window_offset_x; - float vpy = -2560.0f * window_height_scalar + window_offset_y; - glViewportIndexedf(0, vpx + texel_offset_x, vpy + texel_offset_y, vpw, vph); - } - float voz = vport_zoffset_enable ? regs.pa_cl_vport_zoffset : 0; - float vsz = vport_zscale_enable ? regs.pa_cl_vport_zscale : 1; - glDepthRangef(voz, voz + vsz); - - return UpdateStatus::kMismatch; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateRasterizerState( - PrimitiveType prim_type) { - auto& regs = update_rasterizer_state_regs_; - - bool dirty = false; - dirty |= SetShadowRegister(®s.pa_su_sc_mode_cntl, - XE_GPU_REG_PA_SU_SC_MODE_CNTL); - dirty |= SetShadowRegister(®s.pa_sc_screen_scissor_tl, - XE_GPU_REG_PA_SC_SCREEN_SCISSOR_TL); - dirty |= SetShadowRegister(®s.pa_sc_screen_scissor_br, - XE_GPU_REG_PA_SC_SCREEN_SCISSOR_BR); - dirty |= SetShadowRegister(®s.multi_prim_ib_reset_index, - XE_GPU_REG_VGT_MULTI_PRIM_IB_RESET_INDX); - dirty |= SetShadowRegister(®s.pa_sc_viz_query, XE_GPU_REG_PA_SC_VIZ_QUERY); - dirty |= regs.prim_type != prim_type; - if (!dirty) { - return UpdateStatus::kCompatible; - } - - regs.prim_type = prim_type; - - SCOPE_profile_cpu_f("gpu"); - - draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange); - - // viz query enabled - // assert_zero(regs.pa_sc_viz_query & 0x01); - - // Kill pix post early-z test - // assert_zero(regs.pa_sc_viz_query & 0x80); - - // Scissoring. - // TODO(benvanik): is this used? we are using scissoring for window scissor. - if (regs.pa_sc_screen_scissor_tl != 0 && - regs.pa_sc_screen_scissor_br != 0x20002000) { - assert_always(); - // glEnable(GL_SCISSOR_TEST); - // TODO(benvanik): signed? - int32_t screen_scissor_x = regs.pa_sc_screen_scissor_tl & 0x7FFF; - int32_t screen_scissor_y = (regs.pa_sc_screen_scissor_tl >> 16) & 0x7FFF; - int32_t screen_scissor_w = - regs.pa_sc_screen_scissor_br & 0x7FFF - screen_scissor_x; - int32_t screen_scissor_h = - (regs.pa_sc_screen_scissor_br >> 16) & 0x7FFF - screen_scissor_y; - glScissor(screen_scissor_x, screen_scissor_y, screen_scissor_w, - screen_scissor_h); - } else { - // glDisable(GL_SCISSOR_TEST); - } - - switch (regs.pa_su_sc_mode_cntl & 0x3) { - case 0: - glDisable(GL_CULL_FACE); - break; - case 1: - glEnable(GL_CULL_FACE); - glCullFace(GL_FRONT); - break; - case 2: - glEnable(GL_CULL_FACE); - glCullFace(GL_BACK); - break; - } - if (regs.pa_su_sc_mode_cntl & 0x4) { - glFrontFace(GL_CW); - } else { - glFrontFace(GL_CCW); - } - - if (prim_type == PrimitiveType::kRectangleList) { - // Rectangle lists aren't culled. There may be other things they skip too. - glDisable(GL_CULL_FACE); - } - - static const GLenum kFillModes[3] = { - GL_POINT, - GL_LINE, - GL_FILL, - }; - bool poly_mode = ((regs.pa_su_sc_mode_cntl >> 3) & 0x3) != 0; - if (poly_mode) { - uint32_t front_poly_mode = (regs.pa_su_sc_mode_cntl >> 5) & 0x7; - uint32_t back_poly_mode = (regs.pa_su_sc_mode_cntl >> 8) & 0x7; - // GL only supports both matching. - assert_true(front_poly_mode == back_poly_mode); - glPolygonMode(GL_FRONT_AND_BACK, kFillModes[front_poly_mode]); - } else { - glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); - } - - if (regs.pa_su_sc_mode_cntl & (1 << 19)) { - glProvokingVertex(GL_LAST_VERTEX_CONVENTION); - } else { - glProvokingVertex(GL_FIRST_VERTEX_CONVENTION); - } - - if (regs.pa_su_sc_mode_cntl & (1 << 21)) { - glEnable(GL_PRIMITIVE_RESTART); - } else { - glDisable(GL_PRIMITIVE_RESTART); - } - glPrimitiveRestartIndex(regs.multi_prim_ib_reset_index); - - return UpdateStatus::kMismatch; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateBlendState() { - auto& reg_file = *register_file_; - auto& regs = update_blend_state_regs_; - - // Alpha testing -- ALPHAREF, ALPHAFUNC, ALPHATESTENABLE - // Deprecated in GL, implemented in shader. - // if(ALPHATESTENABLE && frag_out.a [<=/ALPHAFUNC] ALPHAREF) discard; - uint32_t color_control = reg_file[XE_GPU_REG_RB_COLORCONTROL].u32; - draw_batcher_.set_alpha_test((color_control & 0x8) != 0, // ALPAHTESTENABLE - color_control & 0x7, // ALPHAFUNC - reg_file[XE_GPU_REG_RB_ALPHA_REF].f32); - - bool dirty = false; - dirty |= - SetShadowRegister(®s.rb_blendcontrol[0], XE_GPU_REG_RB_BLENDCONTROL_0); - dirty |= - SetShadowRegister(®s.rb_blendcontrol[1], XE_GPU_REG_RB_BLENDCONTROL_1); - dirty |= - SetShadowRegister(®s.rb_blendcontrol[2], XE_GPU_REG_RB_BLENDCONTROL_2); - dirty |= - SetShadowRegister(®s.rb_blendcontrol[3], XE_GPU_REG_RB_BLENDCONTROL_3); - dirty |= SetShadowRegister(®s.rb_blend_rgba[0], XE_GPU_REG_RB_BLEND_RED); - dirty |= SetShadowRegister(®s.rb_blend_rgba[1], XE_GPU_REG_RB_BLEND_GREEN); - dirty |= SetShadowRegister(®s.rb_blend_rgba[2], XE_GPU_REG_RB_BLEND_BLUE); - dirty |= SetShadowRegister(®s.rb_blend_rgba[3], XE_GPU_REG_RB_BLEND_ALPHA); - if (!dirty) { - return UpdateStatus::kCompatible; - } - - SCOPE_profile_cpu_f("gpu"); - - draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange); - - static const GLenum blend_map[] = { - /* 0 */ GL_ZERO, - /* 1 */ GL_ONE, - /* 2 */ GL_ZERO, // ? - /* 3 */ GL_ZERO, // ? - /* 4 */ GL_SRC_COLOR, - /* 5 */ GL_ONE_MINUS_SRC_COLOR, - /* 6 */ GL_SRC_ALPHA, - /* 7 */ GL_ONE_MINUS_SRC_ALPHA, - /* 8 */ GL_DST_COLOR, - /* 9 */ GL_ONE_MINUS_DST_COLOR, - /* 10 */ GL_DST_ALPHA, - /* 11 */ GL_ONE_MINUS_DST_ALPHA, - /* 12 */ GL_CONSTANT_COLOR, - /* 13 */ GL_ONE_MINUS_CONSTANT_COLOR, - /* 14 */ GL_CONSTANT_ALPHA, - /* 15 */ GL_ONE_MINUS_CONSTANT_ALPHA, - /* 16 */ GL_SRC_ALPHA_SATURATE, - }; - static const GLenum blend_op_map[] = { - /* 0 */ GL_FUNC_ADD, - /* 1 */ GL_FUNC_SUBTRACT, - /* 2 */ GL_MIN, - /* 3 */ GL_MAX, - /* 4 */ GL_FUNC_REVERSE_SUBTRACT, - }; - for (int i = 0; i < xe::countof(regs.rb_blendcontrol); ++i) { - uint32_t blend_control = regs.rb_blendcontrol[i]; - // A2XX_RB_BLEND_CONTROL_COLOR_SRCBLEND - auto src_blend = blend_map[(blend_control & 0x0000001F) >> 0]; - // A2XX_RB_BLEND_CONTROL_COLOR_DESTBLEND - auto dest_blend = blend_map[(blend_control & 0x00001F00) >> 8]; - // A2XX_RB_BLEND_CONTROL_COLOR_COMB_FCN - auto blend_op = blend_op_map[(blend_control & 0x000000E0) >> 5]; - // A2XX_RB_BLEND_CONTROL_ALPHA_SRCBLEND - auto src_blend_alpha = blend_map[(blend_control & 0x001F0000) >> 16]; - // A2XX_RB_BLEND_CONTROL_ALPHA_DESTBLEND - auto dest_blend_alpha = blend_map[(blend_control & 0x1F000000) >> 24]; - // A2XX_RB_BLEND_CONTROL_ALPHA_COMB_FCN - auto blend_op_alpha = blend_op_map[(blend_control & 0x00E00000) >> 21]; - // A2XX_RB_COLORCONTROL_BLEND_DISABLE ?? Can't find this! - // Just guess based on actions. - // bool blend_enable = - // !((src_blend == GL_ONE) && (dest_blend == GL_ZERO) && - // (blend_op == GL_FUNC_ADD) && (src_blend_alpha == GL_ONE) && - // (dest_blend_alpha == GL_ZERO) && (blend_op_alpha == GL_FUNC_ADD)); - bool blend_enable = !(color_control & 0x20); - if (blend_enable) { - glEnablei(GL_BLEND, i); - glBlendEquationSeparatei(i, blend_op, blend_op_alpha); - glBlendFuncSeparatei(i, src_blend, dest_blend, src_blend_alpha, - dest_blend_alpha); - } else { - glDisablei(GL_BLEND, i); - } - } - - glBlendColor(regs.rb_blend_rgba[0], regs.rb_blend_rgba[1], - regs.rb_blend_rgba[2], regs.rb_blend_rgba[3]); - - return UpdateStatus::kMismatch; -} - -GL4CommandProcessor::UpdateStatus -GL4CommandProcessor::UpdateDepthStencilState() { - auto& regs = update_depth_stencil_state_regs_; - - bool dirty = false; - dirty |= SetShadowRegister(®s.rb_depthcontrol, XE_GPU_REG_RB_DEPTHCONTROL); - dirty |= - SetShadowRegister(®s.rb_stencilrefmask, XE_GPU_REG_RB_STENCILREFMASK); - if (!dirty) { - return UpdateStatus::kCompatible; - } - - SCOPE_profile_cpu_f("gpu"); - - draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange); - - static const GLenum compare_func_map[] = { - /* 0 */ GL_NEVER, - /* 1 */ GL_LESS, - /* 2 */ GL_EQUAL, - /* 3 */ GL_LEQUAL, - /* 4 */ GL_GREATER, - /* 5 */ GL_NOTEQUAL, - /* 6 */ GL_GEQUAL, - /* 7 */ GL_ALWAYS, - }; - static const GLenum stencil_op_map[] = { - /* 0 */ GL_KEEP, - /* 1 */ GL_ZERO, - /* 2 */ GL_REPLACE, - /* 3 */ GL_INCR_WRAP, - /* 4 */ GL_DECR_WRAP, - /* 5 */ GL_INVERT, - /* 6 */ GL_INCR, - /* 7 */ GL_DECR, - }; - // A2XX_RB_DEPTHCONTROL_Z_ENABLE - if (regs.rb_depthcontrol & 0x00000002) { - glEnable(GL_DEPTH_TEST); - } else { - glDisable(GL_DEPTH_TEST); - } - // glDisable(GL_DEPTH_TEST); - // A2XX_RB_DEPTHCONTROL_Z_WRITE_ENABLE - glDepthMask((regs.rb_depthcontrol & 0x00000004) ? GL_TRUE : GL_FALSE); - // A2XX_RB_DEPTHCONTROL_EARLY_Z_ENABLE - // ? - // A2XX_RB_DEPTHCONTROL_ZFUNC - glDepthFunc(compare_func_map[(regs.rb_depthcontrol & 0x00000070) >> 4]); - // A2XX_RB_DEPTHCONTROL_STENCIL_ENABLE - if (regs.rb_depthcontrol & 0x00000001) { - glEnable(GL_STENCIL_TEST); - } else { - glDisable(GL_STENCIL_TEST); - } - // RB_STENCILREFMASK_STENCILREF - uint32_t stencil_ref = (regs.rb_stencilrefmask & 0x000000FF); - // RB_STENCILREFMASK_STENCILMASK - uint32_t stencil_read_mask = (regs.rb_stencilrefmask & 0x0000FF00) >> 8; - // RB_STENCILREFMASK_STENCILWRITEMASK - glStencilMask((regs.rb_stencilrefmask & 0x00FF0000) >> 16); - // A2XX_RB_DEPTHCONTROL_BACKFACE_ENABLE - bool backface_enabled = (regs.rb_depthcontrol & 0x00000080) != 0; - if (backface_enabled) { - // A2XX_RB_DEPTHCONTROL_STENCILFUNC - glStencilFuncSeparate( - GL_FRONT, compare_func_map[(regs.rb_depthcontrol & 0x00000700) >> 8], - stencil_ref, stencil_read_mask); - // A2XX_RB_DEPTHCONTROL_STENCILFAIL - // A2XX_RB_DEPTHCONTROL_STENCILZFAIL - // A2XX_RB_DEPTHCONTROL_STENCILZPASS - glStencilOpSeparate( - GL_FRONT, stencil_op_map[(regs.rb_depthcontrol & 0x00003800) >> 11], - stencil_op_map[(regs.rb_depthcontrol & 0x000E0000) >> 17], - stencil_op_map[(regs.rb_depthcontrol & 0x0001C000) >> 14]); - // A2XX_RB_DEPTHCONTROL_STENCILFUNC_BF - glStencilFuncSeparate( - GL_BACK, compare_func_map[(regs.rb_depthcontrol & 0x00700000) >> 20], - stencil_ref, stencil_read_mask); - // A2XX_RB_DEPTHCONTROL_STENCILFAIL_BF - // A2XX_RB_DEPTHCONTROL_STENCILZFAIL_BF - // A2XX_RB_DEPTHCONTROL_STENCILZPASS_BF - glStencilOpSeparate( - GL_BACK, stencil_op_map[(regs.rb_depthcontrol & 0x03800000) >> 23], - stencil_op_map[(regs.rb_depthcontrol & 0xE0000000) >> 29], - stencil_op_map[(regs.rb_depthcontrol & 0x1C000000) >> 26]); - } else { - // Backfaces disabled - treat backfaces as frontfaces. - glStencilFunc(compare_func_map[(regs.rb_depthcontrol & 0x00000700) >> 8], - stencil_ref, stencil_read_mask); - glStencilOp(stencil_op_map[(regs.rb_depthcontrol & 0x00003800) >> 11], - stencil_op_map[(regs.rb_depthcontrol & 0x000E0000) >> 17], - stencil_op_map[(regs.rb_depthcontrol & 0x0001C000) >> 14]); - } - - return UpdateStatus::kMismatch; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::PopulateIndexBuffer( - IndexBufferInfo* index_buffer_info) { - auto& regs = *register_file_; - if (!index_buffer_info || !index_buffer_info->guest_base) { - // No index buffer or auto draw. - return UpdateStatus::kCompatible; - } - auto& info = *index_buffer_info; - -#if FINE_GRAINED_DRAW_SCOPES - SCOPE_profile_cpu_f("gpu"); -#endif // FINE_GRAINED_DRAW_SCOPES - - // Min/max index ranges for clamping. This is often [0g,FFFF|FFFFFF]. - // All indices should be clamped to [min,max]. May be a way to do this in GL. - uint32_t min_index = regs[XE_GPU_REG_VGT_MIN_VTX_INDX].u32; - uint32_t max_index = regs[XE_GPU_REG_VGT_MAX_VTX_INDX].u32; - assert_true(min_index == 0); - assert_true(max_index == 0xFFFF || max_index == 0xFFFFFF); - - assert_true(info.endianness == Endian::k8in16 || - info.endianness == Endian::k8in32); - - trace_writer_.WriteMemoryRead(info.guest_base, info.length); - - size_t total_size = - info.count * (info.format == IndexFormat::kInt32 ? sizeof(uint32_t) - : sizeof(uint16_t)); - CircularBuffer::Allocation allocation; - if (!scratch_buffer_.AcquireCached(info.guest_base, total_size, - &allocation)) { - if (info.format == IndexFormat::kInt32) { - auto dest = reinterpret_cast<uint32_t*>(allocation.host_ptr); - auto src = memory_->TranslatePhysical<const uint32_t*>(info.guest_base); - xe::copy_and_swap_32_aligned(dest, src, info.count); - } else { - auto dest = reinterpret_cast<uint16_t*>(allocation.host_ptr); - auto src = memory_->TranslatePhysical<const uint16_t*>(info.guest_base); - xe::copy_and_swap_16_aligned(dest, src, info.count); - } - draw_batcher_.set_index_buffer(allocation); - scratch_buffer_.Commit(std::move(allocation)); - } else { - draw_batcher_.set_index_buffer(allocation); - } - - return UpdateStatus::kCompatible; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::PopulateVertexBuffers() { -#if FINE_GRAINED_DRAW_SCOPES - SCOPE_profile_cpu_f("gpu"); -#endif // FINE_GRAINED_DRAW_SCOPES - - auto& regs = *register_file_; - assert_not_null(active_vertex_shader_); - - for (const auto& vertex_binding : active_vertex_shader_->vertex_bindings()) { - int r = XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0 + - (vertex_binding.fetch_constant / 3) * 6; - const auto group = reinterpret_cast<xe_gpu_fetch_group_t*>(®s.values[r]); - const xe_gpu_vertex_fetch_t* fetch = nullptr; - switch (vertex_binding.fetch_constant % 3) { - case 0: - fetch = &group->vertex_fetch_0; - break; - case 1: - fetch = &group->vertex_fetch_1; - break; - case 2: - fetch = &group->vertex_fetch_2; - break; - } - assert_true(fetch->endian == 2); - - size_t valid_range = size_t(fetch->size * 4); - - trace_writer_.WriteMemoryRead(fetch->address << 2, valid_range); - - auto vertex_shader = static_cast<GL4Shader*>(active_vertex_shader_); - CircularBuffer::Allocation allocation; - if (!scratch_buffer_.AcquireCached(fetch->address << 2, valid_range, - &allocation)) { - // Copy and byte swap the entire buffer. - // We could be smart about this to save GPU bandwidth by building a CRC - // as we copy and only if it differs from the previous value committing - // it (and if it matches just discard and reuse). - xe::copy_and_swap_32_aligned( - allocation.host_ptr, - memory_->TranslatePhysical<const uint32_t*>(fetch->address << 2), - valid_range / 4); - - // TODO(benvanik): if we could find a way to avoid this, we could use - // multidraw without flushing. - glVertexArrayVertexBuffer( - vertex_shader->vao(), - static_cast<GLuint>(vertex_binding.binding_index), - scratch_buffer_.handle(), allocation.offset, - vertex_binding.stride_words * 4); - - scratch_buffer_.Commit(std::move(allocation)); - } else { - // TODO(benvanik): if we could find a way to avoid this, we could use - // multidraw without flushing. - glVertexArrayVertexBuffer( - vertex_shader->vao(), - static_cast<GLuint>(vertex_binding.binding_index), - scratch_buffer_.handle(), allocation.offset, - vertex_binding.stride_words * 4); - } - } - - return UpdateStatus::kCompatible; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::PopulateSamplers() { -#if FINE_GRAINED_DRAW_SCOPES - SCOPE_profile_cpu_f("gpu"); -#endif // FINE_GRAINED_DRAW_SCOPES - - bool mismatch = false; - - // VS and PS samplers are shared, but may be used exclusively. - // We walk each and setup lazily. - bool has_setup_sampler[32] = {false}; - - // Vertex texture samplers. - for (auto& texture_binding : active_vertex_shader_->texture_bindings()) { - if (has_setup_sampler[texture_binding.fetch_constant]) { - continue; - } - has_setup_sampler[texture_binding.fetch_constant] = true; - auto status = PopulateSampler(texture_binding); - if (status == UpdateStatus::kError) { - return status; - } else if (status == UpdateStatus::kMismatch) { - mismatch = true; - } - } - - // Pixel shader texture sampler. - for (auto& texture_binding : active_pixel_shader_->texture_bindings()) { - if (has_setup_sampler[texture_binding.fetch_constant]) { - continue; - } - has_setup_sampler[texture_binding.fetch_constant] = true; - auto status = PopulateSampler(texture_binding); - if (status == UpdateStatus::kError) { - return UpdateStatus::kError; - } else if (status == UpdateStatus::kMismatch) { - mismatch = true; - } - } - - return mismatch ? UpdateStatus::kMismatch : UpdateStatus::kCompatible; -} - -GL4CommandProcessor::UpdateStatus GL4CommandProcessor::PopulateSampler( - const Shader::TextureBinding& texture_binding) { - auto& regs = *register_file_; - int r = XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0 + - texture_binding.fetch_constant * 6; - auto group = reinterpret_cast<const xe_gpu_fetch_group_t*>(®s.values[r]); - auto& fetch = group->texture_fetch; - - // Reset slot. - // If we fail, we still draw but with an invalid texture. - draw_batcher_.set_texture_sampler(texture_binding.fetch_constant, 0, 0); - - if (FLAGS_disable_textures) { - return UpdateStatus::kCompatible; - } - - // ? - if (!fetch.type) { - return UpdateStatus::kCompatible; - } - assert_true(fetch.type == 0x2); - - TextureInfo texture_info; - if (!TextureInfo::Prepare(fetch, &texture_info)) { - XELOGE("Unable to parse texture fetcher info"); - return UpdateStatus::kCompatible; // invalid texture used - } - SamplerInfo sampler_info; - if (!SamplerInfo::Prepare(fetch, texture_binding.fetch_instr, - &sampler_info)) { - XELOGE("Unable to parse sampler info"); - return UpdateStatus::kCompatible; // invalid texture used - } - - trace_writer_.WriteMemoryRead(texture_info.guest_address, - texture_info.input_length); - - auto entry_view = texture_cache_.Demand(texture_info, sampler_info); - if (!entry_view) { - // Unable to create/fetch/etc. - XELOGE("Failed to demand texture"); - return UpdateStatus::kCompatible; - } - - // Shaders will use bindless to fetch right from it. - draw_batcher_.set_texture_sampler(texture_binding.fetch_constant, - entry_view->texture_sampler_handle, - fetch.swizzle); - - return UpdateStatus::kCompatible; -} - -bool GL4CommandProcessor::IssueCopy() { - SCOPE_profile_cpu_f("gpu"); - auto& regs = *register_file_; - - // This is used to resolve surfaces, taking them from EDRAM render targets - // to system memory. It can optionally clear color/depth surfaces, too. - // The command buffer has stuff for actually doing this by drawing, however - // we should be able to do it without that much easier. - - uint32_t copy_control = regs[XE_GPU_REG_RB_COPY_CONTROL].u32; - // Render targets 0-3, 4 = depth - uint32_t copy_src_select = copy_control & 0x7; - bool color_clear_enabled = (copy_control >> 8) & 0x1; - bool depth_clear_enabled = (copy_control >> 9) & 0x1; - auto copy_command = static_cast<CopyCommand>((copy_control >> 20) & 0x3); - - uint32_t copy_dest_info = regs[XE_GPU_REG_RB_COPY_DEST_INFO].u32; - auto copy_dest_endian = static_cast<Endian128>(copy_dest_info & 0x7); - uint32_t copy_dest_array = (copy_dest_info >> 3) & 0x1; - assert_true(copy_dest_array == 0); - uint32_t copy_dest_slice = (copy_dest_info >> 4) & 0x7; - assert_true(copy_dest_slice == 0); - auto copy_dest_format = - static_cast<ColorFormat>((copy_dest_info >> 7) & 0x3F); - uint32_t copy_dest_number = (copy_dest_info >> 13) & 0x7; - // assert_true(copy_dest_number == 0); // ? - uint32_t copy_dest_bias = (copy_dest_info >> 16) & 0x3F; - // assert_true(copy_dest_bias == 0); - uint32_t copy_dest_swap = (copy_dest_info >> 25) & 0x1; - - uint32_t copy_dest_base = regs[XE_GPU_REG_RB_COPY_DEST_BASE].u32; - uint32_t copy_dest_pitch = regs[XE_GPU_REG_RB_COPY_DEST_PITCH].u32; - uint32_t copy_dest_height = (copy_dest_pitch >> 16) & 0x3FFF; - copy_dest_pitch &= 0x3FFF; - - // None of this is supported yet: - uint32_t copy_surface_slice = regs[XE_GPU_REG_RB_COPY_SURFACE_SLICE].u32; - assert_true(copy_surface_slice == 0); - uint32_t copy_func = regs[XE_GPU_REG_RB_COPY_FUNC].u32; - assert_true(copy_func == 0); - uint32_t copy_ref = regs[XE_GPU_REG_RB_COPY_REF].u32; - assert_true(copy_ref == 0); - uint32_t copy_mask = regs[XE_GPU_REG_RB_COPY_MASK].u32; - assert_true(copy_mask == 0); - - // RB_SURFACE_INFO - // http://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html - uint32_t surface_info = regs[XE_GPU_REG_RB_SURFACE_INFO].u32; - uint32_t surface_pitch = surface_info & 0x3FFF; - auto surface_msaa = static_cast<MsaaSamples>((surface_info >> 16) & 0x3); - - // Depending on the source, pick the buffer we'll be sourcing. - // We then query for a cached framebuffer setup with that buffer active. - TextureFormat src_format = TextureFormat::kUnknown; - GLuint color_targets[4] = {kAnyTarget, kAnyTarget, kAnyTarget, kAnyTarget}; - GLuint depth_target = kAnyTarget; - if (copy_src_select <= 3 || color_clear_enabled) { - // Source from a color target. - uint32_t color_info[4] = { - regs[XE_GPU_REG_RB_COLOR_INFO].u32, - regs[XE_GPU_REG_RB_COLOR1_INFO].u32, - regs[XE_GPU_REG_RB_COLOR2_INFO].u32, - regs[XE_GPU_REG_RB_COLOR3_INFO].u32, - }; - uint32_t color_base = color_info[copy_src_select] & 0xFFF; - auto color_format = static_cast<ColorRenderTargetFormat>( - (color_info[copy_src_select] >> 16) & 0xF); - color_targets[copy_src_select] = GetColorRenderTarget( - surface_pitch, surface_msaa, color_base, color_format); - - if (copy_src_select <= 3) { - src_format = ColorRenderTargetToTextureFormat(color_format); - } - } - - // Grab the depth/stencil if we're sourcing from it or clear is enabled. - if (copy_src_select > 3 || depth_clear_enabled) { - uint32_t depth_info = regs[XE_GPU_REG_RB_DEPTH_INFO].u32; - uint32_t depth_base = depth_info & 0xFFF; - auto depth_format = - static_cast<DepthRenderTargetFormat>((depth_info >> 16) & 0x1); - depth_target = GetDepthRenderTarget(surface_pitch, surface_msaa, depth_base, - depth_format); - - if (copy_src_select > 3) { - src_format = DepthRenderTargetToTextureFormat(depth_format); - } - } - - auto source_framebuffer = GetFramebuffer(color_targets, depth_target); - if (!source_framebuffer) { - // If we get here we are likely missing some state checks. - assert_always("No framebuffer for copy source? no-op copy?"); - XELOGE("No framebuffer for copy source"); - return false; - } - - active_framebuffer_ = source_framebuffer; - - GLenum read_format; - GLenum read_type; - size_t read_size = 0; - switch (copy_dest_format) { - case ColorFormat::k_1_5_5_5: - read_format = GL_RGB5_A1; - read_type = GL_UNSIGNED_SHORT_1_5_5_5_REV; - read_size = 16; - break; - case ColorFormat::k_2_10_10_10: - read_format = GL_RGB10_A2; - read_type = GL_UNSIGNED_INT_10_10_10_2; - read_size = 32; - break; - case ColorFormat::k_4_4_4_4: - read_format = GL_RGBA4; - read_type = GL_UNSIGNED_SHORT_4_4_4_4; - read_size = 16; - break; - case ColorFormat::k_5_6_5: - read_format = GL_RGB565; - read_type = GL_UNSIGNED_SHORT_5_6_5; - read_size = 16; - break; - case ColorFormat::k_8: - read_format = GL_R8; - read_type = GL_UNSIGNED_BYTE; - read_size = 8; - break; - case ColorFormat::k_8_8: - read_format = GL_RG8; - read_type = GL_UNSIGNED_BYTE; - read_size = 16; - break; - case ColorFormat::k_8_8_8_8: - read_format = copy_dest_swap ? GL_BGRA : GL_RGBA; - read_type = GL_UNSIGNED_BYTE; - read_size = 32; - break; - case ColorFormat::k_16: - read_format = GL_R16; - read_type = GL_UNSIGNED_SHORT; - read_size = 16; - break; - case ColorFormat::k_16_FLOAT: - read_format = GL_R16F; - read_type = GL_HALF_FLOAT; - read_size = 16; - break; - case ColorFormat::k_16_16: - read_format = GL_RG16; - read_type = GL_UNSIGNED_SHORT; - read_size = 32; - break; - case ColorFormat::k_16_16_FLOAT: - read_format = GL_RG16F; - read_type = GL_HALF_FLOAT; - read_size = 32; - break; - case ColorFormat::k_16_16_16_16: - read_format = GL_RGBA16; - read_type = GL_UNSIGNED_SHORT; - read_size = 64; - break; - case ColorFormat::k_16_16_16_16_FLOAT: - read_format = GL_RGBA16F; - read_type = GL_HALF_FLOAT; - read_size = 64; - break; - case ColorFormat::k_32_FLOAT: - read_format = GL_R32F; - read_type = GL_FLOAT; - read_size = 32; - break; - case ColorFormat::k_32_32_FLOAT: - read_format = GL_RG32F; - read_type = GL_FLOAT; - read_size = 64; - break; - case ColorFormat::k_32_32_32_32_FLOAT: - read_format = GL_RGBA32F; - read_type = GL_FLOAT; - read_size = 128; - break; - case ColorFormat::k_10_11_11: - case ColorFormat::k_11_11_10: - read_format = GL_R11F_G11F_B10F; - read_type = GL_UNSIGNED_INT_10F_11F_11F_REV; - read_size = 32; - break; - default: - assert_unhandled_case(copy_dest_format); - return false; - } - - // TODO(benvanik): swap channel ordering on copy_dest_swap - // Can we use GL swizzles for this? - - // Swap byte order during read. - // TODO(benvanik): handle other endian modes. - switch (copy_dest_endian) { - case Endian128::kUnspecified: - glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE); - break; - case Endian128::k8in32: - glPixelStorei(GL_PACK_SWAP_BYTES, GL_TRUE); - break; - default: - // assert_unhandled_case(copy_dest_endian); - glPixelStorei(GL_PACK_SWAP_BYTES, GL_TRUE); - break; - } - - // TODO(benvanik): tweak alignments/strides. - // glPixelStorei(GL_PACK_ALIGNMENT, 1); - // glPixelStorei(GL_PACK_ROW_LENGTH, 0); - // glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0); - - // TODO(benvanik): any way to scissor this? a200 has: - // REG_A2XX_RB_COPY_DEST_OFFSET = A2XX_RB_COPY_DEST_OFFSET_X(tile->xoff) | - // A2XX_RB_COPY_DEST_OFFSET_Y(tile->yoff); - // but I can't seem to find something similar. - uint32_t dest_logical_width = copy_dest_pitch; - uint32_t dest_logical_height = copy_dest_height; - uint32_t dest_block_width = xe::round_up(dest_logical_width, 32); - uint32_t dest_block_height = /*xe::round_up(*/ dest_logical_height /*, 32)*/; - - uint32_t window_offset = regs[XE_GPU_REG_PA_SC_WINDOW_OFFSET].u32; - int16_t window_offset_x = window_offset & 0x7FFF; - int16_t window_offset_y = (window_offset >> 16) & 0x7FFF; - if (window_offset_x & 0x4000) { - window_offset_x |= 0x8000; - } - if (window_offset_y & 0x4000) { - window_offset_y |= 0x8000; - } - - // HACK: vertices to use are always in vf0. - int copy_vertex_fetch_slot = 0; - int r = - XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0 + (copy_vertex_fetch_slot / 3) * 6; - const auto group = reinterpret_cast<xe_gpu_fetch_group_t*>(®s.values[r]); - const xe_gpu_vertex_fetch_t* fetch = nullptr; - switch (copy_vertex_fetch_slot % 3) { - case 0: - fetch = &group->vertex_fetch_0; - break; - case 1: - fetch = &group->vertex_fetch_1; - break; - case 2: - fetch = &group->vertex_fetch_2; - break; - } - assert_true(fetch->type == 3); - assert_true(fetch->endian == 2); - assert_true(fetch->size == 6); - const uint8_t* vertex_addr = memory_->TranslatePhysical(fetch->address << 2); - trace_writer_.WriteMemoryRead(fetch->address << 2, fetch->size * 4); - int32_t dest_min_x = int32_t((std::min( - std::min( - GpuSwap(xe::load<float>(vertex_addr + 0), Endian(fetch->endian)), - GpuSwap(xe::load<float>(vertex_addr + 8), Endian(fetch->endian))), - GpuSwap(xe::load<float>(vertex_addr + 16), Endian(fetch->endian))))); - int32_t dest_max_x = int32_t((std::max( - std::max( - GpuSwap(xe::load<float>(vertex_addr + 0), Endian(fetch->endian)), - GpuSwap(xe::load<float>(vertex_addr + 8), Endian(fetch->endian))), - GpuSwap(xe::load<float>(vertex_addr + 16), Endian(fetch->endian))))); - int32_t dest_min_y = int32_t((std::min( - std::min( - GpuSwap(xe::load<float>(vertex_addr + 4), Endian(fetch->endian)), - GpuSwap(xe::load<float>(vertex_addr + 12), Endian(fetch->endian))), - GpuSwap(xe::load<float>(vertex_addr + 20), Endian(fetch->endian))))); - int32_t dest_max_y = int32_t((std::max( - std::max( - GpuSwap(xe::load<float>(vertex_addr + 4), Endian(fetch->endian)), - GpuSwap(xe::load<float>(vertex_addr + 12), Endian(fetch->endian))), - GpuSwap(xe::load<float>(vertex_addr + 20), Endian(fetch->endian))))); - Rect2D dest_rect(dest_min_x, dest_min_y, dest_max_x - dest_min_x, - dest_max_y - dest_min_y); - Rect2D src_rect(0, 0, dest_rect.width, dest_rect.height); - - // The dest base address passed in has already been offset by the window - // offset, so to ensure texture lookup works we need to offset it. - // TODO(benvanik): allow texture cache to lookup partial textures. - // TODO(benvanik): change based on format. - int32_t dest_offset = window_offset_y * copy_dest_pitch * int(read_size / 8); - dest_offset += window_offset_x * 32 * int(read_size / 8); - copy_dest_base += dest_offset; - - // Destination pointer in guest memory. - // We have GL throw bytes directly into it. - // TODO(benvanik): copy to staging texture then PBO back? - void* ptr = memory_->TranslatePhysical(copy_dest_base); - size_t size = copy_dest_pitch * copy_dest_height * (read_size / 8); - - auto blitter = static_cast<xe::ui::gl::GLContext*>(context_.get())->blitter(); - - // Make active so glReadPixels reads from us. - switch (copy_command) { - case CopyCommand::kRaw: { - // This performs a byte-for-byte copy of the textures from src to dest - // with no conversion. Byte swapping may still occur. - if (copy_src_select <= 3) { - // Source from a bound render target. - // TODO(benvanik): RAW copy. - last_framebuffer_texture_ = texture_cache_.CopyTexture( - blitter, copy_dest_base, dest_logical_width, dest_logical_height, - dest_block_width, dest_block_height, - ColorFormatToTextureFormat(copy_dest_format), - copy_dest_swap ? true : false, color_targets[copy_src_select], - src_rect, dest_rect); - if (!FLAGS_disable_framebuffer_readback) { - // std::memset(ptr, 0xDE, - // copy_dest_pitch * copy_dest_height * (read_size / 8)); - // glReadPixels(0, 0, copy_dest_pitch, copy_dest_height, read_format, - // read_type, ptr); - } - } else { - // Source from the bound depth/stencil target. - // TODO(benvanik): RAW copy. - texture_cache_.CopyTexture( - blitter, copy_dest_base, dest_logical_width, dest_logical_height, - dest_block_width, dest_block_height, src_format, - copy_dest_swap ? true : false, depth_target, src_rect, dest_rect); - if (!FLAGS_disable_framebuffer_readback) { - // std::memset(ptr, 0xDE, - // copy_dest_pitch * copy_dest_height * (read_size / 8)); - // glReadPixels(0, 0, copy_dest_pitch, copy_dest_height, - // GL_DEPTH_STENCIL, read_type, ptr); - } - } - break; - } - case CopyCommand::kConvert: { - if (copy_src_select <= 3) { - // Source from a bound render target. - // Either copy the readbuffer into an existing texture or create a new - // one in the cache so we can service future upload requests. - last_framebuffer_texture_ = texture_cache_.ConvertTexture( - blitter, copy_dest_base, dest_logical_width, dest_logical_height, - dest_block_width, dest_block_height, - ColorFormatToTextureFormat(copy_dest_format), - copy_dest_swap ? true : false, color_targets[copy_src_select], - src_rect, dest_rect); - if (!FLAGS_disable_framebuffer_readback) { - // std::memset(ptr, 0xDE, - // copy_dest_pitch * copy_dest_height * (read_size / 8)); - // glReadPixels(0, 0, copy_dest_pitch, copy_dest_height, read_format, - // read_type, ptr); - } - } else { - // Source from the bound depth/stencil target. - texture_cache_.ConvertTexture( - blitter, copy_dest_base, dest_logical_width, dest_logical_height, - dest_block_width, dest_block_height, src_format, - copy_dest_swap ? true : false, depth_target, src_rect, dest_rect); - if (!FLAGS_disable_framebuffer_readback) { - // std::memset(ptr, 0xDE, - // copy_dest_pitch * copy_dest_height * (read_size / 8)); - // glReadPixels(0, 0, copy_dest_pitch, copy_dest_height, - // GL_DEPTH_STENCIL, read_type, ptr); - } - } - break; - } - case CopyCommand::kConstantOne: - case CopyCommand::kNull: - default: - // assert_unhandled_case(copy_command); - return false; - } - - // Perform any requested clears. - uint32_t copy_depth_clear = regs[XE_GPU_REG_RB_DEPTH_CLEAR].u32; - uint32_t copy_color_clear = regs[XE_GPU_REG_RB_COLOR_CLEAR].u32; - uint32_t copy_color_clear_low = regs[XE_GPU_REG_RB_COLOR_CLEAR_LOW].u32; - assert_true(copy_color_clear == copy_color_clear_low); - - if (color_clear_enabled) { - // Clear the render target we selected for copy. - assert_true(copy_src_select < 3); - // TODO(benvanik): verify color order. - float color[] = {(copy_color_clear & 0xFF) / 255.0f, - ((copy_color_clear >> 8) & 0xFF) / 255.0f, - ((copy_color_clear >> 16) & 0xFF) / 255.0f, - ((copy_color_clear >> 24) & 0xFF) / 255.0f}; - // TODO(benvanik): remove query. - GLboolean old_color_mask[4]; - glGetBooleani_v(GL_COLOR_WRITEMASK, copy_src_select, old_color_mask); - glColorMaski(copy_src_select, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); - glClearNamedFramebufferfv(source_framebuffer->framebuffer, GL_COLOR, - copy_src_select, color); - glColorMaski(copy_src_select, old_color_mask[0], old_color_mask[1], - old_color_mask[2], old_color_mask[3]); - } - - if (depth_clear_enabled && depth_target != kAnyTarget) { - // Clear the current depth buffer. - // TODO(benvanik): verify format. - GLfloat depth = {(copy_depth_clear & 0xFFFFFF00) / - static_cast<float>(0xFFFFFF00)}; - GLint stencil = copy_depth_clear & 0xFF; - GLint old_draw_framebuffer; - GLboolean old_depth_mask; - GLint old_stencil_mask; - glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &old_draw_framebuffer); - glGetBooleanv(GL_DEPTH_WRITEMASK, &old_depth_mask); - glGetIntegerv(GL_STENCIL_WRITEMASK, &old_stencil_mask); - glDepthMask(GL_TRUE); - glStencilMask(0xFF); - // HACK: this should work, but throws INVALID_ENUM on nvidia drivers. - // GLEW signature differs from OpenGL docs? - // glClearNamedFramebufferfi(source_framebuffer->framebuffer, - // GL_DEPTH_STENCIL, depth, stencil); - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, source_framebuffer->framebuffer); - glClearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil); - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, old_draw_framebuffer); - glDepthMask(old_depth_mask); - glStencilMask(old_stencil_mask); - } - - return true; -} - -GLuint GL4CommandProcessor::GetColorRenderTarget( - uint32_t pitch, MsaaSamples samples, uint32_t base, - ColorRenderTargetFormat format) { - // Because we don't know the height of anything, we allocate at full res. - // At 2560x2560, it's impossible for EDRAM to fit anymore. - uint32_t width = 2560; - uint32_t height = 2560; - - // NOTE: we strip gamma formats down to normal ones. - if (format == ColorRenderTargetFormat::k_8_8_8_8_GAMMA) { - format = ColorRenderTargetFormat::k_8_8_8_8; - } - - GLenum internal_format; - switch (format) { - case ColorRenderTargetFormat::k_8_8_8_8: - case ColorRenderTargetFormat::k_8_8_8_8_GAMMA: - internal_format = GL_RGBA8; - break; - case ColorRenderTargetFormat::k_2_10_10_10: - case ColorRenderTargetFormat::k_2_10_10_10_unknown: - internal_format = GL_RGB10_A2UI; - break; - case ColorRenderTargetFormat::k_2_10_10_10_FLOAT: - case ColorRenderTargetFormat::k_2_10_10_10_FLOAT_unknown: - internal_format = GL_RGB10_A2; - break; - case ColorRenderTargetFormat::k_16_16: - internal_format = GL_RG16; - break; - case ColorRenderTargetFormat::k_16_16_FLOAT: - internal_format = GL_RG16F; - break; - case ColorRenderTargetFormat::k_16_16_16_16: - internal_format = GL_RGBA16; - break; - case ColorRenderTargetFormat::k_16_16_16_16_FLOAT: - internal_format = GL_RGBA16F; - break; - case ColorRenderTargetFormat::k_32_FLOAT: - internal_format = GL_R32F; - break; - case ColorRenderTargetFormat::k_32_32_FLOAT: - internal_format = GL_RG32F; - break; - default: - assert_unhandled_case(format); - return 0; - } - - for (auto it = cached_color_render_targets_.begin(); - it != cached_color_render_targets_.end(); ++it) { - if (it->base == base && it->width == width && it->height == height && - it->internal_format == internal_format) { - return it->texture; - } - } - cached_color_render_targets_.push_back(CachedColorRenderTarget()); - auto cached = &cached_color_render_targets_.back(); - cached->base = base; - cached->width = width; - cached->height = height; - cached->format = format; - cached->internal_format = internal_format; - - glCreateTextures(GL_TEXTURE_2D, 1, &cached->texture); - glTextureStorage2D(cached->texture, 1, internal_format, width, height); - - return cached->texture; -} - -GLuint GL4CommandProcessor::GetDepthRenderTarget( - uint32_t pitch, MsaaSamples samples, uint32_t base, - DepthRenderTargetFormat format) { - uint32_t width = 2560; - uint32_t height = 2560; - - GLenum internal_format; - switch (format) { - case DepthRenderTargetFormat::kD24S8: - internal_format = GL_DEPTH24_STENCIL8; - break; - case DepthRenderTargetFormat::kD24FS8: - // TODO(benvanik): not supported in GL? - internal_format = GL_DEPTH24_STENCIL8; - break; - default: - assert_unhandled_case(format); - return 0; - } - - for (auto it = cached_depth_render_targets_.begin(); - it != cached_depth_render_targets_.end(); ++it) { - if (it->base == base && it->width == width && it->height == height && - it->format == format) { - return it->texture; - } - } - cached_depth_render_targets_.push_back(CachedDepthRenderTarget()); - auto cached = &cached_depth_render_targets_.back(); - cached->base = base; - cached->width = width; - cached->height = height; - cached->format = format; - cached->internal_format = internal_format; - - glCreateTextures(GL_TEXTURE_2D, 1, &cached->texture); - glTextureStorage2D(cached->texture, 1, internal_format, width, height); - - return cached->texture; -} - -GL4CommandProcessor::CachedFramebuffer* GL4CommandProcessor::GetFramebuffer( - GLuint color_targets[4], GLuint depth_target) { - for (auto it = cached_framebuffers_.begin(); it != cached_framebuffers_.end(); - ++it) { - if ((depth_target == kAnyTarget || it->depth_target == depth_target) && - (color_targets[0] == kAnyTarget || - it->color_targets[0] == color_targets[0]) && - (color_targets[1] == kAnyTarget || - it->color_targets[1] == color_targets[1]) && - (color_targets[2] == kAnyTarget || - it->color_targets[2] == color_targets[2]) && - (color_targets[3] == kAnyTarget || - it->color_targets[3] == color_targets[3])) { - return &*it; - } - } - - GLuint real_color_targets[4]; - bool any_set = false; - for (int i = 0; i < 4; ++i) { - if (color_targets[i] == kAnyTarget) { - real_color_targets[i] = 0; - } else { - any_set = true; - real_color_targets[i] = color_targets[i]; - } - } - GLuint real_depth_target; - if (depth_target == kAnyTarget) { - real_depth_target = 0; - } else { - any_set = true; - real_depth_target = depth_target; - } - if (!any_set) { - // No framebuffer required. - return nullptr; - } - - cached_framebuffers_.push_back(CachedFramebuffer()); - auto cached = &cached_framebuffers_.back(); - glCreateFramebuffers(1, &cached->framebuffer); - for (int i = 0; i < 4; ++i) { - cached->color_targets[i] = real_color_targets[i]; - glNamedFramebufferTexture(cached->framebuffer, GL_COLOR_ATTACHMENT0 + i, - real_color_targets[i], 0); - } - cached->depth_target = real_depth_target; - glNamedFramebufferTexture(cached->framebuffer, GL_DEPTH_STENCIL_ATTACHMENT, - real_depth_target, 0); - - return cached; -} - -} // namespace gl4 -} // namespace gpu -} // namespace xe diff --git a/src/xenia/gpu/gl4/gl4_command_processor.h b/src/xenia/gpu/gl4/gl4_command_processor.h deleted file mode 100644 index e3f45c9eb..000000000 --- a/src/xenia/gpu/gl4/gl4_command_processor.h +++ /dev/null @@ -1,237 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_GPU_GL4_GL4_COMMAND_PROCESSOR_H_ -#define XENIA_GPU_GL4_GL4_COMMAND_PROCESSOR_H_ - -#include <atomic> -#include <cstring> -#include <functional> -#include <memory> -#include <mutex> -#include <queue> -#include <string> -#include <unordered_map> -#include <vector> - -#include "xenia/base/threading.h" -#include "xenia/gpu/command_processor.h" -#include "xenia/gpu/gl4/draw_batcher.h" -#include "xenia/gpu/gl4/gl4_shader.h" -#include "xenia/gpu/gl4/gl4_shader_cache.h" -#include "xenia/gpu/gl4/texture_cache.h" -#include "xenia/gpu/glsl_shader_translator.h" -#include "xenia/gpu/register_file.h" -#include "xenia/gpu/xenos.h" -#include "xenia/kernel/xthread.h" -#include "xenia/memory.h" -#include "xenia/ui/gl/circular_buffer.h" -#include "xenia/ui/gl/gl_context.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -class GL4GraphicsSystem; - -class GL4CommandProcessor : public CommandProcessor { - public: - GL4CommandProcessor(GL4GraphicsSystem* graphics_system, - kernel::KernelState* kernel_state); - ~GL4CommandProcessor() override; - - void ClearCaches() override; - - // HACK: for debugging; would be good to have this in a base type. - TextureCache* texture_cache() { return &texture_cache_; } - DrawBatcher* draw_batcher() { return &draw_batcher_; } - - GLuint GetColorRenderTarget(uint32_t pitch, MsaaSamples samples, - uint32_t base, ColorRenderTargetFormat format); - GLuint GetDepthRenderTarget(uint32_t pitch, MsaaSamples samples, - uint32_t base, DepthRenderTargetFormat format); - - private: - enum class UpdateStatus { - kCompatible, - kMismatch, - kError, - }; - - struct CachedFramebuffer { - GLuint color_targets[4]; - GLuint depth_target; - GLuint framebuffer; - }; - struct CachedColorRenderTarget { - uint32_t base; - uint32_t width; - uint32_t height; - ColorRenderTargetFormat format; - GLenum internal_format; - GLuint texture; - }; - struct CachedDepthRenderTarget { - uint32_t base; - uint32_t width; - uint32_t height; - DepthRenderTargetFormat format; - GLenum internal_format; - GLuint texture; - }; - struct CachedPipeline { - CachedPipeline(); - ~CachedPipeline(); - GLuint vertex_program; - GLuint fragment_program; - struct { - GLuint default_pipeline; - GLuint point_list_pipeline; - GLuint rect_list_pipeline; - GLuint quad_list_pipeline; - GLuint line_quad_list_pipeline; - // TODO(benvanik): others with geometry shaders. - } handles; - }; - - bool SetupContext() override; - void ShutdownContext() override; - GLuint CreateGeometryProgram(const std::string& source); - - void MakeCoherent() override; - void PrepareForWait() override; - void ReturnFromWait() override; - - void PerformSwap(uint32_t frontbuffer_ptr, uint32_t frontbuffer_width, - uint32_t frontbuffer_height) override; - - Shader* LoadShader(ShaderType shader_type, uint32_t guest_address, - const uint32_t* host_address, - uint32_t dword_count) override; - - bool IssueDraw(PrimitiveType prim_type, uint32_t index_count, - IndexBufferInfo* index_buffer_info) override; - UpdateStatus UpdateShaders(PrimitiveType prim_type); - UpdateStatus UpdateRenderTargets(); - UpdateStatus UpdateState(PrimitiveType prim_type); - UpdateStatus UpdateViewportState(); - UpdateStatus UpdateRasterizerState(PrimitiveType prim_type); - UpdateStatus UpdateBlendState(); - UpdateStatus UpdateDepthStencilState(); - UpdateStatus PopulateIndexBuffer(IndexBufferInfo* index_buffer_info); - UpdateStatus PopulateVertexBuffers(); - UpdateStatus PopulateSamplers(); - UpdateStatus PopulateSampler(const Shader::TextureBinding& texture_binding); - bool IssueCopy() override; - - CachedFramebuffer* GetFramebuffer(GLuint color_targets[4], - GLuint depth_target); - - GlslShaderTranslator shader_translator_; - GL4ShaderCache shader_cache_; - CachedFramebuffer* active_framebuffer_ = nullptr; - GLuint last_framebuffer_texture_ = 0; - - std::vector<CachedFramebuffer> cached_framebuffers_; - std::vector<CachedColorRenderTarget> cached_color_render_targets_; - std::vector<CachedDepthRenderTarget> cached_depth_render_targets_; - std::vector<std::unique_ptr<CachedPipeline>> all_pipelines_; - std::unordered_map<uint64_t, CachedPipeline*> cached_pipelines_; - GLuint point_list_geometry_program_ = 0; - GLuint rect_list_geometry_program_ = 0; - GLuint quad_list_geometry_program_ = 0; - GLuint line_quad_list_geometry_program_ = 0; - - TextureCache texture_cache_; - - DrawBatcher draw_batcher_; - xe::ui::gl::CircularBuffer scratch_buffer_; - - private: - bool SetShadowRegister(uint32_t* dest, uint32_t register_name); - bool SetShadowRegister(float* dest, uint32_t register_name); - struct UpdateRenderTargetsRegisters { - uint32_t rb_modecontrol; - uint32_t rb_surface_info; - uint32_t rb_color_info; - uint32_t rb_color1_info; - uint32_t rb_color2_info; - uint32_t rb_color3_info; - uint32_t rb_color_mask; - uint32_t rb_depthcontrol; - uint32_t rb_stencilrefmask; - uint32_t rb_depth_info; - - UpdateRenderTargetsRegisters() { Reset(); } - void Reset() { std::memset(this, 0, sizeof(*this)); } - } update_render_targets_regs_; - struct UpdateViewportStateRegisters { - // uint32_t pa_cl_clip_cntl; - uint32_t rb_surface_info; - uint32_t pa_cl_vte_cntl; - uint32_t pa_su_sc_mode_cntl; - uint32_t pa_sc_window_offset; - uint32_t pa_sc_window_scissor_tl; - uint32_t pa_sc_window_scissor_br; - float pa_cl_vport_xoffset; - float pa_cl_vport_yoffset; - float pa_cl_vport_zoffset; - float pa_cl_vport_xscale; - float pa_cl_vport_yscale; - float pa_cl_vport_zscale; - - UpdateViewportStateRegisters() { Reset(); } - void Reset() { std::memset(this, 0, sizeof(*this)); } - } update_viewport_state_regs_; - struct UpdateRasterizerStateRegisters { - uint32_t pa_su_sc_mode_cntl; - uint32_t pa_sc_screen_scissor_tl; - uint32_t pa_sc_screen_scissor_br; - uint32_t multi_prim_ib_reset_index; - uint32_t pa_sc_viz_query; - PrimitiveType prim_type; - - UpdateRasterizerStateRegisters() { Reset(); } - void Reset() { std::memset(this, 0, sizeof(*this)); } - } update_rasterizer_state_regs_; - struct UpdateBlendStateRegisters { - uint32_t rb_blendcontrol[4]; - float rb_blend_rgba[4]; - - UpdateBlendStateRegisters() { Reset(); } - void Reset() { std::memset(this, 0, sizeof(*this)); } - } update_blend_state_regs_; - struct UpdateDepthStencilStateRegisters { - uint32_t rb_depthcontrol; - uint32_t rb_stencilrefmask; - - UpdateDepthStencilStateRegisters() { Reset(); } - void Reset() { std::memset(this, 0, sizeof(*this)); } - } update_depth_stencil_state_regs_; - struct UpdateShadersRegisters { - PrimitiveType prim_type; - uint32_t pa_su_sc_mode_cntl; - uint32_t sq_program_cntl; - uint32_t sq_context_misc; - GL4Shader* vertex_shader; - GL4Shader* pixel_shader; - - UpdateShadersRegisters() { Reset(); } - void Reset() { - sq_program_cntl = 0; - vertex_shader = pixel_shader = nullptr; - } - } update_shaders_regs_; -}; - -} // namespace gl4 -} // namespace gpu -} // namespace xe - -#endif // XENIA_GPU_GL4_GL4_COMMAND_PROCESSOR_H_ diff --git a/src/xenia/gpu/gl4/gl4_gpu_flags.cc b/src/xenia/gpu/gl4/gl4_gpu_flags.cc deleted file mode 100644 index 3844bfc95..000000000 --- a/src/xenia/gpu/gl4/gl4_gpu_flags.cc +++ /dev/null @@ -1,17 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/gpu/gl4/gl4_gpu_flags.h" - -DEFINE_bool(disable_framebuffer_readback, false, - "Disable framebuffer readback."); -DEFINE_bool(disable_textures, false, "Disable textures and use colors only."); -DEFINE_string(shader_cache_dir, "", - "GL4 Shader cache directory (relative to Xenia). Specify an " - "empty string to disable the cache."); diff --git a/src/xenia/gpu/gl4/gl4_gpu_flags.h b/src/xenia/gpu/gl4/gl4_gpu_flags.h deleted file mode 100644 index 9f68287f9..000000000 --- a/src/xenia/gpu/gl4/gl4_gpu_flags.h +++ /dev/null @@ -1,21 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2013 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_GPU_GL4_GL4_GPU_FLAGS_H_ -#define XENIA_GPU_GL4_GL4_GPU_FLAGS_H_ - -#include <gflags/gflags.h> - -DECLARE_bool(disable_framebuffer_readback); -DECLARE_bool(disable_textures); -DECLARE_string(shader_cache_dir); - -#define FINE_GRAINED_DRAW_SCOPES 0 - -#endif // XENIA_GPU_GL4_GL4_GPU_FLAGS_H_ diff --git a/src/xenia/gpu/gl4/gl4_graphics_system.cc b/src/xenia/gpu/gl4/gl4_graphics_system.cc deleted file mode 100644 index efca2fa08..000000000 --- a/src/xenia/gpu/gl4/gl4_graphics_system.cc +++ /dev/null @@ -1,86 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/gpu/gl4/gl4_graphics_system.h" - -#include <algorithm> -#include <cstring> - -#include "xenia/base/logging.h" -#include "xenia/base/profiling.h" -#include "xenia/cpu/processor.h" -#include "xenia/gpu/gl4/gl4_command_processor.h" -#include "xenia/gpu/gl4/gl4_gpu_flags.h" -#include "xenia/gpu/gpu_flags.h" -#include "xenia/ui/gl/gl_provider.h" -#include "xenia/ui/window.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -GL4GraphicsSystem::GL4GraphicsSystem() = default; - -GL4GraphicsSystem::~GL4GraphicsSystem() = default; - -X_STATUS GL4GraphicsSystem::Setup(cpu::Processor* processor, - kernel::KernelState* kernel_state, - ui::Window* target_window) { - // Must create the provider so we can create contexts. - provider_ = xe::ui::gl::GLProvider::Create(target_window); - - auto result = GraphicsSystem::Setup(processor, kernel_state, target_window); - if (result) { - return result; - } - - display_context_ = - reinterpret_cast<xe::ui::gl::GLContext*>(target_window->context()); - - return X_STATUS_SUCCESS; -} - -void GL4GraphicsSystem::Shutdown() { GraphicsSystem::Shutdown(); } - -std::unique_ptr<CommandProcessor> GL4GraphicsSystem::CreateCommandProcessor() { - return std::unique_ptr<CommandProcessor>( - new GL4CommandProcessor(this, kernel_state_)); -} - -void GL4GraphicsSystem::Swap(xe::ui::UIEvent* e) { - if (!command_processor_) { - return; - } - // Check for pending swap. - auto& swap_state = command_processor_->swap_state(); - { - std::lock_guard<std::mutex> lock(swap_state.mutex); - if (swap_state.pending) { - swap_state.pending = false; - std::swap(swap_state.front_buffer_texture, - swap_state.back_buffer_texture); - } - } - - if (!swap_state.front_buffer_texture) { - // Not yet ready. - return; - } - - // Blit the frontbuffer. - display_context_->blitter()->BlitTexture2D( - static_cast<GLuint>(swap_state.front_buffer_texture), - Rect2D(0, 0, swap_state.width, swap_state.height), - Rect2D(0, 0, target_window_->width(), target_window_->height()), - GL_LINEAR, false); -} - -} // namespace gl4 -} // namespace gpu -} // namespace xe diff --git a/src/xenia/gpu/gl4/gl4_graphics_system.h b/src/xenia/gpu/gl4/gl4_graphics_system.h deleted file mode 100644 index 9644db075..000000000 --- a/src/xenia/gpu/gl4/gl4_graphics_system.h +++ /dev/null @@ -1,45 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_GPU_GL4_GL4_GRAPHICS_SYSTEM_H_ -#define XENIA_GPU_GL4_GL4_GRAPHICS_SYSTEM_H_ - -#include <memory> - -#include "xenia/gpu/graphics_system.h" -#include "xenia/ui/gl/gl_context.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -class GL4GraphicsSystem : public GraphicsSystem { - public: - GL4GraphicsSystem(); - ~GL4GraphicsSystem() override; - - std::wstring name() const override { return L"GL4"; } - - X_STATUS Setup(cpu::Processor* processor, kernel::KernelState* kernel_state, - ui::Window* target_window) override; - void Shutdown() override; - - private: - std::unique_ptr<CommandProcessor> CreateCommandProcessor() override; - - void Swap(xe::ui::UIEvent* e) override; - - xe::ui::gl::GLContext* display_context_ = nullptr; -}; - -} // namespace gl4 -} // namespace gpu -} // namespace xe - -#endif // XENIA_GPU_GL4_GL4_GRAPHICS_SYSTEM_H_ diff --git a/src/xenia/gpu/gl4/gl4_shader.cc b/src/xenia/gpu/gl4/gl4_shader.cc deleted file mode 100644 index 7f34b1957..000000000 --- a/src/xenia/gpu/gl4/gl4_shader.cc +++ /dev/null @@ -1,298 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/gpu/gl4/gl4_shader.h" - -#include "xenia/base/logging.h" -#include "xenia/base/math.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -GL4Shader::GL4Shader(ShaderType shader_type, uint64_t data_hash, - const uint32_t* dword_ptr, uint32_t dword_count) - : Shader(shader_type, data_hash, dword_ptr, dword_count) {} - -GL4Shader::~GL4Shader() { - glDeleteProgram(program_); - glDeleteVertexArrays(1, &vao_); -} - -bool GL4Shader::Prepare() { - // Build static vertex array descriptor. - if (!PrepareVertexArrayObject()) { - XELOGE("Unable to prepare vertex shader array object"); - return false; - } - - bool success = true; - if (!CompileShader()) { - host_error_log_ = GetShaderInfoLog(); - success = false; - } - if (success && !LinkProgram()) { - host_error_log_ = GetProgramInfoLog(); - success = false; - } - - if (success) { - host_binary_ = GetBinary(); - host_disassembly_ = GetHostDisasmNV(host_binary_); - } - is_valid_ = success; - - return success; -} - -bool GL4Shader::LoadFromBinary(const uint8_t* blob, GLenum binary_format, - size_t length) { - program_ = glCreateProgram(); - glProgramBinary(program_, binary_format, blob, GLsizei(length)); - - GLint link_status = 0; - glGetProgramiv(program_, GL_LINK_STATUS, &link_status); - if (!link_status) { - // Failed to link. Not fatal - just clean up so we can get generated later. - XELOGD("GL4Shader::LoadFromBinary failed. Log:\n%s", - GetProgramInfoLog().c_str()); - glDeleteProgram(program_); - program_ = 0; - - return false; - } - - // Build static vertex array descriptor. - if (!PrepareVertexArrayObject()) { - XELOGE("Unable to prepare vertex shader array object"); - return false; - } - - // Success! - host_binary_ = GetBinary(); - host_disassembly_ = GetHostDisasmNV(host_binary_); - - is_valid_ = true; - return true; -} - -bool GL4Shader::PrepareVertexArrayObject() { - glCreateVertexArrays(1, &vao_); - - for (const auto& vertex_binding : vertex_bindings()) { - for (const auto& attrib : vertex_binding.attributes) { - auto comp_count = GetVertexFormatComponentCount( - attrib.fetch_instr.attributes.data_format); - GLenum comp_type = 0; - bool is_signed = attrib.fetch_instr.attributes.is_signed; - switch (attrib.fetch_instr.attributes.data_format) { - case VertexFormat::k_8_8_8_8: - comp_type = is_signed ? GL_BYTE : GL_UNSIGNED_BYTE; - break; - case VertexFormat::k_2_10_10_10: - comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT; - comp_count = 1; - break; - case VertexFormat::k_10_11_11: - comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT; - comp_count = 1; - break; - case VertexFormat::k_11_11_10: - assert_true(is_signed); - comp_type = is_signed ? GL_R11F_G11F_B10F : 0; - break; - case VertexFormat::k_16_16: - comp_type = is_signed ? GL_SHORT : GL_UNSIGNED_SHORT; - break; - case VertexFormat::k_16_16_FLOAT: - comp_type = GL_HALF_FLOAT; - break; - case VertexFormat::k_16_16_16_16: - comp_type = is_signed ? GL_SHORT : GL_UNSIGNED_SHORT; - break; - case VertexFormat::k_16_16_16_16_FLOAT: - comp_type = GL_HALF_FLOAT; - break; - case VertexFormat::k_32: - comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT; - break; - case VertexFormat::k_32_32: - comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT; - break; - case VertexFormat::k_32_32_32_32: - comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT; - break; - case VertexFormat::k_32_FLOAT: - comp_type = GL_FLOAT; - break; - case VertexFormat::k_32_32_FLOAT: - comp_type = GL_FLOAT; - break; - case VertexFormat::k_32_32_32_FLOAT: - comp_type = GL_FLOAT; - break; - case VertexFormat::k_32_32_32_32_FLOAT: - comp_type = GL_FLOAT; - break; - default: - assert_unhandled_case(attrib.fetch_instr.attributes.data_format); - return false; - } - - glEnableVertexArrayAttrib(vao_, attrib.attrib_index); - glVertexArrayAttribBinding(vao_, attrib.attrib_index, - vertex_binding.binding_index); - glVertexArrayAttribFormat(vao_, attrib.attrib_index, comp_count, - comp_type, - !attrib.fetch_instr.attributes.is_integer, - attrib.fetch_instr.attributes.offset * 4); - } - } - - return true; -} - -bool GL4Shader::CompileShader() { - assert_zero(program_); - - shader_ = - glCreateShader(shader_type_ == ShaderType::kVertex ? GL_VERTEX_SHADER - : GL_FRAGMENT_SHADER); - if (!shader_) { - XELOGE("OpenGL could not create a shader object!"); - return false; - } - - auto source_str = GetTranslatedBinaryString(); - auto source_str_ptr = source_str.c_str(); - GLint source_length = GLint(source_str.length()); - glShaderSource(shader_, 1, &source_str_ptr, &source_length); - glCompileShader(shader_); - - GLint status = 0; - glGetShaderiv(shader_, GL_COMPILE_STATUS, &status); - - return status == GL_TRUE; -} - -bool GL4Shader::LinkProgram() { - program_ = glCreateProgram(); - if (!program_) { - XELOGE("OpenGL could not create a shader program!"); - return false; - } - - glAttachShader(program_, shader_); - - // Enable TFB - if (shader_type_ == ShaderType::kVertex) { - const GLchar* feedbackVaryings = "gl_Position"; - glTransformFeedbackVaryings(program_, 1, &feedbackVaryings, - GL_SEPARATE_ATTRIBS); - } - - glProgramParameteri(program_, GL_PROGRAM_SEPARABLE, GL_TRUE); - glLinkProgram(program_); - - GLint link_status = 0; - glGetProgramiv(program_, GL_LINK_STATUS, &link_status); - if (!link_status) { - assert_always("Unable to link generated shader"); - return false; - } - - return true; -} - -std::string GL4Shader::GetShaderInfoLog() { - if (!shader_) { - return "GL4Shader::GetShaderInfoLog(): Program is NULL"; - } - - std::string log; - GLint log_length = 0; - glGetShaderiv(shader_, GL_INFO_LOG_LENGTH, &log_length); - if (log_length > 0) { - log.resize(log_length - 1); - glGetShaderInfoLog(shader_, log_length, &log_length, &log[0]); - } - - return log; -} - -std::string GL4Shader::GetProgramInfoLog() { - if (!program_) { - return "GL4Shader::GetProgramInfoLog(): Program is NULL"; - } - - std::string log; - GLint log_length = 0; - glGetProgramiv(program_, GL_INFO_LOG_LENGTH, &log_length); - if (log_length > 0) { - log.resize(log_length - 1); - glGetProgramInfoLog(program_, log_length, &log_length, &log[0]); - } - - return log; -} - -std::vector<uint8_t> GL4Shader::GetBinary(GLenum* binary_format) { - std::vector<uint8_t> binary; - - // Get program binary, if it's available. - GLint binary_length = 0; - glGetProgramiv(program_, GL_PROGRAM_BINARY_LENGTH, &binary_length); - if (binary_length) { - binary.resize(binary_length); - GLenum binary_format_tmp = 0; - glGetProgramBinary(program_, binary_length, &binary_length, - &binary_format_tmp, binary.data()); - - if (binary_format) { - *binary_format = binary_format_tmp; - } - } - - return binary; -} - -std::string GL4Shader::GetHostDisasmNV(const std::vector<uint8_t>& binary) { - // If we are on nvidia, we can find the disassembly string. - // I haven't been able to figure out from the format how to do this - // without a search like this. - std::string disasm; - - const char* disasm_start = nullptr; - size_t search_offset = 0; - const char* search_start = reinterpret_cast<const char*>(binary.data()); - while (true) { - auto p = reinterpret_cast<const char*>(memchr( - binary.data() + search_offset, '!', binary.size() - search_offset)); - if (!p) { - break; - } - if (p[0] == '!' && p[1] == '!' && p[2] == 'N' && p[3] == 'V') { - disasm_start = p; - break; - } - search_offset = p - search_start; - ++search_offset; - } - if (disasm_start) { - disasm = std::string(disasm_start); - } else { - disasm = std::string("Shader disassembly not available."); - } - - return disasm; -} - -} // namespace gl4 -} // namespace gpu -} // namespace xe diff --git a/src/xenia/gpu/gl4/gl4_shader.h b/src/xenia/gpu/gl4/gl4_shader.h deleted file mode 100644 index 1f884ebf2..000000000 --- a/src/xenia/gpu/gl4/gl4_shader.h +++ /dev/null @@ -1,54 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_GPU_GL4_GL4_SHADER_H_ -#define XENIA_GPU_GL4_GL4_SHADER_H_ - -#include <string> - -#include "xenia/gpu/shader.h" -#include "xenia/ui/gl/gl_context.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -class GL4Shader : public Shader { - public: - GL4Shader(ShaderType shader_type, uint64_t data_hash, - const uint32_t* dword_ptr, uint32_t dword_count); - ~GL4Shader() override; - - GLuint program() const { return program_; } - GLuint shader() const { return shader_; } - GLuint vao() const { return vao_; } - - bool Prepare(); - bool LoadFromBinary(const uint8_t* blob, GLenum binary_format, size_t length); - std::vector<uint8_t> GetBinary(GLenum* binary_format = nullptr); - - protected: - bool PrepareVertexArrayObject(); - bool CompileShader(); - bool LinkProgram(); - - std::string GetShaderInfoLog(); - std::string GetProgramInfoLog(); - static std::string GetHostDisasmNV(const std::vector<uint8_t>& binary); - - GLuint program_ = 0; - GLuint shader_ = 0; - GLuint vao_ = 0; -}; - -} // namespace gl4 -} // namespace gpu -} // namespace xe - -#endif // XENIA_GPU_GL4_GL4_SHADER_H_ diff --git a/src/xenia/gpu/gl4/gl4_shader_cache.cc b/src/xenia/gpu/gl4/gl4_shader_cache.cc deleted file mode 100644 index 714de3e1d..000000000 --- a/src/xenia/gpu/gl4/gl4_shader_cache.cc +++ /dev/null @@ -1,187 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2016 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/gpu/gl4/gl4_shader_cache.h" - -#include <cinttypes> - -#include "xenia/base/filesystem.h" -#include "xenia/base/logging.h" -#include "xenia/base/mapped_memory.h" -#include "xenia/gpu/gl4/gl4_gpu_flags.h" -#include "xenia/gpu/gl4/gl4_shader.h" -#include "xenia/gpu/glsl_shader_translator.h" -#include "xenia/gpu/gpu_flags.h" - -#include "third_party/xxhash/xxhash.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -GL4ShaderCache::GL4ShaderCache(GlslShaderTranslator* shader_translator) - : shader_translator_(shader_translator) {} - -GL4ShaderCache::~GL4ShaderCache() {} - -void GL4ShaderCache::Reset() { - shader_map_.clear(); - all_shaders_.clear(); -} - -GL4Shader* GL4ShaderCache::LookupOrInsertShader(ShaderType shader_type, - const uint32_t* dwords, - uint32_t dword_count) { - // Hash the input memory and lookup the shader. - GL4Shader* shader_ptr = nullptr; - uint64_t hash = XXH64(dwords, dword_count * sizeof(uint32_t), 0); - auto it = shader_map_.find(hash); - if (it != shader_map_.end()) { - // Shader has been previously loaded. - // TODO(benvanik): compare bytes? Likelihood of collision is low. - shader_ptr = it->second; - } else { - // Check filesystem cache. - shader_ptr = FindCachedShader(shader_type, hash, dwords, dword_count); - if (shader_ptr) { - // Found! - XELOGGPU("Loaded %s shader from cache (hash: %.16" PRIX64 ")", - shader_type == ShaderType::kVertex ? "vertex" : "pixel", hash); - return shader_ptr; - } - - // Not found in cache - load from scratch. - auto shader = - std::make_unique<GL4Shader>(shader_type, hash, dwords, dword_count); - shader_ptr = shader.get(); - shader_map_.insert({hash, shader_ptr}); - all_shaders_.emplace_back(std::move(shader)); - - // Perform translation. - // If this fails the shader will be marked as invalid and ignored later. - if (shader_translator_->Translate(shader_ptr)) { - shader_ptr->Prepare(); - if (shader_ptr->is_valid()) { - CacheShader(shader_ptr); - - XELOGGPU("Generated %s shader at 0x%.16" PRIX64 " (%db):\n%s", - shader_type == ShaderType::kVertex ? "vertex" : "pixel", - dwords, dword_count * 4, - shader_ptr->ucode_disassembly().c_str()); - } - - // Dump shader files if desired. - if (!FLAGS_dump_shaders.empty()) { - shader_ptr->Dump(FLAGS_dump_shaders, "gl4"); - } - } else { - XELOGE("Shader failed translation"); - } - } - - return shader_ptr; -} - -void GL4ShaderCache::CacheShader(GL4Shader* shader) { - if (FLAGS_shader_cache_dir.empty()) { - // Cache disabled. - return; - } - - GLenum binary_format = 0; - auto binary = shader->GetBinary(&binary_format); - if (binary.size() == 0) { - // No binary returned. - return; - } - - auto cache_dir = xe::to_absolute_path(xe::to_wstring(FLAGS_shader_cache_dir)); - xe::filesystem::CreateFolder(cache_dir); - auto filename = - cache_dir + xe::format_string( - L"%.16" PRIX64 ".%s", shader->ucode_data_hash(), - shader->type() == ShaderType::kPixel ? L"frag" : L"vert"); - auto file = xe::filesystem::OpenFile(filename, "wb"); - if (!file) { - // Not fatal, but not too good. - return; - } - - std::vector<uint8_t> cached_shader_mem; - // Resize this vector to the final filesize (- 1 to account for dummy array - // in CachedShader) - cached_shader_mem.resize(sizeof(CachedShader) + binary.size() - 1); - auto cached_shader = - reinterpret_cast<CachedShader*>(cached_shader_mem.data()); - cached_shader->magic = xe::byte_swap('XSHD'); - cached_shader->version = 0; // TODO - cached_shader->shader_type = uint8_t(shader->type()); - cached_shader->binary_len = uint32_t(binary.size()); - cached_shader->binary_format = binary_format; - std::memcpy(cached_shader->binary, binary.data(), binary.size()); - - fwrite(cached_shader_mem.data(), cached_shader_mem.size(), 1, file); - fclose(file); -} - -GL4Shader* GL4ShaderCache::FindCachedShader(ShaderType shader_type, - uint64_t hash, - const uint32_t* dwords, - uint32_t dword_count) { - if (FLAGS_shader_cache_dir.empty()) { - // Cache disabled. - return nullptr; - } - - auto cache_dir = xe::to_absolute_path(xe::to_wstring(FLAGS_shader_cache_dir)); - auto filename = - cache_dir + - xe::format_string(L"%.16" PRIX64 ".%s", hash, - shader_type == ShaderType::kPixel ? L"frag" : L"vert"); - if (!xe::filesystem::PathExists(filename)) { - return nullptr; - } - - // Shader is cached. Open it up. - auto map = xe::MappedMemory::Open(filename, MappedMemory::Mode::kRead); - if (!map) { - // Should not fail - assert_always(); - return nullptr; - } - - auto cached_shader = reinterpret_cast<CachedShader*>(map->data()); - // TODO: Compare versions - if (cached_shader->magic != xe::byte_swap('XSHD')) { - return nullptr; - } - - auto shader = - std::make_unique<GL4Shader>(shader_type, hash, dwords, dword_count); - - // Gather the binding points. - // TODO: Make Shader do this on construction. - // TODO: Regenerate microcode disasm/etc on load. - shader_translator_->GatherAllBindingInformation(shader.get()); - if (!shader->LoadFromBinary(cached_shader->binary, - cached_shader->binary_format, - cached_shader->binary_len)) { - // Failed to load from binary. - return nullptr; - } - - auto shader_ptr = shader.get(); - shader_map_.insert({hash, shader_ptr}); - all_shaders_.emplace_back(std::move(shader)); - return shader_ptr; -} - -} // namespace gl4 -} // namespace gpu -} // namespace xe diff --git a/src/xenia/gpu/gl4/gl4_shader_cache.h b/src/xenia/gpu/gl4/gl4_shader_cache.h deleted file mode 100644 index 9c5c77cb2..000000000 --- a/src/xenia/gpu/gl4/gl4_shader_cache.h +++ /dev/null @@ -1,62 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2016 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_GPU_GL4_SHADER_CACHE_H_ -#define XENIA_GPU_GL4_SHADER_CACHE_H_ - -#include <cstdint> -#include <cstring> -#include <memory> -#include <unordered_map> -#include <vector> - -#include "xenia/gpu/xenos.h" - -namespace xe { -namespace gpu { -class GlslShaderTranslator; - -namespace gl4 { - -class GL4Shader; - -class GL4ShaderCache { - public: - GL4ShaderCache(GlslShaderTranslator* shader_translator); - ~GL4ShaderCache(); - - void Reset(); - GL4Shader* LookupOrInsertShader(ShaderType shader_type, - const uint32_t* dwords, uint32_t dword_count); - - private: - // Cached shader file format. - struct CachedShader { - uint32_t magic; - uint32_t version; // Version of the shader translator used. - uint8_t shader_type; // ShaderType enum - uint32_t binary_len; // Code length - uint32_t binary_format; // Binary format (from OpenGL) - uint8_t binary[1]; // Code - }; - - void CacheShader(GL4Shader* shader); - GL4Shader* FindCachedShader(ShaderType shader_type, uint64_t hash, - const uint32_t* dwords, uint32_t dword_count); - - GlslShaderTranslator* shader_translator_ = nullptr; - std::vector<std::unique_ptr<GL4Shader>> all_shaders_; - std::unordered_map<uint64_t, GL4Shader*> shader_map_; -}; - -} // namespace gl4 -} // namespace gpu -} // namespace xe - -#endif // XENIA_GPU_GL4_SHADER_CACHE_H_ diff --git a/src/xenia/gpu/gl4/gl4_trace_viewer_main.cc b/src/xenia/gpu/gl4/gl4_trace_viewer_main.cc deleted file mode 100644 index c7d24001c..000000000 --- a/src/xenia/gpu/gl4/gl4_trace_viewer_main.cc +++ /dev/null @@ -1,109 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/base/logging.h" -#include "xenia/base/main.h" -#include "xenia/gpu/gl4/gl4_command_processor.h" -#include "xenia/gpu/gl4/gl4_graphics_system.h" -#include "xenia/gpu/trace_viewer.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -using namespace xe::gpu::xenos; - -class GL4TraceViewer : public TraceViewer { - public: - std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem() override { - return std::unique_ptr<gpu::GraphicsSystem>(new GL4GraphicsSystem()); - } - - uintptr_t GetColorRenderTarget(uint32_t pitch, MsaaSamples samples, - uint32_t base, - ColorRenderTargetFormat format) override { - auto command_processor = static_cast<GL4CommandProcessor*>( - graphics_system_->command_processor()); - return command_processor->GetColorRenderTarget(pitch, samples, base, - format); - } - - uintptr_t GetDepthRenderTarget(uint32_t pitch, MsaaSamples samples, - uint32_t base, - DepthRenderTargetFormat format) override { - auto command_processor = static_cast<GL4CommandProcessor*>( - graphics_system_->command_processor()); - return command_processor->GetDepthRenderTarget(pitch, samples, base, - format); - } - - uintptr_t GetTextureEntry(const TextureInfo& texture_info, - const SamplerInfo& sampler_info) override { - auto command_processor = static_cast<GL4CommandProcessor*>( - graphics_system_->command_processor()); - - auto entry_view = - command_processor->texture_cache()->Demand(texture_info, sampler_info); - if (!entry_view) { - return 0; - } - auto texture = entry_view->texture; - return static_cast<uintptr_t>(texture->handle); - } - - size_t QueryVSOutputSize() override { - auto command_processor = static_cast<GL4CommandProcessor*>( - graphics_system_->command_processor()); - auto draw_batcher = command_processor->draw_batcher(); - - return draw_batcher->QueryTFBSize(); - } - - size_t QueryVSOutputElementSize() override { - // vec4 always has 4 elements. - return 4; - } - - bool QueryVSOutput(void* buffer, size_t size) override { - auto command_processor = static_cast<GL4CommandProcessor*>( - graphics_system_->command_processor()); - auto draw_batcher = command_processor->draw_batcher(); - - return draw_batcher->ReadbackTFB(buffer, size); - } - - bool Setup() override { - if (!TraceViewer::Setup()) { - return false; - } - - // Enable TFB - auto command_processor = static_cast<GL4CommandProcessor*>( - graphics_system_->command_processor()); - auto draw_batcher = command_processor->draw_batcher(); - draw_batcher->set_tfb_enabled(true); - - return true; - } - - private: -}; - -int trace_viewer_main(const std::vector<std::wstring>& args) { - GL4TraceViewer trace_viewer; - return trace_viewer.Main(args); -} - -} // namespace gl4 -} // namespace gpu -} // namespace xe - -DEFINE_ENTRY_POINT(L"xenia-gpu-gl4-trace-viewer", - L"xenia-gpu-gl4-trace-viewer some.trace", - xe::gpu::gl4::trace_viewer_main); diff --git a/src/xenia/gpu/gl4/premake5.lua b/src/xenia/gpu/gl4/premake5.lua deleted file mode 100644 index 6c61b285a..000000000 --- a/src/xenia/gpu/gl4/premake5.lua +++ /dev/null @@ -1,88 +0,0 @@ -project_root = "../../../.." -include(project_root.."/tools/build") - -group("src") -project("xenia-gpu-gl4") - uuid("da10149d-efb0-44aa-924c-a76a46e1f04d") - kind("StaticLib") - language("C++") - links({ - "glew", - "xenia-base", - "xenia-gpu", - "xenia-ui", - "xenia-ui-gl", - "xxhash", - }) - defines({ - "GLEW_STATIC=1", - "GLEW_MX=1", - }) - includedirs({ - project_root.."/third_party/gflags/src", - }) - local_platform_files() - --- TODO(benvanik): kill this and move to the debugger UI. -group("src") -project("xenia-gpu-gl4-trace-viewer") - uuid("450f965b-a019-4ba5-bc6f-99901e5a4c8d") - kind("WindowedApp") - language("C++") - links({ - "capstone", - "gflags", - "glew", - "imgui", - "libavcodec", - "libavutil", - "snappy", - "xenia-apu", - "xenia-apu-nop", - "xenia-base", - "xenia-core", - "xenia-cpu", - "xenia-cpu-backend-x64", - "xenia-gpu", - "xenia-gpu-gl4", - "xenia-hid", - "xenia-hid-nop", - "xenia-kernel", - "xenia-ui", - "xenia-ui-gl", - "xenia-vfs", - "xxhash", - }) - flags({ - "WinMain", -- Use WinMain instead of main. - }) - defines({ - "GLEW_STATIC=1", - "GLEW_MX=1", - }) - includedirs({ - project_root.."/third_party/gflags/src", - }) - files({ - "gl4_trace_viewer_main.cc", - "../../base/main_"..platform_suffix..".cc", - }) - - filter("platforms:Windows") - links({ - "xenia-apu-xaudio2", - "xenia-hid-winkey", - "xenia-hid-xinput", - }) - - -- Only create the .user file if it doesn't already exist. - local user_file = project_root.."/build/xenia-gpu-gl4-trace-viewer.vcxproj.user" - if not os.isfile(user_file) then - debugdir(project_root) - debugargs({ - "--flagfile=scratch/flags.txt", - "2>&1", - "1>scratch/stdout-trace-viewer.txt", - }) - end -
\ No newline at end of file diff --git a/src/xenia/gpu/gl4/texture_cache.cc b/src/xenia/gpu/gl4/texture_cache.cc deleted file mode 100644 index affd012bd..000000000 --- a/src/xenia/gpu/gl4/texture_cache.cc +++ /dev/null @@ -1,1101 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/gpu/gl4/texture_cache.h" - -#include <algorithm> -#include <cstring> - -#include "xenia/base/assert.h" -#include "xenia/base/logging.h" -#include "xenia/base/math.h" -#include "xenia/base/memory.h" -#include "xenia/base/profiling.h" -#include "xenia/gpu/gpu_flags.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -struct TextureConfig { - TextureFormat texture_format; - GLenum internal_format; - GLenum format; - GLenum type; -}; - -// https://code.google.com/p/glsnewton/source/browse/trunk/Source/uDDSLoader.pas?r=62 -// http://dench.flatlib.jp/opengl/textures -// http://fossies.org/linux/WebKit/Source/ThirdParty/ANGLE/src/libGLESv2/formatutils.cpp -static const TextureConfig texture_configs[64] = { - {TextureFormat::k_1_REVERSE, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_1, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM}, - {TextureFormat::k_8, GL_R8, GL_RED, GL_UNSIGNED_BYTE}, - {TextureFormat::k_1_5_5_5, GL_RGB5_A1, GL_RGBA, - GL_UNSIGNED_SHORT_1_5_5_5_REV}, - {TextureFormat::k_5_6_5, GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV}, - {TextureFormat::k_6_5_5, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM}, - {TextureFormat::k_8_8_8_8, GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV}, - {TextureFormat::k_2_10_10_10, GL_RGB10_A2, GL_RGBA, - GL_UNSIGNED_INT_2_10_10_10_REV}, - {TextureFormat::k_8_A, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM}, - {TextureFormat::k_8_B, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM}, - {TextureFormat::k_8_8, GL_RG8, GL_RG, GL_UNSIGNED_BYTE}, - {TextureFormat::k_Cr_Y1_Cb_Y0, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_Y1_Cr_Y0_Cb, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::kUnknown, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_8_8_8_8_A, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_4_4_4_4, GL_RGBA4, GL_RGBA, - GL_UNSIGNED_SHORT_4_4_4_4_REV}, - {TextureFormat::k_10_11_11, GL_R11F_G11F_B10F, GL_RGB, - GL_UNSIGNED_INT_10F_11F_11F_REV}, // ? - {TextureFormat::k_11_11_10, GL_R11F_G11F_B10F, GL_RGB, - GL_UNSIGNED_INT_10F_11F_11F_REV}, // ? - {TextureFormat::k_DXT1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, - GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_UNSIGNED_BYTE}, - {TextureFormat::k_DXT2_3, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_UNSIGNED_BYTE}, - {TextureFormat::k_DXT4_5, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, - GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_UNSIGNED_BYTE}, - {TextureFormat::kUnknown, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_24_8, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, - GL_UNSIGNED_INT_24_8}, - {TextureFormat::k_24_8_FLOAT, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, - GL_FLOAT_32_UNSIGNED_INT_24_8_REV}, - {TextureFormat::k_16, GL_R16, GL_RED, GL_UNSIGNED_SHORT}, - {TextureFormat::k_16_16, GL_RG16, GL_RG, GL_UNSIGNED_SHORT}, - {TextureFormat::k_16_16_16_16, GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT}, - {TextureFormat::k_16_EXPAND, GL_R16, GL_RED, GL_UNSIGNED_SHORT}, - {TextureFormat::k_16_16_EXPAND, GL_RG16, GL_RG, GL_UNSIGNED_SHORT}, - {TextureFormat::k_16_16_16_16_EXPAND, GL_RGBA16, GL_RGBA, - GL_UNSIGNED_SHORT}, - {TextureFormat::k_16_FLOAT, GL_R16F, GL_RED, GL_HALF_FLOAT}, - {TextureFormat::k_16_16_FLOAT, GL_RG16F, GL_RG, GL_HALF_FLOAT}, - {TextureFormat::k_16_16_16_16_FLOAT, GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT}, - {TextureFormat::k_32, GL_R32I, GL_RED, GL_UNSIGNED_INT}, - {TextureFormat::k_32_32, GL_RG32I, GL_RG, GL_UNSIGNED_INT}, - {TextureFormat::k_32_32_32_32, GL_RGBA32I, GL_RGBA, GL_UNSIGNED_INT}, - {TextureFormat::k_32_FLOAT, GL_R32F, GL_RED, GL_FLOAT}, - {TextureFormat::k_32_32_FLOAT, GL_RG32F, GL_RG, GL_FLOAT}, - {TextureFormat::k_32_32_32_32_FLOAT, GL_RGBA32F, GL_RGBA, GL_FLOAT}, - {TextureFormat::k_32_AS_8, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_32_AS_8_8, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_16_MPEG, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_16_16_MPEG, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_8_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_32_AS_8_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_32_AS_8_8_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_16_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_16_MPEG_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_16_16_MPEG_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::k_DXN, GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_RG_RGTC2, - GL_INVALID_ENUM}, - {TextureFormat::k_8_8_8_8_AS_16_16_16_16, GL_RGBA8, GL_RGBA, - GL_UNSIGNED_BYTE}, - {TextureFormat::k_DXT1_AS_16_16_16_16, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, - GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_UNSIGNED_BYTE}, - {TextureFormat::k_DXT2_3_AS_16_16_16_16, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_UNSIGNED_BYTE}, - {TextureFormat::k_DXT4_5_AS_16_16_16_16, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, - GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_UNSIGNED_BYTE}, - {TextureFormat::k_2_10_10_10_AS_16_16_16_16, GL_RGB10_A2, GL_RGBA, - GL_UNSIGNED_INT_2_10_10_10_REV}, - {TextureFormat::k_10_11_11_AS_16_16_16_16, GL_R11F_G11F_B10F, GL_RGB, - GL_UNSIGNED_INT_10F_11F_11F_REV}, - {TextureFormat::k_11_11_10_AS_16_16_16_16, GL_R11F_G11F_B10F, - GL_INVALID_ENUM, GL_INVALID_ENUM}, - {TextureFormat::k_32_32_32_FLOAT, GL_RGB32F, GL_RGB, GL_FLOAT}, - {TextureFormat::k_DXT3A, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_UNSIGNED_BYTE}, - {TextureFormat::k_DXT5A, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, - GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_UNSIGNED_BYTE}, - {TextureFormat::k_CTX1, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM}, - {TextureFormat::k_DXT3A_AS_1_1_1_1, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::kUnknown, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, - {TextureFormat::kUnknown, GL_INVALID_ENUM, GL_INVALID_ENUM, - GL_INVALID_ENUM}, -}; - -TextureCache::TextureCache() : memory_(nullptr), scratch_buffer_(nullptr) { - invalidated_textures_sets_[0].reserve(64); - invalidated_textures_sets_[1].reserve(64); - invalidated_textures_ = &invalidated_textures_sets_[0]; -} - -TextureCache::~TextureCache() { Shutdown(); } - -bool TextureCache::Initialize(Memory* memory, CircularBuffer* scratch_buffer) { - memory_ = memory; - scratch_buffer_ = scratch_buffer; - return true; -} - -void TextureCache::Shutdown() { Clear(); } - -void TextureCache::Scavenge() { - invalidated_textures_mutex_.lock(); - std::vector<TextureEntry*>& invalidated_textures = *invalidated_textures_; - if (invalidated_textures_ == &invalidated_textures_sets_[0]) { - invalidated_textures_ = &invalidated_textures_sets_[1]; - } else { - invalidated_textures_ = &invalidated_textures_sets_[0]; - } - invalidated_textures_mutex_.unlock(); - if (invalidated_textures.empty()) { - return; - } - - for (auto& entry : invalidated_textures) { - EvictTexture(entry); - } - invalidated_textures.clear(); -} - -void TextureCache::Clear() { - EvictAllTextures(); - - // Samplers must go last, as textures depend on them. - while (sampler_entries_.size()) { - auto entry = sampler_entries_.begin()->second; - EvictSampler(entry); - } -} - -void TextureCache::EvictAllTextures() { - // Kill all textures - some may be in the eviction list, but that's fine - // as we will clear that below. - while (!texture_entries_.empty()) { - auto entry = texture_entries_.begin()->second; - EvictTexture(entry); - } - - { - std::lock_guard<std::mutex> lock(invalidated_textures_mutex_); - invalidated_textures_sets_[0].clear(); - invalidated_textures_sets_[1].clear(); - } - - // Kill all readbuffer textures. - while (!read_buffer_textures_.empty()) { - auto it = --read_buffer_textures_.end(); - auto entry = *it; - glDeleteTextures(1, &entry->handle); - delete entry; - read_buffer_textures_.erase(it); - } -} - -TextureCache::TextureEntryView* TextureCache::Demand( - const TextureInfo& texture_info, const SamplerInfo& sampler_info) { - uint64_t texture_hash = texture_info.hash(); - auto texture_entry = LookupOrInsertTexture(texture_info, texture_hash); - if (!texture_entry) { - XELOGE("Failed to setup texture"); - return nullptr; - } - - // We likely have the sampler in the texture view listing, so scan for it. - uint64_t sampler_hash = sampler_info.hash(); - for (auto& it : texture_entry->views) { - if (it->sampler_hash == sampler_hash) { - // Found. - return it.get(); - } - } - - // No existing view found - build it. - auto sampler_entry = LookupOrInsertSampler(sampler_info, sampler_hash); - if (!sampler_entry) { - XELOGE("Failed to setup texture sampler"); - return nullptr; - } - - auto view = std::make_unique<TextureEntryView>(); - view->texture = texture_entry; - view->sampler = sampler_entry; - view->sampler_hash = sampler_hash; - view->texture_sampler_handle = 0; - - // Get the uvec2 handle to the texture/sampler pair and make it resident. - // The handle can be passed directly to the shader. - view->texture_sampler_handle = glGetTextureSamplerHandleARB( - texture_entry->handle, sampler_entry->handle); - if (!view->texture_sampler_handle) { - assert_always("Unable to get texture handle?"); - return nullptr; - } - glMakeTextureHandleResidentARB(view->texture_sampler_handle); - - // Entry takes ownership. - auto view_ptr = view.get(); - texture_entry->views.push_back(std::move(view)); - return view_ptr; -} - -TextureCache::SamplerEntry* TextureCache::LookupOrInsertSampler( - const SamplerInfo& sampler_info, uint64_t opt_hash) { - const uint64_t hash = opt_hash ? opt_hash : sampler_info.hash(); - for (auto it = sampler_entries_.find(hash); it != sampler_entries_.end(); - ++it) { - if (it->second->sampler_info == sampler_info) { - // Found in cache! - return it->second; - } - } - - // Not found, create. - auto entry = std::make_unique<SamplerEntry>(); - entry->sampler_info = sampler_info; - glCreateSamplers(1, &entry->handle); - - // TODO(benvanik): border color from texture fetch. - GLfloat border_color[4] = {0.0f}; - glSamplerParameterfv(entry->handle, GL_TEXTURE_BORDER_COLOR, border_color); - - // TODO(benvanik): setup LODs for mipmapping. - glSamplerParameterf(entry->handle, GL_TEXTURE_LOD_BIAS, 0.0f); - glSamplerParameterf(entry->handle, GL_TEXTURE_MIN_LOD, 0.0f); - glSamplerParameterf(entry->handle, GL_TEXTURE_MAX_LOD, 0.0f); - - // Texture wrapping modes. - // TODO(benvanik): not sure if the middle ones are correct. - static const GLenum wrap_map[] = { - GL_REPEAT, // - GL_MIRRORED_REPEAT, // - GL_CLAMP_TO_EDGE, // - GL_MIRROR_CLAMP_TO_EDGE, // - GL_CLAMP_TO_BORDER, // ? - GL_MIRROR_CLAMP_TO_BORDER_EXT, // ? - GL_CLAMP_TO_BORDER, // - GL_MIRROR_CLAMP_TO_BORDER_EXT, // - }; - glSamplerParameteri(entry->handle, GL_TEXTURE_WRAP_S, - wrap_map[static_cast<int>(sampler_info.clamp_u)]); - glSamplerParameteri(entry->handle, GL_TEXTURE_WRAP_T, - wrap_map[static_cast<int>(sampler_info.clamp_v)]); - glSamplerParameteri(entry->handle, GL_TEXTURE_WRAP_R, - wrap_map[static_cast<int>(sampler_info.clamp_w)]); - - // Texture level filtering. - GLenum min_filter; - switch (sampler_info.min_filter) { - case TextureFilter::kPoint: - switch (sampler_info.mip_filter) { - case TextureFilter::kBaseMap: - min_filter = GL_NEAREST; - break; - case TextureFilter::kPoint: - // min_filter = GL_NEAREST_MIPMAP_NEAREST; - min_filter = GL_NEAREST; - break; - case TextureFilter::kLinear: - // min_filter = GL_NEAREST_MIPMAP_LINEAR; - min_filter = GL_NEAREST; - break; - default: - assert_unhandled_case(sampler_info.mip_filter); - return nullptr; - } - break; - case TextureFilter::kLinear: - switch (sampler_info.mip_filter) { - case TextureFilter::kBaseMap: - min_filter = GL_LINEAR; - break; - case TextureFilter::kPoint: - // min_filter = GL_LINEAR_MIPMAP_NEAREST; - min_filter = GL_LINEAR; - break; - case TextureFilter::kLinear: - // min_filter = GL_LINEAR_MIPMAP_LINEAR; - min_filter = GL_LINEAR; - break; - default: - assert_unhandled_case(sampler_info.mip_filter); - return nullptr; - } - break; - default: - assert_unhandled_case(sampler_info.min_filter); - return nullptr; - } - GLenum mag_filter; - switch (sampler_info.mag_filter) { - case TextureFilter::kPoint: - mag_filter = GL_NEAREST; - break; - case TextureFilter::kLinear: - mag_filter = GL_LINEAR; - break; - default: - assert_unhandled_case(mag_filter); - return nullptr; - } - glSamplerParameteri(entry->handle, GL_TEXTURE_MIN_FILTER, min_filter); - glSamplerParameteri(entry->handle, GL_TEXTURE_MAG_FILTER, mag_filter); - - GLfloat aniso; - switch (sampler_info.aniso_filter) { - case AnisoFilter::kDisabled: - aniso = 0.0f; - break; - case AnisoFilter::kMax_1_1: - aniso = 1.0f; - break; - case AnisoFilter::kMax_2_1: - aniso = 2.0f; - break; - case AnisoFilter::kMax_4_1: - aniso = 4.0f; - break; - case AnisoFilter::kMax_8_1: - aniso = 8.0f; - break; - case AnisoFilter::kMax_16_1: - aniso = 16.0f; - break; - default: - assert_unhandled_case(aniso); - return nullptr; - } - - if (aniso) { - glSamplerParameterf(entry->handle, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso); - } - - // Add to map - map takes ownership. - auto entry_ptr = entry.get(); - sampler_entries_.insert({hash, entry.release()}); - return entry_ptr; -} - -void TextureCache::EvictSampler(SamplerEntry* entry) { - glDeleteSamplers(1, &entry->handle); - - for (auto it = sampler_entries_.find(entry->sampler_info.hash()); - it != sampler_entries_.end(); ++it) { - if (it->second == entry) { - sampler_entries_.erase(it); - break; - } - } - - delete entry; -} - -TextureCache::TextureEntry* TextureCache::LookupOrInsertTexture( - const TextureInfo& texture_info, uint64_t opt_hash) { - const uint64_t hash = opt_hash ? opt_hash : texture_info.hash(); - for (auto it = texture_entries_.find(hash); it != texture_entries_.end(); - ++it) { - if (it->second->pending_invalidation) { - // Whoa, we've been invalidated! Let's scavenge to cleanup and try again. - // TODO(benvanik): reuse existing texture storage. - Scavenge(); - break; - } - if (it->second->texture_info == texture_info) { - // Found in cache! - return it->second; - } - } - - // Not found, create. - auto entry = std::make_unique<TextureEntry>(); - entry->texture_info = texture_info; - entry->access_watch_handle = 0; - entry->pending_invalidation = false; - entry->handle = 0; - - // Check read buffer textures - there may be one waiting for us. - // TODO(benvanik): speed up existence check? - for (auto it = read_buffer_textures_.begin(); - it != read_buffer_textures_.end(); ++it) { - auto read_buffer_entry = *it; - if (read_buffer_entry->guest_address == texture_info.guest_address && - read_buffer_entry->block_width == texture_info.size_2d.block_width && - read_buffer_entry->block_height == texture_info.size_2d.block_height) { - // Found! Acquire the handle and remove the readbuffer entry. - read_buffer_textures_.erase(it); - entry->handle = read_buffer_entry->handle; - entry->access_watch_handle = read_buffer_entry->access_watch_handle; - delete read_buffer_entry; - // TODO(benvanik): set more texture properties? swizzle/etc? - auto entry_ptr = entry.get(); - texture_entries_.insert({hash, entry.release()}); - return entry_ptr; - } - } - - GLenum target; - switch (texture_info.dimension) { - case Dimension::k1D: - target = GL_TEXTURE_1D; - break; - case Dimension::k2D: - target = GL_TEXTURE_2D; - break; - case Dimension::k3D: - target = GL_TEXTURE_3D; - break; - case Dimension::kCube: - target = GL_TEXTURE_CUBE_MAP; - break; - } - - // Setup the base texture. - glCreateTextures(target, 1, &entry->handle); - - // TODO(benvanik): texture mip levels. - glTextureParameteri(entry->handle, GL_TEXTURE_BASE_LEVEL, 0); - glTextureParameteri(entry->handle, GL_TEXTURE_MAX_LEVEL, 1); - - // Upload/convert. - bool uploaded = false; - switch (texture_info.dimension) { - case Dimension::k1D: - uploaded = UploadTexture1D(entry->handle, texture_info); - break; - case Dimension::k2D: - uploaded = UploadTexture2D(entry->handle, texture_info); - break; - case Dimension::kCube: - uploaded = UploadTextureCube(entry->handle, texture_info); - break; - case Dimension::k3D: - assert_unhandled_case(texture_info.dimension); - return nullptr; - } - if (!uploaded) { - XELOGE("Failed to convert/upload texture"); - return nullptr; - } - - // Add a write watch. If any data in the given range is touched we'll get a - // callback and evict the texture. We could reuse the storage, though the - // driver is likely in a better position to pool that kind of stuff. - entry->access_watch_handle = memory_->AddPhysicalAccessWatch( - texture_info.guest_address, texture_info.input_length, - cpu::MMIOHandler::kWatchWrite, - [](void* context_ptr, void* data_ptr, uint32_t address) { - auto self = reinterpret_cast<TextureCache*>(context_ptr); - auto touched_entry = reinterpret_cast<TextureEntry*>(data_ptr); - // Clear watch handle first so we don't redundantly - // remove. - touched_entry->access_watch_handle = 0; - touched_entry->pending_invalidation = true; - // Add to pending list so Scavenge will clean it up. - self->invalidated_textures_mutex_.lock(); - self->invalidated_textures_->push_back(touched_entry); - self->invalidated_textures_mutex_.unlock(); - }, - this, entry.get()); - - // Add to map - map takes ownership. - auto entry_ptr = entry.get(); - texture_entries_.insert({hash, entry.release()}); - return entry_ptr; -} - -TextureCache::TextureEntry* TextureCache::LookupAddress(uint32_t guest_address, - uint32_t width, - uint32_t height, - TextureFormat format) { - // TODO(benvanik): worth speeding up? - for (auto it = texture_entries_.begin(); it != texture_entries_.end(); ++it) { - const auto& texture_info = it->second->texture_info; - if (texture_info.guest_address == guest_address && - texture_info.dimension == Dimension::k2D && - texture_info.size_2d.input_width == width && - texture_info.size_2d.input_height == height) { - return it->second; - } - } - return nullptr; -} - -GLuint TextureCache::CopyTexture(Blitter* blitter, uint32_t guest_address, - uint32_t logical_width, - uint32_t logical_height, uint32_t block_width, - uint32_t block_height, TextureFormat format, - bool swap_channels, GLuint src_texture, - Rect2D src_rect, Rect2D dest_rect) { - return ConvertTexture(blitter, guest_address, logical_width, logical_height, - block_width, block_height, format, swap_channels, - src_texture, src_rect, dest_rect); -} - -GLuint TextureCache::ConvertTexture(Blitter* blitter, uint32_t guest_address, - uint32_t logical_width, - uint32_t logical_height, - uint32_t block_width, uint32_t block_height, - TextureFormat format, bool swap_channels, - GLuint src_texture, Rect2D src_rect, - Rect2D dest_rect) { - const auto& config = texture_configs[uint32_t(format)]; - if (config.format == GL_INVALID_ENUM) { - assert_always("Unhandled destination texture format"); - return 0; - } - - // See if we have used a texture at this address before. If we have, we can - // reuse it. - // TODO(benvanik): better lookup matching format/etc? - auto texture_entry = - LookupAddress(guest_address, block_width, block_height, format); - if (texture_entry) { - // Have existing texture. - assert_false(texture_entry->pending_invalidation); - if (config.format == GL_DEPTH_STENCIL) { - blitter->CopyDepthTexture(src_texture, src_rect, texture_entry->handle, - dest_rect); - } else { - blitter->CopyColorTexture2D(src_texture, src_rect, texture_entry->handle, - dest_rect, GL_LINEAR, swap_channels); - } - - // Setup a read/write access watch. If the game tries to touch the memory - // we were supposed to populate with this texture, then we'll actually - // populate it. - if (texture_entry->access_watch_handle) { - memory_->CancelAccessWatch(texture_entry->access_watch_handle); - texture_entry->access_watch_handle = 0; - } - - texture_entry->access_watch_handle = memory_->AddPhysicalAccessWatch( - guest_address, texture_entry->texture_info.input_length, - cpu::MMIOHandler::kWatchReadWrite, - [](void* context, void* data, uint32_t address) { - auto touched_entry = reinterpret_cast<TextureEntry*>(data); - touched_entry->access_watch_handle = 0; - - // This happens. RDR resolves to a texture then upsizes it, BF1943 - // writes to a resolved texture. - // TODO (for Vulkan): Copy this texture back into system memory. - // assert_always(); - }, - nullptr, texture_entry); - - return texture_entry->handle; - } - - // Check pending read buffer textures (for multiple resolves with no - // uploads inbetween). - for (auto it = read_buffer_textures_.begin(); - it != read_buffer_textures_.end(); ++it) { - const auto& entry = *it; - if (entry->guest_address == guest_address && - entry->logical_width == logical_width && - entry->logical_height == logical_height && entry->format == format) { - // Found an existing entry - just reupload. - if (config.format == GL_DEPTH_STENCIL) { - blitter->CopyDepthTexture(src_texture, src_rect, entry->handle, - dest_rect); - } else { - blitter->CopyColorTexture2D(src_texture, src_rect, entry->handle, - dest_rect, GL_LINEAR, swap_channels); - } - return entry->handle; - } - } - - // Need to create a new texture. - // As we don't know anything about this texture, we'll add it to the - // pending readbuffer list. If nobody claims it after a certain amount - // of time we'll dump it. - auto entry = std::make_unique<ReadBufferTexture>(); - entry->guest_address = guest_address; - entry->logical_width = logical_width; - entry->logical_height = logical_height; - entry->block_width = block_width; - entry->block_height = block_height; - entry->format = format; - - entry->access_watch_handle = memory_->AddPhysicalAccessWatch( - guest_address, block_height * block_width * 4, - cpu::MMIOHandler::kWatchReadWrite, - [](void* context, void* data, uint32_t address) { - auto entry = reinterpret_cast<ReadBufferTexture*>(data); - entry->access_watch_handle = 0; - - // This happens. RDR resolves to a texture then upsizes it, BF1943 - // writes to a resolved texture. - // TODO (for Vulkan): Copy this texture back into system memory. - // assert_always(); - }, - nullptr, entry.get()); - - glCreateTextures(GL_TEXTURE_2D, 1, &entry->handle); - glTextureParameteri(entry->handle, GL_TEXTURE_BASE_LEVEL, 0); - glTextureParameteri(entry->handle, GL_TEXTURE_MAX_LEVEL, 1); - glTextureStorage2D(entry->handle, 1, config.internal_format, logical_width, - logical_height); - if (config.format == GL_DEPTH_STENCIL) { - blitter->CopyDepthTexture(src_texture, src_rect, entry->handle, dest_rect); - } else { - blitter->CopyColorTexture2D(src_texture, src_rect, entry->handle, dest_rect, - GL_LINEAR, swap_channels); - } - - GLuint handle = entry->handle; - read_buffer_textures_.push_back(entry.release()); - return handle; -} - -void TextureCache::EvictTexture(TextureEntry* entry) { - if (entry->access_watch_handle) { - memory_->CancelAccessWatch(entry->access_watch_handle); - entry->access_watch_handle = 0; - } - - for (auto& view : entry->views) { - glMakeTextureHandleNonResidentARB(view->texture_sampler_handle); - } - glDeleteTextures(1, &entry->handle); - - uint64_t texture_hash = entry->texture_info.hash(); - for (auto it = texture_entries_.find(texture_hash); - it != texture_entries_.end(); ++it) { - if (it->second == entry) { - texture_entries_.erase(it); - break; - } - } - - delete entry; -} - -struct HostTextureInfo { - uint32_t output_length; - - union { - struct { - uint32_t output_width; - uint32_t output_pitch; - } size_1d; - struct { - uint32_t output_width; - uint32_t output_height; - uint32_t output_pitch; - } size_2d; - struct { - } size_3d; - struct { - uint32_t output_width; - uint32_t output_height; - uint32_t output_pitch; - uint32_t output_face_length; - } size_cube; - }; - - static bool Setup(const TextureInfo& guest_info, HostTextureInfo* out_info) { - auto& info = *out_info; - auto format = guest_info.format_info(); - - switch (guest_info.dimension) { - case Dimension::k1D: { - uint32_t bytes_per_block = - format->block_width * format->bits_per_pixel / 8; - uint32_t block_width = xe::round_up(guest_info.size_1d.logical_width, - format->block_width) / - format->block_width; - info.size_1d.output_width = block_width * format->block_width; - info.size_1d.output_pitch = block_width * bytes_per_block; - info.output_length = info.size_1d.output_pitch; - return true; - } - case Dimension::k2D: { - uint32_t bytes_per_block = format->block_width * format->block_height * - format->bits_per_pixel / 8; - uint32_t block_width = xe::round_up(guest_info.size_2d.logical_width, - format->block_width) / - format->block_width; - uint32_t block_height = xe::round_up(guest_info.size_2d.logical_height, - format->block_height) / - format->block_height; - info.size_2d.output_width = block_width * format->block_width; - info.size_2d.output_height = block_height * format->block_height; - info.size_2d.output_pitch = block_width * bytes_per_block; - info.output_length = info.size_2d.output_pitch * block_height; - return true; - }; - case Dimension::k3D: { - return false; - } - case Dimension::kCube: { - uint32_t bytes_per_block = format->block_width * format->block_height * - format->bits_per_pixel / 8; - uint32_t block_width = xe::round_up(guest_info.size_cube.logical_width, - format->block_width) / - format->block_width; - uint32_t block_height = - xe::round_up(guest_info.size_cube.logical_height, - format->block_height) / - format->block_height; - info.size_cube.output_width = block_width * format->block_width; - info.size_cube.output_height = block_height * format->block_height; - info.size_cube.output_pitch = block_width * bytes_per_block; - info.size_cube.output_face_length = - info.size_cube.output_pitch * block_height; - info.output_length = info.size_cube.output_face_length * 6; - return true; - } - } - return false; - } -}; - -void TextureSwap(Endian endianness, void* dest, const void* src, - size_t length) { - switch (endianness) { - case Endian::k8in16: - xe::copy_and_swap_16_aligned(dest, src, length / 2); - break; - case Endian::k8in32: - xe::copy_and_swap_32_aligned(dest, src, length / 4); - break; - case Endian::k16in32: // Swap high and low 16 bits within a 32 bit word - xe::copy_and_swap_16_in_32_aligned(dest, src, length); - break; - default: - case Endian::kUnspecified: - std::memcpy(dest, src, length); - break; - } -} - -bool TextureCache::UploadTexture1D(GLuint texture, - const TextureInfo& texture_info) { - SCOPE_profile_cpu_f("gpu"); - const auto host_address = - memory_->TranslatePhysical(texture_info.guest_address); - - const auto& config = texture_configs[uint32_t(texture_info.texture_format)]; - if (config.format == GL_INVALID_ENUM) { - assert_always("Unhandled texture format"); - return false; - } - - HostTextureInfo host_info; - if (!HostTextureInfo::Setup(texture_info, &host_info)) { - assert_always("Failed to set up host texture info"); - return false; - } - - size_t unpack_length = host_info.output_length; - glTextureStorage1D(texture, 1, config.internal_format, - host_info.size_1d.output_width); - - auto allocation = scratch_buffer_->Acquire(unpack_length); - - if (!texture_info.is_tiled) { - if (texture_info.size_1d.input_pitch == host_info.size_1d.output_pitch) { - TextureSwap(texture_info.endianness, allocation.host_ptr, host_address, - unpack_length); - } else { - assert_always(); - } - } else { - assert_always(); - } - size_t unpack_offset = allocation.offset; - scratch_buffer_->Commit(std::move(allocation)); - // TODO(benvanik): avoid flush on entire buffer by using another texture - // buffer. - scratch_buffer_->Flush(); - - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, scratch_buffer_->handle()); - if (texture_info.is_compressed()) { - glCompressedTextureSubImage1D(texture, 0, 0, host_info.size_1d.output_width, - config.format, - static_cast<GLsizei>(unpack_length), - reinterpret_cast<void*>(unpack_offset)); - } else { - // Most of these don't seem to have an effect on compressed images. - // glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_TRUE); - // glPixelStorei(GL_UNPACK_ALIGNMENT, texture_info.texel_pitch); - // glPixelStorei(GL_UNPACK_ROW_LENGTH, texture_info.size_2d.input_width); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - - glTextureSubImage1D(texture, 0, 0, host_info.size_1d.output_width, - config.format, config.type, - reinterpret_cast<void*>(unpack_offset)); - } - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); - return true; -} - -bool TextureCache::UploadTexture2D(GLuint texture, - const TextureInfo& texture_info) { - SCOPE_profile_cpu_f("gpu"); - const auto host_address = - memory_->TranslatePhysical(texture_info.guest_address); - - const auto& config = - texture_configs[uint32_t(texture_info.format_info()->format)]; - if (config.format == GL_INVALID_ENUM) { - assert_always("Unhandled texture format"); - return false; - } - - HostTextureInfo host_info; - if (!HostTextureInfo::Setup(texture_info, &host_info)) { - assert_always("Failed to set up host texture info"); - return false; - } - - size_t unpack_length = host_info.output_length; - glTextureStorage2D(texture, 1, config.internal_format, - host_info.size_2d.output_width, - host_info.size_2d.output_height); - - auto allocation = scratch_buffer_->Acquire(unpack_length); - - if (!texture_info.is_tiled) { - uint32_t offset_x, offset_y; - if (texture_info.has_packed_mips && - TextureInfo::GetPackedTileOffset(texture_info, &offset_x, &offset_y)) { - uint32_t bytes_per_block = texture_info.format_info()->block_width * - texture_info.format_info()->block_height * - texture_info.format_info()->bits_per_pixel / 8; - const uint8_t* src = host_address; - // TODO(gibbed): this needs checking - src += offset_y * texture_info.size_2d.input_pitch; - src += offset_x * bytes_per_block; - uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr); - uint32_t pitch = std::min(texture_info.size_2d.input_pitch, - host_info.size_2d.output_pitch); - for (uint32_t y = 0; y < std::min(texture_info.size_2d.block_height, - texture_info.size_2d.logical_height); - y++) { - TextureSwap(texture_info.endianness, dest, src, pitch); - src += texture_info.size_2d.input_pitch; - dest += host_info.size_2d.output_pitch; - } - } else if (texture_info.size_2d.input_pitch == - host_info.size_2d.output_pitch) { - // Fast path copy entire image. - TextureSwap(texture_info.endianness, allocation.host_ptr, host_address, - unpack_length); - } else { - // Slow path copy row-by-row because strides differ. - // UNPACK_ROW_LENGTH only works for uncompressed images, and likely does - // this exact thing under the covers, so we just always do it here. - const uint8_t* src = host_address; - uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr); - uint32_t pitch = std::min(texture_info.size_2d.input_pitch, - host_info.size_2d.output_pitch); - for (uint32_t y = 0; y < std::min(texture_info.size_2d.block_height, - texture_info.size_2d.logical_height); - y++) { - TextureSwap(texture_info.endianness, dest, src, pitch); - src += texture_info.size_2d.input_pitch; - dest += host_info.size_2d.output_pitch; - } - } - } else { - // Untile image. - // We could do this in a shader to speed things up, as this is pretty slow. - - // TODO(benvanik): optimize this inner loop (or work by tiles). - const uint8_t* src = host_address; - uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr); - uint32_t bytes_per_block = texture_info.format_info()->block_width * - texture_info.format_info()->block_height * - texture_info.format_info()->bits_per_pixel / 8; - - // Tiled textures can be packed; get the offset into the packed texture. - uint32_t offset_x; - uint32_t offset_y; - TextureInfo::GetPackedTileOffset(texture_info, &offset_x, &offset_y); - - auto bpp = (bytes_per_block >> 2) + - ((bytes_per_block >> 1) >> (bytes_per_block >> 2)); - for (uint32_t y = 0, output_base_offset = 0; - y < std::min(texture_info.size_2d.block_height, - texture_info.size_2d.logical_height); - y++, output_base_offset += host_info.size_2d.output_pitch) { - auto input_base_offset = TextureInfo::TiledOffset2DOuter( - offset_y + y, - (texture_info.size_2d.input_width / - texture_info.format_info()->block_width), - bpp); - for (uint32_t x = 0, output_offset = output_base_offset; - x < texture_info.size_2d.block_width; - x++, output_offset += bytes_per_block) { - auto input_offset = - TextureInfo::TiledOffset2DInner(offset_x + x, offset_y + y, bpp, - input_base_offset) >> - bpp; - TextureSwap(texture_info.endianness, dest + output_offset, - src + input_offset * bytes_per_block, bytes_per_block); - } - } - } - size_t unpack_offset = allocation.offset; - scratch_buffer_->Commit(std::move(allocation)); - // TODO(benvanik): avoid flush on entire buffer by using another texture - // buffer. - scratch_buffer_->Flush(); - - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, scratch_buffer_->handle()); - if (texture_info.is_compressed()) { - glCompressedTextureSubImage2D( - texture, 0, 0, 0, host_info.size_2d.output_width, - host_info.size_2d.output_height, config.format, - static_cast<GLsizei>(unpack_length), - reinterpret_cast<void*>(unpack_offset)); - } else { - // Most of these don't seem to have an effect on compressed images. - // glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_TRUE); - // glPixelStorei(GL_UNPACK_ALIGNMENT, texture_info.texel_pitch); - // glPixelStorei(GL_UNPACK_ROW_LENGTH, texture_info.size_2d.input_width); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - - glTextureSubImage2D(texture, 0, 0, 0, host_info.size_2d.output_width, - host_info.size_2d.output_height, config.format, - config.type, reinterpret_cast<void*>(unpack_offset)); - } - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); - return true; -} - -bool TextureCache::UploadTextureCube(GLuint texture, - const TextureInfo& texture_info) { - SCOPE_profile_cpu_f("gpu"); - const auto host_address = - memory_->TranslatePhysical(texture_info.guest_address); - - const auto& config = - texture_configs[uint32_t(texture_info.format_info()->format)]; - if (config.format == GL_INVALID_ENUM) { - assert_always("Unhandled texture format"); - return false; - } - - HostTextureInfo host_info; - if (!HostTextureInfo::Setup(texture_info, &host_info)) { - assert_always("Failed to set up host texture info"); - return false; - } - - size_t unpack_length = host_info.output_length; - glTextureStorage2D(texture, 1, config.internal_format, - host_info.size_cube.output_width, - host_info.size_cube.output_height); - - auto allocation = scratch_buffer_->Acquire(unpack_length); - if (!texture_info.is_tiled) { - if (texture_info.size_cube.input_pitch == - host_info.size_cube.output_pitch) { - // Fast path copy entire image. - TextureSwap(texture_info.endianness, allocation.host_ptr, host_address, - unpack_length); - } else { - // Slow path copy row-by-row because strides differ. - // UNPACK_ROW_LENGTH only works for uncompressed images, and likely does - // this exact thing under the covers, so we just always do it here. - const uint8_t* src = host_address; - uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr); - for (int face = 0; face < 6; ++face) { - uint32_t pitch = std::min(texture_info.size_cube.input_pitch, - host_info.size_cube.output_pitch); - for (uint32_t y = 0; y < texture_info.size_cube.block_height; y++) { - TextureSwap(texture_info.endianness, dest, src, pitch); - src += texture_info.size_cube.input_pitch; - dest += host_info.size_cube.output_pitch; - } - } - } - } else { - // TODO(benvanik): optimize this inner loop (or work by tiles). - const uint8_t* src = host_address; - uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr); - uint32_t bytes_per_block = texture_info.format_info()->block_width * - texture_info.format_info()->block_height * - texture_info.format_info()->bits_per_pixel / 8; - // Tiled textures can be packed; get the offset into the packed texture. - uint32_t offset_x; - uint32_t offset_y; - TextureInfo::GetPackedTileOffset(texture_info, &offset_x, &offset_y); - auto bpp = (bytes_per_block >> 2) + - ((bytes_per_block >> 1) >> (bytes_per_block >> 2)); - for (int face = 0; face < 6; ++face) { - for (uint32_t y = 0, output_base_offset = 0; - y < texture_info.size_cube.block_height; - y++, output_base_offset += host_info.size_cube.output_pitch) { - auto input_base_offset = TextureInfo::TiledOffset2DOuter( - offset_y + y, - (texture_info.size_cube.input_width / - texture_info.format_info()->block_width), - bpp); - for (uint32_t x = 0, output_offset = output_base_offset; - x < texture_info.size_cube.block_width; - x++, output_offset += bytes_per_block) { - auto input_offset = - TextureInfo::TiledOffset2DInner(offset_x + x, offset_y + y, bpp, - input_base_offset) >> - bpp; - TextureSwap(texture_info.endianness, dest + output_offset, - src + input_offset * bytes_per_block, bytes_per_block); - } - } - src += texture_info.size_cube.input_face_length; - dest += host_info.size_cube.output_face_length; - } - } - size_t unpack_offset = allocation.offset; - scratch_buffer_->Commit(std::move(allocation)); - // TODO(benvanik): avoid flush on entire buffer by using another texture - // buffer. - scratch_buffer_->Flush(); - - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, scratch_buffer_->handle()); - if (texture_info.is_compressed()) { - glCompressedTextureSubImage3D( - texture, 0, 0, 0, 0, host_info.size_cube.output_width, - host_info.size_cube.output_height, 6, config.format, - static_cast<GLsizei>(unpack_length), - reinterpret_cast<void*>(unpack_offset)); - } else { - // Most of these don't seem to have an effect on compressed images. - // glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_TRUE); - // glPixelStorei(GL_UNPACK_ALIGNMENT, texture_info.texel_pitch); - // glPixelStorei(GL_UNPACK_ROW_LENGTH, texture_info.size_2d.input_width); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - - glTextureSubImage3D(texture, 0, 0, 0, 0, host_info.size_cube.output_width, - host_info.size_cube.output_height, 6, config.format, - config.type, reinterpret_cast<void*>(unpack_offset)); - } - glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); - return true; -} - -} // namespace gl4 -} // namespace gpu -} // namespace xe diff --git a/src/xenia/gpu/gl4/texture_cache.h b/src/xenia/gpu/gl4/texture_cache.h deleted file mode 100644 index 4f018c329..000000000 --- a/src/xenia/gpu/gl4/texture_cache.h +++ /dev/null @@ -1,119 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_GPU_GL4_TEXTURE_CACHE_H_ -#define XENIA_GPU_GL4_TEXTURE_CACHE_H_ - -#include <mutex> -#include <unordered_map> -#include <vector> - -#include "xenia/gpu/sampler_info.h" -#include "xenia/gpu/texture_info.h" -#include "xenia/memory.h" -#include "xenia/ui/gl/blitter.h" -#include "xenia/ui/gl/circular_buffer.h" -#include "xenia/ui/gl/gl_context.h" - -namespace xe { -namespace gpu { -namespace gl4 { - -using xe::ui::gl::Blitter; -using xe::ui::gl::CircularBuffer; -using xe::ui::gl::Rect2D; - -class TextureCache { - public: - struct TextureEntry; - struct SamplerEntry { - SamplerInfo sampler_info; - GLuint handle; - }; - struct TextureEntryView { - TextureEntry* texture; - SamplerEntry* sampler; - uint64_t sampler_hash; - GLuint64 texture_sampler_handle; - }; - struct TextureEntry { - TextureInfo texture_info; - uintptr_t access_watch_handle; - GLuint handle; - bool pending_invalidation; - std::vector<std::unique_ptr<TextureEntryView>> views; - }; - - TextureCache(); - ~TextureCache(); - - bool Initialize(Memory* memory, CircularBuffer* scratch_buffer); - void Shutdown(); - - void Scavenge(); - void Clear(); - void EvictAllTextures(); - - TextureEntryView* Demand(const TextureInfo& texture_info, - const SamplerInfo& sampler_info); - - GLuint CopyTexture(Blitter* blitter, uint32_t guest_address, - uint32_t logical_width, uint32_t logical_height, - uint32_t block_width, uint32_t block_height, - TextureFormat format, bool swap_channels, - GLuint src_texture, Rect2D src_rect, Rect2D dest_rect); - GLuint ConvertTexture(Blitter* blitter, uint32_t guest_address, - uint32_t logical_width, uint32_t logical_height, - uint32_t block_width, uint32_t block_height, - TextureFormat format, bool swap_channels, - GLuint src_texture, Rect2D src_rect, Rect2D dest_rect); - - TextureEntry* LookupAddress(uint32_t guest_address, uint32_t width, - uint32_t height, TextureFormat format); - - private: - struct ReadBufferTexture { - uintptr_t access_watch_handle; - uint32_t guest_address; - uint32_t logical_width; - uint32_t logical_height; - uint32_t block_width; - uint32_t block_height; - TextureFormat format; - GLuint handle; - }; - - SamplerEntry* LookupOrInsertSampler(const SamplerInfo& sampler_info, - uint64_t opt_hash = 0); - void EvictSampler(SamplerEntry* entry); - TextureEntry* LookupOrInsertTexture(const TextureInfo& texture_info, - uint64_t opt_hash = 0); - void EvictTexture(TextureEntry* entry); - - bool UploadTexture1D(GLuint texture, const TextureInfo& texture_info); - bool UploadTexture2D(GLuint texture, const TextureInfo& texture_info); - bool UploadTextureCube(GLuint texture, const TextureInfo& texture_info); - - Memory* memory_; - CircularBuffer* scratch_buffer_; - std::unordered_map<uint64_t, SamplerEntry*> sampler_entries_; - std::unordered_map<uint64_t, TextureEntry*> texture_entries_; - - std::vector<ReadBufferTexture*> read_buffer_textures_; - - std::mutex invalidated_textures_mutex_; - std::vector<TextureEntry*>* invalidated_textures_; - std::vector<TextureEntry*> invalidated_textures_sets_[2]; -}; - -} // namespace gl4 -} // namespace gpu -} // namespace xe - -#endif // XENIA_GPU_GL4_TEXTURE_CACHE_H_ diff --git a/src/xenia/gpu/glsl_shader_translator.cc b/src/xenia/gpu/glsl_shader_translator.cc index 2f89ab3df..32d26c1a2 100644 --- a/src/xenia/gpu/glsl_shader_translator.cc +++ b/src/xenia/gpu/glsl_shader_translator.cc @@ -959,6 +959,7 @@ void GlslShaderTranslator::EmitStoreResult(const InstructionResult& result, case InstructionStorageTarget::kDepth: EmitSourceDepth("gl_FragDepth"); break; + default: case InstructionStorageTarget::kNone: return; } diff --git a/src/xenia/gpu/graphics_system.cc b/src/xenia/gpu/graphics_system.cc index 56443db3a..7728e8eee 100644 --- a/src/xenia/gpu/graphics_system.cc +++ b/src/xenia/gpu/graphics_system.cc @@ -170,7 +170,7 @@ uint32_t GraphicsSystem::ReadRegister(uint32_t addr) { uint32_t r = (addr & 0xFFFF) / 4; switch (r) { - case 0x0F00: // ? + case 0x0F00: // RB_EDRAM_TIMING return 0x08100748; case 0x0F01: // RB_BC_CONTROL return 0x0000200E; @@ -211,7 +211,7 @@ void GraphicsSystem::WriteRegister(uint32_t addr, uint32_t value) { } void GraphicsSystem::InitializeRingBuffer(uint32_t ptr, uint32_t log2_size) { - command_processor_->InitializeRingBuffer(ptr, (log2_size | 0x2) + 1); + command_processor_->InitializeRingBuffer(ptr, log2_size + 0x3); } void GraphicsSystem::EnableReadPointerWriteBack(uint32_t ptr, diff --git a/src/xenia/gpu/sampler_info.cc b/src/xenia/gpu/sampler_info.cc index 0adefbd1b..c6fcf0985 100644 --- a/src/xenia/gpu/sampler_info.cc +++ b/src/xenia/gpu/sampler_info.cc @@ -44,6 +44,8 @@ bool SamplerInfo::Prepare(const xenos::xe_gpu_texture_fetch_t& fetch, out_info->border_color = static_cast<BorderColor>(fetch.border_color); out_info->lod_bias = (fetch.lod_bias) / 32.f; + out_info->mip_min_level = fetch.mip_min_level; + out_info->mip_max_level = fetch.mip_max_level; return true; } diff --git a/src/xenia/gpu/sampler_info.h b/src/xenia/gpu/sampler_info.h index 57e3ceeac..415c28bd2 100644 --- a/src/xenia/gpu/sampler_info.h +++ b/src/xenia/gpu/sampler_info.h @@ -26,6 +26,8 @@ struct SamplerInfo { AnisoFilter aniso_filter; BorderColor border_color; float lod_bias; + uint32_t mip_min_level; + uint32_t mip_max_level; static bool Prepare(const xenos::xe_gpu_texture_fetch_t& fetch, const ParsedTextureFetchInstruction& fetch_instr, @@ -36,7 +38,9 @@ struct SamplerInfo { return min_filter == other.min_filter && mag_filter == other.mag_filter && mip_filter == other.mip_filter && clamp_u == other.clamp_u && clamp_v == other.clamp_v && clamp_w == other.clamp_w && - aniso_filter == other.aniso_filter; + aniso_filter == other.aniso_filter && lod_bias == other.lod_bias && + mip_min_level == other.mip_min_level && + mip_max_level == other.mip_max_level; } }; diff --git a/src/xenia/gpu/shader.h b/src/xenia/gpu/shader.h index 7e0cd3ab2..ebea8b9f3 100644 --- a/src/xenia/gpu/shader.h +++ b/src/xenia/gpu/shader.h @@ -31,6 +31,11 @@ enum class InstructionStorageTarget { kPosition, // Result is stored to the point size export (gl_PointSize). kPointSize, + // Result is stored as memexport destination address. + // [physical >> 2, ??, ??, ??] + kExportAddress, + // Result is stored to memexport destination data. + kExportData, // Result is stored to a color target export indexed by storage_index [0-3]. kColorTarget, // Result is stored to the depth export (gl_FragDepth). diff --git a/src/xenia/gpu/shader_translator.cc b/src/xenia/gpu/shader_translator.cc index 4634ef34d..1f3e13dbc 100644 --- a/src/xenia/gpu/shader_translator.cc +++ b/src/xenia/gpu/shader_translator.cc @@ -1147,14 +1147,15 @@ void ShaderTranslator::ParseAluVectorInstruction( } else if (is_vertex_shader()) { switch (dest_num) { case 32: + i.result.storage_target = InstructionStorageTarget::kExportAddress; + break; case 33: case 34: case 35: case 36: case 37: - // TODO: Memexport registers - i.result.storage_target = InstructionStorageTarget::kNone; - i.result.storage_index = 0; + i.result.storage_index = dest_num - 33; + i.result.storage_target = InstructionStorageTarget::kExportData; break; case 62: i.result.storage_target = InstructionStorageTarget::kPosition; @@ -1198,14 +1199,15 @@ void ShaderTranslator::ParseAluVectorInstruction( i.result.storage_index = 3; break; case 32: + i.result.storage_target = InstructionStorageTarget::kExportAddress; + break; case 33: case 34: case 35: case 36: case 37: - // TODO: Memexport registers - i.result.storage_target = InstructionStorageTarget::kNone; - i.result.storage_index = 0; + i.result.storage_index = dest_num - 33; + i.result.storage_target = InstructionStorageTarget::kExportData; break; case 61: i.result.storage_target = InstructionStorageTarget::kDepth; @@ -1303,6 +1305,17 @@ void ShaderTranslator::ParseAluScalarInstruction( : InstructionStorageAddressingMode::kStatic; } else if (is_vertex_shader()) { switch (dest_num) { + case 32: + i.result.storage_target = InstructionStorageTarget::kExportAddress; + break; + case 33: + case 34: + case 35: + case 36: + case 37: + i.result.storage_index = dest_num - 33; + i.result.storage_target = InstructionStorageTarget::kExportData; + break; case 62: i.result.storage_target = InstructionStorageTarget::kPosition; break; @@ -1344,6 +1357,17 @@ void ShaderTranslator::ParseAluScalarInstruction( i.result.storage_target = InstructionStorageTarget::kColorTarget; i.result.storage_index = 3; break; + case 32: + i.result.storage_target = InstructionStorageTarget::kExportAddress; + break; + case 33: + case 34: + case 35: + case 36: + case 37: + i.result.storage_index = dest_num - 33; + i.result.storage_target = InstructionStorageTarget::kExportData; + break; case 61: i.result.storage_target = InstructionStorageTarget::kDepth; break; diff --git a/src/xenia/gpu/shader_translator_disasm.cc b/src/xenia/gpu/shader_translator_disasm.cc index b36267fb4..6a2007eaa 100644 --- a/src/xenia/gpu/shader_translator_disasm.cc +++ b/src/xenia/gpu/shader_translator_disasm.cc @@ -38,6 +38,13 @@ void DisassembleResultOperand(const InstructionResult& result, case InstructionStorageTarget::kPointSize: out->Append("oPts"); break; + case InstructionStorageTarget::kExportAddress: + out->Append("eA"); + break; + case InstructionStorageTarget::kExportData: + out->Append("eM"); + uses_storage_index = true; + break; case InstructionStorageTarget::kColorTarget: out->AppendFormat("oC"); uses_storage_index = true; diff --git a/src/xenia/gpu/spirv_shader_translator.cc b/src/xenia/gpu/spirv_shader_translator.cc index 376d04f17..17cec8f37 100644 --- a/src/xenia/gpu/spirv_shader_translator.cc +++ b/src/xenia/gpu/spirv_shader_translator.cc @@ -67,6 +67,7 @@ void SpirvShaderTranslator::StartTranslation() { vec2_int_type_ = b.makeVectorType(int_type_, 2); vec2_uint_type_ = b.makeVectorType(uint_type_, 2); vec2_float_type_ = b.makeVectorType(float_type_, 2); + vec3_int_type_ = b.makeVectorType(int_type_, 3); vec3_float_type_ = b.makeVectorType(float_type_, 3); vec4_float_type_ = b.makeVectorType(float_type_, 4); vec4_int_type_ = b.makeVectorType(int_type_, 4); @@ -482,8 +483,10 @@ std::vector<uint8_t> SpirvShaderTranslator::CompleteTranslation() { mainFn, "main"); b.addExecutionMode(mainFn, spv::ExecutionModeOriginUpperLeft); - // FIXME(DrChat): We need to declare the DepthReplacing execution mode if - // we write depth, and we must unconditionally write depth if declared! + // If we write a new depth value, we must declare this mode! + if (writes_depth_) { + b.addExecutionMode(mainFn, spv::ExecutionModeDepthReplacing); + } for (auto id : interface_ids_) { entry->addIdOperand(id); @@ -527,10 +530,18 @@ std::vector<uint8_t> SpirvShaderTranslator::CompleteTranslation() { // Reinsert w p = b.createCompositeInsert(p_w, p, vec4_float_type_, 3); + // Apply window offset + // pos.xy += window_scale.zw + auto window_offset = b.createOp(spv::Op::OpVectorShuffle, vec4_float_type_, + {window_scale, window_scale, 2, 3, 0, 1}); + auto p_offset = + b.createBinOp(spv::Op::OpFAdd, vec4_float_type_, p, window_offset); + // Apply window scaling // pos.xy *= window_scale.xy - auto p_scaled = - b.createBinOp(spv::Op::OpFMul, vec4_float_type_, p, window_scale); + auto p_scaled = b.createBinOp(spv::Op::OpFMul, vec4_float_type_, p_offset, + window_scale); + p = b.createOp(spv::Op::OpVectorShuffle, vec4_float_type_, {p, p_scaled, 4, 5, 2, 3}); @@ -608,6 +619,7 @@ std::vector<uint8_t> SpirvShaderTranslator::CompleteTranslation() { // Cleanup builder. cf_blocks_.clear(); + writes_depth_ = false; loop_head_block_ = nullptr; loop_body_block_ = nullptr; loop_cont_block_ = nullptr; @@ -1786,60 +1798,10 @@ void SpirvShaderTranslator::ProcessTextureFetchInstruction( tex_[dim_idx], std::vector<Id>({texture_index})); auto texture = b.createLoad(texture_ptr); - spv::Id size = 0; - if (instr.attributes.offset_x || instr.attributes.offset_y) { - auto image = - b.createUnaryOp(spv::OpImage, b.getImageType(texture), texture); - - spv::Builder::TextureParameters params; - std::memset(¶ms, 0, sizeof(params)); - params.sampler = image; - params.lod = b.makeIntConstant(0); - size = b.createTextureQueryCall(spv::Op::OpImageQuerySizeLod, params, - false); - - if (instr.dimension == TextureDimension::k1D) { - size = b.createUnaryOp(spv::Op::OpConvertSToF, float_type_, size); - } else if (instr.dimension == TextureDimension::k2D) { - size = - b.createUnaryOp(spv::Op::OpConvertSToF, vec2_float_type_, size); - } else if (instr.dimension == TextureDimension::k3D) { - size = - b.createUnaryOp(spv::Op::OpConvertSToF, vec3_float_type_, size); - } else if (instr.dimension == TextureDimension::kCube) { - size = - b.createUnaryOp(spv::Op::OpConvertSToF, vec4_float_type_, size); - } - } - if (instr.dimension == TextureDimension::k1D) { - src = b.createCompositeExtract(src, float_type_, 0); - if (instr.attributes.offset_x) { - auto offset = b.makeFloatConstant(instr.attributes.offset_x + 0.5f); - offset = b.createBinOp(spv::Op::OpFDiv, float_type_, offset, size); - src = b.createBinOp(spv::Op::OpFAdd, float_type_, src, offset); - } - - // https://msdn.microsoft.com/en-us/library/windows/desktop/bb944006.aspx - // "Because the runtime does not support 1D textures, the compiler will - // use a 2D texture with the knowledge that the y-coordinate is - // unimportant." - src = b.createCompositeConstruct( - vec2_float_type_, - std::vector<Id>({src, b.makeFloatConstant(0.0f)})); - } else if (instr.dimension == TextureDimension::k2D) { - src = b.createRvalueSwizzle(spv::NoPrecision, vec2_float_type_, src, - std::vector<uint32_t>({0, 1})); - if (instr.attributes.offset_x || instr.attributes.offset_y) { - auto offset = b.makeCompositeConstant( - vec2_float_type_, - std::vector<Id>( - {b.makeFloatConstant(instr.attributes.offset_x + 0.5f), - b.makeFloatConstant(instr.attributes.offset_y + 0.5f)})); - offset = - b.createBinOp(spv::Op::OpFDiv, vec2_float_type_, offset, size); - src = b.createBinOp(spv::Op::OpFAdd, vec2_float_type_, src, offset); - } + // Upgrade 1D src coordinate into 2D + src = b.createCompositeConstruct(vec2_float_type_, + {src, b.makeFloatConstant(0.f)}); } spv::Builder::TextureParameters params = {0}; @@ -1848,6 +1810,50 @@ void SpirvShaderTranslator::ProcessTextureFetchInstruction( if (instr.attributes.use_register_lod) { params.lod = b.createLoad(lod_); } + if (instr.attributes.offset_x || instr.attributes.offset_y || + instr.attributes.offset_z) { + float offset_x = instr.attributes.offset_x; + float offset_y = instr.attributes.offset_y; + float offset_z = instr.attributes.offset_z; + + // Round numbers away from zero. No effect if offset is 0. + offset_x += instr.attributes.offset_x < 0 ? -0.5f : 0.5f; + offset_y += instr.attributes.offset_y < 0 ? -0.5f : 0.5f; + offset_z += instr.attributes.offset_z < 0 ? -0.5f : 0.5f; + + Id offset = 0; + switch (instr.dimension) { + case TextureDimension::k1D: { + // https://msdn.microsoft.com/en-us/library/windows/desktop/bb944006.aspx + // "Because the runtime does not support 1D textures, the compiler + // will use a 2D texture with the knowledge that the y-coordinate is + // unimportant." + offset = b.makeCompositeConstant( + vec2_int_type_, + {b.makeIntConstant(int(offset_x)), b.makeIntConstant(0)}); + } break; + case TextureDimension::k2D: { + offset = b.makeCompositeConstant( + vec2_int_type_, {b.makeIntConstant(int(offset_x)), + b.makeIntConstant(int(offset_y))}); + } break; + case TextureDimension::k3D: { + offset = b.makeCompositeConstant( + vec3_int_type_, {b.makeIntConstant(int(offset_x)), + b.makeIntConstant(int(offset_y)), + b.makeIntConstant(int(offset_z))}); + } break; + case TextureDimension::kCube: { + // FIXME(DrChat): Is this the correct dimension? I forget + offset = b.makeCompositeConstant( + vec3_int_type_, {b.makeIntConstant(int(offset_x)), + b.makeIntConstant(int(offset_y)), + b.makeIntConstant(int(offset_z))}); + } break; + } + + params.offset = offset; + } dest = b.createTextureCall(spv::NoPrecision, vec4_float_type_, false, false, @@ -1908,11 +1914,39 @@ void SpirvShaderTranslator::ProcessTextureFetchInstruction( } } break; + case FetchOpcode::kGetTextureComputedLod: { + // TODO(DrChat): Verify if this implementation is correct. + // This is only valid in pixel shaders. + assert_true(is_pixel_shader()); + + auto texture_index = + b.makeUintConstant(tex_binding_map_[instr.operands[1].storage_index]); + auto texture_ptr = + b.createAccessChain(spv::StorageClass::StorageClassUniformConstant, + tex_[dim_idx], std::vector<Id>({texture_index})); + auto texture = b.createLoad(texture_ptr); + + if (instr.dimension == TextureDimension::k1D) { + // Upgrade 1D src coordinate into 2D + src = b.createCompositeConstruct(vec2_float_type_, + {src, b.makeFloatConstant(0.f)}); + } + + spv::Builder::TextureParameters params = {}; + params.sampler = texture; + params.coords = src; + auto lod = + b.createTextureQueryCall(spv::Op::OpImageQueryLod, params, false); + + dest = b.createCompositeExtract(lod, float_type_, 1); + dest = b.smearScalar(spv::NoPrecision, dest, vec4_float_type_); + } break; + case FetchOpcode::kSetTextureLod: { // <lod register> = src1.x (MIP level) // ... immediately after // tfetch UseRegisterLOD=true - b.createStore(b.createCompositeExtract(src, float_type_, 0), lod_); + b.createStore(src, lod_); } break; default: @@ -2210,8 +2244,8 @@ void SpirvShaderTranslator::ProcessVectorAluInstruction( auto src1_y = b.createCompositeExtract(sources[1], float_type_, 1); auto dst_y = b.createBinOp(spv::Op::OpFMul, float_type_, src0_y, src1_y); - auto src0_z = b.createCompositeExtract(sources[0], float_type_, 3); - auto src1_w = b.createCompositeExtract(sources[1], float_type_, 4); + auto src0_z = b.createCompositeExtract(sources[0], float_type_, 2); + auto src1_w = b.createCompositeExtract(sources[1], float_type_, 3); dest = b.createCompositeConstruct( vec4_float_type_, std::vector<Id>({b.makeFloatConstant(1.f), dst_y, src0_z, src1_w})); @@ -3267,7 +3301,9 @@ void SpirvShaderTranslator::StoreToResult(Id source_value_id, storage_type = float_type_; storage_offsets.push_back(0); storage_array = false; + writes_depth_ = true; break; + default: case InstructionStorageTarget::kNone: assert_unhandled_case(result.storage_target); break; diff --git a/src/xenia/gpu/spirv_shader_translator.h b/src/xenia/gpu/spirv_shader_translator.h index ec822e8e2..caa288353 100644 --- a/src/xenia/gpu/spirv_shader_translator.h +++ b/src/xenia/gpu/spirv_shader_translator.h @@ -29,7 +29,7 @@ namespace gpu { // supported size). struct SpirvPushConstants { // Accessible to vertex shader only: - float window_scale[4]; // scale x/y, viewport width/height (pixels) + float window_scale[4]; // scale x/y, offset x/y (pixels) float vtx_fmt[4]; // Accessible to geometry shader only: @@ -132,7 +132,7 @@ class SpirvShaderTranslator : public ShaderTranslator { // Types. spv::Id float_type_ = 0, bool_type_ = 0, int_type_ = 0, uint_type_ = 0; - spv::Id vec2_int_type_ = 0, vec2_uint_type_ = 0; + spv::Id vec2_int_type_ = 0, vec2_uint_type_ = 0, vec3_int_type_ = 0; spv::Id vec2_float_type_ = 0, vec3_float_type_ = 0, vec4_float_type_ = 0; spv::Id vec4_int_type_ = 0, vec4_uint_type_ = 0; spv::Id vec2_bool_type_ = 0, vec3_bool_type_ = 0, vec4_bool_type_ = 0; @@ -163,6 +163,8 @@ class SpirvShaderTranslator : public ShaderTranslator { spv::Id vtx_ = 0; // Vertex buffer array (32 runtime arrays) std::unordered_map<uint32_t, uint32_t> vtx_binding_map_; + bool writes_depth_ = false; + // SPIR-V IDs that are part of the in/out interface. std::vector<spv::Id> interface_ids_; diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc index 13cf23c81..46caa54f3 100644 --- a/src/xenia/gpu/texture_info.cc +++ b/src/xenia/gpu/texture_info.cc @@ -15,6 +15,7 @@ #include "xenia/base/logging.h" #include "xenia/base/math.h" +#include "xenia/base/memory.h" #include "third_party/xxhash/xxhash.h" @@ -59,6 +60,8 @@ bool TextureInfo::Prepare(const xe_gpu_texture_fetch_t& fetch, info.endianness = static_cast<Endian>(fetch.endianness); info.is_tiled = fetch.tiled; info.has_packed_mips = fetch.packed_mips; + info.mip_address = fetch.mip_address << 12; + info.mip_levels = fetch.packed_mips ? fetch.mip_max_level + 1 : 1; info.input_length = 0; // Populated below. if (info.format_info()->format == TextureFormat::kUnknown) { @@ -70,15 +73,16 @@ bool TextureInfo::Prepare(const xe_gpu_texture_fetch_t& fetch, // Must be called here when we know the format. switch (info.dimension) { case Dimension::k1D: { - assert_always(); + info.CalculateTextureSizes1D(fetch.size_1d.width + 1); } break; case Dimension::k2D: { info.CalculateTextureSizes2D(fetch.size_2d.width + 1, fetch.size_2d.height + 1); } break; case Dimension::k3D: { - // TODO(benvanik): calculate size. - return false; + info.CalculateTextureSizes3D(fetch.size_3d.width + 1, + fetch.size_3d.height + 1, + fetch.size_3d.depth + 1); } case Dimension::kCube: { info.CalculateTextureSizesCube(fetch.size_stack.width + 1, @@ -106,6 +110,8 @@ bool TextureInfo::PrepareResolve(uint32_t physical_address, info.endianness = endian; info.is_tiled = true; info.has_packed_mips = false; + info.mip_address = 0; + info.mip_levels = 1; info.input_length = 0; if (info.format_info()->format == TextureFormat::kUnknown) { @@ -117,14 +123,46 @@ bool TextureInfo::PrepareResolve(uint32_t physical_address, return true; } +void TextureInfo::CalculateTextureSizes1D(uint32_t width) { + size_1d.logical_width = width; + + auto format = format_info(); + + // width in blocks. + uint32_t block_width = + xe::round_up(size_1d.logical_width, format->block_width) / + format->block_width; + + if (is_tiled) { + // If the texture is tiled, its dimensions must be a multiple of tile + // dimensions (32x32 blocks). + size_1d.block_width = xe::round_up(block_width, 32); + } else { + size_1d.block_width = block_width; + } + + uint32_t bytes_per_block = format->block_width * format->bits_per_pixel / 8; + uint32_t byte_pitch = size_1d.block_width * bytes_per_block; + + uint32_t texel_width; + if (!is_tiled) { + // Each row must be a multiple of 256 in linear textures. + byte_pitch = xe::round_up(byte_pitch, 256); + texel_width = (byte_pitch / bytes_per_block) * format->block_width; + } else { + texel_width = size_2d.block_width * format->block_width; + } + + size_1d.input_width = texel_width; + size_1d.input_pitch = byte_pitch; + + input_length = size_1d.input_pitch; +} + void TextureInfo::CalculateTextureSizes2D(uint32_t width, uint32_t height) { size_2d.logical_width = width; size_2d.logical_height = height; - // Here be dragons. The values here are used in texture_cache.cc to copy - // images and create GL textures. Changes here will impact that code. - // TODO(benvanik): generic texture copying utility. - auto format = format_info(); // w/h in blocks. @@ -135,11 +173,15 @@ void TextureInfo::CalculateTextureSizes2D(uint32_t width, uint32_t height) { xe::round_up(size_2d.logical_height, format->block_height) / format->block_height; - // Tiles are 32x32 blocks. The pitch of all textures must a multiple of tile - // dimensions. - uint32_t tile_width = xe::round_up(block_width, 32) / 32; - size_2d.block_width = tile_width * 32; - size_2d.block_height = block_height; + if (is_tiled) { + // If the texture is tiled, its dimensions must be a multiple of tile + // dimensions (32x32 blocks). + size_2d.block_width = xe::round_up(block_width, 32); + size_2d.block_height = xe::round_up(block_height, 32); + } else { + size_2d.block_width = block_width; + size_2d.block_height = block_height; + } uint32_t bytes_per_block = format->block_width * format->block_height * format->bits_per_pixel / 8; @@ -161,6 +203,52 @@ void TextureInfo::CalculateTextureSizes2D(uint32_t width, uint32_t height) { input_length = size_2d.input_pitch * size_2d.block_height; } +void TextureInfo::CalculateTextureSizes3D(uint32_t width, uint32_t height, + uint32_t depth) { + size_3d.logical_width = width; + size_3d.logical_height = height; + + auto format = format_info(); + + // w/h in blocks must be a multiple of block size. + uint32_t block_width = + xe::round_up(size_3d.logical_width, format->block_width) / + format->block_width; + uint32_t block_height = + xe::round_up(size_3d.logical_height, format->block_height) / + format->block_height; + + if (is_tiled) { + // If the texture is tiled, its dimensions must be a multiple of tile + // dimensions (32x32 blocks). + size_3d.block_width = xe::round_up(block_width, 32); + size_3d.block_height = xe::round_up(block_height, 32); + } else { + size_3d.block_width = block_width; + size_3d.block_height = block_height; + } + + uint32_t bytes_per_block = + format->block_width * format->block_height * format->bits_per_pixel / 8; + uint32_t byte_pitch = size_3d.block_width * bytes_per_block; + + uint32_t texel_width; + if (!is_tiled) { + // Each row must be a multiple of 256 in linear textures. + byte_pitch = xe::round_up(byte_pitch, 256); + texel_width = (byte_pitch / bytes_per_block) * format->block_width; + } else { + texel_width = size_3d.block_width * format->block_width; + } + + size_3d.input_width = texel_width; + size_3d.input_height = size_3d.block_height * format->block_height; + size_3d.input_pitch = byte_pitch; + + size_3d.input_face_length = size_3d.input_pitch * size_3d.block_height; + input_length = size_3d.input_face_length * depth; +} + void TextureInfo::CalculateTextureSizesCube(uint32_t width, uint32_t height, uint32_t depth) { assert_true(depth == 6); @@ -177,11 +265,15 @@ void TextureInfo::CalculateTextureSizesCube(uint32_t width, uint32_t height, xe::round_up(size_cube.logical_height, format->block_height) / format->block_height; - // Tiles are 32x32 blocks. All textures must be multiples of tile dimensions. - uint32_t tile_width = xe::round_up(block_width, 32) / 32; - uint32_t tile_height = xe::round_up(block_height, 32) / 32; - size_cube.block_width = tile_width * 32; - size_cube.block_height = tile_height * 32; + if (is_tiled) { + // If the texture is tiled, its dimensions must be a multiple of tile + // dimensions (32x32 blocks). + size_cube.block_width = xe::round_up(block_width, 32); + size_cube.block_height = xe::round_up(block_height, 32); + } else { + size_cube.block_width = block_width; + size_cube.block_height = block_height; + } uint32_t bytes_per_block = format->block_width * format->block_height * format->bits_per_pixel / 8; @@ -204,7 +296,194 @@ void TextureInfo::CalculateTextureSizesCube(uint32_t width, uint32_t height, input_length = size_cube.input_face_length * 6; } -bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info, +static void TextureSwap(Endian endianness, void* dest, const void* src, + size_t length) { + switch (endianness) { + case Endian::k8in16: + xe::copy_and_swap_16_unaligned(dest, src, length / 2); + break; + case Endian::k8in32: + xe::copy_and_swap_32_unaligned(dest, src, length / 4); + break; + case Endian::k16in32: // Swap high and low 16 bits within a 32 bit word + xe::copy_and_swap_16_in_32_unaligned(dest, src, length); + break; + default: + case Endian::kUnspecified: + std::memcpy(dest, src, length); + break; + } +} + +static void ConvertTexelCTX1(uint8_t* dest, size_t dest_pitch, + const uint8_t* src, Endian src_endianness) { + // http://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf + union { + uint8_t data[8]; + struct { + uint8_t r0, g0, r1, g1; + uint32_t xx; + }; + } block; + static_assert(sizeof(block) == 8, "CTX1 block mismatch"); + + const uint32_t bytes_per_block = 8; + TextureSwap(src_endianness, block.data, src, bytes_per_block); + + uint8_t cr[4] = { + block.r0, block.r1, + static_cast<uint8_t>(2.f / 3.f * block.r0 + 1.f / 3.f * block.r1), + static_cast<uint8_t>(1.f / 3.f * block.r0 + 2.f / 3.f * block.r1)}; + uint8_t cg[4] = { + block.g0, block.g1, + static_cast<uint8_t>(2.f / 3.f * block.g0 + 1.f / 3.f * block.g1), + static_cast<uint8_t>(1.f / 3.f * block.g0 + 2.f / 3.f * block.g1)}; + + for (uint32_t oy = 0; oy < 4; ++oy) { + for (uint32_t ox = 0; ox < 4; ++ox) { + uint8_t xx = (block.xx >> (((ox + (oy * 4)) * 2))) & 3; + dest[(oy * dest_pitch) + (ox * 2) + 0] = cr[xx]; + dest[(oy * dest_pitch) + (ox * 2) + 1] = cg[xx]; + } + } +} + +void TextureInfo::ConvertTiled(uint8_t* dest, const uint8_t* src, Endian endian, + const FormatInfo* format_info, uint32_t offset_x, + uint32_t offset_y, uint32_t block_pitch, + uint32_t width, uint32_t height, + uint32_t output_width) { + // TODO(benvanik): optimize this inner loop (or work by tiles). + uint32_t bytes_per_block = format_info->block_width * + format_info->block_height * + format_info->bits_per_pixel / 8; + + uint32_t output_pitch = + output_width * format_info->block_width * format_info->bits_per_pixel / 8; + + uint32_t output_row_height = 1; + if (format_info->format == TextureFormat::k_CTX1) { + // TODO: Can we calculate this? + output_row_height = 4; + } + + // logical w/h in blocks. + uint32_t block_width = + xe::round_up(width, format_info->block_width) / format_info->block_width; + uint32_t block_height = xe::round_up(height, format_info->block_height) / + format_info->block_height; + + // Bytes per pixel + auto log2_bpp = + (bytes_per_block / 4) + ((bytes_per_block / 2) >> (bytes_per_block / 4)); + + // Offset to the current row, in bytes. + uint32_t output_row_offset = 0; + for (uint32_t y = 0; y < block_height; y++) { + auto input_row_offset = + TextureInfo::TiledOffset2DOuter(offset_y + y, block_pitch, log2_bpp); + + // Go block-by-block on this row. + uint32_t output_offset = output_row_offset; + for (uint32_t x = 0; x < block_width; x++) { + auto input_offset = TextureInfo::TiledOffset2DInner( + offset_x + x, offset_y + y, log2_bpp, input_row_offset); + input_offset >>= log2_bpp; + + if (format_info->format == TextureFormat::k_CTX1) { + // Convert to R8G8. + ConvertTexelCTX1(&dest[output_offset], output_pitch, src, endian); + } else { + // Generic swap to destination. + TextureSwap(endian, dest + output_offset, + src + input_offset * bytes_per_block, bytes_per_block); + } + + output_offset += bytes_per_block; + } + + output_row_offset += output_pitch * output_row_height; + } +} + +uint32_t TextureInfo::GetMaxMipLevels(uint32_t width, uint32_t height, + uint32_t depth) { + return 1 + xe::log2_floor(std::max({width, height, depth})); +} + +uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip, + uint32_t* offset_x, uint32_t* offset_y) { + if (mip == 0) { + // Short-circuit. Mip 0 is always stored in guest_address. + GetPackedTileOffset(src, offset_x, offset_y); + return src.guest_address; + } + + // If the texture is <= 16 pixels w/h, the mips are packed with the base + // texture. Otherwise, they're stored beginning from mip_address. + uint32_t address_base = std::min(src.width, src.height) < 16 + ? src.guest_address + : src.mip_address; + uint32_t address_offset = 0; + + // Walk forward to find the address of the mip. + for (uint32_t i = 1; i < mip; i++) { + uint32_t logical_width = std::max(xe::next_pow2(src.width + 1) >> i, 1u); + uint32_t logical_height = std::max(xe::next_pow2(src.height + 1) >> i, 1u); + if (std::min(logical_width, logical_height) <= 16) { + // We've reached the point where the mips are packed into a single tile. + break; + } + + address_offset += GetMipSize(src, i); + } + + // Now, check if the mip is packed at an offset. + GetPackedTileOffset(xe::next_pow2(src.width + 1) >> mip, + xe::next_pow2(src.height + 1) >> mip, src.format_info(), + offset_x, offset_y); + return address_base + address_offset; +} + +uint32_t TextureInfo::GetMipSize(const TextureInfo& src, uint32_t mip) { + if (mip == 0) { + return src.input_length; + } + + uint32_t bytes_per_block = src.format_info()->block_width * + src.format_info()->block_height * + src.format_info()->bits_per_pixel / 8; + + uint32_t logical_width = xe::next_pow2(src.width + 1) >> mip; + uint32_t logical_height = xe::next_pow2(src.height + 1) >> mip; + + // w/h in blocks + uint32_t block_width = + xe::round_up(logical_width, src.format_info()->block_width) / + src.format_info()->block_width; + uint32_t block_height = + xe::round_up(logical_height, src.format_info()->block_height) / + src.format_info()->block_height; + + uint32_t size = block_width * block_height * bytes_per_block; + + // Minimum of one tile, which is 32x32 blocks. + uint32_t tile_size = 32 * 32 * bytes_per_block; + return std::max(size, tile_size) * (src.depth + 1); +} + +uint32_t TextureInfo::GetMipLinearSize(const TextureInfo& src, uint32_t mip) { + uint32_t bytes_per_block = src.format_info()->block_width * + src.format_info()->block_height * + src.format_info()->bits_per_pixel / 8; + uint32_t size = src.input_length >> (mip * 2); + + // The size is a multiple of the block size. + return xe::round_up(size, bytes_per_block); +} + +bool TextureInfo::GetPackedTileOffset(uint32_t width, uint32_t height, + const FormatInfo* format_info, uint32_t* out_offset_x, uint32_t* out_offset_y) { // Tile size is 32x32, and once textures go <=16 they are packed into a @@ -226,6 +505,13 @@ bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info, // This only works for square textures, or textures that are some non-pot // <= square. As soon as the aspect ratio goes weird, the textures start to // stretch across tiles. + // + // The 2x2 and 1x1 squares are packed in their specific positions because + // each square is the size of at least one block (which is 4x4 pixels max) + // 4x4: x = width & ~0x3 + // 2x2: y = (width & 0x3) << 2 + // 1x1: y = (width & 0x3) << 2 + // // if (tile_aligned(w) > tile_aligned(h)) { // // wider than tall, so packed horizontally // } else if (tile_aligned(w) < tile_aligned(h)) { @@ -238,44 +524,57 @@ bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info, // The minimum dimension is what matters most: if either width or height // is <= 16 this mode kicks in. - if (std::min(texture_info.size_2d.logical_width, - texture_info.size_2d.logical_height) > 16) { + uint32_t log2_width = xe::log2_ceil(width); + uint32_t log2_height = xe::log2_ceil(height); + if (std::min(log2_width, log2_height) > 4) { // Too big, not packed. *out_offset_x = 0; *out_offset_y = 0; return false; } - if (xe::log2_ceil(texture_info.size_2d.logical_width) > - xe::log2_ceil(texture_info.size_2d.logical_height)) { + // Find the block offset of the mip. + if (log2_width > log2_height) { // Wider than tall. Laid out vertically. - *out_offset_x = 0; - *out_offset_y = 16; + *out_offset_y = log2_height > 0x1 ? 1 << log2_height : 0; + *out_offset_x = log2_height <= 0x1 ? 1 << (log2_width + 2) : 0; } else { // Taller than wide. Laid out horizontally. - *out_offset_x = 16; - *out_offset_y = 0; + *out_offset_x = log2_width > 0x1 ? 1 << log2_width : 0; + *out_offset_y = log2_width <= 0x1 ? 1 << (log2_height + 2) : 0; } - *out_offset_x /= texture_info.format_info()->block_width; - *out_offset_y /= texture_info.format_info()->block_height; + + *out_offset_x /= format_info->block_width; + *out_offset_y /= format_info->block_height; return true; } +bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info, + uint32_t* out_offset_x, + uint32_t* out_offset_y) { + return GetPackedTileOffset(xe::next_pow2(texture_info.size_2d.logical_width), + xe::next_pow2(texture_info.size_2d.logical_height), + texture_info.format_info(), out_offset_x, + out_offset_y); +} + // https://github.com/BinomialLLC/crunch/blob/ea9b8d8c00c8329791256adafa8cf11e4e7942a2/inc/crn_decomp.h#L4108 uint32_t TextureInfo::TiledOffset2DOuter(uint32_t y, uint32_t width, - uint32_t log_bpp) { - uint32_t macro = ((y >> 5) * (width >> 5)) << (log_bpp + 7); - uint32_t micro = ((y & 6) << 2) << log_bpp; - return macro + ((micro & ~15) << 1) + (micro & 15) + - ((y & 8) << (3 + log_bpp)) + ((y & 1) << 4); + uint32_t log2_bpp) { + uint32_t macro = ((y / 32) * (width / 32)) << (log2_bpp + 7); + uint32_t micro = ((y & 6) << 2) << log2_bpp; + return macro + ((micro & ~0xF) << 1) + (micro & 0xF) + + ((y & 8) << (3 + log2_bpp)) + ((y & 1) << 4); } -uint32_t TextureInfo::TiledOffset2DInner(uint32_t x, uint32_t y, uint32_t bpp, +uint32_t TextureInfo::TiledOffset2DInner(uint32_t x, uint32_t y, + uint32_t log2_bpp, uint32_t base_offset) { - uint32_t macro = (x >> 5) << (bpp + 7); - uint32_t micro = (x & 7) << bpp; - uint32_t offset = base_offset + (macro + ((micro & ~15) << 1) + (micro & 15)); - return ((offset & ~511) << 3) + ((offset & 448) << 2) + (offset & 63) + + uint32_t macro = (x / 32) << (log2_bpp + 7); + uint32_t micro = (x & 7) << log2_bpp; + uint32_t offset = + base_offset + (macro + ((micro & ~0xF) << 1) + (micro & 0xF)); + return ((offset & ~0x1FF) << 3) + ((offset & 0x1C0) << 2) + (offset & 0x3F) + ((y & 16) << 7) + (((((y & 8) >> 2) + (x >> 3)) & 3) << 6); } diff --git a/src/xenia/gpu/texture_info.h b/src/xenia/gpu/texture_info.h index 3228a4768..cfce4cc43 100644 --- a/src/xenia/gpu/texture_info.h +++ b/src/xenia/gpu/texture_info.h @@ -256,6 +256,8 @@ struct TextureInfo { Endian endianness; bool is_tiled; bool has_packed_mips; + uint32_t mip_address; + uint32_t mip_levels; uint32_t input_length; const FormatInfo* format_info() const { @@ -283,8 +285,6 @@ struct TextureInfo { uint32_t input_pitch; // byte pitch } size_2d; struct { - } size_3d; - struct { uint32_t logical_width; uint32_t logical_height; uint32_t block_width; // # of horizontal blocks @@ -293,7 +293,7 @@ struct TextureInfo { uint32_t input_height; // texel height uint32_t input_pitch; // byte pitch uint32_t input_face_length; // byte pitch of face - } size_cube; + } size_3d, size_cube; }; static bool Prepare(const xenos::xe_gpu_texture_fetch_t& fetch, @@ -304,12 +304,33 @@ struct TextureInfo { uint32_t width, uint32_t height, TextureInfo* out_info); + static void ConvertTiled(uint8_t* dest, const uint8_t* src, Endian endian, + const FormatInfo* format_info, uint32_t offset_x, + uint32_t offset_y, uint32_t block_pitch, + uint32_t width, uint32_t height, + uint32_t output_width); + + static uint32_t GetMaxMipLevels(uint32_t width, uint32_t height, + uint32_t depth); + + // Get the memory location of a mip. offset_x and offset_y are in blocks. + static uint32_t GetMipLocation(const TextureInfo& src, uint32_t mip, + uint32_t* offset_x, uint32_t* offset_y); + static uint32_t GetMipSize(const TextureInfo& src, uint32_t mip); + + // Get the byte size of a MIP when stored linearly. + static uint32_t GetMipLinearSize(const TextureInfo& src, uint32_t mip); + + static bool GetPackedTileOffset(uint32_t width, uint32_t height, + const FormatInfo* format_info, + uint32_t* out_offset_x, + uint32_t* out_offset_y); static bool GetPackedTileOffset(const TextureInfo& texture_info, uint32_t* out_offset_x, uint32_t* out_offset_y); static uint32_t TiledOffset2DOuter(uint32_t y, uint32_t width, - uint32_t log_bpp); - static uint32_t TiledOffset2DInner(uint32_t x, uint32_t y, uint32_t bpp, + uint32_t log2_bpp); + static uint32_t TiledOffset2DInner(uint32_t x, uint32_t y, uint32_t log2_bpp, uint32_t base_offset); uint64_t hash() const; @@ -318,7 +339,9 @@ struct TextureInfo { } private: + void CalculateTextureSizes1D(uint32_t width); void CalculateTextureSizes2D(uint32_t width, uint32_t height); + void CalculateTextureSizes3D(uint32_t width, uint32_t height, uint32_t depth); void CalculateTextureSizesCube(uint32_t width, uint32_t height, uint32_t depth); }; diff --git a/src/xenia/gpu/vulkan/buffer_cache.cc b/src/xenia/gpu/vulkan/buffer_cache.cc index f975ec09f..0a0162d35 100644 --- a/src/xenia/gpu/vulkan/buffer_cache.cc +++ b/src/xenia/gpu/vulkan/buffer_cache.cc @@ -15,8 +15,7 @@ #include "xenia/base/profiling.h" #include "xenia/gpu/gpu_flags.h" #include "xenia/gpu/vulkan/vulkan_gpu_flags.h" - -#include "third_party/vulkan/vk_mem_alloc.h" +#include "xenia/ui/vulkan/vulkan_mem_alloc.h" using namespace xe::gpu::xenos; @@ -104,7 +103,7 @@ BufferCache::BufferCache(RegisterFile* register_file, Memory* memory, device_, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - capacity, 4096); + capacity, 256); } BufferCache::~BufferCache() { Shutdown(); } @@ -120,9 +119,13 @@ VkResult BufferCache::Initialize() { } // Create a memory allocator for textures. + VmaVulkanFunctions vulkan_funcs = {}; + ui::vulkan::FillVMAVulkanFunctions(&vulkan_funcs); + VmaAllocatorCreateInfo alloc_info = { - 0, *device_, *device_, 0, 0, nullptr, nullptr, + 0, *device_, *device_, 0, 0, nullptr, nullptr, 0, nullptr, &vulkan_funcs, }; + status = vmaCreateAllocator(&alloc_info, &mem_allocator_); if (status != VK_SUCCESS) { return status; @@ -147,10 +150,10 @@ VkResult xe::gpu::vulkan::BufferCache::CreateVertexDescriptorPool() { std::vector<VkDescriptorPoolSize> pool_sizes; pool_sizes.push_back({ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, - 65536, + 32 * 16384, }); - vertex_descriptor_pool_ = - std::make_unique<ui::vulkan::DescriptorPool>(*device_, 65536, pool_sizes); + vertex_descriptor_pool_ = std::make_unique<ui::vulkan::DescriptorPool>( + *device_, 32 * 16384, pool_sizes); // 32 storage buffers available to vertex shader. // TODO(DrChat): In the future, this could hold memexport staging data. @@ -287,7 +290,8 @@ VkResult BufferCache::CreateConstantDescriptorSet() { return VK_SUCCESS; } -void xe::gpu::vulkan::BufferCache::FreeConstantDescriptorSet() { + +void BufferCache::FreeConstantDescriptorSet() { if (constant_descriptor_set_) { vkFreeDescriptorSets(*device_, constant_descriptor_pool_, 1, &constant_descriptor_set_); diff --git a/src/xenia/gpu/vulkan/pipeline_cache.cc b/src/xenia/gpu/vulkan/pipeline_cache.cc index 4d5594276..e4ba55ba7 100644 --- a/src/xenia/gpu/vulkan/pipeline_cache.cc +++ b/src/xenia/gpu/vulkan/pipeline_cache.cc @@ -569,17 +569,13 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer, // http://ftp.tku.edu.tw/NetBSD/NetBSD-current/xsrc/external/mit/xf86-video-ati/dist/src/r600_reg_auto_r6xx.h // See r200UpdateWindow: // https://github.com/freedreno/mesa/blob/master/src/mesa/drivers/dri/r200/r200_state.c - int16_t window_offset_x = 0; - int16_t window_offset_y = 0; - if ((regs.pa_su_sc_mode_cntl >> 16) & 1) { - window_offset_x = regs.pa_sc_window_offset & 0x7FFF; - window_offset_y = (regs.pa_sc_window_offset >> 16) & 0x7FFF; - if (window_offset_x & 0x4000) { - window_offset_x |= 0x8000; - } - if (window_offset_y & 0x4000) { - window_offset_y |= 0x8000; - } + int16_t window_offset_x = regs.pa_sc_window_offset & 0x7FFF; + int16_t window_offset_y = (regs.pa_sc_window_offset >> 16) & 0x7FFF; + if (window_offset_x & 0x4000) { + window_offset_x |= 0x8000; + } + if (window_offset_y & 0x4000) { + window_offset_y |= 0x8000; } // VK_DYNAMIC_STATE_SCISSOR @@ -593,8 +589,11 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer, int32_t ws_y = (regs.pa_sc_window_scissor_tl >> 16) & 0x7FFF; int32_t ws_w = (regs.pa_sc_window_scissor_br & 0x7FFF) - ws_x; int32_t ws_h = ((regs.pa_sc_window_scissor_br >> 16) & 0x7FFF) - ws_y; - ws_x += window_offset_x; - ws_y += window_offset_y; + if (!(regs.pa_sc_window_scissor_tl & 0x80000000)) { + // ! WINDOW_OFFSET_DISABLE + ws_x += window_offset_x; + ws_y += window_offset_y; + } int32_t adj_x = ws_x - std::max(ws_x, 0); int32_t adj_y = ws_y - std::max(ws_y, 0); @@ -657,6 +656,11 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer, vport_zscale_enable == vport_xoffset_enable == vport_yoffset_enable == vport_zoffset_enable); + int16_t vtx_window_offset_x = + (regs.pa_su_sc_mode_cntl >> 16) & 1 ? window_offset_x : 0; + int16_t vtx_window_offset_y = + (regs.pa_su_sc_mode_cntl >> 16) & 1 ? window_offset_y : 0; + float vpw, vph, vpx, vpy; if (vport_xscale_enable) { float vox = vport_xoffset_enable ? regs.pa_cl_vport_xoffset : 0; @@ -667,25 +671,21 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer, window_width_scalar = window_height_scalar = 1; vpw = 2 * window_width_scalar * vsx; vph = -2 * window_height_scalar * vsy; - vpx = window_width_scalar * vox - vpw / 2 + window_offset_x; - vpy = window_height_scalar * voy - vph / 2 + window_offset_y; + vpx = window_width_scalar * vox - vpw / 2 + vtx_window_offset_x; + vpy = window_height_scalar * voy - vph / 2 + vtx_window_offset_y; } else { - vpw = 2 * 2560.0f * window_width_scalar; - vph = 2 * 2560.0f * window_height_scalar; - vpx = -2560.0f * window_width_scalar + window_offset_x; - vpy = -2560.0f * window_height_scalar + window_offset_y; + // TODO(DrChat): This should be the width/height of the target picture + vpw = 2560.0f; + vph = 2560.0f; + vpx = vtx_window_offset_x; + vpy = vtx_window_offset_y; } if (viewport_state_dirty) { - // float texel_offset_x = regs.pa_su_sc_vtx_cntl & 0x01 ? 0.5f : 0.f; - // float texel_offset_y = regs.pa_su_sc_vtx_cntl & 0x01 ? 0.5f : 0.f; - float texel_offset_x = 0.f; - float texel_offset_y = 0.f; - VkViewport viewport_rect; std::memset(&viewport_rect, 0, sizeof(VkViewport)); - viewport_rect.x = vpx + texel_offset_x; - viewport_rect.y = vpy + texel_offset_y; + viewport_rect.x = vpx; + viewport_rect.y = vpy; viewport_rect.width = vpw; viewport_rect.height = vph; @@ -766,18 +766,21 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer, program_cntl.vs_export_mode == 7); assert_false(program_cntl.gen_index_vtx); - SpirvPushConstants push_constants; + SpirvPushConstants push_constants = {}; // Done in VS, no need to flush state. - if ((regs.pa_cl_vte_cntl & (1 << 0)) > 0) { + if (vport_xscale_enable) { push_constants.window_scale[0] = 1.0f; push_constants.window_scale[1] = -1.0f; + push_constants.window_scale[2] = 0.f; + push_constants.window_scale[3] = 0.f; } else { - push_constants.window_scale[0] = 1.0f / 2560.0f; - push_constants.window_scale[1] = 1.0f / 2560.0f; + // 1 / unscaled viewport w/h + push_constants.window_scale[0] = window_width_scalar / 1280.f; + push_constants.window_scale[1] = window_height_scalar / 1280.f; + push_constants.window_scale[2] = (-1280.f / window_width_scalar) + 0.5f; + push_constants.window_scale[3] = (-1280.f / window_height_scalar) + 0.5f; } - push_constants.window_scale[2] = vpw; - push_constants.window_scale[3] = vph; // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf // VTX_XY_FMT = true: the incoming XY have already been multiplied by 1/W0. diff --git a/src/xenia/gpu/vulkan/premake5.lua b/src/xenia/gpu/vulkan/premake5.lua index 3e41ca44d..b399914a8 100644 --- a/src/xenia/gpu/vulkan/premake5.lua +++ b/src/xenia/gpu/vulkan/premake5.lua @@ -7,7 +7,7 @@ project("xenia-gpu-vulkan") kind("StaticLib") language("C++") links({ - "vulkan-loader", + "volk", "xenia-base", "xenia-gpu", "xenia-ui", @@ -40,7 +40,7 @@ project("xenia-gpu-vulkan-trace-viewer") "libavutil", "snappy", "spirv-tools", - "vulkan-loader", + "volk", "xenia-apu", "xenia-apu-nop", "xenia-base", @@ -71,6 +71,15 @@ project("xenia-gpu-vulkan-trace-viewer") "../../base/main_"..platform_suffix..".cc", }) + filter("platforms:Linux") + links({ + "X11", + "xcb", + "X11-xcb", + "GL", + "vulkan", + }) + filter("platforms:Windows") links({ "xenia-apu-xaudio2", @@ -103,7 +112,7 @@ project("xenia-gpu-vulkan-trace-dump") "libavutil", "snappy", "spirv-tools", - "vulkan-loader", + "volk", "xenia-apu", "xenia-apu-nop", "xenia-base", @@ -131,6 +140,15 @@ project("xenia-gpu-vulkan-trace-dump") "../../base/main_"..platform_suffix..".cc", }) + filter("platforms:Linux") + links({ + "X11", + "xcb", + "X11-xcb", + "GL", + "vulkan", + }) + filter("platforms:Windows") -- Only create the .user file if it doesn't already exist. local user_file = project_root.."/build/xenia-gpu-vulkan-trace-dump.vcxproj.user" diff --git a/src/xenia/gpu/vulkan/render_cache.cc b/src/xenia/gpu/vulkan/render_cache.cc index abae7b95c..5cdb848c0 100644 --- a/src/xenia/gpu/vulkan/render_cache.cc +++ b/src/xenia/gpu/vulkan/render_cache.cc @@ -87,6 +87,8 @@ class CachedFramebuffer { CachedTileView* color_attachments[4] = {nullptr}; // Reference to depth/stencil attachment, if used. CachedTileView* depth_stencil_attachment = nullptr; + // Associated render pass + VkRenderPass render_pass = nullptr; CachedFramebuffer(VkDevice device, VkRenderPass render_pass, uint32_t surface_width, uint32_t surface_height, @@ -94,6 +96,8 @@ class CachedFramebuffer { CachedTileView* target_depth_stencil_attachment); ~CachedFramebuffer(); + VkResult Initialize(); + bool IsCompatible(const RenderConfiguration& desired_config) const; private: @@ -117,6 +121,8 @@ class CachedRenderPass { CachedRenderPass(VkDevice device, const RenderConfiguration& desired_config); ~CachedRenderPass(); + VkResult Initialize(); + bool IsCompatible(const RenderConfiguration& desired_config) const; private: @@ -124,10 +130,21 @@ class CachedRenderPass { }; CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device, - VkCommandBuffer command_buffer, VkDeviceMemory edram_memory, TileViewKey view_key) - : device_(*device), key(std::move(view_key)) { + : device_(device), key(std::move(view_key)) {} + +CachedTileView::~CachedTileView() { + VK_SAFE_DESTROY(vkDestroyImageView, *device_, image_view, nullptr); + VK_SAFE_DESTROY(vkDestroyImageView, *device_, image_view_depth, nullptr); + VK_SAFE_DESTROY(vkDestroyImageView, *device_, image_view_stencil, nullptr); + VK_SAFE_DESTROY(vkDestroyImage, *device_, image, nullptr); + VK_SAFE_DESTROY(vkFreeMemory, *device_, memory, nullptr); +} + +VkResult CachedTileView::Initialize(VkCommandBuffer command_buffer) { + VkResult status = VK_SUCCESS; + // Map format to Vulkan. VkFormat vulkan_format = VK_FORMAT_UNDEFINED; uint32_t bpp = 4; @@ -196,22 +213,26 @@ CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device, image_info.queueFamilyIndexCount = 0; image_info.pQueueFamilyIndices = nullptr; image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; - auto err = vkCreateImage(device_, &image_info, nullptr, &image); - CheckResult(err, "vkCreateImage"); + status = vkCreateImage(*device_, &image_info, nullptr, &image); + if (status != VK_SUCCESS) { + return status; + } - device->DbgSetObjectName( + device_->DbgSetObjectName( reinterpret_cast<uint64_t>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - xe::format_string("%.8X pitch %.8X(%d)", key.tile_offset, key.tile_width, + xe::format_string("RT %.8X %.8X(%d)", key.tile_offset, key.tile_width, key.tile_width)); VkMemoryRequirements memory_requirements; - vkGetImageMemoryRequirements(*device, image, &memory_requirements); + vkGetImageMemoryRequirements(*device_, image, &memory_requirements); // Bind to a newly allocated chunk. // TODO: Alias from a really big buffer? - memory = device->AllocateMemory(memory_requirements, 0); - err = vkBindImageMemory(device_, image, memory, 0); - CheckResult(err, "vkBindImageMemory"); + memory = device_->AllocateMemory(memory_requirements, 0); + status = vkBindImageMemory(*device_, image, memory, 0); + if (status != VK_SUCCESS) { + return status; + } // Create the image view we'll use to attach it to a framebuffer. VkImageViewCreateInfo image_view_info; @@ -235,20 +256,26 @@ CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device, image_view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; } - err = vkCreateImageView(device_, &image_view_info, nullptr, &image_view); - CheckResult(err, "vkCreateImageView"); + status = vkCreateImageView(*device_, &image_view_info, nullptr, &image_view); + if (status != VK_SUCCESS) { + return status; + } // Create separate depth/stencil views. if (key.color_or_depth == 0) { image_view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; - err = vkCreateImageView(device_, &image_view_info, nullptr, - &image_view_depth); - CheckResult(err, "vkCreateImageView"); + status = vkCreateImageView(*device_, &image_view_info, nullptr, + &image_view_depth); + if (status != VK_SUCCESS) { + return status; + } image_view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; - err = vkCreateImageView(device_, &image_view_info, nullptr, - &image_view_stencil); - CheckResult(err, "vkCreateImageView"); + status = vkCreateImageView(*device_, &image_view_info, nullptr, + &image_view_stencil); + if (status != VK_SUCCESS) { + return status; + } } // TODO(benvanik): transition to general layout? @@ -279,12 +306,7 @@ CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device, 0, 0, nullptr, 0, nullptr, 1, &image_barrier); image_layout = image_barrier.newLayout; -} - -CachedTileView::~CachedTileView() { - vkDestroyImageView(device_, image_view, nullptr); - vkDestroyImage(device_, image, nullptr); - vkFreeMemory(device_, memory, nullptr); + return VK_SUCCESS; } CachedFramebuffer::CachedFramebuffer( @@ -294,11 +316,18 @@ CachedFramebuffer::CachedFramebuffer( : device_(device), width(surface_width), height(surface_height), - depth_stencil_attachment(target_depth_stencil_attachment) { + depth_stencil_attachment(target_depth_stencil_attachment), + render_pass(render_pass) { for (int i = 0; i < 4; ++i) { color_attachments[i] = target_color_attachments[i]; } +} + +CachedFramebuffer::~CachedFramebuffer() { + VK_SAFE_DESTROY(vkDestroyFramebuffer, device_, handle, nullptr); +} +VkResult CachedFramebuffer::Initialize() { // Create framebuffer. VkImageView image_views[5] = {nullptr}; int image_view_count = 0; @@ -320,12 +349,7 @@ CachedFramebuffer::CachedFramebuffer( framebuffer_info.width = width; framebuffer_info.height = height; framebuffer_info.layers = 1; - auto err = vkCreateFramebuffer(device_, &framebuffer_info, nullptr, &handle); - CheckResult(err, "vkCreateFramebuffer"); -} - -CachedFramebuffer::~CachedFramebuffer() { - vkDestroyFramebuffer(device_, handle, nullptr); + return vkCreateFramebuffer(device_, &framebuffer_info, nullptr, &handle); } bool CachedFramebuffer::IsCompatible( @@ -372,10 +396,21 @@ CachedRenderPass::CachedRenderPass(VkDevice device, const RenderConfiguration& desired_config) : device_(device) { std::memcpy(&config, &desired_config, sizeof(config)); +} + +CachedRenderPass::~CachedRenderPass() { + for (auto framebuffer : cached_framebuffers) { + delete framebuffer; + } + cached_framebuffers.clear(); + VK_SAFE_DESTROY(vkDestroyRenderPass, device_, handle, nullptr); +} + +VkResult CachedRenderPass::Initialize() { VkSampleCountFlagBits sample_count; if (FLAGS_vulkan_native_msaa) { - switch (desired_config.surface_msaa) { + switch (config.surface_msaa) { case MsaaSamples::k1X: sample_count = VK_SAMPLE_COUNT_1_BIT; break; @@ -386,7 +421,7 @@ CachedRenderPass::CachedRenderPass(VkDevice device, sample_count = VK_SAMPLE_COUNT_4_BIT; break; default: - assert_unhandled_case(desired_config.surface_msaa); + assert_unhandled_case(config.surface_msaa); break; } } else { @@ -480,17 +515,7 @@ CachedRenderPass::CachedRenderPass(VkDevice device, render_pass_info.dependencyCount = 1; render_pass_info.pDependencies = dependencies; - auto err = vkCreateRenderPass(device_, &render_pass_info, nullptr, &handle); - CheckResult(err, "vkCreateRenderPass"); -} - -CachedRenderPass::~CachedRenderPass() { - for (auto framebuffer : cached_framebuffers) { - delete framebuffer; - } - cached_framebuffers.clear(); - - vkDestroyRenderPass(device_, handle, nullptr); + return vkCreateRenderPass(device_, &render_pass_info, nullptr, &handle); } bool CachedRenderPass::IsCompatible( @@ -842,6 +867,14 @@ bool RenderCache::ConfigureRenderPass(VkCommandBuffer command_buffer, // If no render pass was found in the cache create a new one. if (!render_pass) { render_pass = new CachedRenderPass(*device_, *config); + VkResult status = render_pass->Initialize(); + if (status != VK_SUCCESS) { + XELOGE("%s: Failed to create render pass, status %s", __func__, + ui::vulkan::to_string(status)); + delete render_pass; + return false; + } + cached_render_passes_.push_back(render_pass); } @@ -913,6 +946,14 @@ bool RenderCache::ConfigureRenderPass(VkCommandBuffer command_buffer, framebuffer = new CachedFramebuffer( *device_, render_pass->handle, surface_pitch_px, surface_height_px, target_color_attachments, target_depth_stencil_attachment); + VkResult status = framebuffer->Initialize(); + if (status != VK_SUCCESS) { + XELOGE("%s: Failed to create framebuffer, status %s", __func__, + ui::vulkan::to_string(status)); + delete framebuffer; + return false; + } + render_pass->cached_framebuffers.push_back(framebuffer); } @@ -969,10 +1010,17 @@ CachedTileView* RenderCache::FindOrCreateTileView( } // Create a new tile and add to the cache. - tile_view = - new CachedTileView(device_, command_buffer, edram_memory_, view_key); - cached_tile_views_.push_back(tile_view); + tile_view = new CachedTileView(device_, edram_memory_, view_key); + VkResult status = tile_view->Initialize(command_buffer); + if (status != VK_SUCCESS) { + XELOGE("%s: Failed to create tile view, status %s", __func__, + ui::vulkan::to_string(status)); + delete tile_view; + return nullptr; + } + + cached_tile_views_.push_back(tile_view); return tile_view; } diff --git a/src/xenia/gpu/vulkan/render_cache.h b/src/xenia/gpu/vulkan/render_cache.h index 03c500de0..432dc5992 100644 --- a/src/xenia/gpu/vulkan/render_cache.h +++ b/src/xenia/gpu/vulkan/render_cache.h @@ -68,11 +68,12 @@ class CachedTileView { // (if a depth view) Image view of stencil aspect VkImageView image_view_stencil = nullptr; - CachedTileView(ui::vulkan::VulkanDevice* device, - VkCommandBuffer command_buffer, VkDeviceMemory edram_memory, + CachedTileView(ui::vulkan::VulkanDevice* device, VkDeviceMemory edram_memory, TileViewKey view_key); ~CachedTileView(); + VkResult Initialize(VkCommandBuffer command_buffer); + bool IsEqual(const TileViewKey& other_key) const { auto a = reinterpret_cast<const uint64_t*>(&key); auto b = reinterpret_cast<const uint64_t*>(&other_key); @@ -88,7 +89,7 @@ class CachedTileView { } private: - VkDevice device_ = nullptr; + ui::vulkan::VulkanDevice* device_ = nullptr; }; // Parsed render configuration from the current render state. diff --git a/src/xenia/gpu/vulkan/texture_cache.cc b/src/xenia/gpu/vulkan/texture_cache.cc index 07bbc409f..bccb1b7b8 100644 --- a/src/xenia/gpu/vulkan/texture_cache.cc +++ b/src/xenia/gpu/vulkan/texture_cache.cc @@ -17,8 +17,7 @@ #include "xenia/gpu/sampler_info.h" #include "xenia/gpu/texture_info.h" #include "xenia/gpu/vulkan/vulkan_gpu_flags.h" - -#include "third_party/vulkan/vk_mem_alloc.h" +#include "xenia/ui/vulkan/vulkan_mem_alloc.h" namespace xe { namespace gpu { @@ -62,7 +61,7 @@ static const TextureConfig texture_configs[64] = { // TODO: D24 unsupported on AMD. /* k_24_8 */ {VK_FORMAT_D24_UNORM_S8_UINT}, - /* k_24_8_FLOAT */ {VK_FORMAT_D24_UNORM_S8_UINT}, + /* k_24_8_FLOAT */ {VK_FORMAT_D32_SFLOAT_S8_UINT}, /* k_16 */ {VK_FORMAT_R16_UNORM}, /* k_16_16 */ {VK_FORMAT_R16G16_UNORM}, /* k_16_16_16_16 */ {VK_FORMAT_R16G16B16A16_UNORM}, @@ -198,8 +197,11 @@ VkResult TextureCache::Initialize() { } // Create a memory allocator for textures. + VmaVulkanFunctions vulkan_funcs = {}; + ui::vulkan::FillVMAVulkanFunctions(&vulkan_funcs); + VmaAllocatorCreateInfo alloc_info = { - 0, *device_, *device_, 0, 0, nullptr, nullptr, + 0, *device_, *device_, 0, 0, nullptr, nullptr, 0, nullptr, &vulkan_funcs, }; status = vmaCreateAllocator(&alloc_info, &mem_allocator_); if (status != VK_SUCCESS) { @@ -256,6 +258,18 @@ TextureCache::TextureRegion* TextureCache::AllocateTextureRegion( return nullptr; } + assert_not_null(texture->texture_info.format_info()); + auto& config = + texture_configs[int(texture->texture_info.format_info()->format)]; + VkFormat format = config.host_format; + if (format == VK_FORMAT_UNDEFINED) { + XELOGE( + "Texture Cache: Attempted to allocate texture format %s, which is " + "defined as VK_FORMAT_UNDEFINED!", + texture->texture_info.format_info()->name); + return nullptr; + } + image_info.tiling = VK_IMAGE_TILING_OPTIMAL; image_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; @@ -270,7 +284,6 @@ TextureCache::TextureRegion* TextureCache::AllocateTextureRegion( "(0x%.8X != 0x%.8X)", texture->texture_info.format_info()->name, texture->format, (props.optimalTilingFeatures & required_flags), required_flags); - assert_always(); } if (texture->texture_info.dimension != Dimension::kCube && @@ -296,7 +309,7 @@ TextureCache::TextureRegion* TextureCache::AllocateTextureRegion( image_info.format = texture->format; image_info.extent = region_size; - image_info.mipLevels = 1; + image_info.mipLevels = texture->texture_info.mip_levels; image_info.arrayLayers = texture->texture_info.depth + 1; image_info.samples = VK_SAMPLE_COUNT_1_BIT; image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; @@ -327,6 +340,7 @@ TextureCache::TextureRegion* TextureCache::AllocateTextureRegion( region->image = image; region->image_layout = image_info.initialLayout; + region->usage_flags = image_info.usage; region->allocation = allocation; region->allocation_info = vma_info; @@ -453,8 +467,7 @@ TextureCache::Texture* TextureCache::DemandResolveTexture( // No texture at this location. Make a new one. auto texture = AllocateTexture(texture_info, required_flags); if (!texture) { - // Failed to allocate texture (out of memory?) - assert_always(); + // Failed to allocate texture (out of memory) XELOGE("Vulkan Texture Cache: Failed to allocate texture!"); return nullptr; } @@ -595,8 +608,7 @@ TextureCache::TextureRegion* TextureCache::DemandRegion( auto texture = AllocateTexture(texture_info, VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); if (!texture) { - // Failed to allocate texture (out of memory?) - assert_always(); + // Failed to allocate texture (out of memory) XELOGE("Vulkan Texture Cache: Failed to allocate texture!"); return nullptr; } @@ -664,6 +676,13 @@ TextureCache::TextureRegionView* TextureCache::DemandTextureRegionView( VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_IDENTITY, }; + if (region->texture->texture_info.texture_format == + TextureFormat::k_4_4_4_4) { + swiz_component_map[0] = VK_COMPONENT_SWIZZLE_A; + swiz_component_map[1] = VK_COMPONENT_SWIZZLE_B; + swiz_component_map[2] = VK_COMPONENT_SWIZZLE_G; + swiz_component_map[3] = VK_COMPONENT_SWIZZLE_R; + } view_info.components = { swiz_component_map[(swizzle >> 0) & 0x7], @@ -671,7 +690,8 @@ TextureCache::TextureRegionView* TextureCache::DemandTextureRegionView( swiz_component_map[(swizzle >> 6) & 0x7], swiz_component_map[(swizzle >> 9) & 0x7], }; - view_info.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; + view_info.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, + region->texture->texture_info.mip_levels, 0, 1}; if (region->texture->format == VK_FORMAT_D16_UNORM_S8_UINT || region->texture->format == VK_FORMAT_D24_UNORM_S8_UINT || region->texture->format == VK_FORMAT_D32_SFLOAT_S8_UINT) { @@ -786,8 +806,6 @@ TextureCache::Sampler* TextureCache::Demand(const SamplerInfo& sampler_info) { sampler_create_info.addressModeW = address_mode_map[static_cast<int>(sampler_info.clamp_w)]; - sampler_create_info.mipLodBias = sampler_info.lod_bias; - float aniso = 0.f; switch (sampler_info.aniso_filter) { case AnisoFilter::kDisabled: @@ -819,8 +837,9 @@ TextureCache::Sampler* TextureCache::Demand(const SamplerInfo& sampler_info) { sampler_create_info.compareEnable = VK_FALSE; sampler_create_info.compareOp = VK_COMPARE_OP_NEVER; - sampler_create_info.minLod = 0.0f; - sampler_create_info.maxLod = 0.0f; + sampler_create_info.mipLodBias = sampler_info.lod_bias; + sampler_create_info.minLod = float(sampler_info.mip_min_level); + sampler_create_info.maxLod = float(sampler_info.mip_max_level); sampler_create_info.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK; sampler_create_info.unnormalizedCoordinates = VK_FALSE; VkSampler vk_sampler; @@ -938,13 +957,13 @@ void TextureSwap(Endian endianness, void* dest, const void* src, size_t length) { switch (endianness) { case Endian::k8in16: - xe::copy_and_swap_16_aligned(dest, src, length / 2); + xe::copy_and_swap_16_unaligned(dest, src, length / 2); break; case Endian::k8in32: - xe::copy_and_swap_32_aligned(dest, src, length / 4); + xe::copy_and_swap_32_unaligned(dest, src, length / 4); break; case Endian::k16in32: // Swap high and low 16 bits within a 32 bit word - xe::copy_and_swap_16_in_32_aligned(dest, src, length); + xe::copy_and_swap_16_in_32_unaligned(dest, src, length); break; default: case Endian::kUnspecified: @@ -989,144 +1008,56 @@ void TextureCache::FlushPendingCommands(VkCommandBuffer setup_buffer, vkBeginCommandBuffer(setup_buffer, &begin_info); } -void TextureCache::ConvertTexelCTX1(uint8_t* dest, size_t dest_pitch, - const uint8_t* src, Endian src_endianness) { - // http://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf - union { - uint8_t data[8]; - struct { - uint8_t r0, g0, r1, g1; - uint32_t xx; - }; - } block; - static_assert(sizeof(block) == 8, "CTX1 block mismatch"); - - const uint32_t bytes_per_block = 8; - TextureSwap(src_endianness, block.data, src, bytes_per_block); - - uint8_t cr[4] = { - block.r0, block.r1, - static_cast<uint8_t>(2.f / 3.f * block.r0 + 1.f / 3.f * block.r1), - static_cast<uint8_t>(1.f / 3.f * block.r0 + 2.f / 3.f * block.r1)}; - uint8_t cg[4] = { - block.g0, block.g1, - static_cast<uint8_t>(2.f / 3.f * block.g0 + 1.f / 3.f * block.g1), - static_cast<uint8_t>(1.f / 3.f * block.g0 + 2.f / 3.f * block.g1)}; - - for (uint32_t oy = 0; oy < 4; ++oy) { - for (uint32_t ox = 0; ox < 4; ++ox) { - uint8_t xx = (block.xx >> (((ox + (oy * 4)) * 2))) & 3; - dest[(oy * dest_pitch) + (ox * 2) + 0] = cr[xx]; - dest[(oy * dest_pitch) + (ox * 2) + 1] = cg[xx]; - } - } -} - bool TextureCache::ConvertTexture2D(uint8_t* dest, VkBufferImageCopy* copy_region, - const TextureInfo& src) { - void* host_address = memory_->TranslatePhysical(src.guest_address); + uint32_t mip, const TextureInfo& src) { + uint32_t offset_x = 0; + uint32_t offset_y = 0; + uint32_t address = + TextureInfo::GetMipLocation(src, mip, &offset_x, &offset_y); + void* host_address = memory_->TranslatePhysical(address); + + // Pitch of the source texture in blocks. + uint32_t block_width = mip == 0 + ? src.size_2d.block_width + : xe::next_pow2(src.size_2d.block_width) >> mip; + uint32_t logical_width = src.size_2d.logical_width >> mip; + uint32_t logical_height = src.size_2d.logical_height >> mip; + uint32_t input_width = src.size_2d.input_width >> mip; + uint32_t input_height = src.size_2d.input_height >> mip; + + // All dimensions must be a multiple of block w/h + logical_width = xe::round_up(logical_width, src.format_info()->block_width); + logical_height = + xe::round_up(logical_height, src.format_info()->block_height); + input_width = xe::round_up(input_width, src.format_info()->block_width); + input_height = xe::round_up(input_height, src.format_info()->block_height); + if (!src.is_tiled) { - uint32_t offset_x, offset_y; - if (src.has_packed_mips && - TextureInfo::GetPackedTileOffset(src, &offset_x, &offset_y)) { - uint32_t bytes_per_block = src.format_info()->block_width * - src.format_info()->block_height * - src.format_info()->bits_per_pixel / 8; - - const uint8_t* src_mem = reinterpret_cast<const uint8_t*>(host_address); - src_mem += offset_y * src.size_2d.input_pitch; - src_mem += offset_x * bytes_per_block; - for (uint32_t y = 0; - y < std::min(src.size_2d.block_height, src.size_2d.logical_height); - y++) { - TextureSwap(src.endianness, dest, src_mem, src.size_2d.input_pitch); - src_mem += src.size_2d.input_pitch; - dest += src.size_2d.input_pitch; - } - copy_region->bufferRowLength = src.size_2d.input_width; - copy_region->bufferImageHeight = src.size_2d.input_height; - copy_region->imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; - copy_region->imageExtent = {src.size_2d.logical_width, - src.size_2d.logical_height, 1}; - return true; - } else { - // Fast path copy entire image. - TextureSwap(src.endianness, dest, host_address, src.input_length); - copy_region->bufferRowLength = src.size_2d.input_width; - copy_region->bufferImageHeight = src.size_2d.input_height; - copy_region->imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; - copy_region->imageExtent = {src.size_2d.logical_width, - src.size_2d.logical_height, 1}; - return true; - } + uint32_t bytes_per_block = src.format_info()->block_width * + src.format_info()->block_height * + src.format_info()->bits_per_pixel / 8; + + const uint8_t* src_mem = reinterpret_cast<const uint8_t*>(host_address); + src_mem += offset_y * src.size_2d.input_pitch; + src_mem += offset_x * bytes_per_block; + TextureSwap(src.endianness, dest, src_mem, + src.size_2d.input_pitch * src.size_2d.logical_height); } else { // Untile image. // We could do this in a shader to speed things up, as this is pretty // slow. - - // TODO(benvanik): optimize this inner loop (or work by tiles). const uint8_t* src_mem = reinterpret_cast<const uint8_t*>(host_address); - uint32_t bytes_per_block = src.format_info()->block_width * - src.format_info()->block_height * - src.format_info()->bits_per_pixel / 8; - - uint32_t output_pitch = src.size_2d.input_width * - src.format_info()->block_width * - src.format_info()->bits_per_pixel / 8; - - uint32_t output_row_height = 1; - if (src.texture_format == TextureFormat::k_CTX1) { - // TODO: Can we calculate this? - output_row_height = 4; - } - - // Tiled textures can be packed; get the offset into the packed texture. - uint32_t offset_x; - uint32_t offset_y; - TextureInfo::GetPackedTileOffset(src, &offset_x, &offset_y); - auto log2_bpp = (bytes_per_block >> 2) + - ((bytes_per_block >> 1) >> (bytes_per_block >> 2)); - - // Offset to the current row, in bytes. - uint32_t output_row_offset = 0; - for (uint32_t y = 0; y < src.size_2d.block_height; y++) { - auto input_row_offset = TextureInfo::TiledOffset2DOuter( - offset_y + y, src.size_2d.block_width, log2_bpp); - - // Go block-by-block on this row. - uint32_t output_offset = output_row_offset; - for (uint32_t x = 0; x < src.size_2d.block_width; x++) { - auto input_offset = TextureInfo::TiledOffset2DInner( - offset_x + x, offset_y + y, log2_bpp, input_row_offset); - input_offset >>= log2_bpp; - - if (src.texture_format == TextureFormat::k_CTX1) { - // Convert to R8G8. - ConvertTexelCTX1(&dest[output_offset], output_pitch, src_mem, - src.endianness); - } else { - // Generic swap to destination. - TextureSwap(src.endianness, dest + output_offset, - src_mem + input_offset * bytes_per_block, - bytes_per_block); - } - - output_offset += bytes_per_block; - } - - output_row_offset += output_pitch * output_row_height; - } - - copy_region->bufferRowLength = src.size_2d.input_width; - copy_region->bufferImageHeight = src.size_2d.input_height; - copy_region->imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}; - copy_region->imageExtent = {src.size_2d.logical_width, - src.size_2d.logical_height, 1}; - return true; + TextureInfo::ConvertTiled(dest, src_mem, src.endianness, src.format_info(), + offset_x, offset_y, block_width, logical_width, + logical_height, input_width); } - return false; + copy_region->bufferRowLength = input_width; + copy_region->bufferImageHeight = input_height; + copy_region->imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, mip, 0, 1}; + copy_region->imageExtent = {logical_width, logical_height, 1}; + return true; } bool TextureCache::ConvertTextureCube(uint8_t* dest, @@ -1189,13 +1120,13 @@ bool TextureCache::ConvertTextureCube(uint8_t* dest, } bool TextureCache::ConvertTexture(uint8_t* dest, VkBufferImageCopy* copy_region, - const TextureInfo& src) { + uint32_t mip, const TextureInfo& src) { switch (src.dimension) { case Dimension::k1D: assert_always(); break; case Dimension::k2D: - return ConvertTexture2D(dest, copy_region, src); + return ConvertTexture2D(dest, copy_region, mip, src); case Dimension::k3D: assert_always(); break; @@ -1205,107 +1136,7 @@ bool TextureCache::ConvertTexture(uint8_t* dest, VkBufferImageCopy* copy_region, return false; } -bool TextureCache::ComputeTextureStorage(size_t* output_length, - const TextureInfo& src) { - if (src.texture_format == TextureFormat::k_CTX1) { - switch (src.dimension) { - case Dimension::k1D: { - assert_always(); - } break; - case Dimension::k2D: { - *output_length = src.size_2d.input_width * src.size_2d.input_height * 2; - return true; - } - case Dimension::k3D: { - assert_always(); - } break; - case Dimension::kCube: { - *output_length = - src.size_cube.input_width * src.size_cube.input_height * 2 * 6; - return true; - } - } - return false; - } else { - *output_length = src.input_length; - return true; - } -} - -void TextureCache::WritebackTexture(Texture* texture) { - VkResult status = VK_SUCCESS; - VkFence fence = wb_command_pool_->BeginBatch(); - auto alloc = wb_staging_buffer_.Acquire( - texture->base_region->allocation_info.size, fence); - if (!alloc) { - wb_command_pool_->EndBatch(); - return; - } - - auto command_buffer = wb_command_pool_->AcquireEntry(); - - VkCommandBufferBeginInfo begin_info = { - VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, - nullptr, - VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, - nullptr, - }; - vkBeginCommandBuffer(command_buffer, &begin_info); - - // TODO: Transition the texture to a transfer source. - - VkBufferImageCopy region = { - alloc->offset, - 0, - 0, - {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, - {0, 0, 0}, - {texture->texture_info.width + 1, texture->texture_info.height + 1, 1}, - }; - - vkCmdCopyImageToBuffer(command_buffer, texture->base_region->image, - VK_IMAGE_LAYOUT_GENERAL, - wb_staging_buffer_.gpu_buffer(), 1, ®ion); - - // TODO: Transition the texture back to a shader resource. - - vkEndCommandBuffer(command_buffer); - - // Submit the command buffer. - // Submit commands and wait. - { - std::lock_guard<std::mutex>(device_->primary_queue_mutex()); - VkSubmitInfo submit_info = { - VK_STRUCTURE_TYPE_SUBMIT_INFO, - nullptr, - 0, - nullptr, - nullptr, - 1, - &command_buffer, - 0, - nullptr, - }; - status = vkQueueSubmit(device_->primary_queue(), 1, &submit_info, fence); - CheckResult(status, "vkQueueSubmit"); - - if (status == VK_SUCCESS) { - status = vkQueueWaitIdle(device_->primary_queue()); - CheckResult(status, "vkQueueWaitIdle"); - } - } - - wb_command_pool_->EndBatch(); - - auto dest = memory_->TranslatePhysical(texture->texture_info.guest_address); - if (status == VK_SUCCESS) { - std::memcpy(dest, alloc->host_ptr, texture->texture_info.input_length); - } - - wb_staging_buffer_.Scavenge(); -} - -bool TextureCache::UploadTexture(VkCommandBuffer setup_buffer, +bool TextureCache::UploadTexture(VkCommandBuffer command_buffer, VkFence completion_fence, Texture* dest, const TextureInfo& src) { #if FINE_GRAINED_DRAW_SCOPES @@ -1318,26 +1149,36 @@ bool TextureCache::UploadTexture(VkCommandBuffer setup_buffer, return false; } - if (!staging_buffer_.CanAcquire(unpack_length)) { + size_t total_unpack_length = unpack_length; + for (uint32_t i = 1; i < src.mip_levels; i++) { + // Add in more space for mips. + total_unpack_length += TextureInfo::GetMipLinearSize(src, i); + } + + if (!staging_buffer_.CanAcquire(total_unpack_length)) { // Need to have unique memory for every upload for at least one frame. If we // run out of memory, we need to flush all queued upload commands to the // GPU. - FlushPendingCommands(setup_buffer, completion_fence); + FlushPendingCommands(command_buffer, completion_fence); // Uploads have been flushed. Continue. - if (!staging_buffer_.CanAcquire(unpack_length)) { + if (!staging_buffer_.CanAcquire(total_unpack_length)) { // The staging buffer isn't big enough to hold this texture. XELOGE( "TextureCache staging buffer is too small! (uploading 0x%.8X bytes)", - unpack_length); + total_unpack_length); assert_always(); return false; } } // Grab some temporary memory for staging. - auto alloc = staging_buffer_.Acquire(unpack_length, completion_fence); + auto alloc = staging_buffer_.Acquire(total_unpack_length, completion_fence); assert_not_null(alloc); + if (!alloc) { + XELOGE("%s: Failed to acquire staging memory", __func__); + return false; + } // DEBUG: Check the source address. If it's completely zero'd out, print it. bool valid = false; @@ -1352,8 +1193,8 @@ bool TextureCache::UploadTexture(VkCommandBuffer setup_buffer, if (!valid) { XELOGW( "Warning: Uploading blank texture at address 0x%.8X " - "(length: 0x%.8X, format: %d)", - src.guest_address, src.input_length, src.texture_format); + "(length: 0x%.8X, format: %s)", + src.guest_address, src.input_length, src.format_info()->name); } // Invalidate contents of all regions for this texture, except for the base @@ -1368,12 +1209,28 @@ bool TextureCache::UploadTexture(VkCommandBuffer setup_buffer, // TODO: If the GPU supports it, we can submit a compute batch to convert the // texture and copy it to its destination. Otherwise, fallback to conversion // on the CPU. - VkBufferImageCopy copy_region; - if (!ConvertTexture(reinterpret_cast<uint8_t*>(alloc->host_ptr), ©_region, - src)) { + std::vector<VkBufferImageCopy> copy_regions(src.mip_levels); + + // Base MIP + if (!ConvertTexture(reinterpret_cast<uint8_t*>(alloc->host_ptr), + ©_regions[0], 0, src)) { XELOGW("Failed to convert texture"); return false; } + copy_regions[0].bufferOffset = alloc->offset; + copy_regions[0].imageOffset = {0, 0, 0}; + + // Now upload all the MIPs + VkDeviceSize buffer_offset = unpack_length; + for (uint32_t mip = 1; mip < src.mip_levels; mip++) { + uint8_t* dest = reinterpret_cast<uint8_t*>(alloc->host_ptr) + buffer_offset; + ConvertTexture(dest, ©_regions[mip], mip, src); + copy_regions[mip].bufferOffset = alloc->offset + buffer_offset; + copy_regions[mip].imageOffset = {0, 0, 0}; + + // With each mip, the length is divided by 4. + buffer_offset += TextureInfo::GetMipLinearSize(src, mip); + } // Transition the texture into a transfer destination layout. VkImageMemoryBarrier barrier; @@ -1386,9 +1243,9 @@ bool TextureCache::UploadTexture(VkCommandBuffer setup_buffer, barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.image = dest->base_region->image; - barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, - copy_region.imageSubresource.baseArrayLayer, - copy_region.imageSubresource.layerCount}; + barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, src.mip_levels, + copy_regions[0].imageSubresource.baseArrayLayer, + copy_regions[0].imageSubresource.layerCount}; if (dest->format == VK_FORMAT_D16_UNORM_S8_UINT || dest->format == VK_FORMAT_D24_UNORM_S8_UINT || dest->format == VK_FORMAT_D32_SFLOAT_S8_UINT) { @@ -1396,29 +1253,29 @@ bool TextureCache::UploadTexture(VkCommandBuffer setup_buffer, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; } - vkCmdPipelineBarrier(setup_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, + vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier); // Now move the converted texture into the destination. - copy_region.bufferOffset = alloc->offset; - copy_region.imageOffset = {0, 0, 0}; if (dest->format == VK_FORMAT_D16_UNORM_S8_UINT || dest->format == VK_FORMAT_D24_UNORM_S8_UINT || dest->format == VK_FORMAT_D32_SFLOAT_S8_UINT) { // Do just a depth upload (for now). - copy_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; + // This assumes depth buffers don't have mips (hopefully they don't) + copy_regions[0].imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; } - vkCmdCopyBufferToImage(setup_buffer, staging_buffer_.gpu_buffer(), + vkCmdCopyBufferToImage(command_buffer, staging_buffer_.gpu_buffer(), dest->base_region->image, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©_region); + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, src.mip_levels, + copy_regions.data()); // Now transition the texture into a shader readonly source. barrier.srcAccessMask = barrier.dstAccessMask; barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; barrier.oldLayout = barrier.newLayout; barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - vkCmdPipelineBarrier(setup_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, + vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier); @@ -1427,6 +1284,106 @@ bool TextureCache::UploadTexture(VkCommandBuffer setup_buffer, return true; } +bool TextureCache::ComputeTextureStorage(size_t* output_length, + const TextureInfo& src) { + if (src.texture_format == TextureFormat::k_CTX1) { + switch (src.dimension) { + case Dimension::k1D: { + assert_always(); + } break; + case Dimension::k2D: { + *output_length = src.size_2d.input_width * src.size_2d.input_height * 2; + return true; + } + case Dimension::k3D: { + assert_always(); + } break; + case Dimension::kCube: { + *output_length = + src.size_cube.input_width * src.size_cube.input_height * 2 * 6; + return true; + } + } + return false; + } else { + *output_length = src.input_length; + return true; + } +} + +void TextureCache::WritebackTexture(Texture* texture) { + VkResult status = VK_SUCCESS; + VkFence fence = wb_command_pool_->BeginBatch(); + auto alloc = wb_staging_buffer_.Acquire( + texture->base_region->allocation_info.size, fence); + if (!alloc) { + wb_command_pool_->EndBatch(); + return; + } + + auto command_buffer = wb_command_pool_->AcquireEntry(); + + VkCommandBufferBeginInfo begin_info = { + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + nullptr, + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, + nullptr, + }; + vkBeginCommandBuffer(command_buffer, &begin_info); + + // TODO: Transition the texture to a transfer source. + + VkBufferImageCopy region = { + alloc->offset, + 0, + 0, + {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, + {0, 0, 0}, + {texture->texture_info.width + 1, texture->texture_info.height + 1, 1}, + }; + + vkCmdCopyImageToBuffer(command_buffer, texture->base_region->image, + VK_IMAGE_LAYOUT_GENERAL, + wb_staging_buffer_.gpu_buffer(), 1, ®ion); + + // TODO: Transition the texture back to a shader resource. + + vkEndCommandBuffer(command_buffer); + + // Submit the command buffer. + // Submit commands and wait. + { + std::lock_guard<std::mutex>(device_->primary_queue_mutex()); + VkSubmitInfo submit_info = { + VK_STRUCTURE_TYPE_SUBMIT_INFO, + nullptr, + 0, + nullptr, + nullptr, + 1, + &command_buffer, + 0, + nullptr, + }; + status = vkQueueSubmit(device_->primary_queue(), 1, &submit_info, fence); + CheckResult(status, "vkQueueSubmit"); + + if (status == VK_SUCCESS) { + status = vkQueueWaitIdle(device_->primary_queue()); + CheckResult(status, "vkQueueWaitIdle"); + } + } + + wb_command_pool_->EndBatch(); + + auto dest = memory_->TranslatePhysical(texture->texture_info.guest_address); + if (status == VK_SUCCESS) { + std::memcpy(dest, alloc->host_ptr, texture->texture_info.input_length); + } + + wb_staging_buffer_.Scavenge(); +} + void TextureCache::HashTextureBindings( XXH64_state_t* hash_state, uint32_t& fetch_mask, const std::vector<Shader::TextureBinding>& bindings) { diff --git a/src/xenia/gpu/vulkan/texture_cache.h b/src/xenia/gpu/vulkan/texture_cache.h index c19a58f3e..01716b864 100644 --- a/src/xenia/gpu/vulkan/texture_cache.h +++ b/src/xenia/gpu/vulkan/texture_cache.h @@ -65,6 +65,7 @@ class TextureCache { VkImage image; VkImageLayout image_layout; + VkImageUsageFlags usage_flags; VmaAllocation allocation; VmaAllocationInfo allocation_info; @@ -172,15 +173,12 @@ class TextureCache { void FlushPendingCommands(VkCommandBuffer setup_buffer, VkFence completion_fence); - static void ConvertTexelCTX1(uint8_t* dest, size_t dest_pitch, - const uint8_t* src, Endian src_endianness); - bool ConvertTexture2D(uint8_t* dest, VkBufferImageCopy* copy_region, - const TextureInfo& src); - bool ConvertTextureCube(uint8_t* dest, VkBufferImageCopy* copy_region, + uint32_t mip, const TextureInfo& src); + bool ConvertTextureCube(uint8_t* dest, VkBufferImageCopy* copy_regions, const TextureInfo& src); bool ConvertTexture(uint8_t* dest, VkBufferImageCopy* copy_region, - const TextureInfo& src); + uint32_t mip, const TextureInfo& src); bool ComputeTextureStorage(size_t* output_length, const TextureInfo& src); // Writes a texture back into guest memory. This call is (mostly) asynchronous diff --git a/src/xenia/gpu/vulkan/vulkan_command_processor.cc b/src/xenia/gpu/vulkan/vulkan_command_processor.cc index 559fad74d..335a312d6 100644 --- a/src/xenia/gpu/vulkan/vulkan_command_processor.cc +++ b/src/xenia/gpu/vulkan/vulkan_command_processor.cc @@ -915,15 +915,8 @@ bool VulkanCommandProcessor::IssueCopy() { // vtx_window_offset_enable assert_true(regs[XE_GPU_REG_PA_SU_SC_MODE_CNTL].u32 & 0x00010000); uint32_t window_offset = regs[XE_GPU_REG_PA_SC_WINDOW_OFFSET].u32; - int16_t window_offset_x = window_offset & 0x7FFF; - int16_t window_offset_y = (window_offset >> 16) & 0x7FFF; - // Sign-extension - if (window_offset_x & 0x4000) { - window_offset_x |= 0x8000; - } - if (window_offset_y & 0x4000) { - window_offset_y |= 0x8000; - } + int32_t window_offset_x = window_regs->window_offset.window_x_offset; + int32_t window_offset_y = window_regs->window_offset.window_y_offset; uint32_t dest_texel_size = uint32_t(GetTexelSize(copy_dest_format)); @@ -1027,7 +1020,18 @@ bool VulkanCommandProcessor::IssueCopy() { std::max(1u, dest_logical_height), &texture_info); auto texture = texture_cache_->DemandResolveTexture(texture_info); - assert_not_null(texture); + if (!texture) { + // Out of memory. + return false; + } + + if (!(texture->base_region->usage_flags & + (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT))) { + // Resolve image doesn't support drawing, and we don't support conversion. + return false; + } + texture->in_flight_fence = current_batch_fence_; // For debugging purposes only (trace viewer) @@ -1188,35 +1192,50 @@ bool VulkanCommandProcessor::IssueCopy() { resolve_extent, }; - // By offsetting the destination texture by the window offset, we've - // already handled it and need to subtract the window offset from the - // destination rectangle. VkRect2D dst_rect = { - {resolve_offset.x + window_offset_x, - resolve_offset.y + window_offset_y}, + {resolve_offset.x, resolve_offset.y}, resolve_extent, }; + // If the destination rectangle lies outside the window, make it start + // inside. The Xenos does not copy pixel data at any offset in screen + // coordinates. + int32_t dst_adj_x = + std::max(dst_rect.offset.x, -window_offset_x) - dst_rect.offset.x; + int32_t dst_adj_y = + std::max(dst_rect.offset.y, -window_offset_y) - dst_rect.offset.y; + + if (uint32_t(dst_adj_x) > dst_rect.extent.width || + uint32_t(dst_adj_y) > dst_rect.extent.height) { + // No-op? + break; + } + + dst_rect.offset.x += dst_adj_x; + dst_rect.offset.y += dst_adj_y; + dst_rect.extent.width -= dst_adj_x; + dst_rect.extent.height -= dst_adj_y; + src_rect.extent.width -= dst_adj_x; + src_rect.extent.height -= dst_adj_y; + VkViewport viewport = { - float(-window_offset_x), - float(-window_offset_y), - float(copy_dest_pitch), - float(copy_dest_height), - 0.f, - 1.f, + 0.f, 0.f, float(copy_dest_pitch), float(copy_dest_height), 0.f, 1.f, }; + uint32_t scissor_tl_x = window_regs->window_scissor_tl.tl_x; + uint32_t scissor_br_x = window_regs->window_scissor_br.br_x; + uint32_t scissor_tl_y = window_regs->window_scissor_tl.tl_y; + uint32_t scissor_br_y = window_regs->window_scissor_br.br_y; + + // Clamp the values to destination dimensions. + scissor_tl_x = std::min(scissor_tl_x, copy_dest_pitch); + scissor_br_x = std::min(scissor_br_x, copy_dest_pitch); + scissor_tl_y = std::min(scissor_tl_y, copy_dest_height); + scissor_br_y = std::min(scissor_br_y, copy_dest_height); + VkRect2D scissor = { - { - int32_t(window_regs->window_scissor_tl.tl_x.value()), - int32_t(window_regs->window_scissor_tl.tl_y.value()), - }, - { - window_regs->window_scissor_br.br_x.value() - - window_regs->window_scissor_tl.tl_x.value(), - window_regs->window_scissor_br.br_y.value() - - window_regs->window_scissor_tl.tl_y.value(), - }, + {int32_t(scissor_tl_x), int32_t(scissor_tl_y)}, + {scissor_br_x - scissor_tl_x, scissor_br_y - scissor_tl_y}, }; blitter_->BlitTexture2D( diff --git a/src/xenia/gpu/xenos.h b/src/xenia/gpu/xenos.h index e0dd8e35c..d6a24a856 100644 --- a/src/xenia/gpu/xenos.h +++ b/src/xenia/gpu/xenos.h @@ -601,20 +601,18 @@ enum Type3Opcode { }; // clang-format on -template <uint16_t index, uint16_t count, bool one_reg = false> -constexpr inline uint32_t MakePacketType0() { +inline uint32_t MakePacketType0(uint16_t index, uint16_t count, + bool one_reg = false) { // ttcccccc cccccccc oiiiiiii iiiiiiii - static_assert(index <= 0x7FFF, "index must be <= 0x7FFF"); - static_assert(count >= 1 && count <= 0x4000, - "count must be >= 1 and <= 0x4000"); + assert(index <= 0x7FFF); + assert(count >= 1 && count <= 0x4000); return (0u << 30) | (((count - 1) & 0x3FFF) << 16) | (index & 0x7FFF); } -template <uint16_t index_1, uint16_t index_2> -constexpr inline uint32_t MakePacketType1() { +inline uint32_t MakePacketType1(uint16_t index_1, uint16_t index_2) { // tt?????? ??222222 22222111 11111111 - static_assert(index_1 <= 0x7FF, "index_1 must be <= 0x7FF"); - static_assert(index_2 <= 0x7FF, "index_2 must be <= 0x7FF"); + assert(index_1 <= 0x7FF); + assert(index_2 <= 0x7FF); return (1u << 30) | ((index_2 & 0x7FF) << 11) | (index_1 & 0x7FF); } @@ -623,12 +621,11 @@ constexpr inline uint32_t MakePacketType2() { return (2u << 30); } -template <Type3Opcode opcode, uint16_t count, bool predicate = false> -constexpr inline uint32_t MakePacketType3() { +inline uint32_t MakePacketType3(Type3Opcode opcode, uint16_t count, + bool predicate = false) { // ttcccccc cccccccc ?ooooooo ???????p - static_assert(opcode <= 0x7F, "opcode must be <= 0x7F"); - static_assert(count >= 1 && count <= 0x4000, - "count must be >= 1 and <= 0x4000"); + assert(opcode <= 0x7F); + assert(count >= 1 && count <= 0x4000); return (3u << 30) | (((count - 1) & 0x3FFF) << 16) | ((opcode & 0x7F) << 8) | (predicate ? 1 : 0); } diff --git a/src/xenia/hid/hid_demo.cc b/src/xenia/hid/hid_demo.cc index 70c84a35f..5afe6eef4 100644 --- a/src/xenia/hid/hid_demo.cc +++ b/src/xenia/hid/hid_demo.cc @@ -17,8 +17,8 @@ #include "xenia/base/main.h" #include "xenia/base/threading.h" #include "xenia/hid/input_system.h" -#include "xenia/ui/gl/gl_provider.h" #include "xenia/ui/imgui_drawer.h" +#include "xenia/ui/vulkan/vulkan_provider.h" #include "xenia/ui/window.h" // Available input drivers: @@ -67,7 +67,7 @@ std::vector<std::unique_ptr<hid::InputDriver>> CreateInputDrivers( std::unique_ptr<xe::ui::GraphicsProvider> CreateDemoGraphicsProvider( xe::ui::Window* window) { - return xe::ui::gl::GLProvider::Create(window); + return xe::ui::vulkan::VulkanProvider::Create(window); } void DrawInputStatus(); diff --git a/src/xenia/hid/premake5.lua b/src/xenia/hid/premake5.lua index 69ea6c197..a348160f6 100644 --- a/src/xenia/hid/premake5.lua +++ b/src/xenia/hid/premake5.lua @@ -26,12 +26,23 @@ project("xenia-hid-demo") "gflags", "glew", "imgui", + "volk", "xenia-base", "xenia-hid", "xenia-hid-nop", "xenia-ui", - "xenia-ui-gl", + "xenia-ui-vulkan", }) + filter("platforms:Linux") + links({ + "X11", + "xcb", + "X11-xcb", + "GL", + "vulkan", + }) + filter() + flags({ "WinMain", -- Use WinMain instead of main. }) diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc index 560cec820..92f9ac2d3 100644 --- a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc +++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc @@ -160,13 +160,13 @@ DECLARE_XBOXKRNL_EXPORT(VdSetDisplayModeOverride, ExportTag::kVideo | ExportTag::kStub); dword_result_t VdInitializeEngines(unknown_t unk0, function_t callback, - lpvoid_t arg, lpunknown_t unk2_ptr, - lpunknown_t unk3_ptr) { + lpvoid_t arg, lpdword_t pfp_ptr, + lpdword_t me_ptr) { // r3 = 0x4F810000 // r4 = function ptr (cleanup callback?) // r5 = function arg - // r6 = register init cmds(?) - // r7 = gpu init cmds(?) + // r6 = PFP Microcode + // r7 = ME Microcode return 1; } DECLARE_XBOXKRNL_EXPORT(VdInitializeEngines, @@ -205,12 +205,6 @@ DECLARE_XBOXKRNL_EXPORT(VdSetGraphicsInterruptCallback, ExportTag::kVideo); void VdInitializeRingBuffer(lpvoid_t ptr, int_t log2_size) { // r3 = result of MmGetPhysicalAddress // r4 = log2(size) - // r4 is or'd with 0x802 and then stuffed into CP_RB_CNTL - // according to AMD docs, this corresponds with RB_BUFSZ, which is log2 - // actual size. - // 0x8 is RB_BLKSZ, or number of words gpu will read before updating the - // host read pointer. - // So being or'd with 0x2 makes the ring buffer size always a multiple of 4. // Buffer pointers are from MmAllocatePhysicalMemory with WRITE_COMBINE. auto graphics_system = kernel_state()->emulator()->graphics_system(); graphics_system->InitializeRingBuffer(ptr, log2_size); @@ -374,7 +368,7 @@ void VdSwap(lpvoid_t buffer_ptr, // ptr into primary ringbuffer // Write in the texture fetch. dwords[offset++] = - xenos::MakePacketType0<gpu::XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0, 6>(); + xenos::MakePacketType0(gpu::XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0, 6); dwords[offset++] = fetch.dword_0; dwords[offset++] = fetch.dword_1; dwords[offset++] = fetch.dword_2; @@ -382,7 +376,7 @@ void VdSwap(lpvoid_t buffer_ptr, // ptr into primary ringbuffer dwords[offset++] = fetch.dword_4; dwords[offset++] = fetch.dword_5; - dwords[offset++] = xenos::MakePacketType3<xenos::PM4_XE_SWAP, 4>(); + dwords[offset++] = xenos::MakePacketType3(xenos::PM4_XE_SWAP, 4); dwords[offset++] = 'SWAP'; dwords[offset++] = (*frontbuffer_ptr) & 0x1FFFFFFF; diff --git a/src/xenia/ui/gl/blitter.cc b/src/xenia/ui/gl/blitter.cc deleted file mode 100644 index 7501758ca..000000000 --- a/src/xenia/ui/gl/blitter.cc +++ /dev/null @@ -1,315 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/ui/gl/blitter.h" - -#include <string> - -#include "xenia/base/assert.h" -#include "xenia/base/math.h" -#include "xenia/ui/gl/gl_context.h" - -namespace xe { -namespace ui { -namespace gl { - -Blitter::Blitter() - : vertex_program_(0), - color_fragment_program_(0), - depth_fragment_program_(0), - color_pipeline_(0), - depth_pipeline_(0), - vbo_(0), - vao_(0), - nearest_sampler_(0), - linear_sampler_(0), - scratch_framebuffer_(0) {} - -Blitter::~Blitter() = default; - -bool Blitter::Initialize() { - const std::string header = - R"( -#version 450 -#extension GL_ARB_explicit_uniform_location : require -#extension GL_ARB_shading_language_420pack : require -precision highp float; -precision highp int; -layout(std140, column_major) uniform; -layout(std430, column_major) buffer; -)"; - const std::string vs_source = header + - R"( -layout(location = 0) uniform vec4 src_uv; -out gl_PerVertex { - vec4 gl_Position; - float gl_PointSize; - float gl_ClipDistance[]; -}; -layout(location = 0) in vec2 vfetch_pos; -layout(location = 0) out vec2 vtx_uv; -void main() { - gl_Position = vec4(vfetch_pos.xy * vec2(2.0, -2.0) - - vec2(1.0, -1.0), 0.0, 1.0); - vtx_uv = vfetch_pos.xy * src_uv.zw + src_uv.xy; -})"; - const std::string color_fs_source = header + - R"( -layout(location = 1) uniform sampler2D src_texture; -layout(location = 2) uniform bool swap; -layout(location = 0) in vec2 vtx_uv; -layout(location = 0) out vec4 oC; -void main() { - oC = texture(src_texture, vtx_uv); - if (!swap) oC = oC.bgra; -})"; - const std::string depth_fs_source = header + - R"( -layout(location = 1) uniform sampler2D src_texture; -layout(location = 0) in vec2 vtx_uv; -layout(location = 0) out vec4 oC; -void main() { - gl_FragDepth = texture(src_texture, vtx_uv).r; -})"; - - auto vs_source_str = vs_source.c_str(); - vertex_program_ = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &vs_source_str); - auto color_fs_source_str = color_fs_source.c_str(); - color_fragment_program_ = - glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &color_fs_source_str); - auto depth_fs_source_str = depth_fs_source.c_str(); - depth_fragment_program_ = - glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &depth_fs_source_str); - glCreateProgramPipelines(1, &color_pipeline_); - glUseProgramStages(color_pipeline_, GL_VERTEX_SHADER_BIT, vertex_program_); - glUseProgramStages(color_pipeline_, GL_FRAGMENT_SHADER_BIT, - color_fragment_program_); - glCreateProgramPipelines(1, &depth_pipeline_); - glUseProgramStages(depth_pipeline_, GL_VERTEX_SHADER_BIT, vertex_program_); - glUseProgramStages(depth_pipeline_, GL_FRAGMENT_SHADER_BIT, - depth_fragment_program_); - - glCreateBuffers(1, &vbo_); - static const GLfloat vbo_data[] = { - 0, 0, 1, 0, 0, 1, 1, 1, - }; - glNamedBufferStorage(vbo_, sizeof(vbo_data), vbo_data, 0); - - glCreateVertexArrays(1, &vao_); - glEnableVertexArrayAttrib(vao_, 0); - glVertexArrayAttribBinding(vao_, 0, 0); - glVertexArrayAttribFormat(vao_, 0, 2, GL_FLOAT, GL_FALSE, 0); - glVertexArrayVertexBuffer(vao_, 0, vbo_, 0, sizeof(GLfloat) * 2); - - glCreateSamplers(1, &nearest_sampler_); - glSamplerParameteri(nearest_sampler_, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glSamplerParameteri(nearest_sampler_, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glSamplerParameteri(nearest_sampler_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); - glSamplerParameteri(nearest_sampler_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - glCreateSamplers(1, &linear_sampler_); - glSamplerParameteri(linear_sampler_, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glSamplerParameteri(linear_sampler_, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glSamplerParameteri(linear_sampler_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); - glSamplerParameteri(linear_sampler_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - - glCreateFramebuffers(1, &scratch_framebuffer_); - - return true; -} - -void Blitter::Shutdown() { - glDeleteFramebuffers(1, &scratch_framebuffer_); - glDeleteProgram(vertex_program_); - glDeleteProgram(color_fragment_program_); - glDeleteProgram(depth_fragment_program_); - glDeleteProgramPipelines(1, &color_pipeline_); - glDeleteProgramPipelines(1, &depth_pipeline_); - glDeleteBuffers(1, &vbo_); - glDeleteVertexArrays(1, &vao_); - glDeleteSamplers(1, &nearest_sampler_); - glDeleteSamplers(1, &linear_sampler_); -} - -struct SavedState { - GLboolean scissor_test_enabled; - GLboolean depth_test_enabled; - GLboolean depth_mask_enabled; - GLint depth_func; - GLboolean stencil_test_enabled; - GLboolean cull_face_enabled; - GLint cull_face; - GLint front_face; - GLint polygon_mode; - GLboolean color_mask_0_enabled[4]; - GLboolean blend_0_enabled; - GLint draw_buffer; - GLfloat viewport[4]; - GLint program_pipeline; - GLint vertex_array; - GLint texture_0; - GLint sampler_0; - - void Save() { - scissor_test_enabled = glIsEnabled(GL_SCISSOR_TEST); - depth_test_enabled = glIsEnabled(GL_DEPTH_TEST); - glGetBooleanv(GL_DEPTH_WRITEMASK, &depth_mask_enabled); - glGetIntegerv(GL_DEPTH_FUNC, &depth_func); - stencil_test_enabled = glIsEnabled(GL_STENCIL_TEST); - cull_face_enabled = glIsEnabled(GL_CULL_FACE); - glGetIntegerv(GL_CULL_FACE_MODE, &cull_face); - glGetIntegerv(GL_FRONT_FACE, &front_face); - glGetIntegerv(GL_POLYGON_MODE, &polygon_mode); - glGetBooleani_v(GL_COLOR_WRITEMASK, 0, - reinterpret_cast<GLboolean*>(&color_mask_0_enabled)); - blend_0_enabled = glIsEnabledi(GL_BLEND, 0); - glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &draw_buffer); - glGetFloati_v(GL_VIEWPORT, 0, viewport); - glGetIntegerv(GL_PROGRAM_PIPELINE_BINDING, &program_pipeline); - glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &vertex_array); - glGetIntegerv(GL_TEXTURE_BINDING_2D, &texture_0); - glGetIntegerv(GL_SAMPLER_BINDING, &sampler_0); - } - - void Restore() { - scissor_test_enabled ? glEnable(GL_SCISSOR_TEST) - : glDisable(GL_SCISSOR_TEST); - depth_test_enabled ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST); - glDepthMask(depth_mask_enabled); - glDepthFunc(depth_func); - stencil_test_enabled ? glEnable(GL_STENCIL_TEST) - : glDisable(GL_STENCIL_TEST); - cull_face_enabled ? glEnable(GL_CULL_FACE) : glDisable(GL_CULL_FACE); - glCullFace(cull_face); - glFrontFace(front_face); - glPolygonMode(GL_FRONT_AND_BACK, polygon_mode); - glColorMaski(0, color_mask_0_enabled[0], color_mask_0_enabled[1], - color_mask_0_enabled[2], color_mask_0_enabled[3]); - blend_0_enabled ? glEnablei(GL_BLEND, 0) : glDisablei(GL_BLEND, 0); - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw_buffer); - glViewportIndexedf(0, viewport[0], viewport[1], viewport[2], viewport[3]); - glBindProgramPipeline(program_pipeline); - glBindVertexArray(vertex_array); - glBindTexture(GL_TEXTURE_2D, texture_0); - glBindSampler(0, sampler_0); - } -}; - -void Blitter::Draw(GLuint src_texture, Rect2D src_rect, Rect2D dest_rect, - GLenum filter) { - assert_not_zero(src_texture); - - glDisable(GL_SCISSOR_TEST); - glDisable(GL_STENCIL_TEST); - glDisablei(GL_BLEND, 0); - glEnable(GL_CULL_FACE); - glCullFace(GL_BACK); - glFrontFace(GL_CW); - glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); - glBindVertexArray(vao_); - glBindTextures(0, 1, &src_texture); - switch (filter) { - default: - case GL_NEAREST: - glBindSampler(0, nearest_sampler_); - break; - case GL_LINEAR: - glBindSampler(0, linear_sampler_); - break; - } - - glViewportIndexedf(0, GLfloat(dest_rect.x), GLfloat(dest_rect.y), - GLfloat(dest_rect.width), GLfloat(dest_rect.height)); - - // TODO(benvanik): avoid this? - GLint src_texture_width; - glGetTextureLevelParameteriv(src_texture, 0, GL_TEXTURE_WIDTH, - &src_texture_width); - GLint src_texture_height; - glGetTextureLevelParameteriv(src_texture, 0, GL_TEXTURE_HEIGHT, - &src_texture_height); - glProgramUniform4f(vertex_program_, 0, - src_rect.x / static_cast<float>(src_texture_width), - src_rect.y / static_cast<float>(src_texture_height), - src_rect.width / static_cast<float>(src_texture_width), - src_rect.height / static_cast<float>(src_texture_height)); - - // Useful for seeing the entire framebuffer/etc: - // glProgramUniform4f(vertex_program_, 0, 0.0f, 0.0f, 1.0f, 1.0f); - - glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); -} - -void Blitter::BlitTexture2D(GLuint src_texture, Rect2D src_rect, - Rect2D dest_rect, GLenum filter, - bool swap_channels) { - SavedState state; - state.Save(); - - glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); - glDisable(GL_DEPTH_TEST); - glDepthMask(GL_FALSE); - glStencilMask(0xFF); - glBindProgramPipeline(color_pipeline_); - - glProgramUniform1i(color_fragment_program_, 2, swap_channels ? 1 : 0); - - Draw(src_texture, src_rect, dest_rect, filter); - - state.Restore(); -} - -void Blitter::CopyColorTexture2D(GLuint src_texture, Rect2D src_rect, - GLuint dest_texture, Rect2D dest_rect, - GLenum filter, bool swap_channels) { - SavedState state; - state.Save(); - - glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); - glDisable(GL_DEPTH_TEST); - glDepthMask(GL_FALSE); - glBindProgramPipeline(color_pipeline_); - - glProgramUniform1i(color_fragment_program_, 2, swap_channels ? 1 : 0); - - glNamedFramebufferTexture(scratch_framebuffer_, GL_COLOR_ATTACHMENT0, - dest_texture, 0); - glNamedFramebufferDrawBuffer(scratch_framebuffer_, GL_COLOR_ATTACHMENT0); - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, scratch_framebuffer_); - Draw(src_texture, src_rect, dest_rect, filter); - glNamedFramebufferDrawBuffer(scratch_framebuffer_, GL_NONE); - glNamedFramebufferTexture(scratch_framebuffer_, GL_COLOR_ATTACHMENT0, GL_NONE, - 0); - - state.Restore(); -} - -void Blitter::CopyDepthTexture(GLuint src_texture, Rect2D src_rect, - GLuint dest_texture, Rect2D dest_rect) { - SavedState state; - state.Save(); - - glColorMaski(0, GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); - glEnable(GL_DEPTH_TEST); - glDepthFunc(GL_ALWAYS); - glDepthMask(GL_TRUE); - glBindProgramPipeline(depth_pipeline_); - - glNamedFramebufferTexture(scratch_framebuffer_, GL_DEPTH_STENCIL_ATTACHMENT, - dest_texture, 0); - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, scratch_framebuffer_); - Draw(src_texture, src_rect, dest_rect, GL_NEAREST); - glNamedFramebufferTexture(scratch_framebuffer_, GL_DEPTH_STENCIL_ATTACHMENT, - GL_NONE, 0); - - state.Restore(); -} - -} // namespace gl -} // namespace ui -} // namespace xe diff --git a/src/xenia/ui/gl/blitter.h b/src/xenia/ui/gl/blitter.h deleted file mode 100644 index 3080c6aaa..000000000 --- a/src/xenia/ui/gl/blitter.h +++ /dev/null @@ -1,70 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_UI_GL_BLITTER_H_ -#define XENIA_UI_GL_BLITTER_H_ - -#include <memory> - -#include "xenia/ui/gl/gl.h" - -namespace xe { -namespace ui { -namespace gl { - -struct Rect2D { - int32_t x; - int32_t y; - int32_t width; - int32_t height; - Rect2D() : x(0), y(0), width(0), height(0) {} - Rect2D(int32_t x_, int32_t y_, int32_t width_, int32_t height_) - : x(x_), y(y_), width(width_), height(height_) {} - int32_t right() const { return x + width; } - int32_t bottom() const { return y + height; } -}; - -class Blitter { - public: - Blitter(); - ~Blitter(); - - bool Initialize(); - void Shutdown(); - - void BlitTexture2D(GLuint src_texture, Rect2D src_rect, Rect2D dest_rect, - GLenum filter, bool swap_channels); - - void CopyColorTexture2D(GLuint src_texture, Rect2D src_rect, - GLuint dest_texture, Rect2D dest_rect, GLenum filter, - bool swap_channels); - void CopyDepthTexture(GLuint src_texture, Rect2D src_rect, - GLuint dest_texture, Rect2D dest_rect); - - private: - void Draw(GLuint src_texture, Rect2D src_rect, Rect2D dest_rect, - GLenum filter); - - GLuint vertex_program_; - GLuint color_fragment_program_; - GLuint depth_fragment_program_; - GLuint color_pipeline_; - GLuint depth_pipeline_; - GLuint vbo_; - GLuint vao_; - GLuint nearest_sampler_; - GLuint linear_sampler_; - GLuint scratch_framebuffer_; -}; - -} // namespace gl -} // namespace ui -} // namespace xe - -#endif // XENIA_UI_GL_BLITTER_H_ diff --git a/src/xenia/ui/gl/circular_buffer.cc b/src/xenia/ui/gl/circular_buffer.cc deleted file mode 100644 index 863b1bd2d..000000000 --- a/src/xenia/ui/gl/circular_buffer.cc +++ /dev/null @@ -1,139 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/ui/gl/circular_buffer.h" - -#include <algorithm> - -#include "xenia/base/assert.h" -#include "xenia/base/math.h" - -namespace xe { -namespace ui { -namespace gl { - -CircularBuffer::CircularBuffer(size_t capacity, size_t alignment) - : capacity_(capacity), - alignment_(alignment), - write_head_(0), - dirty_start_(UINT64_MAX), - dirty_end_(0), - buffer_(0), - gpu_base_(0), - host_base_(nullptr) {} - -CircularBuffer::~CircularBuffer() { Shutdown(); } - -bool CircularBuffer::Initialize() { - glCreateBuffers(1, &buffer_); - glNamedBufferStorage(buffer_, capacity_, nullptr, - GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); - host_base_ = reinterpret_cast<uint8_t*>(glMapNamedBufferRange( - buffer_, 0, capacity_, - GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT)); - assert_not_null(host_base_); - if (!host_base_) { - return false; - } - - return true; -} - -void CircularBuffer::Shutdown() { - if (!buffer_) { - return; - } - glUnmapNamedBuffer(buffer_); - glDeleteBuffers(1, &buffer_); - buffer_ = 0; -} - -bool CircularBuffer::CanAcquire(size_t length) { - size_t aligned_length = xe::round_up(length, alignment_); - return write_head_ + aligned_length <= capacity_; -} - -CircularBuffer::Allocation CircularBuffer::Acquire(size_t length) { - // Addresses must always be % 256. - size_t aligned_length = xe::round_up(length, alignment_); - assert_true(aligned_length <= capacity_, "Request too large"); - if (write_head_ + aligned_length > capacity_) { - // Flush and wait. - WaitUntilClean(); - } - - Allocation allocation; - allocation.host_ptr = host_base_ + write_head_; - allocation.gpu_ptr = gpu_base_ + write_head_; - allocation.offset = write_head_; - allocation.length = length; - allocation.aligned_length = aligned_length; - allocation.cache_key = 0; - write_head_ += aligned_length; - return allocation; -} - -bool CircularBuffer::AcquireCached(uint32_t key, size_t length, - Allocation* out_allocation) { - uint64_t full_key = key | (length << 32); - auto it = allocation_cache_.find(full_key); - if (it != allocation_cache_.end()) { - uintptr_t write_head = it->second; - size_t aligned_length = xe::round_up(length, alignment_); - out_allocation->host_ptr = host_base_ + write_head; - out_allocation->gpu_ptr = gpu_base_ + write_head; - out_allocation->offset = write_head; - out_allocation->length = length; - out_allocation->aligned_length = aligned_length; - out_allocation->cache_key = full_key; - return true; - } else { - *out_allocation = Acquire(length); - out_allocation->cache_key = full_key; - return false; - } -} - -void CircularBuffer::Discard(Allocation allocation) { - write_head_ -= allocation.aligned_length; -} - -void CircularBuffer::Commit(Allocation allocation) { - uintptr_t start = allocation.gpu_ptr - gpu_base_; - uintptr_t end = start + allocation.aligned_length; - dirty_start_ = std::min(dirty_start_, start); - dirty_end_ = std::max(dirty_end_, end); - assert_true(dirty_end_ <= capacity_); - if (allocation.cache_key) { - allocation_cache_.insert({allocation.cache_key, allocation.offset}); - } -} - -void CircularBuffer::Flush() { - if (dirty_start_ == dirty_end_ || dirty_start_ == UINT64_MAX) { - return; - } - glFlushMappedNamedBufferRange(buffer_, dirty_start_, - dirty_end_ - dirty_start_); - dirty_start_ = UINT64_MAX; - dirty_end_ = 0; -} - -void CircularBuffer::ClearCache() { allocation_cache_.clear(); } - -void CircularBuffer::WaitUntilClean() { - Flush(); - glFinish(); - write_head_ = 0; - ClearCache(); -} - -} // namespace gl -} // namespace ui -} // namespace xe diff --git a/src/xenia/ui/gl/circular_buffer.h b/src/xenia/ui/gl/circular_buffer.h deleted file mode 100644 index 3b9c119f8..000000000 --- a/src/xenia/ui/gl/circular_buffer.h +++ /dev/null @@ -1,71 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_UI_GL_CIRCULAR_BUFFER_H_ -#define XENIA_UI_GL_CIRCULAR_BUFFER_H_ - -#include <unordered_map> - -#include "xenia/ui/gl/gl.h" - -namespace xe { -namespace ui { -namespace gl { - -// TODO(benvanik): uh, make this circular. -// TODO(benvanik): fences to prevent this from ever flushing. -class CircularBuffer { - public: - CircularBuffer(size_t capacity, size_t alignment = 256); - ~CircularBuffer(); - - struct Allocation { - void* host_ptr; - GLuint64 gpu_ptr; - size_t offset; - size_t length; - size_t aligned_length; - uint64_t cache_key; // 0 if caching disabled. - }; - - bool Initialize(); - void Shutdown(); - - GLuint handle() const { return buffer_; } - GLuint64 gpu_handle() const { return gpu_base_; } - size_t capacity() const { return capacity_; } - - bool CanAcquire(size_t length); - Allocation Acquire(size_t length); - bool AcquireCached(uint32_t key, size_t length, Allocation* out_allocation); - void Discard(Allocation allocation); - void Commit(Allocation allocation); - void Flush(); - void ClearCache(); - - void WaitUntilClean(); - - private: - size_t capacity_; - size_t alignment_; - uintptr_t write_head_; - uintptr_t dirty_start_; - uintptr_t dirty_end_; - GLuint buffer_; - GLuint64 gpu_base_; - uint8_t* host_base_; - - std::unordered_map<uint64_t, uintptr_t> allocation_cache_; -}; - -} // namespace gl -} // namespace ui -} // namespace xe - -#endif // XENIA_UI_GL_CIRCULAR_BUFFER_H_ diff --git a/src/xenia/ui/gl/gl.h b/src/xenia/ui/gl/gl.h deleted file mode 100644 index 796248803..000000000 --- a/src/xenia/ui/gl/gl.h +++ /dev/null @@ -1,32 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_UI_GL_GL_H_ -#define XENIA_UI_GL_GL_H_ - -#include "xenia/base/platform.h" - -#include "third_party/GL/glew.h" - -typedef struct GLEWContextStruct GLEWContext; -extern "C" GLEWContext* glewGetContext(); - -#if XE_PLATFORM_WIN32 -// We avoid including wglew.h here as it includes windows.h and pollutes the -// global namespace. As we don't need wglew most places we only do that as -// required. -typedef struct WGLEWContextStruct WGLEWContext; -extern "C" WGLEWContext* wglewGetContext(); -#elif XE_PLATFORM_LINUX -typedef struct GLXEWContextStruct GLXEWContext; -extern "C" GLXEWContext* glxewGetContext(); - -#endif - -#endif // XENIA_UI_GL_GL_H_ diff --git a/src/xenia/ui/gl/gl_context.cc b/src/xenia/ui/gl/gl_context.cc deleted file mode 100644 index afae0de6e..000000000 --- a/src/xenia/ui/gl/gl_context.cc +++ /dev/null @@ -1,268 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/ui/gl/gl_context.h" - -#include <gflags/gflags.h> - -#include <mutex> -#include <string> - -#include "xenia/base/assert.h" -#include "xenia/base/logging.h" -#include "xenia/base/math.h" -#include "xenia/base/profiling.h" -#include "xenia/ui/gl/gl_immediate_drawer.h" -#include "xenia/ui/window.h" - -DEFINE_bool(thread_safe_gl, false, - "Only allow one GL context to be active at a time."); - -DEFINE_bool(disable_gl_context_reset, false, - "Do not aggressively reset the GL context (helps with capture " - "programs such as OBS or FRAPS)."); - -DEFINE_bool(random_clear_color, false, "Randomizes GL clear color."); - -DEFINE_bool(gl_debug, false, "Enable OpenGL debug validation layer."); -DEFINE_bool(gl_debug_output, false, "Dump ARB_debug_output to stderr."); -DEFINE_bool(gl_debug_output_synchronous, true, - "ARB_debug_output will synchronize to be thread safe."); - -namespace xe { -namespace ui { -namespace gl { - -std::recursive_mutex GLContext::global_gl_mutex_; - -void GLContext::FatalGLError(std::string error) { - xe::FatalError( - error + - "\nEnsure you have the latest drivers for your GPU and that it supports " - "OpenGL 4.5. See http://xenia.jp/faq/ for more information and a list" - "of supported GPUs."); -} - -GLContext::GLContext(GraphicsProvider* provider, Window* target_window) - : GraphicsContext(provider, target_window) {} - -GLContext::~GLContext() {} - -void GLContext::AssertExtensionsPresent() { - if (!MakeCurrent()) { - FatalGLError("Unable to make GL context current."); - return; - } - - // Check shader version at least 4.5 (matching GL 4.5). - auto glsl_version_raw = - reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION)); - std::string glsl_version(glsl_version_raw); - if (glsl_version.find("4.5") == std::string::npos && - glsl_version.find("4.6") == std::string::npos) { - FatalGLError("OpenGL GLSL version 4.50 or higher is required."); - return; - } - - if (!GLEW_ARB_bindless_texture || !glMakeTextureHandleResidentARB) { - FatalGLError("OpenGL extension ARB_bindless_texture is required."); - return; - } - - if (!GLEW_ARB_fragment_coord_conventions) { - FatalGLError( - "OpenGL extension ARB_fragment_coord_conventions is required."); - return; - } - - ClearCurrent(); -} - -void GLContext::DebugMessage(GLenum source, GLenum type, GLuint id, - GLenum severity, GLsizei length, - const GLchar* message) { - const char* source_name = nullptr; - switch (source) { - case GL_DEBUG_SOURCE_API_ARB: - source_name = "OpenGL"; - break; - case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB: - source_name = "Windows"; - break; - case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB: - source_name = "Shader Compiler"; - break; - case GL_DEBUG_SOURCE_THIRD_PARTY_ARB: - source_name = "Third Party"; - break; - case GL_DEBUG_SOURCE_APPLICATION_ARB: - source_name = "Application"; - break; - case GL_DEBUG_SOURCE_OTHER_ARB: - source_name = "Other"; - break; - default: - source_name = "(unknown source)"; - break; - } - - const char* type_name = nullptr; - switch (type) { - case GL_DEBUG_TYPE_ERROR: - type_name = "error"; - break; - case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: - type_name = "deprecated behavior"; - break; - case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: - type_name = "undefined behavior"; - break; - case GL_DEBUG_TYPE_PORTABILITY: - type_name = "portability"; - break; - case GL_DEBUG_TYPE_PERFORMANCE: - type_name = "performance"; - break; - case GL_DEBUG_TYPE_OTHER: - type_name = "message"; - break; - case GL_DEBUG_TYPE_MARKER: - type_name = "marker"; - break; - case GL_DEBUG_TYPE_PUSH_GROUP: - type_name = "push group"; - break; - case GL_DEBUG_TYPE_POP_GROUP: - type_name = "pop group"; - break; - default: - type_name = "(unknown type)"; - break; - } - - const char* severity_name = nullptr; - switch (severity) { - case GL_DEBUG_SEVERITY_HIGH_ARB: - severity_name = "high"; - break; - case GL_DEBUG_SEVERITY_MEDIUM_ARB: - severity_name = "medium"; - break; - case GL_DEBUG_SEVERITY_LOW_ARB: - severity_name = "low"; - break; - case GL_DEBUG_SEVERITY_NOTIFICATION: - severity_name = "notification"; - break; - default: - severity_name = "(unknown severity)"; - break; - } - - XELOGE("GL4 %s: %s(%s) %d: %s", source_name, type_name, severity_name, id, - message); -} - -void GLAPIENTRY GLContext::DebugMessageThunk(GLenum source, GLenum type, - GLuint id, GLenum severity, - GLsizei length, - const GLchar* message, - GLvoid* user_param) { - reinterpret_cast<GLContext*>(user_param) - ->DebugMessage(source, type, id, severity, length, message); -} - -void GLContext::SetupDebugging() { - if (!FLAGS_gl_debug || !FLAGS_gl_debug_output) { - return; - } - - glEnable(GL_DEBUG_OUTPUT); - - // Synchronous output hurts, but is required if we want to line up the logs. - if (FLAGS_gl_debug_output_synchronous) { - glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); - } else { - glDisable(GL_DEBUG_OUTPUT_SYNCHRONOUS); - } - - // Enable everything by default. - glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, - GL_TRUE); - - // Disable annoying messages. - GLuint disable_message_ids[] = { - 0x00020004, // Usage warning: Generic vertex attribute array 0 uses a - // pointer with a small value (0x0000000000000000). Is this - // intended to be used as an offset into a buffer object? - }; - glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_OTHER, GL_DONT_CARE, - GLsizei(xe::countof(disable_message_ids)), - disable_message_ids, GL_FALSE); - - // Callback will be made from driver threads. - glDebugMessageCallback(reinterpret_cast<GLDEBUGPROC>(&DebugMessageThunk), - this); -} - -ImmediateDrawer* GLContext::immediate_drawer() { - return immediate_drawer_.get(); -} - -bool GLContext::WasLost() { - if (!robust_access_supported_) { - // Can't determine if we lost the context. - return false; - } - - if (context_lost_) { - return true; - } - - auto status = glGetGraphicsResetStatusARB(); - if (status != GL_NO_ERROR) { - // Graphics card reset. - XELOGE("============= TDR detected on context %p! Context %s =============", - handle(), status == GL_GUILTY_CONTEXT_RESET ? "guilty" : "innocent"); - context_lost_ = true; - return true; - } - - return false; -} - -std::unique_ptr<RawImage> GLContext::Capture() { - GraphicsContextLock lock(this); - - std::unique_ptr<RawImage> raw_image(new RawImage()); - raw_image->width = target_window_->width(); - raw_image->stride = raw_image->width * 4; - raw_image->height = target_window_->height(); - raw_image->data.resize(raw_image->stride * raw_image->height); - - glReadPixels(0, 0, target_window_->width(), target_window_->height(), GL_RGBA, - GL_UNSIGNED_BYTE, raw_image->data.data()); - - // Flip vertically in-place. - size_t yt = 0; - size_t yb = (raw_image->height - 1) * raw_image->stride; - while (yt < yb) { - for (size_t i = 0; i < raw_image->stride; ++i) { - std::swap(raw_image->data[yt + i], raw_image->data[yb + i]); - } - yt += raw_image->stride; - yb -= raw_image->stride; - } - - return raw_image; -} - -} // namespace gl -} // namespace ui -} // namespace xe diff --git a/src/xenia/ui/gl/gl_context.h b/src/xenia/ui/gl/gl_context.h deleted file mode 100644 index d71e209b2..000000000 --- a/src/xenia/ui/gl/gl_context.h +++ /dev/null @@ -1,93 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_UI_GL_GL_CONTEXT_H_ -#define XENIA_UI_GL_GL_CONTEXT_H_ - -#include <gflags/gflags.h> - -#include <memory> -#include <mutex> - -#include "xenia/ui/gl/blitter.h" -#include "xenia/ui/gl/gl.h" -#include "xenia/ui/graphics_context.h" - -DECLARE_bool(thread_safe_gl); - -DECLARE_bool(disable_gl_context_reset); - -DECLARE_bool(random_clear_color); - -DECLARE_bool(gl_debug); -DECLARE_bool(gl_debug_output); -DECLARE_bool(gl_debug_output_synchronous); - -namespace xe { -namespace ui { -namespace gl { - -class GLImmediateDrawer; -class GLProvider; - -class GLContext : public GraphicsContext { - public: - ~GLContext() override; - - ImmediateDrawer* immediate_drawer() override; - - virtual bool is_current() override = 0; - virtual bool MakeCurrent() override = 0; - virtual void ClearCurrent() override = 0; - bool WasLost() override; - - virtual void BeginSwap() override = 0; - virtual void EndSwap() override = 0; - std::unique_ptr<RawImage> Capture() override; - - Blitter* blitter() { return &blitter_; } - - protected: - Blitter blitter_; - std::unique_ptr<GLImmediateDrawer> immediate_drawer_; - - static std::recursive_mutex global_gl_mutex_; - bool context_lost_ = false; - bool robust_access_supported_ = false; - static void FatalGLError(std::string error); - virtual bool Initialize(GLContext* share_context) = 0; - virtual void* handle() = 0; - GLContext(GraphicsProvider* provider, Window* target_window); - void SetupDebugging(); - void AssertExtensionsPresent(); - void DebugMessage(GLenum source, GLenum type, GLuint id, GLenum severity, - GLsizei length, const GLchar* message); - - private: - friend class GLProvider; - - static std::unique_ptr<GLContext> Create(GraphicsProvider* provider, - Window* target_window, - GLContext* share_context = nullptr); - static std::unique_ptr<GLContext> CreateOffscreen(GraphicsProvider* provider, - GLContext* parent_context); - - private: - static void GLAPIENTRY DebugMessageThunk(GLenum source, GLenum type, - GLuint id, GLenum severity, - GLsizei length, - const GLchar* message, - GLvoid* user_param); -}; - -} // namespace gl -} // namespace ui -} // namespace xe - -#endif // XENIA_UI_GL_GL_CONTEXT_H_ diff --git a/src/xenia/ui/gl/gl_context_win.cc b/src/xenia/ui/gl/gl_context_win.cc deleted file mode 100644 index 0ca66146c..000000000 --- a/src/xenia/ui/gl/gl_context_win.cc +++ /dev/null @@ -1,315 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/ui/gl/gl_context_win.h" - -#include <gflags/gflags.h> - -#include <mutex> -#include <string> - -#include "xenia/base/assert.h" -#include "xenia/base/logging.h" -#include "xenia/base/math.h" -#include "xenia/base/platform_win.h" -#include "xenia/base/profiling.h" -#include "xenia/ui/gl/gl_immediate_drawer.h" -#include "xenia/ui/window.h" - -#include "third_party/GL/wglew.h" - -namespace xe { -namespace ui { -namespace gl { - -thread_local GLEWContext* tls_glew_context_ = nullptr; -thread_local WGLEWContext* tls_wglew_context_ = nullptr; -extern "C" GLEWContext* glewGetContext() { return tls_glew_context_; } -extern "C" WGLEWContext* wglewGetContext() { return tls_wglew_context_; } - -std::unique_ptr<GLContext> GLContext::Create(GraphicsProvider* provider, - Window* target_window, - GLContext* share_context) { - auto context = - std::unique_ptr<GLContext>(new WGLContext(provider, target_window)); - if (!context->Initialize(share_context)) { - return nullptr; - } - context->AssertExtensionsPresent(); - return context; -} - -std::unique_ptr<GLContext> GLContext::CreateOffscreen( - GraphicsProvider* provider, GLContext* parent_context) { - return WGLContext::CreateOffscreen(provider, - static_cast<WGLContext*>(parent_context)); -} - -WGLContext::WGLContext(GraphicsProvider* provider, Window* target_window) - : GLContext(provider, target_window) { - glew_context_.reset(new GLEWContext()); - wglew_context_.reset(new WGLEWContext()); -} - -WGLContext::~WGLContext() { - MakeCurrent(); - blitter_.Shutdown(); - immediate_drawer_.reset(); - ClearCurrent(); - if (glrc_) { - wglDeleteContext(glrc_); - } - if (dc_) { - ReleaseDC(HWND(target_window_->native_handle()), dc_); - } -} - -bool WGLContext::Initialize(GLContext* share_context_) { - WGLContext* share_context = static_cast<WGLContext*>(share_context_); - dc_ = GetDC(HWND(target_window_->native_handle())); - - PIXELFORMATDESCRIPTOR pfd = {0}; - pfd.nSize = sizeof(pfd); - pfd.nVersion = 1; - pfd.dwFlags = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW; - pfd.iPixelType = PFD_TYPE_RGBA; - pfd.cColorBits = 32; - pfd.cDepthBits = 32; - pfd.iLayerType = PFD_MAIN_PLANE; - int pixel_format = ChoosePixelFormat(dc_, &pfd); - if (!pixel_format) { - FatalGLError("Unable to choose pixel format."); - return false; - } - if (!SetPixelFormat(dc_, pixel_format, &pfd)) { - FatalGLError("Unable to set pixel format."); - return false; - } - - HGLRC temp_context = wglCreateContext(dc_); - if (!temp_context) { - FatalGLError("Unable to create temporary GL context."); - return false; - } - wglMakeCurrent(dc_, temp_context); - - tls_glew_context_ = glew_context_.get(); - tls_wglew_context_ = wglew_context_.get(); - if (glewInit() != GLEW_OK) { - FatalGLError("Unable to initialize GLEW."); - return false; - } - if (wglewInit() != GLEW_OK) { - FatalGLError("Unable to initialize WGLEW."); - return false; - } - - if (!WGLEW_ARB_create_context) { - FatalGLError("WGL_ARG_create_context not supported by GL ICD."); - return false; - } - - if (GLEW_ARB_robustness) { - robust_access_supported_ = true; - } - - int context_flags = 0; - if (FLAGS_gl_debug) { - context_flags |= WGL_CONTEXT_DEBUG_BIT_ARB; - } - if (robust_access_supported_) { - context_flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB; - } - - int attrib_list[] = { - WGL_CONTEXT_MAJOR_VERSION_ARB, - 4, - WGL_CONTEXT_MINOR_VERSION_ARB, - 5, - WGL_CONTEXT_FLAGS_ARB, - context_flags, - WGL_CONTEXT_PROFILE_MASK_ARB, - WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, - WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, - robust_access_supported_ ? WGL_LOSE_CONTEXT_ON_RESET_ARB : 0, - 0}; - - glrc_ = wglCreateContextAttribsARB( - dc_, share_context ? share_context->glrc_ : nullptr, attrib_list); - wglMakeCurrent(nullptr, nullptr); - wglDeleteContext(temp_context); - if (!glrc_) { - FatalGLError("Unable to create real GL context."); - return false; - } - - if (!MakeCurrent()) { - FatalGLError("Could not make real GL context current."); - return false; - } - - XELOGI("Successfully created OpenGL context:"); - XELOGI(" GL_VENDOR: %s", glGetString(GL_VENDOR)); - XELOGI(" GL_VERSION: %s", glGetString(GL_VERSION)); - XELOGI(" GL_RENDERER: %s", glGetString(GL_RENDERER)); - XELOGI(" GL_SHADING_LANGUAGE_VERSION: %s", - glGetString(GL_SHADING_LANGUAGE_VERSION)); - - while (glGetError()) { - // Clearing errors. - } - - SetupDebugging(); - - if (!blitter_.Initialize()) { - FatalGLError("Unable to initialize blitter."); - ClearCurrent(); - return false; - } - - immediate_drawer_ = std::make_unique<GLImmediateDrawer>(this); - - ClearCurrent(); - - return true; -} - -std::unique_ptr<WGLContext> WGLContext::CreateOffscreen( - GraphicsProvider* provider, WGLContext* parent_context) { - assert_not_null(parent_context->glrc_); - - HGLRC new_glrc = nullptr; - { - GraphicsContextLock context_lock(parent_context); - - int context_flags = 0; - if (FLAGS_gl_debug) { - context_flags |= WGL_CONTEXT_DEBUG_BIT_ARB; - } - - bool robust_access_supported = parent_context->robust_access_supported_; - if (robust_access_supported) { - context_flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB; - } - - int attrib_list[] = { - WGL_CONTEXT_MAJOR_VERSION_ARB, - 4, - WGL_CONTEXT_MINOR_VERSION_ARB, - 5, - WGL_CONTEXT_FLAGS_ARB, - context_flags, - WGL_CONTEXT_PROFILE_MASK_ARB, - WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, - WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, - robust_access_supported ? WGL_LOSE_CONTEXT_ON_RESET_ARB : 0, - 0}; - new_glrc = wglCreateContextAttribsARB(parent_context->dc_, - parent_context->glrc_, attrib_list); - if (!new_glrc) { - FatalGLError("Could not create shared context."); - return nullptr; - } - } - - auto new_context = std::unique_ptr<WGLContext>( - new WGLContext(provider, parent_context->target_window_)); - new_context->glrc_ = new_glrc; - new_context->dc_ = - GetDC(HWND(parent_context->target_window_->native_handle())); - new_context->robust_access_supported_ = - parent_context->robust_access_supported_; - if (!new_context->MakeCurrent()) { - FatalGLError("Could not make new GL context current."); - return nullptr; - } - if (!glGetString(GL_EXTENSIONS)) { - new_context->ClearCurrent(); - FatalGLError("New GL context did not have extensions."); - return nullptr; - } - - if (glewInit() != GLEW_OK) { - new_context->ClearCurrent(); - FatalGLError("Unable to initialize GLEW on shared context."); - return nullptr; - } - if (wglewInit() != GLEW_OK) { - new_context->ClearCurrent(); - FatalGLError("Unable to initialize WGLEW on shared context."); - return nullptr; - } - - new_context->SetupDebugging(); - - if (!new_context->blitter_.Initialize()) { - FatalGLError("Unable to initialize blitter on shared context."); - return nullptr; - } - - new_context->ClearCurrent(); - - return new_context; -} - -bool WGLContext::is_current() { - return tls_glew_context_ == glew_context_.get(); -} - -bool WGLContext::MakeCurrent() { - SCOPE_profile_cpu_f("gpu"); - if (FLAGS_thread_safe_gl) { - global_gl_mutex_.lock(); - } - - if (!wglMakeCurrent(dc_, glrc_)) { - if (FLAGS_thread_safe_gl) { - global_gl_mutex_.unlock(); - } - FatalGLError("Unable to make GL context current."); - return false; - } - tls_glew_context_ = glew_context_.get(); - tls_wglew_context_ = wglew_context_.get(); - return true; -} - -void WGLContext::ClearCurrent() { - if (!FLAGS_disable_gl_context_reset) { - wglMakeCurrent(nullptr, nullptr); - } - tls_glew_context_ = nullptr; - tls_wglew_context_ = nullptr; - - if (FLAGS_thread_safe_gl) { - global_gl_mutex_.unlock(); - } -} - -void WGLContext::BeginSwap() { - SCOPE_profile_cpu_i("gpu", "xe::ui::gl::WGLContext::BeginSwap"); - float clear_color[] = {238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.0f}; - if (FLAGS_random_clear_color) { - clear_color[0] = - rand() / static_cast<float>(RAND_MAX); // NOLINT(runtime/threadsafe_fn) - clear_color[1] = 1.0f; - clear_color[2] = 0.0f; - clear_color[3] = 1.0f; - } - glClearNamedFramebufferfv(0, GL_COLOR, 0, clear_color); -} - -void WGLContext::EndSwap() { - SCOPE_profile_cpu_i("gpu", "xe::ui::gl::WGLContext::EndSwap"); - SwapBuffers(dc_); -} - -} // namespace gl -} // namespace ui -} // namespace xe diff --git a/src/xenia/ui/gl/gl_context_win.h b/src/xenia/ui/gl/gl_context_win.h deleted file mode 100644 index 772de4d3e..000000000 --- a/src/xenia/ui/gl/gl_context_win.h +++ /dev/null @@ -1,64 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_UI_GL_WGL_CONTEXT_H_ -#define XENIA_UI_GL_WGL_CONTEXT_H_ - -#include <gflags/gflags.h> - -#include <memory> - -#include "xenia/ui/gl/blitter.h" -#include "xenia/ui/gl/gl.h" -#include "xenia/ui/gl/gl_context.h" -#include "xenia/ui/graphics_context.h" - -typedef struct HDC__* HDC; -typedef struct HGLRC__* HGLRC; - -namespace xe { -namespace ui { -namespace gl { - -class GLImmediateDrawer; -class GLProvider; - -class WGLContext : public GLContext { - public: - ~WGLContext() override; - - bool is_current() override; - bool MakeCurrent() override; - void ClearCurrent() override; - - void BeginSwap() override; - void EndSwap() override; - - protected: - friend class GLContext; - WGLContext(GraphicsProvider* provider, Window* target_window); - static std::unique_ptr<WGLContext> CreateOffscreen( - GraphicsProvider* provider, WGLContext* parent_context); - - bool Initialize(GLContext* share_context) override; - void* handle() override { return glrc_; } - - private: - HDC dc_ = nullptr; - HGLRC glrc_ = nullptr; - - std::unique_ptr<GLEWContext> glew_context_; - std::unique_ptr<WGLEWContext> wglew_context_; -}; - -} // namespace gl -} // namespace ui -} // namespace xe - -#endif // XENIA_UI_GL_GL_CONTEXT_H_ diff --git a/src/xenia/ui/gl/gl_context_x11.cc b/src/xenia/ui/gl/gl_context_x11.cc deleted file mode 100644 index fc4b3176b..000000000 --- a/src/xenia/ui/gl/gl_context_x11.cc +++ /dev/null @@ -1,323 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/ui/gl/gl_context_x11.h" - -#include <gflags/gflags.h> - -#include <gdk/gdkx.h> -#include <mutex> -#include <string> - -#include "third_party/GL/glxew.h" -#include "xenia/base/assert.h" -#include "xenia/base/logging.h" -#include "xenia/base/math.h" -#include "xenia/base/platform_linux.h" -#include "xenia/base/profiling.h" -#include "xenia/ui/gl/gl_immediate_drawer.h" -#include "xenia/ui/window.h" - -namespace xe { -namespace ui { -namespace gl { - -thread_local GLEWContext* tls_glew_context_ = nullptr; -thread_local GLXEWContext* tls_glxew_context_ = nullptr; -extern "C" GLEWContext* glewGetContext() { return tls_glew_context_; } -extern "C" GLXEWContext* glxewGetContext() { return tls_glxew_context_; } - -std::unique_ptr<GLContext> GLContext::Create(GraphicsProvider* provider, - Window* target_window, - GLContext* share_context) { - auto context = - std::unique_ptr<GLContext>(new GLXContext(provider, target_window)); - if (!context->Initialize(share_context)) { - return nullptr; - } - context->AssertExtensionsPresent(); - return context; -} - -std::unique_ptr<GLContext> GLContext::CreateOffscreen( - GraphicsProvider* provider, GLContext* parent_context) { - return GLXContext::CreateOffscreen(provider, - static_cast<GLXContext*>(parent_context)); -} - -GLXContext::GLXContext(GraphicsProvider* provider, Window* target_window) - : GLContext(provider, target_window) { - glew_context_.reset(new GLEWContext()); - glxew_context_.reset(new GLXEWContext()); -} - -GLXContext::~GLXContext() { - MakeCurrent(); - blitter_.Shutdown(); - immediate_drawer_.reset(); - ClearCurrent(); - if (glx_context_) { - glXDestroyContext(disp_, glx_context_); - } - if (draw_area_) { - gtk_widget_destroy(draw_area_); - } -} - -bool GLXContext::Initialize(GLContext* share_context) { - GtkWidget* window = GTK_WIDGET(target_window_->native_handle()); - GtkWidget* draw_area = gtk_drawing_area_new(); - int32_t width; - int32_t height; - gtk_window_get_size(GTK_WINDOW(window), &width, &height); - gtk_widget_set_size_request(draw_area, width, height); - gtk_container_add(GTK_CONTAINER(window), draw_area); - GdkVisual* visual = gdk_screen_get_system_visual(gdk_screen_get_default()); - - GdkDisplay* gdk_display = gtk_widget_get_display(window); - Display* display = gdk_x11_display_get_xdisplay(gdk_display); - disp_ = display; - ::Window root = gdk_x11_get_default_root_xwindow(); - static int vis_attrib_list[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, - GLX_DOUBLEBUFFER, None}; - XVisualInfo* vi = glXChooseVisual(display, 0, vis_attrib_list); - if (vi == NULL) { - FatalGLError("No matching visuals for X display"); - return false; - } - - cmap_ = XCreateColormap(display, root, vi->visual, AllocNone); - - ::GLXContext temp_context = glXCreateContext(display, vi, NULL, GL_TRUE); - if (!temp_context) { - FatalGLError("Unable to create temporary GLX context"); - return false; - } - xid_ = GDK_WINDOW_XID(gtk_widget_get_window(window)); - glXMakeCurrent(display, xid_, temp_context); - - tls_glew_context_ = glew_context_.get(); - tls_glxew_context_ = glxew_context_.get(); - if (glewInit() != GLEW_OK) { - FatalGLError("Unable to initialize GLEW."); - return false; - } - if (glxewInit() != GLEW_OK) { - FatalGLError("Unable to initialize GLXEW."); - return false; - } - - if (!GLXEW_ARB_create_context) { - FatalGLError("GLX_ARB_create_context not supported by GL ICD."); - return false; - } - - if (GLEW_ARB_robustness) { - robust_access_supported_ = true; - } - - int context_flags = 0; - if (FLAGS_gl_debug) { - context_flags |= GLX_CONTEXT_DEBUG_BIT_ARB; - } - if (robust_access_supported_) { - context_flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB; - } - - int attrib_list[] = { - GLX_CONTEXT_MAJOR_VERSION_ARB, - 4, - GLX_CONTEXT_MINOR_VERSION_ARB, - 5, - GLX_CONTEXT_FLAGS_ARB, - context_flags, - GLX_CONTEXT_PROFILE_MASK_ARB, - GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, - GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, - robust_access_supported_ ? GLX_LOSE_CONTEXT_ON_RESET_ARB : 0, - 0}; - GLXContext* share_context_glx = static_cast<GLXContext*>(share_context); - glx_context_ = glXCreateContextAttribsARB( - display, nullptr, - share_context ? share_context_glx->glx_context_ : nullptr, True, - attrib_list); - glXMakeCurrent(display, 0, nullptr); - glXDestroyContext(display, temp_context); - if (!glx_context_) { - FatalGLError("Unable to create real GL context."); - return false; - } - - if (!MakeCurrent()) { - FatalGLError("Could not make real GL context current."); - return false; - } - - XELOGI("Successfully created OpenGL context:"); - XELOGI(" GL_VENDOR: %s", glGetString(GL_VENDOR)); - XELOGI(" GL_VERSION: %s", glGetString(GL_VERSION)); - XELOGI(" GL_RENDERER: %s", glGetString(GL_RENDERER)); - XELOGI(" GL_SHADING_LANGUAGE_VERSION: %s", - glGetString(GL_SHADING_LANGUAGE_VERSION)); - - while (glGetError()) { - // Clearing errors. - } - - SetupDebugging(); - - if (!blitter_.Initialize()) { - FatalGLError("Unable to initialize blitter."); - ClearCurrent(); - return false; - } - - immediate_drawer_ = std::make_unique<GLImmediateDrawer>(this); - - ClearCurrent(); - - return true; -} - -std::unique_ptr<GLXContext> GLXContext::CreateOffscreen( - GraphicsProvider* provider, GLXContext* parent_context) { - assert_not_null(parent_context->glx_context_); - - ::GLXContext new_glrc; - { - GraphicsContextLock context_lock(parent_context); - - int context_flags = 0; - if (FLAGS_gl_debug) { - context_flags |= GLX_CONTEXT_DEBUG_BIT_ARB; - } - - bool robust_access_supported = parent_context->robust_access_supported_; - if (robust_access_supported) { - context_flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB; - } - - int attrib_list[] = { - GLX_CONTEXT_MAJOR_VERSION_ARB, - 4, - GLX_CONTEXT_MINOR_VERSION_ARB, - 5, - GLX_CONTEXT_FLAGS_ARB, - context_flags, - GLX_CONTEXT_PROFILE_MASK_ARB, - GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, - GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, - robust_access_supported ? GLX_LOSE_CONTEXT_ON_RESET_ARB : 0, - 0}; - new_glrc = glXCreateContextAttribsARB(parent_context->disp_, nullptr, - parent_context->glx_context_, True, - attrib_list); - if (!new_glrc) { - FatalGLError("Could not create shared context."); - return nullptr; - } - } - - auto new_context = std::unique_ptr<GLXContext>( - new GLXContext(provider, parent_context->target_window_)); - new_context->glx_context_ = new_glrc; - new_context->window_ = parent_context->window_; - new_context->draw_area_ = parent_context->draw_area_; - new_context->disp_ = parent_context->disp_; - new_context->xid_ = parent_context->xid_; - new_context->robust_access_supported_ = - parent_context->robust_access_supported_; - if (!new_context->MakeCurrent()) { - FatalGLError("Could not make new GL context current."); - return nullptr; - } - if (!glGetString(GL_EXTENSIONS)) { - new_context->ClearCurrent(); - FatalGLError("New GL context did not have extensions."); - return nullptr; - } - - if (glewInit() != GLEW_OK) { - new_context->ClearCurrent(); - FatalGLError("Unable to initialize GLEW on shared context."); - return nullptr; - } - if (glxewInit() != GLEW_OK) { - new_context->ClearCurrent(); - FatalGLError("Unable to initialize GLXEW on shared context."); - return nullptr; - } - - new_context->SetupDebugging(); - - if (!new_context->blitter_.Initialize()) { - FatalGLError("Unable to initialize blitter on shared context."); - return nullptr; - } - - new_context->ClearCurrent(); - - return new_context; -} - -bool GLXContext::is_current() { - return tls_glew_context_ == glew_context_.get(); -} - -bool GLXContext::MakeCurrent() { - SCOPE_profile_cpu_f("gpu"); - if (FLAGS_thread_safe_gl) { - global_gl_mutex_.lock(); - } - - if (!glXMakeCurrent(disp_, xid_, glx_context_)) { - if (FLAGS_thread_safe_gl) { - global_gl_mutex_.unlock(); - } - FatalGLError("Unable to make GL context current."); - return false; - } - tls_glew_context_ = glew_context_.get(); - tls_glxew_context_ = glxew_context_.get(); - return true; -} - -void GLXContext::ClearCurrent() { - if (!FLAGS_disable_gl_context_reset) { - glXMakeCurrent(disp_, 0, nullptr); - } - tls_glew_context_ = nullptr; - tls_glxew_context_ = nullptr; - - if (FLAGS_thread_safe_gl) { - global_gl_mutex_.unlock(); - } -} - -void GLXContext::BeginSwap() { - SCOPE_profile_cpu_i("gpu", "xe::ui::gl::GLXContext::BeginSwap"); - float clear_color[] = {238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.0f}; - if (FLAGS_random_clear_color) { - clear_color[0] = - rand() / static_cast<float>(RAND_MAX); // NOLINT(runtime/threadsafe_fn) - clear_color[1] = 1.0f; - clear_color[2] = 0.0f; - clear_color[3] = 1.0f; - } - glClearNamedFramebufferfv(0, GL_COLOR, 0, clear_color); -} - -void GLXContext::EndSwap() { - SCOPE_profile_cpu_i("gpu", "xe::ui::gl::GLXContext::EndSwap"); - glXSwapBuffers(disp_, xid_); -} - -} // namespace gl -} // namespace ui -} // namespace xe diff --git a/src/xenia/ui/gl/gl_context_x11.h b/src/xenia/ui/gl/gl_context_x11.h deleted file mode 100644 index 6eea7fdb7..000000000 --- a/src/xenia/ui/gl/gl_context_x11.h +++ /dev/null @@ -1,69 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2014 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_UI_GL_GLX_CONTEXT_H_ -#define XENIA_UI_GL_GLX_CONTEXT_H_ - -#include <gflags/gflags.h> - -#include <memory> - -#include "third_party/GL/glxew.h" -#include "xenia/base/platform_linux.h" -#include "xenia/ui/gl/blitter.h" -#include "xenia/ui/gl/gl.h" -#include "xenia/ui/gl/gl_context.h" -#include "xenia/ui/graphics_context.h" - -DECLARE_bool(thread_safe_gl); - -namespace xe { -namespace ui { -namespace gl { - -class GLImmediateDrawer; -class GLProvider; - -class GLXContext : public GLContext { - public: - ~GLXContext() override; - - bool is_current() override; - - bool MakeCurrent() override; - void ClearCurrent() override; - - void BeginSwap() override; - void EndSwap() override; - - protected: - static std::unique_ptr<GLXContext> CreateOffscreen( - GraphicsProvider* provider, GLXContext* parent_context); - - bool Initialize(GLContext* share_context) override; - void* handle() override { return glx_context_; } - - private: - friend class GLContext; - GLXContext(GraphicsProvider* provider, Window* target_window); - std::unique_ptr<GLEWContext> glew_context_; - std::unique_ptr<GLXEWContext> glxew_context_; - ::GLXContext glx_context_; - GtkWidget* window_; - GtkWidget* draw_area_; - Colormap cmap_; - Display* disp_; - int xid_; -}; - -} // namespace gl -} // namespace ui -} // namespace xe - -#endif // XENIA_UI_GL_GL_CONTEXT_H_ diff --git a/src/xenia/ui/gl/gl_immediate_drawer.cc b/src/xenia/ui/gl/gl_immediate_drawer.cc deleted file mode 100644 index 998ff7c50..000000000 --- a/src/xenia/ui/gl/gl_immediate_drawer.cc +++ /dev/null @@ -1,283 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/ui/gl/gl_immediate_drawer.h" - -#include <string> - -#include "xenia/base/assert.h" -#include "xenia/ui/graphics_context.h" - -namespace xe { -namespace ui { -namespace gl { - -constexpr uint32_t kMaxDrawVertices = 64 * 1024; -constexpr uint32_t kMaxDrawIndices = 64 * 1024; - -class GLImmediateTexture : public ImmediateTexture { - public: - GLImmediateTexture(uint32_t width, uint32_t height, - ImmediateTextureFilter filter, bool repeat) - : ImmediateTexture(width, height) { - GLuint gl_handle; - glCreateTextures(GL_TEXTURE_2D, 1, &gl_handle); - - GLenum gl_filter = GL_NEAREST; - switch (filter) { - case ImmediateTextureFilter::kNearest: - gl_filter = GL_NEAREST; - break; - case ImmediateTextureFilter::kLinear: - gl_filter = GL_LINEAR; - break; - } - glTextureParameteri(gl_handle, GL_TEXTURE_MIN_FILTER, gl_filter); - glTextureParameteri(gl_handle, GL_TEXTURE_MAG_FILTER, gl_filter); - - glTextureParameteri(gl_handle, GL_TEXTURE_WRAP_S, - repeat ? GL_REPEAT : GL_CLAMP_TO_EDGE); - glTextureParameteri(gl_handle, GL_TEXTURE_WRAP_T, - repeat ? GL_REPEAT : GL_CLAMP_TO_EDGE); - - glTextureStorage2D(gl_handle, 1, GL_RGBA8, width, height); - - handle = static_cast<uintptr_t>(gl_handle); - } - - ~GLImmediateTexture() override { - GLuint gl_handle = static_cast<GLuint>(handle); - glDeleteTextures(1, &gl_handle); - } -}; - -GLImmediateDrawer::GLImmediateDrawer(GraphicsContext* graphics_context) - : ImmediateDrawer(graphics_context) { - glCreateBuffers(1, &vertex_buffer_); - glNamedBufferStorage(vertex_buffer_, - kMaxDrawVertices * sizeof(ImmediateVertex), nullptr, - GL_DYNAMIC_STORAGE_BIT); - glCreateBuffers(1, &index_buffer_); - glNamedBufferStorage(index_buffer_, kMaxDrawIndices * sizeof(uint16_t), - nullptr, GL_DYNAMIC_STORAGE_BIT); - - glCreateVertexArrays(1, &vao_); - glEnableVertexArrayAttrib(vao_, 0); - glVertexArrayAttribBinding(vao_, 0, 0); - glVertexArrayAttribFormat(vao_, 0, 2, GL_FLOAT, GL_FALSE, - offsetof(ImmediateVertex, x)); - glEnableVertexArrayAttrib(vao_, 1); - glVertexArrayAttribBinding(vao_, 1, 0); - glVertexArrayAttribFormat(vao_, 1, 2, GL_FLOAT, GL_FALSE, - offsetof(ImmediateVertex, u)); - glEnableVertexArrayAttrib(vao_, 2); - glVertexArrayAttribBinding(vao_, 2, 0); - glVertexArrayAttribFormat(vao_, 2, 4, GL_UNSIGNED_BYTE, GL_TRUE, - offsetof(ImmediateVertex, color)); - glVertexArrayVertexBuffer(vao_, 0, vertex_buffer_, 0, - sizeof(ImmediateVertex)); - - InitializeShaders(); -} - -GLImmediateDrawer::~GLImmediateDrawer() { - GraphicsContextLock lock(graphics_context_); - glDeleteBuffers(1, &vertex_buffer_); - glDeleteBuffers(1, &index_buffer_); - glDeleteVertexArrays(1, &vao_); - glDeleteProgram(program_); -} - -void GLImmediateDrawer::InitializeShaders() { - const std::string header = - R"( -#version 450 -#extension GL_ARB_explicit_uniform_location : require -#extension GL_ARB_shading_language_420pack : require -precision highp float; -layout(std140, column_major) uniform; -layout(std430, column_major) buffer; -)"; - const std::string vertex_shader_source = header + - R"( -layout(location = 0) uniform mat4 projection_matrix; -layout(location = 0) in vec2 in_pos; -layout(location = 1) in vec2 in_uv; -layout(location = 2) in vec4 in_color; -layout(location = 0) out vec2 vtx_uv; -layout(location = 1) out vec4 vtx_color; -void main() { - gl_Position = projection_matrix * vec4(in_pos.xy, 0.0, 1.0); - vtx_uv = in_uv; - vtx_color = in_color; -})"; - const std::string fragment_shader_source = header + - R"( -layout(location = 1) uniform sampler2D texture_sampler; -layout(location = 2) uniform int restrict_texture_samples; -layout(location = 0) in vec2 vtx_uv; -layout(location = 1) in vec4 vtx_color; -layout(location = 0) out vec4 out_color; -void main() { - out_color = vtx_color; - if (restrict_texture_samples == 0 || vtx_uv.x <= 1.0) { - vec4 tex_color = texture(texture_sampler, vtx_uv); - out_color *= tex_color; - // TODO(benvanik): microprofiler shadows. - } -})"; - - GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER); - const char* vertex_shader_source_ptr = vertex_shader_source.c_str(); - GLint vertex_shader_source_length = GLint(vertex_shader_source.size()); - glShaderSource(vertex_shader, 1, &vertex_shader_source_ptr, - &vertex_shader_source_length); - glCompileShader(vertex_shader); - - GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); - const char* fragment_shader_source_ptr = fragment_shader_source.c_str(); - GLint fragment_shader_source_length = GLint(fragment_shader_source.size()); - glShaderSource(fragment_shader, 1, &fragment_shader_source_ptr, - &fragment_shader_source_length); - glCompileShader(fragment_shader); - - program_ = glCreateProgram(); - glAttachShader(program_, vertex_shader); - glAttachShader(program_, fragment_shader); - glLinkProgram(program_); - glDeleteShader(vertex_shader); - glDeleteShader(fragment_shader); -} - -std::unique_ptr<ImmediateTexture> GLImmediateDrawer::CreateTexture( - uint32_t width, uint32_t height, ImmediateTextureFilter filter, bool repeat, - const uint8_t* data) { - GraphicsContextLock lock(graphics_context_); - auto texture = - std::make_unique<GLImmediateTexture>(width, height, filter, repeat); - if (data) { - UpdateTexture(texture.get(), data); - } - return std::unique_ptr<ImmediateTexture>(texture.release()); -} - -void GLImmediateDrawer::UpdateTexture(ImmediateTexture* texture, - const uint8_t* data) { - GraphicsContextLock lock(graphics_context_); - glTextureSubImage2D(static_cast<GLuint>(texture->handle), 0, 0, 0, - texture->width, texture->height, GL_RGBA, - GL_UNSIGNED_BYTE, data); -} - -void GLImmediateDrawer::Begin(int render_target_width, - int render_target_height) { - was_current_ = graphics_context_->is_current(); - if (!was_current_) { - graphics_context_->MakeCurrent(); - } - - // Setup render state. - glEnablei(GL_BLEND, 0); - glBlendEquationi(0, GL_FUNC_ADD); - glBlendFunci(0, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - glDisable(GL_DEPTH_TEST); - glDisable(GL_SCISSOR_TEST); - - // Prepare drawing resources. - glUseProgram(program_); - glBindVertexArray(vao_); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_); - - // Setup orthographic projection matrix and viewport. - const float ortho_projection[4][4] = { - {2.0f / render_target_width, 0.0f, 0.0f, 0.0f}, - {0.0f, 2.0f / -render_target_height, 0.0f, 0.0f}, - {0.0f, 0.0f, -1.0f, 0.0f}, - {-1.0f, 1.0f, 0.0f, 1.0f}, - }; - glProgramUniformMatrix4fv(program_, 0, 1, GL_FALSE, &ortho_projection[0][0]); - glViewport(0, 0, render_target_width, render_target_height); -} - -void GLImmediateDrawer::BeginDrawBatch(const ImmediateDrawBatch& batch) { - assert_true(batch.vertex_count <= kMaxDrawVertices); - glNamedBufferSubData(vertex_buffer_, 0, - batch.vertex_count * sizeof(ImmediateVertex), - batch.vertices); - if (batch.indices) { - assert_true(batch.index_count <= kMaxDrawIndices); - glNamedBufferSubData(index_buffer_, 0, batch.index_count * sizeof(uint16_t), - batch.indices); - } - - batch_has_index_buffer_ = !!batch.indices; -} - -void GLImmediateDrawer::Draw(const ImmediateDraw& draw) { - if (draw.scissor) { - glEnable(GL_SCISSOR_TEST); - glScissorIndexed(0, draw.scissor_rect[0], draw.scissor_rect[1], - draw.scissor_rect[2], draw.scissor_rect[3]); - } else { - glDisable(GL_SCISSOR_TEST); - } - - if (draw.alpha_blend) { - glEnablei(GL_BLEND, 0); - glBlendEquationi(0, GL_FUNC_ADD); - glBlendFunci(0, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - } else { - glDisablei(GL_BLEND, 0); - } - - if (draw.texture_handle) { - glBindTextureUnit(0, static_cast<GLuint>(draw.texture_handle)); - } else { - glBindTextureUnit(0, 0); - } - glProgramUniform1i(program_, 2, draw.restrict_texture_samples ? 1 : 0); - - GLenum mode = GL_TRIANGLES; - switch (draw.primitive_type) { - case ImmediatePrimitiveType::kLines: - mode = GL_LINES; - break; - case ImmediatePrimitiveType::kTriangles: - mode = GL_TRIANGLES; - break; - } - - if (batch_has_index_buffer_) { - glDrawElementsBaseVertex( - mode, draw.count, GL_UNSIGNED_SHORT, - reinterpret_cast<void*>(draw.index_offset * sizeof(uint16_t)), - draw.base_vertex); - } else { - glDrawArrays(mode, draw.base_vertex, draw.count); - } -} - -void GLImmediateDrawer::EndDrawBatch() { glFlush(); } - -void GLImmediateDrawer::End() { - // Restore modified state. - glDisable(GL_SCISSOR_TEST); - glBindTextureUnit(0, 0); - glUseProgram(0); - glBindVertexArray(0); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); - - if (!was_current_) { - graphics_context_->ClearCurrent(); - } -} - -} // namespace gl -} // namespace ui -} // namespace xe diff --git a/src/xenia/ui/gl/gl_immediate_drawer.h b/src/xenia/ui/gl/gl_immediate_drawer.h deleted file mode 100644 index e9e02798e..000000000 --- a/src/xenia/ui/gl/gl_immediate_drawer.h +++ /dev/null @@ -1,56 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_UI_GL_GL_IMMEDIATE_DRAWER_H_ -#define XENIA_UI_GL_GL_IMMEDIATE_DRAWER_H_ - -#include <memory> - -#include "xenia/ui/gl/gl.h" -#include "xenia/ui/immediate_drawer.h" - -namespace xe { -namespace ui { -namespace gl { - -class GLImmediateDrawer : public ImmediateDrawer { - public: - GLImmediateDrawer(GraphicsContext* graphics_context); - ~GLImmediateDrawer() override; - - std::unique_ptr<ImmediateTexture> CreateTexture(uint32_t width, - uint32_t height, - ImmediateTextureFilter filter, - bool repeat, - const uint8_t* data) override; - void UpdateTexture(ImmediateTexture* texture, const uint8_t* data) override; - - void Begin(int render_target_width, int render_target_height) override; - void BeginDrawBatch(const ImmediateDrawBatch& batch) override; - void Draw(const ImmediateDraw& draw) override; - void EndDrawBatch() override; - void End() override; - - private: - void InitializeShaders(); - - GLuint program_ = 0; - GLuint vao_ = 0; - GLuint vertex_buffer_ = 0; - GLuint index_buffer_ = 0; - - bool was_current_ = false; - bool batch_has_index_buffer_ = false; -}; - -} // namespace gl -} // namespace ui -} // namespace xe - -#endif // XENIA_UI_GL_GL_IMMEDIATE_DRAWER_H_ diff --git a/src/xenia/ui/gl/gl_provider.cc b/src/xenia/ui/gl/gl_provider.cc deleted file mode 100644 index b53bc9696..000000000 --- a/src/xenia/ui/gl/gl_provider.cc +++ /dev/null @@ -1,49 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include "xenia/ui/gl/gl_provider.h" - -#include "xenia/ui/gl/gl_context.h" -#include "xenia/ui/window.h" - -namespace xe { -namespace ui { -namespace gl { - -std::unique_ptr<GraphicsProvider> GLProvider::Create(Window* main_window) { - std::unique_ptr<GLProvider> provider(new GLProvider(main_window)); - - // - - return std::unique_ptr<GraphicsProvider>(provider.release()); -} - -GLProvider::GLProvider(Window* main_window) : GraphicsProvider(main_window) {} - -GLProvider::~GLProvider() = default; - -std::unique_ptr<GraphicsContext> GLProvider::CreateContext( - Window* target_window) { - auto share_context = main_window_->context(); - return std::unique_ptr<GraphicsContext>( - GLContext::Create(this, target_window, - static_cast<GLContext*>(share_context)) - .release()); -} - -std::unique_ptr<GraphicsContext> GLProvider::CreateOffscreenContext() { - auto share_context = main_window_->context(); - return std::unique_ptr<GraphicsContext>( - GLContext::CreateOffscreen(this, static_cast<GLContext*>(share_context)) - .release()); -} - -} // namespace gl -} // namespace ui -} // namespace xe diff --git a/src/xenia/ui/gl/gl_provider.h b/src/xenia/ui/gl/gl_provider.h deleted file mode 100644 index 5c3303f32..000000000 --- a/src/xenia/ui/gl/gl_provider.h +++ /dev/null @@ -1,40 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#ifndef XENIA_UI_GL_GL_PROVIDER_H_ -#define XENIA_UI_GL_GL_PROVIDER_H_ - -#include <memory> - -#include "xenia/ui/graphics_provider.h" - -namespace xe { -namespace ui { -namespace gl { - -class GLProvider : public GraphicsProvider { - public: - ~GLProvider() override; - - static std::unique_ptr<GraphicsProvider> Create(Window* main_window); - - std::unique_ptr<GraphicsContext> CreateContext( - Window* target_window) override; - - std::unique_ptr<GraphicsContext> CreateOffscreenContext() override; - - protected: - explicit GLProvider(Window* main_window); -}; - -} // namespace gl -} // namespace ui -} // namespace xe - -#endif // XENIA_UI_GL_GL_PROVIDER_H_ diff --git a/src/xenia/ui/gl/gl_window_demo.cc b/src/xenia/ui/gl/gl_window_demo.cc deleted file mode 100644 index 6b39ab40f..000000000 --- a/src/xenia/ui/gl/gl_window_demo.cc +++ /dev/null @@ -1,30 +0,0 @@ -/** - ****************************************************************************** - * Xenia : Xbox 360 Emulator Research Project * - ****************************************************************************** - * Copyright 2015 Ben Vanik. All rights reserved. * - * Released under the BSD license - see LICENSE in the root for more details. * - ****************************************************************************** - */ - -#include <string> -#include <vector> - -#include "xenia/base/main.h" -#include "xenia/ui/gl/gl_provider.h" -#include "xenia/ui/window.h" - -namespace xe { -namespace ui { - -int window_demo_main(const std::vector<std::wstring>& args); - -std::unique_ptr<GraphicsProvider> CreateDemoGraphicsProvider(Window* window) { - return xe::ui::gl::GLProvider::Create(window); -} - -} // namespace ui -} // namespace xe - -DEFINE_ENTRY_POINT(L"xenia-ui-window-gl-demo", L"xenia-ui-window-gl-demo", - xe::ui::window_demo_main); diff --git a/src/xenia/ui/gl/premake5.lua b/src/xenia/ui/gl/premake5.lua deleted file mode 100644 index 430640c70..000000000 --- a/src/xenia/ui/gl/premake5.lua +++ /dev/null @@ -1,56 +0,0 @@ -project_root = "../../../.." -include(project_root.."/tools/build") - -group("src") -project("xenia-ui-gl") - uuid("623300e3-0085-4ccc-af46-d60e88cb43aa") - kind("StaticLib") - language("C++") - links({ - "glew", - "xenia-base", - "xenia-ui", - }) - defines({ - "GLEW_STATIC=1", - "GLEW_MX=1", - }) - includedirs({ - project_root.."/third_party/gflags/src", - }) - local_platform_files() - removefiles({"*_demo.cc"}) - -group("demos") -project("xenia-ui-window-gl-demo") - uuid("e0a687e5-d1f4-4c18-b2f7-012c53ec1ee4") - kind("WindowedApp") - language("C++") - links({ - "gflags", - "glew", - "imgui", - "xenia-base", - "xenia-ui", - "xenia-ui-gl", - }) - flags({ - "WinMain", -- Use WinMain instead of main. - }) - defines({ - "GLEW_STATIC=1", - "GLEW_MX=1", - }) - includedirs({ - project_root.."/third_party/gflags/src", - }) - files({ - "../window_demo.cc", - "gl_window_demo.cc", - project_root.."/src/xenia/base/main_"..platform_suffix..".cc", - }) - files({ - }) - resincludedirs({ - project_root, - }) diff --git a/src/xenia/ui/vulkan/premake5.lua b/src/xenia/ui/vulkan/premake5.lua index 71824e5ec..51fd69aa5 100644 --- a/src/xenia/ui/vulkan/premake5.lua +++ b/src/xenia/ui/vulkan/premake5.lua @@ -31,12 +31,22 @@ project("xenia-ui-window-vulkan-demo") links({ "gflags", "imgui", - "vulkan-loader", + "volk", "xenia-base", "xenia-ui", "xenia-ui-spirv", "xenia-ui-vulkan", }) + filter("platforms:Linux") + links({ + "X11", + "xcb", + "X11-xcb", + "GL", + "vulkan", + }) + filter() + flags({ "WinMain", -- Use WinMain instead of main. }) diff --git a/src/xenia/ui/vulkan/vulkan.h b/src/xenia/ui/vulkan/vulkan.h index 38a4400f7..7d4887418 100644 --- a/src/xenia/ui/vulkan/vulkan.h +++ b/src/xenia/ui/vulkan/vulkan.h @@ -22,13 +22,10 @@ #error Platform not yet supported. #endif // XE_PLATFORM_WIN32 -// We are statically linked with the loader, so use function prototypes. -#define VK_PROTOTYPES +// We use a loader with its own function prototypes. +#include "third_party/volk/volk.h" #include "third_party/vulkan/vulkan.h" -// NOTE: header order matters here, unfortunately: -#include "third_party/vulkan/vk_lunarg_debug_marker.h" - #define XELOGVK XELOGI DECLARE_bool(vulkan_validation); diff --git a/src/xenia/ui/vulkan/vulkan_device.cc b/src/xenia/ui/vulkan/vulkan_device.cc index d31ffc327..437f8568d 100644 --- a/src/xenia/ui/vulkan/vulkan_device.cc +++ b/src/xenia/ui/vulkan/vulkan_device.cc @@ -169,7 +169,7 @@ bool VulkanDevice::Initialize(DeviceInfo device_info) { queue_info.queueFamilyIndex = i; queue_info.queueCount = family_props.queueCount; - queue_priorities[i].resize(queue_count, 0.f); + queue_priorities[i].resize(family_props.queueCount, 0.f); if (i == ideal_queue_family_index) { // Prioritize the first queue on the primary queue family. queue_priorities[i][0] = 1.0f; diff --git a/src/xenia/ui/vulkan/vulkan_instance.cc b/src/xenia/ui/vulkan/vulkan_instance.cc index efadcfa39..a383cf116 100644 --- a/src/xenia/ui/vulkan/vulkan_instance.cc +++ b/src/xenia/ui/vulkan/vulkan_instance.cc @@ -16,6 +16,7 @@ #include <string> #include "third_party/renderdoc/renderdoc_app.h" +#include "third_party/volk/volk.h" #include "xenia/base/assert.h" #include "xenia/base/logging.h" @@ -30,7 +31,7 @@ #include "xenia/ui/window_gtk.h" #endif -#define VK_API_VERSION VK_API_VERSION_1_0 +#define VK_API_VERSION VK_API_VERSION_1_1 namespace xe { namespace ui { @@ -72,6 +73,10 @@ VulkanInstance::~VulkanInstance() { DestroyInstance(); } bool VulkanInstance::Initialize() { auto version = Version::Parse(VK_API_VERSION); XELOGVK("Initializing Vulkan %s...", version.pretty_string.c_str()); + if (volkInitialize() != VK_SUCCESS) { + XELOGE("volkInitialize() failed!"); + return false; + } // Get all of the global layers and extensions provided by the system. if (!QueryGlobals()) { @@ -271,6 +276,9 @@ bool VulkanInstance::CreateInstance() { return false; } + // Load Vulkan entrypoints and extensions. + volkLoadInstance(handle); + // Enable debug validation, if needed. EnableDebugValidation(); diff --git a/src/xenia/ui/vulkan/vulkan_mem_alloc.h b/src/xenia/ui/vulkan/vulkan_mem_alloc.h new file mode 100644 index 000000000..caf89aae6 --- /dev/null +++ b/src/xenia/ui/vulkan/vulkan_mem_alloc.h @@ -0,0 +1,44 @@ +/** + ****************************************************************************** + * Xenia : Xbox 360 Emulator Research Project * + ****************************************************************************** + * Copyright 2018 Ben Vanik. All rights reserved. * + * Released under the BSD license - see LICENSE in the root for more details. * + ****************************************************************************** + */ + +#ifndef XENIA_UI_VULKAN_VULKAN_MEM_ALLOC_H_ +#define XENIA_UI_VULKAN_VULKAN_MEM_ALLOC_H_ + +#include "third_party/volk/volk.h" + +#define VMA_STATIC_VULKAN_FUNCTIONS 0 +#include "third_party/vulkan/vk_mem_alloc.h" + +namespace xe { +namespace ui { +namespace vulkan { + +inline void FillVMAVulkanFunctions(VmaVulkanFunctions* vma_funcs) { + vma_funcs->vkGetPhysicalDeviceProperties = vkGetPhysicalDeviceProperties; + vma_funcs->vkGetPhysicalDeviceMemoryProperties = + vkGetPhysicalDeviceMemoryProperties; + vma_funcs->vkAllocateMemory = vkAllocateMemory; + vma_funcs->vkFreeMemory = vkFreeMemory; + vma_funcs->vkMapMemory = vkMapMemory; + vma_funcs->vkUnmapMemory = vkUnmapMemory; + vma_funcs->vkBindBufferMemory = vkBindBufferMemory; + vma_funcs->vkBindImageMemory = vkBindImageMemory; + vma_funcs->vkGetBufferMemoryRequirements = vkGetBufferMemoryRequirements; + vma_funcs->vkGetImageMemoryRequirements = vkGetImageMemoryRequirements; + vma_funcs->vkCreateBuffer = vkCreateBuffer; + vma_funcs->vkDestroyBuffer = vkDestroyBuffer; + vma_funcs->vkCreateImage = vkCreateImage; + vma_funcs->vkDestroyImage = vkDestroyImage; +} + +} // namespace vulkan +} // namespace ui +} // namespace xe + +#endif // XENIA_UI_VULKAN_VULKAN_MEM_ALLOC_H_
\ No newline at end of file diff --git a/src/xenia/ui/vulkan/vulkan_util.cc b/src/xenia/ui/vulkan/vulkan_util.cc index 9c0a4238a..2e2034f65 100644 --- a/src/xenia/ui/vulkan/vulkan_util.cc +++ b/src/xenia/ui/vulkan/vulkan_util.cc @@ -14,7 +14,7 @@ // Implement AMD's VMA here. #define VMA_IMPLEMENTATION -#include "third_party/vulkan/vk_mem_alloc.h" +#include "xenia/ui/vulkan/vulkan_mem_alloc.h" namespace xe { namespace ui { |