Provides static helper methods for file I/O and path management. More...

#include <utility.hpp>

Static Public Member Functions
static void	InitializePaths (int argc, char *argv[])
	Initializes engine paths based on the executable location.

static AppConfig	ReadConfigFile ()
	Reads application settings from the JSON config file.

static std::vector< char >	ReadShaderBinaryFile (std::string const &filename)
	Reads a binary shader file from disk.

static std::vector< std::string >	GetListOfFilesInDirectory (std::string directory)
	Returns a list of full file paths in the given directory.

static std::filesystem::path	GetApplicationPath ()
	Returns the absolute path of the running application.

static std::filesystem::path	GetBuildPath ()
	Returns the build output directory path.

static std::filesystem::path	GetShadersBinaryPath ()
	Returns the directory path containing compiled shader binaries.

static std::vector< std::string >	GetListOfFileNamesInDirectory (const char *directory, std::string extToSearch)
	Returns a list of file names in a directory matching the specified extension.

static std::filesystem::path	ResolveProjectRoot ()
	Resolves project root folder (handles Release/Debug/Binaries layouts).

static std::filesystem::path	GetContentFolderPath ()
	Returns absolute path to Content.

static std::filesystem::path	GetTextureFolderPath ()
	Returns absolute path to Content/Textures.

static std::filesystem::path	GetModelsFolderPath ()
	Returns absolute path to Content/Models.

static std::filesystem::path	GetFontsFolderPath ()
	Returns absolute path to Content/Fonts.

static std::filesystem::path	GetShadersFolderPath ()
	Returns absolute path to Content/Shaders.

static std::filesystem::path	GetConfigFilePath ()
	Returns absolute path to Config/app_config.json.

static std::filesystem::path	GetLogsFolderPath ()
	Returns absolute path to Logs folder.

static bool	IsPackageProvided ()
	Checks whether packed assets (Pack.bin / Pack.json) exist.

static const PackEntries &	GetPackEntries ()
	Returns the manifest of packed files.

static std::vector< uint8_t >	ReadPackedFile (const std::string &entryPath)
	Reads raw bytes of a file stored inside Pack.bin.

Static Public Attributes
static std::filesystem::path	sApplicationPath

static std::filesystem::path const	sDefaultShadersBinaryRelativePath = {"/Content/Shaders/"}

static std::filesystem::path	sBuildPath

static std::filesystem::path	sShadersBinaryPath

static std::filesystem::path const	sContentRelativePathFolder = path{} / "Content"

static std::filesystem::path const	sContentPackageFilePath = path{} / "Content" / "Pack.bin"

static std::filesystem::path const	sContentPackEntriesFilePath = path{} / "Content" / "Pack.json"

static std::filesystem::path const	sTextureRelativePathFolder = sContentRelativePathFolder / "Textures"

static std::filesystem::path const	sModelsRelativePathFolder = sContentRelativePathFolder / "Models"

static std::filesystem::path const	sFontsRelativePathFolder = sContentRelativePathFolder / "Fonts"

static std::filesystem::path const	sShadersRelativePathFolder = sContentRelativePathFolder / "Shaders"

static std::filesystem::path const	sAppConfigFilePath = path{} / "Config" / "app_config.json"

static std::filesystem::path const	sLogFolderPath = path{} / "Logs"

Detailed Description

Provides static helper methods for file I/O and path management.

The Utility class centralizes filesystem operations such as locating shader binaries, listing files, and resolving build or application paths.

All methods are static and thread-safe, designed for use throughout the engine.

Definition at line 72 of file utility.hpp.

Member Function Documentation

◆ GetApplicationPath()

std::filesystem::path rendering_engine::Utility::GetApplicationPath ( )

static

Returns the absolute path of the running application.

Returns: Application path as std::filesystem::path.

Definition at line 175 of file utility.cpp.

{
    return sApplicationPath;
}

◆ GetBuildPath()

std::filesystem::path rendering_engine::Utility::GetBuildPath ( )

static

Returns the build output directory path.

Returns: Build path as std::filesystem::path.

Definition at line 180 of file utility.cpp.

{
    return sBuildPath;
}

◆ GetConfigFilePath()

std::filesystem::path rendering_engine::Utility::GetConfigFilePath ( )

static

Returns absolute path to Config/app_config.json.

Definition at line 273 of file utility.cpp.

{
    return ResolveProjectRoot() / sAppConfigFilePath;
}

