[62.CAD] Fixes to SingleLineText and Rendering Stretched Text

Author: Erfan-Ahmadi

62_CAD/SingleLineText.cpp

@@ -3,14 +3,17 @@
 SingleLineText::SingleLineText(core::smart_refctd_ptr<nbl::ext::TextRendering::FontFace>&& face, const std::string& text)
 {
 	m_face = std::move(face);
-	glyphBoxes.reserve(text.length());
+	m_glyphBoxes.reserve(text.length());
+
+	m_boundingBox.min = float64_t2(0.0, 0.0);
+	m_boundingBox.max = float64_t2(0.0, 0.0);
 
 	// Position transform
 	float64_t2 currentPos = float32_t2(0.0, 0.0);
 	for (uint32_t i = 0; i < text.length(); i++)
 	{
 		const auto glyphIndex = m_face->getGlyphIndex(wchar_t(text.at(i)));
-		const auto glyphMetrics = m_face->getGlyphMetricss(glyphIndex);
+		const auto glyphMetrics = m_face->getGlyphMetrics(glyphIndex);
 		const bool skipGenerateGlyph = (glyphIndex == 0 || (glyphMetrics.size.x == 0.0 && glyphMetrics.size.y == 0.0));
 
 		if (!skipGenerateGlyph)
@@ -25,7 +28,13 @@ SingleLineText::SingleLineText(core::smart_refctd_ptr<nbl::ext::TextRendering::F
 				.size = glyphMetrics.size,
 				.glyphIdx = glyphIndex,
 			};
-			glyphBoxes.push_back(glyphBbox);
+
+			m_boundingBox.min.x = nbl::core::min(m_boundingBox.min.x, glyphBbox.topLeft.x);
+			m_boundingBox.min.y = nbl::core::min(m_boundingBox.min.y, glyphBbox.topLeft.y - glyphBbox.size.y);
+			m_boundingBox.max.x = nbl::core::max(m_boundingBox.max.x, glyphBbox.topLeft.x + glyphBbox.size.x);
+			m_boundingBox.max.y = nbl::core::max(m_boundingBox.max.y, glyphBbox.topLeft.y);
+
+			m_glyphBoxes.push_back(glyphBbox);
 		}
 		currentPos += glyphMetrics.advance;
 	}
@@ -36,7 +45,8 @@ void SingleLineText::Draw(
 	SIntendedSubmitInfo& intendedNextSubmit,
 	const float64_t2& baselineStart,
 	const float32_t2& scale,
-	const float32_t& rotateAngle)
+	const float32_t& rotateAngle,
+	const float32_t4& color) const
 {
 	float32_t2 vec(cos(rotateAngle), sin(rotateAngle));
 	float64_t3x3 rotationMulScaleMat =
@@ -54,11 +64,11 @@ void SingleLineText::Draw(
 	float64_t3x3 transformation = mul(translationMat, rotationMulScaleMat);
 
 	LineStyleInfo lineStyle = {};
-	lineStyle.color = float32_t4(1.0, 1.0, 1.0, 1.0);
+	lineStyle.color = color;
 	const uint32_t styleIdx = drawResourcesFiller.addLineStyle_SubmitIfNeeded(lineStyle, intendedNextSubmit);
 	auto glyphObjectIdx = drawResourcesFiller.addMainObject_SubmitIfNeeded(styleIdx, intendedNextSubmit);
 
-	for (const auto& glyphBox : glyphBoxes)
+	for (const auto& glyphBox : m_glyphBoxes)
 	{
 		const float64_t2 topLeft = mul(transformation, float64_t3(glyphBox.topLeft, 1.0)).xy;
 		const float64_t2 dirU = mul(transformation, float64_t3(glyphBox.size.x, 0.0, 0.0)).xy;
@@ -70,5 +80,4 @@ void SingleLineText::Draw(
 		drawResourcesFiller.drawFontGlyph(m_face.get(), glyphBox.glyphIdx, topLeft, dirU, aspectRatio, minUV, glyphObjectIdx, intendedNextSubmit);
 	}
 
-}
-
+}

62_CAD/SingleLineText.h

@@ -12,15 +12,24 @@ class SingleLineText
 public:
 	// constructs and fills the `glyphBoxes`
 	SingleLineText(core::smart_refctd_ptr<nbl::ext::TextRendering::FontFace>&& face, const std::string& text);
+	
+	struct BoundingBox
+	{
+		float64_t2 min;
+		float64_t2 max;
+	};
+
+	BoundingBox GetAABB() const { return m_boundingBox; }
 
 	// iterates over `glyphBoxes` generates textures msdfs if failed to add to cache (through that lambda you put)
 	// void Draw(DrawResourcesFiller& drawResourcesFiller, SIntendedSubmitInfo& intendedNextSubmit);
 	void Draw(
 		DrawResourcesFiller& drawResourcesFiller,
 		SIntendedSubmitInfo& intendedNextSubmit,
 		const float64_t2& baselineStart = float64_t2(0.0,0.0),
-		const float32_t2& scale = float64_t2(1.0, 1.0),
-		const float32_t& rotateAngle = 0);
+		const float32_t2& scale = float64_t2(1.0f, 1.0f),
+		const float32_t& rotateAngle = 0.0f,
+		const float32_t4& color = float32_t4(1.0f,1.0f,1.0f,1.0f)) const;
 
 protected:
 
