mitiru::resource

Resource pipeline: asset loading, caches, dependency tracking, and hot-reload plumbing.

Name	Kind	Items
`CacheStatistics`	struct	7
`AssetCache`	class	16
`AssetHandle`	class	10
`AssetManager`	class	9
`AssetPath`	class	6
`AssetProcessor`	class	3
`TextureData`	struct	4
`MipLevel`	struct	3
`AtlasEntry`	struct	5
`TextureAtlas`	struct	4
`TextureProcessor`	class	9
`TextureAtlasBuilder`	class	5
`ManifestEntry`	struct	5
`AssetManifest`	class	9
`BundleFileEntry`	struct	3
`BundleHeader`	struct	4
`BundleData`	struct	2
`AssetBundler`	class	5
`AssetBundleReader`	class	7
`AssetPriority`	enum	4
`CancellationToken`	class	3
`BatchProgress`	struct	4
`AsyncAssetLoader`	class	9
`DdsFormat`	enum	5
`DdsMipLevel`	struct	4
`DdsTextureData`	struct	7
`DdsImageLoader`	class	3
`EmbeddedAssetData`	struct	5
`EmbeddedAssets`	class	7
`FontMetrics`	struct	9
`FontLoader`	class	5
`HotReloadManager`	class	7
`FileChangeType`	enum	4
`FileChangeEvent`	struct	3
`HotReloadWatcher`	class	17
`IAssetLoaderBase`	class	3
`TypedAssetLoader`	class	5
`ImageFormat`	enum	7
`ImageData`	struct	5
`IImageLoader`	class	3
`BmpImageLoader`	class	2
`TgaImageLoader`	class	2
`UnifiedImageLoader`	class	6
`KtxFormat`	enum	14
`KtxVkFormat`	enum	13
`KtxMipLevel`	struct	4
`KtxTextureData`	struct	12
`KtxImageLoader`	class	7
`PackageCommand`	struct	2
`PackageInfo`	struct	8
`PackageRuntime`	class	16
`TargetPlatform`	enum	2
`PackageConfig`	struct	7
`PackageFileEntry`	struct	4
`VersionMetadata`	struct	5
`PackageResult`	struct	6
`DeltaEntry`	struct	6
`DeltaManifest`	struct	4
`PackagingTool`	class	4
`StbImageHandle`	class	14
`PngImageLoader`	class	5
`ResourceCache`	class	7
`StreamingState`	enum	5
`StreamingRequest`	struct	6
`StreamingStatistics`	struct	7
`StreamingManager`	class	18
`ThreadPool`	class	10

Free functions and typedefs

template <typename F, typename T> concept SizeEstimator = requires(F estimator, const T& asset)

struct CacheStatistics 7

std::size_t hits = 0

std::size_t misses = 0

std::size_t evictions = 0

std::size_t currentEntries = 0

std::size_t currentBytes = 0

std::size_t budgetBytes = 0

[[nodiscard]] double hitRate() const noexcept

class AssetCache 16

explicit AssetCache(std::size_t budgetBytes = 0) noexcept

AssetCache(const AssetCache&) = delete

AssetCache& operator=(const AssetCache&) = delete

AssetCache(AssetCache&&) = delete

AssetCache& operator=(AssetCache&&) = delete

void setSizeEstimator(std::function<std::size_t(const T&)> estimator)

void put(const std::string& key, std::shared_ptr<T> asset)

[[nodiscard]] std::optional<std::shared_ptr<T>> get(const std::string& key)

[[nodiscard]] bool contains(const std::string& key) const

bool erase(const std::string& key)

void clear()

void setBudget(std::size_t bytes)

[[nodiscard]] CacheStatistics statistics() const

[[nodiscard]] std::size_t size() const

[[nodiscard]] std::size_t currentBytes() const

[[nodiscard]] std::size_t budgetBytes() const noexcept

class AssetHandle 10

AssetHandle() = default

AssetHandle(std::string id, std::shared_ptr<T> asset)

[[nodiscard]] T* get() const noexcept

[[nodiscard]] T* operator->() const noexcept

[[nodiscard]] T& operator*() const noexcept

[[nodiscard]] bool isLoaded() const noexcept

[[nodiscard]] explicit operator bool() const noexcept

[[nodiscard]] const std::string& id() const noexcept

[[nodiscard]] long useCount() const noexcept

void reset() noexcept

class AssetManager 9

template <typename LoaderT> requires AssetLoader<LoaderT> void registerLoader(LoaderT loader)

