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 boost::filesystem::path	GetApplicationPath ()
	Returns the absolute path of the running application.
static boost::filesystem::path	GetBuildPath ()
	Returns the build output directory path.
static boost::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 boost::filesystem::path	ResolveProjectRoot ()
	Resolves project root folder (handles Release/Debug/Binaries layouts).
static boost::filesystem::path	GetTextureFolderPath ()
	Returns absolute path to Content/Textures.
static boost::filesystem::path	GetModelsFolderPath ()
	Returns absolute path to Content/Models.
static boost::filesystem::path	GetShadersFolderPath ()
	Returns absolute path to Content/Shaders.
static boost::filesystem::path	GetConfigFilePath ()
	Returns absolute path to Config/app_config.json.
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 boost::filesystem::path	sApplicationPath
static boost::filesystem::path const	sDefaultShadersBinaryRelativePath = {"/Content/Shaders/"}
static boost::filesystem::path	sBuildPath
static boost::filesystem::path	sShadersBinaryPath
static boost::filesystem::path const	sContentRelativePathFolder = path{} / "Content"
static boost::filesystem::path const	sContentPackageFilePath = path{} / "Content" / "Pack.bin"
static boost::filesystem::path const	sContentPackEntriesFilePath = path{} / "Content" / "Pack.json"
static boost::filesystem::path const	sTextureRelativePathFolder = sContentRelativePathFolder / "Textures"
static boost::filesystem::path const	sModelsRelativePathFolder = sContentRelativePathFolder / "Models"
static boost::filesystem::path const	sShadersRelativePathFolder = sContentRelativePathFolder / "Shaders"
static boost::filesystem::path const	sAppConfigFilePath = path{} / "Config" / "app_config.json"

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 59 of file utility.hpp.

Member Function Documentation

◆ GetApplicationPath()

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

static

Returns the absolute path of the running application.

Returns: Application path as boost::filesystem::path.

Definition at line 120 of file utility.cpp.

{
    return sApplicationPath;
}

◆ GetBuildPath()

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

static

Returns the build output directory path.

Returns: Build path as boost::filesystem::path.

Definition at line 125 of file utility.cpp.

{
    return sBuildPath;
}

◆ GetConfigFilePath()

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

static

Returns absolute path to Config/app_config.json.

Definition at line 207 of file utility.cpp.

{
    return ResolveProjectRoot() / sAppConfigFilePath;
}

◆ 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 149 of file utility.cpp.

