eden-emu
/
eden
mirror of https://git.eden-emu.dev/eden-emu/eden.git
1
0
Fork 0
Code Releases Wiki Activity
Browse Source

Revert "[surface, vk, pipeline, texture_cache] Refactor image view handling and add normalized compatible format utility" 

This reverts commit 6a230bec1a.
true-eds
CamilleLaVey 4 weeks ago
committed by Caio Oliveira
parent
83323d7993
commit
a99c35d0ff
No known key found for this signature in database GPG Key ID: AAAE6C7FD4186B0C
5 changed files with 9 additions and 169 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/video_core/renderer_vulkan/pipeline_helper.h
  2. 85
      src/video_core/renderer_vulkan/vk_texture_cache.cpp
  3. 19
      src/video_core/renderer_vulkan/vk_texture_cache.h
  4. 68
      src/video_core/surface.cpp
  5. 4
      src/video_core/surface.h

2
src/video_core/renderer_vulkan/pipeline_helper.h
View File

@ -189,7 +189,7 @@ inline void PushImageDescriptors(TextureCache& texture_cache,
const VideoCommon::ImageViewId image_view_id{(views++)->id};
const VideoCommon::SamplerId sampler_id{*(samplers++)};
ImageView& image_view{texture_cache.GetImageView(image_view_id)};
const VkImageView vk_image_view{image_view.SampledHandle(desc.type, desc.is_integer)};
const VkImageView vk_image_view{image_view.Handle(desc.type)};
const Sampler& sampler{texture_cache.GetSampler(sampler_id)};
const bool use_fallback_sampler{sampler.HasAddedAnisotropy() &&
!image_view.SupportsAnisotropy()};

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

@ -45,8 +45,6 @@ using VideoCore::Surface::BytesPerBlock;
using VideoCore::Surface::HasAlpha;
using VideoCore::Surface::IsPixelFormatASTC;
using VideoCore::Surface::IsPixelFormatInteger;
using VideoCore::Surface::IntegerCompatibleFormat;
using VideoCore::Surface::NormalizedCompatibleFormat;
using VideoCore::Surface::SurfaceType;
namespace {
@ -2053,8 +2051,7 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
samples(ConvertSampleCount(image.info.num_samples)) {
using Shader::TextureType;
const VkImageAspectFlags aspect_mask_local = ImageViewAspectMask(info);
aspect_mask = aspect_mask_local;
const VkImageAspectFlags aspect_mask = ImageViewAspectMask(info);
std::array<SwizzleSource, 4> swizzle{
SwizzleSource::R,
SwizzleSource::G,
@ -2086,14 +2083,6 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
.pNext = nullptr,
.usage = view_usage,
};
view_usage_flags = view_usage;
const VkComponentMapping components{
.r = ComponentSwizzle(swizzle[0]),
.g = ComponentSwizzle(swizzle[1]),
.b = ComponentSwizzle(swizzle[2]),
.a = ComponentSwizzle(swizzle[3]),
};
component_mapping = components;
const VkImageViewCreateInfo create_info{
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.pNext = &image_view_usage,
@ -2101,8 +2090,13 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
.image = image.Handle(),
.viewType = VkImageViewType{},
.format = format_info.format,
.components = components,
.subresourceRange = MakeSubresourceRange(aspect_mask_local, info.range),
.components{
.r = ComponentSwizzle(swizzle[0]),
.g = ComponentSwizzle(swizzle[1]),
.b = ComponentSwizzle(swizzle[2]),
.a = ComponentSwizzle(swizzle[3]),
},
.subresourceRange = MakeSubresourceRange(aspect_mask, info.range),
};
const auto create = [&](TextureType tex_type, std::optional<u32> num_layers) {
VkImageViewCreateInfo ci{create_info};
@ -2115,7 +2109,6 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
handle.SetObjectNameEXT(VideoCommon::Name(*this, gpu_addr).c_str());
}
image_views[static_cast<size_t>(tex_type)] = std::move(handle);
view_layer_counts[static_cast<size_t>(tex_type)] = num_layers;
};
switch (info.type) {
case VideoCommon::ImageViewType::e1D:
@ -2169,8 +2162,6 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::NullImageV
null_image = MakeImage(*device, runtime.memory_allocator, info, {});
image_handle = *null_image;
aspect_mask = VK_IMAGE_ASPECT_COLOR_BIT;
view_usage_flags = VK_IMAGE_USAGE_SAMPLED_BIT;
for (u32 i = 0; i < Shader::NUM_TEXTURE_TYPES; i++) {
image_views[i] = MakeView(VK_FORMAT_A8B8G8R8_UNORM_PACK32, VK_IMAGE_ASPECT_COLOR_BIT);
}
@ -2235,42 +2226,6 @@ VkImageView ImageView::StorageView(Shader::TextureType texture_type,
return *view;
}
VkImageView ImageView::SampledHandle(Shader::TextureType texture_type, bool use_integer_view) {
const auto type_index = static_cast<size_t>(texture_type);
if (use_integer_view || !IsPixelFormatInteger(format)) {
if (!use_integer_view || IsPixelFormatInteger(format)) {
return Handle(texture_type);
}
const auto compatible_integer = IntegerCompatibleFormat(format);
if (!compatible_integer) {
return Handle(texture_type);
}
auto& int_view = sampled_integer_views[type_index];
if (int_view) {
return *int_view;
}
const auto format_info =
MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, *compatible_integer);
int_view = CreateSampledView(texture_type, format_info.format);
return *int_view;
}
const auto compatible_format = NormalizedCompatibleFormat(format);
if (!compatible_format) {
return Handle(texture_type);
}
auto& float_view = sampled_float_views[type_index];
if (float_view) {
return *float_view;
}
const auto format_info =
MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, *compatible_format);
float_view = CreateSampledView(texture_type, format_info.format);
return *float_view;
}
bool ImageView::IsRescaled() const noexcept {
if (!slot_images) {
return false;
@ -2298,30 +2253,6 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_
});
}
vk::ImageView ImageView::CreateSampledView(Shader::TextureType texture_type,
VkFormat vk_format) const {
const VkImageViewUsageCreateInfo usage_info{
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
.pNext = nullptr,
.usage = view_usage_flags,
};
VkImageViewCreateInfo create_info{
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.pNext = &usage_info,
.flags = 0,
.image = image_handle,
.viewType = ImageViewType(texture_type),
.format = vk_format,
.components = component_mapping,
.subresourceRange = MakeSubresourceRange(aspect_mask, range),
};
const auto idx = static_cast<size_t>(texture_type);
if (view_layer_counts[idx]) {
create_info.subresourceRange.layerCount = *view_layer_counts[idx];
}
return device->GetLogical().CreateImageView(create_info);
}
Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& tsc) {
const auto& device = runtime.device;
// Check if custom border colors are supported

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

@ -3,8 +3,6 @@
#pragma once
#include <array>
#include <optional>
#include <span>
#include "video_core/texture_cache/texture_cache_base.h"
@ -243,10 +241,6 @@ public:
[[nodiscard]] VkImageView Handle(Shader::TextureType texture_type) const noexcept {
return *image_views[static_cast<size_t>(texture_type)];
}
[[nodiscard]] VkImageView SampledHandle(Shader::TextureType texture_type,
bool use_integer_view);
[[nodiscard]] VkImage ImageHandle() const noexcept {
return image_handle;
}
@ -274,16 +268,11 @@ private:
};
[[nodiscard]] vk::ImageView MakeView(VkFormat vk_format, VkImageAspectFlags aspect_mask);
[[nodiscard]] vk::ImageView CreateSampledView(Shader::TextureType texture_type,
VkFormat vk_format) const;
const Device* device = nullptr;
const SlotVector<Image>* slot_images = nullptr;
std::array<vk::ImageView, Shader::NUM_TEXTURE_TYPES> image_views;
std::array<vk::ImageView, Shader::NUM_TEXTURE_TYPES> sampled_float_views;
std::array<vk::ImageView, Shader::NUM_TEXTURE_TYPES> sampled_integer_views;
std::array<std::optional<u32>, Shader::NUM_TEXTURE_TYPES> view_layer_counts{};
std::unique_ptr<StorageViews> storage_views;
vk::ImageView depth_view;
vk::ImageView stencil_view;
@ -292,14 +281,6 @@ private:
VkImage image_handle = VK_NULL_HANDLE;
VkImageView render_target = VK_NULL_HANDLE;
VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
VkComponentMapping component_mapping{
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
};
VkImageAspectFlags aspect_mask = 0;
VkImageUsageFlags view_usage_flags = 0;
u32 buffer_size = 0;
};

