OpenVulkano/openVulkanoCpp/Scene/TextDrawable.cpp

/*
 * 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 <fstream>
#include <utf8.h>

namespace OpenVulkano::Scene
{
#ifdef MSDFGEN_AVAILABLE
	using namespace msdfgen;
	using namespace msdf_atlas;
#endif

	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;
	}

	std::map<uint32_t, GlyphInfo> TextDrawable::ReadAtlasMetadataFile(const std::string& atlasMetadataFile) 
	{
		OpenVulkano::Array<char> data = OpenVulkano::Utils::ReadFile(atlasMetadataFile);
		return ReadAtlasMetadata(data);
	}

	std::map<uint32_t, GlyphInfo> TextDrawable::ReadAtlasMetadata(const Array<char>& atlasMetadata)
	{
		size_t len = atlasMetadata.Size();
		size_t read_bytes = 0;
		uint32_t unicode = 0;
		GlyphInfo info;
		std::map<uint32_t, GlyphInfo> glyphs;
		while (read_bytes < len)
		{
			std::memcpy(&unicode, atlasMetadata.Data() + read_bytes, sizeof(uint32_t));
			read_bytes += sizeof(uint32_t);
			std::memcpy(&info, atlasMetadata.Data() + read_bytes, sizeof(GlyphInfo));
			read_bytes += sizeof(GlyphInfo);
			glyphs[unicode] = std::move(info);
		}
		return glyphs;
	}

	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);
	}

#ifdef MSDFGEN_AVAILABLE
	TextDrawable::TextDrawable(FontAtlasGenerator* fontAtlasGenerator, const TextConfig& config)
	{
		if (!fontAtlasGenerator) { throw std::runtime_error("FontAtlasGenerator is nullptr"); }
		if (fontAtlasGenerator->GetAtlasInfo().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);
	}
#endif

	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);

#ifdef MSDFGEN_AVAILABLE
		// 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
		std::optional<std::reference_wrapper<std::map<unicode_t, GlyphInfo>>> glyphData; 
		if (m_fontAtlasGenerator->GetAtlasInfo().empty() && !m_glyphs.empty())
		{
			// texture is set in ctor
			glyphData = m_glyphs;
		}
		else
		{
			// just in case if FontAtlasGenerator changed it's atlas
			m_material.texture = const_cast<Texture*>(&m_fontAtlasGenerator->GetAtlas());
			glyphData = m_fontAtlasGenerator->GetAtlasInfo();
		}
		std::map<unicode_t, GlyphInfo>& symbols = glyphData.value();
#else
		std::map<unicode_t, GlyphInfo>& symbols = m_glyphs;
#endif
		const Texture& atlasTex = *m_material.texture;
		double cursorX = pos.x;
		auto begin = text.begin();
		auto end = text.end();
		for (size_t i = 0; begin != end; i++)
		{
			uint32_t c = utf8::next(begin, end);
			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 = pos.y - 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 = pos.y - 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 = pos.y + 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 = pos.y + 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);
	}
}