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

Merge pull request 'TextUpdate' (#187) from TextUpdate into master

Browse Source 
Reviewed-on: https://git.madvoxel.net/OpenVulkano/OpenVulkano/pulls/187
This commit is contained in:
Georg Hagen
2025-01-11 20:20:12 +01:00
parent ce57ed2091 006968fb4c
commit c976d75715
18 changed files with 353 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
3rdParty/CMakeLists.txt vendored
View File

@@ -28,7 +28,7 @@ add_subdirectory(tracy)
add_subdirectory(libstud-uuid)
add_subdirectory(rapidyaml)
add_subdirectory(libarchive)
add_subdirectory(boost)
#add_subdirectory(boost)
add_subdirectory(units)
add_subdirectory(libjpeg-turbo)
add_subdirectory(msdf)

8
examples/ExampleApps/TextExampleApp.cpp
View File

@@ -7,10 +7,10 @@
#include "TextExampleApp.hpp"
#include "Scene/Scene.hpp"
#include "Scene/Shader/Shader.hpp"
#include "Scene/Geometry.hpp"
#include "Scene/TextDrawable.hpp"
#include "Scene/Vertex.hpp"
#include "Scene/UI/PerformanceInfo.hpp"
#include "Scene/Text/FontAtlas.hpp"
#include "Input/InputManager.hpp"
#include "Host/GraphicsAppManager.hpp"
#include "Host/GLFW/WindowGLFW.hpp"
@@ -68,15 +68,15 @@ namespace OpenVulkano
std::set<uint32_t> s = BitmapFontAtlasGenerator::LoadAllGlyphs(fontPath);
BitmapFontAtlasGenerator generator;
generator.GenerateAtlas(fontPath, s);
generator.SaveAtlasMetadataInfo("bitmap_atlas");
generator.GetAtlas()->Save("bitmap_atlas_packed.png");
}
#if defined(MSDFGEN_AVAILABLE) && CREATE_NEW_ATLAS
std::set<uint32_t> s = SdfFontAtlasGenerator::LoadAllGlyphs(fontPath);
m_atlasGenerator.GenerateAtlas(fontPath, s);
m_msdfAtlasGenerator.GenerateAtlas(fontPath, s);
m_atlasGenerator.SaveAtlasMetadataInfo("sdf_atlas.png");
m_msdfAtlasGenerator.SaveAtlasMetadataInfo("msdf_atlas");
m_atlasGenerator.GetAtlas()->Save("sdf_atlas_packed.png");
m_msdfAtlasGenerator.GetAtlas()->Save("msdf_atlas_packed.png");
#else
auto sdfMetadataInfo = resourceLoader.GetResource("sdf_atlas_packed.png");
auto msdfMetadataInfo = resourceLoader.GetResource("msdf_atlas_packed.png");

8
openVulkanoCpp/Base/Wrapper.hpp
View File

@@ -13,4 +13,12 @@ namespace OpenVulkano
template<typename T> using Ptr = std::shared_ptr<T>;
template<typename T> using Weak = std::weak_ptr<T>;
template<typename T> using Unique = std::unique_ptr<T>;
template<typename T = void>
struct FreeDelete
{
void operator()(T* x) const { free(x); }
};
template<typename T> using UniqueMalloc = std::unique_ptr<T, FreeDelete<T>>;
}

6
openVulkanoCpp/Data/Containers/Array.hpp
View File