◆ GetContentFolderPath()

std::filesystem::path rendering_engine::Utility::GetContentFolderPath ( )

static

Returns absolute path to Content.

Definition at line 248 of file utility.cpp.

{
    return ResolveProjectRoot() / sContentRelativePathFolder;
}

◆ GetFontsFolderPath()

std::filesystem::path rendering_engine::Utility::GetFontsFolderPath ( )

static

Returns absolute path to Content/Fonts.

Definition at line 263 of file utility.cpp.

{
    return ResolveProjectRoot() / sFontsRelativePathFolder;
}

◆ GetListOfFileNamesInDirectory()

std::vector< std::string > rendering_engine::Utility::GetListOfFileNamesInDirectory	(	const char *	directory,
		std::string	extToSearch
	)

static

Returns a list of file names in a directory matching the specified extension.

Parameters

directory	Directory path.
extToSearch	File extension to match (e.g., ".spv").

Returns: Vector of matching file names.

Definition at line 205 of file utility.cpp.

{
    std::vector<std::string> imageFileNames;
 
    try
    {
        //check if parameter string is directory
        if(std::filesystem::exists(std::filesystem::path(directory)) && std::filesystem::is_directory(std::filesystem::path(directory)) )
        {
            std::filesystem::path pathToDirectory = std::filesystem::path(directory);
 
            if(std::filesystem::is_directory(pathToDirectory) )
            {
                for(const std::filesystem::directory_entry& x : std::filesystem::directory_iterator(pathToDirectory) )
                {
                    size_t dot = x.path().string().find_last_of(".");
 
                    if( extToSearch == x.path().string().substr(dot + 1) )
                    {
                        imageFileNames.push_back(x.path().string());
                    }
                }
            }
        }
    }
    catch( const std::filesystem::filesystem_error& ex )
    {
        std::cout << ex.what() << '\n';
    }
 
    return imageFileNames;
}

◆ GetListOfFilesInDirectory()

std::vector< std::string > rendering_engine::Utility::GetListOfFilesInDirectory ( std::string directory )

static

Returns a list of full file paths in the given directory.

Parameters

directory Directory path to search.

Returns: Vector of file paths.

Definition at line 141 of file utility.cpp.

{
    std::vector<std::string> shaderFileNames;
 
    try
    {
        //check if parameter string is directory
        if( std::filesystem::exists( std::filesystem::path( directory ) ) && std::filesystem::is_directory(std::filesystem::path( directory ) ) )
        {
            std::filesystem::path pathToDirectory = std::filesystem::path( directory );
 
            if(std::filesystem::is_directory( pathToDirectory ) )
            {
                for(const std::filesystem::directory_entry& x : std::filesystem::directory_iterator( pathToDirectory ) )
                {
                    size_t dot = x.path().string().find_last_of( "." );
 
                    if( std::string{ "spv" } == x.path().string().substr( dot + 1 ) )
                    {
                        std::cout << "Shader binary file: " << x.path().string() << "\n";
                        shaderFileNames.push_back( x.path().string() );
                    }
                }
            }
        }
    }
    catch( const std::filesystem::filesystem_error& ex )
    {
        std::cout << ex.what() << '\n';
    }
 
    return shaderFileNames;
}

◆ GetLogsFolderPath()

std::filesystem::path rendering_engine::Utility::GetLogsFolderPath ( )

static

Returns absolute path to Logs folder.

Definition at line 278 of file utility.cpp.

{
    return ResolveProjectRoot() / sLogFolderPath;
}

◆ GetModelsFolderPath()

std::filesystem::path rendering_engine::Utility::GetModelsFolderPath ( )

static

Returns absolute path to Content/Models.

Definition at line 258 of file utility.cpp.

{
    return ResolveProjectRoot() / sModelsRelativePathFolder;
}

◆ GetPackEntries()

const PackEntries & rendering_engine::Utility::GetPackEntries ( )

static

Returns the manifest of packed files.

Definition at line 290 of file utility.cpp.

