diff --git a/README.md b/README.md index 10e0b4d62..7f3e6963c 100755 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ yuzu emulator early access ============= -This is the source code for early-access 2901. +This is the source code for early-access 2904. ## Legal Notice diff --git a/src/video_core/renderer_vulkan/vk_compute_pass.cpp b/src/video_core/renderer_vulkan/vk_compute_pass.cpp index f17a5ccd6..241d7573e 100755 --- a/src/video_core/renderer_vulkan/vk_compute_pass.cpp +++ b/src/video_core/renderer_vulkan/vk_compute_pass.cpp @@ -26,8 +26,6 @@ namespace Vulkan { -using Tegra::Texture::SWIZZLE_TABLE; - namespace { constexpr u32 ASTC_BINDING_INPUT_BUFFER = 0; diff --git a/src/video_core/textures/decoders.cpp b/src/video_core/textures/decoders.cpp index c287213d8..aa7262fd6 100755 --- a/src/video_core/textures/decoders.cpp +++ b/src/video_core/textures/decoders.cpp @@ -15,6 +15,24 @@ namespace Tegra::Texture { namespace { +template +constexpr u32 pdep(u32 value) { + u32 result = 0; + u32 m = mask; + for (u32 bit = 1; m; bit += bit) { + if (value & bit) + result |= m & -m; + m &= m - 1; + } + return result; +} + +template +void incrpdep(u32& value) { + constexpr u32 swizzled_incr = pdep(incr_amount); + value = ((value | ~mask) + swizzled_incr) & mask; +} + template void SwizzleImpl(std::span output, std::span input, u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth, u32 stride) { @@ -43,18 +61,20 @@ void SwizzleImpl(std::span output, std::span input, u32 width, u32 ((z & block_depth_mask) << (GOB_SIZE_SHIFT + block_height)); for (u32 line = 0; line < height; ++line) { const u32 y = line + origin_y; - const auto& table = SWIZZLE_TABLE[y % GOB_SIZE_Y]; + const u32 swizzled_y = pdep(y); const u32 block_y = y >> GOB_SIZE_Y_SHIFT; const u32 offset_y = (block_y >> block_height) * block_size + ((block_y & block_height_mask) << GOB_SIZE_SHIFT); - for (u32 column = 0; column < width; ++column) { + u32 swizzled_x = pdep(origin_x * BYTES_PER_PIXEL); + for (u32 column = 0; column < width; + ++column, incrpdep(swizzled_x)) { const u32 x = (column + origin_x) * BYTES_PER_PIXEL; const u32 offset_x = (x >> GOB_SIZE_X_SHIFT) << x_shift; const u32 base_swizzled_offset = offset_z + offset_y + offset_x; - const u32 swizzled_offset = base_swizzled_offset + table[x % GOB_SIZE_X]; + const u32 swizzled_offset = base_swizzled_offset + (swizzled_x | swizzled_y); const u32 unswizzled_offset = slice * pitch * height + line * pitch + column * BYTES_PER_PIXEL; @@ -100,18 +120,20 @@ void SwizzleSubrectImpl(std::span output, std::span input, u32 wid const u32 lines_in_y = std::min(unprocessed_lines, extent_y); for (u32 line = 0; line < lines_in_y; ++line) { const u32 y = line + origin_y; - const auto& table = SWIZZLE_TABLE[y % GOB_SIZE_Y]; + const u32 swizzled_y = pdep(y); const u32 block_y = y >> GOB_SIZE_Y_SHIFT; const u32 offset_y = (block_y >> block_height) * block_size + ((block_y & block_height_mask) << GOB_SIZE_SHIFT); - for (u32 column = 0; column < extent_x; ++column) { + u32 swizzled_x = 0; + for (u32 column = 0; column < extent_x; + ++column, incrpdep(swizzled_x)) { const u32 x = (column + origin_x) * BYTES_PER_PIXEL; const u32 offset_x = (x >> GOB_SIZE_X_SHIFT) << x_shift; const u32 base_swizzled_offset = offset_z + offset_y + offset_x; - const u32 swizzled_offset = base_swizzled_offset + table[x % GOB_SIZE_X]; + const u32 swizzled_offset = base_swizzled_offset + (swizzled_x | swizzled_y); const u32 unswizzled_offset = slice * pitch * height + line * pitch + column * BYTES_PER_PIXEL; @@ -151,6 +173,98 @@ void Swizzle(std::span output, std::span input, u32 bytes_per_pixe } } +template +void SwizzleSubrect(u32 subrect_width, u32 subrect_height, u32 source_pitch, u32 swizzled_width, + u8* swizzled_data, const u8* unswizzled_data, u32 block_height_bit, + u32 offset_x, u32 offset_y) { + const u32 block_height = 1U << block_height_bit; + const u32 image_width_in_gobs = + (swizzled_width * BYTES_PER_PIXEL + (GOB_SIZE_X - 1)) / GOB_SIZE_X; + for (u32 line = 0; line < subrect_height; ++line) { + const u32 dst_y = line + offset_y; + const u32 gob_address_y = + (dst_y / (GOB_SIZE_Y * block_height)) * GOB_SIZE * block_height * image_width_in_gobs + + ((dst_y % (GOB_SIZE_Y * block_height)) / GOB_SIZE_Y) * GOB_SIZE; + + const u32 swizzled_y = pdep(dst_y); + u32 swizzled_x = pdep(offset_x * BYTES_PER_PIXEL); + for (u32 x = 0; x < subrect_width; + ++x, incrpdep(swizzled_x)) { + const u32 dst_x = x + offset_x; + const u32 gob_address = + gob_address_y + (dst_x * BYTES_PER_PIXEL / GOB_SIZE_X) * GOB_SIZE * block_height; + const u32 swizzled_offset = gob_address + (swizzled_x | swizzled_y); + const u32 unswizzled_offset = line * source_pitch + x * BYTES_PER_PIXEL; + + const u8* const source_line = unswizzled_data + unswizzled_offset; + u8* const dest_addr = swizzled_data + swizzled_offset; + std::memcpy(dest_addr, source_line, BYTES_PER_PIXEL); + } + } +} + +template +void UnswizzleSubrect(u32 line_length_in, u32 line_count, u32 pitch, u32 width, u32 block_height, + u32 origin_x, u32 origin_y, u8* output, const u8* input) { + const u32 stride = width * BYTES_PER_PIXEL; + const u32 gobs_in_x = (stride + GOB_SIZE_X - 1) / GOB_SIZE_X; + const u32 block_size = gobs_in_x << (GOB_SIZE_SHIFT + block_height); + + const u32 block_height_mask = (1U << block_height) - 1; + const u32 x_shift = GOB_SIZE_SHIFT + block_height; + + for (u32 line = 0; line < line_count; ++line) { + const u32 src_y = line + origin_y; + const u32 swizzled_y = pdep(src_y); + + const u32 block_y = src_y >> GOB_SIZE_Y_SHIFT; + const u32 src_offset_y = (block_y >> block_height) * block_size + + ((block_y & block_height_mask) << GOB_SIZE_SHIFT); + + u32 swizzled_x = pdep(origin_x * BYTES_PER_PIXEL); + for (u32 column = 0; column < line_length_in; + ++column, incrpdep(swizzled_x)) { + const u32 src_x = (column + origin_x) * BYTES_PER_PIXEL; + const u32 src_offset_x = (src_x >> GOB_SIZE_X_SHIFT) << x_shift; + + const u32 swizzled_offset = src_offset_y + src_offset_x + (swizzled_x | swizzled_y); + const u32 unswizzled_offset = line * pitch + column * BYTES_PER_PIXEL; + + std::memcpy(output + unswizzled_offset, input + swizzled_offset, BYTES_PER_PIXEL); + } + } +} + +template +void SwizzleSliceToVoxel(u32 line_length_in, u32 line_count, u32 pitch, u32 width, u32 height, + u32 block_height, u32 block_depth, u32 origin_x, u32 origin_y, u8* output, + const u8* input) { + UNIMPLEMENTED_IF(origin_x > 0); + UNIMPLEMENTED_IF(origin_y > 0); + + const u32 stride = width * BYTES_PER_PIXEL; + const u32 gobs_in_x = (stride + GOB_SIZE_X - 1) / GOB_SIZE_X; + const u32 block_size = gobs_in_x << (GOB_SIZE_SHIFT + block_height + block_depth); + + const u32 block_height_mask = (1U << block_height) - 1; + const u32 x_shift = static_cast(GOB_SIZE_SHIFT) + block_height + block_depth; + + for (u32 line = 0; line < line_count; ++line) { + const u32 swizzled_y = pdep(line); + const u32 block_y = line / GOB_SIZE_Y; + const u32 dst_offset_y = + (block_y >> block_height) * block_size + (block_y & block_height_mask) * GOB_SIZE; + + u32 swizzled_x = 0; + for (u32 x = 0; x < line_length_in; ++x, incrpdep(swizzled_x)) { + const u32 dst_offset = + ((x / GOB_SIZE_X) << x_shift) + dst_offset_y + (swizzled_x | swizzled_y); + const u32 src_offset = x * BYTES_PER_PIXEL + line * pitch; + std::memcpy(output + dst_offset, input + src_offset, BYTES_PER_PIXEL); + } + } +} + } // Anonymous namespace void UnswizzleTexture(std::span output, std::span input, u32 bytes_per_pixel, diff --git a/src/video_core/textures/decoders.h b/src/video_core/textures/decoders.h index f51695ba1..e70407692 100755 --- a/src/video_core/textures/decoders.h +++ b/src/video_core/textures/decoders.h @@ -20,6 +20,9 @@ constexpr u32 GOB_SIZE_Y_SHIFT = 3; constexpr u32 GOB_SIZE_Z_SHIFT = 0; constexpr u32 GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHIFT; +constexpr u32 SWIZZLE_X_BITS = 0b100101111; +constexpr u32 SWIZZLE_Y_BITS = 0b011010000; + using SwizzleTable = std::array, GOB_SIZE_Y>; /** @@ -37,7 +40,6 @@ constexpr SwizzleTable MakeSwizzleTable() { } return table; } -constexpr SwizzleTable SWIZZLE_TABLE = MakeSwizzleTable(); /// Unswizzles a block linear texture into linear memory. void UnswizzleTexture(std::span output, std::span input, u32 bytes_per_pixel,