225 lines
8.1 KiB
C++
225 lines
8.1 KiB
C++
/*
|
|
* 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 "TextDrawable.hpp"
|
|
#include "Scene/Geometry.hpp"
|
|
#include "Scene/Material.hpp"
|
|
#include "Scene/Vertex.hpp"
|
|
#include "Scene/UniformBuffer.hpp"
|
|
#include "Scene/FontAtlasGenerator.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>
|
|
|
|
namespace OpenVulkano::Scene
|
|
{
|
|
Shader& TextDrawable::GetDefaultShader()
|
|
{
|
|
static bool once = true;
|
|
static Shader textDefaultShader;
|
|
if (once)
|
|
{
|
|
textDefaultShader.AddShaderProgram(OpenVulkano::ShaderProgramType::VERTEX, "Shader/text");
|
|
textDefaultShader.AddShaderProgram(OpenVulkano::ShaderProgramType::FRAGMENT, "Shader/text");
|
|
textDefaultShader.AddVertexInputDescription(OpenVulkano::Vertex::GetVertexInputDescription());
|
|
textDefaultShader.AddDescriptorSetLayoutBinding(Texture::DESCRIPTOR_SET_LAYOUT_BINDING);
|
|
textDefaultShader.AddDescriptorSetLayoutBinding(UniformBuffer::DESCRIPTOR_SET_LAYOUT_BINDING);
|
|
textDefaultShader.alphaBlend = true;
|
|
textDefaultShader.cullMode = CullMode::NONE;
|
|
once = false;
|
|
}
|
|
return textDefaultShader;
|
|
}
|
|
|
|
TextDrawable::TextDrawable(const Array<char>& atlasMetadata, const TextConfig& config)
|
|
: TextDrawable(atlasMetadata, nullptr, config)
|
|
{
|
|
}
|
|
|
|
TextDrawable::TextDrawable(const std::string& atlasMetadataFile, const TextConfig& config)
|
|
: TextDrawable(OpenVulkano::Utils::ReadFile(atlasMetadataFile), nullptr, config)
|
|
{
|
|
}
|
|
|
|
TextDrawable::TextDrawable(const std::string& atlasMetadataFile, Texture* atlasTex, const TextConfig& config)
|
|
: TextDrawable(OpenVulkano::Utils::ReadFile(atlasMetadataFile), atlasTex, config)
|
|
{
|
|
}
|
|
|
|
TextDrawable::TextDrawable(const Array<char>& atlasMetadata, Texture* atlasTex, const TextConfig& 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);
|
|
if (isPacked)
|
|
{
|
|
m_material.texture = new Texture();
|
|
m_img = Image::IImageLoader::loadData((const uint8_t*) atlasMetadata.Data(),
|
|
offsetToMetadata);
|
|
m_material.texture->format = m_img->dataFormat;
|
|
m_material.texture->resolution = m_img->resolution;
|
|
m_material.texture->size = m_img->data.Size(); // 1 channel
|
|
m_material.texture->textureBuffer = m_img->data.Data();
|
|
}
|
|
else
|
|
{
|
|
if (atlasTex == nullptr) { throw std::runtime_error("Atlas texture cannot be null with non-packed atlas metadata"); }
|
|
m_material.texture = atlasTex;
|
|
}
|
|
|
|
// metadata info
|
|
size_t read_bytes = offsetToMetadata;
|
|
size_t readMetadataBytes = 0;
|
|
uint32_t unicode = 0;
|
|
|
|
std::memcpy(&m_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_glyphs[unicode];
|
|
std::memcpy(&info, atlasMetadata.Data() + read_bytes, sizeof(GlyphInfo));
|
|
read_bytes += sizeof(GlyphInfo);
|
|
readMetadataBytes += sizeof(GlyphInfo);
|
|
}
|
|
m_cfg = config;
|
|
m_uniBuffer.Init(sizeof(TextConfig), &m_cfg, 3);
|
|
}
|
|
|
|
TextDrawable::TextDrawable(const std::map<uint32_t, GlyphInfo>& glyphData, Texture* atlasTex,
|
|
const TextConfig& config)
|
|
{
|
|
if (!atlasTex) { throw std::runtime_error("Atlas texture is nullptr"); }
|
|
if (glyphData.empty()) { throw std::runtime_error("Glyphs are not loaded"); }
|
|
m_material.texture = atlasTex;
|
|
m_glyphs = glyphData;
|
|
m_cfg = config;
|
|
m_uniBuffer.Init(sizeof(TextConfig), &m_cfg, 3);
|
|
}
|
|
|
|
TextDrawable::TextDrawable(FontAtlasGenerator* fontAtlasGenerator, const TextConfig& config)
|
|
{
|
|
if (!fontAtlasGenerator) { throw std::runtime_error("FontAtlasGenerator is nullptr"); }
|
|
if (fontAtlasGenerator->GetGlyphsInfo().empty()) { throw std::runtime_error("Glyphs are not loaded"); }
|
|
m_fontAtlasGenerator = fontAtlasGenerator;
|
|
m_cfg = config;
|
|
m_material.texture = const_cast<Texture*>(&m_fontAtlasGenerator->GetAtlas());
|
|
m_uniBuffer.Init(sizeof(TextConfig), &m_cfg, 3);
|
|
}
|
|
|
|
void TextDrawable::GenerateText(const std::string& text, const Math::Vector3f& pos)
|
|
{
|
|
if (text.empty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_geometry.Close();
|
|
m_geometry.Init(text.size() * 4, text.size() * 6);
|
|
|
|
// TODO: better implementation to decide what to use: data from atlas generator or data read from file
|
|
// we have msdf but loaded glyphs metadata from file before
|
|
AtlasMetadata* meta;
|
|
std::map<uint32_t, GlyphInfo>* symbols;
|
|
if (m_fontAtlasGenerator)
|
|
{
|
|
if (m_fontAtlasGenerator->GetGlyphsInfo().empty() && !m_glyphs.empty())
|
|
{
|
|
// texture is set in ctor
|
|
symbols = &m_glyphs;
|
|
}
|
|
else
|
|
{
|
|
// just in case if FontAtlasGenerator changed it's atlas
|
|
m_material.texture = const_cast<Texture*>(&m_fontAtlasGenerator->GetAtlas());
|
|
symbols = &m_fontAtlasGenerator->GetGlyphsInfo();
|
|
}
|
|
meta = &m_fontAtlasGenerator->GetAtlasMetadata();
|
|
}
|
|
else
|
|
{
|
|
symbols = &m_glyphs;
|
|
meta = &m_meta;
|
|
}
|
|
|
|
const Texture& atlasTex = *m_material.texture;
|
|
double cursorX = pos.x;
|
|
auto begin = text.begin();
|
|
auto end = text.end();
|
|
const double lineHeight = meta->lineHeight;
|
|
double posY = pos.y;
|
|
for (size_t i = 0; begin != end; i++)
|
|
{
|
|
uint32_t c = utf8::next(begin, end);
|
|
if (c == '\n')
|
|
{
|
|
posY -= lineHeight;
|
|
cursorX = pos.x;
|
|
continue;
|
|
}
|
|
if (symbols->find(c) != symbols->end())
|
|
{
|
|
uint32_t vIdx = i * 4;
|
|
uint32_t indices[] = { 1 + vIdx, 2 + vIdx, 3 + vIdx, 1 + vIdx, 3 + vIdx, 0 + vIdx };
|
|
GlyphInfo& info = symbols->at(c);
|
|
|
|
// left bottom
|
|
m_geometry.vertices[vIdx].position.x = info.xyz[0].x + cursorX;
|
|
m_geometry.vertices[vIdx].position.y = posY - info.xyz[0].y;
|
|
m_geometry.vertices[vIdx].position.z = info.xyz[0].z;
|
|
m_geometry.vertices[vIdx].textureCoordinates = Math::Vector3f(info.uv[0], 0);
|
|
|
|
// right bottom
|
|
m_geometry.vertices[vIdx + 1].position.x = info.xyz[1].x + cursorX;
|
|
m_geometry.vertices[vIdx + 1].position.y = posY - info.xyz[1].y;
|
|
m_geometry.vertices[vIdx + 1].position.z = info.xyz[1].z;
|
|
m_geometry.vertices[vIdx + 1].textureCoordinates = Math::Vector3f(info.uv[1], 0);
|
|
|
|
// top right
|
|
m_geometry.vertices[vIdx + 2].position.x = info.xyz[2].x + cursorX;
|
|
m_geometry.vertices[vIdx + 2].position.y = posY + info.xyz[2].y;
|
|
m_geometry.vertices[vIdx + 2].position.z = info.xyz[2].z;
|
|
m_geometry.vertices[vIdx + 2].textureCoordinates = Math::Vector3f(info.uv[2], 0);
|
|
|
|
// top left
|
|
m_geometry.vertices[vIdx + 3].position.x = info.xyz[3].x + cursorX;
|
|
m_geometry.vertices[vIdx + 3].position.y = posY + info.xyz[3].y;
|
|
m_geometry.vertices[vIdx + 3].position.z = info.xyz[3].z;
|
|
m_geometry.vertices[vIdx + 3].textureCoordinates = Math::Vector3f(info.uv[3], 0);
|
|
m_geometry.SetIndices(indices, 6, 6 * i);
|
|
// TODO: change to lower value(or ideally remove completely) to avoid overlapping and make less space between symbols
|
|
// when setting for depth comparison operator will be available( <= )
|
|
cursorX += info.advance + 0.08;
|
|
}
|
|
else
|
|
{
|
|
// throw ? replace with ? character (if available) ?
|
|
Logger::RENDER->error("Could not find glyph for character {}", c);
|
|
}
|
|
}
|
|
SimpleDrawable::Init(m_shader, &m_geometry, &m_material, &m_uniBuffer);
|
|
}
|
|
|
|
void TextDrawable::SetFontAtlasGenerator(FontAtlasGenerator* fontAtlasGenerator)
|
|
{
|
|
if (!fontAtlasGenerator || fontAtlasGenerator->GetGlyphsInfo().empty())
|
|
{
|
|
Logger::RENDER->error("FontAtlasGenerator is either nullptr or doesn't contain glyphs info");
|
|
return;
|
|
}
|
|
m_fontAtlasGenerator = fontAtlasGenerator;
|
|
}
|
|
} |