@@ -31,8 +40,8 @@ class SingleLineText
 		uint32_t glyphIdx;
 		uint32_t pad;
 	};
-
-	std::vector<GlyphBox> glyphBoxes;
+	
+	BoundingBox m_boundingBox = {};
+	std::vector<GlyphBox> m_glyphBoxes;
 	core::smart_refctd_ptr<nbl::ext::TextRendering::FontFace> m_face;
-};
-
+};

62_CAD/main.cpp

@@ -68,7 +68,7 @@ constexpr std::array<float, (uint32_t)ExampleMode::CASE_COUNT> cameraExtents =
 	600.0,	// CASE_8
 };
 
-constexpr ExampleMode mode = ExampleMode::CASE_3;
+constexpr ExampleMode mode = ExampleMode::CASE_8;
 
 class Camera2D
 {
@@ -2922,7 +2922,7 @@ class ComputerAidedDesign final : public examples::SimpleWindowedApplication, pu
 				{
 					char k = TestString[i];
 					auto glyphIndex = m_arialFont->getGlyphIndex(wchar_t(k));
-					const auto glyphMetrics = m_arialFont->getGlyphMetricss(glyphIndex);
+					const auto glyphMetrics = m_arialFont->getGlyphMetrics(glyphIndex);
 					const float64_t2 baselineStart = currentBaselineStart;
 
 					currentBaselineStart += glyphMetrics.advance;

62_CAD/vertex_shader.hlsl

@@ -506,12 +506,14 @@ PSInput main(uint vertexID : SV_VertexID)
         const float2 offsetVec = vx * undilatedCornerNDC.x + vy * undilatedCornerNDC.y;
         const float2 coord = screenTopLeft + corner.x * screenDirU + corner.y * screenDirV + offsetVec;
 
-        // If aspect ratio of the dimensions and glyph inside the texture are the same -->
-        // it doesn't matter which component (x or y) to use to compute screenPxRange.
+        // If aspect ratio of the dimensions and glyph inside the texture are the same then screenPxRangeX === screenPxRangeY
         // but if the glyph box is stretched in any way then we won't get correct msdf
-        // We compute this value using the ration of our screenspace extent to the texel space our glyph takes inside the texture
+        // in that case we need to take the max(screenPxRangeX, screenPxRangeY) to avoid blur due to underexaggerated distances
+        // We compute screenPxRange using the ratio of our screenspace extent to the texel space our glyph takes inside the texture
         // Our glyph is centered inside the texture, so `maxUV = 1.0 - minUV` and `glyphTexelSize = (1.0-2.0*minUV) * MSDFSize
-        const float screenPxRange = max(screenSpaceAabbExtents.x / ((1.0 - 2.0 * minUV.x) * MSDFSize), 1.0);
+        const float screenPxRangeX = screenSpaceAabbExtents.x / ((1.0 - 2.0 * minUV.x) * MSDFSize);
+        const float screenPxRangeY = screenSpaceAabbExtents.y / ((1.0 - 2.0 * minUV.y) * MSDFSize);
+        const float screenPxRange = max(max(screenPxRangeX, screenPxRangeY), 1.0);
 
         // In order to keep the shape scale constant with any dilation values:
         // We compute the new dilated minUV that gets us minUV when interpolated on the previous undilated top left
@@ -524,8 +526,7 @@ PSInput main(uint vertexID : SV_VertexID)
         outV.position = float4(coord, 0.f, 1.f);
         outV.setFontGlyphUV(uv);
         outV.setFontGlyphTextureId(textureID);
-        outV.setFontGlyphScreenPxRange(screenPxRange);
-    }
+        outV.setFontGlyphScreenPxRange(screenPxRange);    }
     else if (objType == ObjectType::IMAGE)
     {
         float64_t2 topLeft = vk::RawBufferLoad<double2>(drawObj.geometryAddress, 8u);