|
|
|
@ -7,6 +7,7 @@
|
|
|
|
|
#include "common/cityhash.h"
|
|
|
|
|
#include "common/alignment.h"
|
|
|
|
|
#include "core/core.h"
|
|
|
|
|
#include "video_core/engines/shader_bytecode.h"
|
|
|
|
|
#include "video_core/surface.h"
|
|
|
|
|
#include "video_core/texture_cache/surface_params.h"
|
|
|
|
|
#include "video_core/textures/decoders.h"
|
|
|
|
@ -22,6 +23,37 @@ using VideoCore::Surface::PixelFormatFromTextureFormat;
|
|
|
|
|
using VideoCore::Surface::SurfaceTarget;
|
|
|
|
|
using VideoCore::Surface::SurfaceTargetFromTextureType;
|
|
|
|
|
|
|
|
|
|
SurfaceTarget TextureType2SurfaceTarget(Tegra::Shader::TextureType type, bool is_array) {
|
|
|
|
|
switch (type) {
|
|
|
|
|
case Tegra::Shader::TextureType::Texture1D: {
|
|
|
|
|
if (is_array)
|
|
|
|
|
return SurfaceTarget::Texture1DArray;
|
|
|
|
|
else
|
|
|
|
|
return SurfaceTarget::Texture1D;
|
|
|
|
|
}
|
|
|
|
|
case Tegra::Shader::TextureType::Texture2D: {
|
|
|
|
|
if (is_array)
|
|
|
|
|
return SurfaceTarget::Texture2DArray;
|
|
|
|
|
else
|
|
|
|
|
return SurfaceTarget::Texture2D;
|
|
|
|
|
}
|
|
|
|
|
case Tegra::Shader::TextureType::Texture3D: {
|
|
|
|
|
ASSERT(!is_array);
|
|
|
|
|
return SurfaceTarget::Texture3D;
|
|
|
|
|
}
|
|
|
|
|
case Tegra::Shader::TextureType::TextureCube: {
|
|
|
|
|
if (is_array)
|
|
|
|
|
return SurfaceTarget::TextureCubeArray;
|
|
|
|
|
else
|
|
|
|
|
return SurfaceTarget::TextureCubemap;
|
|
|
|
|
}
|
|
|
|
|
default: {
|
|
|
|
|
UNREACHABLE();
|
|
|
|
|
return SurfaceTarget::Texture2D;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
constexpr u32 GetMipmapSize(bool uncompressed, u32 mip_size, u32 tile) {
|
|
|
|
|
return uncompressed ? mip_size : std::max(1U, (mip_size + tile - 1) / tile);
|
|
|
|
@ -29,7 +61,8 @@ constexpr u32 GetMipmapSize(bool uncompressed, u32 mip_size, u32 tile) {
|
|
|
|
|
} // Anonymous namespace
|
|
|
|
|
|
|
|
|
|
SurfaceParams SurfaceParams::CreateForTexture(Core::System& system,
|
|
|
|
|
const Tegra::Texture::FullTextureInfo& config) {
|
|
|
|
|
const Tegra::Texture::FullTextureInfo& config,
|
|
|
|
|
const VideoCommon::Shader::Sampler& entry) {
|
|
|
|
|
SurfaceParams params;
|
|
|
|
|
params.is_tiled = config.tic.IsTiled();
|
|
|
|
|
params.srgb_conversion = config.tic.IsSrgbConversionEnabled();
|
|
|
|
@ -41,7 +74,8 @@ SurfaceParams SurfaceParams::CreateForTexture(Core::System& system,
|
|
|
|
|
params.srgb_conversion);
|
|
|
|
|
params.component_type = ComponentTypeFromTexture(config.tic.r_type.Value());
|
|
|
|
|
params.type = GetFormatType(params.pixel_format);
|
|
|
|
|
params.target = SurfaceTargetFromTextureType(config.tic.texture_type);
|
|
|
|
|
// TODO: on 1DBuffer we should use the tic info.
|
|
|
|
|
params.target = TextureType2SurfaceTarget(entry.GetType(), entry.IsArray());
|
|
|
|
|
params.width = Common::AlignUp(config.tic.Width(), GetCompressionFactor(params.pixel_format));
|
|
|
|
|
params.height = Common::AlignUp(config.tic.Height(), GetCompressionFactor(params.pixel_format));
|
|
|
|
|
params.depth = config.tic.Depth();
|
|
|
|
@ -52,8 +86,7 @@ SurfaceParams SurfaceParams::CreateForTexture(Core::System& system,
|
|
|
|
|
params.pitch = params.is_tiled ? 0 : config.tic.Pitch();
|
|
|
|
|
params.unaligned_height = config.tic.Height();
|
|
|
|
|
params.num_levels = config.tic.max_mip_level + 1;
|
|
|
|
|
|
|
|
|
|
params.CalculateCachedValues();
|
|
|
|
|
params.is_layered = params.IsLayered();
|
|
|
|
|
return params;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -77,8 +110,7 @@ SurfaceParams SurfaceParams::CreateForDepthBuffer(
|
|
|
|
|
params.target = SurfaceTarget::Texture2D;
|
|
|
|
|
params.depth = 1;
|
|
|
|
|
params.num_levels = 1;
|
|
|
|
|
|
|
|
|
|
params.CalculateCachedValues();
|
|
|
|
|
params.is_layered = false;
|
|
|
|
|
return params;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -108,8 +140,7 @@ SurfaceParams SurfaceParams::CreateForFramebuffer(Core::System& system, std::siz
|
|
|
|
|
params.unaligned_height = config.height;
|
|
|
|
|
params.target = SurfaceTarget::Texture2D;
|
|
|
|
|
params.num_levels = 1;
|
|
|
|
|
|
|
|
|
|
params.CalculateCachedValues();
|
|
|
|
|
params.is_layered = false;
|
|
|
|
|
return params;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -128,13 +159,13 @@ SurfaceParams SurfaceParams::CreateForFermiCopySurface(
|
|
|
|
|
params.type = GetFormatType(params.pixel_format);
|
|
|
|
|
params.width = config.width;
|
|
|
|
|
params.height = config.height;
|
|
|
|
|
params.pitch = config.pitch;
|
|
|
|
|
params.unaligned_height = config.height;
|
|
|
|
|
// TODO(Rodrigo): Try to guess the surface target from depth and layer parameters
|
|
|
|
|
params.target = SurfaceTarget::Texture2D;
|
|
|
|
|
params.depth = 1;
|
|
|
|
|
params.num_levels = 1;
|
|
|
|
|
|
|
|
|
|
params.CalculateCachedValues();
|
|
|
|
|
params.is_layered = params.IsLayered();
|
|
|
|
|
return params;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -147,7 +178,7 @@ u32 SurfaceParams::GetMipHeight(u32 level) const {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
u32 SurfaceParams::GetMipDepth(u32 level) const {
|
|
|
|
|
return IsLayered() ? depth : std::max(1U, depth >> level);
|
|
|
|
|
return is_layered ? depth : std::max(1U, depth >> level);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool SurfaceParams::IsLayered() const {
|
|
|
|
@ -183,7 +214,7 @@ u32 SurfaceParams::GetMipBlockDepth(u32 level) const {
|
|
|
|
|
if (level == 0) {
|
|
|
|
|
return this->block_depth;
|
|
|
|
|
}
|
|
|
|
|
if (IsLayered()) {
|
|
|
|
|
if (is_layered) {
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -216,6 +247,10 @@ std::size_t SurfaceParams::GetHostMipmapLevelOffset(u32 level) const {
|
|
|
|
|
return offset;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::size_t SurfaceParams::GetGuestMipmapSize(u32 level) const {
|
|
|
|
|
return GetInnerMipmapMemorySize(level, false, false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::size_t SurfaceParams::GetHostMipmapSize(u32 level) const {
|
|
|
|
|
return GetInnerMipmapMemorySize(level, true, false) * GetNumLayers();
|
|
|
|
|
}
|
|
|
|
@ -229,7 +264,7 @@ std::size_t SurfaceParams::GetLayerSize(bool as_host_size, bool uncompressed) co
|
|
|
|
|
for (u32 level = 0; level < num_levels; ++level) {
|
|
|
|
|
size += GetInnerMipmapMemorySize(level, as_host_size, uncompressed);
|
|
|
|
|
}
|
|
|
|
|
if (is_tiled && (IsLayered() || target == SurfaceTarget::Texture3D)) {
|
|
|
|
|
if (is_tiled && is_layered) {
|
|
|
|
|
return Common::AlignUp(size, Tegra::Texture::GetGOBSize() * block_height * block_depth);
|
|
|
|
|
}
|
|
|
|
|
return size;
|
|
|
|
@ -256,150 +291,32 @@ u32 SurfaceParams::GetBytesPerPixel() const {
|
|
|
|
|
return VideoCore::Surface::GetBytesPerPixel(pixel_format);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool SurfaceParams::IsFamiliar(const SurfaceParams& view_params) const {
|
|
|
|
|
if (std::tie(is_tiled, tile_width_spacing, pixel_format, component_type, type) !=
|
|
|
|
|
std::tie(view_params.is_tiled, view_params.tile_width_spacing, view_params.pixel_format,
|
|
|
|
|
view_params.component_type, view_params.type)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const SurfaceTarget view_target{view_params.target};
|
|
|
|
|
if (view_target == target) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (target) {
|
|
|
|
|
case SurfaceTarget::Texture1D:
|
|
|
|
|
case SurfaceTarget::Texture2D:
|
|
|
|
|
case SurfaceTarget::Texture3D:
|
|
|
|
|
return false;
|
|
|
|
|
case SurfaceTarget::Texture1DArray:
|
|
|
|
|
return view_target == SurfaceTarget::Texture1D;
|
|
|
|
|
case SurfaceTarget::Texture2DArray:
|
|
|
|
|
return view_target == SurfaceTarget::Texture2D;
|
|
|
|
|
case SurfaceTarget::TextureCubemap:
|
|
|
|
|
return view_target == SurfaceTarget::Texture2D ||
|
|
|
|
|
view_target == SurfaceTarget::Texture2DArray;
|
|
|
|
|
case SurfaceTarget::TextureCubeArray:
|
|
|
|
|
return view_target == SurfaceTarget::Texture2D ||
|
|
|
|
|
view_target == SurfaceTarget::Texture2DArray ||
|
|
|
|
|
view_target == SurfaceTarget::TextureCubemap;
|
|
|
|
|
default:
|
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented texture family={}", static_cast<u32>(target));
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool SurfaceParams::IsPixelFormatZeta() const {
|
|
|
|
|
return pixel_format >= VideoCore::Surface::PixelFormat::MaxColorFormat &&
|
|
|
|
|
pixel_format < VideoCore::Surface::PixelFormat::MaxDepthStencilFormat;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void SurfaceParams::CalculateCachedValues() {
|
|
|
|
|
switch (target) {
|
|
|
|
|
case SurfaceTarget::Texture1D:
|
|
|
|
|
case SurfaceTarget::Texture2D:
|
|
|
|
|
case SurfaceTarget::Texture3D:
|
|
|
|
|
num_layers = 1;
|
|
|
|
|
break;
|
|
|
|
|
case SurfaceTarget::Texture1DArray:
|
|
|
|
|
case SurfaceTarget::Texture2DArray:
|
|
|
|
|
case SurfaceTarget::TextureCubemap:
|
|
|
|
|
case SurfaceTarget::TextureCubeArray:
|
|
|
|
|
num_layers = depth;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
UNREACHABLE();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
guest_size_in_bytes = GetInnerMemorySize(false, false, false);
|
|
|
|
|
|
|
|
|
|
if (IsPixelFormatASTC(pixel_format)) {
|
|
|
|
|
// ASTC is uncompressed in software, in emulated as RGBA8
|
|
|
|
|
host_size_in_bytes = static_cast<std::size_t>(width) * static_cast<std::size_t>(height) *
|
|
|
|
|
static_cast<std::size_t>(depth) * 4ULL;
|
|
|
|
|
} else {
|
|
|
|
|
host_size_in_bytes = GetInnerMemorySize(true, false, false);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::size_t SurfaceParams::GetInnerMipmapMemorySize(u32 level, bool as_host_size,
|
|
|
|
|
bool uncompressed) const {
|
|
|
|
|
const bool tiled{as_host_size ? false : is_tiled};
|
|
|
|
|
const u32 width{GetMipmapSize(uncompressed, GetMipWidth(level), GetDefaultBlockWidth())};
|
|
|
|
|
const u32 height{GetMipmapSize(uncompressed, GetMipHeight(level), GetDefaultBlockHeight())};
|
|
|
|
|
const u32 depth{target == SurfaceTarget::Texture3D ? GetMipDepth(level) : 1U};
|
|
|
|
|
const u32 depth{is_layered ? 1U : GetMipDepth(level)};
|
|
|
|
|
return Tegra::Texture::CalculateSize(tiled, GetBytesPerPixel(), width, height, depth,
|
|
|
|
|
GetMipBlockHeight(level), GetMipBlockDepth(level));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::size_t SurfaceParams::GetInnerMemorySize(bool as_host_size, bool layer_only,
|
|
|
|
|
bool uncompressed) const {
|
|
|
|
|
return GetLayerSize(as_host_size, uncompressed) * (layer_only ? 1U : num_layers);
|
|
|
|
|
return GetLayerSize(as_host_size, uncompressed) * (layer_only ? 1U : depth);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::map<u64, std::pair<u32, u32>> SurfaceParams::CreateViewOffsetMap() const {
|
|
|
|
|
std::map<u64, std::pair<u32, u32>> view_offset_map;
|
|
|
|
|
switch (target) {
|
|
|
|
|
case SurfaceTarget::Texture1D:
|
|
|
|
|
case SurfaceTarget::Texture2D:
|
|
|
|
|
case SurfaceTarget::Texture3D: {
|
|
|
|
|
// TODO(Rodrigo): Add layer iterations for 3D textures
|
|
|
|
|
constexpr u32 layer = 0;
|
|
|
|
|
for (u32 level = 0; level < num_levels; ++level) {
|
|
|
|
|
const std::size_t offset{GetGuestMipmapLevelOffset(level)};
|
|
|
|
|
view_offset_map.insert({offset, {layer, level}});
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case SurfaceTarget::Texture1DArray:
|
|
|
|
|
case SurfaceTarget::Texture2DArray:
|
|
|
|
|
case SurfaceTarget::TextureCubemap:
|
|
|
|
|
case SurfaceTarget::TextureCubeArray: {
|
|
|
|
|
const std::size_t layer_size{GetGuestLayerSize()};
|
|
|
|
|
for (u32 level = 0; level < num_levels; ++level) {
|
|
|
|
|
const std::size_t level_offset{GetGuestMipmapLevelOffset(level)};
|
|
|
|
|
for (u32 layer = 0; layer < num_layers; ++layer) {
|
|
|
|
|
const auto layer_offset{static_cast<std::size_t>(layer_size * layer)};
|
|
|
|
|
const std::size_t offset{level_offset + layer_offset};
|
|
|
|
|
view_offset_map.insert({offset, {layer, level}});
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
UNIMPLEMENTED_MSG("Unimplemented surface target {}", static_cast<u32>(target));
|
|
|
|
|
}
|
|
|
|
|
return view_offset_map;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool SurfaceParams::IsViewValid(const SurfaceParams& view_params, u32 layer, u32 level) const {
|
|
|
|
|
return IsDimensionValid(view_params, level) && IsDepthValid(view_params, level) &&
|
|
|
|
|
IsInBounds(view_params, layer, level);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool SurfaceParams::IsDimensionValid(const SurfaceParams& view_params, u32 level) const {
|
|
|
|
|
return view_params.width == GetMipWidth(level) && view_params.height == GetMipHeight(level);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool SurfaceParams::IsDepthValid(const SurfaceParams& view_params, u32 level) const {
|
|
|
|
|
if (view_params.target != SurfaceTarget::Texture3D) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return view_params.depth == GetMipDepth(level);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool SurfaceParams::IsInBounds(const SurfaceParams& view_params, u32 layer, u32 level) const {
|
|
|
|
|
return layer + view_params.num_layers <= num_layers &&
|
|
|
|
|
level + view_params.num_levels <= num_levels;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::size_t HasheableSurfaceParams::Hash() const {
|
|
|
|
|
std::size_t SurfaceParams::Hash() const {
|
|
|
|
|
return static_cast<std::size_t>(
|
|
|
|
|
Common::CityHash64(reinterpret_cast<const char*>(this), sizeof(*this)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool HasheableSurfaceParams::operator==(const HasheableSurfaceParams& rhs) const {
|
|
|
|
|
bool SurfaceParams::operator==(const SurfaceParams& rhs) const {
|
|
|
|
|
return std::tie(is_tiled, block_width, block_height, block_depth, tile_width_spacing, width,
|
|
|
|
|
height, depth, pitch, unaligned_height, num_levels, pixel_format,
|
|
|
|
|
component_type, type, target) ==
|
|
|
|
@ -409,4 +326,27 @@ bool HasheableSurfaceParams::operator==(const HasheableSurfaceParams& rhs) const
|
|
|
|
|
rhs.type, rhs.target);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string SurfaceParams::TargetName() const {
|
|
|
|
|
switch (target) {
|
|
|
|
|
case SurfaceTarget::Texture1D:
|
|
|
|
|
return "1D";
|
|
|
|
|
case SurfaceTarget::Texture2D:
|
|
|
|
|
return "2D";
|
|
|
|
|
case SurfaceTarget::Texture3D:
|
|
|
|
|
return "3D";
|
|
|
|
|
case SurfaceTarget::Texture1DArray:
|
|
|
|
|
return "1DArray";
|
|
|
|
|
case SurfaceTarget::Texture2DArray:
|
|
|
|
|
return "2DArray";
|
|
|
|
|
case SurfaceTarget::TextureCubemap:
|
|
|
|
|
return "Cube";
|
|
|
|
|
case SurfaceTarget::TextureCubeArray:
|
|
|
|
|
return "CubeArray";
|
|
|
|
|
default:
|
|
|
|
|
LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
|
|
|
|
|
UNREACHABLE();
|
|
|
|
|
return fmt::format("TUK({})", static_cast<u32>(target));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace VideoCommon
|
|
|
|
|