@@ -13,6 +13,7 @@
#include <vector>
#include <stdexcept>
#include <string>
#include <span>
namespace OpenVulkano
{
@@ -171,6 +172,11 @@ namespace OpenVulkano
return data;
}
operator std::span<T>() const noexcept
{
return { data, size };
}
iterator Begin() noexcept
{
return data;

14
openVulkanoCpp/Scene/BitmapFontAtlasGenerator.cpp
View File

@@ -6,6 +6,7 @@
#include "BitmapFontAtlasGenerator.hpp"
#include "Base/Logger.hpp"
#include "Text/FontAtlas.hpp"
namespace OpenVulkano::Scene
{
@@ -31,7 +32,6 @@ namespace OpenVulkano::Scene
return;
}
m_atlasData = std::make_shared<AtlasData>();
const auto& [lib, face] = FontAtlasGeneratorBase::InitFreetype(source);
FT_Set_Pixel_Sizes(face.get(), 0, m_pixelSizeConfig.CalculatePixelSize());
@@ -47,12 +47,9 @@ namespace OpenVulkano::Scene
// but since some algorithms have already been implemented for EM_NORMALIZED mode, currently there is no support for default font metrics (ints)
// The coordinates will be normalized to the em size, i.e. 1 = 1 em
const double scaleFactor = (1. / face->units_per_EM);
SetupAtlasData(atlasResolution, face->height * scaleFactor, FontAtlasType::BITMAP);
m_atlasData = std::make_shared<FontAtlas>(atlasResolution, face->height * scaleFactor, FontAtlasType::BITMAP);
FillGlyphsInfo(allGlyphs, face, scaleFactor);
if (pngOutput)
{
SavePng(*pngOutput);
}
if (pngOutput) m_atlasData->Save(*pngOutput);
}
std::pair<std::vector<GlyphForPacking>, double>
@@ -94,14 +91,15 @@ namespace OpenVulkano::Scene
}
FT_GlyphSlot slot = face->glyph;
char* baseAddress = static_cast<char*>(m_atlasData->GetTexture()->textureBuffer) + glyph.firstGlyphByteInAtlas;
for (int row = 0; row < slot->bitmap.rows; row++)
{
std::memcpy(&m_atlasData->img->data[glyph.firstGlyphByteInAtlas + row * m_atlasData->img->resolution.x],
std::memcpy(baseAddress + row * m_atlasData->GetTexture()->resolution.x,
&slot->bitmap.buffer[(slot->bitmap.rows - 1 - row) * slot->bitmap.pitch],
slot->bitmap.width);
}
GlyphInfo& glyphInfo = m_atlasData->glyphs[glyph.code];
GlyphInfo& glyphInfo = m_atlasData->GetGlyphs()[glyph.code];
const Math::Vector2d glyphMetrics = { slot->metrics.width * scaleFactor,
slot->metrics.height * scaleFactor };
const Math::Vector2d glyphBearing = { slot->metrics.horiBearingX * scaleFactor,

6
openVulkanoCpp/Scene/DataFormat.cpp
View File

@@ -225,7 +225,7 @@ namespace OpenVulkano
return { UNDEFINED };
}
uint32_t DataFormat::GetBytesPerPixel()
uint32_t DataFormat::GetBytesPerPixel() const
{
auto size = FORMAT_SIZE_MAP.find(m_format);
if (size == FORMAT_SIZE_MAP.end() || size->second == 0) [[unlikely]]
@@ -236,7 +236,7 @@ namespace OpenVulkano
return size->second;
}
bool DataFormat::IsBlockCompressed()
bool DataFormat::IsBlockCompressed() const
{
for (auto format: magic_enum::enum_values<DataFormat::Format>())
{
@@ -249,7 +249,7 @@ namespace OpenVulkano
return false;
}
size_t DataFormat::CalculatedSize(uint32_t& width, uint32_t& height)
size_t DataFormat::CalculatedSize(uint32_t& width, uint32_t& height) const
{
if (IsBlockCompressed())
{

12
openVulkanoCpp/Scene/DataFormat.hpp
View File

@@ -336,7 +336,7 @@ namespace OpenVulkano
constexpr DataFormat() : DataFormat(UNDEFINED) {}
constexpr DataFormat(Format format) : m_format(format) {}
constexpr DataFormat(const Format format) : m_format(format) {}
[[nodiscard]] std::string_view GetName() const;
@@ -351,12 +351,12 @@ namespace OpenVulkano
(m_format >= PVRTC1_2BPP_SRGB_BLOCK_IMG && m_format <= PVRTC2_4BPP_SRGB_BLOCK_IMG);
}
[[nodiscard]] constexpr bool operator ==(Format rhs)
[[nodiscard]] constexpr bool operator ==(Format rhs) const
{
return m_format == rhs;
}
[[nodiscard]] constexpr bool operator !=(Format rhs)
[[nodiscard]] constexpr bool operator !=(Format rhs) const
{
return m_format != rhs;
}
@@ -377,11 +377,11 @@ namespace OpenVulkano
#pragma clang diagnostic pop
}
uint32_t GetBytesPerPixel();
uint32_t GetBytesPerPixel() const;
bool IsBlockCompressed();
bool IsBlockCompressed() const;
size_t CalculatedSize(uint32_t& width, uint32_t& height);
size_t CalculatedSize(uint32_t& width, uint32_t& height) const;
static DataFormat GetFromName(std::string_view name);

105
openVulkanoCpp/Scene/FontAtlasGeneratorBase.cpp
View File

@@ -5,14 +5,9 @@
*/
#include "FontAtlasGeneratorBase.hpp"
#include "Text/FontAtlas.hpp"
#include "Base/Logger.hpp"
#include "Extensions/STBZlibCompressor.hpp"
#include <filesystem>
#include <fstream>
#define STBI_MSC_SECURE_CRT
#define STB_IMAGE_WRITE_IMPLEMENTATION
#define STBIW_ZLIB_COMPRESS Extensions::STBZlibCompressor
#include <stb_image_write.h>
namespace OpenVulkano::Scene
{
@@ -61,98 +56,34 @@ namespace OpenVulkano::Scene
return fmt::format("Error code is {}", error);
}
void FontAtlasGeneratorBase::SaveAtlasMetadataInfo(const std::string& outputFile, bool packIntoSingleFile) const
{
if (m_atlasData->glyphs.empty())
{
Logger::DATA->info("No glyphs loaded. Nothing to save.");
return;
}
std::string fileName = outputFile;
uint32_t packedFlag = packIntoSingleFile;
if (packIntoSingleFile)
{
std::filesystem::path fPath(fileName);
fileName = (fPath.parent_path() / fPath.stem()).string() + "_packed.png";
SavePng(fileName);
}
std::fstream fs(fileName.c_str(), std::ios_base::out | std::ios_base::binary | (packedFlag ? std::ios_base::app : std::ios_base::trunc));
fs.write(reinterpret_cast<const char*>(&m_atlasData->meta), sizeof(AtlasMetadata));
uint64_t metadataBytes = sizeof(AtlasMetadata);
for (const auto& [key, val] : m_atlasData->glyphs)
{
fs.write(reinterpret_cast<const char*>(&key), sizeof(uint32_t));
fs.write(reinterpret_cast<const char*>(&val), sizeof(GlyphInfo));
metadataBytes += sizeof(uint32_t);
metadataBytes += sizeof(GlyphInfo);
}
fs.write(reinterpret_cast<const char*>(&metadataBytes), sizeof(uint64_t));
fs.write(reinterpret_cast<const char*>(&packedFlag), sizeof(uint32_t));
fs.close();
}
void FontAtlasGeneratorBase::SavePng(std::string output) const
{
stbi_flip_vertically_on_write(1);
if (std::filesystem::path(output).extension() != ".png")
{
output += ".png";
}
stbi_write_png(output.c_str(), m_atlasData->img->resolution.x, m_atlasData->img->resolution.y, m_channelsCount,
m_atlasData->img->data.Data(), m_channelsCount * m_atlasData->img->resolution.x);
}
void FontAtlasGeneratorBase::SetupAtlasData(Math::Vector2ui textureResolution, double lineHeight,
FontAtlasType::Type atlasType)
{
// generate texture
m_atlasData->img = std::make_unique<Image::Image>();
m_atlasData->img->resolution = Math::Vector3ui(textureResolution, 1);
m_atlasData->img->dataFormat = m_channelsCount == 1 ? DataFormat::R8_UNORM : DataFormat::R8G8B8A8_UNORM;
m_atlasData->img->data = Array<uint8_t>(m_atlasData->img->dataFormat.CalculatedSize(textureResolution.x, textureResolution.y));
m_atlasData->texture.resolution = m_atlasData->img->resolution;
m_atlasData->texture.textureBuffer = m_atlasData->img->data.Data();
m_atlasData->texture.format = m_atlasData->img->dataFormat;
m_atlasData->texture.size = m_atlasData->img->data.Size();
m_atlasData->meta.atlasType = atlasType;
m_atlasData->meta.lineHeight = lineHeight;
if (atlasType == FontAtlasType::BITMAP)
{
m_atlasData->texture.m_samplerConfig = &SamplerConfig::NEAREST;
}
}
void FontAtlasGeneratorBase::SetGlyphData(GlyphInfo& info, Math::Vector2d bearing, Math::Vector2d size,
const Math::AABB& aabb, double advance)
{
const double bearingX = bearing.x;
const double bearingY = bearing.y;
const double w = size.x;
const double h = size.y;
const auto& resolution = m_atlasData->GetTexture()->resolution;
const double l = aabb.min.x;
const double r = aabb.max.x;
const double t = aabb.max.y;
const double b = aabb.min.y;
info.xyz[0].x = bearingX;
info.xyz[0].y = h - bearingY;
info.uv[0].x = l / m_atlasData->texture.resolution.x;
info.uv[0].y = b / m_atlasData->texture.resolution.y;
info.pos[0].x = bearing.x;
info.pos[0].y = size.y - bearing.y;
info.uv[0].x = l / resolution.x;
info.uv[0].y = b / resolution.y;
info.xyz[1].x = bearingX + w;
info.xyz[1].y = h - bearingY;
info.uv[1].x = r / m_atlasData->texture.resolution.x;
info.uv[1].y = b / m_atlasData->texture.resolution.y;
info.pos[1].x = bearing.x + size.x;
info.pos[1].y = size.y - bearing.y;
info.uv[1].x = r / resolution.x;
info.uv[1].y = b / resolution.y;
info.xyz[2].x = bearingX + w;
info.xyz[2].y = bearingY; //h - bearingY + h;
info.uv[2].x = r / m_atlasData->texture.resolution.x;
info.uv[2].y = t / m_atlasData->texture.resolution.y;
info.pos[2].x = bearing.x + size.x;
info.pos[2].y = bearing.y;
info.uv[2].x = r / resolution.x;
info.uv[2].y = t / resolution.y;
info.xyz[3].x = bearingX;
info.xyz[3].y = bearingY;
info.uv[3].x = l / m_atlasData->texture.resolution.x;
info.uv[3].y = t / m_atlasData->texture.resolution.y;
info.pos[3].x = bearing.x;
info.pos[3].y = bearing.y;
info.uv[3].x = l / resolution.x;
info.uv[3].y = t / resolution.y;
info.advance = advance;
}

10
openVulkanoCpp/Scene/FontAtlasGeneratorBase.hpp
View File

@@ -7,29 +7,27 @@
#pragma once
#include "IFontAtlasGenerator.hpp"
#include "AtlasData.hpp"
#include "Math/AABB.hpp"
#include "Extensions/FreetypeHelper.hpp"
#include <variant>
namespace OpenVulkano::Scene
{
class GlyphInfo;
class FontAtlasGeneratorBase : public IFontAtlasGenerator
{
protected:
int m_channelsCount;
std::shared_ptr<AtlasData> m_atlasData;
std::shared_ptr<FontAtlas> m_atlasData;
public:
FontAtlasGeneratorBase(const int channelsCount) : m_channelsCount(channelsCount) {}
void SaveAtlasMetadataInfo(const std::string& outputFile, bool packIntoSingleFile = true) const override;
[[nodiscard]] const std::shared_ptr<AtlasData>& GetAtlasData() const override { return m_atlasData; }
[[nodiscard]] const std::shared_ptr<FontAtlas>& GetAtlas() const final { return m_atlasData; }
[[nodiscard]] int GetAtlasChannelsCount() const { return m_channelsCount; }
[[nodiscard]] static std::set<uint32_t> LoadAllGlyphs(const std::variant<std::string, Array<char>>& data);
protected:
void SavePng(std::string output) const;
void SetupAtlasData(Math::Vector2ui textureResolution, double lineHeight, FontAtlasType::Type atlasType);
void SetGlyphData(GlyphInfo& info, Math::Vector2d bearing, Math::Vector2d size, const Math::AABB& aabb, double advance);
[[nodiscard]] static std::string GetFreetypeErrorDescription(FT_Error error);
[[nodiscard]] static std::pair<FtLibraryRecPtr, FtFaceRecPtr> InitFreetype(const std::variant<std::string, Array<char>>& source);

5
openVulkanoCpp/Scene/IFontAtlasGenerator.hpp
View File

@@ -14,7 +14,7 @@
namespace OpenVulkano::Scene
{
struct AtlasData;
struct FontAtlas;
class IFontAtlasGenerator
{
@@ -24,7 +24,6 @@ namespace OpenVulkano::Scene
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 void SaveAtlasMetadataInfo(const std::string& outputFile, bool packIntoSingleFile = true) const = 0;
virtual const std::shared_ptr<AtlasData>& GetAtlasData() const = 0;
virtual const std::shared_ptr<FontAtlas>& GetAtlas() const = 0;
};
}

14
openVulkanoCpp/Scene/Prefabs/LabelDrawable.cpp
View File

@@ -10,9 +10,10 @@
#include "Scene/Vertex.hpp"
#include "Scene/Shader/Shader.hpp"
#include "Scene/IFontAtlasGenerator.hpp"
#include "Base/Logger.hpp"
#include "Scene/Text/FontAtlasType.hpp"
#include <optional>
namespace OpenVulkano::Scene
{
namespace
@@ -68,14 +69,11 @@ namespace OpenVulkano::Scene
}
}
LabelDrawable::LabelDrawable(const std::shared_ptr<AtlasData>& atlasData, const LabelDrawableSettings& settings)
LabelDrawable::LabelDrawable(const std::shared_ptr<FontAtlas>& atlasData, const LabelDrawableSettings& settings)
: Drawable(DrawEncoder::GetDrawEncoder<LabelDrawable>(), DrawPhase::MAIN), m_atlasData(atlasData)
, m_labelBuffer(sizeof(LabelUniformData), &m_labelData, 4)
{
if (atlasData->glyphs.empty() || !atlasData->texture.size)
{
throw std::runtime_error("Can't create label drawable. Either glyphs or texture is empty");
}
if (!atlasData || !*atlasData) throw std::runtime_error("Can't create label drawable. Either glyphs or texture is empty");
SetLabelSettings(settings);
SetShader(IsBillboard() ? &BACKGROUND_BILLBOARD_SHADER : &BACKGROUND_SHADER);
}
@@ -97,9 +95,9 @@ namespace OpenVulkano::Scene
TextDrawable& textDrawable = m_texts.emplace_back(m_atlasData, config);
textDrawable.GetConfig().backgroundColor.a = 0; // do not render glyph's background
double lineHeight = m_atlasData->meta.lineHeight;
double lineHeight = m_atlasData->GetLineHeight();
textDrawable.GenerateText(text, m_position);
textDrawable.SetShader(GetTextShader(m_atlasData->meta.atlasType, IsBillboard()));
textDrawable.SetShader(GetTextShader(m_atlasData->GetAtlasType(), IsBillboard()));
m_bbox.Grow(textDrawable.GetBoundingBox());
// update position for next text entry
m_position.y = m_bbox.GetMin().y - lineHeight;

4
openVulkanoCpp/Scene/Prefabs/LabelDrawable.hpp
View File

@@ -44,7 +44,7 @@ namespace OpenVulkano::Scene
class LabelDrawable final : public Drawable
{
public:
LabelDrawable(const std::shared_ptr<AtlasData>& atlasData, const LabelDrawableSettings& settings = LabelDrawableSettings());
LabelDrawable(const std::shared_ptr<FontAtlas>& atlasData, const LabelDrawableSettings& settings = LabelDrawableSettings());
void AddText(const std::string& text, const TextConfig& config = TextConfig());
void SetLabelSettings(const LabelDrawableSettings& settings);
@@ -61,7 +61,7 @@ namespace OpenVulkano::Scene
private:
LabelDrawableSettings m_settings;
std::shared_ptr<AtlasData> m_atlasData;
std::shared_ptr<FontAtlas> m_atlasData;
UniformBuffer m_labelBuffer;
LabelUniformData m_labelData;
std::list<TextDrawable> m_texts; // Using list instead of vector for stable iterators

13
openVulkanoCpp/Scene/SdfFontAtlasGenerator.cpp
View File

@@ -5,7 +5,7 @@
*/
#if __has_include("msdfgen.h")
#include "Text/FontAtlas.hpp"
#include "SdfFontAtlasGenerator.hpp"
#include "Base/Logger.hpp"
#include <msdfgen.h>
@@ -106,7 +106,6 @@ namespace OpenVulkano::Scene
void SdfFontAtlasGeneratorGeneric<Channels>::Generate(FreetypeHandle* ft, FontHandle* font, const Charset& chset,
const std::optional<std::string>& pngOutput)
{
m_atlasData.reset(new AtlasData);
std::vector<GlyphGeometry> glyphsGeometry;
// FontGeometry is a helper class that loads a set of glyphs from a single font.
@@ -142,14 +141,14 @@ namespace OpenVulkano::Scene
generator.generate(glyphsGeometry.data(), glyphsGeometry.size());
int idx = 0;
SetupAtlasData(Math::Vector3ui(width, height, 1), fontGeometry.getMetrics().lineHeight,
m_atlasData = std::make_shared<FontAtlas>(Math::Vector2ui{ width, height }, fontGeometry.getMetrics().lineHeight,
channelsCount == 1 ? FontAtlasType::SDF : FontAtlasType::MSDF);
if constexpr (Channels == 3)
{
// store RGB as RGBA
const BitmapConstRef<msdfgen::byte, 3> storage = generator.atlasStorage();
msdfgen::byte* data = static_cast<msdfgen::byte*>(m_atlasData->img->data.Data());
msdfgen::byte* data = static_cast<msdfgen::byte*>(m_atlasData->GetTexture()->textureBuffer);
for (size_t srcPos = 0, dstPos = 0; srcPos < width * height * 3; srcPos += 3, dstPos += 4)
{
data[dstPos] = storage.pixels[srcPos];
@@ -161,7 +160,7 @@ namespace OpenVulkano::Scene
else
{
const msdfgen::BitmapConstRef<msdfgen::byte, 1>& storage = generator.atlasStorage();
memcpy(m_atlasData->img->data.Data(), storage.pixels, width * height);
memcpy(m_atlasData->GetTexture()->textureBuffer, storage.pixels, width * height);
}
struct Bbox
@@ -171,7 +170,7 @@ namespace OpenVulkano::Scene
for (const auto& glyph: glyphsGeometry)
{
GlyphInfo& info = m_atlasData->glyphs[glyph.getCodepoint()];
GlyphInfo& info = m_atlasData->GetGlyphs()[glyph.getCodepoint()];
const GlyphBox& glyphBox = generator.getLayout()[idx++];
Bbox glyphBaselineBbox, glyphAtlasBbox;
@@ -195,7 +194,7 @@ namespace OpenVulkano::Scene
SetGlyphData(info, { bearingX, bearingY }, { w, h }, glyphAtlasAABB, glyphBox.advance);
}
if (pngOutput && !pngOutput->empty()) { SavePng(pngOutput.value()); }
if (pngOutput && !pngOutput->empty()) { m_atlasData->Save(*pngOutput); }
destroyFont(font);
deinitializeFreetype(ft);
}

184
openVulkanoCpp/Scene/Text/FontAtlas.cpp Normal file
View File

@@ -0,0 +1,184 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
#include "FontAtlas.hpp"
#include "Base/Logger.hpp"
#include "Base/Wrapper.hpp"
#include "Image/ImageLoader.hpp"
#include "Extensions/STBZlibCompressor.hpp"
#include <fstream>
#include <zstd.h>
#define STBI_MSC_SECURE_CRT
#define STB_IMAGE_WRITE_IMPLEMENTATION
#define STBIW_ZLIB_COMPRESS Extensions::STBZlibCompressor
#include <stb_image_write.h>
namespace OpenVulkano::Scene
{
namespace
{
struct FontAtlasFileFlags
{
uint8_t packed = 1;
uint8_t version = 1;
[[maybe_unused]] uint16_t reserved = 0;
};
#pragma pack(push, 1)
struct EndOfFileHeader
{
uint64_t metadataSize;
FontAtlasFileFlags flags;
};
#pragma pack(pop)
static_assert(sizeof(EndOfFileHeader) == 12);
}
FontAtlas::FontAtlas(const std::filesystem::path& path)
{
auto content = Utils::ReadFile(path);
Load(content);
}
void FontAtlas::Save(const std::filesystem::path& path) const
{
if (!*this) { Logger::DATA->warn("Can't save empty font atlas!"); return; };
std::fstream fs(path, std::ios_base::out | std::ios_base::binary);
// Save image
{
stbi_flip_vertically_on_write(1);
int pngSize;
UniqueMalloc<uint8_t> png(stbi_write_png_to_mem(static_cast<const uint8_t*>(m_texture.textureBuffer), m_texture.format.GetBytesPerPixel() * m_texture.resolution.x, m_texture.resolution.x, m_texture.resolution.y, m_texture.format.GetBytesPerPixel(), &pngSize));
fs.write(reinterpret_cast<const std::ostream::char_type*>(png.get()), pngSize);
}
// Save metadata
{
const Array<char> metadata = SerializeMetadata();
Array<char> compressed(ZSTD_compressBound(metadata.Size()));
size_t compressedSize = ZSTD_compress(compressed.Data(), compressed.Size(), metadata.Data(), metadata.Size(), 5);
if (ZSTD_isError(compressedSize)) throw std::runtime_error(std::string("Compression failed: ") + ZSTD_getErrorName(compressedSize));
fs.write(compressed.Data(), compressedSize);
fs.write(reinterpret_cast<const char*>(&compressedSize), sizeof(uint64_t));
}
FontAtlasFileFlags flags;
fs.write(reinterpret_cast<const char*>(&flags), sizeof(FontAtlasFileFlags));
fs.close();
}
Array<char> FontAtlas::SerializeMetadata() const
{
Array<char> data(sizeof(Metadata) + m_glyphs.size() * (sizeof(GlyphInfo) + sizeof(uint32_t)));
char* ptr = data.Data();
memcpy(ptr, &m_metadata, sizeof(Metadata));
ptr += sizeof(Metadata);
for (const auto& [key, val] : m_glyphs)
{
memcpy(ptr, &key, sizeof(uint32_t));
ptr += sizeof(uint32_t);
memcpy(ptr, &val, sizeof(GlyphInfo));
ptr += sizeof(GlyphInfo);
}
return data;
}
void FontAtlas::DeserializeMetadata(const std::span<char>& data)
{
const char* d = data.data();
const char* end = data.data() + data.size();
uint32_t unicode = 0;
std::memcpy(&m_metadata, d, sizeof(Metadata));
d += sizeof(Metadata);
while (d < end)
{
std::memcpy(&unicode, d, sizeof(uint32_t));
d += sizeof(uint32_t);
GlyphInfo& info = m_glyphs[unicode];
std::memcpy(&info, d, sizeof(GlyphInfo));
d += sizeof(GlyphInfo);
}
}
void FontAtlas::Load(const std::span<char> data)
{
if (data.size() < sizeof(EndOfFileHeader) + sizeof(Metadata)) { Logger::DATA->warn("Font atlas file is invalid!"); return; };
EndOfFileHeader eofHeader;
std::memcpy(&eofHeader, data.data() + data.size() - sizeof(EndOfFileHeader), sizeof(EndOfFileHeader));
if (eofHeader.flags.packed == 0) throw std::runtime_error("No longer support loading of unpacked font atlas!");
LoadImage(data);
char* metadata = data.data() + data.size() - sizeof(EndOfFileHeader) - eofHeader.metadataSize;
const std::span metadataSpan(metadata, eofHeader.metadataSize);
if (eofHeader.flags.version == 0) LoadLegacy(metadataSpan);
else LoadNew(metadataSpan);
if (GetAtlasType() >= FontAtlasType::BITMAP) m_texture.m_samplerConfig = &SamplerConfig::NEAREST;
}
void FontAtlas::LoadLegacy(const std::span<char> data)
{
const char* d = data.data();
const char* end = data.data() + data.size();
uint32_t unicode = 0;
std::memcpy(&m_metadata, d, sizeof(Metadata));
d += sizeof(Metadata);
while (d < end)
{
std::memcpy(&unicode, d, sizeof(uint32_t));
d += sizeof(uint32_t);
GlyphInfo& info = m_glyphs[unicode];
for (int i = 0; i < 4; i++)
{
std::memcpy(&info.pos[i], d, sizeof(GlyphInfo::pos) / 4);
d += sizeof(GlyphInfo::pos) / 2;
}
std::memcpy(&info.uv, d, sizeof(GlyphInfo::uv));
d += sizeof(GlyphInfo::uv);
std::memcpy(&info.advance, d, sizeof(GlyphInfo::advance));
d += sizeof(GlyphInfo::advance) * 2;
}
}
void FontAtlas::LoadNew(const std::span<char> data)
{
size_t originalSize = ZSTD_getFrameContentSize(data.data(), data.size());
if (originalSize == ZSTD_CONTENTSIZE_ERROR) throw std::runtime_error("Not compressed by zstd");
if (originalSize == ZSTD_CONTENTSIZE_UNKNOWN) throw std::runtime_error("Original size unknown");
Array<char> metadata(originalSize);
size_t decompressedBytes = ZSTD_decompress(metadata.Data(), metadata.Size(), data.data(), data.size());
if (ZSTD_isError(decompressedBytes)) throw std::runtime_error(std::string("Decompression failed: ") + ZSTD_getErrorName(decompressedBytes));
if (decompressedBytes != originalSize) throw std::runtime_error("Decompressed size does not match expected size");
DeserializeMetadata(metadata);
}
void FontAtlas::LoadImage(const std::span<char> data)
{
auto img = Image::IImageLoader::loadData(reinterpret_cast<const uint8_t*>(data.data()), data.size());
m_imgData = std::move(img->data);
m_texture.format = img->dataFormat;
m_texture.resolution = img->resolution;
m_texture.size = m_imgData.Size();
m_texture.textureBuffer = m_imgData.Data();
}
void FontAtlas::Init(const Math::Vector2ui textureResolution, const double lineHeight, const FontAtlasType atlasType)
{
m_metadata = { lineHeight, atlasType };
m_texture.format = atlasType.GetChannelCount() == 1 ? DataFormat::R8_UNORM : DataFormat::R8G8B8A8_UNORM;
m_texture.resolution = { textureResolution, 1 };
m_imgData = Array<uint8_t>(m_texture.format.CalculatedSize(m_texture.resolution.x, m_texture.resolution.y));
m_texture.textureBuffer = m_imgData.Data();
m_texture.size = m_imgData.Size();
if (atlasType >= FontAtlasType::BITMAP) m_texture.m_samplerConfig = &SamplerConfig::NEAREST;
}
}

65
openVulkanoCpp/Scene/Text/FontAtlas.hpp Normal file
View File

@@ -0,0 +1,65 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
#pragma once
#include "FontAtlasType.hpp"
#include "Math/Math.hpp"
#include "Data/Containers/Array.hpp"
#include "Scene/Texture.hpp"
#include <map>
#include <filesystem>
namespace OpenVulkano::Scene
{
struct GlyphInfo
{
//GlyphGeometry geometry;
//GlyphBox glyphBox;
Math::Vector2f_SIMD pos[4] = {};
Math::Vector2f_SIMD uv[4] = {};
double advance = 0;
};
class FontAtlas
{
struct Metadata
{
double lineHeight = 0;
FontAtlasType atlasType = FontAtlasType::UNKNOWN;
};
std::map<uint32_t, GlyphInfo> m_glyphs;
Metadata m_metadata;
Array<uint8_t> m_imgData;
Texture m_texture;
void LoadLegacy(std::span<char> data);
void LoadNew(std::span<char> data);
void LoadImage(std::span<char> data);
Array<char> SerializeMetadata() const;
void DeserializeMetadata(const std::span<char>& data);
public:
FontAtlas() = default;
FontAtlas(const Math::Vector2ui textureResolution, const double lineHeight, const FontAtlasType atlasType) { Init(textureResolution, lineHeight, atlasType); }
FontAtlas(const std::filesystem::path& path);
FontAtlas(const std::span<char> data) { Load(data); }
void Init(Math::Vector2ui textureResolution, double lineHeight, FontAtlasType atlasType);
void Save(const std::filesystem::path& path) const;
void Load(std::span<char> data);
[[nodiscard]] operator bool() const { return !m_glyphs.empty() && m_texture.textureBuffer; }
[[nodiscard]] Texture* GetTexture() { return &m_texture; }
[[nodiscard]] decltype(m_glyphs)& GetGlyphs() { return m_glyphs; }
[[nodiscard]] decltype(Metadata::lineHeight) GetLineHeight() const { return m_metadata.lineHeight;}
[[nodiscard]] FontAtlasType GetAtlasType() const { return m_metadata.atlasType;}
};
}

40
openVulkanoCpp/Scene/AtlasData.hpp → openVulkanoCpp/Scene/Text/FontAtlasType.hpp
View File

@@ -6,25 +6,10 @@
#pragma once
#include "Base/Wrapper.hpp"
#include "Math/Math.hpp"
#include "Image/Image.hpp"
#include "Scene/Texture.hpp"
#include <string_view>
#include <map>
#include <magic_enum.hpp>
namespace OpenVulkano::Scene
{
struct GlyphInfo
{
//GlyphGeometry geometry;
//GlyphBox glyphBox;
Math::Vector3f_SIMD xyz[4] = {};
Math::Vector2f_SIMD uv[4] = {};
double advance = 0;
};
class FontAtlasType
{
public:
@@ -38,6 +23,8 @@ namespace OpenVulkano::Scene
static constexpr std::string_view DEFAULT_FG_SHADERS[] = { "Shader/sdfText", "Shader/msdfText", "Shader/text" };
static constexpr uint32_t CHANNEL_COUNT[] = { 1, 4, 1, 4, 0 };
constexpr FontAtlasType(Type type) : m_type(type) {}
[[nodiscard]] constexpr Type GetType() const { return m_type; }
@@ -49,27 +36,14 @@ namespace OpenVulkano::Scene
return DEFAULT_FG_SHADERS[static_cast<int>(m_type)];
}
[[nodiscard]] constexpr uint32_t GetChannelCount() const { return CHANNEL_COUNT[static_cast<int>(m_type)]; }
[[nodiscard]] constexpr operator Type() const { return m_type; }
[[nodiscard]] constexpr auto operator<=>(const FontAtlasType rhs) const { return m_type <=> rhs.m_type; }
[[nodiscard]] constexpr auto operator<=>(const Type rhs) const { return m_type <=> rhs; }
private:
Type m_type;
};
struct AtlasMetadata
{
// vertical difference between baselines
double lineHeight = 0;
FontAtlasType atlasType = FontAtlasType::UNKNOWN;
};
struct AtlasData
{
std::map<uint32_t, GlyphInfo> glyphs;
AtlasMetadata meta;
Unique<Image::Image> img;
Texture texture;
operator bool() const { return !glyphs.empty() && texture.textureBuffer; }
};
}

86
openVulkanoCpp/Scene/TextDrawable.cpp
View File

@@ -9,10 +9,8 @@
#include "Shader/Shader.hpp"
#include "Scene/IFontAtlasGenerator.hpp"
#include "Base/Logger.hpp"
#include "Host/ResourceLoader.hpp"
#include "Image/ImageLoader.hpp"
#include "DataFormat.hpp"
#include "Base/Logger.hpp"
#include <fstream>
#include <utf8.h>
@@ -56,81 +54,30 @@ namespace OpenVulkano::Scene
: Drawable(DrawEncoder::GetDrawEncoder<TextDrawable>()), m_cfg(config)
{}
TextDrawable::TextDrawable(const Array<char>& atlasMetadata, const TextConfig& config)
: TextDrawable(atlasMetadata, nullptr, config)
{}
TextDrawable::TextDrawable(const std::string& atlasMetadataFile, const TextConfig& config)
: TextDrawable(Utils::ReadFile(atlasMetadataFile), nullptr, config)
: TextDrawable(Utils::ReadFile(atlasMetadataFile), config)
{}
TextDrawable::TextDrawable(const std::string& atlasMetadataFile, Texture* atlasTex, const TextConfig& config)
: TextDrawable(Utils::ReadFile(atlasMetadataFile), atlasTex, config)
{}
TextDrawable::TextDrawable(const Array<char>& atlasMetadata, Texture* atlasTex, const TextConfig& config)
TextDrawable::TextDrawable(const Array<char>& atlasMetadata, const TextConfig& config)
: Drawable(DrawEncoder::GetDrawEncoder<TextDrawable>()), m_cfg(config)
{
uint32_t isPacked;
std::memcpy(&isPacked, atlasMetadata.Data() + (atlasMetadata.Size() - sizeof(uint32_t)), sizeof(uint32_t));
uint64_t metadataBytes;
std::memcpy(&metadataBytes, atlasMetadata.Data() + (atlasMetadata.Size() - sizeof(uint32_t) - sizeof(uint64_t)),
sizeof(uint64_t));
uint64_t offsetToMetadata = atlasMetadata.Size() - metadataBytes - sizeof(uint32_t) - sizeof(uint64_t);
m_atlasData = std::make_shared<AtlasData>();
if (isPacked)
{
Texture* texture = &m_atlasData->texture;
m_atlasData->img = Image::IImageLoader::loadData(reinterpret_cast<const uint8_t*>(atlasMetadata.Data()), offsetToMetadata);
texture->format = m_atlasData->img->dataFormat;
texture->resolution = m_atlasData->img->resolution;
texture->size = m_atlasData->img->data.Size();
texture->textureBuffer = m_atlasData->img->data.Data();
}
else
{
if (atlasTex == nullptr) { throw std::runtime_error("Atlas texture cannot be null with non-packed atlas metadata"); }
m_atlasData->texture = *atlasTex;
m_atlasData = std::make_shared<FontAtlas>(atlasMetadata);
}
// metadata info
size_t read_bytes = offsetToMetadata;
size_t readMetadataBytes = 0;
uint32_t unicode = 0;
std::memcpy(&m_atlasData->meta, atlasMetadata.Data() + read_bytes, sizeof(AtlasMetadata));
read_bytes += sizeof(AtlasMetadata);
readMetadataBytes += sizeof(AtlasMetadata);
while (readMetadataBytes < metadataBytes)
{
std::memcpy(&unicode, atlasMetadata.Data() + read_bytes, sizeof(uint32_t));
read_bytes += sizeof(uint32_t);
readMetadataBytes += sizeof(uint32_t);
GlyphInfo& info = m_atlasData->glyphs[unicode];
std::memcpy(&info, atlasMetadata.Data() + read_bytes, sizeof(GlyphInfo));
read_bytes += sizeof(GlyphInfo);
readMetadataBytes += sizeof(GlyphInfo);
}
if (m_atlasData->meta.atlasType == FontAtlasType::BITMAP)
{
m_atlasData->texture.m_samplerConfig = &SamplerConfig::NEAREST;
}
}
TextDrawable::TextDrawable(const std::shared_ptr<AtlasData>& atlasData, const TextConfig& config)
TextDrawable::TextDrawable(const std::shared_ptr<FontAtlas>& atlasData, const TextConfig& config)
: Drawable(DrawEncoder::GetDrawEncoder<TextDrawable>()), m_atlasData(atlasData), m_cfg(config)
{
if (!atlasData || !*atlasData) throw std::runtime_error("Cannot initialize text drawable with empty atlas data");
}
uint32_t TextDrawable::GetFallbackGlyph() const
{
if (m_atlasData->glyphs.find(MISSING_GLYPH_SYMBOL) != m_atlasData->glyphs.end())
{ //TODO move into FontAtlas
if (m_atlasData->GetGlyphs().contains(MISSING_GLYPH_SYMBOL))
{
return MISSING_GLYPH_SYMBOL;
}
Logger::RENDER->warn("Could not find glyph for character ? to use as fallback. Using first glyph instead");
return m_atlasData->glyphs.begin()->first;
return m_atlasData->GetGlyphs().begin()->first;
}
void TextDrawable::GenerateText(const std::string& text, const Math::Vector2f& pos)
@@ -144,11 +91,10 @@ namespace OpenVulkano::Scene
const size_t len = utf8::distance(text.begin(), text.end());
m_vertexBuffer.Close();
TextGlyphVertex* vertices = m_vertexBuffer.Init<TextGlyphVertex>(len);
std::map<uint32_t, GlyphInfo>* symbols = &m_atlasData->glyphs;
AtlasMetadata* meta = &m_atlasData->meta;
const std::map<uint32_t, GlyphInfo>& symbols = m_atlasData->GetGlyphs();
double cursorX = pos.x;
const double lineHeight = meta->lineHeight;
const double lineHeight = m_atlasData->GetLineHeight();
double posY = pos.y;
Math::Vector3f bmin(pos, 0), bmax(pos, 0);
for (auto begin = text.begin(), end = text.end(); begin != end;)
@@ -162,20 +108,20 @@ namespace OpenVulkano::Scene
}
// TODO handle special chars
if (!symbols->contains(c))
if (!symbols.contains(c))
{
Logger::RENDER->warn("Could not find glyph for character {}, using fallback", c);
c = fallbackGlyph;
}
GlyphInfo& info = symbols->at(c);
const GlyphInfo& info = symbols.at(c);
for (int i = 0; i < 4; i++)
{
vertices->position[i].x = info.xyz[i].x + cursorX;
vertices->position[i].x = info.pos[i].x + cursorX;
vertices->uv[i] = info.uv[i];
if (i < 2) vertices->position[i].y = posY - info.xyz[i].y;
else vertices->position[i].y = posY + info.xyz[i].y;
if (i < 2) vertices->position[i].y = posY - info.pos[i].y;
else vertices->position[i].y = posY + info.pos[i].y;
vertices->color = m_cfg.textColor;
vertices->background = m_cfg.backgroundColor;
}
@@ -193,10 +139,10 @@ namespace OpenVulkano::Scene
bmin.x = vertices->position[0].x;
m_bbox.Init(bmin, bmax);
if (!GetShader()) SetShader(GetDefaultShader(m_atlasData->meta.atlasType));
if (!GetShader()) SetShader(GetDefaultShader(m_atlasData->GetAtlasType()));
}
void TextDrawable::SetAtlasData(const std::shared_ptr<AtlasData>& atlasData)
void TextDrawable::SetAtlasData(const std::shared_ptr<FontAtlas>& atlasData)
{
if (!atlasData || !*atlasData) throw std::runtime_error("Cannot initialize text drawable with empty atlas data");
m_atlasData = atlasData;

17
openVulkanoCpp/Scene/TextDrawable.hpp
View File

@@ -9,11 +9,12 @@
#include "Drawable.hpp"
#include "Texture.hpp"
#include "VertexBuffer.hpp"
#include "AtlasData.hpp"
#include "Image/Image.hpp"
#include "Text/FontAtlas.hpp"
namespace OpenVulkano::Scene
{
class FontAtlas;
class IFontAtlasGenerator;
struct TextConfig
@@ -33,7 +34,7 @@ namespace OpenVulkano::Scene
class TextDrawable : public Drawable
{
VertexBuffer m_vertexBuffer;
std::shared_ptr<AtlasData> m_atlasData;
std::shared_ptr<FontAtlas> m_atlasData;
Math::AABB2f m_bbox;
std::string m_text;
size_t m_symbolCount = 0;
@@ -43,23 +44,21 @@ namespace OpenVulkano::Scene
public:
TextDrawable(const TextConfig& config = TextConfig());
TextDrawable(const Array<char>& atlasMetadata, const TextConfig& config = TextConfig());
TextDrawable(const std::string& atlasMetadataFile, const TextConfig& config = TextConfig());
TextDrawable(const std::string& atlasMetadataFile, Texture* atlasTex, const TextConfig& config = TextConfig());
TextDrawable(const Array<char>& atlasMetadata, Texture* atlasTex, const TextConfig& config = TextConfig());
TextDrawable(const std::shared_ptr<AtlasData>& atlasData, const TextConfig& config = TextConfig());
TextDrawable(const Array<char>& atlasMetadata, const TextConfig& config = TextConfig());
TextDrawable(const std::shared_ptr<FontAtlas>& atlasData, const TextConfig& config = TextConfig());
void GenerateText(const std::string& text, const Math::Vector2f& pos = Math::Vector2f(0.f));
void SetConfig(const TextConfig& cfg) { m_cfg = cfg; }
void SetAtlasData(const std::shared_ptr<AtlasData>& atlasData);
void SetAtlasData(const std::shared_ptr<FontAtlas>& atlasData);
[[nodiscard]] Math::AABB2f& GetBoundingBox() { return m_bbox; }
[[nodiscard]] TextConfig& GetConfig() { return m_cfg; }
[[nodiscard]] const std::string& GetText() const { return m_text; }
[[nodiscard]] const std::shared_ptr<AtlasData>& GetAtlasData() { return m_atlasData; }
[[nodiscard]] const std::shared_ptr<FontAtlas>& GetAtlasData() { return m_atlasData; }
[[nodiscard]] VertexBuffer* GetVertexBuffer() { return &m_vertexBuffer; }
[[nodiscard]] Texture* GetTexture() { return &m_atlasData->texture; }
[[nodiscard]] Texture* GetTexture() { return m_atlasData->GetTexture(); }
[[nodiscard]] size_t GetSymbolCount() const { return m_symbolCount; }
[[nodiscard]] static Shader MakeDefaultShader(FontAtlasType type);