68
src/video_core/surface.cpp
View File

@ -4,8 +4,6 @@
// SPDX-FileCopyrightText: 2014 Citra Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <optional>
#include "common/common_types.h"
#include "common/math_util.h"
#include "common/settings.h"
@ -410,72 +408,6 @@ bool IsPixelFormatSignedInteger(PixelFormat format) {
}
}
std::optional<PixelFormat> NormalizedCompatibleFormat(PixelFormat format) {
switch (format) {
case PixelFormat::A8B8G8R8_UINT:
return PixelFormat::A8B8G8R8_UNORM;
case PixelFormat::A8B8G8R8_SINT:
return PixelFormat::A8B8G8R8_SNORM;
case PixelFormat::A2B10G10R10_UINT:
return PixelFormat::A2B10G10R10_UNORM;
case PixelFormat::R8_UINT:
return PixelFormat::R8_UNORM;
case PixelFormat::R8_SINT:
return PixelFormat::R8_SNORM;
case PixelFormat::R8G8_UINT:
return PixelFormat::R8G8_UNORM;
case PixelFormat::R8G8_SINT:
return PixelFormat::R8G8_SNORM;
case PixelFormat::R16_UINT:
return PixelFormat::R16_UNORM;
case PixelFormat::R16_SINT:
return PixelFormat::R16_SNORM;
case PixelFormat::R16G16_UINT:
return PixelFormat::R16G16_UNORM;
case PixelFormat::R16G16_SINT:
return PixelFormat::R16G16_SNORM;
case PixelFormat::R16G16B16A16_UINT:
return PixelFormat::R16G16B16A16_UNORM;
case PixelFormat::R16G16B16A16_SINT:
return PixelFormat::R16G16B16A16_SNORM;
default:
return std::nullopt;
}
}
std::optional<PixelFormat> IntegerCompatibleFormat(PixelFormat format) {
switch (format) {
case PixelFormat::A8B8G8R8_UNORM:
return PixelFormat::A8B8G8R8_UINT;
case PixelFormat::A8B8G8R8_SNORM:
return PixelFormat::A8B8G8R8_SINT;
case PixelFormat::A2B10G10R10_UNORM:
return PixelFormat::A2B10G10R10_UINT;
case PixelFormat::R8_UNORM:
return PixelFormat::R8_UINT;
case PixelFormat::R8_SNORM:
return PixelFormat::R8_SINT;
case PixelFormat::R8G8_UNORM:
return PixelFormat::R8G8_UINT;
case PixelFormat::R8G8_SNORM:
return PixelFormat::R8G8_SINT;
case PixelFormat::R16_UNORM:
return PixelFormat::R16_UINT;
case PixelFormat::R16_SNORM:
return PixelFormat::R16_SINT;
case PixelFormat::R16G16_UNORM:
return PixelFormat::R16G16_UINT;
case PixelFormat::R16G16_SNORM:
return PixelFormat::R16G16_SINT;
case PixelFormat::R16G16B16A16_UNORM:
return PixelFormat::R16G16B16A16_UINT;
case PixelFormat::R16G16B16A16_SNORM:
return PixelFormat::R16G16B16A16_SINT;
default:
return std::nullopt;
}
}
size_t PixelComponentSizeBitsInteger(PixelFormat format) {
switch (format) {
case PixelFormat::A8B8G8R8_SINT:

4
src/video_core/surface.h
View File

@ -4,7 +4,6 @@
#pragma once
#include <climits>
#include <optional>
#include <utility>
#include "common/assert.h"
#include "common/common_types.h"
@ -516,9 +515,6 @@ bool IsPixelFormatInteger(PixelFormat format);
bool IsPixelFormatSignedInteger(PixelFormat format);
std::optional<PixelFormat> NormalizedCompatibleFormat(PixelFormat format);
std::optional<PixelFormat> IntegerCompatibleFormat(PixelFormat format);
size_t PixelComponentSizeBitsInteger(PixelFormat format);
std::pair<u32, u32> GetASTCBlockSize(PixelFormat format);

Write Preview
Loading…
Cancel
Save