RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2024-11-22 02:32:36 +01:00
Code Issues Releases Wiki Activity

Update GSL and yaml-cpp submodules

Browse Source
This commit is contained in:
Nekotekina 2018-08-24 19:07:38 +03:00
parent 923314aef5
commit 1c6c24f8ac
12 changed files with 100 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
3rdparty/GSL vendored

@ -1 +1 @@
Subproject commit fc5fce4f4f8d64fbda523d1b0d55115f5ca68774 Subproject commit 1995e86d1ad70519465374fb4876c6ef7c9f8c61

2
3rdparty/yaml-cpp vendored

@ -1 +1 @@
Subproject commit 4fb1c4b92bf8d94b32ebccdd890407d45b3bc794 Subproject commit c90c08ccc9a08abcca609064fb9a856dfdbbb7b4

2
Utilities/GSL.h
View File

@ -4,7 +4,7 @@
#pragma push_macro("new") #pragma push_macro("new")
#undef new #undef new
#include <gsl.h> #include <gsl/gsl>
#pragma pop_macro("new") #pragma pop_macro("new")
#undef Expects #undef Expects
#undef Ensures #undef Ensures

3
Utilities/types.h
View File

@ -9,6 +9,7 @@
#include <emmintrin.h> #include <emmintrin.h>
#include <cstdint> #include <cstdint>
#include <cstddef>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <chrono> #include <chrono>
@ -90,7 +91,7 @@ using steady_clock = std::conditional<
namespace gsl namespace gsl
{ {
enum class byte : u8; using std::byte;
} }
// Formatting helper, type-specific preprocessing for improving safety and functionality // Formatting helper, type-specific preprocessing for improving safety and functionality

10
rpcs3/Emu/RSX/Common/BufferUtils.cpp
View File

@ -24,6 +24,12 @@ namespace
{ {
return{ (T*)unformated_span.data(), ::narrow<int>(unformated_span.size_bytes() / sizeof(T)) }; return{ (T*)unformated_span.data(), ::narrow<int>(unformated_span.size_bytes() / sizeof(T)) };
} }
template <typename T>
gsl::span<T> as_const_span(gsl::span<const gsl::byte> unformated_span)
{
return{ (T*)unformated_span.data(), ::narrow<int>(unformated_span.size_bytes() / sizeof(T)) };
}
} }
namespace namespace
@ -820,10 +826,10 @@ std::tuple<u32, u32, u32> write_index_array_data_to_buffer(gsl::span<gsl::byte>
{ {
case rsx::index_array_type::u16: case rsx::index_array_type::u16:
return write_index_array_data_to_buffer_impl<u16>(as_span_workaround<u16>(dst), return write_index_array_data_to_buffer_impl<u16>(as_span_workaround<u16>(dst),
gsl::as_span<const be_t<u16>>(src), draw_mode, restart_index_enabled, restart_index, first_count_arguments, base_index, expands); as_const_span<const be_t<u16>>(src), draw_mode, restart_index_enabled, restart_index, first_count_arguments, base_index, expands);
case rsx::index_array_type::u32: case rsx::index_array_type::u32:
return write_index_array_data_to_buffer_impl<u32>(as_span_workaround<u32>(dst), return write_index_array_data_to_buffer_impl<u32>(as_span_workaround<u32>(dst),
gsl::as_span<const be_t<u32>>(src), draw_mode, restart_index_enabled, restart_index, first_count_arguments, base_index, expands); as_const_span<const be_t<u32>>(src), draw_mode, restart_index_enabled, restart_index, first_count_arguments, base_index, expands);
} }
fmt::throw_exception("Unknown index type" HERE); fmt::throw_exception("Unknown index type" HERE);
} }

2
rpcs3/Emu/RSX/Common/ProgramStateCache.h
View File

@ -228,7 +228,7 @@ protected:
} }
LOG_NOTICE(RSX, "FP not found in buffer!"); LOG_NOTICE(RSX, "FP not found in buffer!");
gsl::not_null<void*> fragment_program_ucode_copy = malloc(rsx_fp.ucode_length); void* fragment_program_ucode_copy = malloc(rsx_fp.ucode_length);
std::memcpy(fragment_program_ucode_copy, rsx_fp.addr, rsx_fp.ucode_length); std::memcpy(fragment_program_ucode_copy, rsx_fp.addr, rsx_fp.ucode_length);
RSXFragmentProgram new_fp_key = rsx_fp; RSXFragmentProgram new_fp_key = rsx_fp;
new_fp_key.addr = fragment_program_ucode_copy; new_fp_key.addr = fragment_program_ucode_copy;

44
rpcs3/Emu/RSX/Common/TextureUtils.cpp
View File