template <typename T> [[nodiscard]] AssetHandle<T> load(const std::string& id, std::string_view path)

template <typename T> AssetHandle<T> store(const std::string& id, std::shared_ptr<T> asset)

template <typename T> [[nodiscard]] AssetHandle<T> get(const std::string& id) const

void unload(const std::string& id)

[[nodiscard]] bool isLoaded(const std::string& id) const

[[nodiscard]] std::vector<std::string> loadedIds() const

void unloadAll()

[[nodiscard]] std::size_t cacheSize() const noexcept

class AssetPath 6

[[nodiscard]] static std::string executableDir()

[[nodiscard]] static std::string resolve(const std::string& relativePath)

static void setBasePath(const std::string& path)

[[nodiscard]] static std::string fromBase(const std::string& relativePath)

[[nodiscard]] inline TextureData resizeImage(const TextureData& input, std::uint32_t maxWidth, std::uint32_t maxHeight)

[[nodiscard]] inline std::vector<MipLevel> generateMipmaps(const TextureData& source)

class AssetProcessor 3

virtual ~AssetProcessor() = default

[[nodiscard]] virtual bool process(const std::string& inputPath, const std::string& outputPath) = 0

[[nodiscard]] virtual std::string name() const = 0

struct TextureData 4

std::uint32_t width = 0

std::uint32_t height = 0

std::uint32_t channels = 4

std::vector<std::uint8_t> pixels

struct MipLevel 3

std::uint32_t width = 0

std::uint32_t height = 0

std::vector<std::uint8_t> pixels

struct AtlasEntry 5

std::string name

std::uint32_t x = 0

std::uint32_t y = 0

std::uint32_t width = 0

std::uint32_t height = 0

struct TextureAtlas 4

TextureData image

std::vector<AtlasEntry> entries

std::uint32_t atlasWidth = 0

std::uint32_t atlasHeight = 0

class TextureProcessor : public AssetProcessor 9

explicit TextureProcessor(std::uint32_t maxWidth = 2048, std::uint32_t maxHeight = 2048, bool generateMips = true)

[[nodiscard]] bool process(const std::string& inputPath, const std::string& outputPath) override

[[nodiscard]] std::string name() const override

[[nodiscard]] TextureData processTexture(const TextureData& input) const

[[nodiscard]] std::uint32_t maxWidth() const noexcept

[[nodiscard]] std::uint32_t maxHeight() const noexcept

[[nodiscard]] bool generateMipsEnabled() const noexcept

[[nodiscard]] const std::string& lastInputPath() const noexcept

[[nodiscard]] const std::string& lastOutputPath() const noexcept

class TextureAtlasBuilder 5

void addImage(const std::string& name, TextureData texture)

[[nodiscard]] std::size_t imageCount() const noexcept

[[nodiscard]] TextureAtlas build(std::uint32_t atlasWidth, std::uint32_t atlasHeight) const

[[nodiscard]] static std::string generateMetadata(const TextureAtlas& atlas)

void clear()

struct ManifestEntry 5

std::string path

std::string type

std::uint64_t sizeBytes = 0

std::string hash

std::vector<std::string> dependencies

class AssetManifest 9

void addEntry(ManifestEntry entry)

[[nodiscard]] const ManifestEntry* getEntry(const std::string& path) const

[[nodiscard]] std::vector<ManifestEntry> allEntries() const

[[nodiscard]] std::size_t entryCount() const noexcept

bool generateManifest(const std::string& assetsDir)

[[nodiscard]] std::vector<std::string> validate(const std::string& assetsDir) const

[[nodiscard]] std::string serialize() const

void deserialize(const std::string& text)

void clear()

struct BundleFileEntry 3

std::string path

std::uint64_t offset = 0

std::uint64_t size = 0

struct BundleHeader 4

std::uint32_t magic = 0x4D545242

std::uint32_t version = 1

std::uint32_t fileCount = 0

std::vector<BundleFileEntry> files

struct BundleData 2

BundleHeader header

std::vector<std::uint8_t> payload

class AssetBundler 5

void addFile(const std::string& path, std::vector<std::uint8_t> data)

[[nodiscard]] std::size_t fileCount() const noexcept

[[nodiscard]] BundleData build() const

[[nodiscard]] BundleData buildFromManifest( const AssetManifest& manifest, const std::string& assetsDir) const

void clear()

class AssetBundleReader 7

void load(BundleData bundle)

[[nodiscard]] bool isLoaded() const noexcept

