camerin
/
eden
mirror of https://git.eden-emu.dev/eden-emu/eden.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[spv, vk] reworked texture view handling and added layer count overrides

This commit is contained in:
CamilleLaVey 2025-11-29 01:29:41 -04:00 committed by Caio Oliveira
parent 93f4cccb76
commit 7b78b2dd1f
No known key found for this signature in database
GPG Key ID: AAAE6C7FD4186B0C
3 changed files with 99 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/shader_recompiler/backend/spirv/emit_spirv_image.cpp
View File

@ -221,7 +221,12 @@ Id TextureSampleResultToFloat(EmitContext& ctx, const TextureDefinition& def, Id
case SamplerComponentType::Sint:
return ctx.OpConvertSToF(ctx.F32[4], color);
case SamplerComponentType::Stencil:
return ctx.OpConvertUToF(ctx.F32[4], color);
{
const Id converted{ctx.OpConvertUToF(ctx.F32[4], color)};
const Id inv255{ctx.Const(1.0f / 255.0f)};
const Id scale{ctx.ConstantComposite(ctx.F32[4], inv255, inv255, inv255, inv255)};
return ctx.OpFMul(ctx.F32[4], converted, scale);
}
case SamplerComponentType::Uint:
return ctx.OpConvertUToF(ctx.F32[4], color);
}

107
src/video_core/renderer_vulkan/vk_texture_cache.cpp
View File