{
    if (sPackEntriesLoaded)
        return sPackEntries;
 
    sPackEntries.clear();
 
    // Path to Pack.json
    const std::filesystem::path jsonPath = ResolveProjectRoot() / sContentPackEntriesFilePath;
 
    if (!std::filesystem::exists(jsonPath))
    {
        sPackEntriesLoaded = true;
        return sPackEntries; // empty
    }
 
    // Load JSON
    std::ifstream f(jsonPath.string());
    if (!f.is_open())
    {
        std::cerr << "[ERROR] Failed to open Pack.json\n";
        sPackEntriesLoaded = true;
        return sPackEntries;
    }
 
    nlohmann::json j;
    f >> j;
 
    // Parse entries
    for (auto it = j.begin(); it != j.end(); ++it)
    {
        PackEntry entry;
        entry.offset = it.value().value("offset", std::size_t{ 0 });
        entry.size = it.value().value("size", std::size_t{ 0 });
        sPackEntries[it.key()] = entry;
    }
 
    sPackEntriesLoaded = true;
    return sPackEntries;
}

◆ GetShadersBinaryPath()

std::filesystem::path rendering_engine::Utility::GetShadersBinaryPath ( )

static

Returns the directory path containing compiled shader binaries.

Returns: Shader binary path as std::filesystem::path.

Definition at line 185 of file utility.cpp.

{
    return sShadersBinaryPath;
}

◆ GetShadersFolderPath()

std::filesystem::path rendering_engine::Utility::GetShadersFolderPath ( )

static

Returns absolute path to Content/Shaders.

Definition at line 268 of file utility.cpp.

{
    return ResolveProjectRoot() / sShadersRelativePathFolder;
}

◆ GetTextureFolderPath()

std::filesystem::path rendering_engine::Utility::GetTextureFolderPath ( )

static

Returns absolute path to Content/Textures.

Definition at line 253 of file utility.cpp.

{
    return ResolveProjectRoot() / sTextureRelativePathFolder;
}

◆ InitializePaths()

void rendering_engine::Utility::InitializePaths	(	int	argc,
		char *	argv[]
	)

static

Initializes engine paths based on the executable location.

Should be called once during startup to establish base directories for application, build, and shader assets.

Parameters

argc	Command-line argument count.
argv	Command-line argument vector.

Definition at line 27 of file utility.cpp.

{
    static_cast<void>(argc);
 
    sApplicationPath = std::filesystem::path(argv[0]);
 
    sBuildPath = FindPath( "Build" );
    sShadersBinaryPath = sBuildPath += sDefaultShadersBinaryRelativePath;
}

◆ IsPackageProvided()

bool rendering_engine::Utility::IsPackageProvided ( )

static

Checks whether packed assets (Pack.bin / Pack.json) exist.

Definition at line 283 of file utility.cpp.

{
    const auto root = ResolveProjectRoot();
    return std::filesystem::exists(root / sContentPackageFilePath) &&
        std::filesystem::exists(root / sContentPackEntriesFilePath);
}

◆ ReadConfigFile()

AppConfig rendering_engine::Utility::ReadConfigFile ( )

static

Reads application settings from the JSON config file.

Missing or invalid fields fall back to default AppConfig values.

Returns: Populated AppConfig structure.

Definition at line 37 of file utility.cpp.

{
    AppConfig cfg;
 
    std::ifstream f(GetConfigFilePath().string());
    if (!f.is_open())
    {
        return cfg;
    }
 
    try
    {
        nlohmann::json appConfigData = nlohmann::json::parse(f);
 
        if (appConfigData.contains("appName"))
            cfg.appName = appConfigData["appName"].get<std::string>();
 
        if (appConfigData.contains("isFullScreen"))
            cfg.isFullScreen = appConfigData["isFullScreen"].get<bool>();
 
        if (appConfigData.contains("screenWidth"))
            cfg.screenWidth = appConfigData["screenWidth"].get<float>();
 
        if (appConfigData.contains("screenHeight"))
            cfg.screenHeight = appConfigData["screenHeight"].get<float>();
 
        if (appConfigData.contains("text"))
        {
            const auto& textNode = appConfigData["text"];
 
            if (textNode.contains("scripts") && textNode["scripts"].is_array())
            {
                for (const auto& script : textNode["scripts"])
                {
                    if (script.is_string())
                    {
                        auto found = std::find(cfg.textScripts.begin(), cfg.textScripts.end(), script);
                        if(found == cfg.textScripts.end())
                        {
                            cfg.textScripts.push_back(script.get<std::string>());
                        }
                    }
                }
            }
 
            if (textNode.contains("fontSizePreload") && textNode["fontSizePreload"].is_array())
            {
                for (const auto& fontSize : textNode["fontSizePreload"])
                {
                    auto found = std::find(cfg.fontSizePreload.begin(), cfg.fontSizePreload.end(), fontSize);
                    if (found == cfg.fontSizePreload.end())
                    {
                        cfg.fontSizePreload.push_back(fontSize.get<unsigned int>());
                    }
                }
            }
        }
 
        if (appConfigData.contains("logLevel"))
            cfg.logLevel = appConfigData["logLevel"].get<std::string>();
 
        if (appConfigData.contains("useSmoothedFPS"))
            cfg.useSmoothedFPS = appConfigData["useSmoothedFPS"].get<bool>();
 
        if (appConfigData.contains("targetFPS"))
            cfg.targetFPS = appConfigData["targetFPS"].get<float>();
 
        if (appConfigData.contains("showStatsOverlay"))
            cfg.showStatsOverlay = appConfigData["showStatsOverlay"].get<bool>();
        
    }
    catch (const std::exception&)
    {
        return cfg;
    }
 
    return cfg;
}