[[nodiscard]] std::uint32_t fileCount() const noexcept

[[nodiscard]] std::vector<std::string> filePaths() const

[[nodiscard]] std::vector<std::uint8_t> readFile(const std::string& path) const

[[nodiscard]] bool hasFile(const std::string& path) const

[[nodiscard]] std::uint64_t fileSize(const std::string& path) const

enum AssetPriority : std::uint8_t 4

Low = 0

Normal = 1

High = 2

Urgent = 3

class CancellationToken 3

CancellationToken()

void cancel() noexcept

[[nodiscard]] bool isCancelled() const noexcept

struct BatchProgress 4

std::size_t completed = 0

std::size_t total = 0

std::size_t failed = 0

[[nodiscard]] double ratio() const noexcept

class AsyncAssetLoader 9

explicit AsyncAssetLoader(AssetManager& assetManager, std::size_t threadCount = 0)

AsyncAssetLoader(const AsyncAssetLoader&) = delete

AsyncAssetLoader& operator=(const AsyncAssetLoader&) = delete

AsyncAssetLoader(AsyncAssetLoader&&) = delete

AsyncAssetLoader& operator=(AsyncAssetLoader&&) = delete

template <typename T> [[nodiscard]] std::future<AssetHandle<T>> load( const std::string& id, std::string_view path, AssetPriority priority = AssetPriority::Normal, CancellationToken token = CancellationToken{})

template <typename T> [[nodiscard]] std::vector<std::future<AssetHandle<T>>> loadBatch( const std::vector<std::pair<std::string, std::string>>& entries, std::function<void(const BatchProgress&)> progressCallback = nullptr, AssetPriority priority = AssetPriority::Normal, CancellationToken token = CancellationToken{})

[[nodiscard]] std::size_t pendingCount() const

[[nodiscard]] std::size_t workerCount() const noexcept

enum DdsFormat : std::uint8_t 5

Unknown

Rgba8Unorm

Bc1Unorm

Bc2Unorm

Bc3Unorm

struct DdsMipLevel 4

int width = 0

int height = 0

std::vector<std::uint8_t> data

[[nodiscard]] bool isValid() const noexcept

struct DdsTextureData 7

int width = 0

int height = 0

int mipCount = 0

DdsFormat format = DdsFormat::Unknown

std::vector<DdsMipLevel> mipLevels

[[nodiscard]] bool isValid() const noexcept

[[nodiscard]] bool isCompressed() const noexcept

class DdsImageLoader 3

[[nodiscard]] std::optional<DdsTextureData> loadDds(std::string_view path) const

[[nodiscard]] static std::optional<DdsTextureData> parseDds( const std::vector<std::uint8_t>& data)

[[nodiscard]] bool canLoad(std::string_view extension) const noexcept

struct EmbeddedAssetData 5

const uint8_t* data = nullptr

std::size_t size = 0

[[nodiscard]] bool valid() const noexcept

[[nodiscard]] std::string_view asStringView() const noexcept

[[nodiscard]] std::string asString() const

class EmbeddedAssets 7

[[nodiscard]] static EmbeddedAssets& instance()

void registerAsset(const std::string& name, const uint8_t* data, std::size_t size)

[[nodiscard]] EmbeddedAssetData get(const std::string& name) const

[[nodiscard]] bool has(const std::string& name) const

[[nodiscard]] std::size_t assetCount() const noexcept

[[nodiscard]] std::vector<std::string> assetNames() const

void clear()

struct FontMetrics 9

int glyphWidth = 8

int glyphHeight = 8

int firstChar = 32

int lastChar = 126

std::string name

[[nodiscard]] constexpr int glyphCount() const noexcept

[[nodiscard]] constexpr bool contains(char ch) const noexcept

[[nodiscard]] constexpr int textWidth(std::string_view text, int scale = 1) const noexcept

[[nodiscard]] constexpr int textHeight(int scale = 1) const noexcept

class FontLoader 5

FontLoader() noexcept = default

[[nodiscard]] std::optional<FontMetrics> loadFromFile(std::string_view path) const

[[nodiscard]] static std::optional<FontMetrics> parseMetrics(std::string_view content)

[[nodiscard]] static constexpr FontMetrics createDefault() noexcept

[[nodiscard]] static FontMetrics createCustom( std::string_view fontName, int glyphW, int glyphH, int first = 32, int last = 126)

class HotReloadManager 7

using Callback = std::function<void(const std::string&)>;

void watch(const std::string& path, Callback callback)

void unwatch(const std::string& path)

