Merge branch 'master' into cad-text-rendering-mip-maps

Author: deprilula28

3rdparty/CMakeLists.txt

@@ -30,6 +30,7 @@ add_library(Freetype::Freetype ALIAS freetype) # alias target for MSDFGEN not tr
 
 # msdfgen
 set(MSDFGEN_USE_VCPKG OFF)
+set(MSDFGEN_USE_SKIA OFF)
 set(MSDFGEN_CORE_ONLY OFF) # if turned on then MSDFGEN will be built without dependencies like freetype or skia
 set(MSDFGEN_INSTALL OFF)
 set(MSDFGEN_BUILD_STANDALONE OFF)

examples_tests

@@ -7,10 +7,8 @@
 
 #include "nabla.h"
 
-#include "nbl/video/utilities/CPropertyPool.h"
 #include <msdfgen/msdfgen.h>
 #include <ft2build.h>
-#include <nbl/ext/TextRendering/TextRendering.h>
 #include <nbl/builtin/hlsl/cpp_compat.hlsl>
 #include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
 #include <nbl/builtin/hlsl/cpp_compat/vector.hlsl>
@@ -46,6 +44,12 @@ class TextRenderer : public nbl::core::IReferenceCounted
 		auto error = FT_Init_FreeType(&m_ftLibrary);
 		assert(!error);
 	}
+
+	~TextRenderer()
+	{
+		auto error = FT_Done_FreeType(m_ftLibrary);
+		assert(!error);
+	}
 
 	// TODO: Remove these here, it's only used for customized tests such as building shapes for hatches
 	const FT_Library& getFreetypeLibrary() const { return m_ftLibrary; }
@@ -59,11 +63,23 @@ class TextRenderer : public nbl::core::IReferenceCounted
 class FontFace : public nbl::core::IReferenceCounted
 {
 public:
+
+	// Face Global Metrics/Settings
+	struct Metrics
+	{
+		// This value is the vertical distance between two consecutive baselines, expressed in font units. It is always positive.
+		float64_t height;
+		// The distance from the baseline to the highest or upper grid coordinate used to place an outline point. It is a positive value.
+		float64_t ascent;
+		// The distance from the baseline to the lowest grid coordinate used to place an outline point. this is almost always a negative value.
+		float64_t descent;
+	};
+
 	struct GlyphMetrics
 	{
 		// Offset that should be applied to the current baseline after this glyph is placed
 		float64_t2 advance;
-		// Offset that the image of the glyph should be placed from the current baseline start, horizontal refers to horizonral LTR or RTL Languages
+		// Offset of the glyph's top left from the current baseline start, horizontal refers to horizonral LTR or RTL Languages
 		float64_t2 horizontalBearing;
 		// Size of the glyph in the text line
 		float64_t2 size;
@@ -79,6 +95,12 @@ class FontFace : public nbl::core::IReferenceCounted
 		m_hash = std::hash<std::string>{}(path);
 	}
 
+	~FontFace()
+	{
+		auto error = FT_Done_Face(m_ftFace);
+		assert(!error);
+	}
+
 	static constexpr uint32_t InvalidGlyphIndex = ~0u;
 
 	uint32_t getGlyphIndex(wchar_t unicode)
@@ -91,7 +113,9 @@ class FontFace : public nbl::core::IReferenceCounted
 		return FT_Get_Char_Index(m_ftFace, unicode);
 	}
 
-	GlyphMetrics getGlyphMetricss(uint32_t glyphId);
+	Metrics getMetrics() const;
+
+	GlyphMetrics getGlyphMetrics(uint32_t glyphId);
 
 	// returns the cpu buffer for the generated MSDF texture with "TextRenderer::MSDFTextureFormat" format
 	// it will place the glyph in the center of msdfExtents considering the margin of msdfPixelRange