◆ ReadPackedFile()

std::vector< uint8_t > rendering_engine::Utility::ReadPackedFile ( const std::string & entryPath )

static

Reads raw bytes of a file stored inside Pack.bin.

Parameters

entryPath Virtual path inside the pack (e.g. "Textures/my.png").

Returns: Decoded file bytes, or empty vector on failure.

Definition at line 331 of file utility.cpp.

{
    std::vector<std::uint8_t> data;
 
    if (!IsPackageProvided())
        return data;
 
    const path binPath = ResolveProjectRoot() / sContentPackageFilePath;
    const path jsonPath = ResolveProjectRoot() / sContentPackEntriesFilePath;
 
    if (!std::filesystem::exists(binPath) ||
        !std::filesystem::exists(jsonPath))
    {
        std::cerr << "[Utility::ReadPackedFile] Missing Pack.bin or Pack.json\n";
        return data;
    }
 
    GetPackEntries();
    // Check if this entry exists in Pack.json
    auto it = sPackEntries.find(entryPath);
    if (it == sPackEntries.end())
    {
        std::cerr << "[Utility::ReadPackedFile] No such packed entry: "
            << entryPath << std::endl;
        return data; // empty
    }
 
    const PackEntry& entry = it->second;
 
    std::ifstream bin(binPath.string(), std::ios::binary);
    if (!bin)
    {
        std::cerr << "[Utility::ReadPackedFile] Failed to open Pack.bin: "
            << binPath.string() << std::endl;
        return data;
    }
 
    // Read the memory region [offset, offset + size)
 
    data.resize(entry.size);
 
    if (entry.offset > static_cast<std::size_t>(std::numeric_limits<std::streamoff>::max()))
    {
        std::cerr << "[Utility::ReadPackedFile] Entry offset exceeds supported file range: "
            << entryPath << std::endl;
        return {};
    }
 
    bin.seekg(static_cast<std::streamoff>(entry.offset), std::ios::beg);
 
    if (!bin.good())
    {
        std::cerr << "[Utility::ReadPackedFile] Seek error for entry: "
            << entryPath << std::endl;
        return {};
    }
 
    if (entry.size >
        static_cast<std::size_t>(std::numeric_limits<std::streamsize>::max()))
    {
        std::cerr << "[Utility::ReadPackedFile] Entry size exceeds supported read range: "
            << entryPath << std::endl;
        return {};
    }
 
    bin.read(
        reinterpret_cast<char*>(data.data()),
        static_cast<std::streamsize>(entry.size));
 
    if (!bin.good())
    {
        std::cerr << "[Utility::ReadPackedFile] Read error for entry: "
            << entryPath << std::endl;
        return {};
    }
 
    return data;
}

◆ ReadShaderBinaryFile()

std::vector< char > rendering_engine::Utility::ReadShaderBinaryFile ( std::string const & filename )

static

Reads a binary shader file from disk.

Parameters

filename Path to the shader file.

Returns: Vector containing the binary data.

Definition at line 116 of file utility.cpp.

{
    std::ifstream file(filename, std::ios::ate | std::ios::binary);
 
    if (!file.is_open()) 
    {
        throw std::runtime_error("failed to open shader binary file!");
    }
 
    const auto fileSize = file.tellg();
    if (fileSize < 0)
    {
        throw std::runtime_error("failed to determine shader binary file size!");
    }
 
    std::vector<char> buffer(static_cast<size_t>(fileSize));
 
    file.seekg(0);
    file.read(buffer.data(), static_cast<std::streamsize>(fileSize));
 
    file.close();
 
    return buffer;
}

