Skip to content

VERY experimental Nintendo Switch 2 emulator

C++

[video_core] Implementation on ASTC HDR formats + Vulkan fixes (#4190)

CamilleLaVey3a6ac6e418f0
diff --git a/src/video_core/host_shaders/astc_decoder.comp b/src/video_core/host_shaders/astc_decoder.comp
index da21b4bde8..ce03e589ad 100644
--- a/src/video_core/host_shaders/astc_decoder.comp
+++ b/src/video_core/host_shaders/astc_decoder.comp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@@ -40,7 +43,11 @@ layout(binding = BINDING_INPUT_BUFFER, std430) readonly restrict buffer InputBuf
uvec4 astc_data[];
};
+#ifdef VULKAN
+layout(binding = BINDING_OUTPUT_IMAGE) uniform writeonly restrict image2DArray dest_image;
+#else
layout(binding = BINDING_OUTPUT_IMAGE, rgba8) uniform writeonly restrict image2DArray dest_image;
+#endif
const uint GOB_SIZE_X_SHIFT = 6;
const uint GOB_SIZE_Y_SHIFT = 3;
@@ -589,6 +596,158 @@ ivec4 BlueContract(int a, int r, int g, int b) {
return ivec4(a, (r + b) >> 1, (g + b) >> 1, b);
}
+bool IsHDRColorEndpointMode(uint cem) {
+ return cem == 2u || cem == 3u || cem == 7u || cem == 11u || cem == 14u || cem == 15u;
+}
+
+int SignExtend(int value, uint nbits) {
+ int sign_bit = 1 << (nbits - 1u);
+ return (value ^ sign_bit) - sign_bit;
+}
+
+void DecodeHDREndpointMode7(uint v0, uint v1, uint v2, uint v3, out ivec3 e0, out ivec3 e1) {
+ uint modeval = ((v0 & 0xC0u) >> 6u) | ((v1 & 0x80u) >> 5u) | ((v2 & 0x80u) >> 4u);
+
+ uint majcomp;
+ uint mode;
+ if ((modeval & 0xCu) != 0xCu) {
+ majcomp = modeval >> 2u;
+ mode = modeval & 3u;
+ } else if (modeval != 0xFu) {
+ majcomp = modeval & 3u;
+ mode = 4u;
+ } else {
+ majcomp = 0u;
+ mode = 5u;
+ }
+
+ int red = int(v0 & 0x3Fu);
+ int green = int(v1 & 0x1Fu);
+ int blue = int(v2 & 0x1Fu);
+ int scale = int(v3 & 0x1Fu);
+
+ uint x0 = (v1 >> 6u) & 1u;
+ uint x1 = (v1 >> 5u) & 1u;
+ uint x2 = (v2 >> 6u) & 1u;
+ uint x3 = (v2 >> 5u) & 1u;
+ uint x4 = (v3 >> 7u) & 1u;
+ uint x5 = (v3 >> 6u) & 1u;
+ uint x6 = (v3 >> 5u) & 1u;
+
+ uint ohm = 1u << mode;
+ if ((ohm & 0x30u) != 0u) green |= int(x0 << 6u);
+ if ((ohm & 0x3Au) != 0u) green |= int(x1 << 5u);
+ if ((ohm & 0x30u) != 0u) blue |= int(x2 << 6u);
+ if ((ohm & 0x3Au) != 0u) blue |= int(x3 << 5u);
+ if ((ohm & 0x3Du) != 0u) scale |= int(x6 << 5u);
+ if ((ohm & 0x2Du) != 0u) scale |= int(x5 << 6u);
+ if ((ohm & 0x04u) != 0u) scale |= int(x4 << 7u);
+ if ((ohm & 0x3Bu) != 0u) red |= int(x4 << 6u);
+ if ((ohm & 0x04u) != 0u) red |= int(x3 << 6u);
+ if ((ohm & 0x10u) != 0u) red |= int(x5 << 7u);
+ if ((ohm & 0x0Fu) != 0u) red |= int(x2 << 7u);
+ if ((ohm & 0x05u) != 0u) red |= int(x1 << 8u);
+ if ((ohm & 0x0Au) != 0u) red |= int(x0 << 8u);
+ if ((ohm & 0x05u) != 0u) red |= int(x0 << 9u);
+ if ((ohm & 0x02u) != 0u) red |= int(x6 << 9u);
+ if ((ohm & 0x01u) != 0u) red |= int(x3 << 10u);
+ if ((ohm & 0x02u) != 0u) red |= int(x5 << 10u);
+
+ int shamts[6] = int[](1, 1, 2, 3, 4, 5);
+ int shamt = shamts[mode];
+ red <<= shamt;
+ green <<= shamt;
+ blue <<= shamt;
+ scale <<= shamt;
+
+ if (mode != 5u) {
+ green = red - green;
+ blue = red - blue;
+ }
+
+ if (majcomp == 1u) {
+ int t = red; red = green; green = t;
+ }
+ if (majcomp == 2u) {
+ int t = red; red = blue; blue = t;
+ }
+
+ e1 = ivec3(clamp(red, 0, 0xFFF), clamp(green, 0, 0xFFF), clamp(blue, 0, 0xFFF));
+ e0 = ivec3(clamp(red - scale, 0, 0xFFF), clamp(green - scale, 0, 0xFFF),
+ clamp(blue - scale, 0, 0xFFF));
+}
+
+void DecodeHDREndpointMode11(uint v0, uint v1, uint v2, uint v3, uint v4, uint v5, out ivec3 e0,
+ out ivec3 e1) {
+ uint majcomp = ((v4 & 0x80u) >> 7u) | ((v5 & 0x80u) >> 6u);
+ if (majcomp == 3u) {
+ e0 = ivec3(int(v0 << 4u), int(v2 << 4u), int((v4 & 0x7Fu) << 5u));
+ e1 = ivec3(int(v1 << 4u), int(v3 << 4u), int((v5 & 0x7Fu) << 5u));
+ return;
+ }
+
+ uint mode = ((v1 & 0x80u) >> 7u) | ((v2 & 0x80u) >> 6u) | ((v3 & 0x80u) >> 5u);
+ int va = int(v0 | ((v1 & 0x40u) << 2u));
+ int vb0 = int(v2 & 0x3Fu);
+ int vb1 = int(v3 & 0x3Fu);
+ int vc = int(v1 & 0x3Fu);
+ int vd0 = int(v4 & 0x7Fu);
+ int vd1 = int(v5 & 0x7Fu);
+
+ int dbitstab[8] = int[](7, 6, 7, 6, 5, 6, 5, 6);
+ vd0 = SignExtend(vd0, uint(dbitstab[mode]));
+ vd1 = SignExtend(vd1, uint(dbitstab[mode]));
+
+ uint x0 = (v2 >> 6u) & 1u;
+ uint x1 = (v3 >> 6u) & 1u;
+ uint x2 = (v4 >> 6u) & 1u;
+ uint x3 = (v5 >> 6u) & 1u;
+ uint x4 = (v4 >> 5u) & 1u;
+ uint x5 = (v5 >> 5u) & 1u;
+
+ uint ohm = 1u << mode;
+ if ((ohm & 0xA4u) != 0u) va |= int(x0 << 9u);
+ if ((ohm & 0x08u) != 0u) va |= int(x2 << 9u);
+ if ((ohm & 0x50u) != 0u) va |= int(x4 << 9u);
+ if ((ohm & 0x50u) != 0u) va |= int(x5 << 10u);
+ if ((ohm & 0xA0u) != 0u) va |= int(x1 << 10u);
+ if ((ohm & 0xC0u) != 0u) va |= int(x2 << 11u);
+ if ((ohm & 0x04u) != 0u) vc |= int(x1 << 6u);
+ if ((ohm & 0xE8u) != 0u) vc |= int(x3 << 6u);
+ if ((ohm & 0x20u) != 0u) vc |= int(x2 << 7u);
+ if ((ohm & 0x5Bu) != 0u) vb0 |= int(x0 << 6u);
+ if ((ohm & 0x5Bu) != 0u) vb1 |= int(x1 << 6u);
+ if ((ohm & 0x12u) != 0u) vb0 |= int(x2 << 7u);
+ if ((ohm & 0x12u) != 0u) vb1 |= int(x3 << 7u);
+
+ int shamt = (int(mode) >> 1) ^ 3;
+ va <<= shamt;
+ vb0 <<= shamt;
+ vb1 <<= shamt;
+ vc <<= shamt;
+ vd0 <<= shamt;
+ vd1 <<= shamt;
+
+ int r1 = clamp(va, 0, 0xFFF);
+ int g1 = clamp(va - vb0, 0, 0xFFF);
+ int b1 = clamp(va - vb1, 0, 0xFFF);
+ int r0 = clamp(va - vc, 0, 0xFFF);
+ int g0 = clamp(va - vb0 - vc - vd0, 0, 0xFFF);
+ int b0 = clamp(va - vb1 - vc - vd1, 0, 0xFFF);
+
+ if (majcomp == 1u) {
+ int t;
+ t = r0; r0 = g0; g0 = t;
+ t = r1; r1 = g1; g1 = t;
+ } else if (majcomp == 2u) {
+ int t;
+ t = r0; r0 = b0; b0 = t;
+ t = r1; r1 = b1; b1 = t;
+ }
+ e0 = ivec3(r0, g0, b0);
+ e1 = ivec3(r1, g1, b1);
+}
+
void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, uint color_endpoint_mode, uint color_values[32],
inout uint colvals_index) {
#define READ_UINT_VALUES(N) \
@@ -715,8 +874,86 @@ void ComputeEndpoints(out uvec4 ep1, out uvec4 ep2, uint color_endpoint_mode, ui
}
break;
}
+ case 2: {
+ READ_UINT_VALUES(2)
+ uint y0, y1;
+ if (V[0].y >= V[0].x) {
+ y0 = V[0].x << 4u;
+ y1 = V[0].y << 4u;
+ } else {
+ y0 = (V[0].y << 4u) + 8u;
+ y1 = (V[0].x << 4u) - 8u;
+ }
+ ep1 = uvec4(0x780u, y0, y0, y0);
+ ep2 = uvec4(0x780u, y1, y1, y1);
+ break;
+ }
+ case 3: {
+ READ_UINT_VALUES(2)
+ uint y0, d;
+ if ((V[0].x & 0x80u) != 0u) {
+ y0 = ((V[0].y & 0xE0u) << 4u) | ((V[0].x & 0x7Fu) << 2u);
+ d = (V[0].y & 0x1Fu) << 2u;
+ } else {
+ y0 = ((V[0].y & 0xF0u) << 4u) | ((V[0].x & 0x7Fu) << 1u);
+ d = (V[0].y & 0x0Fu) << 1u;
+ }
+ const uint y1 = min(y0 + d, 0xFFFu);
+ ep1 = uvec4(0x780u, y0, y0, y0);
+ ep2 = uvec4(0x780u, y1, y1, y1);
+ break;
+ }
+ case 7: {
+ READ_UINT_VALUES(4)
+ ivec3 e0, e1;
+ DecodeHDREndpointMode7(V[0].x, V[0].y, V[0].z, V[0].w, e0, e1);
+ ep1 = uvec4(0x780u, uint(e0.x), uint(e0.y), uint(e0.z));
+ ep2 = uvec4(0x780u, uint(e1.x), uint(e1.y), uint(e1.z));
+ break;
+ }
+ case 11: {
+ READ_UINT_VALUES(6)
+ ivec3 e0, e1;
+ DecodeHDREndpointMode11(V[0].x, V[0].y, V[0].z, V[0].w, V[1].x, V[1].y, e0, e1);
+ ep1 = uvec4(0x780u, uint(e0.x), uint(e0.y), uint(e0.z));
+ ep2 = uvec4(0x780u, uint(e1.x), uint(e1.y), uint(e1.z));
+ break;
+ }
+ case 14: {
+ READ_UINT_VALUES(8)
+ ivec3 e0, e1;
+ DecodeHDREndpointMode11(V[0].x, V[0].y, V[0].z, V[0].w, V[1].x, V[1].y, e0, e1);
+ ep1 = uvec4(V[1].z, uint(e0.x), uint(e0.y), uint(e0.z));
+ ep2 = uvec4(V[1].w, uint(e1.x), uint(e1.y), uint(e1.z));
+ break;
+ }
+ case 15: {
+ READ_UINT_VALUES(8)
+ ivec3 e0, e1;
+ DecodeHDREndpointMode11(V[0].x, V[0].y, V[0].z, V[0].w, V[1].x, V[1].y, e0, e1);
+ const uint mode = ((V[1].z >> 7u) & 1u) | ((V[1].w >> 6u) & 2u);
+ int a6 = int(V[1].z & 0x7Fu);
+ int a7 = int(V[1].w & 0x7Fu);
+ int alpha0, alpha1;
+ if (mode == 3u) {
+ alpha0 = a6 << 5;
+ alpha1 = a7 << 5;
+ } else {
+ a6 |= (a7 << int(mode + 1u)) & 0x780;
+ a7 &= int(0x3Fu >> mode);
+ a7 ^= int(0x20u >> mode);
+ a7 -= int(0x20u >> mode);
+ a6 <<= int(4u - mode);
+ a7 <<= int(4u - mode);
+ a7 += a6;
+ alpha0 = a6;
+ alpha1 = clamp(a7, 0, 0xFFF);
+ }
+ ep1 = uvec4(uint(alpha0), uint(e0.x), uint(e0.y), uint(e0.z));
+ ep2 = uvec4(uint(alpha1), uint(e1.x), uint(e1.y), uint(e1.z));
+ break;
+ }
default: {
- // HDR mode, or more likely a bug computing the color_endpoint_mode
ep1 = uvec4(0xFF, 0xFF, 0, 0);
ep2 = uvec4(0xFF, 0xFF, 0, 0);
break;
@@ -1112,13 +1349,46 @@ void DecompressBlock(ivec3 coord) {
if (num_partitions > 1) {
local_partition = Select2DPartition(partition_index, i, j, num_partitions);
}
- const uvec4 C0 = ReplicateByteTo16(endpoints0[local_partition]);
- const uvec4 C1 = ReplicateByteTo16(endpoints1[local_partition]);
+ const uint local_cem = color_endpoint_mode[local_partition];
const uvec4 weight_vec = GetUnquantizedWeightVector(j, i, size_params, plane_index, dual_plane);
- const vec4 Cf =
- vec4((C0 * (uvec4(64) - weight_vec) + C1 * weight_vec + uvec4(32)) / 64);
- const vec4 p = (Cf / 65535.0f);
+
+ vec4 p;
+ if (IsHDRColorEndpointMode(local_cem)) {
+ const uvec4 C0 = endpoints0[local_partition] << 4u;
+ const uvec4 C1 = endpoints1[local_partition] << 4u;
+ const uvec4 C = (C0 * (uvec4(64) - weight_vec) + C1 * weight_vec + uvec4(32)) / 64u;
+ const uvec4 E = (C & uvec4(0xF800u)) >> 11u;
+ const uvec4 M = C & uvec4(0x7FFu);
+ const uvec4 Mt_lo = 3u * M;
+ const uvec4 Mt_mid = 4u * M - 512u;
+ const uvec4 Mt_hi = 5u * M - 2048u;
+ const uvec4 Mt =
+ mix(Mt_lo, mix(Mt_mid, Mt_hi, greaterThanEqual(M, uvec4(1536u))),
+ greaterThanEqual(M, uvec4(512u)));
+ const uvec4 Cf = (E << 10u) + (Mt >> 3u);
+ const uvec4 half_bits = mix(Cf, uvec4(0x7BFFu), greaterThanEqual(Cf, uvec4(0x7C00u)));
+ p = vec4(unpackHalf2x16(half_bits.x).x, unpackHalf2x16(half_bits.y).x,
+ unpackHalf2x16(half_bits.z).x, unpackHalf2x16(half_bits.w).x);
+
+ if (local_cem == 14u) {
+ const uint a0 = ReplicateByteTo16(uvec4(endpoints0[local_partition].x)).x;
+ const uint a1 = ReplicateByteTo16(uvec4(endpoints1[local_partition].x)).x;
+ const uint Ca = (a0 * (64u - weight_vec.x) + a1 * weight_vec.x + 32u) / 64u;
+ p.x = float(Ca) / 65535.0f;
+ }
+ } else {
+ const uvec4 C0 = ReplicateByteTo16(endpoints0[local_partition]);
+ const uvec4 C1 = ReplicateByteTo16(endpoints1[local_partition]);
+ const vec4 Cf =
+ vec4((C0 * (uvec4(64) - weight_vec) + C1 * weight_vec + uvec4(32)) / 64);
+ p = Cf / 65535.0f;
+ }
+
+#ifdef VULKAN
imageStore(dest_image, coord + ivec3(i, j, 0), p.gbar);
+#else
+ imageStore(dest_image, coord + ivec3(i, j, 0), clamp(p, 0.0f, 1.0f).gbar);
+#endif
}
}
}
diff --git a/src/video_core/renderer_vulkan/vk_compute_pass.cpp b/src/video_core/renderer_vulkan/vk_compute_pass.cpp
index 0011ec3bf5..f361c34f44 100644
--- a/src/video_core/renderer_vulkan/vk_compute_pass.cpp
+++ b/src/video_core/renderer_vulkan/vk_compute_pass.cpp
@@ -26,6 +26,7 @@
#include "video_core/host_shaders/vulkan_uint8_comp_spv.h"
#include "video_core/host_shaders/block_linear_unswizzle_3d_bcn_comp_spv.h"
#include "video_core/renderer_vulkan/vk_compute_pass.h"
+#include "video_core/surface.h"
#include "video_core/renderer_vulkan/vk_descriptor_pool.h"
#include "video_core/renderer_vulkan/vk_scheduler.h"
#include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
index 6307f8b93e..ac4bc29905 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -6,6 +6,7 @@
#include <algorithm>
#include <array>
+#include <optional>
#include <span>
#include <memory>
#include <vector>
@@ -128,9 +129,32 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
return usage;
}
-[[nodiscard]] VkImageCreateInfo MakeImageCreateInfo(const Device& device, const ImageInfo& info) {
- const auto format_info =
+[[nodiscard]] bool WillUseAcceleratedAstcDecode(const Device& device, const ImageInfo& info) {
+ if (!IsPixelFormatASTC(info.format) || device.IsOptimalAstcSupported()) {
+ return false;
+ }
+ if (Settings::values.accelerate_astc.GetValue() != Settings::AstcDecodeMode::Gpu) {
+ return false;
+ }
+ return Settings::values.astc_recompression.GetValue() ==
+ Settings::AstcRecompression::Uncompressed &&
+ info.size.depth == 1;
+}
+
+[[nodiscard]] bool WillUseWidenedAstcFormat(const Device& device, const ImageInfo& info) {
+ return WillUseAcceleratedAstcDecode(device, info) &&
+ !VideoCore::Surface::IsPixelFormatSRGB(info.format);
+}
+
+[[nodiscard]] VkImageCreateInfo MakeImageCreateInfo(const Device& device, const ImageInfo& info,
+ std::optional<VkFormat> format_override = {}) {
+ auto format_info =
MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, false, info.format);
+ if (format_override) {
+ format_info.format = *format_override;
+ format_info.attachable = false;
+ format_info.storage = true;
+ }
VkImageCreateFlags flags{};
if (info.type == ImageType::e2D && info.resources.layers >= 6 &&
info.size.width == info.size.height && !device.HasBrokenCubeImageCompatibility()) {
@@ -164,11 +188,12 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
}
[[nodiscard]] vk::Image MakeImage(const Device& device, const MemoryAllocator& allocator,
- const ImageInfo& info, std::span<const VkFormat> view_formats) {
+ const ImageInfo& info, std::span<const VkFormat> view_formats,
+ std::optional<VkFormat> format_override = {}) {
if (info.type == ImageType::Buffer) {
return vk::Image{};
}
- VkImageCreateInfo image_ci = MakeImageCreateInfo(device, info);
+ VkImageCreateInfo image_ci = MakeImageCreateInfo(device, info, format_override);
const VkImageFormatListCreateInfo image_format_list = {
.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO,
.pNext = nullptr,
@@ -1557,15 +1582,19 @@ void TextureCacheRuntime::TickFrame() {}
Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu_addr_,
VAddr cpu_addr_)
: VideoCommon::ImageBase(info_, gpu_addr_, cpu_addr_), scheduler{&runtime_.scheduler},
- runtime{&runtime_}, original_image(MakeImage(runtime_.device, runtime_.memory_allocator, info,
- runtime->ViewFormats(info.format))),
+ runtime{&runtime_},
+ original_image(MakeImage(runtime_.device, runtime_.memory_allocator, info,
+ WillUseWidenedAstcFormat(runtime_.device, info)
+ ? std::span<const VkFormat>{}
+ : runtime->ViewFormats(info.format),
+ WillUseWidenedAstcFormat(runtime_.device, info)
+ ? std::make_optional(VK_FORMAT_R32G32B32A32_SFLOAT)
+ : std::nullopt)),
aspect_mask(ImageAspectMask(info.format)) {
if (IsPixelFormatASTC(info.format) && !runtime->device.IsOptimalAstcSupported()) {
switch (Settings::values.accelerate_astc.GetValue()) {
case Settings::AstcDecodeMode::Gpu:
- if (Settings::values.astc_recompression.GetValue() ==
- Settings::AstcRecompression::Uncompressed &&
- info.size.depth == 1) {
+ if (WillUseAcceleratedAstcDecode(runtime->device, info)) {
flags |= VideoCommon::ImageFlagBits::AcceleratedUpload;
}
break;
@@ -1591,9 +1620,12 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
Settings::values.astc_recompression.GetValue() ==
Settings::AstcRecompression::Uncompressed) {
const auto& device = runtime->device.GetLogical();
+ const VkFormat storage_format = WillUseWidenedAstcFormat(runtime->device, info)
+ ? VK_FORMAT_R32G32B32A32_SFLOAT
+ : VK_FORMAT_A8B8G8R8_UNORM_PACK32;
for (s32 level = 0; level < info.resources.levels; ++level) {
storage_image_views[level] =
- MakeStorageView(device, level, *original_image, VK_FORMAT_A8B8G8R8_UNORM_PACK32);
+ MakeStorageView(device, level, *original_image, storage_format);
}
}
}
@@ -1942,8 +1974,13 @@ void Image::DownloadMemory(const StagingBufferRef& map, std::span<const BufferIm
VkImageView Image::StorageImageView(s32 level) noexcept {
auto& view = storage_image_views[level];
if (!view) {
- const auto format_info =
+ auto format_info =
MaxwellToVK::SurfaceFormat(runtime->device, FormatType::Optimal, true, info.format);
+ if (WillUseAcceleratedAstcDecode(runtime->device, info)) {
+ format_info.format = WillUseWidenedAstcFormat(runtime->device, info)
+ ? VK_FORMAT_R32G32B32A32_SFLOAT
+ : VK_FORMAT_A8B8G8R8_UNORM_PACK32;
+ }
view = MakeStorageView(runtime->device.GetLogical(), level, *(this->*current_image),
format_info.format);
}
@@ -2110,7 +2147,11 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
SanitizeDepthStencilSwizzle(swizzle, device->SupportsDepthStencilSwizzleOne());
}
}
- const auto format_info = MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
+ uses_widened_astc_format = WillUseWidenedAstcFormat(*device, image.info);
+ auto format_info = MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
+ if (uses_widened_astc_format) {
+ format_info.format = VK_FORMAT_R32G32B32A32_SFLOAT;
+ }
const VkImageUsageFlags requested_view_usage = ImageUsageFlags(format_info, format);
const VkImageUsageFlags image_usage = image.UsageFlags();
const VkImageUsageFlags clamped_view_usage = requested_view_usage & image_usage;
@@ -2245,8 +2286,10 @@ VkImageView ImageView::StorageView(Shader::TextureType texture_type,
if (image_handle) {
if (image_format == Shader::ImageFormat::Typeless) {
if (!typeless_storage_view) {
- const auto& info =
- MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
+ auto info = MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
+ if (uses_widened_astc_format) {
+ info.format = VK_FORMAT_R32G32B32A32_SFLOAT;
+ }
typeless_storage_view = MakeView(info.format, VK_IMAGE_ASPECT_COLOR_BIT);
}
return *typeless_storage_view;
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.h
index 005ab94762..027143fdbc 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.h
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h
@@ -386,6 +386,8 @@ private:
VkImageView render_target = VK_NULL_HANDLE;
VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
u32 buffer_size = 0;
+
+ bool uses_widened_astc_format = false;
};
class ImageAlloc : public VideoCommon::ImageAllocBase {};
diff --git a/src/video_core/textures/astc.cpp b/src/video_core/textures/astc.cpp
index b7b5f5bd4a..5f8fe3dfdf 100644
--- a/src/video_core/textures/astc.cpp
+++ b/src/video_core/textures/astc.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: 2016 The University of North Carolina at Chapel Hill
@@ -1269,6 +1269,209 @@ static inline u32 Select2DPartition(s32 seed, s32 x, s32 y, s32 partitionCount,
return SelectPartition(seed, x, y, 0, partitionCount, smallBlock);
}
+static constexpr bool IsHDRColorEndpointMode(u32 cem) {
+ switch (cem) {
+ case 2:
+ case 3:
+ case 7:
+ case 11:
+ case 14:
+ case 15:
+ return true;
+ default:
+ return false;
+ }
+}
+
+static constexpr s32 SignExtend(s32 value, u32 nbits) {
+ const s32 sign_bit = 1 << (nbits - 1);
+ return (value ^ sign_bit) - sign_bit;
+}
+
+struct HDREndpointRGB {
+ s32 r0, g0, b0;
+ s32 r1, g1, b1;
+};
+
+static void DecodeHDREndpointMode7(u32 v0, u32 v1, u32 v2, u32 v3, s32& r0, s32& g0, s32& b0,
+ s32& r1, s32& g1, s32& b1) {
+ const u32 modeval = ((v0 & 0xC0) >> 6) | ((v1 & 0x80) >> 5) | ((v2 & 0x80) >> 4);
+
+ u32 majcomp;
+ u32 mode;
+ if ((modeval & 0xC) != 0xC) {
+ majcomp = modeval >> 2;
+ mode = modeval & 3;
+ } else if (modeval != 0xF) {
+ majcomp = modeval & 3;
+ mode = 4;
+ } else {
+ majcomp = 0;
+ mode = 5;
+ }
+
+ s32 red = static_cast<s32>(v0 & 0x3f);
+ s32 green = static_cast<s32>(v1 & 0x1f);
+ s32 blue = static_cast<s32>(v2 & 0x1f);
+ s32 scale = static_cast<s32>(v3 & 0x1f);
+
+ const u32 x0 = (v1 >> 6) & 1;
+ const u32 x1 = (v1 >> 5) & 1;
+ const u32 x2 = (v2 >> 6) & 1;
+ const u32 x3 = (v2 >> 5) & 1;
+ const u32 x4 = (v3 >> 7) & 1;
+ const u32 x5 = (v3 >> 6) & 1;
+ const u32 x6 = (v3 >> 5) & 1;
+
+ const u32 ohm = 1u << mode;
+ if (ohm & 0x30)
+ green |= static_cast<s32>(x0 << 6);
+ if (ohm & 0x3A)
+ green |= static_cast<s32>(x1 << 5);
+ if (ohm & 0x30)
+ blue |= static_cast<s32>(x2 << 6);
+ if (ohm & 0x3A)
+ blue |= static_cast<s32>(x3 << 5);
+ if (ohm & 0x3D)
+ scale |= static_cast<s32>(x6 << 5);
+ if (ohm & 0x2D)
+ scale |= static_cast<s32>(x5 << 6);
+ if (ohm & 0x04)
+ scale |= static_cast<s32>(x4 << 7);
+ if (ohm & 0x3B)
+ red |= static_cast<s32>(x4 << 6);
+ if (ohm & 0x04)
+ red |= static_cast<s32>(x3 << 6);
+ if (ohm & 0x10)
+ red |= static_cast<s32>(x5 << 7);
+ if (ohm & 0x0F)
+ red |= static_cast<s32>(x2 << 7);
+ if (ohm & 0x05)
+ red |= static_cast<s32>(x1 << 8);
+ if (ohm & 0x0A)
+ red |= static_cast<s32>(x0 << 8);
+ if (ohm & 0x05)
+ red |= static_cast<s32>(x0 << 9);
+ if (ohm & 0x02)
+ red |= static_cast<s32>(x6 << 9);
+ if (ohm & 0x01)
+ red |= static_cast<s32>(x3 << 10);
+ if (ohm & 0x02)
+ red |= static_cast<s32>(x5 << 10);
+
+ static constexpr int shamts[6] = {1, 1, 2, 3, 4, 5};
+ const s32 shamt = shamts[mode];
+ red <<= shamt;
+ green <<= shamt;
+ blue <<= shamt;
+ scale <<= shamt;
+
+ if (mode != 5) {
+ green = red - green;
+ blue = red - blue;
+ }
+
+ if (majcomp == 1)
+ std::swap(red, green);
+ if (majcomp == 2)
+ std::swap(red, blue);
+
+ r1 = std::clamp(red, 0, 0xFFF);
+ g1 = std::clamp(green, 0, 0xFFF);
+ b1 = std::clamp(blue, 0, 0xFFF);
+
+ r0 = std::clamp(red - scale, 0, 0xFFF);
+ g0 = std::clamp(green - scale, 0, 0xFFF);
+ b0 = std::clamp(blue - scale, 0, 0xFFF);
+}
+
+static HDREndpointRGB DecodeHDREndpointMode11(u32 v0, u32 v1, u32 v2, u32 v3, u32 v4, u32 v5) {
+ const u32 majcomp = ((v4 & 0x80) >> 7) | ((v5 & 0x80) >> 6);
+ if (majcomp == 3) {
+ HDREndpointRGB result;
+ result.r0 = static_cast<s32>(v0 << 4);
+ result.g0 = static_cast<s32>(v2 << 4);
+ result.b0 = static_cast<s32>((v4 & 0x7f) << 5);
+ result.r1 = static_cast<s32>(v1 << 4);
+ result.g1 = static_cast<s32>(v3 << 4);
+ result.b1 = static_cast<s32>((v5 & 0x7f) << 5);
+ return result;
+ }
+
+ const u32 mode = ((v1 & 0x80) >> 7) | ((v2 & 0x80) >> 6) | ((v3 & 0x80) >> 5);
+ s32 va = static_cast<s32>(v0 | ((v1 & 0x40) << 2));
+ s32 vb0 = static_cast<s32>(v2 & 0x3f);
+ s32 vb1 = static_cast<s32>(v3 & 0x3f);
+ s32 vc = static_cast<s32>(v1 & 0x3f);
+ s32 vd0 = static_cast<s32>(v4 & 0x7f);
+ s32 vd1 = static_cast<s32>(v5 & 0x7f);
+
+ static constexpr int dbitstab[8] = {7, 6, 7, 6, 5, 6, 5, 6};
+ vd0 = SignExtend(vd0, dbitstab[mode]);
+ vd1 = SignExtend(vd1, dbitstab[mode]);
+
+ const u32 x0 = (v2 >> 6) & 1;
+ const u32 x1 = (v3 >> 6) & 1;
+ const u32 x2 = (v4 >> 6) & 1;
+ const u32 x3 = (v5 >> 6) & 1;
+ const u32 x4 = (v4 >> 5) & 1;
+ const u32 x5 = (v5 >> 5) & 1;
+
+ const u32 ohm = 1u << mode;
+ if (ohm & 0xA4)
+ va |= static_cast<s32>(x0 << 9);
+ if (ohm & 0x08)
+ va |= static_cast<s32>(x2 << 9);
+ if (ohm & 0x50)
+ va |= static_cast<s32>(x4 << 9);
+ if (ohm & 0x50)
+ va |= static_cast<s32>(x5 << 10);
+ if (ohm & 0xA0)
+ va |= static_cast<s32>(x1 << 10);
+ if (ohm & 0xC0)
+ va |= static_cast<s32>(x2 << 11);
+ if (ohm & 0x04)
+ vc |= static_cast<s32>(x1 << 6);
+ if (ohm & 0xE8)
+ vc |= static_cast<s32>(x3 << 6);
+ if (ohm & 0x20)
+ vc |= static_cast<s32>(x2 << 7);
+ if (ohm & 0x5B)
+ vb0 |= static_cast<s32>(x0 << 6);
+ if (ohm & 0x5B)
+ vb1 |= static_cast<s32>(x1 << 6);
+ if (ohm & 0x12)
+ vb0 |= static_cast<s32>(x2 << 7);
+ if (ohm & 0x12)
+ vb1 |= static_cast<s32>(x3 << 7);
+
+ const s32 shamt = (static_cast<s32>(mode) >> 1) ^ 3;
+ va <<= shamt;
+ vb0 <<= shamt;
+ vb1 <<= shamt;
+ vc <<= shamt;
+ vd0 <<= shamt;
+ vd1 <<= shamt;
+
+ HDREndpointRGB result;
+ result.r1 = std::clamp(va, 0, 0xFFF);
+ result.g1 = std::clamp(va - vb0, 0, 0xFFF);
+ result.b1 = std::clamp(va - vb1, 0, 0xFFF);
+
+ result.r0 = std::clamp(va - vc, 0, 0xFFF);
+ result.g0 = std::clamp(va - vb0 - vc - vd0, 0, 0xFFF);
+ result.b0 = std::clamp(va - vb1 - vc - vd1, 0, 0xFFF);
+
+ if (majcomp == 1) {
+ std::swap(result.r0, result.g0);
+ std::swap(result.r1, result.g1);
+ } else if (majcomp == 2) {
+ std::swap(result.r0, result.b0);
+ std::swap(result.r1, result.b1);
+ }
+ return result;
+}
+
// Section C.2.14
static void ComputeEndpoints(Pixel& ep1, Pixel& ep2, const u32*& colorValues,
u32 colorEndpointMode) {
@@ -1382,8 +1585,84 @@ static void ComputeEndpoints(Pixel& ep1, Pixel& ep2, const u32*& colorValues,
ep2.ClampByte();
} break;
+ case 2: {
+ READ_UINT_VALUES(2)
+ u32 y0, y1;
+ if (v[1] >= v[0]) {
+ y0 = v[0] << 4;
+ y1 = v[1] << 4;
+ } else {
+ y0 = (v[1] << 4) + 8;
+ y1 = (v[0] << 4) - 8;
+ }
+ ep1 = Pixel(0x780, y0, y0, y0);
+ ep2 = Pixel(0x780, y1, y1, y1);
+ } break;
+
+ case 3: {
+ READ_UINT_VALUES(2)
+ u32 y0, d;
+ if (v[0] & 0x80) {
+ y0 = ((v[1] & 0xE0) << 4) | ((v[0] & 0x7F) << 2);
+ d = (v[1] & 0x1F) << 2;
+ } else {
+ y0 = ((v[1] & 0xF0) << 4) | ((v[0] & 0x7F) << 1);
+ d = (v[1] & 0x0F) << 1;
+ }
+ const u32 y1 = (std::min)(y0 + d, 0xFFFU);
+ ep1 = Pixel(0x780, y0, y0, y0);
+ ep2 = Pixel(0x780, y1, y1, y1);
+ } break;
+
+ case 7: {
+ READ_UINT_VALUES(4)
+ s32 r0, g0, b0, r1, g1, b1;
+ DecodeHDREndpointMode7(v[0], v[1], v[2], v[3], r0, g0, b0, r1, g1, b1);
+ ep1 = Pixel(0x780, r0, g0, b0);
+ ep2 = Pixel(0x780, r1, g1, b1);
+ } break;
+
+ case 11: {
+ READ_UINT_VALUES(6)
+ const HDREndpointRGB rgb = DecodeHDREndpointMode11(v[0], v[1], v[2], v[3], v[4], v[5]);
+ ep1 = Pixel(0x780, rgb.r0, rgb.g0, rgb.b0);
+ ep2 = Pixel(0x780, rgb.r1, rgb.g1, rgb.b1);
+ } break;
+
+ case 14: {
+ READ_UINT_VALUES(8)
+ const HDREndpointRGB rgb = DecodeHDREndpointMode11(v[0], v[1], v[2], v[3], v[4], v[5]);
+ ep1 = Pixel(v[6], rgb.r0, rgb.g0, rgb.b0);
+ ep2 = Pixel(v[7], rgb.r1, rgb.g1, rgb.b1);
+ } break;
+
+ case 15: {
+ READ_UINT_VALUES(8)
+ const HDREndpointRGB rgb = DecodeHDREndpointMode11(v[0], v[1], v[2], v[3], v[4], v[5]);
+ const u32 mode = ((v[6] >> 7) & 1) | ((v[7] >> 6) & 2);
+ s32 a6 = static_cast<s32>(v[6] & 0x7F);
+ s32 a7 = static_cast<s32>(v[7] & 0x7F);
+ s32 alpha0, alpha1;
+ if (mode == 3) {
+ alpha0 = a6 << 5;
+ alpha1 = a7 << 5;
+ } else {
+ a6 |= (a7 << (mode + 1)) & 0x780;
+ a7 &= (0x3F >> mode);
+ a7 ^= 0x20 >> mode;
+ a7 -= 0x20 >> mode;
+ a6 <<= (4 - mode);
+ a7 <<= (4 - mode);
+ a7 += a6;
+ alpha0 = a6;
+ alpha1 = std::clamp(a7, 0, 0xFFF);
+ }
+ ep1 = Pixel(alpha0, rgb.r0, rgb.g0, rgb.b0);
+ ep2 = Pixel(alpha1, rgb.r1, rgb.g1, rgb.b1);
+ } break;
+
default:
- assert(false && "Unsupported color endpoint mode (is it HDR?)");
+ assert(false && "Unsupported color endpoint mode");
break;
}
@@ -1414,6 +1693,39 @@ static void FillVoidExtentLDR(InputBitStream& strm, std::span<u32> outBuf, u32 b
}
}
+static float HalfToFloat(u16 h) {
+ const u32 sign = static_cast<u32>(h & 0x8000) << 16;
+ u32 exp = (h & 0x7C00) >> 10;
+ u32 mant = h & 0x3FF;
+ u32 bits;
+ if (exp == 0) {
+ if (mant == 0) {
+ bits = sign;
+ } else {
+ s32 e = 127 - 15 + 1;
+ while ((mant & 0x400) == 0) {
+ mant <<= 1;
+ --e;
+ }
+ mant &= 0x3FF;
+ bits = sign | (static_cast<u32>(e) << 23) | (mant << 13);
+ }
+ } else if (exp == 0x1F) {
+ bits = sign | 0x7F800000 | (mant << 13);
+ } else {
+ bits = sign | ((exp - 15 + 127) << 23) | (mant << 13);
+ }
+ float result;
+ std::memcpy(&result, &bits, sizeof(result));
+ return result;
+}
+
+static u16 HalfToClampedByte(u16 half_bits) {
+ const float value = HalfToFloat(half_bits);
+ const float clamped = std::clamp(value, 0.0f, 1.0f);
+ return static_cast<u16>(clamped * 255.0f + 0.5f);
+}
+
static void FillError(std::span<u32> outBuf, u32 blockWidth, u32 blockHeight) {
for (u32 j = 0; j < blockHeight; j++) {
for (u32 i = 0; i < blockWidth; i++) {
@@ -1631,22 +1943,44 @@ static void DecompressBlock(std::span<const u8, 16> inBuf, const u32 blockWidth,
Pixel p;
for (u32 c = 0; c < 4; c++) {
u32 C0 = endpoints[partition][0].Component(c);
- C0 = ReplicateByteTo16(C0);
u32 C1 = endpoints[partition][1].Component(c);
- C1 = ReplicateByteTo16(C1);
u32 plane = 0;
if (weightParams.m_bDualPlane && (((planeIdx + 1) & 3) == c)) {
plane = 1;
}
-
u32 weight = weights[plane][j * blockWidth + i];
- u32 C = (C0 * (64 - weight) + C1 * weight + 32) / 64;
- if (C == 65535) {
- p.Component(c) = 255;
+
+ const bool is_hdr = IsHDRColorEndpointMode(colorEndpointMode[partition]) &&
+ !(colorEndpointMode[partition] == 14 && c == 0);
+
+ if (is_hdr) {
+ C0 <<= 4;
+ C1 <<= 4;
+ const u32 C = (C0 * (64 - weight) + C1 * weight + 32) / 64;
+ const u32 E = (C & 0xF800) >> 11;
+ const u32 M = C & 0x7FF;
+ u32 Mt;
+ if (M < 512) {
+ Mt = 3 * M;
+ } else if (M >= 1536) {
+ Mt = 5 * M - 2048;
+ } else {
+ Mt = 4 * M - 512;
+ }
+ const u32 Cf = (E << 10) + (Mt >> 3);
+ const u16 half_bits = (Cf >= 0x7C00) ? u16{0x7BFF} : static_cast<u16>(Cf);
+ p.Component(c) = HalfToClampedByte(half_bits);
} else {
- double Cf = static_cast<double>(C);
- p.Component(c) = static_cast<u16>(255.0 * (Cf / 65536.0) + 0.5);
+ C0 = ReplicateByteTo16(C0);
+ C1 = ReplicateByteTo16(C1);
+ const u32 C = (C0 * (64 - weight) + C1 * weight + 32) / 64;
+ if (C == 65535) {
+ p.Component(c) = 255;
+ } else {
+ double Cf = static_cast<double>(C);
+ p.Component(c) = static_cast<u16>(255.0 * (Cf / 65536.0) + 0.5);
+ }
}
}
diff --git a/src/video_core/vulkan_common/vulkan_device.h b/src/video_core/vulkan_common/vulkan_device.h
index cf039768fd..a98717bc3e 100644
--- a/src/video_core/vulkan_common/vulkan_device.h
+++ b/src/video_core/vulkan_common/vulkan_device.h
@@ -72,7 +72,9 @@ VK_DEFINE_HANDLE(VmaAllocator)
FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES, \
pipeline_executable_properties) \
FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT, \
- workgroup_memory_explicit_layout)
+ workgroup_memory_explicit_layout) \
+ FEATURE(EXT, TextureCompressionASTCHDR, TEXTURE_COMPRESSION_ASTC_HDR, \
+ texture_compression_astc_hdr)
// Define miscellaneous extensions which may be used by the implementation here.
@@ -348,9 +350,9 @@ FN_MAX_LIMIT_LIST
return properties.float_controls;
}
- /// Returns true if ASTC is natively supported.
bool IsOptimalAstcSupported() const {
- return features.features.textureCompressionASTC_LDR;
+ return features.features.textureCompressionASTC_LDR &&
+ features.texture_compression_astc_hdr.textureCompressionASTC_HDR;
}
/// Returns true if BCn is natively supported.