pull master & resolve conflicts

Author: AnastaZIuk

include/nbl/builtin/hlsl/text_rendering/msdf.hlsl

@@ -23,19 +23,18 @@ This can then be processed using smoothstep to provide anti-alising when renderi
 @params:
 - msdfSample: sampled SNORM value from the MSDF texture generated by msdfgen library.
 
-- msdfPixelRange: specifies the width of the range around the shape between the minimum and maximum representable signed distance in shape units or distance field pixels, respectivelly.
-  for example if msdfPixelRange is 4, then the range of distance values are [-2, +2], and it can be computed by snormValue * MSDFPixelRange/2.0
-    so an snorm value of 1.0 means a distance of 2 pixels outside the shape (in msdf texture space)
-    This value is set when rendering the MSDF with MSDFgen.
-
-- screenPxRangeValue: the value used to convert the distance values in the msdf texture/atlas to distance in screen space. 
-  In other words it's DistanceInScreenSpace/DistanceInMSDFTextureSpace, the larger the glyph (or more zoomed in) the larger this value is.
-  In 2D Text Rendering it is computed by `GlyphScreenSpaceSize/GlyphTextureSpaceSize`
-  where GlyphTextureSpaceSize is the size of the glyph inside the msdf texture/atlas
+- pixelRange = msdfPixelRange * screenPxRangeValue, It is the value to convert snorm distance to screen space distance
+    - msdfPixelRange: specifies the width of the range around the shape between the minimum and maximum representable signed distance in shape units or distance field pixels, respectivelly.
+        for example if msdfPixelRange is 4, then the range of distance values are [-2, +2], and it can be computed by snormValue * MSDFPixelRange/2.0
+        so an snorm value of 1.0 means a distance of 2 pixels outside the shape (in msdf texture space)
+        This value is set when rendering the MSDF with MSDFgen.
+    - screenPxRangeValue: the value used to convert the distance values in the msdf texture/atlas to distance in screen space. 
+        In other words it's DistanceInScreenSpace/DistanceInMSDFTextureSpace, the larger the glyph (or more zoomed in) the larger this value is.
+        In 2D Text Rendering it is computed by `GlyphScreenSpaceSize/GlyphTextureSpaceSize`
+         where GlyphTextureSpaceSize is the size of the glyph inside the msdf texture/atlas
 */
-float msdfDistance(float3 msdfSample, float msdfPixelRange, float screenPxRangeValue) {
-    float texelDist = median(msdfSample.r, msdfSample.g, msdfSample.b) * msdfPixelRange / 2.0f;
-    return texelDist * screenPxRangeValue;
+float msdfDistance(float3 msdfSample, float pixelRange) {
+    return median(msdfSample.r, msdfSample.g, msdfSample.b) * pixelRange / 2.0f;
 }
 
 }

include/nbl/ext/TextRendering/TextRendering.h

@@ -34,8 +34,15 @@ class TextRenderer : public nbl::core::IReferenceCounted
 
 	static constexpr asset::E_FORMAT MSDFTextureFormat = asset::E_FORMAT::EF_R8G8B8A8_SNORM;
 