std::vector<std::string> pollChanges()

[[nodiscard]] std::size_t watchCount() const noexcept

[[nodiscard]] std::vector<std::string> watchedPaths() const

void unwatchAll()

enum FileChangeType : std::uint8_t 4

Modified

Created

Deleted

using FileChangeCallback = std::function<void(const FileChangeEvent&)>;

struct FileChangeEvent 3

std::string path

FileChangeType type = FileChangeType::Modified

std::chrono::steady_clock::time_point timestamp

class HotReloadWatcher 17

void setDebounceDelay(std::chrono::milliseconds delay) noexcept

[[nodiscard]] std::chrono::milliseconds debounceDelay() const noexcept

void watchFile(const std::string& path, FileChangeCallback callback)

void watchDirectory(const std::string& dirPath, const std::string& extension, FileChangeCallback callback)

std::vector<FileChangeEvent> update()

void unwatch(const std::string& path)

void unwatchAll()

[[nodiscard]] std::size_t watchedFileCount() const noexcept

[[nodiscard]] std::size_t watchedDirectoryCount() const noexcept

[[nodiscard]] std::vector<std::string> watchedFilePaths() const

[[nodiscard]] std::vector<std::string> watchedDirectoryPaths() const

[[nodiscard]] bool isWatching(const std::string& path) const

void watchShaders(const std::string& dirPath, FileChangeCallback callback)

void watchTextures(const std::string& dirPath, FileChangeCallback callback)

void watchScripts(const std::string& dirPath, FileChangeCallback callback)

void watchJsonFiles(const std::string& dirPath, FileChangeCallback callback)

template <typename T> concept AssetLoader = requires(T loader, std::string_view path)

class IAssetLoaderBase 3

virtual ~IAssetLoaderBase() = default

[[nodiscard]] virtual bool canLoad(std::string_view path) const = 0

[[nodiscard]] virtual std::any loadAny(std::string_view path) = 0

class TypedAssetLoader : public IAssetLoaderBase 5

using AssetType = typename LoaderT::AssetType;

explicit TypedAssetLoader(LoaderT loader)

[[nodiscard]] bool canLoad(std::string_view path) const override

[[nodiscard]] std::shared_ptr<AssetType> load(std::string_view path)

[[nodiscard]] std::any loadAny(std::string_view path) override

enum ImageFormat : std::uint8_t 7

Unknown

Bmp

Tga

Png

Jpeg

Dds

Ktx

struct ImageData 5

int width = 0

int height = 0

int channels = 4

std::vector<std::uint8_t> pixels

[[nodiscard]] bool isValid() const noexcept

class IImageLoader 3

virtual ~IImageLoader() = default

[[nodiscard]] virtual std::optional<ImageData> load(std::string_view path) = 0

[[nodiscard]] virtual bool canLoad(std::string_view extension) const = 0

class BmpImageLoader : public IImageLoader 2

[[nodiscard]] std::optional<ImageData> load(std::string_view path) override

[[nodiscard]] bool canLoad(std::string_view extension) const override

class TgaImageLoader : public IImageLoader 2

[[nodiscard]] std::optional<ImageData> load(std::string_view path) override

[[nodiscard]] bool canLoad(std::string_view extension) const override

class UnifiedImageLoader : public IImageLoader 6

[[nodiscard]] std::optional<ImageData> load(std::string_view path) override

[[nodiscard]] bool canLoad(std::string_view extension) const override

[[nodiscard]] std::optional<ImageData> loadFromMemory( const std::uint8_t* data, std::size_t size) const

[[nodiscard]] static ImageFormat detectFormatByPath(std::string_view path) noexcept

[[nodiscard]] static ImageFormat detectFormatByExtension(std::string_view ext) noexcept

[[nodiscard]] static ImageFormat detectFormatByMagic( const std::uint8_t* data, std::size_t size) noexcept

enum KtxFormat : std::uint32_t 14

Unknown = 0

Bc1Rgba = 0x8C4D

Bc2Rgba = 0x8C4E

Bc3Rgba = 0x8C4F

Bc7Rgba = 0x8E8C

Etc2Rgb8 = 0x9274

Etc2Rgba8 = 0x9278

Etc2Rgb8A1 = 0x9276

Astc4x4 = 0x93B0

Astc5x5 = 0x93B2

Astc6x6 = 0x93B4

Astc8x8 = 0x93B7

Rgba8 = 0x8058

Rgb8 = 0x8051

enum KtxVkFormat : std::uint32_t 13