@ -15,6 +15,12 @@ namespace
return{ (T*)unformated_span.data(), ::narrow<int>(unformated_span.size_bytes() / sizeof(T)) }; return{ (T*)unformated_span.data(), ::narrow<int>(unformated_span.size_bytes() / sizeof(T)) };
} }
template <typename T>
gsl::span<T> as_const_span(gsl::span<const gsl::byte> unformated_span)
{
return{ (T*)unformated_span.data(), ::narrow<int>(unformated_span.size_bytes() / sizeof(T)) };
}
// TODO: Make this function part of GSL // TODO: Make this function part of GSL
// Note: Doesn't handle overlapping range detection. // Note: Doesn't handle overlapping range detection.
template<typename T1, typename T2> template<typename T1, typename T2>
@ -288,16 +294,16 @@ void upload_texture_subresource(gsl::span<gsl::byte> dst_buffer, const rsx_subre
case CELL_GCM_TEXTURE_B8: case CELL_GCM_TEXTURE_B8:
{ {
if (is_swizzled) if (is_swizzled)
copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u8>(dst_buffer), gsl::as_span<const u8>(src_layout.data), w, h, depth, get_row_pitch_in_block<u8>(w, dst_row_pitch_multiple_of)); copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u8>(dst_buffer), as_const_span<const u8>(src_layout.data), w, h, depth, get_row_pitch_in_block<u8>(w, dst_row_pitch_multiple_of));
else else
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u8>(dst_buffer), gsl::as_span<const u8>(src_layout.data), w, h, depth, get_row_pitch_in_block<u8>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u8>(dst_buffer), as_const_span<const u8>(src_layout.data), w, h, depth, get_row_pitch_in_block<u8>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
break; break;
} }
case ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN) & CELL_GCM_TEXTURE_COMPRESSED_B8R8_G8R8: case ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN) & CELL_GCM_TEXTURE_COMPRESSED_B8R8_G8R8:
case ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN) & CELL_GCM_TEXTURE_COMPRESSED_R8B8_R8G8: case ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN) & CELL_GCM_TEXTURE_COMPRESSED_R8B8_R8G8:
{ {
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), gsl::as_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), as_const_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
break; break;
} }
@ -316,9 +322,9 @@ void upload_texture_subresource(gsl::span<gsl::byte> dst_buffer, const rsx_subre
case CELL_GCM_TEXTURE_X16: case CELL_GCM_TEXTURE_X16:
{ {
if (is_swizzled) if (is_swizzled)
copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u16>(dst_buffer), gsl::as_span<const be_t<u16>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u16>(w, dst_row_pitch_multiple_of)); copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u16>(dst_buffer), as_const_span<const be_t<u16>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u16>(w, dst_row_pitch_multiple_of));
else else
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u16>(dst_buffer), gsl::as_span<const be_t<u16>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u16>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u16>(dst_buffer), as_const_span<const be_t<u16>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u16>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
break; break;
} }
@ -326,9 +332,9 @@ void upload_texture_subresource(gsl::span<gsl::byte> dst_buffer, const rsx_subre
case CELL_GCM_TEXTURE_DEPTH24_D8_FLOAT: // Untested case CELL_GCM_TEXTURE_DEPTH24_D8_FLOAT: // Untested
{ {
if (is_swizzled) if (is_swizzled)
copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), gsl::as_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of)); copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), as_const_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of));
else else
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), gsl::as_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), as_const_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
break; break;
} }
@ -336,9 +342,9 @@ void upload_texture_subresource(gsl::span<gsl::byte> dst_buffer, const rsx_subre
case CELL_GCM_TEXTURE_D8R8G8B8: case CELL_GCM_TEXTURE_D8R8G8B8:
{ {
if (is_swizzled) if (is_swizzled)
copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), gsl::as_span<const u32>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of)); copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), as_const_span<const u32>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of));
else else
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), gsl::as_span<const u32>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), as_const_span<const u32>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
break; break;
} }
@ -347,27 +353,27 @@ void upload_texture_subresource(gsl::span<gsl::byte> dst_buffer, const rsx_subre
case CELL_GCM_TEXTURE_X32_FLOAT: case CELL_GCM_TEXTURE_X32_FLOAT:
{ {
if (is_swizzled) if (is_swizzled)
copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), gsl::as_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of)); copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), as_const_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of));
else else
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), gsl::as_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u32>(dst_buffer), as_const_span<const be_t<u32>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u32>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
break; break;
} }
case CELL_GCM_TEXTURE_W16_Z16_Y16_X16_FLOAT: case CELL_GCM_TEXTURE_W16_Z16_Y16_X16_FLOAT:
{ {
if (is_swizzled) if (is_swizzled)
copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u64>(dst_buffer), gsl::as_span<const be_t<u64>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u64>(w, dst_row_pitch_multiple_of)); copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u64>(dst_buffer), as_const_span<const be_t<u64>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u64>(w, dst_row_pitch_multiple_of));
else else
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u64>(dst_buffer), gsl::as_span<const be_t<u64>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u64>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u64>(dst_buffer), as_const_span<const be_t<u64>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u64>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
break; break;
} }
case CELL_GCM_TEXTURE_W32_Z32_Y32_X32_FLOAT: case CELL_GCM_TEXTURE_W32_Z32_Y32_X32_FLOAT:
{ {
if (is_swizzled) if (is_swizzled)
copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u128>(dst_buffer), gsl::as_span<const be_t<u128>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u128>(w, dst_row_pitch_multiple_of)); copy_unmodified_block_swizzled::copy_mipmap_level(as_span_workaround<u128>(dst_buffer), as_const_span<const be_t<u128>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u128>(w, dst_row_pitch_multiple_of));
else else
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u128>(dst_buffer), gsl::as_span<const be_t<u128>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u128>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u128>(dst_buffer), as_const_span<const be_t<u128>>(src_layout.data), w, h, depth, get_row_pitch_in_block<u128>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
break; break;
} }
@ -378,11 +384,11 @@ void upload_texture_subresource(gsl::span<gsl::byte> dst_buffer, const rsx_subre
// PS3 uses the Nvidia VTC memory layout for compressed 3D textures. // PS3 uses the Nvidia VTC memory layout for compressed 3D textures.
// This is only supported using Nvidia OpenGL. // This is only supported using Nvidia OpenGL.
// Remove the VTC tiling to support ATI and Vulkan. // Remove the VTC tiling to support ATI and Vulkan.
copy_unmodified_block_vtc::copy_mipmap_level(as_span_workaround<u64>(dst_buffer), gsl::as_span<const u64>(src_layout.data), w, h, depth, get_row_pitch_in_block<u64>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block_vtc::copy_mipmap_level(as_span_workaround<u64>(dst_buffer), as_const_span<const u64>(src_layout.data), w, h, depth, get_row_pitch_in_block<u64>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
} }
else else
{ {
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u64>(dst_buffer), gsl::as_span<const u64>(src_layout.data), w, h, depth, get_row_pitch_in_block<u64>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u64>(dst_buffer), as_const_span<const u64>(src_layout.data), w, h, depth, get_row_pitch_in_block<u64>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
} }
break; break;
} }
@ -395,11 +401,11 @@ void upload_texture_subresource(gsl::span<gsl::byte> dst_buffer, const rsx_subre
// PS3 uses the Nvidia VTC memory layout for compressed 3D textures. // PS3 uses the Nvidia VTC memory layout for compressed 3D textures.
// This is only supported using Nvidia OpenGL. // This is only supported using Nvidia OpenGL.
// Remove the VTC tiling to support ATI and Vulkan. // Remove the VTC tiling to support ATI and Vulkan.
copy_unmodified_block_vtc::copy_mipmap_level(as_span_workaround<u128>(dst_buffer), gsl::as_span<const u128>(src_layout.data), w, h, depth, get_row_pitch_in_block<u128>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block_vtc::copy_mipmap_level(as_span_workaround<u128>(dst_buffer), as_const_span<const u128>(src_layout.data), w, h, depth, get_row_pitch_in_block<u128>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
} }
else else
{ {
copy_unmodified_block::copy_mipmap_level(as_span_workaround<u128>(dst_buffer), gsl::as_span<const u128>(src_layout.data), w, h, depth, get_row_pitch_in_block<u128>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block); copy_unmodified_block::copy_mipmap_level(as_span_workaround<u128>(dst_buffer), as_const_span<const u128>(src_layout.data), w, h, depth, get_row_pitch_in_block<u128>(w, dst_row_pitch_multiple_of), src_layout.pitch_in_block);
} }
break; break;
} }