@ -2113,11 +2113,11 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
},
.subresourceRange = MakeSubresourceRange(aspect_mask, info.range),
};
const auto create = [&](TextureType tex_type, std::optional<u32> num_layers) {
const auto create = [&](TextureType tex_type) {
VkImageViewCreateInfo ci{create_info};
ci.viewType = ImageViewType(tex_type);
if (num_layers) {
ci.subresourceRange.layerCount = *num_layers;
if (const auto override_layers = LayerCountOverride(tex_type)) {
ci.subresourceRange.layerCount = *override_layers;
}
vk::ImageView handle = device->GetLogical().CreateImageView(ci);
if (device->HasDebuggingToolAttached()) {
@ -2128,25 +2128,29 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
switch (info.type) {
case VideoCommon::ImageViewType::e1D:
case VideoCommon::ImageViewType::e1DArray:
create(TextureType::Color1D, 1);
create(TextureType::ColorArray1D, std::nullopt);
create(TextureType::Color1D);
create(TextureType::ColorArray1D);
render_target = Handle(TextureType::ColorArray1D);
break;
case VideoCommon::ImageViewType::e2D:
case VideoCommon::ImageViewType::e2DArray:
create(TextureType::Color2D);
create(TextureType::ColorArray2D);
render_target = Handle(Shader::TextureType::ColorArray2D);
break;
case VideoCommon::ImageViewType::Rect:
create(TextureType::Color2D, 1);
create(TextureType::ColorArray2D, std::nullopt);
create(TextureType::Color2DRect);
create(TextureType::ColorArray2D);
render_target = Handle(Shader::TextureType::ColorArray2D);
break;
case VideoCommon::ImageViewType::e3D:
create(TextureType::Color3D, std::nullopt);
create(TextureType::Color3D);
render_target = Handle(Shader::TextureType::Color3D);
break;
case VideoCommon::ImageViewType::Cube:
case VideoCommon::ImageViewType::CubeArray:
create(TextureType::ColorCube, 6);
create(TextureType::ColorArrayCube, std::nullopt);
create(TextureType::ColorCube);
create(TextureType::ColorArrayCube);
break;
case VideoCommon::ImageViewType::Buffer:
ASSERT(false);
@ -2184,28 +2188,76 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::NullImageV
ImageView::~ImageView() = default;
Shader::TextureType ImageView::BaseTextureType() const noexcept {
using VideoCommon::ImageViewType;
switch (type) {
case ImageViewType::e1D:
return Shader::TextureType::Color1D;
case ImageViewType::e1DArray:
return Shader::TextureType::ColorArray1D;
case ImageViewType::e2D:
return Shader::TextureType::Color2D;
case ImageViewType::e2DArray:
return Shader::TextureType::ColorArray2D;
case ImageViewType::Rect:
return Shader::TextureType::Color2DRect;
case ImageViewType::e3D:
return Shader::TextureType::Color3D;
case ImageViewType::Cube:
return Shader::TextureType::ColorCube;
case ImageViewType::CubeArray:
return Shader::TextureType::ColorArrayCube;
case ImageViewType::Buffer:
break;
}
return Shader::TextureType::Color2D;
}
std::optional<u32> ImageView::LayerCountOverride(Shader::TextureType texture_type) const noexcept {
switch (texture_type) {
case Shader::TextureType::Color1D:
case Shader::TextureType::Color2D:
case Shader::TextureType::Color2DRect:
return 1u;
case Shader::TextureType::ColorCube:
return 6u;
default:
return std::nullopt;
}
}
VkImageView ImageView::DepthView() {
return DepthView(BaseTextureType());
}
VkImageView ImageView::DepthView(Shader::TextureType texture_type) {
if (!image_handle) {
return VK_NULL_HANDLE;
}
if (depth_view) {
return *depth_view;
auto& view = depth_views[static_cast<size_t>(texture_type)];
if (view) {
return *view;
}
const auto& info = MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
depth_view = MakeView(info.format, VK_IMAGE_ASPECT_DEPTH_BIT);
return *depth_view;
view = MakeView(info.format, VK_IMAGE_ASPECT_DEPTH_BIT, texture_type);
return *view;
}
VkImageView ImageView::StencilView() {
return StencilView(BaseTextureType());
}
VkImageView ImageView::StencilView(Shader::TextureType texture_type) {
if (!image_handle) {
return VK_NULL_HANDLE;
}
if (stencil_view) {
return *stencil_view;
auto& view = stencil_views[static_cast<size_t>(texture_type)];
if (view) {
return *view;
}
const auto& info = MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
stencil_view = MakeView(info.format, VK_IMAGE_ASPECT_STENCIL_BIT);
return *stencil_view;
view = MakeView(info.format, VK_IMAGE_ASPECT_STENCIL_BIT, texture_type);
return *view;
}
VkImageView ImageView::ColorView() {
@ -2228,12 +2280,12 @@ VkImageView ImageView::SampledView(Shader::TextureType texture_type,
switch (component_type) {
case Shader::SamplerComponentType::Depth:
if (surface_type == SurfaceType::Depth || surface_type == SurfaceType::DepthStencil) {
return DepthView();
return DepthView(texture_type);
}
break;
case Shader::SamplerComponentType::Stencil:
if (surface_type == SurfaceType::Stencil || surface_type == SurfaceType::DepthStencil) {
return StencilView();
return StencilView(texture_type);
}
break;
default:
@ -2274,12 +2326,17 @@ bool ImageView::IsRescaled() const noexcept {
}
vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_mask) {
return device->GetLogical().CreateImageView({
return MakeView(vk_format, aspect_mask, BaseTextureType());
}
vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_mask,
Shader::TextureType texture_type) {
VkImageViewCreateInfo ci{
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.image = image_handle,
.viewType = ImageViewType(type),
.viewType = ImageViewType(texture_type),
.format = vk_format,
.components{
.r = VK_COMPONENT_SWIZZLE_IDENTITY,
@ -2288,7 +2345,11 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_
.a = VK_COMPONENT_SWIZZLE_IDENTITY,
},
.subresourceRange = MakeSubresourceRange(aspect_mask, range),
});
};
if (const auto override_layers = LayerCountOverride(texture_type)) {
ci.subresourceRange.layerCount = *override_layers;
}
return device->GetLogical().CreateImageView(ci);
}
Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& tsc) {

11
src/video_core/renderer_vulkan/vk_texture_cache.h
View File

@ -276,15 +276,22 @@ private:
std::array<vk::ImageView, Shader::NUM_TEXTURE_TYPES> unsigneds;
};
[[nodiscard]] Shader::TextureType BaseTextureType() const noexcept;
[[nodiscard]] std::optional<u32> LayerCountOverride(Shader::TextureType texture_type) const noexcept;
[[nodiscard]] VkImageView DepthView(Shader::TextureType texture_type);
[[nodiscard]] VkImageView StencilView(Shader::TextureType texture_type);
[[nodiscard]] vk::ImageView MakeView(VkFormat vk_format, VkImageAspectFlags aspect_mask);
[[nodiscard]] vk::ImageView MakeView(VkFormat vk_format, VkImageAspectFlags aspect_mask,
Shader::TextureType texture_type);
const Device* device = nullptr;
const SlotVector<Image>* slot_images = nullptr;
std::array<vk::ImageView, Shader::NUM_TEXTURE_TYPES> image_views;
std::unique_ptr<StorageViews> storage_views;
vk::ImageView depth_view;
vk::ImageView stencil_view;
std::array<vk::ImageView, Shader::NUM_TEXTURE_TYPES> depth_views;
std::array<vk::ImageView, Shader::NUM_TEXTURE_TYPES> stencil_views;
vk::ImageView color_view;
vk::Image null_image;
VkImage image_handle = VK_NULL_HANDLE;