{
    std::vector<std::string> imageFileNames;
 
    try
    {
        //check if parameter string is directory
        if( boost::filesystem::exists(boost::filesystem::path(directory)) && boost::filesystem::is_directory(boost::filesystem::path(directory)) )
        {
            boost::filesystem::path pathToDirectory = boost::filesystem::path(directory);
 
            if( boost::filesystem::is_directory(pathToDirectory) )
            {
                for( boost::filesystem::directory_entry& x : boost::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 boost::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 86 of file utility.cpp.

{
    std::vector<std::string> shaderFileNames;
 
    try
    {
        //check if parameter string is directory
        if( boost::filesystem::exists( boost::filesystem::path( directory ) ) && boost::filesystem::is_directory( boost::filesystem::path( directory ) ) )
        {
            boost::filesystem::path pathToDirectory = boost::filesystem::path( directory );
 
            if( boost::filesystem::is_directory( pathToDirectory ) )
            {
                for( boost::filesystem::directory_entry& x : boost::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 boost::filesystem::filesystem_error& ex )
    {
        std::cout << ex.what() << '\n';
    }
 
    return shaderFileNames;
}

◆ GetModelsFolderPath()

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

static

Returns absolute path to Content/Models.

Definition at line 197 of file utility.cpp.

{
    return ResolveProjectRoot() / sModelsRelativePathFolder;
}

◆ GetPackEntries()

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

static

Returns the manifest of packed files.

Definition at line 219 of file utility.cpp.

{
    if (sPackEntriesLoaded)
        return sPackEntries;
 
    sPackEntries.clear();
 
    // Path to Pack.json
    const boost::filesystem::path jsonPath = ResolveProjectRoot() / sContentPackEntriesFilePath;
 
    if (!boost::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", 0);
        entry.size = it.value().value("size", 0);
        sPackEntries[it.key()] = entry;
    }
 
    sPackEntriesLoaded = true;
    return sPackEntries;
}

◆ GetShadersBinaryPath()

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

static

Returns the directory path containing compiled shader binaries.

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

Definition at line 130 of file utility.cpp.

{
    return sShadersBinaryPath;
}

◆ GetShadersFolderPath()

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

static

Returns absolute path to Content/Shaders.

Definition at line 202 of file utility.cpp.

{
    return ResolveProjectRoot() / sShadersRelativePathFolder;
}

◆ GetTextureFolderPath()

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

static

Returns absolute path to Content/Textures.

Definition at line 192 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 24 of file utility.cpp.

{
    sApplicationPath = boost::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 212 of file utility.cpp.

{
    const auto root = ResolveProjectRoot();
    return boost::filesystem::exists(root / sContentPackageFilePath) &&
        boost::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 32 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>();
    }
    catch (const std::exception& e)
    {
        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 260 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 (!boost::filesystem::exists(binPath) ||
        !boost::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);
 
    bin.seekg(entry.offset, std::ios::beg);
    if (!bin.good())
    {
        std::cerr << "[Utility::ReadPackedFile] Seek error for entry: "
            << entryPath << std::endl;
        return {};
    }
 
    bin.read(reinterpret_cast<char*>(data.data()), 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 66 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!");
    }
 
    size_t fileSize = (size_t) file.tellg();
    std::vector<char> buffer(fileSize);
 
    file.seekg(0);
    file.read(buffer.data(), fileSize);
 
    file.close();
 
    return buffer;
}

◆ ResolveProjectRoot()

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

static

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

Definition at line 182 of file utility.cpp.

{
    auto exeDir = boost::filesystem::canonical(boost::filesystem::path(boost::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 166 of file utility.hpp.

◆ sApplicationPath

path rendering_engine::Utility::sApplicationPath

static

Definition at line 156 of file utility.hpp.

◆ sBuildPath

path rendering_engine::Utility::sBuildPath

static

Definition at line 158 of file utility.hpp.

◆ sContentPackageFilePath

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

static

Definition at line 161 of file utility.hpp.

◆ sContentPackEntriesFilePath

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

static

Definition at line 162 of file utility.hpp.

◆ sContentRelativePathFolder

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

static

Definition at line 160 of file utility.hpp.

◆ sDefaultShadersBinaryRelativePath

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

static

Definition at line 157 of file utility.hpp.

◆ sModelsRelativePathFolder

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

static

Definition at line 164 of file utility.hpp.

◆ sShadersBinaryPath

path rendering_engine::Utility::sShadersBinaryPath

static

Definition at line 159 of file utility.hpp.

◆ sShadersRelativePathFolder

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

static

Definition at line 165 of file utility.hpp.

◆ sTextureRelativePathFolder

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

static

Definition at line 163 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()

◆ GetListOfFileNamesInDirectory()

◆ GetListOfFilesInDirectory()

◆ GetModelsFolderPath()

◆ GetPackEntries()

◆ GetShadersBinaryPath()

◆ GetShadersFolderPath()

◆ GetTextureFolderPath()

◆ InitializePaths()

◆ IsPackageProvided()

◆ ReadConfigFile()

◆ ReadPackedFile()

◆ ReadShaderBinaryFile()

◆ ResolveProjectRoot()

Member Data Documentation

◆ sAppConfigFilePath

◆ sApplicationPath

◆ sBuildPath

◆ sContentPackageFilePath

◆ sContentPackEntriesFilePath

◆ sContentRelativePathFolder

◆ sDefaultShadersBinaryRelativePath

◆ sModelsRelativePathFolder

◆ sShadersBinaryPath

◆ sShadersRelativePathFolder

◆ sTextureRelativePathFolder