@@ -142,7 +166,7 @@ class GlyphShapeBuilder {
 	void lineTo(const float64_t2 to)
 	{
 		if (to != lastPosition) {
-			currentContour->addEdge(new msdfgen::LinearSegment(msdfPoint(lastPosition), msdfPoint(to)));
+			currentContour->addEdge(msdfgen::EdgeHolder(msdfPoint(lastPosition), msdfPoint(to)));
 			lastPosition = to;
 		}
 	}
@@ -151,15 +175,15 @@ class GlyphShapeBuilder {
 	// [last position, control, end]
 	void quadratic(const float64_t2 control, const float64_t2 to)
 	{
-		currentContour->addEdge(new msdfgen::QuadraticSegment(msdfPoint(lastPosition), msdfPoint(control), msdfPoint(to)));
+		currentContour->addEdge(msdfgen::EdgeHolder(msdfPoint(lastPosition), msdfPoint(control), msdfPoint(to)));
 		lastPosition = to;
 	}
 
 	// Continue the last moveTo or lineTo with a cubic bezier:
 	// [last position, control1, control2, end]
 	void cubic(const float64_t2 control1, const float64_t2 control2, const float64_t2 to)
 	{
-		currentContour->addEdge(new msdfgen::CubicSegment(msdfPoint(lastPosition), msdfPoint(control1), msdfPoint(control2), msdfPoint(to)));
+		currentContour->addEdge(msdfgen::EdgeHolder(msdfPoint(lastPosition), msdfPoint(control1), msdfPoint(control2), msdfPoint(to)));
 		lastPosition = to;
 	}
 

include/nbl/ext/TextRendering/TextRendering.h

@@ -130,24 +130,36 @@ struct SIntendedSubmitInfo final : core::Uncopyable
 
         // One thing you might notice is that this results in a few implicit Memory and Execution Dependencies
         // So there's a little bit of non-deterministic behaviour we won't fight (will not insert a barrier every time you "could-have" overflown)
-        inline void overflowSubmit()
+        inline IQueue::RESULT overflowSubmit()
         {
             auto cmdbuf = getScratchCommandBuffer();
             // first sumbit the already buffered up work
             cmdbuf->end();
+            
             // we only signal the scratch semaphore when overflowing
             const auto submit = popSubmit({});
-            queue->submit(submit);
+            IQueue::RESULT res = queue->submit(submit);
+            if (res != IQueue::RESULT::SUCCESS)
+                return res;
+            
             // We wait (stall) on the immediately preceeding submission, this could be improved in the future with multiple buffering of the commandbuffers
             {
                 const ISemaphore::SWaitInfo info = {.semaphore=scratchSemaphore.semaphore,.value=scratchSemaphore.value};
-                const_cast<ILogicalDevice*>(cmdbuf->getOriginDevice())->blockForSemaphores({&info,1});
+                ISemaphore::WAIT_RESULT waitResult = const_cast<ILogicalDevice*>(cmdbuf->getOriginDevice())->blockForSemaphores({&info,1});
+                if (waitResult != ISemaphore::WAIT_RESULT::SUCCESS)
+                {
+                    assert(false);
+                    return IQueue::RESULT::OTHER_ERROR;
+                }
             }
             // since all the commandbuffers have submitted already we only reuse the last one
             commandBuffers = {&commandBuffers.back(),1};
+            
+            
             // we will still signal the same set in the future
             cmdbuf->reset(IGPUCommandBuffer::RESET_FLAGS::RELEASE_RESOURCES_BIT);
             cmdbuf->begin(IGPUCommandBuffer::USAGE::ONE_TIME_SUBMIT_BIT);
+            return res;
         }
 
         // Error Text to Log/Display if you try to use an invalid `SIntendedSubmitInfo`

include/nbl/video/utilities/SIntendedSubmitInfo.h

@@ -1,20 +1,26 @@
 # Creates a c++ file for builtin resources that contains binary data of all resources
 
-# TODO: use argparse not this by-hand-shit
-
-import sys, os, subprocess, json
+import argparse, os, subprocess, json
 from datetime import datetime, timezone
 
-if  len(sys.argv) < 8 :
-    print(sys.argv[0] + " - Incorrect argument count")
-else:
-    outputBuiltinPath = sys.argv[1]
-    outputArchivePath = sys.argv[2]
-    bundleAbsoluteEntryPath = sys.argv[3]
-    resourcesFile  = sys.argv[4]
-    resourcesNamespace = sys.argv[5]
-    correspondingHeaderFile = sys.argv[6]
-    xxHash256Exe = sys.argv[7]
+
+parser = argparse.ArgumentParser(description="Creates a c++ file for builtin resources that contains binary data of all resources")
+parser.add_argument('--outputBuiltinPath', required=True, help="output path of generated C++ builtin data source")
+parser.add_argument('--outputArchivePath', required=True, help="output path of generated C++ archive data source")
+parser.add_argument('--bundleAbsoluteEntryPath', required=True, help="\"absolute path\" for an archive which will store a given bundle of builtin resources")
+parser.add_argument('--resourcesFile', required=True, help="path to file containing resources list")
+parser.add_argument('--resourcesNamespace', required=True, help="a C++ namespace builtin resources will be wrapped into")
+parser.add_argument('--correspondingHeaderFile', required=True, help="filename of previosly generated header (via buitinHeaderGen.py)")
+parser.add_argument('--xxHash256Exe', default="", nargs='?', help="path to xxHash256 executable")
+
+def execute(args):
+    outputBuiltinPath = args.outputBuiltinPath
+    outputArchivePath = args.outputArchivePath
+    bundleAbsoluteEntryPath = args.bundleAbsoluteEntryPath
+    resourcesFile = args.resourcesFile
+    resourcesNamespace = args.resourcesNamespace
+    correspondingHeaderFile = args.correspondingHeaderFile
+    xxHash256Exe = args.xxHash256Exe
 
     forceConstexprHash = True if not xxHash256Exe else False
 
@@ -196,4 +202,9 @@
 
     outp = open(outputArchivePath, "w+")
     outp.write(archiveSource)
-    outp.close()
+    outp.close()
+
+
+if __name__ == "__main__":
+    args: argparse.Namespace = parser.parse_args()
+    execute(args)

src/nbl/builtin/builtinDataGen.py

@@ -1,19 +1,25 @@
 # Creates a header file for builtin resources
 
-# TODO: use argparse not this by-hand-shit
-
-import sys, os
-
-if  len(sys.argv) < 8 :
-    print(sys.argv[0] + " - Incorrect argument count")
-else:
-    outputBuiltinPath = sys.argv[1]
-    outputArchivePath = sys.argv[2]
-    archiveBundlePath = sys.argv[3]
-    resourcesFile  = sys.argv[4]
-    resourcesNamespace = sys.argv[5]
-    guardSuffix = sys.argv[6]
-    isSharedLibrary = True if sys.argv[7] == "True" else False
+import argparse, sys, os
+
+
+parser = argparse.ArgumentParser(description="Creates a c++ file for builtin resources that contains binary data of all resources")
+parser.add_argument('--outputBuiltinPath', required=True, help="output path of generated C++ builtin header source")
+parser.add_argument('--outputArchivePath', required=True, help="output path of generated C++ archive header source")
+parser.add_argument('--archiveBundlePath', required=True, help="path for an archive which will store a given bundle of builtin resources")
+parser.add_argument('--resourcesFile', required=True, help="path for a file which containins list of resources")
+parser.add_argument('--resourcesNamespace', required=True, help="a C++ namespace builtin resources will be wrapped into")
+parser.add_argument('--guardSuffix', required=True, help="include guard suffix name, for C header files")
+parser.add_argument('--isSharedLibrary', required=True, choices=["True", "False"])
+
+def execute(args):
+    outputBuiltinPath = args.outputBuiltinPath
+    outputArchivePath = args.outputArchivePath
+    archiveBundlePath = args.archiveBundlePath
+    resourcesFile = args.resourcesFile
+    resourcesNamespace = args.resourcesNamespace
+    guardSuffix = args.guardSuffix
+    isSharedLibrary = True if args.isSharedLibrary == "True" else False
 
     NBL_BR_API = "NBL_BR_API" if isSharedLibrary else ""
 
@@ -134,3 +140,7 @@ class {NBL_BR_API} CArchive final : public nbl::system::CFileArchive
     outp = open(outputArchivePath, "w+")
     outp.write(archiveHeader)
     outp.close()
+
+if __name__ == "__main__":
+    args: argparse.Namespace = parser.parse_args()
+    execute(args)

src/nbl/builtin/builtinHeaderGen.py

@@ -133,9 +133,14 @@ function(ADD_CUSTOM_BUILTIN_RESOURCES _TARGET_NAME_ _BUNDLE_NAME_ _BUNDLE_SEARCH
 		set(_NBL_BR_RUNTIME_HASH_ 1)
 	endif()
 
+	set(NBL_BUILTIN_RESOURCES_COMMON_ARGS
+   		--resourcesFile "${NBL_RESOURCES_LIST_FILE}"
+   		--resourcesNamespace "${_NAMESPACE_}"
+	)
+
 	add_custom_command(OUTPUT "${NBL_BUILTIN_RESOURCES_H}" "${NBL_BUILTIN_RESOURCE_DATA_CPP}" "${NBL_BUILTIN_DATA_ARCHIVE_H}" "${NBL_BUILTIN_DATA_ARCHIVE_CPP}"
-		COMMAND "${_Python3_EXECUTABLE}" "${NBL_BUILTIN_HEADER_GEN_PY}" "${NBL_BUILTIN_RESOURCES_H}" "${NBL_BUILTIN_DATA_ARCHIVE_H}" "${_BUNDLE_ARCHIVE_ABSOLUTE_PATH_}" "${NBL_RESOURCES_LIST_FILE}" "${_NAMESPACE_}" "${_GUARD_SUFFIX_}" "${_SHARED_}"
-		COMMAND "${_Python3_EXECUTABLE}" "${NBL_BUILTIN_DATA_GEN_PY}" "${NBL_BUILTIN_RESOURCE_DATA_CPP}" "${NBL_BUILTIN_DATA_ARCHIVE_CPP}" "${_BUNDLE_SEARCH_DIRECTORY_}/${_BUNDLE_ARCHIVE_ABSOLUTE_PATH_}" "${NBL_RESOURCES_LIST_FILE}" "${_NAMESPACE_}" "${NBL_BS_HEADER_FILENAME}" "$<${_NBL_BR_RUNTIME_HASH_}:$<TARGET_FILE:xxHash256>>"
+		COMMAND "${_Python3_EXECUTABLE}" "${NBL_BUILTIN_HEADER_GEN_PY}" ${NBL_BUILTIN_RESOURCES_COMMON_ARGS} --outputBuiltinPath "${NBL_BUILTIN_RESOURCES_H}" --outputArchivePath "${NBL_BUILTIN_DATA_ARCHIVE_H}" --archiveBundlePath "${_BUNDLE_ARCHIVE_ABSOLUTE_PATH_}" --guardSuffix "${_GUARD_SUFFIX_}" --isSharedLibrary "${_SHARED_}"
+		COMMAND "${_Python3_EXECUTABLE}" "${NBL_BUILTIN_DATA_GEN_PY}" ${NBL_BUILTIN_RESOURCES_COMMON_ARGS} --outputBuiltinPath "${NBL_BUILTIN_RESOURCE_DATA_CPP}" --outputArchivePath "${NBL_BUILTIN_DATA_ARCHIVE_CPP}" --bundleAbsoluteEntryPath "${_BUNDLE_SEARCH_DIRECTORY_}/${_BUNDLE_ARCHIVE_ABSOLUTE_PATH_}" --correspondingHeaderFile "${NBL_BS_HEADER_FILENAME}" --xxHash256Exe "$<${_NBL_BR_RUNTIME_HASH_}:$<TARGET_FILE:xxHash256>>"
 		COMMENT "Generating \"${_TARGET_NAME_}\"'s sources & headers"
 		DEPENDS ${NBL_DEPENDENCY_FILES}
 		VERBATIM

src/nbl/builtin/utils.cmake

@@ -1,4 +1,3 @@
-
 using namespace nbl;
 using namespace nbl::core;
 using namespace nbl::asset;
@@ -57,7 +56,16 @@ core::smart_refctd_ptr<ICPUBuffer> TextRenderer::generateShapeMSDF(msdfgen::Shap
 
 constexpr double FreeTypeFontScaling = 1.0 / 64.0;
 
-FontFace::GlyphMetrics FontFace::getGlyphMetricss(uint32_t glyphId)
+FontFace::Metrics FontFace::getMetrics() const
+{
+	Metrics ret = {};
+	ret.height = float64_t(m_ftFace->height) * FreeTypeFontScaling;
+	ret.ascent = float64_t(m_ftFace->ascender) * FreeTypeFontScaling;
+	ret.descent = float64_t(m_ftFace->descender) * FreeTypeFontScaling;
+	return ret;
+}
+
+FontFace::GlyphMetrics FontFace::getGlyphMetrics(uint32_t glyphId)
 {
 	auto slot = getGlyphSlot(glyphId);
 
@@ -177,4 +185,4 @@ msdfgen::Shape FontFace::generateGlyphShape(uint32_t glyphId)
 
 }
 }
-}
+}

src/nbl/ext/TextRendering/TextRendering.cpp

@@ -156,7 +156,7 @@ bool IGPUCommandBuffer::reset(const core::bitflag<RESET_FLAGS> flags)
 {
     if (!canReset())
     {
-        m_logger.log("Failed to reset command buffer.", system::ILogger::ELL_ERROR);
+        m_logger.log("Failed to reset command buffer, state is: %d", system::ILogger::ELL_ERROR, (uint32_t)m_state);
         m_state = STATE::INVALID;
         return false;
     }

src/nbl/video/IGPUCommandBuffer.cpp

@@ -260,7 +260,10 @@ core::smart_refctd_ptr<IGPUBufferView> ILogicalDevice::createBufferView(const as
 core::smart_refctd_ptr<IGPUShader> ILogicalDevice::createShader(const SShaderCreationParameters& creationParams)
 {
     if (!creationParams.cpushader)
+    {
+        m_logger.log("No valid CPU Shader supplied",system::ILogger::ELL_ERROR);
         return nullptr;
+    }
 
     const asset::IShader::E_SHADER_STAGE shaderStage = creationParams.cpushader->getStage();
     const auto& features = getEnabledFeatures();
@@ -277,11 +280,17 @@ core::smart_refctd_ptr<IGPUShader> ILogicalDevice::createShader(const SShaderCre
         case IGPUShader::E_SHADER_STAGE::ESS_TESSELLATION_CONTROL: [[fallthrough]];
         case IGPUShader::E_SHADER_STAGE::ESS_TESSELLATION_EVALUATION:
             if (!features.tessellationShader)
+            {
+                m_logger.log("Cannot create IGPUShader for %p, Tessellation Shader feature not enabled!",system::ILogger::ELL_ERROR,creationParams.cpushader);
                 return nullptr;
+            }
             break;
         case IGPUShader::E_SHADER_STAGE::ESS_GEOMETRY:
             if (!features.geometryShader)
+            {
+                m_logger.log("Cannot create IGPUShader for %p, Geometry Shader feature not enabled!",system::ILogger::ELL_ERROR,creationParams.cpushader);
                 return nullptr;
+            }
             break;
         case IGPUShader::E_SHADER_STAGE::ESS_FRAGMENT: [[fallthrough]];
         case IGPUShader::E_SHADER_STAGE::ESS_COMPUTE:
@@ -298,10 +307,14 @@ core::smart_refctd_ptr<IGPUShader> ILogicalDevice::createShader(const SShaderCre
         case IGPUShader::E_SHADER_STAGE::ESS_INTERSECTION: [[fallthrough]];
         case IGPUShader::E_SHADER_STAGE::ESS_CALLABLE:
             if (!features.rayTracingPipeline)
+            {
+                m_logger.log("Cannot create IGPUShader for %p, Raytracing Pipeline feature not enabled!",system::ILogger::ELL_ERROR,creationParams.cpushader);
                 return nullptr;
+            }
             break;
         default:
             // Implicit unsupported stages or weird multi-bit stage enum values
+            m_logger.log("Unknown Shader Stage %d",system::ILogger::ELL_ERROR,shaderStage);
             return nullptr;
             break;
     }
@@ -343,12 +356,18 @@ core::smart_refctd_ptr<IGPUShader> ILogicalDevice::createShader(const SShaderCre
             spirvShader = m_compilerSet->compileToSPIRV(creationParams.cpushader, commonCompileOptions);
 
         if (!spirvShader)
+        {
+            m_logger.log("SPIR-V Compilation from non SPIR-V shader %p failed.",system::ILogger::ELL_ERROR,creationParams.cpushader);
             return nullptr;
+        }
     }
 
     auto spirv = spirvShader->getContent();
     if (!spirv)
+    {
+        m_logger.log("SPIR-V Compilation from non SPIR-V shader %p failed.",system::ILogger::ELL_ERROR,creationParams.cpushader);
         return nullptr;
+    }
 
     // for debugging 
     if constexpr (true)