43
rpcs3/Emu/RSX/Common/surface_store.h
View File

@ -4,6 +4,15 @@
#include "../GCM.h" #include "../GCM.h"
#include <list> #include <list>
namespace
{
template <typename T>
gsl::span<T> as_const_span(gsl::span<const gsl::byte> unformated_span)
{
return{ (T*)unformated_span.data(), ::narrow<int>(unformated_span.size_bytes() / sizeof(T)) };
}
}
namespace rsx namespace rsx
{ {
namespace utility namespace utility
@ -206,7 +215,7 @@ namespace rsx
if (address >= memory_end) if (address >= memory_end)
return; return;
surface_format_info info2; surface_format_info info2{};
Traits::get_surface_info(surface, &info2); Traits::get_surface_info(surface, &info2);
const auto offset = (address - memory_address); const auto offset = (address - memory_address);
const auto offset_y = (offset / info.rsx_pitch); const auto offset_y = (offset / info.rsx_pitch);
@ -218,7 +227,7 @@ namespace rsx
if (fits_w && fits_h) if (fits_w && fits_h)
{ {
typename surface_hierachy_info<surface_type>::memory_overlap_t overlap; typename surface_hierachy_info<surface_type>::memory_overlap_t overlap{};
overlap._ref = surface; overlap._ref = surface;
overlap.memory_address = address; overlap.memory_address = address;
overlap.x = offset_x; overlap.x = offset_x;
@ -237,7 +246,7 @@ namespace rsx
auto process_block = [this, process_entry](u32 memory_address, surface_type surface) auto process_block = [this, process_entry](u32 memory_address, surface_type surface)
{ {
surface_hierachy_info<surface_type> block_info; surface_hierachy_info<surface_type> block_info;
surface_format_info info; surface_format_info info{};
Traits::get_surface_info(surface, &info); Traits::get_surface_info(surface, &info);
const auto memory_end = memory_address + (info.rsx_pitch * info.surface_height); const auto memory_end = memory_address + (info.rsx_pitch * info.surface_height);
@ -282,7 +291,7 @@ namespace rsx
* returns the corresponding render target resource. * returns the corresponding render target resource.
*/ */
template <typename ...Args> template <typename ...Args>
gsl::not_null<surface_type> bind_address_as_render_targets( surface_type bind_address_as_render_targets(
command_list_type command_list, command_list_type command_list,
u32 address, u32 address,
surface_color_format color_format, size_t width, size_t height, surface_color_format color_format, size_t width, size_t height,
@ -369,7 +378,7 @@ namespace rsx
} }
template <typename ...Args> template <typename ...Args>
gsl::not_null<surface_type> bind_address_as_depth_stencil( surface_type bind_address_as_depth_stencil(
command_list_type command_list, command_list_type command_list,
u32 address, u32 address,
surface_depth_format depth_format, size_t width, size_t height, surface_depth_format depth_format, size_t width, size_t height,
@ -494,9 +503,9 @@ namespace rsx
// Same for depth buffer // Same for depth buffer
if (std::get<1>(m_bound_depth_stencil) != nullptr) if (std::get<1>(m_bound_depth_stencil) != nullptr)
Traits::prepare_ds_for_sampling(command_list, std::get<1>(m_bound_depth_stencil)); Traits::prepare_ds_for_sampling(command_list, std::get<1>(m_bound_depth_stencil));
m_bound_depth_stencil = std::make_tuple(0, nullptr); m_bound_depth_stencil = std::make_tuple(0, nullptr);
if (!address_z) if (!address_z)
return; return;
@ -584,13 +593,13 @@ namespace rsx
case surface_color_format::x32: case surface_color_format::x32:
{ {
gsl::span<be_t<u32>> dst_span{ (be_t<u32>*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(be_t<u32>)) }; gsl::span<be_t<u32>> dst_span{ (be_t<u32>*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(be_t<u32>)) };
copy_pitched_src_to_dst(dst_span, gsl::as_span<const u32>(raw_src), src_pitch, width, height); copy_pitched_src_to_dst(dst_span, as_const_span<const u32>(raw_src), src_pitch, width, height);
break; break;
} }
case surface_color_format::b8: case surface_color_format::b8:
{ {
gsl::span<u8> dst_span{ (u8*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(u8)) }; gsl::span<u8> dst_span{ (u8*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(u8)) };
copy_pitched_src_to_dst(dst_span, gsl::as_span<const u8>(raw_src), src_pitch, width, height); copy_pitched_src_to_dst(dst_span, as_const_span<const u8>(raw_src), src_pitch, width, height);
break; break;
} }
case surface_color_format::g8b8: case surface_color_format::g8b8:
@ -599,20 +608,20 @@ namespace rsx
case surface_color_format::x1r5g5b5_z1r5g5b5: case surface_color_format::x1r5g5b5_z1r5g5b5:
{ {
gsl::span<be_t<u16>> dst_span{ (be_t<u16>*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(be_t<u16>)) }; gsl::span<be_t<u16>> dst_span{ (be_t<u16>*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(be_t<u16>)) };
copy_pitched_src_to_dst(dst_span, gsl::as_span<const u16>(raw_src), src_pitch, width, height); copy_pitched_src_to_dst(dst_span, as_const_span<const u16>(raw_src), src_pitch, width, height);
break; break;
} }
// Note : may require some big endian swap // Note : may require some big endian swap
case surface_color_format::w32z32y32x32: case surface_color_format::w32z32y32x32:
{ {
gsl::span<u128> dst_span{ (u128*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(u128)) }; gsl::span<u128> dst_span{ (u128*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(u128)) };
copy_pitched_src_to_dst(dst_span, gsl::as_span<const u128>(raw_src), src_pitch, width, height); copy_pitched_src_to_dst(dst_span, as_const_span<const u128>(raw_src), src_pitch, width, height);
break; break;
} }
case surface_color_format::w16z16y16x16: case surface_color_format::w16z16y16x16:
{ {
gsl::span<u64> dst_span{ (u64*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(u64)) }; gsl::span<u64> dst_span{ (u64*)result[i].data(), ::narrow<int>(dst_pitch * height / sizeof(u64)) };
copy_pitched_src_to_dst(dst_span, gsl::as_span<const u64>(raw_src), src_pitch, width, height); copy_pitched_src_to_dst(dst_span, as_const_span<const u64>(raw_src), src_pitch, width, height);
break; break;
} }
@ -646,13 +655,13 @@ namespace rsx
{ {
result[0].resize(width * height * 2); result[0].resize(width * height * 2);
gsl::span<u16> dest{ (u16*)result[0].data(), ::narrow<int>(width * height) }; gsl::span<u16> dest{ (u16*)result[0].data(), ::narrow<int>(width * height) };
copy_pitched_src_to_dst(dest, gsl::as_span<const u16>(depth_buffer_raw_src), row_pitch, width, height); copy_pitched_src_to_dst(dest, as_const_span<const u16>(depth_buffer_raw_src), row_pitch, width, height);
} }
if (depth_format == surface_depth_format::z24s8) if (depth_format == surface_depth_format::z24s8)
{ {
result[0].resize(width * height * 4); result[0].resize(width * height * 4);
gsl::span<u32> dest{ (u32*)result[0].data(), ::narrow<int>(width * height) }; gsl::span<u32> dest{ (u32*)result[0].data(), ::narrow<int>(width * height) };
copy_pitched_src_to_dst(dest, gsl::as_span<const u32>(depth_buffer_raw_src), row_pitch, width, height); copy_pitched_src_to_dst(dest, as_const_span<const u32>(depth_buffer_raw_src), row_pitch, width, height);
} }
Traits::unmap_downloaded_buffer(depth_data, std::forward<Args&&>(args)...); Traits::unmap_downloaded_buffer(depth_data, std::forward<Args&&>(args)...);
@ -662,7 +671,7 @@ namespace rsx
gsl::span<const gsl::byte> stencil_buffer_raw_src = Traits::map_downloaded_buffer(stencil_data, std::forward<Args&&>(args)...); gsl::span<const gsl::byte> stencil_buffer_raw_src = Traits::map_downloaded_buffer(stencil_data, std::forward<Args&&>(args)...);
result[1].resize(width * height); result[1].resize(width * height);
gsl::span<u8> dest{ (u8*)result[1].data(), ::narrow<int>(width * height) }; gsl::span<u8> dest{ (u8*)result[1].data(), ::narrow<int>(width * height) };
copy_pitched_src_to_dst(dest, gsl::as_span<const u8>(stencil_buffer_raw_src), align(width, 256), width, height); copy_pitched_src_to_dst(dest, as_const_span<const u8>(stencil_buffer_raw_src), align(width, 256), width, height);
Traits::unmap_downloaded_buffer(stencil_data, std::forward<Args&&>(args)...); Traits::unmap_downloaded_buffer(stencil_data, std::forward<Args&&>(args)...);
return result; return result;
} }
@ -774,7 +783,7 @@ namespace rsx
} }
else else
{ {
surface_format_info info; surface_format_info info{};
Traits::get_surface_info(surface, &info); Traits::get_surface_info(surface, &info);
bool doubled_x = false; bool doubled_x = false;
@ -862,7 +871,7 @@ namespace rsx
{ {
if (surface_overlaps_address(surface, this_address, texaddr, &x_offset, &y_offset)) if (surface_overlaps_address(surface, this_address, texaddr, &x_offset, &y_offset))
{ {
surface_format_info info; surface_format_info info{};
Traits::get_surface_info(surface, &info); Traits::get_surface_info(surface, &info);
u16 real_width = requested_width; u16 real_width = requested_width;

2
rpcs3/Emu/RSX/D3D12/D3D12Buffer.cpp
View File

@ -262,7 +262,7 @@ namespace
std::function<attribute_storage(rsx::rsx_state, std::vector<std::pair<u32, u32>>)> std::function<attribute_storage(rsx::rsx_state, std::vector<std::pair<u32, u32>>)>
get_vertex_buffers, get_vertex_buffers,
ID3D12Resource* m_vertex_buffer_data, d3d12_data_heap& m_buffer_data, ID3D12Resource* m_vertex_buffer_data, d3d12_data_heap& m_buffer_data,
gsl::not_null<ID3D12GraphicsCommandList*> command_list) ID3D12GraphicsCommandList* command_list)
{ {
command_list->ResourceBarrier(1, command_list->ResourceBarrier(1,
&CD3DX12_RESOURCE_BARRIER::Transition(m_vertex_buffer_data, &CD3DX12_RESOURCE_BARRIER::Transition(m_vertex_buffer_data,

32
rpcs3/Emu/RSX/D3D12/D3D12RenderTargetSets.h
View File

@ -15,7 +15,7 @@ struct render_target_traits
{ {
using surface_storage_type = ComPtr<ID3D12Resource>; using surface_storage_type = ComPtr<ID3D12Resource>;
using surface_type = ID3D12Resource*; using surface_type = ID3D12Resource*;
using command_list_type = gsl::not_null<ID3D12GraphicsCommandList*>; using command_list_type = ID3D12GraphicsCommandList*;
using download_buffer_object = std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE>; // heap offset, size, last_put_pos, fence, handle using download_buffer_object = std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE>; // heap offset, size, last_put_pos, fence, handle
//TODO: Move this somewhere else //TODO: Move this somewhere else
@ -26,7 +26,7 @@ struct render_target_traits
u32 address, u32 address,
surface_color_format color_format, size_t width, size_t height, surface_color_format color_format, size_t width, size_t height,
ID3D12Resource* /*old*/, ID3D12Resource* /*old*/,
gsl::not_null<ID3D12Device*> device, const std::array<float, 4> &clear_color, float, u8) ID3D12Device* device, const std::array<float, 4> &clear_color, float, u8)
{ {
DXGI_FORMAT dxgi_format = get_color_surface_format(color_format); DXGI_FORMAT dxgi_format = get_color_surface_format(color_format);
ComPtr<ID3D12Resource> rtt; ComPtr<ID3D12Resource> rtt;
@ -68,7 +68,7 @@ struct render_target_traits
static static
void prepare_rtt_for_drawing( void prepare_rtt_for_drawing(
gsl::not_null<ID3D12GraphicsCommandList*> command_list, ID3D12GraphicsCommandList* command_list,
ID3D12Resource* rtt) ID3D12Resource* rtt)
{ {
command_list->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(rtt, D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_RENDER_TARGET)); command_list->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(rtt, D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_RENDER_TARGET));
@ -76,7 +76,7 @@ struct render_target_traits
static static
void prepare_rtt_for_sampling( void prepare_rtt_for_sampling(
gsl::not_null<ID3D12GraphicsCommandList*> command_list, ID3D12GraphicsCommandList* command_list,
ID3D12Resource* rtt) ID3D12Resource* rtt)
{ {
command_list->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(rtt, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_GENERIC_READ)); command_list->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(rtt, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_GENERIC_READ));
@ -87,7 +87,7 @@ struct render_target_traits
u32 address, u32 address,
surface_depth_format surfaceDepthFormat, size_t width, size_t height, surface_depth_format surfaceDepthFormat, size_t width, size_t height,
ID3D12Resource* /*old*/, ID3D12Resource* /*old*/,
gsl::not_null<ID3D12Device*> device, const std::array<float, 4>& , float clear_depth, u8 clear_stencil) ID3D12Device* device, const std::array<float, 4>& , float clear_depth, u8 clear_stencil)
{ {
D3D12_CLEAR_VALUE clear_depth_value = {}; D3D12_CLEAR_VALUE clear_depth_value = {};
clear_depth_value.DepthStencil.Depth = clear_depth; clear_depth_value.DepthStencil.Depth = clear_depth;
@ -113,7 +113,7 @@ struct render_target_traits
static static
void prepare_ds_for_drawing( void prepare_ds_for_drawing(
gsl::not_null<ID3D12GraphicsCommandList*> command_list, ID3D12GraphicsCommandList* command_list,
ID3D12Resource* ds) ID3D12Resource* ds)
{ {
// set the resource as depth write // set the resource as depth write
@ -122,7 +122,7 @@ struct render_target_traits
static static
void prepare_ds_for_sampling( void prepare_ds_for_sampling(
gsl::not_null<ID3D12GraphicsCommandList*> command_list, ID3D12GraphicsCommandList* command_list,
ID3D12Resource* ds) ID3D12Resource* ds)
{ {
command_list->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(ds, D3D12_RESOURCE_STATE_DEPTH_WRITE, D3D12_RESOURCE_STATE_GENERIC_READ)); command_list->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(ds, D3D12_RESOURCE_STATE_DEPTH_WRITE, D3D12_RESOURCE_STATE_GENERIC_READ));
@ -130,7 +130,7 @@ struct render_target_traits
static static
void invalidate_surface_contents( void invalidate_surface_contents(
gsl::not_null<ID3D12GraphicsCommandList*>, ID3D12GraphicsCommandList*,
ID3D12Resource*, ID3D12Resource*) ID3D12Resource*, ID3D12Resource*)
{} {}
@ -158,9 +158,9 @@ struct render_target_traits
static static
std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> issue_download_command( std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> issue_download_command(
gsl::not_null<ID3D12Resource*> rtt, ID3D12Resource* rtt,
surface_color_format color_format, size_t width, size_t height, surface_color_format color_format, size_t width, size_t height,
gsl::not_null<ID3D12Device*> device, gsl::not_null<ID3D12CommandQueue*> command_queue, d3d12_data_heap &readback_heap, resource_storage &res_store ID3D12Device* device, ID3D12CommandQueue* command_queue, d3d12_data_heap &readback_heap, resource_storage &res_store
) )
{ {
ID3D12GraphicsCommandList* command_list = res_store.command_list.Get(); ID3D12GraphicsCommandList* command_list = res_store.command_list.Get();
@ -191,9 +191,9 @@ struct render_target_traits
static static
std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> issue_depth_download_command( std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> issue_depth_download_command(
gsl::not_null<ID3D12Resource*> ds, ID3D12Resource* ds,
surface_depth_format depth_format, size_t width, size_t height, surface_depth_format depth_format, size_t width, size_t height,
gsl::not_null<ID3D12Device*> device, gsl::not_null<ID3D12CommandQueue*> command_queue, d3d12_data_heap &readback_heap, resource_storage &res_store ID3D12Device* device, ID3D12CommandQueue* command_queue, d3d12_data_heap &readback_heap, resource_storage &res_store
) )
{ {
ID3D12GraphicsCommandList* command_list = res_store.command_list.Get(); ID3D12GraphicsCommandList* command_list = res_store.command_list.Get();
@ -224,9 +224,9 @@ struct render_target_traits
static static
std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> issue_stencil_download_command( std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> issue_stencil_download_command(
gsl::not_null<ID3D12Resource*> stencil, ID3D12Resource* stencil,
size_t width, size_t height, size_t width, size_t height,
gsl::not_null<ID3D12Device*> device, gsl::not_null<ID3D12CommandQueue*> command_queue, d3d12_data_heap &readback_heap, resource_storage &res_store ID3D12Device* device, ID3D12CommandQueue* command_queue, d3d12_data_heap &readback_heap, resource_storage &res_store
) )
{ {
ID3D12GraphicsCommandList* command_list = res_store.command_list.Get(); ID3D12GraphicsCommandList* command_list = res_store.command_list.Get();
@ -256,7 +256,7 @@ struct render_target_traits
static static
gsl::span<const gsl::byte> map_downloaded_buffer(const std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> &sync_data, gsl::span<const gsl::byte> map_downloaded_buffer(const std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> &sync_data,
gsl::not_null<ID3D12Device*>, gsl::not_null<ID3D12CommandQueue*>, d3d12_data_heap &readback_heap, resource_storage&) ID3D12Device*, ID3D12CommandQueue*, d3d12_data_heap &readback_heap, resource_storage&)
{ {
size_t offset; size_t offset;
size_t buffer_size; size_t buffer_size;
@ -273,7 +273,7 @@ struct render_target_traits
static static
void unmap_downloaded_buffer(const std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> &, void unmap_downloaded_buffer(const std::tuple<size_t, size_t, size_t, ComPtr<ID3D12Fence>, HANDLE> &,
gsl::not_null<ID3D12Device*>, gsl::not_null<ID3D12CommandQueue*>, d3d12_data_heap &readback_heap, resource_storage&) ID3D12Device*, ID3D12CommandQueue*, d3d12_data_heap &readback_heap, resource_storage&)
{ {
readback_heap.unmap(); readback_heap.unmap();
} }

2
rpcs3/Emu/RSX/VK/VKRenderTargets.h
View File

@ -289,7 +289,7 @@ namespace rsx
gsl::span<const gsl::byte> map_downloaded_buffer(download_buffer_object, ...) gsl::span<const gsl::byte> map_downloaded_buffer(download_buffer_object, ...)
{ {
return{ (gsl::byte*)nullptr, 0 }; return {};
} }
static void unmap_downloaded_buffer(download_buffer_object, ...) static void unmap_downloaded_buffer(download_buffer_object, ...)

25
rpcs3/rpcs3qt/rsx_debugger.cpp
View File

@ -10,6 +10,15 @@ enum GCMEnumTypes
constexpr auto qstr = QString::fromStdString; constexpr auto qstr = QString::fromStdString;
namespace
{
template <typename T>
gsl::span<T> as_const_span(gsl::span<const gsl::byte> unformated_span)
{
return{ (T*)unformated_span.data(), ::narrow<int>(unformated_span.size_bytes() / sizeof(T)) };
}
}
rsx_debugger::rsx_debugger(std::shared_ptr<gui_settings> gui_settings, QWidget* parent) rsx_debugger::rsx_debugger(std::shared_ptr<gui_settings> gui_settings, QWidget* parent)
: QDialog(parent) : QDialog(parent)
, m_gui_settings(gui_settings) , m_gui_settings(gui_settings)
@ -416,12 +425,12 @@ namespace
{ {
case rsx::surface_color_format::b8: case rsx::surface_color_format::b8:
{ {
u8 value = gsl::as_span<const u8>(orig_buffer)[idx]; u8 value = as_const_span<const u8>(orig_buffer)[idx];
return{ value, value, value }; return{ value, value, value };
} }
case rsx::surface_color_format::x32: case rsx::surface_color_format::x32:
{ {
be_t<u32> stored_val = gsl::as_span<const be_t<u32>>(orig_buffer)[idx]; be_t<u32> stored_val = as_const_span<const be_t<u32>>(orig_buffer)[idx];
u32 swapped_val = stored_val; u32 swapped_val = stored_val;
f32 float_val = (f32&)swapped_val; f32 float_val = (f32&)swapped_val;
u8 val = float_val * 255.f; u8 val = float_val * 255.f;
@ -431,19 +440,19 @@ namespace
case rsx::surface_color_format::x8b8g8r8_o8b8g8r8: case rsx::surface_color_format::x8b8g8r8_o8b8g8r8:
case rsx::surface_color_format::x8b8g8r8_z8b8g8r8: case rsx::surface_color_format::x8b8g8r8_z8b8g8r8:
{ {
auto ptr = gsl::as_span<const u8>(orig_buffer); auto ptr = as_const_span<const u8>(orig_buffer);
return{ ptr[1 + idx * 4], ptr[2 + idx * 4], ptr[3 + idx * 4] }; return{ ptr[1 + idx * 4], ptr[2 + idx * 4], ptr[3 + idx * 4] };
} }
case rsx::surface_color_format::a8r8g8b8: case rsx::surface_color_format::a8r8g8b8:
case rsx::surface_color_format::x8r8g8b8_o8r8g8b8: case rsx::surface_color_format::x8r8g8b8_o8r8g8b8:
case rsx::surface_color_format::x8r8g8b8_z8r8g8b8: case rsx::surface_color_format::x8r8g8b8_z8r8g8b8:
{ {
auto ptr = gsl::as_span<const u8>(orig_buffer); auto ptr = as_const_span<const u8>(orig_buffer);
return{ ptr[3 + idx * 4], ptr[2 + idx * 4], ptr[1 + idx * 4] }; return{ ptr[3 + idx * 4], ptr[2 + idx * 4], ptr[1 + idx * 4] };
} }
case rsx::surface_color_format::w16z16y16x16: case rsx::surface_color_format::w16z16y16x16:
{ {
auto ptr = gsl::as_span<const u16>(orig_buffer); auto ptr = as_const_span<const u16>(orig_buffer);
f16 h0 = f16(ptr[4 * idx]); f16 h0 = f16(ptr[4 * idx]);
f16 h1 = f16(ptr[4 * idx + 1]); f16 h1 = f16(ptr[4 * idx + 1]);
f16 h2 = f16(ptr[4 * idx + 2]); f16 h2 = f16(ptr[4 * idx + 2]);
@ -524,7 +533,7 @@ void rsx_debugger::OnClickDrawCalls()
{ {
for (u32 col = 0; col < width; col++) for (u32 col = 0; col < width; col++)
{ {
u32 depth_val = gsl::as_span<const u32>(orig_buffer)[row * width + col]; u32 depth_val = as_const_span<const u32>(orig_buffer)[row * width + col];
u8 displayed_depth_val = 255 * depth_val / 0xFFFFFF; u8 displayed_depth_val = 255 * depth_val / 0xFFFFFF;
buffer[4 * col + 0 + width * row * 4] = displayed_depth_val; buffer[4 * col + 0 + width * row * 4] = displayed_depth_val;
buffer[4 * col + 1 + width * row * 4] = displayed_depth_val; buffer[4 * col + 1 + width * row * 4] = displayed_depth_val;
@ -539,7 +548,7 @@ void rsx_debugger::OnClickDrawCalls()
{ {
for (u32 col = 0; col < width; col++) for (u32 col = 0; col < width; col++)
{ {
u16 depth_val = gsl::as_span<const u16>(orig_buffer)[row * width + col]; u16 depth_val = as_const_span<const u16>(orig_buffer)[row * width + col];
u8 displayed_depth_val = 255 * depth_val / 0xFFFF; u8 displayed_depth_val = 255 * depth_val / 0xFFFF;
buffer[4 * col + 0 + width * row * 4] = displayed_depth_val; buffer[4 * col + 0 + width * row * 4] = displayed_depth_val;
buffer[4 * col + 1 + width * row * 4] = displayed_depth_val; buffer[4 * col + 1 + width * row * 4] = displayed_depth_val;
@ -563,7 +572,7 @@ void rsx_debugger::OnClickDrawCalls()
{ {
for (u32 col = 0; col < width; col++) for (u32 col = 0; col < width; col++)
{ {
u8 stencil_val = gsl::as_span<const u8>(orig_buffer)[row * width + col]; u8 stencil_val = as_const_span<const u8>(orig_buffer)[row * width + col];
buffer[4 * col + 0 + width * row * 4] = stencil_val; buffer[4 * col + 0 + width * row * 4] = stencil_val;
buffer[4 * col + 1 + width * row * 4] = stencil_val; buffer[4 * col + 1 + width * row * 4] = stencil_val;
buffer[4 * col + 2 + width * row * 4] = stencil_val; buffer[4 * col + 2 + width * row * 4] = stencil_val;