-	// Spits out CPUBuffer containing the image data in SNORM format
-	core::smart_refctd_ptr<ICPUBuffer> generateShapeMSDF(msdfgen::Shape glyph, uint32_t msdfPixelRange, uint32_t2 msdfExtents, float32_t2 scale, float32_t2 translate);
+	// Takes the CPUBuffer containing the image data in SNORM format and an offset into it
+	void generateShapeMSDF(
+		ICPUBuffer* bufferToFill,
+		size_t*	bufferOffset,
+		msdfgen::Shape glyph,
+		float32_t msdfPixelRange,
+		uint32_t2 msdfExtents, 
+		float32_t2 scale,
+		float32_t2 translate);
 
 	TextRenderer()
 	{
@@ -119,7 +126,7 @@ class FontFace : public nbl::core::IReferenceCounted
 	// it will place the glyph in the center of msdfExtents considering the margin of msdfPixelRange
 	// preserves aspect ratio of the glyph corresponding to metrics of the "glyphId"
 	// use the `getUV` to address the glyph in your texture correctly.
-	core::smart_refctd_ptr<ICPUBuffer> generateGlyphMSDF(uint32_t msdfPixelRange, uint32_t glyphId, uint32_t2 textureExtents);
+	core::smart_refctd_ptr<ICPUImage> generateGlyphMSDF(uint32_t baseMSDFPixelRange, uint32_t glyphId, uint32_t2 textureExtents, uint32_t mipLevels);
 
 	// transforms uv in glyph space to uv in the actual texture
 	float32_t2 getUV(float32_t2 uv, float32_t2 glyphSize, uint32_t2 textureExtents, uint32_t msdfPixelRange);

src/nbl/ext/TextRendering/TextRendering.cpp

@@ -17,40 +17,52 @@ namespace ext
 namespace TextRendering
 {
 
-core::smart_refctd_ptr<ICPUBuffer> TextRenderer::generateShapeMSDF(msdfgen::Shape glyph, uint32_t msdfPixelRange, uint32_t2 msdfExtents, float32_t2 scale, float32_t2 translate)
+void TextRenderer::generateShapeMSDF(
+	ICPUBuffer* bufferToFill,
+	size_t* bufferOffset,
+	msdfgen::Shape glyph,
+	float32_t msdfPixelRange,
+	uint32_t2 msdfExtents, 
+	float32_t2 scale,
+	float32_t2 translate)
 {
 	uint32_t glyphW = msdfExtents.x;
 	uint32_t glyphH = msdfExtents.y;
 
-	auto shapeBounds = glyph.getBounds();
+	size_t& offset = *bufferOffset;
+	size_t bufferSize = glyphW * glyphH * sizeof(int8_t) * 4;
+	assert(bufferToFill->getSize() >= bufferSize + offset);
+
+	int8_t* data = reinterpret_cast<int8_t*>(bufferToFill->getPointer());
+	
+	auto floatToSNORM8 = [](const float fl) -> int8_t
+	{
+		// we need to invert values because msdfgen assigns positive values for shape interior which is the exact opposite of our convention
+		return -1 * (int8_t)(std::clamp(fl * 2.0f - 1.0f, -1.0f, 1.0f) * 127.f);
+	};
 
 	msdfgen::edgeColoringSimple(glyph, 3.0);
-	msdfgen::Bitmap<float, 4> msdfMap(glyphW, glyphH);
 
-	msdfgen::generateMTSDF(msdfMap, glyph, msdfPixelRange, { scale.x, scale.y }, { translate.x, translate.y });
+	auto shapeBounds = glyph.getBounds();
 
-	auto cpuBuf = core::make_smart_refctd_ptr<ICPUBuffer>(glyphW * glyphH * sizeof(int8_t) * 4);
-	int8_t* data = reinterpret_cast<int8_t*>(cpuBuf->getPointer());
+	msdfgen::Bitmap<float, 4> msdfMap(msdfExtents.x, msdfExtents.y);
 
-	auto floatToSNORM8 = [](const float fl) -> int8_t
-		{
-			// we need to invert values because msdfgen assigns positive values for shape interior which is the exact opposite of our convention
-			return -1 * (int8_t)(std::clamp(fl * 2.0f - 1.0f, -1.0f, 1.0f) * 127.f);
-		};
+	float32_t pxRange = msdfPixelRange / (min(scale.x, scale.y));
+	msdfgen::generateMTSDF(msdfMap, glyph, pxRange, { scale.x, scale.y }, { translate.x, translate.y });
 
-	for (int y = 0; y < msdfMap.height(); ++y)
+	for (int y = 0; y < msdfExtents.x; ++y)
 	{
-		for (int x = 0; x < msdfMap.width(); ++x)
+		for (int x = 0; x < msdfExtents.y; ++x)
 		{
-			auto pixel = msdfMap(x, glyphH - 1 - y);
-			data[(x + y * glyphW) * 4 + 0] = floatToSNORM8(pixel[0]);
-			data[(x + y * glyphW) * 4 + 1] = floatToSNORM8(pixel[1]);
-			data[(x + y * glyphW) * 4 + 2] = floatToSNORM8(pixel[2]);
-			data[(x + y * glyphW) * 4 + 3] = floatToSNORM8(pixel[3]);
+			auto pixel = msdfMap(x, msdfExtents.y - 1 - y);
+			data[offset + (x + y * msdfExtents.x) * 4 + 0] = floatToSNORM8(pixel[0]);
+			data[offset + (x + y * msdfExtents.x) * 4 + 1] = floatToSNORM8(pixel[1]);
+			data[offset + (x + y * msdfExtents.x) * 4 + 2] = floatToSNORM8(pixel[2]);
+			data[offset + (x + y * msdfExtents.x) * 4 + 3] = floatToSNORM8(pixel[3]);
 		}
 	}
 
-	return std::move(cpuBuf);
+	offset += bufferSize;
 }
 
 constexpr double FreeTypeFontScaling = 1.0 / 64.0;
@@ -75,33 +87,86 @@ FontFace::GlyphMetrics FontFace::getGlyphMetrics(uint32_t glyphId)
 	};
 }
 
