258 lines
9.1 KiB
C++
258 lines
9.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 "LabelDrawable.hpp"
|
|
#include "Scene/TextDrawable.hpp"
|
|
#include "Scene/DrawEncoder.hpp"
|
|
#include "Scene/IFontAtlasGenerator.hpp"
|
|
#include "Base/Logger.hpp"
|
|
#include <optional>
|
|
|
|
namespace OpenVulkano::Scene
|
|
{
|
|
using namespace Math;
|
|
|
|
LabelDrawable::LabelDrawable(const LabelDrawableSettings& settings, bool isBillboard)
|
|
: Drawable(DrawEncoder::GetDrawEncoder<LabelDrawable>(), DrawPhase::MAIN)
|
|
{
|
|
m_isBillboard = isBillboard;
|
|
SetLabelSettings(settings);
|
|
SetupShaders();
|
|
SetupBuffers();
|
|
m_backgroundGeometry.SetFreeAfterUpload(false);
|
|
}
|
|
|
|
void LabelDrawable::SetLabelSettings(const LabelDrawableSettings& settings)
|
|
{
|
|
m_settings = settings;
|
|
m_labelData.hasRoundedCorners = settings.hasRoundedCorners;
|
|
m_labelData.hasArrow = settings.hasArrow;
|
|
m_labelData.cornerRadius = settings.cornerRadius;
|
|
m_labelData.arrowLength = settings.arrowLength;
|
|
}
|
|
|
|
void LabelDrawable::AddText(TextDrawable* td, const std::string& text)
|
|
{
|
|
if (!td || text.empty())
|
|
{
|
|
return;
|
|
}
|
|
if (!td->GetShader())
|
|
{
|
|
Logger::RENDER->error("Text drawable shader is null, cannot add text to label drawable\n");
|
|
return;
|
|
}
|
|
|
|
TextDrawable& textDrawable = m_texts.emplace_back(td->GetConfig());
|
|
// do not render glyph's background
|
|
textDrawable.GetConfig().backgroundColor.a = 0;
|
|
if (m_isBillboard)
|
|
{
|
|
textDrawable.SetShader(GetBillboardTextShader(td->GetShader()));
|
|
}
|
|
else
|
|
{
|
|
textDrawable.SetShader(td->GetShader());
|
|
}
|
|
double lineHeight;
|
|
if (textDrawable.GetFontAtlasGenerator())
|
|
{
|
|
textDrawable.SetFontAtlasGenerator(td->GetFontAtlasGenerator());
|
|
lineHeight = td->GetFontAtlasGenerator()->GetAtlasMetadata().lineHeight;
|
|
}
|
|
else
|
|
{
|
|
textDrawable.SetAtlasData(td->GetAtlasData());
|
|
lineHeight = td->GetAtlasData()->meta.lineHeight;
|
|
}
|
|
textDrawable.GenerateText(text, m_position);
|
|
RecalculateBbox(textDrawable.GetBoundingBox());
|
|
// update position for next text entry
|
|
m_position.y = m_bbox.GetMin().y - lineHeight;
|
|
|
|
if (!m_settings.hasArrow)
|
|
{
|
|
if (m_backgroundGeometry.vertexCount != 4)
|
|
{
|
|
m_backgroundGeometry.Init(4, 6);
|
|
uint32_t indices[6] = { 0, 1, 2, 0, 2, 3 };
|
|
m_backgroundGeometry.SetIndices(indices, 6);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_backgroundGeometry.vertexCount != 7)
|
|
{
|
|
m_backgroundGeometry.Init(7, 9);
|
|
uint32_t indices[9] = { 0, 1, 2, 0, 2, 3, 4, 5, 6 };
|
|
m_backgroundGeometry.SetIndices(indices, 9);
|
|
}
|
|
}
|
|
|
|
const auto& min = m_bbox.GetMin();
|
|
const auto& max = m_bbox.GetMax();
|
|
Vertex v, v2, v3, v4;
|
|
v.color = v2.color = v3.color = v4.color = m_settings.backgroundColor;
|
|
const float offset = 0.001;
|
|
v.position = Vector3f(min.x - m_settings.horizontalOffset, min.y - m_settings.verticalOffset, min.z - offset);
|
|
v2.position = Vector3f(max.x + m_settings.horizontalOffset, min.y - m_settings.verticalOffset, min.z - offset);
|
|
v3.position = Vector3f(max.x + m_settings.horizontalOffset, max.y + m_settings.verticalOffset, min.z - offset);
|
|
v4.position = Vector3f(min.x - m_settings.horizontalOffset, max.y + m_settings.verticalOffset, min.z - offset);
|
|
if (!m_settings.hasArrow)
|
|
{
|
|
v.textureCoordinates = Vector3f(0, 0, 0);
|
|
v2.textureCoordinates = Vector3f(1, 0, 0);
|
|
v3.textureCoordinates = Vector3f(1, 1, 0);
|
|
v4.textureCoordinates = Vector3f(0, 1, 0);
|
|
}
|
|
else
|
|
{
|
|
const float w = v2.position.x - v.position.x;
|
|
const float h = v3.position.y - v2.position.y + m_settings.arrowLength;
|
|
v.textureCoordinates = Vector3f(0, v.position.y / h, 0);
|
|
v2.textureCoordinates = Vector3f(1, v2.position.y / h, 0);
|
|
v3.textureCoordinates = Vector3f(1, 1, 0);
|
|
v4.textureCoordinates = Vector3f(0, 1, 0);
|
|
// arrow vertices
|
|
Vertex a, b, c;
|
|
a.position = Vector3f(v.position.x + w / 3, v.position.y, v.position.z);
|
|
b.position = Vector3f(v.position.x + w / 2, v.position.y - m_settings.arrowLength, v.position.z);
|
|
c.position = Vector3f(v2.position.x - w / 3, v.position.y, v.position.z);
|
|
a.color = b.color = c.color = m_settings.backgroundColor;
|
|
a.textureCoordinates = Vector3f(a.position.x / w, a.position.y / h, 0);
|
|
b.textureCoordinates = Vector3f(b.position.x / w, 0, 0);
|
|
c.textureCoordinates = Vector3f(c.position.x / w, c.position.y / h, 0);
|
|
m_backgroundGeometry.vertices[4] = a;
|
|
m_backgroundGeometry.vertices[5] = b;
|
|
m_backgroundGeometry.vertices[6] = c;
|
|
}
|
|
m_backgroundGeometry.vertices[0] = v;
|
|
m_backgroundGeometry.vertices[1] = v2;
|
|
m_backgroundGeometry.vertices[2] = v3;
|
|
m_backgroundGeometry.vertices[3] = v4;
|
|
|
|
if (m_settings.hasRoundedCorners)
|
|
{
|
|
m_labelData.textSize.x = v2.position.x - v.position.x;
|
|
m_labelData.textSize.y = v3.position.y - v.position.y;
|
|
}
|
|
}
|
|
|
|
void LabelDrawable::SetBillboardSettings(const BillboardControlBlock& settings)
|
|
{
|
|
m_billboardSettings = settings;
|
|
}
|
|
|
|
void LabelDrawable::RecalculateBbox(const Math::AABB& other)
|
|
{
|
|
if (m_bbox.IsEmpty())
|
|
{
|
|
m_bbox = other;
|
|
}
|
|
else
|
|
{
|
|
auto& currentMin = m_bbox.GetMin();
|
|
auto& currentMax = m_bbox.GetMax();
|
|
currentMin.x = std::min(currentMin.x, other.min.x);
|
|
currentMin.y = std::min(currentMin.y, other.min.y);
|
|
currentMax.x = std::max(currentMax.x, other.max.x);
|
|
currentMax.y = std::max(currentMax.y, other.max.y);
|
|
}
|
|
}
|
|
|
|
// if we have want our label to be billboard, then we'll create new shader and set it's vertex shader to billboard.vert
|
|
// to avoid modifying input shader
|
|
Shader* LabelDrawable::GetBillboardTextShader(Shader* src)
|
|
{
|
|
auto GetFragmentShaderName = [](const Shader& shaderToCheck) -> std::optional<std::string>
|
|
{
|
|
const auto& shaderPrograms = shaderToCheck.shaderPrograms;
|
|
auto pos = std::find_if(shaderPrograms.begin(), shaderPrograms.end(),
|
|
[](const ShaderProgram& program)
|
|
{ return program.type == ShaderProgramType::FRAGMENT; });
|
|
return pos != shaderPrograms.end() ? std::optional<std::string>(pos->name) : std::nullopt;
|
|
};
|
|
|
|
std::optional<std::string> inputFragmentName = GetFragmentShaderName(*src);
|
|
if (!inputFragmentName)
|
|
{
|
|
throw std::runtime_error("Shader doesn't have fragment program");
|
|
}
|
|
|
|
bool exists = false;
|
|
int shaderIdx = 0;
|
|
for (; shaderIdx < m_billboardTextShaders.size(); shaderIdx++)
|
|
{
|
|
std::optional<std::string> name = GetFragmentShaderName(m_billboardTextShaders[shaderIdx]);
|
|
if (name.value() == inputFragmentName.value())
|
|
{
|
|
exists = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!exists)
|
|
{
|
|
Shader& shader = m_billboardTextShaders.emplace_back();
|
|
shaderIdx = m_billboardTextShaders.size() - 1;
|
|
shader.AddShaderProgram(OpenVulkano::ShaderProgramType::VERTEX, "Shader/billboard");
|
|
shader.AddShaderProgram(OpenVulkano::ShaderProgramType::FRAGMENT, inputFragmentName.value());
|
|
shader.AddVertexInputDescription(OpenVulkano::Vertex::GetVertexInputDescription());
|
|
shader.AddDescriptorSetLayoutBinding(Texture::DESCRIPTOR_SET_LAYOUT_BINDING);
|
|
DescriptorSetLayoutBinding binding = UniformBuffer::DESCRIPTOR_SET_LAYOUT_BINDING;
|
|
binding.stageFlags = ShaderProgramType::Type::VERTEX;
|
|
DescriptorSetLayoutBinding binding2 = UniformBuffer::DESCRIPTOR_SET_LAYOUT_BINDING;
|
|
binding2.stageFlags = ShaderProgramType::FRAGMENT;
|
|
shader.AddDescriptorSetLayoutBinding(binding2, 3);
|
|
shader.AddDescriptorSetLayoutBinding(binding, 4);
|
|
shader.depthWrite = false;
|
|
shader.depthCompareOp = CompareOp::LESS_OR_EQUAL;
|
|
shader.alphaBlend = true;
|
|
shader.cullMode = CullMode::NONE;
|
|
}
|
|
return &m_billboardTextShaders[shaderIdx];
|
|
}
|
|
|
|
void LabelDrawable::SetupShaders()
|
|
{
|
|
DescriptorSetLayoutBinding binding = UniformBuffer::DESCRIPTOR_SET_LAYOUT_BINDING;
|
|
if (!m_isBillboard)
|
|
{
|
|
m_backgroundShader.AddShaderProgram(OpenVulkano::ShaderProgramType::VERTEX, "Shader/basic");
|
|
}
|
|
else
|
|
{
|
|
m_backgroundShader.AddShaderProgram(OpenVulkano::ShaderProgramType::VERTEX, "Shader/billboard");
|
|
// binding for billboard's buffer
|
|
binding.stageFlags = ShaderProgramType::Type::VERTEX;
|
|
m_backgroundShader.AddDescriptorSetLayoutBinding(binding, 4);
|
|
}
|
|
m_backgroundShader.AddShaderProgram(OpenVulkano::ShaderProgramType::FRAGMENT, "Shader/label");
|
|
m_backgroundShader.AddVertexInputDescription(OpenVulkano::Vertex::GetVertexInputDescription());
|
|
m_backgroundShader.AddDescriptorSetLayoutBinding(Texture::DESCRIPTOR_SET_LAYOUT_BINDING, 2);
|
|
binding.stageFlags = ShaderProgramType::Type::FRAGMENT;
|
|
m_backgroundShader.AddDescriptorSetLayoutBinding(binding, 5);
|
|
m_backgroundShader.cullMode = CullMode::NONE;
|
|
SetShader(&m_backgroundShader);
|
|
}
|
|
|
|
void LabelDrawable::SetupBuffers()
|
|
{
|
|
DescriptorSetLayoutBinding binding = UniformBuffer::DESCRIPTOR_SET_LAYOUT_BINDING;
|
|
binding.stageFlags = ShaderProgramType::Type::VERTEX;
|
|
m_billboardBuffer.size = sizeof(BillboardControlBlock);
|
|
m_billboardBuffer.data = &m_billboardSettings;
|
|
m_billboardBuffer.setId = 4;
|
|
m_billboardBuffer.binding = binding;
|
|
|
|
binding.stageFlags = ShaderProgramType::Type::FRAGMENT;
|
|
m_labelBuffer.size = sizeof(LabelUniformData);
|
|
m_labelBuffer.data = &m_labelData;
|
|
m_labelBuffer.setId = 5;
|
|
m_labelBuffer.binding = binding;
|
|
}
|
|
}
|