◆ ResolveProjectRoot()

std::filesystem::path rendering_engine::Utility::ResolveProjectRoot ( )

static

Resolves project root folder (handles Release/Debug/Binaries layouts).

Definition at line 238 of file utility.cpp.

{
    auto exeDir = std::filesystem::canonical(std::filesystem::path(std::filesystem::current_path())); // default
    if (exeDir.filename() == "Debug" || exeDir.filename() == "Release")
        exeDir = exeDir.parent_path(); // step out of Debug/Release
    if (exeDir.filename() == "Binaries")
        exeDir = exeDir.parent_path(); // step out of Binaries
    return exeDir;
}

Member Data Documentation

◆ sAppConfigFilePath

path const rendering_engine::Utility::sAppConfigFilePath = path{} / "Config" / "app_config.json"

static

Definition at line 189 of file utility.hpp.

◆ sApplicationPath

path rendering_engine::Utility::sApplicationPath

static

Definition at line 178 of file utility.hpp.

◆ sBuildPath

path rendering_engine::Utility::sBuildPath

static

Definition at line 180 of file utility.hpp.

◆ sContentPackageFilePath

path const rendering_engine::Utility::sContentPackageFilePath = path{} / "Content" / "Pack.bin"

static

Definition at line 183 of file utility.hpp.

◆ sContentPackEntriesFilePath

path const rendering_engine::Utility::sContentPackEntriesFilePath = path{} / "Content" / "Pack.json"

static

Definition at line 184 of file utility.hpp.

◆ sContentRelativePathFolder

path const rendering_engine::Utility::sContentRelativePathFolder = path{} / "Content"

static

Definition at line 182 of file utility.hpp.

◆ sDefaultShadersBinaryRelativePath

path const rendering_engine::Utility::sDefaultShadersBinaryRelativePath = {"/Content/Shaders/"}

static

Definition at line 179 of file utility.hpp.

◆ sFontsRelativePathFolder

path const rendering_engine::Utility::sFontsRelativePathFolder = sContentRelativePathFolder / "Fonts"

static

Definition at line 187 of file utility.hpp.

◆ sLogFolderPath

path const rendering_engine::Utility::sLogFolderPath = path{} / "Logs"

static

Definition at line 190 of file utility.hpp.

◆ sModelsRelativePathFolder

path const rendering_engine::Utility::sModelsRelativePathFolder = sContentRelativePathFolder / "Models"

static

Definition at line 186 of file utility.hpp.

◆ sShadersBinaryPath

path rendering_engine::Utility::sShadersBinaryPath

static

Definition at line 181 of file utility.hpp.

◆ sShadersRelativePathFolder

path const rendering_engine::Utility::sShadersRelativePathFolder = sContentRelativePathFolder / "Shaders"

static

Definition at line 188 of file utility.hpp.

◆ sTextureRelativePathFolder

path const rendering_engine::Utility::sTextureRelativePathFolder = sContentRelativePathFolder / "Textures"

static

Definition at line 185 of file utility.hpp.

The documentation for this class was generated from the following files:

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation

◆ GetApplicationPath()

◆ GetBuildPath()

◆ GetConfigFilePath()

◆ GetContentFolderPath()

◆ GetFontsFolderPath()

◆ GetListOfFileNamesInDirectory()

◆ GetListOfFilesInDirectory()

◆ GetLogsFolderPath()

◆ GetModelsFolderPath()

◆ GetPackEntries()

◆ GetShadersBinaryPath()

◆ GetShadersFolderPath()

◆ GetTextureFolderPath()

◆ InitializePaths()

◆ IsPackageProvided()

◆ ReadConfigFile()

◆ ReadPackedFile()

◆ ReadShaderBinaryFile()

◆ ResolveProjectRoot()

Member Data Documentation

◆ sAppConfigFilePath

◆ sApplicationPath

◆ sBuildPath

◆ sContentPackageFilePath

◆ sContentPackEntriesFilePath

◆ sContentRelativePathFolder

◆ sDefaultShadersBinaryRelativePath

◆ sFontsRelativePathFolder

◆ sLogFolderPath

◆ sModelsRelativePathFolder

◆ sShadersBinaryPath

◆ sShadersRelativePathFolder

◆ sTextureRelativePathFolder