Undefined = 0

Bc1RgbaUnorm = 131

Bc2UnormBlock = 135

Bc3UnormBlock = 137

Bc7UnormBlock = 145

Etc2Rgb8Unorm = 147

Etc2Rgba8Unorm = 151

Astc4x4Unorm = 157

Astc5x5Unorm = 159

Astc6x6Unorm = 161

Astc8x8Unorm = 165

R8G8B8A8Unorm = 37

R8G8B8Unorm = 23

struct KtxMipLevel 4

int width = 0

int height = 0

std::vector<std::uint8_t> data

[[nodiscard]] bool isValid() const noexcept

struct KtxTextureData 12

int width = 0

int height = 0

int mipCount = 0

KtxFormat glFormat = KtxFormat::Unknown

KtxVkFormat vkFormat = KtxVkFormat::Undefined

bool isKtx2 = false

std::vector<KtxMipLevel> mipLevels

[[nodiscard]] bool isValid() const noexcept

[[nodiscard]] bool isCompressed() const noexcept

[[nodiscard]] bool isAstc() const noexcept

[[nodiscard]] bool isEtc2() const noexcept

[[nodiscard]] bool isBc() const noexcept

class KtxImageLoader 7

[[nodiscard]] std::optional<KtxTextureData> loadKtx(std::string_view path) const

[[nodiscard]] bool canLoad(std::string_view extension) const noexcept

using PackageHandle = std::uint32_t;

using CommandRegistrar = std::function<void(const std::string& name, const std::string& desc)>;

using AssetPathRegistrar = std::function<void(const std::string& path)>;

using ScriptRunner = std::function<bool(const std::string& path)>;

inline constexpr PackageHandle INVALID_PACKAGE_HANDLE = 0

struct PackageCommand 2

std::string name

std::string description

struct PackageInfo 8

std::string id

std::string name

std::string version

std::string path

std::vector<std::string> dependencies

std::vector<std::string> headers

std::vector<PackageCommand> commands

std::string initScript

class PackageRuntime 16

PackageRuntime() = default

~PackageRuntime() = default

PackageRuntime(const PackageRuntime&) = delete

PackageRuntime& operator=(const PackageRuntime&) = delete

PackageRuntime(PackageRuntime&&) noexcept = default

PackageRuntime& operator=(PackageRuntime&&) noexcept = default

void setCommandRegistrar(CommandRegistrar r)

void setAssetPathRegistrar(AssetPathRegistrar r)

void setScriptRunner(ScriptRunner r)

[[nodiscard]] PackageHandle loadPackage(std::string_view path)

bool unloadPackage(PackageHandle handle)

[[nodiscard]] std::vector<PackageInfo> listLoaded() const

[[nodiscard]] bool isLoaded(std::string_view id) const

[[nodiscard]] const PackageInfo& getPackageInfo(PackageHandle handle) const

[[nodiscard]] std::size_t packageCount() const noexcept

[[nodiscard]] const std::string& lastError() const noexcept

enum TargetPlatform : uint8_t 2

Windows = 0

Web

struct PackageConfig 7

std::string gameName

std::string version

std::string assetsDir

std::string outputDir

TargetPlatform platform = TargetPlatform::Windows

std::string iconPath

bool includeDebugSymbols = false

struct PackageFileEntry 4

std::string relativePath

std::string sourcePath

uint64_t sizeBytes = 0

std::string hash

struct VersionMetadata 5

std::string version

std::string buildTimestamp

std::string gitHash

std::string platform

bool debugBuild = false

struct PackageResult 6

bool success = false

std::string outputPath

std::vector<PackageFileEntry> files

VersionMetadata metadata

uint64_t totalSizeBytes = 0

std::string errorMessage

struct DeltaEntry 6

enum `ChangeType : uint8_t` { Added = 0, Modified, Removed }

std::string relativePath

std::string oldHash

std::string newHash

uint64_t newSize = 0

ChangeType changeType = ChangeType::Modified

struct DeltaManifest 4

std::string fromVersion

std::string toVersion

std::vector<DeltaEntry> entries

uint64_t totalDeltaSize = 0

class PackagingTool 4

[[nodiscard]] PackageResult createPackage(const PackageConfig& config) const

[[nodiscard]] std::string createInstaller(const PackageConfig& config) const

[[nodiscard]] std::string createWebDeploy(const PackageConfig& config) const

[[nodiscard]] DeltaManifest createDeltaManifest( const std::vector<PackageFileEntry>& oldFiles, const std::vector<PackageFileEntry>& newFiles, const std::string& fromVersion, const std::string& toVersion) const

