GeorgH93/OpenVulkano
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request 'Marked all (probably) functions that take regular string instead of std::fs::path as deprecated' (#198) from using_std_fs_path into master

Browse Source 
Reviewed-on: https://git.madvoxel.net/OpenVulkano/OpenVulkano/pulls/198
Reviewed-by: Georg Hagen <georg.hagen@madvoxel.com>
This commit is contained in:
Vladyslav_Baranovskyi_EXT
2025-02-12 18:30:39 +01:00
parent 4da64d2d42 5cce011710
commit bf73c71e6b
27 changed files with 79 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
openVulkanoCpp/AR/ArRecorder.hpp
View File

@@ -121,7 +121,7 @@ namespace OpenVulkano::AR
* If path is changed after starting the recording, the already running recording will be moved to the new path.
* @param path The path to be used to store the recording
*/
void SetRecordingPath(const std::string& path)
[[deprecated]] void SetRecordingPath(const std::string& path)
{
std::filesystem::path p(path);
SetRecordingPath(p);

2
openVulkanoCpp/AR/ArSession.hpp
View File

@@ -114,7 +114,7 @@ namespace OpenVulkano::AR
* @param autoAdvance If set to true the playback will advance based on the stored timestamps. If set to false it will only advance if a new frame is requested.
* @return ArCreateResult about the status of the AR session creation. The session pointer will always be nullptr unless the status is SUCCESS.
*/
[[nodiscard]] static ArCreateResult CreatePlayback(const std::string& recordingPath, bool autoAdvance = true, bool loadImages = true, bool loadDepth = true);
[[nodiscard]] [[deprecated]] static ArCreateResult CreatePlayback(const std::string& recordingPath, bool autoAdvance = true, bool loadImages = true, bool loadDepth = true);
/**
* Creates a network streamed AR session. nullptr if failed to create session for given address. This will block till the connection with the remote host has been established.

4
openVulkanoCpp/AR/ArSessionMetadata.hpp
View File

@@ -60,8 +60,8 @@ namespace OpenVulkano::AR
static bool DirHasMetadata(const std::filesystem::path& dirPath);
static ArSessionMetadata FromXML(const std::string& filePath);
[[deprecated]] static ArSessionMetadata FromXML(const std::string& filePath);
static ArSessionMetadata FromYaml(const std::string& filePath);
[[deprecated]] static ArSessionMetadata FromYaml(const std::string& filePath);
};
}

2
openVulkanoCpp/AR/Provider/Playback/ArPlaybackReader.hpp
View File

@@ -47,7 +47,7 @@ namespace OpenVulkano::AR::Playback
size_t m_imgTotalSize = 0, m_imgReadSize = 0;
public:
ArPlaybackReader(const std::string& recDir)
[[deprecated]] ArPlaybackReader(const std::string& recDir)
{
std::string extensions = R"((_\d+|\.part\d+)?)" + std::string(TAR_EXTENSIONS_REGEX);
m_archiveMetadata.Open(recDir, ".*meta(data)?" + extensions);

4
openVulkanoCpp/AR/Provider/Playback/ArSessionPlayback.hpp
View File

@@ -15,7 +15,7 @@ namespace OpenVulkano::AR::Playback
class ArSessionPlayback final : public ArSession, public std::enable_shared_from_this<ArSessionPlayback>
{
public:
ArSessionPlayback(const std::string& recordingPath, bool autoAdvance, bool loadImages, bool loadDepth);
[[deprecated]] ArSessionPlayback(const std::string& recordingPath, bool autoAdvance, bool loadImages, bool loadDepth);
~ArSessionPlayback() override;
@@ -31,7 +31,7 @@ class ArSessionPlayback final : public ArSession, public std::enable_shared_from
[[nodiscard]] ArType GetArType() override;
[[nodiscard]] const std::string& GetPlaybackPath() const { return recordingPath; }
[[nodiscard]] [[deprecated]] const std::string& GetPlaybackPath() const { return recordingPath; }
[[nodiscard]] bool IsLoadColorEnabled() const { return loadImages; }
[[nodiscard]] bool IsLoadDepthEnabled() const { return loadDepth; }

2
openVulkanoCpp/Base/Logger.hpp
View File

@@ -35,7 +35,7 @@ namespace OpenVulkano
static Ptr PERF;
static Ptr APP;
static void SetupLogger(std::string logFolder = "", const std::string& logFile = "openVulkano.log", bool handleSignals = false);
[[deprecated]] static void SetupLogger(std::string logFolder = "", const std::string& logFile = "openVulkano.log", bool handleSignals = false);
/**
* \brief Creates a new custom logger that writes to the main log file.

2
openVulkanoCpp/Host/ExeAppendedZipResourceLoader.hpp
View File

@@ -16,7 +16,7 @@ namespace OpenVulkano
class ExeAppendedZipResourceLoader : public ResourceLoader
{
public:
std::string GetResourcePath(const std::string& resourceName) final { return ""; }
[[deprecated]] std::string GetResourcePath(const std::string& resourceName) final { return ""; }
Array<char> GetResource(const std::string& resourceName) override;
protected:
virtual std::string GetCurrentExecutablePath() const = 0;

2
openVulkanoCpp/Host/ResourceLoader.hpp
View File

@@ -19,7 +19,7 @@ namespace OpenVulkano
[[nodiscard]] virtual Array<char> GetResource(const std::string& resourceName) = 0;
[[nodiscard]] virtual std::string GetResourcePath(const std::string& resourceName) { return ""; }
[[nodiscard]] [[deprecated]] virtual std::string GetResourcePath(const std::string& resourceName) { return ""; }
static ResourceLoader& GetInstance();

2
openVulkanoCpp/Host/SystemFontResolver.hpp
View File

@@ -14,7 +14,7 @@ namespace OpenVulkano
class SystemFontResolver
{
public:
static const std::string& GetSystemFontPath(const std::string& fontName);
[[deprecated]] static const std::string& GetSystemFontPath(const std::string& fontName);
private:
static std::map<std::string, std::string> ReadSystemFonts();

2
openVulkanoCpp/Host/Windows/ResourceLoaderAppDirWindows.hpp
View File

@@ -13,7 +13,7 @@ namespace OpenVulkano
class ResourceLoaderAppDirWindows final : public ResourceLoader
{
public:
std::string GetResourcePath(const std::string& resourceName) override;
[[deprecated]] std::string GetResourcePath(const std::string& resourceName) override;
Array<char> GetResource(const std::string& resourceName) override;
};
}

4
openVulkanoCpp/IO/Archive/MultiPartArchiveWriter.hpp
View File

@@ -30,13 +30,13 @@ namespace OpenVulkano
void CheckSize(size_t size);
public:
MultiPartArchiveWriter(const std::string& dir, const std::string& fileNamePattern, const ArchiveConfiguration& archiveConfiguration, size_t sizeLimit = 2_GiB, bool lazyCreation = false, const std::shared_ptr<spdlog::logger>& logger = nullptr);
[[deprecated]] MultiPartArchiveWriter(const std::string& dir, const std::string& fileNamePattern, const ArchiveConfiguration& archiveConfiguration, size_t sizeLimit = 2_GiB, bool lazyCreation = false, const std::shared_ptr<spdlog::logger>& logger = nullptr);
~MultiPartArchiveWriter() override;
bool AddFile(const FileDescription& description, const void* buffer) override;
bool AddFile(const FileDescription& description, const std::vector<std::pair<const void*, size_t>>& buffers) override;
bool AddFile(const char* fileName, const char* inArchiveName) override;
[[deprecated]] bool AddFile(const char* fileName, const char* inArchiveName) override;
using IArchiveWriter::AddFile;
[[nodiscard]] virtual ArchiveOStream AddFileStream(const FileDescription& description) override;

6
openVulkanoCpp/Image/ImageLoader.hpp
View File

@@ -19,10 +19,10 @@ namespace OpenVulkano::Image
virtual ~IImageLoader() = default;
static std::unique_ptr<Image> loadData(const uint8_t* data, int size, int desiredChannels = 0);
virtual std::unique_ptr<Image> loadFromFile(const std::string& filePath) = 0;
[[deprecated]] virtual std::unique_ptr<Image> loadFromFile(const std::string& filePath) = 0;
virtual std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) = 0;
virtual Math::Vector2i GetImageDimensions(const std::string& filename) = 0;
[[deprecated]] virtual Math::Vector2i GetImageDimensions(const std::string& filename) = 0;
protected:
static Math::Vector2i GetDimensionsInternal(const std::string& filename);
[[deprecated]] static Math::Vector2i GetDimensionsInternal(const std::string& filename);
};
}

4
openVulkanoCpp/Image/ImageLoaderDds.hpp
View File

@@ -18,9 +18,9 @@ namespace OpenVulkano::Image
class ImageLoaderDds : public IImageLoader
{
public:
std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
[[deprecated]] std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override;
Math::Vector2i GetImageDimensions(const std::string& filename) override;
[[deprecated]] Math::Vector2i GetImageDimensions(const std::string& filename) override;
protected:
std::unique_ptr<Image> ExtractImage(dds::Image* ddsImage);

4
openVulkanoCpp/Image/ImageLoaderJpeg.hpp
View File

@@ -13,9 +13,9 @@ namespace OpenVulkano::Image
class ImageLoaderJpeg : public IImageLoader
{
public:
std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
[[deprecated]] std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override;
Math::Vector2i GetImageDimensions(const std::string& filename) override;
[[deprecated]] Math::Vector2i GetImageDimensions(const std::string& filename) override;
private:
std::unique_ptr<Image> loadJpeg(const uint8_t* data, size_t size);
};

4
openVulkanoCpp/Image/ImageLoaderKtx.hpp
View File

@@ -13,8 +13,8 @@ namespace OpenVulkano::Image
class ImageLoaderKtx : public IImageLoader
{
public:
std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
[[deprecated]] std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override;
Math::Vector2i GetImageDimensions(const std::string& filename) override;
[[deprecated]] Math::Vector2i GetImageDimensions(const std::string& filename) override;
};
}

4
openVulkanoCpp/Image/ImageLoaderPfm.hpp
View File

@@ -13,8 +13,8 @@ namespace OpenVulkano::Image
class ImageLoaderPfm : public IImageLoader
{
public:
std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
[[deprecated]] std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override;
Math::Vector2i GetImageDimensions(const std::string& filename) override;
[[deprecated]] Math::Vector2i GetImageDimensions(const std::string& filename) override;
};
}

4
openVulkanoCpp/Image/ImageLoaderPng.hpp
View File

@@ -13,8 +13,8 @@ namespace OpenVulkano::Image
class ImageLoaderPng : public IImageLoader
{
public:
std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
[[deprecated]] std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override;
Math::Vector2i GetImageDimensions(const std::string& filename) override;
[[deprecated]] Math::Vector2i GetImageDimensions(const std::string& filename) override;
};
}

4
openVulkanoCpp/Image/ImageLoaderPnm.hpp
View File

@@ -12,8 +12,8 @@ namespace OpenVulkano::Image
class ImageLoaderPnm : public IImageLoader
{
public:
std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
[[deprecated]] std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override;
Math::Vector2i GetImageDimensions(const std::string& filename) override;
[[deprecated]] Math::Vector2i GetImageDimensions(const std::string& filename) override;
};
}

27
openVulkanoCpp/Scene/Export/MeshWriter.cpp
View File

@@ -6,6 +6,7 @@
#include "MeshWriter.hpp"
#include "Base/Utils.hpp"
#include "Extensions/FmtFormatter.hpp"
#include "IO/MemMappedFile.hpp"
#include "Scene/Geometry.hpp"
#include "Scene/Vertex.hpp"
@@ -102,27 +103,27 @@ namespace
namespace OpenVulkano::Scene
{
void MeshWriter::WriteAsOBJ(Geometry* geometry, const std::string& filePath)
void MeshWriter::WriteAsOBJ(Geometry* geometry, const std::filesystem::path& filePath)
{
std::ofstream file(filePath);
if (!file.is_open()) [[unlikely]]
throw std::runtime_error("Failed to open file '" + filePath + "' for writing!");
throw std::runtime_error(fmt::format("Failed to open file '{}' for writing!", filePath));
WriteObjContents(geometry, "", file);
file.close();
}
void MeshWriter::WriteAsUSD(Geometry* geometry, const std::string& filePath)
void MeshWriter::WriteAsUSD(Geometry* geometry, const std::filesystem::path& filePath)
{
std::ofstream file(filePath);
if (!file.is_open()) [[unlikely]]
throw std::runtime_error("Failed to open file '" + filePath + "' for writing!");
throw std::runtime_error(fmt::format("Failed to open file '{}' for writing!", filePath));
WriteUsdContents(file, geometry);
file.close();
}
void MeshWriter::WriteObjAsZip(Geometry* geometry, const std::string& texturePath, const std::string& zipPath)
void MeshWriter::WriteObjAsZip(Geometry* geometry, const std::filesystem::path& texturePath, const std::filesystem::path& zipPath)
{
OpenVulkano::ArchiveWriter zipWriter(zipPath.c_str());
@@ -146,7 +147,7 @@ namespace OpenVulkano::Scene
}
}
void MeshWriter::WriteAsUSDZ(Geometry* geometry, const std::string& texturePath, const std::string& usdzPath)
void MeshWriter::WriteAsUSDZ(Geometry* geometry, const std::filesystem::path& texturePath, const std::filesystem::path& usdzPath)
{
OpenVulkano::ZipWriter zipWriter(usdzPath, true);
@@ -166,7 +167,7 @@ namespace OpenVulkano::Scene
}
}
void MeshWriter::WriteAsSTL(Geometry* geometry, const std::string& filePath, bool binary)
void MeshWriter::WriteAsSTL(Geometry* geometry, const std::filesystem::path& filePath, bool binary)
{
#if __has_include("assimp/Exporter.hpp")
std::unique_ptr<aiScene> scene(new aiScene());
@@ -178,7 +179,7 @@ namespace OpenVulkano::Scene
Assimp::Exporter exporter;
const char* formatId = binary ? "stlb" : "stl";
aiReturn result = exporter.Export(scene.get(), formatId, filePath);
aiReturn result = exporter.Export(scene.get(), formatId, filePath.string().c_str());
scene->mRootNode = nullptr;
scene->mMeshes = nullptr;
@@ -190,14 +191,14 @@ namespace OpenVulkano::Scene
if (result != aiReturn_SUCCESS)
{
throw std::runtime_error("Unable to write STL file to " + filePath + ": " + exporter.GetErrorString());
throw std::runtime_error(fmt::format("Unable to write STL file to {}: {}", filePath, exporter.GetErrorString()));
}
#else
throw std::runtime_error("Unable to export to STL: Assimp is not available!");
#endif
}
void MeshWriter::WriteAsFBX(Geometry* geometry, const std::string& texturePath, const std::string& fbxPath)
void MeshWriter::WriteAsFBX(Geometry* geometry, const std::filesystem::path& texturePath, const std::filesystem::path& fbxPath)
{
#if __has_include("assimp/Exporter.hpp")
std::unique_ptr<aiScene> scene(new aiScene());
@@ -209,12 +210,12 @@ namespace OpenVulkano::Scene
if (!texturePath.empty())
{
aiString externalPath(texturePath);
aiString externalPath(texturePath.string().c_str());
scene->mMaterials[0]->AddProperty(&externalPath, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
}
Assimp::Exporter exporter;
aiReturn result = exporter.Export(scene.get(), "fbx", fbxPath);
aiReturn result = exporter.Export(scene.get(), "fbx", fbxPath.string().c_str());
scene->mRootNode = nullptr;
scene->mMeshes = nullptr;
@@ -226,7 +227,7 @@ namespace OpenVulkano::Scene
if (result != aiReturn_SUCCESS)
{
throw std::runtime_error("Unable to write a fbx file to " + fbxPath + ": " + exporter.GetErrorString());
throw std::runtime_error(fmt::format("Unable to write a fbx file to {}: {}", fbxPath, exporter.GetErrorString()));
}
#else
throw std::runtime_error("Unable to convert the scene to FBX: Assimp is not available!");

14
openVulkanoCpp/Scene/Export/MeshWriter.hpp
View File

@@ -6,7 +6,7 @@
#pragma once
#include <string>
#include <filesystem>
namespace OpenVulkano::Scene
{
@@ -14,11 +14,11 @@ namespace OpenVulkano::Scene
class MeshWriter
{
public:
static void WriteAsOBJ(Geometry* geometry, const std::string& filePath);
static void WriteAsUSD(Geometry* geometry, const std::string& filePath);
static void WriteObjAsZip(Geometry* geometry, const std::string& texturePath, const std::string& zipPath);
static void WriteAsUSDZ(Geometry* geometry, const std::string& texturePath, const std::string& usdzPath);
static void WriteAsFBX(Geometry* geometry, const std::string& texturePath, const std::string& fbxPath);
static void WriteAsSTL(Geometry* geometry, const std::string& filePath, bool binary);
static void WriteAsOBJ(Geometry* geometry, const std::filesystem::path& filePath);
static void WriteAsUSD(Geometry* geometry, const std::filesystem::path& filePath);
static void WriteObjAsZip(Geometry* geometry, const std::filesystem::path& texturePath, const std::filesystem::path& zipPath);
static void WriteAsUSDZ(Geometry* geometry, const std::filesystem::path& texturePath, const std::filesystem::path& usdzPath);
static void WriteAsFBX(Geometry* geometry, const std::filesystem::path& texturePath, const std::filesystem::path& fbxPath);
static void WriteAsSTL(Geometry* geometry, const std::filesystem::path& filePath, bool binary);
};
}

30
openVulkanoCpp/Scene/MeshLoader.cpp
View File

@@ -7,6 +7,7 @@
#include "MeshLoader.hpp"
#include "Scene/Geometry.hpp"
#include "Base/Logger.hpp"
#include "Extensions/FmtFormatter.hpp"
#if __has_include("assimp/Importer.hpp")
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
@@ -26,17 +27,9 @@
#include "value-pprint.hh"
#include "value-types.hh"
namespace
{
static bool ends_with(std::string_view str, std::string_view suffix)
{
return str.size() >= suffix.size() && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
}
}
namespace OpenVulkano::Scene
{
void MeshLoader::ParseAssimpFile(Geometry *geometry, const std::string& file)
void MeshLoader::ParseAssimpFile(Geometry *geometry, const std::filesystem::path& file)
{
#ifdef ASSIMP_AVAILABLE
Assimp::Importer importer;
@@ -45,9 +38,9 @@ namespace OpenVulkano::Scene
aiProcess_ImproveCacheLocality | aiProcess_RemoveRedundantMaterials | aiProcess_GenUVCoords | aiProcess_TransformUVCoords |
aiProcess_ConvertToLeftHanded | aiProcess_PreTransformVertices | aiProcess_OptimizeGraph;
const aiScene* scene = importer.ReadFile(file, flags);
if (!scene) throw std::runtime_error("Failed to load file \"" + file + "\" Error: " + importer.GetErrorString());
if (!scene->HasMeshes()) throw std::runtime_error("File \"" + file + "\" does not have any meshes");
const aiScene* scene = importer.ReadFile(file.string().c_str(), flags);
if (!scene) throw std::runtime_error(fmt::format("Failed to load file \"{}\" Error: {}", file, importer.GetErrorString()));
if (!scene->HasMeshes()) throw std::runtime_error(fmt::format("File \"{}\" does not have any meshes", file));
if (scene->mNumMeshes > 1) Logger::DATA->warn("File {0} contains more than one mesh. Only first one will be loaded", file);
aiMesh *mesh = scene->mMeshes[0];
@@ -91,15 +84,15 @@ namespace OpenVulkano::Scene
#endif
}
void MeshLoader::ParseUSDFile(Geometry *geometry, const std::string& file)
void MeshLoader::ParseUSDFile(Geometry *geometry, const std::filesystem::path& file)
{
tinyusdz::Stage stage;
std::string warning, err;
auto result = tinyusdz::LoadUSDFromFile(file, &stage, &warning, &err);
auto result = tinyusdz::LoadUSDFromFile(file.string().c_str(), &stage, &warning, &err);
if (!result)
{
throw std::runtime_error("Failed to load USD file: " + file);
throw std::runtime_error(fmt::format("Failed to load USD file: {}", file));
}
for (auto &prim : stage.root_prims())
@@ -148,14 +141,15 @@ namespace OpenVulkano::Scene
}
}
}
throw std::runtime_error("No mesh found inside a xform in USD file: " + file);
throw std::runtime_error(fmt::format("No mesh found inside a xform in USD file: {}", file));
}
Geometry* MeshLoader::LoadFromFile(const std::string& file)
Geometry* MeshLoader::LoadFromFile(const std::filesystem::path& file)
{
Geometry* geometry = new Geometry();
if (ends_with(file, ".usd") || ends_with(file, ".usda") || ends_with(file, ".usdc") || ends_with(file, ".usdz"))
const std::filesystem::path ext = file.extension();
if (ext == ".usd" || ext == ".usda" || ext == ".usdc" || ext == ".usdz")
{
ParseUSDFile(geometry, file);
}

7
openVulkanoCpp/Scene/MeshLoader.hpp
View File

@@ -6,6 +6,7 @@
#pragma once
#include <filesystem>
#include <string>
namespace OpenVulkano::Scene
@@ -13,9 +14,9 @@ namespace OpenVulkano::Scene
class Geometry;
class MeshLoader
{
static void ParseAssimpFile(Geometry *geometry, const std::string& file);
static void ParseUSDFile(Geometry *geometry, const std::string& file);
static void ParseAssimpFile(Geometry *geometry, const std::filesystem::path& file);
static void ParseUSDFile(Geometry *geometry, const std::filesystem::path& file);
public:
static Geometry* LoadFromFile(const std::string& file);
static Geometry* LoadFromFile(const std::filesystem::path& file);
};
}

4
openVulkanoCpp/Scene/Text/BitmapFontAtlasGenerator.hpp
View File

@@ -42,8 +42,8 @@ namespace OpenVulkano::Scene
, m_subpixelLayout(subpixelLayout.value_or(SubpixelLayout::UNKNOWN))
{
}
void GenerateAtlas(const std::string& fontFile, const std::set<uint32_t>& charset,
const std::optional<std::string>& pngOutput = std::nullopt) override;
[[deprecated]] void GenerateAtlas(const std::string& fontFile, const std::set<uint32_t>& charset,
const std::optional<std::string>& pngOutput = std::nullopt) override;
void GenerateAtlas(const Array<char>& fontData, const std::set<uint32_t>& charset,
const std::optional<std::string>& pngOutput = std::nullopt) override;
private:

2
openVulkanoCpp/Scene/Text/FontAtlasFactory.hpp
View File

@@ -45,6 +45,6 @@ namespace OpenVulkano::Scene
const std::set<uint32_t>& charset = {}) const;
private:
Array<char> FindFont(const std::string& fontFile) const;
[[deprecated]] Array<char> FindFont(const std::string& fontFile) const;
};
}

4
openVulkanoCpp/Scene/Text/IFontAtlasGenerator.hpp
View File

@@ -20,8 +20,8 @@ namespace OpenVulkano::Scene
{
public:
virtual ~IFontAtlasGenerator() = default;
virtual void GenerateAtlas(const std::string& fontFile, const std::set<uint32_t>& charset,
const std::optional<std::string>& pngOutput = std::nullopt) = 0;
[[deprecated]] virtual void GenerateAtlas(const std::string& fontFile, const std::set<uint32_t>& charset,
const std::optional<std::string>& pngOutput = std::nullopt) = 0;
virtual void GenerateAtlas(const Array<char>& fontData, const std::set<uint32_t>& charset,
const std::optional<std::string>& pngOutput = std::nullopt) = 0;
virtual const std::shared_ptr<FontAtlas>& GetAtlas() const = 0;

9
openVulkanoCpp/Scene/Text/SdfFontAtlasGenerator.hpp
View File

@@ -42,12 +42,13 @@ namespace OpenVulkano::Scene
using Config = SdfFontAtlasGeneratorConfig;
static constexpr int channelsCount = (Channels == 1 ? 1 : 4);
SdfFontAtlasGeneratorGeneric();
void GenerateAtlas(const std::string& fontFile, const std::set<uint32_t>& charset,
const std::optional<std::string>& pngOutput = std::nullopt) override;
[[deprecated]] void GenerateAtlas(const std::string& fontFile, const std::set<uint32_t>& charset,
const std::optional<std::string>& pngOutput = std::nullopt) override;
void GenerateAtlas(const Array<char>& fontData, const std::set<uint32_t>& charset,
const std::optional<std::string>& pngOutput = std::nullopt) override;
void GenerateAtlas(const std::string& fontFile, const msdf_atlas::Charset& charset = msdf_atlas::Charset::ASCII,
const std::optional<std::string>& pngOutput = std::nullopt);
[[deprecated]] void GenerateAtlas(const std::string& fontFile,
const msdf_atlas::Charset& charset = msdf_atlas::Charset::ASCII,
const std::optional<std::string>& pngOutput = std::nullopt);
void GenerateAtlas(const msdfgen::byte* fontData, int length,
const msdf_atlas::Charset& charset = msdf_atlas::Charset::ASCII,
const std::optional<std::string>& pngOutput = std::nullopt);

5
openVulkanoCpp/Shader/ShaderCompiler.hpp
View File

@@ -14,8 +14,9 @@ namespace OpenVulkano
* @param entryPoint - the name of the void function in the shader
* @param shaderStage - type of the shader that needs to be compiled
*/
static Array<uint32_t> CompileGLSLToSpirv(const std::string& absPath, bool hasIncludes,
const std::string& incPath = std::string(), const std::string& entryPoint = "main")
[[deprecated]] static Array<uint32_t> CompileGLSLToSpirv(const std::string& absPath, bool hasIncludes,
const std::string& incPath = std::string(),
const std::string& entryPoint = "main")
#if defined(HAS_SHADERC)
;
#else