-core::smart_refctd_ptr<ICPUBuffer> FontFace::generateGlyphMSDF(uint32_t msdfPixelRange, uint32_t glyphId, uint32_t2 textureExtents)
+core::smart_refctd_ptr<ICPUImage> FontFace::generateGlyphMSDF(uint32_t baseMSDFPixelRange, uint32_t glyphId, uint32_t2 textureExtents, uint32_t mipLevels)
 {
-	auto shape = generateGlyphShape(glyphId);
+	ICPUImage::SCreationParams imgParams;
+	{
+		imgParams.flags = static_cast<ICPUImage::E_CREATE_FLAGS>(0u); // no flags
+		imgParams.type = ICPUImage::ET_2D;
+		imgParams.format = TextRenderer::MSDFTextureFormat;
+		imgParams.extent = { textureExtents.x, textureExtents.y, 1 };
+		imgParams.mipLevels = mipLevels;
+		imgParams.arrayLayers = 1u;
+		imgParams.samples = ICPUImage::ESCF_1_BIT;
+	}
 
-	// Empty shapes should've been filtered sooner
-	assert(!shape.contours.empty());
+	uint32_t bufferSize = 0u;
+	for (uint32_t i = 0; i < mipLevels; i++)
+	{
+		uint32_t mipW = textureExtents.x / (1 << i);
+		uint32_t mipH = textureExtents.y / (1 << i);
+		bufferSize += mipW * mipH * sizeof(uint8_t) * 4;
+	}
 
-	auto shapeBounds = shape.getBounds();
+	auto image = ICPUImage::create(std::move(imgParams));
+	auto buffer = core::make_smart_refctd_ptr<ICPUBuffer>(bufferSize);
+	auto regions = core::make_refctd_dynamic_array<core::smart_refctd_dynamic_array<IImage::SBufferCopy>>(mipLevels);
 
-	float32_t2 frameSize = float32_t2(
-		(shapeBounds.r - shapeBounds.l),
-		(shapeBounds.t - shapeBounds.b)
-	);
+	size_t bufferOffset = 0ull;
+	for (uint32_t i = 0; i < mipLevels; i++)
+	{
+		// we need to generate a msdfgen per mip map, because the msdf generate call consumes the shape
+		// and we can't deep clone it
+		auto shape = generateGlyphShape(glyphId);
+
+		// Empty shapes should've been filtered sooner
+		assert(!shape.contours.empty());
+
+		uint32_t mipW = textureExtents.x / (1 << i);
+		uint32_t mipH = textureExtents.y / (1 << i);
+
+		auto& region = regions->begin()[i];
+		region.bufferOffset = bufferOffset;
+		region.bufferRowLength = mipW;
+		region.bufferImageHeight = mipH;
+		region.imageSubresource.aspectMask = asset::IImage::E_ASPECT_FLAGS::EAF_COLOR_BIT;
+		region.imageSubresource.mipLevel = i;
+		region.imageSubresource.baseArrayLayer = 0u;
+		region.imageSubresource.layerCount = 1u;
+		region.imageOffset = { 0u,0u,0u };
+		region.imageExtent = { mipW, mipH, 1u };
+
+		auto shapeBounds = shape.getBounds();
+
+		float32_t2 mipExtents = float32_t2(float(mipW), float(mipH));
+		float32_t mipPixelRange = (float32_t)baseMSDFPixelRange / pow(2.0, double(i)); // TODO: Pixel range should be float
+
+		float32_t2 frameSize = float32_t2(
+			(shapeBounds.r - shapeBounds.l),
+			(shapeBounds.t - shapeBounds.b)
+		);
+
+		const float32_t2 margin = float32_t2(mipPixelRange * 2);
+		const float32_t2 nonUniformScale = (mipExtents - margin) / frameSize;
+		const float32_t uniformScale = core::min(nonUniformScale.x, nonUniformScale.y);
+		
+		// Center before: ((shapeBounds.l + shapeBounds.r) * 0.5, (shapeBounds.t + shapeBounds.b) * 0.5)
+		// Center after: msdfExtents / 2.0
+		// Transformation implementation: Center after = (Center before + Translation) * Scale
+		// Plugging in the values and solving for translate yields:
+		// Translate = (msdfExtents / (2 * scale)) - ((shapeBounds.l + shapeBounds.r) * 0.5, (shapeBounds.t + shapeBounds.b) * 0.5)
+		const float32_t2 shapeSpaceCenter = float32_t2(shapeBounds.l + shapeBounds.r, shapeBounds.t + shapeBounds.b) * float32_t2(0.5);
+		const float32_t2 translate = mipExtents / (float32_t2(2.0) * uniformScale) - shapeSpaceCenter;
+
+		// We are using `baseMSDFPixelRange`, because we still need larger range for smaller mips when aa feather is relatively large.
+		// WARNING: HWTrilinear filtering will not give correct results.
+		//because now the baseMSDFPixelRange is being used for all mips as it's wrong to mix/lerp values that have different scales (pixel ranges)
+		m_textRenderer->generateShapeMSDF(buffer.get(), &bufferOffset, shape, baseMSDFPixelRange, mipExtents, float32_t2(uniformScale, uniformScale), translate);
+	}
+	assert(bufferOffset <= buffer->getCreationParams().size);
+	image->setBufferAndRegions(std::move(buffer), std::move(regions));
 
-	const float32_t2 margin = float32_t2(msdfPixelRange * 2.0f);
-	const float32_t2 nonUniformScale = (float32_t2(textureExtents) - margin) / frameSize;
-	const float32_t uniformScale = core::min(nonUniformScale.x, nonUniformScale.y);
-	
-	// Center before: ((shapeBounds.l + shapeBounds.r) * 0.5, (shapeBounds.t + shapeBounds.b) * 0.5)
-	// Center after: msdfExtents / 2.0
-	// Transformation implementation: Center after = (Center before + Translation) * Scale
-	// Plugging in the values and solving for translate yields:
-	// Translate = (msdfExtents / (2 * scale)) - ((shapeBounds.l + shapeBounds.r) * 0.5, (shapeBounds.t + shapeBounds.b) * 0.5)
-	const float32_t2 shapeSpaceCenter = float32_t2(shapeBounds.l + shapeBounds.r, shapeBounds.t + shapeBounds.b) * float32_t2(0.5);
-	const float32_t2 translate = float32_t2(textureExtents) / (float32_t2(2.0) * uniformScale) - shapeSpaceCenter;
-
-	return m_textRenderer->generateShapeMSDF(shape, msdfPixelRange, textureExtents, float32_t2(uniformScale, uniformScale), translate);
+	return std::move(image);
 }
 
 float32_t2 FontFace::getUV(float32_t2 uv, float32_t2 glyphSize, uint32_t2 textureExtents, uint32_t msdfPixelRange)