From 3e352559834b070feb89a7b9e47de54aaa7ab528 Mon Sep 17 00:00:00 2001 From: iwubcode Date: Tue, 28 Feb 2023 19:12:35 -0600 Subject: [PATCH 1/2] VideoCommon: add class to load custom texture data --- Source/Core/DolphinLib.props | 2 + Source/Core/VideoCommon/CMakeLists.txt | 2 + .../Runtime/CustomTextureData.cpp | 544 ++++++++++++++++++ .../Runtime/CustomTextureData.h | 32 ++ 4 files changed, 580 insertions(+) create mode 100644 Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.cpp create mode 100644 Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.h diff --git a/Source/Core/DolphinLib.props b/Source/Core/DolphinLib.props index ddb2cd86e7..061c19ae97 100644 --- a/Source/Core/DolphinLib.props +++ b/Source/Core/DolphinLib.props @@ -659,6 +659,7 @@ + @@ -1260,6 +1261,7 @@ + diff --git a/Source/Core/VideoCommon/CMakeLists.txt b/Source/Core/VideoCommon/CMakeLists.txt index 2737d5a514..e2db8c9f03 100644 --- a/Source/Core/VideoCommon/CMakeLists.txt +++ b/Source/Core/VideoCommon/CMakeLists.txt @@ -65,6 +65,8 @@ add_library(videocommon GraphicsModSystem/Runtime/Actions/ScaleAction.h GraphicsModSystem/Runtime/Actions/SkipAction.cpp GraphicsModSystem/Runtime/Actions/SkipAction.h + GraphicsModSystem/Runtime/CustomTextureData.cpp + GraphicsModSystem/Runtime/CustomTextureData.h GraphicsModSystem/Runtime/FBInfo.cpp GraphicsModSystem/Runtime/FBInfo.h GraphicsModSystem/Runtime/GraphicsModAction.h diff --git a/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.cpp b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.cpp new file mode 100644 index 0000000000..10b84b4a7a --- /dev/null +++ b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.cpp @@ -0,0 +1,544 @@ +// Copyright 2023 Dolphin Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.h" + +#include +#include +#include +#include +#include + +#include "Common/Align.h" +#include "Common/IOFile.h" +#include "Common/Image.h" +#include "Common/Logging/Log.h" +#include "Common/Swap.h" +#include "VideoCommon/VideoConfig.h" + +namespace +{ +// From https://raw.githubusercontent.com/Microsoft/DirectXTex/master/DirectXTex/DDS.h +// +// This header defines constants and structures that are useful when parsing +// DDS files. DDS files were originally designed to use several structures +// and constants that are native to DirectDraw and are defined in ddraw.h, +// such as DDSURFACEDESC2 and DDSCAPS2. This file defines similar +// (compatible) constants and structures so that one can use DDS files +// without needing to include ddraw.h. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF +// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO +// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A +// PARTICULAR PURPOSE. +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// +// http://go.microsoft.com/fwlink/?LinkId=248926 + +#pragma pack(push, 1) + +const uint32_t DDS_MAGIC = 0x20534444; // "DDS " + +struct DDS_PIXELFORMAT +{ + uint32_t dwSize; + uint32_t dwFlags; + uint32_t dwFourCC; + uint32_t dwRGBBitCount; + uint32_t dwRBitMask; + uint32_t dwGBitMask; + uint32_t dwBBitMask; + uint32_t dwABitMask; +}; + +#define DDS_FOURCC 0x00000004 // DDPF_FOURCC +#define DDS_RGB 0x00000040 // DDPF_RGB +#define DDS_RGBA 0x00000041 // DDPF_RGB | DDPF_ALPHAPIXELS +#define DDS_LUMINANCE 0x00020000 // DDPF_LUMINANCE +#define DDS_LUMINANCEA 0x00020001 // DDPF_LUMINANCE | DDPF_ALPHAPIXELS +#define DDS_ALPHA 0x00000002 // DDPF_ALPHA +#define DDS_PAL8 0x00000020 // DDPF_PALETTEINDEXED8 +#define DDS_PAL8A 0x00000021 // DDPF_PALETTEINDEXED8 | DDPF_ALPHAPIXELS +#define DDS_BUMPDUDV 0x00080000 // DDPF_BUMPDUDV + +#ifndef MAKEFOURCC +#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ + ((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | ((uint32_t)(uint8_t)(ch2) << 16) | \ + ((uint32_t)(uint8_t)(ch3) << 24)) +#endif /* defined(MAKEFOURCC) */ + +#define DDS_HEADER_FLAGS_TEXTURE \ + 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT +#define DDS_HEADER_FLAGS_MIPMAP 0x00020000 // DDSD_MIPMAPCOUNT +#define DDS_HEADER_FLAGS_VOLUME 0x00800000 // DDSD_DEPTH +#define DDS_HEADER_FLAGS_PITCH 0x00000008 // DDSD_PITCH +#define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000 // DDSD_LINEARSIZE + +// Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION +enum DDS_RESOURCE_DIMENSION +{ + DDS_DIMENSION_TEXTURE1D = 2, + DDS_DIMENSION_TEXTURE2D = 3, + DDS_DIMENSION_TEXTURE3D = 4, +}; + +struct DDS_HEADER +{ + uint32_t dwSize; + uint32_t dwFlags; + uint32_t dwHeight; + uint32_t dwWidth; + uint32_t dwPitchOrLinearSize; + uint32_t dwDepth; // only if DDS_HEADER_FLAGS_VOLUME is set in dwFlags + uint32_t dwMipMapCount; + uint32_t dwReserved1[11]; + DDS_PIXELFORMAT ddspf; + uint32_t dwCaps; + uint32_t dwCaps2; + uint32_t dwCaps3; + uint32_t dwCaps4; + uint32_t dwReserved2; +}; + +struct DDS_HEADER_DXT10 +{ + uint32_t dxgiFormat; + uint32_t resourceDimension; + uint32_t miscFlag; // see DDS_RESOURCE_MISC_FLAG + uint32_t arraySize; + uint32_t miscFlags2; // see DDS_MISC_FLAGS2 +}; + +#pragma pack(pop) + +static_assert(sizeof(DDS_HEADER) == 124, "DDS Header size mismatch"); +static_assert(sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch"); + +constexpr DDS_PIXELFORMAT DDSPF_A8R8G8B8 = { + sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000}; +constexpr DDS_PIXELFORMAT DDSPF_X8R8G8B8 = { + sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000}; +constexpr DDS_PIXELFORMAT DDSPF_A8B8G8R8 = { + sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000}; +constexpr DDS_PIXELFORMAT DDSPF_X8B8G8R8 = { + sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000}; +constexpr DDS_PIXELFORMAT DDSPF_R8G8B8 = { + sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 24, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000}; + +// End of Microsoft code from DDS.h. + +static constexpr bool DDSPixelFormatMatches(const DDS_PIXELFORMAT& pf1, const DDS_PIXELFORMAT& pf2) +{ + return std::tie(pf1.dwSize, pf1.dwFlags, pf1.dwFourCC, pf1.dwRGBBitCount, pf1.dwRBitMask, + pf1.dwGBitMask, pf1.dwGBitMask, pf1.dwBBitMask, pf1.dwABitMask) == + std::tie(pf2.dwSize, pf2.dwFlags, pf2.dwFourCC, pf2.dwRGBBitCount, pf2.dwRBitMask, + pf2.dwGBitMask, pf2.dwGBitMask, pf2.dwBBitMask, pf2.dwABitMask); +} + +struct DDSLoadInfo +{ + u32 block_size = 1; + u32 bytes_per_block = 4; + u32 width = 0; + u32 height = 0; + u32 mip_count = 0; + AbstractTextureFormat format = AbstractTextureFormat::RGBA8; + size_t first_mip_offset = 0; + size_t first_mip_size = 0; + u32 first_mip_row_length = 0; + + std::function conversion_function; +}; + +static constexpr u32 GetBlockCount(u32 extent, u32 block_size) +{ + return std::max(Common::AlignUp(extent, block_size) / block_size, 1u); +} + +static u32 CalculateMipCount(u32 width, u32 height) +{ + u32 mip_width = width; + u32 mip_height = height; + u32 mip_count = 1; + while (mip_width > 1 || mip_height > 1) + { + mip_width = std::max(mip_width / 2, 1u); + mip_height = std::max(mip_height / 2, 1u); + mip_count++; + } + + return mip_count; +} + +static void ConvertTexture_X8B8G8R8(VideoCommon::CustomTextureData::Level* level) +{ + u8* data_ptr = level->data.data(); + for (u32 row = 0; row < level->height; row++) + { + for (u32 x = 0; x < level->row_length; x++) + { + // Set alpha channel to full intensity. + data_ptr[3] = 0xFF; + data_ptr += sizeof(u32); + } + } +} + +static void ConvertTexture_A8R8G8B8(VideoCommon::CustomTextureData::Level* level) +{ + u8* data_ptr = level->data.data(); + for (u32 row = 0; row < level->height; row++) + { + for (u32 x = 0; x < level->row_length; x++) + { + // Byte swap ABGR -> RGBA + u32 val; + std::memcpy(&val, data_ptr, sizeof(val)); + val = ((val & 0xFF00FF00) | ((val >> 16) & 0xFF) | ((val << 16) & 0xFF0000)); + std::memcpy(data_ptr, &val, sizeof(u32)); + data_ptr += sizeof(u32); + } + } +} + +static void ConvertTexture_X8R8G8B8(VideoCommon::CustomTextureData::Level* level) +{ + u8* data_ptr = level->data.data(); + for (u32 row = 0; row < level->height; row++) + { + for (u32 x = 0; x < level->row_length; x++) + { + // Byte swap XBGR -> RGBX, and set alpha to full intensity. + u32 val; + std::memcpy(&val, data_ptr, sizeof(val)); + val = ((val & 0x0000FF00) | ((val >> 16) & 0xFF) | ((val << 16) & 0xFF0000)) | 0xFF000000; + std::memcpy(data_ptr, &val, sizeof(u32)); + data_ptr += sizeof(u32); + } + } +} + +static void ConvertTexture_R8G8B8(VideoCommon::CustomTextureData::Level* level) +{ + std::vector new_data(level->row_length * level->height * sizeof(u32)); + + const u8* rgb_data_ptr = level->data.data(); + u8* data_ptr = new_data.data(); + + for (u32 row = 0; row < level->height; row++) + { + for (u32 x = 0; x < level->row_length; x++) + { + // This is BGR in memory. + u32 val; + std::memcpy(&val, rgb_data_ptr, sizeof(val)); + val = ((val & 0x0000FF00) | ((val >> 16) & 0xFF) | ((val << 16) & 0xFF0000)) | 0xFF000000; + std::memcpy(data_ptr, &val, sizeof(u32)); + data_ptr += sizeof(u32); + rgb_data_ptr += 3; + } + } + + level->data = std::move(new_data); +} + +static bool ParseDDSHeader(File::IOFile& file, DDSLoadInfo* info) +{ + // Exit as early as possible for non-DDS textures, since all extensions are currently + // passed through this function. + u32 magic; + if (!file.ReadBytes(&magic, sizeof(magic)) || magic != DDS_MAGIC) + return false; + + DDS_HEADER header; + size_t header_size = sizeof(header); + if (!file.ReadBytes(&header, header_size) || header.dwSize < header_size) + return false; + + // Required fields. + if ((header.dwFlags & DDS_HEADER_FLAGS_TEXTURE) != DDS_HEADER_FLAGS_TEXTURE) + return false; + + // Image should be 2D. + if (header.dwFlags & DDS_HEADER_FLAGS_VOLUME) + return false; + + // Presence of width/height fields is already tested by DDS_HEADER_FLAGS_TEXTURE. + info->width = header.dwWidth; + info->height = header.dwHeight; + if (info->width == 0 || info->height == 0) + return false; + + // Check for mip levels. + if (header.dwFlags & DDS_HEADER_FLAGS_MIPMAP) + { + info->mip_count = header.dwMipMapCount; + if (header.dwMipMapCount != 0) + info->mip_count = header.dwMipMapCount; + else + info->mip_count = CalculateMipCount(info->width, info->height); + } + else + { + info->mip_count = 1; + } + + // Handle fourcc formats vs uncompressed formats. + bool has_fourcc = (header.ddspf.dwFlags & DDS_FOURCC) != 0; + bool needs_s3tc = false; + if (has_fourcc) + { + // Handle DX10 extension header. + u32 dxt10_format = 0; + if (header.ddspf.dwFourCC == MAKEFOURCC('D', 'X', '1', '0')) + { + DDS_HEADER_DXT10 dxt10_header; + if (!file.ReadBytes(&dxt10_header, sizeof(dxt10_header))) + return false; + + // Can't handle array textures here. Doesn't make sense to use them, anyway. + if (dxt10_header.resourceDimension != DDS_DIMENSION_TEXTURE2D || dxt10_header.arraySize != 1) + return false; + + header_size += sizeof(dxt10_header); + dxt10_format = dxt10_header.dxgiFormat; + } + + // Currently, we only handle compressed textures here, and leave the rest to the SOIL loader. + // In the future, this could be extended, but these isn't much benefit in doing so currently. + if (header.ddspf.dwFourCC == MAKEFOURCC('D', 'X', 'T', '1') || dxt10_format == 71) + { + info->format = AbstractTextureFormat::DXT1; + info->block_size = 4; + info->bytes_per_block = 8; + needs_s3tc = true; + } + else if (header.ddspf.dwFourCC == MAKEFOURCC('D', 'X', 'T', '3') || dxt10_format == 74) + { + info->format = AbstractTextureFormat::DXT3; + info->block_size = 4; + info->bytes_per_block = 16; + needs_s3tc = true; + } + else if (header.ddspf.dwFourCC == MAKEFOURCC('D', 'X', 'T', '5') || dxt10_format == 77) + { + info->format = AbstractTextureFormat::DXT5; + info->block_size = 4; + info->bytes_per_block = 16; + needs_s3tc = true; + } + else if (dxt10_format == 98) + { + info->format = AbstractTextureFormat::BPTC; + info->block_size = 4; + info->bytes_per_block = 16; + if (!g_ActiveConfig.backend_info.bSupportsBPTCTextures) + return false; + } + else + { + // Leave all remaining formats to SOIL. + return false; + } + } + else + { + if (DDSPixelFormatMatches(header.ddspf, DDSPF_A8R8G8B8)) + { + info->conversion_function = ConvertTexture_A8R8G8B8; + } + else if (DDSPixelFormatMatches(header.ddspf, DDSPF_X8R8G8B8)) + { + info->conversion_function = ConvertTexture_X8R8G8B8; + } + else if (DDSPixelFormatMatches(header.ddspf, DDSPF_X8B8G8R8)) + { + info->conversion_function = ConvertTexture_X8B8G8R8; + } + else if (DDSPixelFormatMatches(header.ddspf, DDSPF_R8G8B8)) + { + info->conversion_function = ConvertTexture_R8G8B8; + } + else if (DDSPixelFormatMatches(header.ddspf, DDSPF_A8B8G8R8)) + { + // This format is already in RGBA order, so no conversion necessary. + } + else + { + return false; + } + + // All these formats are RGBA, just with byte swapping. + info->format = AbstractTextureFormat::RGBA8; + info->block_size = 1; + info->bytes_per_block = header.ddspf.dwRGBBitCount / 8; + } + + // We also need to ensure the backend supports these formats natively before loading them, + // otherwise, fallback to SOIL, which will decompress them to RGBA. + if (needs_s3tc && !g_ActiveConfig.backend_info.bSupportsST3CTextures) + return false; + + // Mip levels smaller than the block size are padded to multiples of the block size. + u32 blocks_wide = GetBlockCount(info->width, info->block_size); + u32 blocks_high = GetBlockCount(info->height, info->block_size); + + // Pitch can be specified in the header, otherwise we can derive it from the dimensions. For + // compressed formats, both DDS_HEADER_FLAGS_LINEARSIZE and DDS_HEADER_FLAGS_PITCH should be + // set. See https://msdn.microsoft.com/en-us/library/windows/desktop/bb943982(v=vs.85).aspx + if (header.dwFlags & DDS_HEADER_FLAGS_PITCH && header.dwFlags & DDS_HEADER_FLAGS_LINEARSIZE) + { + // Convert pitch (in bytes) to texels/row length. + if (header.dwPitchOrLinearSize < info->bytes_per_block) + { + // Likely a corrupted or invalid file. + return false; + } + + info->first_mip_row_length = + std::max(header.dwPitchOrLinearSize / info->bytes_per_block, 1u) * info->block_size; + info->first_mip_size = static_cast(info->first_mip_row_length / info->block_size) * + info->block_size * blocks_high; + } + else + { + // Assume no padding between rows of blocks. + info->first_mip_row_length = blocks_wide * info->block_size; + info->first_mip_size = blocks_wide * static_cast(info->bytes_per_block) * blocks_high; + } + + // Check for truncated or corrupted files. + info->first_mip_offset = sizeof(magic) + header_size; + if (info->first_mip_offset >= file.GetSize()) + return false; + + return true; +} + +static bool ReadMipLevel(VideoCommon::CustomTextureData::Level* level, File::IOFile& file, + const std::string& filename, u32 mip_level, const DDSLoadInfo& info, + u32 width, u32 height, u32 row_length, size_t size) +{ + // D3D11 cannot handle block compressed textures where the first mip level is + // not a multiple of the block size. + if (mip_level == 0 && info.block_size > 1 && + ((width % info.block_size) != 0 || (height % info.block_size) != 0)) + { + ERROR_LOG_FMT(VIDEO, + "Invalid dimensions for DDS texture {}. For compressed textures of this format, " + "the width/height of the first mip level must be a multiple of {}.", + filename, info.block_size); + return false; + } + + // Copy to the final storage location. + level->width = width; + level->height = height; + level->format = info.format; + level->row_length = row_length; + level->data.resize(size); + if (!file.ReadBytes(level->data.data(), level->data.size())) + return false; + + // Apply conversion function for uncompressed textures. + if (info.conversion_function) + info.conversion_function(level); + + return true; +} + +} // namespace + +namespace VideoCommon +{ +bool LoadDDSTexture(CustomTextureData* texture, const std::string& filename) +{ + File::IOFile file; + file.Open(filename, "rb"); + if (!file.IsOpen()) + return false; + + DDSLoadInfo info; + if (!ParseDDSHeader(file, &info)) + return false; + + // Read first mip level, as it may have a custom pitch. + CustomTextureData::Level first_level; + if (!file.Seek(info.first_mip_offset, File::SeekOrigin::Begin) || + !ReadMipLevel(&first_level, file, filename, 0, info, info.width, info.height, + info.first_mip_row_length, info.first_mip_size)) + { + return false; + } + + texture->m_levels.push_back(std::move(first_level)); + + // Read in any remaining mip levels in the file. + // If the .dds file does not contain a full mip chain, we'll fall back to the old path. + u32 mip_width = info.width; + u32 mip_height = info.height; + for (u32 i = 1; i < info.mip_count; i++) + { + mip_width = std::max(mip_width / 2, 1u); + mip_height = std::max(mip_height / 2, 1u); + + // Pitch can't be specified with each mip level, so we have to calculate it ourselves. + u32 blocks_wide = GetBlockCount(mip_width, info.block_size); + u32 blocks_high = GetBlockCount(mip_height, info.block_size); + u32 mip_row_length = blocks_wide * info.block_size; + size_t mip_size = blocks_wide * static_cast(info.bytes_per_block) * blocks_high; + CustomTextureData::Level level; + if (!ReadMipLevel(&level, file, filename, i, info, mip_width, mip_height, mip_row_length, + mip_size)) + break; + + texture->m_levels.push_back(std::move(level)); + } + + return true; +} + +bool LoadDDSTexture(CustomTextureData::Level* level, const std::string& filename, u32 mip_level) +{ + // Only loading a single mip level. + File::IOFile file; + file.Open(filename, "rb"); + if (!file.IsOpen()) + return false; + + DDSLoadInfo info; + if (!ParseDDSHeader(file, &info)) + return false; + + return ReadMipLevel(level, file, filename, mip_level, info, info.width, info.height, + info.first_mip_row_length, info.first_mip_size); +} + +bool LoadPNGTexture(CustomTextureData* texture, const std::string& filename) +{ + return LoadPNGTexture(&texture->m_levels[0], filename); +} + +bool LoadPNGTexture(CustomTextureData::Level* level, const std::string& filename) +{ + if (!level) [[unlikely]] + return false; + + File::IOFile file; + file.Open(filename, "rb"); + std::vector buffer(file.GetSize()); + file.ReadBytes(buffer.data(), file.GetSize()); + + if (!Common::LoadPNG(buffer, &level->data, &level->width, &level->height)) + return false; + + if (level->data.empty()) + return false; + + // Loaded PNG images are converted to RGBA. + level->format = AbstractTextureFormat::RGBA8; + level->row_length = level->width; + return true; +} +} // namespace VideoCommon diff --git a/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.h b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.h new file mode 100644 index 0000000000..9a16bf1db0 --- /dev/null +++ b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.h @@ -0,0 +1,32 @@ +// Copyright 2023 Dolphin Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include + +#include "Common/CommonTypes.h" +#include "VideoCommon/TextureConfig.h" + +namespace VideoCommon +{ +class CustomTextureData +{ +public: + struct Level + { + std::vector data; + AbstractTextureFormat format = AbstractTextureFormat::RGBA8; + u32 width = 0; + u32 height = 0; + u32 row_length = 0; + }; + std::vector m_levels; +}; + +bool LoadDDSTexture(CustomTextureData* texture, const std::string& filename); +bool LoadDDSTexture(CustomTextureData::Level* level, const std::string& filename, u32 mip_level); +bool LoadPNGTexture(CustomTextureData* texture, const std::string& filename); +bool LoadPNGTexture(CustomTextureData::Level* level, const std::string& filename); +} // namespace VideoCommon From 42cb3f39046af5d0cfe3fae05e2e2ba98d80d367 Mon Sep 17 00:00:00 2001 From: iwubcode Date: Tue, 28 Feb 2023 20:28:27 -0600 Subject: [PATCH 2/2] VideoCommon: remove HiResTexture DDS loading, update hirestexture logic to use custom texture data --- Source/Core/DolphinLib.props | 1 - Source/Core/VideoCommon/CMakeLists.txt | 1 - Source/Core/VideoCommon/HiresTextures.cpp | 68 +-- Source/Core/VideoCommon/HiresTextures.h | 19 +- .../VideoCommon/HiresTextures_DDSLoader.cpp | 498 ------------------ Source/Core/VideoCommon/TextureCacheBase.cpp | 8 +- 6 files changed, 27 insertions(+), 568 deletions(-) delete mode 100644 Source/Core/VideoCommon/HiresTextures_DDSLoader.cpp diff --git a/Source/Core/DolphinLib.props b/Source/Core/DolphinLib.props index 061c19ae97..6facc4c074 100644 --- a/Source/Core/DolphinLib.props +++ b/Source/Core/DolphinLib.props @@ -1265,7 +1265,6 @@ - diff --git a/Source/Core/VideoCommon/CMakeLists.txt b/Source/Core/VideoCommon/CMakeLists.txt index e2db8c9f03..40c9cd3ded 100644 --- a/Source/Core/VideoCommon/CMakeLists.txt +++ b/Source/Core/VideoCommon/CMakeLists.txt @@ -77,7 +77,6 @@ add_library(videocommon GraphicsModSystem/Runtime/GraphicsModManager.h HiresTextures.cpp HiresTextures.h - HiresTextures_DDSLoader.cpp IndexGenerator.cpp IndexGenerator.h LightingShaderGen.cpp diff --git a/Source/Core/VideoCommon/HiresTextures.cpp b/Source/Core/VideoCommon/HiresTextures.cpp index f3d6d77373..0227105d19 100644 --- a/Source/Core/VideoCommon/HiresTextures.cpp +++ b/Source/Core/VideoCommon/HiresTextures.cpp @@ -185,7 +185,7 @@ void HiresTexture::Prefetch() } if (iter != s_textureCache.end()) { - for (const Level& l : iter->second->m_levels) + for (const VideoCommon::CustomTextureData::Level& l : iter->second->m_data.m_levels) size_sum += l.data.size(); } } @@ -246,21 +246,6 @@ std::string HiresTexture::GenBaseName(const TextureInfo& texture_info, bool dump return ""; } -u32 HiresTexture::CalculateMipCount(u32 width, u32 height) -{ - u32 mip_width = width; - u32 mip_height = height; - u32 mip_count = 1; - while (mip_width > 1 || mip_height > 1) - { - mip_width = std::max(mip_width / 2, 1u); - mip_height = std::max(mip_height / 2, 1u); - mip_count++; - } - - return mip_count; -} - std::shared_ptr HiresTexture::Search(const TextureInfo& texture_info) { const std::string base_filename = GenBaseName(texture_info); @@ -298,10 +283,10 @@ std::unique_ptr HiresTexture::Load(const std::string& base_filenam std::unique_ptr ret = std::unique_ptr(new HiresTexture()); const DiskTexture& first_mip_file = filename_iter->second; ret->m_has_arbitrary_mipmaps = first_mip_file.has_arbitrary_mipmaps; - LoadDDSTexture(ret.get(), first_mip_file.path); + VideoCommon::LoadDDSTexture(&ret->m_data, first_mip_file.path); // Load remaining mip levels, or from the start if it's not a DDS texture. - for (u32 mip_level = static_cast(ret->m_levels.size());; mip_level++) + for (u32 mip_level = static_cast(ret->m_data.m_levels.size());; mip_level++) { std::string filename = base_filename; if (mip_level != 0) @@ -313,30 +298,25 @@ std::unique_ptr HiresTexture::Load(const std::string& base_filenam // Try loading DDS textures first, that way we maintain compression of DXT formats. // TODO: Reduce the number of open() calls here. We could use one fd. - Level level; - if (!LoadDDSTexture(level, filename_iter->second.path, mip_level)) + VideoCommon::CustomTextureData::Level level; + if (!LoadDDSTexture(&level, filename_iter->second.path, mip_level)) { - File::IOFile file; - file.Open(filename_iter->second.path, "rb"); - std::vector buffer(file.GetSize()); - file.ReadBytes(buffer.data(), file.GetSize()); - - if (!LoadTexture(level, buffer)) + if (!LoadPNGTexture(&level, filename_iter->second.path)) { ERROR_LOG_FMT(VIDEO, "Custom texture {} failed to load", filename); break; } } - ret->m_levels.push_back(std::move(level)); + ret->m_data.m_levels.push_back(std::move(level)); } // If we failed to load any mip levels, we can't use this texture at all. - if (ret->m_levels.empty()) + if (ret->m_data.m_levels.empty()) return nullptr; // Verify that the aspect ratio of the texture hasn't changed, as this could have side-effects. - const Level& first_mip = ret->m_levels[0]; + const VideoCommon::CustomTextureData::Level& first_mip = ret->m_data.m_levels[0]; if (first_mip.width * height != first_mip.height * width) { ERROR_LOG_FMT(VIDEO, @@ -357,14 +337,14 @@ std::unique_ptr HiresTexture::Load(const std::string& base_filenam // Verify that each mip level is the correct size (divide by 2 each time). u32 current_mip_width = first_mip.width; u32 current_mip_height = first_mip.height; - for (u32 mip_level = 1; mip_level < static_cast(ret->m_levels.size()); mip_level++) + for (u32 mip_level = 1; mip_level < static_cast(ret->m_data.m_levels.size()); mip_level++) { if (current_mip_width != 1 || current_mip_height != 1) { current_mip_width = std::max(current_mip_width / 2, 1u); current_mip_height = std::max(current_mip_height / 2, 1u); - const Level& level = ret->m_levels[mip_level]; + const VideoCommon::CustomTextureData::Level& level = ret->m_data.m_levels[mip_level]; if (current_mip_width == level.width && current_mip_height == level.height) continue; @@ -381,13 +361,15 @@ std::unique_ptr HiresTexture::Load(const std::string& base_filenam } // Drop this mip level and any others after it. - while (ret->m_levels.size() > mip_level) - ret->m_levels.pop_back(); + while (ret->m_data.m_levels.size() > mip_level) + ret->m_data.m_levels.pop_back(); } // All levels have to have the same format. - if (std::any_of(ret->m_levels.begin(), ret->m_levels.end(), - [&ret](const Level& l) { return l.format != ret->m_levels[0].format; })) + if (std::any_of(ret->m_data.m_levels.begin(), ret->m_data.m_levels.end(), + [&ret](const VideoCommon::CustomTextureData::Level& l) { + return l.format != ret->m_data.m_levels[0].format; + })) { ERROR_LOG_FMT(VIDEO, "Custom texture {} has inconsistent formats across mip levels.", first_mip_file.path); @@ -398,20 +380,6 @@ std::unique_ptr HiresTexture::Load(const std::string& base_filenam return ret; } -bool HiresTexture::LoadTexture(Level& level, const std::vector& buffer) -{ - if (!Common::LoadPNG(buffer, &level.data, &level.width, &level.height)) - return false; - - if (level.data.empty()) - return false; - - // Loaded PNG images are converted to RGBA. - level.format = AbstractTextureFormat::RGBA8; - level.row_length = level.width; - return true; -} - std::set GetTextureDirectoriesWithGameId(const std::string& root_directory, const std::string& game_id) { @@ -464,7 +432,7 @@ HiresTexture::~HiresTexture() AbstractTextureFormat HiresTexture::GetFormat() const { - return m_levels.at(0).format; + return m_data.m_levels.at(0).format; } bool HiresTexture::HasArbitraryMipmaps() const diff --git a/Source/Core/VideoCommon/HiresTextures.h b/Source/Core/VideoCommon/HiresTextures.h index bcd889e18c..2381d24bd6 100644 --- a/Source/Core/VideoCommon/HiresTextures.h +++ b/Source/Core/VideoCommon/HiresTextures.h @@ -9,6 +9,7 @@ #include #include "Common/CommonTypes.h" +#include "VideoCommon/GraphicsModSystem/Runtime/CustomTextureData.h" #include "VideoCommon/TextureConfig.h" #include "VideoCommon/TextureInfo.h" @@ -29,31 +30,21 @@ public: static std::string GenBaseName(const TextureInfo& texture_info, bool dump = false); - static u32 CalculateMipCount(u32 width, u32 height); - ~HiresTexture(); AbstractTextureFormat GetFormat() const; bool HasArbitraryMipmaps() const; - struct Level - { - std::vector data; - AbstractTextureFormat format = AbstractTextureFormat::RGBA8; - u32 width = 0; - u32 height = 0; - u32 row_length = 0; - }; - std::vector m_levels; + VideoCommon::CustomTextureData& GetData() { return m_data; } + const VideoCommon::CustomTextureData& GetData() const { return m_data; } private: static std::unique_ptr Load(const std::string& base_filename, u32 width, u32 height); - static bool LoadDDSTexture(HiresTexture* tex, const std::string& filename); - static bool LoadDDSTexture(Level& level, const std::string& filename, u32 mip_level); - static bool LoadTexture(Level& level, const std::vector& buffer); static void Prefetch(); HiresTexture() = default; + + VideoCommon::CustomTextureData m_data; bool m_has_arbitrary_mipmaps = false; }; diff --git a/Source/Core/VideoCommon/HiresTextures_DDSLoader.cpp b/Source/Core/VideoCommon/HiresTextures_DDSLoader.cpp deleted file mode 100644 index f3b2daf5eb..0000000000 --- a/Source/Core/VideoCommon/HiresTextures_DDSLoader.cpp +++ /dev/null @@ -1,498 +0,0 @@ -// Copyright 2017 Dolphin Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include "VideoCommon/HiresTextures.h" - -#include -#include -#include -#include -#include - -#include "Common/Align.h" -#include "Common/IOFile.h" -#include "Common/Logging/Log.h" -#include "Common/Swap.h" -#include "VideoCommon/VideoConfig.h" - -namespace -{ -// From https://raw.githubusercontent.com/Microsoft/DirectXTex/master/DirectXTex/DDS.h -// -// This header defines constants and structures that are useful when parsing -// DDS files. DDS files were originally designed to use several structures -// and constants that are native to DirectDraw and are defined in ddraw.h, -// such as DDSURFACEDESC2 and DDSCAPS2. This file defines similar -// (compatible) constants and structures so that one can use DDS files -// without needing to include ddraw.h. -// -// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF -// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO -// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A -// PARTICULAR PURPOSE. -// -// Copyright (c) Microsoft Corporation. All rights reserved. -// -// http://go.microsoft.com/fwlink/?LinkId=248926 - -#pragma pack(push, 1) - -const uint32_t DDS_MAGIC = 0x20534444; // "DDS " - -struct DDS_PIXELFORMAT -{ - uint32_t dwSize; - uint32_t dwFlags; - uint32_t dwFourCC; - uint32_t dwRGBBitCount; - uint32_t dwRBitMask; - uint32_t dwGBitMask; - uint32_t dwBBitMask; - uint32_t dwABitMask; -}; - -#define DDS_FOURCC 0x00000004 // DDPF_FOURCC -#define DDS_RGB 0x00000040 // DDPF_RGB -#define DDS_RGBA 0x00000041 // DDPF_RGB | DDPF_ALPHAPIXELS -#define DDS_LUMINANCE 0x00020000 // DDPF_LUMINANCE -#define DDS_LUMINANCEA 0x00020001 // DDPF_LUMINANCE | DDPF_ALPHAPIXELS -#define DDS_ALPHA 0x00000002 // DDPF_ALPHA -#define DDS_PAL8 0x00000020 // DDPF_PALETTEINDEXED8 -#define DDS_PAL8A 0x00000021 // DDPF_PALETTEINDEXED8 | DDPF_ALPHAPIXELS -#define DDS_BUMPDUDV 0x00080000 // DDPF_BUMPDUDV - -#ifndef MAKEFOURCC -#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ - ((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | ((uint32_t)(uint8_t)(ch2) << 16) | \ - ((uint32_t)(uint8_t)(ch3) << 24)) -#endif /* defined(MAKEFOURCC) */ - -#define DDS_HEADER_FLAGS_TEXTURE \ - 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT -#define DDS_HEADER_FLAGS_MIPMAP 0x00020000 // DDSD_MIPMAPCOUNT -#define DDS_HEADER_FLAGS_VOLUME 0x00800000 // DDSD_DEPTH -#define DDS_HEADER_FLAGS_PITCH 0x00000008 // DDSD_PITCH -#define DDS_HEADER_FLAGS_LINEARSIZE 0x00080000 // DDSD_LINEARSIZE - -// Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION -enum DDS_RESOURCE_DIMENSION -{ - DDS_DIMENSION_TEXTURE1D = 2, - DDS_DIMENSION_TEXTURE2D = 3, - DDS_DIMENSION_TEXTURE3D = 4, -}; - -struct DDS_HEADER -{ - uint32_t dwSize; - uint32_t dwFlags; - uint32_t dwHeight; - uint32_t dwWidth; - uint32_t dwPitchOrLinearSize; - uint32_t dwDepth; // only if DDS_HEADER_FLAGS_VOLUME is set in dwFlags - uint32_t dwMipMapCount; - uint32_t dwReserved1[11]; - DDS_PIXELFORMAT ddspf; - uint32_t dwCaps; - uint32_t dwCaps2; - uint32_t dwCaps3; - uint32_t dwCaps4; - uint32_t dwReserved2; -}; - -struct DDS_HEADER_DXT10 -{ - uint32_t dxgiFormat; - uint32_t resourceDimension; - uint32_t miscFlag; // see DDS_RESOURCE_MISC_FLAG - uint32_t arraySize; - uint32_t miscFlags2; // see DDS_MISC_FLAGS2 -}; - -#pragma pack(pop) - -static_assert(sizeof(DDS_HEADER) == 124, "DDS Header size mismatch"); -static_assert(sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch"); - -constexpr DDS_PIXELFORMAT DDSPF_A8R8G8B8 = { - sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000}; -constexpr DDS_PIXELFORMAT DDSPF_X8R8G8B8 = { - sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000}; -constexpr DDS_PIXELFORMAT DDSPF_A8B8G8R8 = { - sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000}; -constexpr DDS_PIXELFORMAT DDSPF_X8B8G8R8 = { - sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000}; -constexpr DDS_PIXELFORMAT DDSPF_R8G8B8 = { - sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 24, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000}; - -// End of Microsoft code from DDS.h. - -bool DDSPixelFormatMatches(const DDS_PIXELFORMAT& pf1, const DDS_PIXELFORMAT& pf2) -{ - return std::tie(pf1.dwSize, pf1.dwFlags, pf1.dwFourCC, pf1.dwRGBBitCount, pf1.dwRBitMask, - pf1.dwGBitMask, pf1.dwGBitMask, pf1.dwBBitMask, pf1.dwABitMask) == - std::tie(pf2.dwSize, pf2.dwFlags, pf2.dwFourCC, pf2.dwRGBBitCount, pf2.dwRBitMask, - pf2.dwGBitMask, pf2.dwGBitMask, pf2.dwBBitMask, pf2.dwABitMask); -} - -struct DDSLoadInfo -{ - u32 block_size = 1; - u32 bytes_per_block = 4; - u32 width = 0; - u32 height = 0; - u32 mip_count = 0; - AbstractTextureFormat format = AbstractTextureFormat::RGBA8; - size_t first_mip_offset = 0; - size_t first_mip_size = 0; - u32 first_mip_row_length = 0; - - std::function conversion_function; -}; - -u32 GetBlockCount(u32 extent, u32 block_size) -{ - return std::max(Common::AlignUp(extent, block_size) / block_size, 1u); -} - -void ConvertTexture_X8B8G8R8(HiresTexture::Level* level) -{ - u8* data_ptr = level->data.data(); - for (u32 row = 0; row < level->height; row++) - { - for (u32 x = 0; x < level->row_length; x++) - { - // Set alpha channel to full intensity. - data_ptr[3] = 0xFF; - data_ptr += sizeof(u32); - } - } -} - -void ConvertTexture_A8R8G8B8(HiresTexture::Level* level) -{ - u8* data_ptr = level->data.data(); - for (u32 row = 0; row < level->height; row++) - { - for (u32 x = 0; x < level->row_length; x++) - { - // Byte swap ABGR -> RGBA - u32 val; - std::memcpy(&val, data_ptr, sizeof(val)); - val = ((val & 0xFF00FF00) | ((val >> 16) & 0xFF) | ((val << 16) & 0xFF0000)); - std::memcpy(data_ptr, &val, sizeof(u32)); - data_ptr += sizeof(u32); - } - } -} - -void ConvertTexture_X8R8G8B8(HiresTexture::Level* level) -{ - u8* data_ptr = level->data.data(); - for (u32 row = 0; row < level->height; row++) - { - for (u32 x = 0; x < level->row_length; x++) - { - // Byte swap XBGR -> RGBX, and set alpha to full intensity. - u32 val; - std::memcpy(&val, data_ptr, sizeof(val)); - val = ((val & 0x0000FF00) | ((val >> 16) & 0xFF) | ((val << 16) & 0xFF0000)) | 0xFF000000; - std::memcpy(data_ptr, &val, sizeof(u32)); - data_ptr += sizeof(u32); - } - } -} - -void ConvertTexture_R8G8B8(HiresTexture::Level* level) -{ - std::vector new_data(level->row_length * level->height * sizeof(u32)); - - const u8* rgb_data_ptr = level->data.data(); - u8* data_ptr = new_data.data(); - - for (u32 row = 0; row < level->height; row++) - { - for (u32 x = 0; x < level->row_length; x++) - { - // This is BGR in memory. - u32 val; - std::memcpy(&val, rgb_data_ptr, sizeof(val)); - val = ((val & 0x0000FF00) | ((val >> 16) & 0xFF) | ((val << 16) & 0xFF0000)) | 0xFF000000; - std::memcpy(data_ptr, &val, sizeof(u32)); - data_ptr += sizeof(u32); - rgb_data_ptr += 3; - } - } - - level->data = std::move(new_data); -} - -bool ParseDDSHeader(File::IOFile& file, DDSLoadInfo* info) -{ - // Exit as early as possible for non-DDS textures, since all extensions are currently - // passed through this function. - u32 magic; - if (!file.ReadBytes(&magic, sizeof(magic)) || magic != DDS_MAGIC) - return false; - - DDS_HEADER header; - size_t header_size = sizeof(header); - if (!file.ReadBytes(&header, header_size) || header.dwSize < header_size) - return false; - - // Required fields. - if ((header.dwFlags & DDS_HEADER_FLAGS_TEXTURE) != DDS_HEADER_FLAGS_TEXTURE) - return false; - - // Image should be 2D. - if (header.dwFlags & DDS_HEADER_FLAGS_VOLUME) - return false; - - // Presence of width/height fields is already tested by DDS_HEADER_FLAGS_TEXTURE. - info->width = header.dwWidth; - info->height = header.dwHeight; - if (info->width == 0 || info->height == 0) - return false; - - // Check for mip levels. - if (header.dwFlags & DDS_HEADER_FLAGS_MIPMAP) - { - info->mip_count = header.dwMipMapCount; - if (header.dwMipMapCount != 0) - info->mip_count = header.dwMipMapCount; - else - info->mip_count = HiresTexture::CalculateMipCount(info->width, info->height); - } - else - { - info->mip_count = 1; - } - - // Handle fourcc formats vs uncompressed formats. - bool has_fourcc = (header.ddspf.dwFlags & DDS_FOURCC) != 0; - bool needs_s3tc = false; - if (has_fourcc) - { - // Handle DX10 extension header. - u32 dxt10_format = 0; - if (header.ddspf.dwFourCC == MAKEFOURCC('D', 'X', '1', '0')) - { - DDS_HEADER_DXT10 dxt10_header; - if (!file.ReadBytes(&dxt10_header, sizeof(dxt10_header))) - return false; - - // Can't handle array textures here. Doesn't make sense to use them, anyway. - if (dxt10_header.resourceDimension != DDS_DIMENSION_TEXTURE2D || dxt10_header.arraySize != 1) - return false; - - header_size += sizeof(dxt10_header); - dxt10_format = dxt10_header.dxgiFormat; - } - - // Currently, we only handle compressed textures here, and leave the rest to the SOIL loader. - // In the future, this could be extended, but these isn't much benefit in doing so currently. - if (header.ddspf.dwFourCC == MAKEFOURCC('D', 'X', 'T', '1') || dxt10_format == 71) - { - info->format = AbstractTextureFormat::DXT1; - info->block_size = 4; - info->bytes_per_block = 8; - needs_s3tc = true; - } - else if (header.ddspf.dwFourCC == MAKEFOURCC('D', 'X', 'T', '3') || dxt10_format == 74) - { - info->format = AbstractTextureFormat::DXT3; - info->block_size = 4; - info->bytes_per_block = 16; - needs_s3tc = true; - } - else if (header.ddspf.dwFourCC == MAKEFOURCC('D', 'X', 'T', '5') || dxt10_format == 77) - { - info->format = AbstractTextureFormat::DXT5; - info->block_size = 4; - info->bytes_per_block = 16; - needs_s3tc = true; - } - else if (dxt10_format == 98) - { - info->format = AbstractTextureFormat::BPTC; - info->block_size = 4; - info->bytes_per_block = 16; - if (!g_ActiveConfig.backend_info.bSupportsBPTCTextures) - return false; - } - else - { - // Leave all remaining formats to SOIL. - return false; - } - } - else - { - if (DDSPixelFormatMatches(header.ddspf, DDSPF_A8R8G8B8)) - { - info->conversion_function = ConvertTexture_A8R8G8B8; - } - else if (DDSPixelFormatMatches(header.ddspf, DDSPF_X8R8G8B8)) - { - info->conversion_function = ConvertTexture_X8R8G8B8; - } - else if (DDSPixelFormatMatches(header.ddspf, DDSPF_X8B8G8R8)) - { - info->conversion_function = ConvertTexture_X8B8G8R8; - } - else if (DDSPixelFormatMatches(header.ddspf, DDSPF_R8G8B8)) - { - info->conversion_function = ConvertTexture_R8G8B8; - } - else if (DDSPixelFormatMatches(header.ddspf, DDSPF_A8B8G8R8)) - { - // This format is already in RGBA order, so no conversion necessary. - } - else - { - return false; - } - - // All these formats are RGBA, just with byte swapping. - info->format = AbstractTextureFormat::RGBA8; - info->block_size = 1; - info->bytes_per_block = header.ddspf.dwRGBBitCount / 8; - } - - // We also need to ensure the backend supports these formats natively before loading them, - // otherwise, fallback to SOIL, which will decompress them to RGBA. - if (needs_s3tc && !g_ActiveConfig.backend_info.bSupportsST3CTextures) - return false; - - // Mip levels smaller than the block size are padded to multiples of the block size. - u32 blocks_wide = GetBlockCount(info->width, info->block_size); - u32 blocks_high = GetBlockCount(info->height, info->block_size); - - // Pitch can be specified in the header, otherwise we can derive it from the dimensions. For - // compressed formats, both DDS_HEADER_FLAGS_LINEARSIZE and DDS_HEADER_FLAGS_PITCH should be - // set. See https://msdn.microsoft.com/en-us/library/windows/desktop/bb943982(v=vs.85).aspx - if (header.dwFlags & DDS_HEADER_FLAGS_PITCH && header.dwFlags & DDS_HEADER_FLAGS_LINEARSIZE) - { - // Convert pitch (in bytes) to texels/row length. - if (header.dwPitchOrLinearSize < info->bytes_per_block) - { - // Likely a corrupted or invalid file. - return false; - } - - info->first_mip_row_length = - std::max(header.dwPitchOrLinearSize / info->bytes_per_block, 1u) * info->block_size; - info->first_mip_size = static_cast(info->first_mip_row_length / info->block_size) * - info->block_size * blocks_high; - } - else - { - // Assume no padding between rows of blocks. - info->first_mip_row_length = blocks_wide * info->block_size; - info->first_mip_size = blocks_wide * static_cast(info->bytes_per_block) * blocks_high; - } - - // Check for truncated or corrupted files. - info->first_mip_offset = sizeof(magic) + header_size; - if (info->first_mip_offset >= file.GetSize()) - return false; - - return true; -} - -bool ReadMipLevel(HiresTexture::Level* level, File::IOFile& file, const std::string& filename, - u32 mip_level, const DDSLoadInfo& info, u32 width, u32 height, u32 row_length, - size_t size) -{ - // D3D11 cannot handle block compressed textures where the first mip level is - // not a multiple of the block size. - if (mip_level == 0 && info.block_size > 1 && - ((width % info.block_size) != 0 || (height % info.block_size) != 0)) - { - ERROR_LOG_FMT(VIDEO, - "Invalid dimensions for DDS texture {}. For compressed textures of this format, " - "the width/height of the first mip level must be a multiple of {}.", - filename, info.block_size); - return false; - } - - // Copy to the final storage location. - level->width = width; - level->height = height; - level->format = info.format; - level->row_length = row_length; - level->data.resize(size); - if (!file.ReadBytes(level->data.data(), level->data.size())) - return false; - - // Apply conversion function for uncompressed textures. - if (info.conversion_function) - info.conversion_function(level); - - return true; -} - -} // namespace - -bool HiresTexture::LoadDDSTexture(HiresTexture* tex, const std::string& filename) -{ - File::IOFile file; - file.Open(filename, "rb"); - if (!file.IsOpen()) - return false; - - DDSLoadInfo info; - if (!ParseDDSHeader(file, &info)) - return false; - - // Read first mip level, as it may have a custom pitch. - Level first_level; - if (!file.Seek(info.first_mip_offset, File::SeekOrigin::Begin) || - !ReadMipLevel(&first_level, file, filename, 0, info, info.width, info.height, - info.first_mip_row_length, info.first_mip_size)) - { - return false; - } - - tex->m_levels.push_back(std::move(first_level)); - - // Read in any remaining mip levels in the file. - // If the .dds file does not contain a full mip chain, we'll fall back to the old path. - u32 mip_width = info.width; - u32 mip_height = info.height; - for (u32 i = 1; i < info.mip_count; i++) - { - mip_width = std::max(mip_width / 2, 1u); - mip_height = std::max(mip_height / 2, 1u); - - // Pitch can't be specified with each mip level, so we have to calculate it ourselves. - u32 blocks_wide = GetBlockCount(mip_width, info.block_size); - u32 blocks_high = GetBlockCount(mip_height, info.block_size); - u32 mip_row_length = blocks_wide * info.block_size; - size_t mip_size = blocks_wide * static_cast(info.bytes_per_block) * blocks_high; - Level level; - if (!ReadMipLevel(&level, file, filename, i, info, mip_width, mip_height, mip_row_length, - mip_size)) - break; - - tex->m_levels.push_back(std::move(level)); - } - - return true; -} - -bool HiresTexture::LoadDDSTexture(Level& level, const std::string& filename, u32 mip_level) -{ - // Only loading a single mip level. - File::IOFile file; - file.Open(filename, "rb"); - if (!file.IsOpen()) - return false; - - DDSLoadInfo info; - if (!ParseDDSHeader(file, &info)) - return false; - - return ReadMipLevel(&level, file, filename, mip_level, info, info.width, info.height, - info.first_mip_row_length, info.first_mip_size); -} diff --git a/Source/Core/VideoCommon/TextureCacheBase.cpp b/Source/Core/VideoCommon/TextureCacheBase.cpp index 8b5e56af37..6d138d5912 100644 --- a/Source/Core/VideoCommon/TextureCacheBase.cpp +++ b/Source/Core/VideoCommon/TextureCacheBase.cpp @@ -1594,7 +1594,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp if (hires_tex) { - const auto& level = hires_tex->m_levels[0]; + const auto& level = hires_tex->GetData().m_levels[0]; if (level.width != width || level.height != height) { width = level.width; @@ -1612,7 +1612,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp #endif // how many levels the allocated texture shall have const u32 texLevels = no_mips ? 1 : - hires_tex ? (u32)hires_tex->m_levels.size() : + hires_tex ? (u32)hires_tex->GetData().m_levels.size() : texture_info.GetLevelCount(); // We can decode on the GPU if it is a supported format and the flag is enabled. @@ -1634,7 +1634,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp ArbitraryMipmapDetector arbitrary_mip_detector; if (hires_tex) { - const auto& level = hires_tex->m_levels[0]; + const auto& level = hires_tex->GetData().m_levels[0]; entry->texture->Load(0, level.width, level.height, level.row_length, level.data.data(), level.data.size()); } @@ -1719,7 +1719,7 @@ RcTcacheEntry TextureCacheBase::GetTexture(const int textureCacheSafetyColorSamp { for (u32 level_index = 1; level_index != texLevels; ++level_index) { - const auto& level = hires_tex->m_levels[level_index]; + const auto& level = hires_tex->GetData().m_levels[level_index]; entry->texture->Load(level_index, level.width, level.height, level.row_length, level.data.data(), level.data.size()); }