class StbImageHandle 14

StbImageHandle() noexcept = default

StbImageHandle(std::uint8_t* pixels, int width, int height, int channels) noexcept

~StbImageHandle()

StbImageHandle(const StbImageHandle&) = delete

StbImageHandle& operator=(const StbImageHandle&) = delete

StbImageHandle(StbImageHandle&& other) noexcept

StbImageHandle& operator=(StbImageHandle&& other) noexcept

[[nodiscard]] bool isValid() const noexcept

[[nodiscard]] const std::uint8_t* pixels() const noexcept

[[nodiscard]] int width() const noexcept

[[nodiscard]] int height() const noexcept

[[nodiscard]] int channels() const noexcept

[[nodiscard]] std::size_t sizeBytes() const noexcept

[[nodiscard]] ImageData toImageData() const

class PngImageLoader : public IImageLoader 5

[[nodiscard]] std::optional<ImageData> load(std::string_view path) override

[[nodiscard]] bool canLoad(std::string_view extension) const override

[[nodiscard]] static StbImageHandle decodeFromMemory( const std::uint8_t* data, std::size_t dataSize, int desiredChannels = 4)

[[nodiscard]] static StbImageHandle decodeFile( std::string_view path, int desiredChannels = 4)

[[nodiscard]] static std::string lastError()

class ResourceCache 7

[[nodiscard]] std::shared_ptr<render::Texture> getTexture(const std::string& path)

void registerTexture(const std::string& name, std::shared_ptr<render::Texture> tex)

[[nodiscard]] bool hasTexture(const std::string& path) const

[[nodiscard]] std::future<std::shared_ptr<render::Texture>> loadTextureAsync( const std::string& path)

void clearAll()

void clearTextures()

[[nodiscard]] int cachedTextureCount() const noexcept

enum StreamingState : std::uint8_t 5

Pending

Loading

Loaded

Failed

Evicted

struct StreamingRequest 6

std::string id

std::string path

float distanceFromCamera = 0.0f

std::uint8_t desiredMipLevel = 0

StreamingState state = StreamingState::Pending

[[nodiscard]] float priority() const noexcept

struct StreamingStatistics 7

std::size_t totalRequests = 0

std::size_t activeLoads = 0

std::size_t completedLoads = 0

std::size_t failedLoads = 0

std::size_t pendingRequests = 0

std::size_t memoryUsedBytes = 0

std::size_t memoryBudgetBytes = 0

class StreamingManager 18

using LoadFunction = std::function<std::shared_ptr<T>(const std::string& path, std::uint8_t mipLevel)>;

using SizeFunction = std::function<std::size_t(const T& asset)>;

explicit StreamingManager( std::size_t memoryBudgetBytes, std::shared_ptr<T> placeholder = nullptr, std::size_t threadCount = 0)

StreamingManager(const StreamingManager&) = delete

StreamingManager& operator=(const StreamingManager&) = delete

StreamingManager(StreamingManager&&) = delete

StreamingManager& operator=(StreamingManager&&) = delete

void setLoadFunction(LoadFunction func)

void setSizeEstimator(SizeFunction func)

void setPlaceholder(std::shared_ptr<T> placeholder)

void requestAsset( const std::string& id, const std::string& path, float distanceFromCamera, std::uint8_t mipLevel = 0)

void update(std::size_t maxDispatches = 4)

[[nodiscard]] std::shared_ptr<T> getAsset(const std::string& id)

[[nodiscard]] std::optional<StreamingState> getState(const std::string& id) const

void cancelRequest(const std::string& id)

void setMaxConcurrentLoads(std::size_t count) noexcept

[[nodiscard]] StreamingStatistics statistics() const

void clear()

class ThreadPool 10

explicit ThreadPool(std::size_t threadCount = 0)

ThreadPool(const ThreadPool&) = delete

ThreadPool& operator=(const ThreadPool&) = delete

ThreadPool(ThreadPool&&) = delete

ThreadPool& operator=(ThreadPool&&) = delete

~ThreadPool()

template <typename F, typename... Args> [[nodiscard]] auto submit(F&& func, Args&&... args) -> std::future<std::invoke_result_t<F, Args...>>

[[nodiscard]] std::size_t pendingCount() const

[[nodiscard]] std::size_t workerCount() const noexcept

void shutdown()

Sourced from docs/API_CATALOG.md, auto-generated by tools/generate_api_catalog.py.