946 lines
30 KiB
C++
946 lines
30 KiB
C++
#include "BuiltInIcons.h"
|
|
|
|
#include "Bootstrap/EditorResources.h"
|
|
#include "Ports/TexturePort.h"
|
|
#include "Support/EmbeddedPngLoader.h"
|
|
#include "Support/StringEncoding.h"
|
|
|
|
#include <stb_image.h>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cstring>
|
|
#include <fstream>
|
|
#include <limits>
|
|
#include <sstream>
|
|
#include <system_error>
|
|
#include <utility>
|
|
|
|
namespace XCEngine::UI::Editor::App {
|
|
|
|
namespace {
|
|
|
|
struct PreviewDiskCacheEntry {
|
|
std::filesystem::path filePath = {};
|
|
std::string relativePathKey = {};
|
|
};
|
|
|
|
#pragma pack(push, 1)
|
|
struct ThumbnailCacheFileHeader {
|
|
char magic[8] = {};
|
|
std::uint32_t version = 1u;
|
|
std::uint64_t fileSize = 0u;
|
|
std::int64_t lastWriteTimeTicks = 0;
|
|
std::uint32_t width = 0u;
|
|
std::uint32_t height = 0u;
|
|
std::uint32_t relativePathSize = 0u;
|
|
std::uint32_t pixelDataSize = 0u;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
constexpr std::size_t kMaxCachedAssetPreviews = 40u;
|
|
constexpr int kMaxPreviewLoadsPerFrame = 64;
|
|
constexpr std::size_t kMaxQueuedPreviewDecodeJobs = 64u;
|
|
constexpr int kMaxPreviewThumbnailExtent = 192;
|
|
constexpr std::size_t kPreviewWorkerCount = 2u;
|
|
constexpr int kPreviewSourceValidationIntervalFrames = 30;
|
|
constexpr std::uint32_t kThumbnailCacheVersion = 1u;
|
|
constexpr std::array<char, 8> kThumbnailCacheMagic = { 'X', 'C', 'T', 'H', 'M', 'B', '1', '\0' };
|
|
constexpr std::uint32_t kMaxThumbnailCacheRelativePathBytes = 16u * 1024u;
|
|
|
|
void AppendLoadError(
|
|
std::ostringstream& stream,
|
|
std::string_view label,
|
|
const std::string& error) {
|
|
if (error.empty()) {
|
|
return;
|
|
}
|
|
|
|
if (stream.tellp() > 0) {
|
|
stream << '\n';
|
|
}
|
|
stream << label << ": " << error;
|
|
}
|
|
|
|
void LoadEmbeddedIconTexture(
|
|
Ports::TexturePort& renderer,
|
|
UINT resourceId,
|
|
std::string_view label,
|
|
::XCEngine::UI::UITextureHandle& outTexture,
|
|
std::ostringstream& errorStream) {
|
|
std::string error = {};
|
|
if (!LoadEmbeddedPngTexture(renderer, resourceId, outTexture, error)) {
|
|
AppendLoadError(errorStream, label, error);
|
|
}
|
|
}
|
|
|
|
BuiltInIcons::SourceFileFingerprint MakeSourceFingerprint(
|
|
std::uint64_t fileSize,
|
|
std::int64_t lastWriteTimeTicks) {
|
|
BuiltInIcons::SourceFileFingerprint fingerprint = {};
|
|
fingerprint.fileSize = fileSize;
|
|
fingerprint.lastWriteTimeTicks = lastWriteTimeTicks;
|
|
return fingerprint;
|
|
}
|
|
|
|
bool QuerySourceFileFingerprint(
|
|
const std::filesystem::path& filePath,
|
|
BuiltInIcons::SourceFileFingerprint& outFingerprint) {
|
|
std::error_code errorCode = {};
|
|
if (!std::filesystem::exists(filePath, errorCode) || errorCode) {
|
|
return false;
|
|
}
|
|
|
|
errorCode.clear();
|
|
if (!std::filesystem::is_regular_file(filePath, errorCode) || errorCode) {
|
|
return false;
|
|
}
|
|
|
|
errorCode.clear();
|
|
const auto fileSize = std::filesystem::file_size(filePath, errorCode);
|
|
if (errorCode || fileSize == static_cast<std::uintmax_t>(-1)) {
|
|
return false;
|
|
}
|
|
|
|
errorCode.clear();
|
|
const auto lastWriteTime = std::filesystem::last_write_time(filePath, errorCode);
|
|
if (errorCode) {
|
|
return false;
|
|
}
|
|
|
|
outFingerprint.fileSize = static_cast<std::uint64_t>(fileSize);
|
|
outFingerprint.lastWriteTimeTicks =
|
|
static_cast<std::int64_t>(lastWriteTime.time_since_epoch().count());
|
|
return outFingerprint.IsValid();
|
|
}
|
|
|
|
std::string NormalizePathKey(const std::filesystem::path& path) {
|
|
std::wstring key = path.lexically_normal().generic_wstring();
|
|
std::transform(key.begin(), key.end(), key.begin(), ::towlower);
|
|
return WideToUtf8(key);
|
|
}
|
|
|
|
std::uint64_t ComputeFnv1a64(const std::string& value) {
|
|
constexpr std::uint64_t kOffsetBasis = 14695981039346656037ull;
|
|
constexpr std::uint64_t kPrime = 1099511628211ull;
|
|
|
|
std::uint64_t hash = kOffsetBasis;
|
|
for (unsigned char character : value) {
|
|
hash ^= static_cast<std::uint64_t>(character);
|
|
hash *= kPrime;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
std::string FormatHashHex(std::uint64_t value) {
|
|
static constexpr char kHexDigits[] = "0123456789abcdef";
|
|
|
|
std::string result(16u, '0');
|
|
for (int index = 15; index >= 0; --index) {
|
|
result[static_cast<std::size_t>(index)] = kHexDigits[value & 0xFu];
|
|
value >>= 4u;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool IsProjectRelativePath(const std::filesystem::path& relativePath) {
|
|
if (relativePath.empty()) {
|
|
return false;
|
|
}
|
|
|
|
const std::wstring generic = relativePath.generic_wstring();
|
|
return generic != L"." && generic != L".." && generic.rfind(L"../", 0) != 0;
|
|
}
|
|
|
|
bool ResolvePreviewDiskCacheEntry(
|
|
const std::filesystem::path& projectRoot,
|
|
const std::filesystem::path& filePath,
|
|
PreviewDiskCacheEntry& outEntry) {
|
|
if (projectRoot.empty() || filePath.empty()) {
|
|
return false;
|
|
}
|
|
|
|
std::error_code errorCode = {};
|
|
const std::filesystem::path canonicalRoot =
|
|
std::filesystem::weakly_canonical(projectRoot, errorCode);
|
|
if (errorCode || canonicalRoot.empty()) {
|
|
return false;
|
|
}
|
|
|
|
errorCode.clear();
|
|
const std::filesystem::path canonicalAsset =
|
|
std::filesystem::weakly_canonical(filePath, errorCode);
|
|
if (errorCode || canonicalAsset.empty()) {
|
|
return false;
|
|
}
|
|
|
|
errorCode.clear();
|
|
std::filesystem::path relativePath =
|
|
std::filesystem::relative(canonicalAsset, canonicalRoot, errorCode);
|
|
if (errorCode) {
|
|
return false;
|
|
}
|
|
|
|
relativePath = relativePath.lexically_normal();
|
|
if (!IsProjectRelativePath(relativePath)) {
|
|
return false;
|
|
}
|
|
|
|
outEntry.relativePathKey = NormalizePathKey(relativePath);
|
|
const std::string hashFileName =
|
|
FormatHashHex(ComputeFnv1a64(outEntry.relativePathKey)) + ".thumb";
|
|
outEntry.filePath =
|
|
(canonicalRoot / L".xceditor" / L"thumbs" /
|
|
std::filesystem::path(Utf8ToWide(hashFileName))).lexically_normal();
|
|
return true;
|
|
}
|
|
|
|
bool ReadThumbnailCacheFile(
|
|
const std::filesystem::path& cacheFilePath,
|
|
const std::string& relativePathKey,
|
|
const BuiltInIcons::SourceFileFingerprint& sourceFingerprint,
|
|
BuiltInIcons::LoadedTexturePixels& outTexturePixels) {
|
|
std::ifstream stream(cacheFilePath, std::ios::binary | std::ios::in);
|
|
if (!stream.is_open()) {
|
|
return false;
|
|
}
|
|
|
|
ThumbnailCacheFileHeader header = {};
|
|
if (!stream.read(reinterpret_cast<char*>(&header), sizeof(header)).good()) {
|
|
return false;
|
|
}
|
|
|
|
if (std::memcmp(header.magic, kThumbnailCacheMagic.data(), kThumbnailCacheMagic.size()) != 0 ||
|
|
header.version != kThumbnailCacheVersion ||
|
|
header.fileSize != sourceFingerprint.fileSize ||
|
|
header.lastWriteTimeTicks != sourceFingerprint.lastWriteTimeTicks ||
|
|
header.relativePathSize == 0u ||
|
|
header.relativePathSize > kMaxThumbnailCacheRelativePathBytes ||
|
|
header.width == 0u ||
|
|
header.height == 0u ||
|
|
header.width > static_cast<std::uint32_t>(kMaxPreviewThumbnailExtent) ||
|
|
header.height > static_cast<std::uint32_t>(kMaxPreviewThumbnailExtent)) {
|
|
return false;
|
|
}
|
|
|
|
const std::uint64_t expectedPixelBytes =
|
|
static_cast<std::uint64_t>(header.width) * static_cast<std::uint64_t>(header.height) * 4ull;
|
|
if (expectedPixelBytes == 0u ||
|
|
expectedPixelBytes > static_cast<std::uint64_t>((std::numeric_limits<std::size_t>::max)()) ||
|
|
header.pixelDataSize != expectedPixelBytes) {
|
|
return false;
|
|
}
|
|
|
|
std::string cachedRelativePath(header.relativePathSize, '\0');
|
|
if (!stream.read(
|
|
cachedRelativePath.data(),
|
|
static_cast<std::streamsize>(cachedRelativePath.size())).good()) {
|
|
return false;
|
|
}
|
|
if (cachedRelativePath != relativePathKey) {
|
|
return false;
|
|
}
|
|
|
|
outTexturePixels.width = static_cast<int>(header.width);
|
|
outTexturePixels.height = static_cast<int>(header.height);
|
|
outTexturePixels.rgbaPixels.resize(static_cast<std::size_t>(header.pixelDataSize));
|
|
if (!stream.read(
|
|
reinterpret_cast<char*>(outTexturePixels.rgbaPixels.data()),
|
|
static_cast<std::streamsize>(outTexturePixels.rgbaPixels.size())).good()) {
|
|
outTexturePixels = {};
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void RemoveDiskCacheFile(const std::filesystem::path& cacheFilePath) {
|
|
std::error_code errorCode = {};
|
|
std::filesystem::remove(cacheFilePath, errorCode);
|
|
}
|
|
|
|
bool WriteThumbnailCacheFile(
|
|
const std::filesystem::path& cacheFilePath,
|
|
const std::string& relativePathKey,
|
|
const BuiltInIcons::SourceFileFingerprint& sourceFingerprint,
|
|
const BuiltInIcons::LoadedTexturePixels& texturePixels) {
|
|
if (cacheFilePath.empty() ||
|
|
relativePathKey.empty() ||
|
|
relativePathKey.size() > kMaxThumbnailCacheRelativePathBytes ||
|
|
!sourceFingerprint.IsValid() ||
|
|
texturePixels.width <= 0 ||
|
|
texturePixels.height <= 0 ||
|
|
texturePixels.rgbaPixels.empty()) {
|
|
return false;
|
|
}
|
|
|
|
const std::uint64_t pixelDataSize =
|
|
static_cast<std::uint64_t>(texturePixels.rgbaPixels.size());
|
|
if (pixelDataSize !=
|
|
static_cast<std::uint64_t>(texturePixels.width) *
|
|
static_cast<std::uint64_t>(texturePixels.height) * 4ull ||
|
|
pixelDataSize >
|
|
static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)())) {
|
|
return false;
|
|
}
|
|
|
|
std::error_code errorCode = {};
|
|
std::filesystem::create_directories(cacheFilePath.parent_path(), errorCode);
|
|
if (errorCode) {
|
|
return false;
|
|
}
|
|
|
|
const std::filesystem::path tempPath =
|
|
cacheFilePath.parent_path() / (cacheFilePath.filename().wstring() + L".tmp");
|
|
std::ofstream stream(tempPath, std::ios::binary | std::ios::out | std::ios::trunc);
|
|
if (!stream.is_open()) {
|
|
return false;
|
|
}
|
|
|
|
ThumbnailCacheFileHeader header = {};
|
|
std::memcpy(header.magic, kThumbnailCacheMagic.data(), kThumbnailCacheMagic.size());
|
|
header.version = kThumbnailCacheVersion;
|
|
header.fileSize = sourceFingerprint.fileSize;
|
|
header.lastWriteTimeTicks = sourceFingerprint.lastWriteTimeTicks;
|
|
header.width = static_cast<std::uint32_t>(texturePixels.width);
|
|
header.height = static_cast<std::uint32_t>(texturePixels.height);
|
|
header.relativePathSize = static_cast<std::uint32_t>(relativePathKey.size());
|
|
header.pixelDataSize = static_cast<std::uint32_t>(pixelDataSize);
|
|
|
|
const bool writeSucceeded =
|
|
stream.write(reinterpret_cast<const char*>(&header), sizeof(header)).good() &&
|
|
stream.write(
|
|
relativePathKey.data(),
|
|
static_cast<std::streamsize>(relativePathKey.size())).good() &&
|
|
stream.write(
|
|
reinterpret_cast<const char*>(texturePixels.rgbaPixels.data()),
|
|
static_cast<std::streamsize>(texturePixels.rgbaPixels.size())).good();
|
|
stream.close();
|
|
if (!writeSucceeded) {
|
|
RemoveDiskCacheFile(tempPath);
|
|
return false;
|
|
}
|
|
|
|
errorCode.clear();
|
|
std::filesystem::remove(cacheFilePath, errorCode);
|
|
errorCode.clear();
|
|
std::filesystem::rename(tempPath, cacheFilePath, errorCode);
|
|
if (errorCode) {
|
|
RemoveDiskCacheFile(tempPath);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ReadFileBytes(
|
|
const std::filesystem::path& filePath,
|
|
std::vector<std::uint8_t>& bytes) {
|
|
std::ifstream stream(filePath, std::ios::binary | std::ios::ate);
|
|
if (!stream.is_open()) {
|
|
return false;
|
|
}
|
|
|
|
const std::streamsize size = stream.tellg();
|
|
if (size <= 0) {
|
|
return false;
|
|
}
|
|
|
|
bytes.resize(static_cast<std::size_t>(size));
|
|
stream.seekg(0, std::ios::beg);
|
|
return stream.read(reinterpret_cast<char*>(bytes.data()), size).good();
|
|
}
|
|
|
|
void ResizeRgbaImageBilinear(
|
|
const std::uint8_t* srcPixels,
|
|
int srcWidth,
|
|
int srcHeight,
|
|
int dstWidth,
|
|
int dstHeight,
|
|
std::vector<std::uint8_t>& dstPixels) {
|
|
dstPixels.resize(
|
|
static_cast<std::size_t>(dstWidth) * static_cast<std::size_t>(dstHeight) * 4u);
|
|
if (!srcPixels ||
|
|
srcWidth <= 0 ||
|
|
srcHeight <= 0 ||
|
|
dstWidth <= 0 ||
|
|
dstHeight <= 0) {
|
|
return;
|
|
}
|
|
|
|
for (int dstY = 0; dstY < dstHeight; ++dstY) {
|
|
const float srcY = dstHeight > 1
|
|
? static_cast<float>(dstY) * static_cast<float>(srcHeight - 1) /
|
|
static_cast<float>(dstHeight - 1)
|
|
: 0.0f;
|
|
const int y0 = static_cast<int>(srcY);
|
|
const int y1 = (std::min)(y0 + 1, srcHeight - 1);
|
|
const float ty = srcY - static_cast<float>(y0);
|
|
|
|
for (int dstX = 0; dstX < dstWidth; ++dstX) {
|
|
const float srcX = dstWidth > 1
|
|
? static_cast<float>(dstX) * static_cast<float>(srcWidth - 1) /
|
|
static_cast<float>(dstWidth - 1)
|
|
: 0.0f;
|
|
const int x0 = static_cast<int>(srcX);
|
|
const int x1 = (std::min)(x0 + 1, srcWidth - 1);
|
|
const float tx = srcX - static_cast<float>(x0);
|
|
|
|
const std::size_t dstOffset =
|
|
(static_cast<std::size_t>(dstY) * static_cast<std::size_t>(dstWidth) +
|
|
static_cast<std::size_t>(dstX)) * 4u;
|
|
const std::size_t srcOffset00 =
|
|
(static_cast<std::size_t>(y0) * static_cast<std::size_t>(srcWidth) +
|
|
static_cast<std::size_t>(x0)) * 4u;
|
|
const std::size_t srcOffset10 =
|
|
(static_cast<std::size_t>(y0) * static_cast<std::size_t>(srcWidth) +
|
|
static_cast<std::size_t>(x1)) * 4u;
|
|
const std::size_t srcOffset01 =
|
|
(static_cast<std::size_t>(y1) * static_cast<std::size_t>(srcWidth) +
|
|
static_cast<std::size_t>(x0)) * 4u;
|
|
const std::size_t srcOffset11 =
|
|
(static_cast<std::size_t>(y1) * static_cast<std::size_t>(srcWidth) +
|
|
static_cast<std::size_t>(x1)) * 4u;
|
|
|
|
for (std::size_t channel = 0u; channel < 4u; ++channel) {
|
|
const float top =
|
|
static_cast<float>(srcPixels[srcOffset00 + channel]) * (1.0f - tx) +
|
|
static_cast<float>(srcPixels[srcOffset10 + channel]) * tx;
|
|
const float bottom =
|
|
static_cast<float>(srcPixels[srcOffset01 + channel]) * (1.0f - tx) +
|
|
static_cast<float>(srcPixels[srcOffset11 + channel]) * tx;
|
|
dstPixels[dstOffset + channel] =
|
|
static_cast<std::uint8_t>(top * (1.0f - ty) + bottom * ty + 0.5f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool DownscalePreviewTextureIfNeeded(BuiltInIcons::LoadedTexturePixels& texturePixels) {
|
|
if (texturePixels.width <= 0 ||
|
|
texturePixels.height <= 0 ||
|
|
texturePixels.rgbaPixels.empty()) {
|
|
return false;
|
|
}
|
|
|
|
const int maxExtent = (std::max)(texturePixels.width, texturePixels.height);
|
|
if (maxExtent <= kMaxPreviewThumbnailExtent) {
|
|
return true;
|
|
}
|
|
|
|
const float scale =
|
|
static_cast<float>(kMaxPreviewThumbnailExtent) / static_cast<float>(maxExtent);
|
|
const int dstWidth =
|
|
(std::max)(1, static_cast<int>(static_cast<float>(texturePixels.width) * scale + 0.5f));
|
|
const int dstHeight =
|
|
(std::max)(1, static_cast<int>(static_cast<float>(texturePixels.height) * scale + 0.5f));
|
|
|
|
std::vector<std::uint8_t> resizedPixels = {};
|
|
ResizeRgbaImageBilinear(
|
|
texturePixels.rgbaPixels.data(),
|
|
texturePixels.width,
|
|
texturePixels.height,
|
|
dstWidth,
|
|
dstHeight,
|
|
resizedPixels);
|
|
if (resizedPixels.empty()) {
|
|
return false;
|
|
}
|
|
|
|
texturePixels.rgbaPixels = std::move(resizedPixels);
|
|
texturePixels.width = dstWidth;
|
|
texturePixels.height = dstHeight;
|
|
return true;
|
|
}
|
|
|
|
bool DecodeTextureFromFile(
|
|
const std::filesystem::path& filePath,
|
|
BuiltInIcons::LoadedTexturePixels& outTexturePixels) {
|
|
if (!std::filesystem::exists(filePath)) {
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::uint8_t> fileData = {};
|
|
if (!ReadFileBytes(filePath, fileData)) {
|
|
return false;
|
|
}
|
|
|
|
int width = 0;
|
|
int height = 0;
|
|
int channels = 0;
|
|
stbi_uc* pixels = stbi_load_from_memory(
|
|
reinterpret_cast<const stbi_uc*>(fileData.data()),
|
|
static_cast<int>(fileData.size()),
|
|
&width,
|
|
&height,
|
|
&channels,
|
|
STBI_rgb_alpha);
|
|
if (!pixels || width <= 0 || height <= 0) {
|
|
if (pixels != nullptr) {
|
|
stbi_image_free(pixels);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
outTexturePixels.width = width;
|
|
outTexturePixels.height = height;
|
|
outTexturePixels.rgbaPixels.assign(
|
|
pixels,
|
|
pixels + static_cast<std::size_t>(width) * static_cast<std::size_t>(height) * 4u);
|
|
stbi_image_free(pixels);
|
|
|
|
return DownscalePreviewTextureIfNeeded(outTexturePixels);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void BuiltInIcons::Initialize(Ports::TexturePort& renderer) {
|
|
Shutdown();
|
|
|
|
m_renderer = &renderer;
|
|
StartPreviewWorkers();
|
|
|
|
std::ostringstream errorStream = {};
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_FOLDER_ICON,
|
|
"folder_icon.png",
|
|
m_folderIcon,
|
|
errorStream);
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_GAMEOBJECT_ICON,
|
|
"gameobject_icon.png",
|
|
m_gameObjectIcon,
|
|
errorStream);
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_SCENE_ICON,
|
|
"scene_icon.png",
|
|
m_sceneIcon,
|
|
errorStream);
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_CAMERA_GIZMO_ICON,
|
|
"camera_gizmo.png",
|
|
m_cameraGizmoIcon,
|
|
errorStream);
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_DIRECTIONAL_LIGHT_GIZMO_ICON,
|
|
"directional_light_gizmo.png",
|
|
m_directionalLightGizmoIcon,
|
|
errorStream);
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_POINT_LIGHT_GIZMO_ICON,
|
|
"point_light_gizmo.png",
|
|
m_pointLightGizmoIcon,
|
|
errorStream);
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_SPOT_LIGHT_GIZMO_ICON,
|
|
"spot_light_gizmo.png",
|
|
m_spotLightGizmoIcon,
|
|
errorStream);
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_PLAY_BUTTON_ICON,
|
|
"play_button.png",
|
|
m_playButtonIcon,
|
|
errorStream);
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_PAUSE_BUTTON_ICON,
|
|
"pause_button.png",
|
|
m_pauseButtonIcon,
|
|
errorStream);
|
|
LoadEmbeddedIconTexture(
|
|
renderer,
|
|
IDR_PNG_STEP_BUTTON_ICON,
|
|
"step_button.png",
|
|
m_stepButtonIcon,
|
|
errorStream);
|
|
|
|
m_frameIndex = 0;
|
|
m_previewLoadsThisFrame = 0;
|
|
m_lastError = errorStream.str();
|
|
}
|
|
|
|
void BuiltInIcons::Shutdown() {
|
|
StopPreviewWorkers();
|
|
ResetAssetPreviewCache();
|
|
|
|
if (m_renderer != nullptr) {
|
|
m_renderer->ReleaseTexture(m_folderIcon);
|
|
m_renderer->ReleaseTexture(m_gameObjectIcon);
|
|
m_renderer->ReleaseTexture(m_sceneIcon);
|
|
m_renderer->ReleaseTexture(m_cameraGizmoIcon);
|
|
m_renderer->ReleaseTexture(m_directionalLightGizmoIcon);
|
|
m_renderer->ReleaseTexture(m_pointLightGizmoIcon);
|
|
m_renderer->ReleaseTexture(m_spotLightGizmoIcon);
|
|
m_renderer->ReleaseTexture(m_playButtonIcon);
|
|
m_renderer->ReleaseTexture(m_pauseButtonIcon);
|
|
m_renderer->ReleaseTexture(m_stepButtonIcon);
|
|
}
|
|
|
|
m_renderer = nullptr;
|
|
m_frameIndex = 0;
|
|
m_previewLoadsThisFrame = 0;
|
|
m_lastError.clear();
|
|
}
|
|
|
|
void BuiltInIcons::BeginFrame() {
|
|
++m_frameIndex;
|
|
m_previewLoadsThisFrame = 0;
|
|
MaintainPreviewRuntimeState();
|
|
PruneAssetPreviewCache();
|
|
}
|
|
|
|
void BuiltInIcons::ResetAssetPreviewCache() {
|
|
if (m_renderer != nullptr) {
|
|
for (auto& entry : m_assetPreviews) {
|
|
m_renderer->ReleaseTexture(entry.second.texture);
|
|
}
|
|
}
|
|
m_assetPreviews.clear();
|
|
}
|
|
|
|
void BuiltInIcons::StartPreviewWorkers() {
|
|
if (m_previewWorkersRunning) {
|
|
return;
|
|
}
|
|
|
|
m_previewWorkersRunning = true;
|
|
m_previewWorkers.reserve(kPreviewWorkerCount);
|
|
for (std::size_t workerIndex = 0u; workerIndex < kPreviewWorkerCount; ++workerIndex) {
|
|
m_previewWorkers.emplace_back([this]() {
|
|
PreviewWorkerMain();
|
|
});
|
|
}
|
|
}
|
|
|
|
void BuiltInIcons::StopPreviewWorkers() {
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_previewQueueMutex);
|
|
m_previewWorkersRunning = false;
|
|
m_previewDecodeQueue.clear();
|
|
m_previewDecodeResults.clear();
|
|
m_pendingPreviewDecodeJobs = 0u;
|
|
}
|
|
m_previewQueueEvent.notify_all();
|
|
|
|
for (std::thread& worker : m_previewWorkers) {
|
|
if (worker.joinable()) {
|
|
worker.join();
|
|
}
|
|
}
|
|
m_previewWorkers.clear();
|
|
}
|
|
|
|
void BuiltInIcons::PreviewWorkerMain() {
|
|
while (true) {
|
|
PreviewDecodeJob job = {};
|
|
{
|
|
std::unique_lock<std::mutex> lock(m_previewQueueMutex);
|
|
m_previewQueueEvent.wait(lock, [this]() {
|
|
return !m_previewWorkersRunning || !m_previewDecodeQueue.empty();
|
|
});
|
|
|
|
if (!m_previewWorkersRunning && m_previewDecodeQueue.empty()) {
|
|
return;
|
|
}
|
|
|
|
job = std::move(m_previewDecodeQueue.front());
|
|
m_previewDecodeQueue.pop_front();
|
|
}
|
|
|
|
PreviewDecodeResult result = {};
|
|
result.key = std::move(job.key);
|
|
result.fileSize = job.fileSize;
|
|
result.lastWriteTimeTicks = job.lastWriteTimeTicks;
|
|
|
|
if (job.useDiskCache) {
|
|
result.success = ReadThumbnailCacheFile(
|
|
job.cacheFilePath,
|
|
job.relativePathKey,
|
|
MakeSourceFingerprint(job.fileSize, job.lastWriteTimeTicks),
|
|
result.pixels);
|
|
if (!result.success) {
|
|
RemoveDiskCacheFile(job.cacheFilePath);
|
|
}
|
|
}
|
|
|
|
if (!result.success) {
|
|
result.success = DecodeTextureFromFile(job.filePath, result.pixels);
|
|
if (result.success && job.useDiskCache) {
|
|
WriteThumbnailCacheFile(
|
|
job.cacheFilePath,
|
|
job.relativePathKey,
|
|
MakeSourceFingerprint(job.fileSize, job.lastWriteTimeTicks),
|
|
result.pixels);
|
|
}
|
|
}
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_previewQueueMutex);
|
|
m_previewDecodeResults.push_back(std::move(result));
|
|
}
|
|
}
|
|
}
|
|
|
|
void BuiltInIcons::DrainPreviewDecodeResults() {
|
|
std::deque<PreviewDecodeResult> completedResults = {};
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_previewQueueMutex);
|
|
completedResults.swap(m_previewDecodeResults);
|
|
}
|
|
|
|
for (PreviewDecodeResult& result : completedResults) {
|
|
if (m_pendingPreviewDecodeJobs > 0u) {
|
|
--m_pendingPreviewDecodeJobs;
|
|
}
|
|
|
|
auto iterator = m_assetPreviews.find(result.key);
|
|
if (iterator == m_assetPreviews.end()) {
|
|
continue;
|
|
}
|
|
|
|
CachedAssetPreview& preview = iterator->second;
|
|
preview.decodeQueued = false;
|
|
if (preview.sourceFingerprint !=
|
|
MakeSourceFingerprint(result.fileSize, result.lastWriteTimeTicks)) {
|
|
continue;
|
|
}
|
|
|
|
if (!result.success) {
|
|
preview.loadFailed = true;
|
|
preview.decodedPixels.reset();
|
|
continue;
|
|
}
|
|
|
|
preview.loadFailed = false;
|
|
preview.decodedPixels =
|
|
std::make_unique<LoadedTexturePixels>(std::move(result.pixels));
|
|
}
|
|
}
|
|
|
|
void BuiltInIcons::MaintainPreviewRuntimeState() {
|
|
DrainPreviewDecodeResults();
|
|
}
|
|
|
|
void BuiltInIcons::InvalidateAssetPreview(CachedAssetPreview& preview) {
|
|
if (m_renderer != nullptr) {
|
|
m_renderer->ReleaseTexture(preview.texture);
|
|
} else {
|
|
preview.texture = {};
|
|
}
|
|
|
|
preview.decodedPixels.reset();
|
|
preview.decodeQueued = false;
|
|
preview.loadFailed = false;
|
|
}
|
|
|
|
bool BuiltInIcons::RefreshAssetPreviewSourceFingerprint(
|
|
const std::filesystem::path& filePath,
|
|
CachedAssetPreview& preview) {
|
|
SourceFileFingerprint currentFingerprint = {};
|
|
if (!QuerySourceFileFingerprint(filePath, currentFingerprint)) {
|
|
InvalidateAssetPreview(preview);
|
|
preview.sourceFingerprint = {};
|
|
preview.loadFailed = true;
|
|
return false;
|
|
}
|
|
|
|
if (preview.sourceFingerprint != currentFingerprint) {
|
|
InvalidateAssetPreview(preview);
|
|
preview.sourceFingerprint = currentFingerprint;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BuiltInIcons::QueuePreviewDecode(
|
|
const std::string& key,
|
|
const std::filesystem::path& filePath,
|
|
const SourceFileFingerprint& sourceFingerprint,
|
|
const std::filesystem::path& projectRoot) {
|
|
PreviewDiskCacheEntry diskCacheEntry = {};
|
|
const bool useDiskCache =
|
|
ResolvePreviewDiskCacheEntry(projectRoot, filePath, diskCacheEntry);
|
|
|
|
std::lock_guard<std::mutex> lock(m_previewQueueMutex);
|
|
if (!m_previewWorkersRunning ||
|
|
m_pendingPreviewDecodeJobs >= kMaxQueuedPreviewDecodeJobs) {
|
|
return false;
|
|
}
|
|
|
|
PreviewDecodeJob job = {};
|
|
job.key = key;
|
|
job.filePath = filePath;
|
|
job.fileSize = sourceFingerprint.fileSize;
|
|
job.lastWriteTimeTicks = sourceFingerprint.lastWriteTimeTicks;
|
|
if (useDiskCache) {
|
|
job.cacheFilePath = std::move(diskCacheEntry.filePath);
|
|
job.relativePathKey = std::move(diskCacheEntry.relativePathKey);
|
|
job.useDiskCache = true;
|
|
}
|
|
|
|
m_previewDecodeQueue.push_back(std::move(job));
|
|
++m_pendingPreviewDecodeJobs;
|
|
m_previewQueueEvent.notify_one();
|
|
return true;
|
|
}
|
|
|
|
BuiltInIcons::CachedAssetPreview* BuiltInIcons::GetOrCreateAssetPreview(
|
|
const std::filesystem::path& assetPath,
|
|
const std::filesystem::path& projectRoot) {
|
|
if (m_renderer == nullptr || assetPath.empty()) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (m_frameIndex <= 0) {
|
|
BeginFrame();
|
|
} else {
|
|
MaintainPreviewRuntimeState();
|
|
}
|
|
|
|
const std::filesystem::path normalizedAssetPath = assetPath.lexically_normal();
|
|
const std::string key = NormalizePathKey(normalizedAssetPath);
|
|
auto [iterator, inserted] = m_assetPreviews.try_emplace(key);
|
|
CachedAssetPreview& preview = iterator->second;
|
|
preview.lastUsedFrame = m_frameIndex;
|
|
|
|
if (inserted ||
|
|
preview.lastSourceValidationFrame < 0 ||
|
|
m_frameIndex - preview.lastSourceValidationFrame >=
|
|
kPreviewSourceValidationIntervalFrames) {
|
|
preview.lastSourceValidationFrame = m_frameIndex;
|
|
if (!RefreshAssetPreviewSourceFingerprint(normalizedAssetPath, preview)) {
|
|
return &preview;
|
|
}
|
|
}
|
|
|
|
if (!preview.sourceFingerprint.IsValid()) {
|
|
return &preview;
|
|
}
|
|
|
|
if (preview.texture.IsValid()) {
|
|
return &preview;
|
|
}
|
|
|
|
if (preview.decodedPixels) {
|
|
std::string error = {};
|
|
if (!m_renderer->LoadTextureFromRgba(
|
|
preview.decodedPixels->rgbaPixels.data(),
|
|
static_cast<std::uint32_t>(preview.decodedPixels->width),
|
|
static_cast<std::uint32_t>(preview.decodedPixels->height),
|
|
preview.texture,
|
|
error)) {
|
|
preview.decodedPixels.reset();
|
|
preview.loadFailed = true;
|
|
return &preview;
|
|
}
|
|
|
|
preview.decodedPixels.reset();
|
|
preview.loadFailed = false;
|
|
return &preview;
|
|
}
|
|
|
|
if (preview.decodeQueued || preview.loadFailed) {
|
|
return &preview;
|
|
}
|
|
|
|
if (m_previewLoadsThisFrame >= kMaxPreviewLoadsPerFrame) {
|
|
return &preview;
|
|
}
|
|
|
|
if (QueuePreviewDecode(key, normalizedAssetPath, preview.sourceFingerprint, projectRoot)) {
|
|
preview.decodeQueued = true;
|
|
++m_previewLoadsThisFrame;
|
|
}
|
|
|
|
return &preview;
|
|
}
|
|
|
|
void BuiltInIcons::PruneAssetPreviewCache() {
|
|
if (m_assetPreviews.size() <= kMaxCachedAssetPreviews) {
|
|
return;
|
|
}
|
|
|
|
std::vector<std::pair<std::string, std::int64_t>> candidates = {};
|
|
candidates.reserve(m_assetPreviews.size());
|
|
for (const auto& entry : m_assetPreviews) {
|
|
if (entry.second.decodeQueued) {
|
|
continue;
|
|
}
|
|
candidates.emplace_back(entry.first, entry.second.lastUsedFrame);
|
|
}
|
|
|
|
std::sort(
|
|
candidates.begin(),
|
|
candidates.end(),
|
|
[](const auto& lhs, const auto& rhs) {
|
|
return lhs.second < rhs.second;
|
|
});
|
|
|
|
const std::size_t removeCount = m_assetPreviews.size() - kMaxCachedAssetPreviews;
|
|
for (std::size_t index = 0u; index < removeCount && index < candidates.size(); ++index) {
|
|
auto iterator = m_assetPreviews.find(candidates[index].first);
|
|
if (iterator == m_assetPreviews.end()) {
|
|
continue;
|
|
}
|
|
|
|
if (m_renderer != nullptr) {
|
|
m_renderer->ReleaseTexture(iterator->second.texture);
|
|
}
|
|
m_assetPreviews.erase(iterator);
|
|
}
|
|
}
|
|
|
|
const ::XCEngine::UI::UITextureHandle& BuiltInIcons::Resolve(
|
|
BuiltInIconKind kind) const {
|
|
switch (kind) {
|
|
case BuiltInIconKind::Folder:
|
|
return m_folderIcon;
|
|
case BuiltInIconKind::GameObject:
|
|
return m_gameObjectIcon;
|
|
case BuiltInIconKind::Scene:
|
|
return m_sceneIcon;
|
|
case BuiltInIconKind::CameraGizmo:
|
|
return m_cameraGizmoIcon;
|
|
case BuiltInIconKind::DirectionalLightGizmo:
|
|
return m_directionalLightGizmoIcon;
|
|
case BuiltInIconKind::PointLightGizmo:
|
|
return m_pointLightGizmoIcon;
|
|
case BuiltInIconKind::SpotLightGizmo:
|
|
return m_spotLightGizmoIcon;
|
|
case BuiltInIconKind::PlayButton:
|
|
return m_playButtonIcon;
|
|
case BuiltInIconKind::PauseButton:
|
|
return m_pauseButtonIcon;
|
|
case BuiltInIconKind::StepButton:
|
|
return m_stepButtonIcon;
|
|
default:
|
|
return m_folderIcon;
|
|
}
|
|
}
|
|
|
|
const ::XCEngine::UI::UITextureHandle* BuiltInIcons::ResolveAssetPreview(
|
|
const std::filesystem::path& assetPath,
|
|
const std::filesystem::path& projectRoot) {
|
|
CachedAssetPreview* preview = GetOrCreateAssetPreview(assetPath, projectRoot);
|
|
if (preview == nullptr || !preview->texture.IsValid()) {
|
|
return nullptr;
|
|
}
|
|
|
|
PruneAssetPreviewCache();
|
|
return &preview->texture;
|
|
}
|
|
|
|
const std::string& BuiltInIcons::GetLastError() const {
|
|
return m_lastError;
|
|
}
|
|
|
|
} // namespace XCEngine::UI::Editor::App
|