mirror of
https://github.com/sal063/AC6_recomp
synced 2026-06-15 06:31:24 -04:00
salh
700 lines
24 KiB
C++
700 lines
24 KiB
C++
#include "ac6_texture_overrides.h"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <sstream>
|
|
#include <system_error>
|
|
#include <utility>
|
|
|
|
#include <rex/cvar.h>
|
|
#include <rex/filesystem.h>
|
|
|
|
REXCVAR_DECLARE(std::string, user_data_root);
|
|
|
|
REXCVAR_DEFINE_BOOL(ac6_texture_swaps_enabled, true, "AC6/TextureSwaps",
|
|
"Enable AC6 texture dump and replacement support");
|
|
REXCVAR_DEFINE_BOOL(ac6_texture_swaps_dump_enabled, true, "AC6/TextureSwaps",
|
|
"Dump host-ready textures to the user-data texture dump folder");
|
|
REXCVAR_DEFINE_BOOL(ac6_texture_swaps_replace_enabled, true, "AC6/TextureSwaps",
|
|
"Load matching replacement DDS files from the user-data texture override folders");
|
|
REXCVAR_DEFINE_STRING(ac6_texture_swaps_dump_dir, "texture_dumps", "AC6/TextureSwaps",
|
|
"User-data subdirectory that stores dumped texture DDS files and metadata");
|
|
REXCVAR_DEFINE_STRING(ac6_texture_swaps_override_dir, "override/textures", "AC6/TextureSwaps",
|
|
"User-data subdirectory that stores loose replacement texture DDS files");
|
|
REXCVAR_DEFINE_STRING(ac6_texture_swaps_mods_dir, "mods", "AC6/TextureSwaps",
|
|
"User-data subdirectory containing mod folders with texture overrides");
|
|
|
|
namespace ac6::textures {
|
|
namespace {
|
|
|
|
constexpr uint32_t kDdsMagic = 0x20534444u;
|
|
constexpr uint32_t kDdsFourCcDx10 = 0x30315844u;
|
|
constexpr uint32_t kDdsHeaderFlagsTexture = 0x00001007u;
|
|
constexpr uint32_t kDdsHeaderFlagsPitch = 0x00000008u;
|
|
constexpr uint32_t kDdsHeaderFlagsLinearSize = 0x00080000u;
|
|
constexpr uint32_t kDdsHeaderFlagsMipmap = 0x00020000u;
|
|
constexpr uint32_t kDdsHeaderFlagsDepth = 0x00800000u;
|
|
constexpr uint32_t kDdsCapsTexture = 0x00001000u;
|
|
constexpr uint32_t kDdsCapsComplex = 0x00000008u;
|
|
constexpr uint32_t kDdsCapsMipmap = 0x00400000u;
|
|
constexpr uint32_t kDdsCaps2Volume = 0x00200000u;
|
|
constexpr uint32_t kDdsPixelFormatFlagsFourCc = 0x00000004u;
|
|
constexpr uint32_t kDdsResourceDimensionTexture1D = 2u;
|
|
constexpr uint32_t kDdsResourceDimensionTexture2D = 3u;
|
|
constexpr uint32_t kDdsResourceDimensionTexture3D = 4u;
|
|
constexpr uint32_t kDdsResourceMiscTextureCube = 0x4u;
|
|
|
|
#pragma pack(push, 1)
|
|
struct DdsPixelFormat {
|
|
uint32_t size;
|
|
uint32_t flags;
|
|
uint32_t four_cc;
|
|
uint32_t rgb_bit_count;
|
|
uint32_t r_bit_mask;
|
|
uint32_t g_bit_mask;
|
|
uint32_t b_bit_mask;
|
|
uint32_t a_bit_mask;
|
|
};
|
|
|
|
struct DdsHeader {
|
|
uint32_t size;
|
|
uint32_t flags;
|
|
uint32_t height;
|
|
uint32_t width;
|
|
uint32_t pitch_or_linear_size;
|
|
uint32_t depth;
|
|
uint32_t mip_map_count;
|
|
uint32_t reserved1[11];
|
|
DdsPixelFormat pixel_format;
|
|
uint32_t caps;
|
|
uint32_t caps2;
|
|
uint32_t caps3;
|
|
uint32_t caps4;
|
|
uint32_t reserved2;
|
|
};
|
|
|
|
struct DdsHeaderDx10 {
|
|
uint32_t dxgi_format;
|
|
uint32_t resource_dimension;
|
|
uint32_t misc_flag;
|
|
uint32_t array_size;
|
|
uint32_t misc_flags2;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
struct DxgiLayoutInfo {
|
|
uint32_t block_width;
|
|
uint32_t block_height;
|
|
uint32_t bytes_per_block;
|
|
const char* name;
|
|
};
|
|
|
|
std::filesystem::path GetUserDataRoot() {
|
|
const std::string user_root = REXCVAR_GET(user_data_root);
|
|
if (!user_root.empty()) {
|
|
return std::filesystem::path(user_root);
|
|
}
|
|
return rex::filesystem::GetUserFolder() / "ac6recomp";
|
|
}
|
|
|
|
bool EnsureParentExists(const std::filesystem::path& path, std::string* error_out) {
|
|
std::error_code ec;
|
|
std::filesystem::create_directories(path.parent_path(), ec);
|
|
if (ec) {
|
|
if (error_out) {
|
|
*error_out = "failed to create parent directory: " + ec.message();
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::string EscapeJson(std::string_view value) {
|
|
std::string escaped;
|
|
escaped.reserve(value.size());
|
|
for (char c : value) {
|
|
switch (c) {
|
|
case '\\':
|
|
escaped += "\\\\";
|
|
break;
|
|
case '"':
|
|
escaped += "\\\"";
|
|
break;
|
|
case '\n':
|
|
escaped += "\\n";
|
|
break;
|
|
case '\r':
|
|
escaped += "\\r";
|
|
break;
|
|
case '\t':
|
|
escaped += "\\t";
|
|
break;
|
|
default:
|
|
escaped.push_back(c);
|
|
break;
|
|
}
|
|
}
|
|
return escaped;
|
|
}
|
|
|
|
std::string HexU32(uint32_t value) {
|
|
std::ostringstream stream;
|
|
stream << std::uppercase << std::hex << std::setw(8) << std::setfill('0') << value;
|
|
return stream.str();
|
|
}
|
|
|
|
std::string HexU64(uint64_t value) {
|
|
std::ostringstream stream;
|
|
stream << std::uppercase << std::hex << std::setw(16) << std::setfill('0') << value;
|
|
return stream.str();
|
|
}
|
|
|
|
const char* DimensionTag(uint32_t dimension) {
|
|
if (dimension == 0 || dimension == uint32_t(D3D12_RESOURCE_DIMENSION_TEXTURE1D)) {
|
|
return "1d";
|
|
}
|
|
if (dimension == 1 || dimension == uint32_t(D3D12_RESOURCE_DIMENSION_TEXTURE2D)) {
|
|
return "2d";
|
|
}
|
|
if (dimension == 2 || dimension == uint32_t(D3D12_RESOURCE_DIMENSION_TEXTURE3D)) {
|
|
return "3d";
|
|
}
|
|
if (dimension == 3) {
|
|
return "cube";
|
|
}
|
|
return "unknown";
|
|
}
|
|
|
|
bool GetDxgiLayoutInfo(DXGI_FORMAT format, DxgiLayoutInfo& out) {
|
|
switch (format) {
|
|
case DXGI_FORMAT_R8_TYPELESS:
|
|
case DXGI_FORMAT_R8_UNORM:
|
|
case DXGI_FORMAT_R8_SNORM:
|
|
case DXGI_FORMAT_R8_UINT:
|
|
case DXGI_FORMAT_R8_SINT:
|
|
out = {1, 1, 1, "DXGI_FORMAT_R8"};
|
|
return true;
|
|
case DXGI_FORMAT_R8G8_TYPELESS:
|
|
case DXGI_FORMAT_R8G8_UNORM:
|
|
case DXGI_FORMAT_R8G8_SNORM:
|
|
case DXGI_FORMAT_R8G8_UINT:
|
|
case DXGI_FORMAT_R8G8_SINT:
|
|
out = {1, 1, 2, "DXGI_FORMAT_R8G8"};
|
|
return true;
|
|
case DXGI_FORMAT_R8G8B8A8_TYPELESS:
|
|
case DXGI_FORMAT_R8G8B8A8_UNORM:
|
|
case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
|
|
case DXGI_FORMAT_R8G8B8A8_SNORM:
|
|
case DXGI_FORMAT_R8G8B8A8_UINT:
|
|
case DXGI_FORMAT_R8G8B8A8_SINT:
|
|
case DXGI_FORMAT_B8G8R8A8_UNORM:
|
|
case DXGI_FORMAT_B8G8R8X8_UNORM:
|
|
out = {1, 1, 4, "DXGI_FORMAT_R8G8B8A8"};
|
|
return true;
|
|
case DXGI_FORMAT_R10G10B10A2_TYPELESS:
|
|
case DXGI_FORMAT_R10G10B10A2_UNORM:
|
|
case DXGI_FORMAT_R10G10B10A2_UINT:
|
|
out = {1, 1, 4, "DXGI_FORMAT_R10G10B10A2"};
|
|
return true;
|
|
case DXGI_FORMAT_B5G6R5_UNORM:
|
|
out = {1, 1, 2, "DXGI_FORMAT_B5G6R5_UNORM"};
|
|
return true;
|
|
case DXGI_FORMAT_B5G5R5A1_UNORM:
|
|
out = {1, 1, 2, "DXGI_FORMAT_B5G5R5A1_UNORM"};
|
|
return true;
|
|
case DXGI_FORMAT_B4G4R4A4_UNORM:
|
|
out = {1, 1, 2, "DXGI_FORMAT_B4G4R4A4_UNORM"};
|
|
return true;
|
|
case DXGI_FORMAT_R16_TYPELESS:
|
|
case DXGI_FORMAT_R16_UNORM:
|
|
case DXGI_FORMAT_R16_SNORM:
|
|
case DXGI_FORMAT_R16_UINT:
|
|
case DXGI_FORMAT_R16_SINT:
|
|
case DXGI_FORMAT_R16_FLOAT:
|
|
out = {1, 1, 2, "DXGI_FORMAT_R16"};
|
|
return true;
|
|
case DXGI_FORMAT_R16G16_TYPELESS:
|
|
case DXGI_FORMAT_R16G16_UNORM:
|
|
case DXGI_FORMAT_R16G16_SNORM:
|
|
case DXGI_FORMAT_R16G16_UINT:
|
|
case DXGI_FORMAT_R16G16_SINT:
|
|
case DXGI_FORMAT_R16G16_FLOAT:
|
|
out = {1, 1, 4, "DXGI_FORMAT_R16G16"};
|
|
return true;
|
|
case DXGI_FORMAT_R16G16B16A16_TYPELESS:
|
|
case DXGI_FORMAT_R16G16B16A16_UNORM:
|
|
case DXGI_FORMAT_R16G16B16A16_SNORM:
|
|
case DXGI_FORMAT_R16G16B16A16_UINT:
|
|
case DXGI_FORMAT_R16G16B16A16_SINT:
|
|
case DXGI_FORMAT_R16G16B16A16_FLOAT:
|
|
out = {1, 1, 8, "DXGI_FORMAT_R16G16B16A16"};
|
|
return true;
|
|
case DXGI_FORMAT_R32_TYPELESS:
|
|
case DXGI_FORMAT_R32_FLOAT:
|
|
case DXGI_FORMAT_R32_UINT:
|
|
case DXGI_FORMAT_R32_SINT:
|
|
out = {1, 1, 4, "DXGI_FORMAT_R32"};
|
|
return true;
|
|
case DXGI_FORMAT_R32G32_TYPELESS:
|
|
case DXGI_FORMAT_R32G32_FLOAT:
|
|
case DXGI_FORMAT_R32G32_UINT:
|
|
case DXGI_FORMAT_R32G32_SINT:
|
|
out = {1, 1, 8, "DXGI_FORMAT_R32G32"};
|
|
return true;
|
|
case DXGI_FORMAT_R32G32B32A32_FLOAT:
|
|
case DXGI_FORMAT_R32G32B32A32_UINT:
|
|
case DXGI_FORMAT_R32G32B32A32_SINT:
|
|
out = {1, 1, 16, "DXGI_FORMAT_R32G32B32A32"};
|
|
return true;
|
|
case DXGI_FORMAT_BC1_TYPELESS:
|
|
case DXGI_FORMAT_BC1_UNORM:
|
|
case DXGI_FORMAT_BC1_UNORM_SRGB:
|
|
out = {4, 4, 8, "DXGI_FORMAT_BC1"};
|
|
return true;
|
|
case DXGI_FORMAT_BC2_TYPELESS:
|
|
case DXGI_FORMAT_BC2_UNORM:
|
|
case DXGI_FORMAT_BC2_UNORM_SRGB:
|
|
out = {4, 4, 16, "DXGI_FORMAT_BC2"};
|
|
return true;
|
|
case DXGI_FORMAT_BC3_TYPELESS:
|
|
case DXGI_FORMAT_BC3_UNORM:
|
|
case DXGI_FORMAT_BC3_UNORM_SRGB:
|
|
out = {4, 4, 16, "DXGI_FORMAT_BC3"};
|
|
return true;
|
|
case DXGI_FORMAT_BC4_TYPELESS:
|
|
case DXGI_FORMAT_BC4_UNORM:
|
|
case DXGI_FORMAT_BC4_SNORM:
|
|
out = {4, 4, 8, "DXGI_FORMAT_BC4"};
|
|
return true;
|
|
case DXGI_FORMAT_BC5_TYPELESS:
|
|
case DXGI_FORMAT_BC5_UNORM:
|
|
case DXGI_FORMAT_BC5_SNORM:
|
|
out = {4, 4, 16, "DXGI_FORMAT_BC5"};
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
uint32_t ComputeSubresourceCount(D3D12_RESOURCE_DIMENSION dimension, uint32_t depth_or_array_size,
|
|
uint32_t mip_count) {
|
|
return dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? mip_count
|
|
: depth_or_array_size * mip_count;
|
|
}
|
|
|
|
bool MapDdsDimension(uint32_t dds_dimension, D3D12_RESOURCE_DIMENSION& out) {
|
|
switch (dds_dimension) {
|
|
case kDdsResourceDimensionTexture1D:
|
|
out = D3D12_RESOURCE_DIMENSION_TEXTURE1D;
|
|
return true;
|
|
case kDdsResourceDimensionTexture2D:
|
|
out = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
|
|
return true;
|
|
case kDdsResourceDimensionTexture3D:
|
|
out = D3D12_RESOURCE_DIMENSION_TEXTURE3D;
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
uint32_t ToDdsDimension(D3D12_RESOURCE_DIMENSION dimension) {
|
|
switch (dimension) {
|
|
case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
|
|
return kDdsResourceDimensionTexture1D;
|
|
case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
|
|
return kDdsResourceDimensionTexture3D;
|
|
case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
|
|
default:
|
|
return kDdsResourceDimensionTexture2D;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool TextureSwapsEnabled() {
|
|
return REXCVAR_GET(ac6_texture_swaps_enabled);
|
|
}
|
|
|
|
bool TextureDumpEnabled() {
|
|
return TextureSwapsEnabled() && REXCVAR_GET(ac6_texture_swaps_dump_enabled);
|
|
}
|
|
|
|
bool TextureReplacementEnabled() {
|
|
return TextureSwapsEnabled() && REXCVAR_GET(ac6_texture_swaps_replace_enabled);
|
|
}
|
|
|
|
bool IsSupportedTextureSwapFormat(DXGI_FORMAT format) {
|
|
DxgiLayoutInfo layout = {};
|
|
return GetDxgiLayoutInfo(format, layout);
|
|
}
|
|
|
|
bool GetTightTextureSubresourceLayout(DXGI_FORMAT format, uint32_t width, uint32_t height,
|
|
TextureSubresourceLayout& out) {
|
|
DxgiLayoutInfo info = {};
|
|
if (!GetDxgiLayoutInfo(format, info)) {
|
|
return false;
|
|
}
|
|
const uint32_t width_blocks = std::max((width + info.block_width - 1) / info.block_width, 1u);
|
|
const uint32_t height_blocks = std::max((height + info.block_height - 1) / info.block_height, 1u);
|
|
out.row_pitch = width_blocks * info.bytes_per_block;
|
|
out.row_count = height_blocks;
|
|
out.slice_pitch = out.row_pitch * out.row_count;
|
|
return true;
|
|
}
|
|
|
|
std::string DescribeDxgiFormat(DXGI_FORMAT format) {
|
|
DxgiLayoutInfo layout = {};
|
|
if (GetDxgiLayoutInfo(format, layout)) {
|
|
return layout.name;
|
|
}
|
|
std::ostringstream stream;
|
|
stream << "DXGI_FORMAT_" << uint32_t(format);
|
|
return stream.str();
|
|
}
|
|
|
|
std::string BuildTextureStableKey(uint64_t texture_key_hash, uint32_t base_page, uint32_t mip_page,
|
|
uint32_t dimension, uint32_t width, uint32_t height,
|
|
uint32_t depth_or_array_size, uint32_t mip_count,
|
|
uint32_t guest_format, uint32_t endianness, bool tiled,
|
|
bool packed_mips, bool signed_separate, bool scaled_resolve) {
|
|
std::ostringstream stream;
|
|
stream << "tex_" << HexU64(texture_key_hash) << "_bp" << HexU32(base_page) << "_mp"
|
|
<< HexU32(mip_page) << "_" << DimensionTag(dimension) << "_" << width << "x" << height
|
|
<< "x" << depth_or_array_size << "_m" << mip_count << "_fmt" << guest_format << "_e"
|
|
<< endianness << "_t" << (tiled ? 1 : 0) << "_p" << (packed_mips ? 1 : 0) << "_s"
|
|
<< (signed_separate ? 1 : 0) << "_r" << (scaled_resolve ? 1 : 0);
|
|
return stream.str();
|
|
}
|
|
|
|
std::filesystem::path GetTextureDumpDdsPath(std::string_view stable_key) {
|
|
return GetUserDataRoot() / REXCVAR_GET(ac6_texture_swaps_dump_dir) /
|
|
(std::string(stable_key) + ".dds");
|
|
}
|
|
|
|
std::filesystem::path GetTextureDumpMetadataPath(std::string_view stable_key) {
|
|
return GetUserDataRoot() / REXCVAR_GET(ac6_texture_swaps_dump_dir) /
|
|
(std::string(stable_key) + ".json");
|
|
}
|
|
|
|
bool DumpExists(std::string_view stable_key) {
|
|
std::error_code ec;
|
|
return std::filesystem::exists(GetTextureDumpDdsPath(stable_key), ec);
|
|
}
|
|
|
|
std::optional<std::filesystem::path> ResolveReplacementDdsPath(std::string_view stable_key) {
|
|
if (!TextureReplacementEnabled()) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
const std::filesystem::path user_root = GetUserDataRoot();
|
|
const std::filesystem::path file_name = std::string(stable_key) + ".dds";
|
|
std::error_code ec;
|
|
|
|
const std::filesystem::path loose_path =
|
|
user_root / REXCVAR_GET(ac6_texture_swaps_override_dir) / file_name;
|
|
if (std::filesystem::exists(loose_path, ec)) {
|
|
return loose_path;
|
|
}
|
|
|
|
const std::filesystem::path mods_root = user_root / REXCVAR_GET(ac6_texture_swaps_mods_dir);
|
|
if (!std::filesystem::exists(mods_root, ec) || ec) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
std::vector<std::filesystem::path> mod_roots;
|
|
for (const std::filesystem::directory_entry& entry : std::filesystem::directory_iterator(mods_root, ec)) {
|
|
if (ec) {
|
|
break;
|
|
}
|
|
if (entry.is_directory()) {
|
|
mod_roots.push_back(entry.path());
|
|
}
|
|
}
|
|
std::sort(mod_roots.begin(), mod_roots.end());
|
|
|
|
std::optional<std::filesystem::path> resolved;
|
|
for (const std::filesystem::path& mod_root : mod_roots) {
|
|
const std::filesystem::path candidate = mod_root / "textures" / file_name;
|
|
if (std::filesystem::exists(candidate, ec)) {
|
|
resolved = candidate;
|
|
}
|
|
}
|
|
return resolved;
|
|
}
|
|
|
|
bool LoadDdsFromFile(const std::filesystem::path& path, DdsImageData& out, std::string* error_out) {
|
|
std::ifstream file(path, std::ios::binary);
|
|
if (!file) {
|
|
if (error_out) {
|
|
*error_out = "failed to open file";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
file.seekg(0, std::ios::end);
|
|
const std::streamoff file_size = file.tellg();
|
|
file.seekg(0, std::ios::beg);
|
|
if (file_size < std::streamoff(sizeof(uint32_t) + sizeof(DdsHeader) + sizeof(DdsHeaderDx10))) {
|
|
if (error_out) {
|
|
*error_out = "file is too small to be a DX10 DDS";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint32_t magic = 0;
|
|
DdsHeader header = {};
|
|
DdsHeaderDx10 header_dx10 = {};
|
|
file.read(reinterpret_cast<char*>(&magic), sizeof(magic));
|
|
file.read(reinterpret_cast<char*>(&header), sizeof(header));
|
|
file.read(reinterpret_cast<char*>(&header_dx10), sizeof(header_dx10));
|
|
if (!file || magic != kDdsMagic || header.size != sizeof(DdsHeader) ||
|
|
header.pixel_format.size != sizeof(DdsPixelFormat) ||
|
|
header.pixel_format.four_cc != kDdsFourCcDx10) {
|
|
if (error_out) {
|
|
*error_out = "only DDS files with a DX10 header are supported";
|
|
}
|
|
return false;
|
|
}
|
|
if ((header_dx10.misc_flag & kDdsResourceMiscTextureCube) != 0) {
|
|
if (error_out) {
|
|
*error_out = "cube DDS files are not supported by the first-pass texture swap loader";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
D3D12_RESOURCE_DIMENSION dimension = D3D12_RESOURCE_DIMENSION_UNKNOWN;
|
|
if (!MapDdsDimension(header_dx10.resource_dimension, dimension)) {
|
|
if (error_out) {
|
|
*error_out = "unsupported DDS resource dimension";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const uint32_t mip_count = std::max(header.mip_map_count, 1u);
|
|
const uint32_t depth_or_array_size =
|
|
dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? std::max(header.depth, 1u)
|
|
: std::max(header_dx10.array_size, 1u);
|
|
const uint32_t width = std::max(header.width, 1u);
|
|
const uint32_t height = std::max(header.height, 1u);
|
|
|
|
if (!IsSupportedTextureSwapFormat(DXGI_FORMAT(header_dx10.dxgi_format))) {
|
|
if (error_out) {
|
|
*error_out = "unsupported DXGI format in DDS file";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
DdsImageData image;
|
|
image.format = DXGI_FORMAT(header_dx10.dxgi_format);
|
|
image.dimension = dimension;
|
|
image.width = width;
|
|
image.height = height;
|
|
image.depth_or_array_size = depth_or_array_size;
|
|
image.mip_count = mip_count;
|
|
image.is_cube = false;
|
|
image.subresources.reserve(ComputeSubresourceCount(dimension, depth_or_array_size, mip_count));
|
|
|
|
std::vector<uint8_t> payload(size_t(file_size) - (sizeof(uint32_t) + sizeof(DdsHeader) + sizeof(DdsHeaderDx10)));
|
|
file.read(reinterpret_cast<char*>(payload.data()), std::streamsize(payload.size()));
|
|
if (!file && !payload.empty()) {
|
|
if (error_out) {
|
|
*error_out = "failed to read DDS payload";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
size_t payload_offset = 0;
|
|
const uint32_t subresource_count = ComputeSubresourceCount(dimension, depth_or_array_size, mip_count);
|
|
for (uint32_t subresource_index = 0; subresource_index < subresource_count; ++subresource_index) {
|
|
const uint32_t mip_index =
|
|
dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? subresource_index
|
|
: (subresource_index % mip_count);
|
|
DdsSubresource subresource;
|
|
subresource.width = std::max(width >> mip_index, 1u);
|
|
subresource.height = std::max(height >> mip_index, 1u);
|
|
subresource.depth = dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D
|
|
? std::max(depth_or_array_size >> mip_index, 1u)
|
|
: 1u;
|
|
TextureSubresourceLayout tight_layout = {};
|
|
if (!GetTightTextureSubresourceLayout(image.format, subresource.width, subresource.height,
|
|
tight_layout)) {
|
|
if (error_out) {
|
|
*error_out = "unsupported tight layout for DDS subresource";
|
|
}
|
|
return false;
|
|
}
|
|
const size_t subresource_size = size_t(tight_layout.slice_pitch) * subresource.depth;
|
|
if (payload_offset + subresource_size > payload.size()) {
|
|
if (error_out) {
|
|
*error_out = "DDS payload is truncated";
|
|
}
|
|
return false;
|
|
}
|
|
subresource.row_pitch = tight_layout.row_pitch;
|
|
subresource.slice_pitch = tight_layout.slice_pitch;
|
|
subresource.data.resize(subresource_size);
|
|
std::copy_n(payload.data() + payload_offset, subresource_size, subresource.data.data());
|
|
payload_offset += subresource_size;
|
|
image.subresources.push_back(std::move(subresource));
|
|
}
|
|
|
|
out = std::move(image);
|
|
return true;
|
|
}
|
|
|
|
bool WriteDdsToFile(const std::filesystem::path& path, const DdsImageData& data,
|
|
std::string* error_out) {
|
|
if (data.is_cube) {
|
|
if (error_out) {
|
|
*error_out = "cube textures are not supported for DDS dumping";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const uint32_t expected_subresource_count =
|
|
ComputeSubresourceCount(data.dimension, data.depth_or_array_size, data.mip_count);
|
|
if (data.subresources.size() != expected_subresource_count) {
|
|
if (error_out) {
|
|
*error_out = "DDS subresource count does not match the texture description";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (!EnsureParentExists(path, error_out)) {
|
|
return false;
|
|
}
|
|
|
|
TextureSubresourceLayout base_layout = {};
|
|
if (!GetTightTextureSubresourceLayout(data.format, data.width, data.height, base_layout)) {
|
|
if (error_out) {
|
|
*error_out = "unsupported DXGI format for DDS output";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
DdsHeader header = {};
|
|
header.size = sizeof(DdsHeader);
|
|
header.flags = kDdsHeaderFlagsTexture;
|
|
header.height = std::max(data.height, 1u);
|
|
header.width = std::max(data.width, 1u);
|
|
header.pitch_or_linear_size = base_layout.row_pitch;
|
|
header.depth = data.dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? data.depth_or_array_size : 0;
|
|
header.mip_map_count = std::max(data.mip_count, 1u);
|
|
header.pixel_format = {sizeof(DdsPixelFormat), kDdsPixelFormatFlagsFourCc, kDdsFourCcDx10, 0, 0, 0, 0, 0};
|
|
header.caps = kDdsCapsTexture;
|
|
header.caps2 = 0;
|
|
if (data.mip_count > 1) {
|
|
header.flags |= kDdsHeaderFlagsMipmap;
|
|
header.caps |= kDdsCapsComplex | kDdsCapsMipmap;
|
|
}
|
|
if (data.dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D) {
|
|
header.flags |= kDdsHeaderFlagsDepth;
|
|
header.caps |= kDdsCapsComplex;
|
|
header.caps2 |= kDdsCaps2Volume;
|
|
} else if (data.depth_or_array_size > 1) {
|
|
header.caps |= kDdsCapsComplex;
|
|
}
|
|
|
|
DxgiLayoutInfo format_info = {};
|
|
GetDxgiLayoutInfo(data.format, format_info);
|
|
if (format_info.block_width != 1 || format_info.block_height != 1) {
|
|
header.flags |= kDdsHeaderFlagsLinearSize;
|
|
header.pitch_or_linear_size = base_layout.slice_pitch;
|
|
} else {
|
|
header.flags |= kDdsHeaderFlagsPitch;
|
|
}
|
|
|
|
DdsHeaderDx10 header_dx10 = {};
|
|
header_dx10.dxgi_format = uint32_t(data.format);
|
|
header_dx10.resource_dimension = ToDdsDimension(data.dimension);
|
|
header_dx10.array_size =
|
|
data.dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? 1u : std::max(data.depth_or_array_size, 1u);
|
|
|
|
std::ofstream file(path, std::ios::binary | std::ios::trunc);
|
|
if (!file) {
|
|
if (error_out) {
|
|
*error_out = "failed to create DDS file";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
file.write(reinterpret_cast<const char*>(&kDdsMagic), sizeof(kDdsMagic));
|
|
file.write(reinterpret_cast<const char*>(&header), sizeof(header));
|
|
file.write(reinterpret_cast<const char*>(&header_dx10), sizeof(header_dx10));
|
|
for (const DdsSubresource& subresource : data.subresources) {
|
|
const size_t expected_size = size_t(subresource.slice_pitch) * subresource.depth;
|
|
if (subresource.data.size() != expected_size) {
|
|
if (error_out) {
|
|
*error_out = "DDS subresource payload has an unexpected size";
|
|
}
|
|
return false;
|
|
}
|
|
file.write(reinterpret_cast<const char*>(subresource.data.data()),
|
|
std::streamsize(subresource.data.size()));
|
|
}
|
|
if (!file) {
|
|
if (error_out) {
|
|
*error_out = "failed while writing DDS file";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool WriteDumpMetadata(const std::filesystem::path& path, const TextureDumpMetadata& metadata,
|
|
std::string* error_out) {
|
|
if (!EnsureParentExists(path, error_out)) {
|
|
return false;
|
|
}
|
|
|
|
std::ofstream file(path, std::ios::binary | std::ios::trunc);
|
|
if (!file) {
|
|
if (error_out) {
|
|
*error_out = "failed to create metadata file";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
file << "{\n";
|
|
file << " \"stable_key\": \"" << EscapeJson(metadata.stable_key) << "\",\n";
|
|
file << " \"texture_key_hash\": \"0x" << HexU64(metadata.texture_key_hash) << "\",\n";
|
|
file << " \"base_page\": \"0x" << HexU32(metadata.base_page) << "\",\n";
|
|
file << " \"mip_page\": \"0x" << HexU32(metadata.mip_page) << "\",\n";
|
|
file << " \"dimension\": " << metadata.dimension << ",\n";
|
|
file << " \"width\": " << metadata.width << ",\n";
|
|
file << " \"height\": " << metadata.height << ",\n";
|
|
file << " \"depth_or_array_size\": " << metadata.depth_or_array_size << ",\n";
|
|
file << " \"mip_count\": " << metadata.mip_count << ",\n";
|
|
file << " \"guest_format\": " << metadata.guest_format << ",\n";
|
|
file << " \"endianness\": " << metadata.endianness << ",\n";
|
|
file << " \"dxgi_format\": " << metadata.dxgi_format << ",\n";
|
|
file << " \"dxgi_format_name\": \"" << EscapeJson(DescribeDxgiFormat(DXGI_FORMAT(metadata.dxgi_format)))
|
|
<< "\",\n";
|
|
file << " \"tiled\": " << (metadata.tiled ? "true" : "false") << ",\n";
|
|
file << " \"packed_mips\": " << (metadata.packed_mips ? "true" : "false") << ",\n";
|
|
file << " \"signed_separate\": " << (metadata.signed_separate ? "true" : "false") << ",\n";
|
|
file << " \"scaled_resolve\": " << (metadata.scaled_resolve ? "true" : "false") << ",\n";
|
|
file << " \"frame_index\": " << metadata.frame_index << ",\n";
|
|
file << " \"signature_stable_id\": \"0x" << HexU64(metadata.signature_stable_id) << "\",\n";
|
|
file << " \"active_vertex_shader_hash\": \"0x" << HexU64(metadata.active_vertex_shader_hash)
|
|
<< "\",\n";
|
|
file << " \"active_pixel_shader_hash\": \"0x" << HexU64(metadata.active_pixel_shader_hash)
|
|
<< "\",\n";
|
|
file << " \"signature_tags\": \"" << EscapeJson(metadata.signature_tags) << "\"\n";
|
|
file << "}\n";
|
|
|
|
if (!file) {
|
|
if (error_out) {
|
|
*error_out = "failed while writing metadata file";
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace ac6::textures
|