[62.CAD][UNTESTED] clipProjectionData in geometry buffer, cleanups and overflow fixes, renamed CPULineStyle to LineStyleInfo

Author: Erfan-Ahmadi

62_CAD/DrawBuffers.cpp

@@ -7,6 +7,12 @@ using namespace nbl::video;
 using namespace nbl::core;
 using namespace nbl::asset;
 
+static_assert(sizeof(DrawObject) == 16u);
+static_assert(sizeof(MainObject) == 16u);
+static_assert(sizeof(Globals) == 128u);
+static_assert(sizeof(LineStyle) == 96u);
+static_assert(sizeof(ClipProjectionData) == 88u);
+
 template <typename BufferType>
 struct DrawBuffers
 {
@@ -15,7 +21,6 @@ struct DrawBuffers
 	smart_refctd_ptr<BufferType> drawObjectsBuffer;
 	smart_refctd_ptr<BufferType> geometryBuffer;
 	smart_refctd_ptr<BufferType> lineStylesBuffer;
-	smart_refctd_ptr<BufferType> customClipProjectionBuffer;
 };
 
 // ! this is just a buffers filler with autosubmission features used for convenience to how you feed our CAD renderer
@@ -42,34 +47,34 @@ struct DrawBuffersFiller
 
 	void allocateGeometryBuffer(ILogicalDevice* logicalDevice, size_t size);
 
-	void allocateStylesBuffer(ILogicalDevice* logicalDevice, uint32_t stylesCount);
+	void allocateStylesBuffer(ILogicalDevice* logicalDevice, uint32_t lineStylesCount);
 
 	void allocateCustomClipProjectionBuffer(ILogicalDevice* logicalDevice, uint32_t ClipProjectionDataCount);
 
 	//! this function fills buffers required for drawing a polyline and submits a draw through provided callback when there is not enough memory.
-	void drawPolyline(
-		const CPolylineBase& polyline,
-		const CPULineStyle& cpuLineStyle,
-		const uint32_t clipProjectionIdx,
-		SIntendedSubmitInfo& intendedNextSubmit);
+	void drawPolyline(const CPolylineBase& polyline, const LineStyleInfo& lineStyleInfo, SIntendedSubmitInfo& intendedNextSubmit);
 
-	void drawPolyline(
-		const CPolylineBase& polyline,
-		const uint32_t polylineMainObjIdx,
+	void drawPolyline(const CPolylineBase& polyline, uint32_t polylineMainObjIdx, SIntendedSubmitInfo& intendedNextSubmit);
+	
+	// !drawSolid
+	void drawHatch(
+		const Hatch& hatch,
+		const float32_t4& foregroundColor, 
+		const float32_t4& backgroundColor,
+		/* something that gets you the texture id */
 		SIntendedSubmitInfo& intendedNextSubmit);
 
 	void drawHatch(
 		const Hatch& hatch,
-		// If more parameters from cpu line style are used here later, make a new HatchStyle & use that
-		const float32_t4 color,
-		const uint32_t clipProjectionIdx,
+		const float32_t4& color,
+		/* something that gets you the texture id */
 		SIntendedSubmitInfo& intendedNextSubmit);
 
 	void finalizeAllCopiesToGPU(SIntendedSubmitInfo& intendedNextSubmit);
 
 	inline uint32_t getLineStyleCount() const { return currentLineStylesCount; }
 
-	inline uint32_t getDrawObjectCount() const { return currentDrawObjectCount; }
+	inline uint32_t getDrawObjectCount() const { return currentDrawObjectCount; } 
 
 	inline uint32_t getMainObjectCount() const { return currentMainObjectCount; }
 
@@ -93,52 +98,52 @@ struct DrawBuffersFiller
 		return sizeof(LineStyle) * currentLineStylesCount;
 	}
 
-	inline size_t getCurrentCustomClipProjectionBufferSize() const
-	{
-		return sizeof(ClipProjectionData) * currentClipProjectionDataCount;
-	}
-
 	void reset()
 	{
-		resetAllCounters();
+		resetGeometryCounters();
+		resetMainObjectCounters();
+		resetLineStyleCounters();
 	}
 
 	DrawBuffers<ICPUBuffer> cpuDrawBuffers;
 	DrawBuffers<IGPUBuffer> gpuDrawBuffers;
 
-	void addLineStyle_SubmitIfNeeded(
-		const CPULineStyle& lineStyle,
-		uint32_t& outLineStyleIdx,
-		SIntendedSubmitInfo& intendedNextSubmit);
+	uint32_t addLineStyle_SubmitIfNeeded(const LineStyleInfo& lineStyle, SIntendedSubmitInfo& intendedNextSubmit);
+	
+	uint32_t addMainObject_SubmitIfNeeded(uint32_t styleIdx, SIntendedSubmitInfo& intendedNextSubmit);
 
-	void addMainObject_SubmitIfNeeded(
-		const MainObject& mainObject,
-		uint32_t& outMainObjectIdx,
-		SIntendedSubmitInfo& intendedNextSubmit);
-
-	void addClipProjectionData_SubmitIfNeeded(
-		const ClipProjectionData& clipProjectionData,
-		uint32_t& outClipProjectionIdx,
-		SIntendedSubmitInfo& intendedNextSubmit);
+	// we need to store the clip projection stack to make sure the front is always available in memory
+	void pushClipProjectionData(const ClipProjectionData& clipProjectionData);
+	void popClipProjectionData();
 
 protected:
 
 	SubmitFunc submitDraws;
-	static constexpr uint32_t InvalidLineStyleIdx = ~0u;
+	static constexpr uint32_t InvalidStyleIdx = ~0u;
 
 	void finalizeMainObjectCopiesToGPU(SIntendedSubmitInfo& intendedNextSubmit);
 
 	void finalizeGeometryCopiesToGPU(SIntendedSubmitInfo& intendedNextSubmit);
 
 	void finalizeLineStyleCopiesToGPU(SIntendedSubmitInfo& intendedNextSubmit);
-
+	
 	void finalizeCustomClipProjectionCopiesToGPU(SIntendedSubmitInfo& intendedNextSubmit);
+	
+	// A hatch and a polyline are considered a "Main Object" which consists of smaller geometries such as beziers, lines, connectors, hatchBoxes
+	// If the whole polyline can't fit into memory for draw, then we submit the render of smaller geometries midway and continue
+	void submitCurrentObjectsAndReset(SIntendedSubmitInfo& intendedNextSubmit, uint32_t mainObjectIndex);
 
 	uint32_t addMainObject_Internal(const MainObject& mainObject);
 
-	uint32_t addLineStyle_Internal(const CPULineStyle& cpuLineStyle);
+	uint32_t addLineStyle_Internal(const LineStyleInfo& lineStyleInfo);
+
+	// Gets the current clip projection data (the top of stack) gpu addreess inside the geometryBuffer
+	// If it's been invalidated then it will request to upload again with a possible auto-submit on low geometry buffer memory.
+	uint64_t getCurrentClipProjectionAddress(SIntendedSubmitInfo& intendedNextSubmit);
+	
+	uint64_t addClipProjectionData_SubmitIfNeeded(const ClipProjectionData& clipProjectionData, SIntendedSubmitInfo& intendedNextSubmit);
 
-	uint32_t addClipProjectionData_Internal(const ClipProjectionData& clipProjectionData);
+	uint64_t addClipProjectionData_Internal(const ClipProjectionData& clipProjectionData);
 
 	static constexpr uint32_t getCageCountPerPolylineObject(ObjectType type)
 	{
@@ -151,26 +156,14 @@ struct DrawBuffersFiller
 
 	void addPolylineObjects_Internal(const CPolylineBase& polyline, const CPolylineBase::SectionInfo& section, uint32_t& currentObjectInSection, uint32_t mainObjIdx);
 
-	// TODO[Prezmek]: another function named addPolylineConnectors_Internal and you pass a Range<PolylineConnectorInfo>, uint32_t currentPolylineConnectorObj, uint32_t mainObjIdx
-	// And implement it similar to addLines/QuadBeziers_Internal which is check how much memory is left and how many PolylineConnectors you can fit into the current geometry and drawobj memory left and return to the drawPolylinefunction
 	void addPolylineConnectors_Internal(const CPolylineBase& polyline, uint32_t& currentPolylineConnectorObj, uint32_t mainObjIdx);
 
-	// TODO[Przemek]: this function will change a little as you'll be copying LinePointInfos instead of double2's
-	// Make sure to test with small memory to trigger submitInBetween function when you run out of memory to see if your changes here didn't mess things up, ask Lucas for help if you're not sure on how to do this
 	void addLines_Internal(const CPolylineBase& polyline, const CPolylineBase::SectionInfo& section, uint32_t& currentObjectInSection, uint32_t mainObjIdx);
 
 	void addQuadBeziers_Internal(const CPolylineBase& polyline, const CPolylineBase::SectionInfo& section, uint32_t& currentObjectInSection, uint32_t mainObjIdx);
 
 	void addHatch_Internal(const Hatch& hatch, uint32_t& currentObjectInSection, uint32_t mainObjIndex);
 
-	void resetAllCounters()
-	{
-		resetMainObjectCounters();
-		resetGeometryCounters();
-		resetStyleCounters();
-		resetCustomClipProjectionCounters();
-	}
-
 	void resetMainObjectCounters()
 	{
 		inMemMainObjectCount = 0u;
@@ -184,18 +177,20 @@ struct DrawBuffersFiller
 
 		inMemGeometryBufferSize = 0u;
 		currentGeometryBufferSize = 0u;
+
+		clipProjectionStackTopAddressInGPU = InvalidClipProjectionAddress;
 	}
 
-	void resetStyleCounters()
+	void resetLineStyleCounters()
 	{
 		currentLineStylesCount = 0u;
 		inMemLineStylesCount = 0u;
 	}
 
-	void resetCustomClipProjectionCounters()
+	MainObject* getMainObject(uint32_t idx)
 	{
-		currentClipProjectionDataCount = 0u;
-		inMemClipProjectionDataCount = 0u;
+		MainObject* mainObjsArray = reinterpret_cast<MainObject*>(cpuDrawBuffers.mainObjectsBuffer->getPointer());
+		return &mainObjsArray[idx];
 	}
 
 	smart_refctd_ptr<IUtilities> m_utilities;
@@ -219,9 +214,8 @@ struct DrawBuffersFiller
 	uint32_t currentLineStylesCount = 0u;
 	uint32_t maxLineStyles = 0u;
 
-	uint32_t inMemClipProjectionDataCount = 0u;
-	uint32_t currentClipProjectionDataCount = 0u;
-	uint32_t maxClipProjectionData = 0u;
-
 	uint64_t geometryBufferAddress = 0u; // Actual BDA offset 0 of the gpu buffer
+
+	std::stack<ClipProjectionData> clipProjectionStack;
+	uint64_t clipProjectionStackTopAddressInGPU = InvalidClipProjectionAddress;
 };

62_CAD/DrawBuffers.h

@@ -320,7 +320,7 @@ std::array<double, 2> Hatch::Segment::intersect(const Segment& other) const
 	return result;
 }
 
-Hatch::Hatch(std::span<CPolyline> lines, const MajorAxis majorAxis, int32_t& debugStep, std::function<void(CPolyline, CPULineStyle)> debugOutput /* tmp */)
+Hatch::Hatch(std::span<CPolyline> lines, const MajorAxis majorAxis, int32_t& debugStep, std::function<void(CPolyline, LineStyleInfo)> debugOutput /* tmp */)
 {
 	intersectionAmounts = std::vector<uint32_t>();
 	// this threshsold is used to decide when to consider minor position to be 
@@ -350,12 +350,12 @@ Hatch::Hatch(std::span<CPolyline> lines, const MajorAxis majorAxis, int32_t& deb
 		beziers.push_back(tmpBezier);
 		outputPolyline.addQuadBeziers(beziers);
 
-		CPULineStyle cpuLineStyle;
-		cpuLineStyle.screenSpaceLineWidth = 4.0f;
-		cpuLineStyle.worldSpaceLineWidth = 0.0f;
-		cpuLineStyle.color = color;
+		LineStyleInfo lineStyleInfo;
+		lineStyleInfo.screenSpaceLineWidth = 4.0f;
+		lineStyleInfo.worldSpaceLineWidth = 0.0f;
+		lineStyleInfo.color = color;
 
-		debugOutput(outputPolyline, cpuLineStyle);
+		debugOutput(outputPolyline, lineStyleInfo);
 	};
 
 	auto drawDebugLine = [&](float64_t2 start, float64_t2 end, float32_t4 color)
@@ -366,12 +366,12 @@ Hatch::Hatch(std::span<CPolyline> lines, const MajorAxis majorAxis, int32_t& deb
 		points.push_back(end);
 		outputPolyline.addLinePoints(points);
 
-		CPULineStyle cpuLineStyle;
-		cpuLineStyle.screenSpaceLineWidth = 2.0f;
-		cpuLineStyle.worldSpaceLineWidth = 0.0f;
-		cpuLineStyle.color = color;
+		LineStyleInfo lineStyleInfo;
+		lineStyleInfo.screenSpaceLineWidth = 2.0f;
+		lineStyleInfo.worldSpaceLineWidth = 0.0f;
+		lineStyleInfo.color = color;
 
-		debugOutput(outputPolyline, cpuLineStyle);
+		debugOutput(outputPolyline, lineStyleInfo);
 	};
 #endif
 

62_CAD/Hatch.cpp

@@ -54,7 +54,7 @@ class Hatch
 		// checks if it's a straight line e.g. if you're sweeping along y axis the it's a line parallel to x
 		bool isStraightLineConstantMajor() const;
 	};
-	Hatch(std::span<CPolyline> lines, const MajorAxis majorAxis, int32_t& debugStep, std::function<void(CPolyline, CPULineStyle)> debugOutput /* tmp */);
+	Hatch(std::span<CPolyline> lines, const MajorAxis majorAxis, int32_t& debugStep, std::function<void(CPolyline, LineStyleInfo)> debugOutput /* tmp */);
 	// (temporary)
 	Hatch(std::vector<CurveHatchBox>&& in_hatchBoxes) :
 		hatchBoxes(std::move(in_hatchBoxes))

62_CAD/Hatch.h

@@ -8,7 +8,7 @@
 #include "curves.h"
 
 // holds values for `LineStyle` struct and caculates stipple pattern re values, cant think of better name
-struct CPULineStyle
+struct LineStyleInfo
 {
 	static constexpr int32_t InvalidStipplePatternSize = -1;
 	static constexpr double InvalidShapeOffset = nbl::hlsl::numeric_limits<double>::infinity;
@@ -208,7 +208,7 @@ struct CPULineStyle
 
 	float calculateStretchValue(float64_t arcLen) const
 	{
-		float ret = 1.0f + CPULineStyle::PatternEpsilon; // we stretch a little but more, this is to avoid clipped sdf numerical precision errors at the end of the line when we need it to be consistent (last pixels in a line or curve need to be in draw section or gap if end of pattern is in draw section or gap respectively)
+		float ret = 1.0f + LineStyleInfo::PatternEpsilon; // we stretch a little but more, this is to avoid clipped sdf numerical precision errors at the end of the line when we need it to be consistent (last pixels in a line or curve need to be in draw section or gap if end of pattern is in draw section or gap respectively)
 		if (stretchToFit)
 		{
 			const bool singleRigidSegment = rigidShapeSegment() && isSingleSegment(); // we shouldn't apply any stretching if we only have one rigid stipple segment(either all draw or all gap(invisible)
@@ -238,12 +238,12 @@ struct CPULineStyle
 				else
 				{
 					// here we calculate the stretch value so that the pattern ends when the line/curve ends.
-					// below `+ CPULineStyle::PhaseShiftEpsilon`, stretches the value a little more  behaves as if arcLen is += epsilon * patternLen.
+					// below `+ LineStyleInfo::PhaseShiftEpsilon`, stretches the value a little more  behaves as if arcLen is += epsilon * patternLen.
 					// because we need it to be consistent (last pixels in a line or curve need to be in draw section or gap if end of pattern is in draw section or gap respectively)
 					// example: when we need to fit a pattern onto a curve, and the pattern ends at a non-draw section
 					//		the erros in the computations using phaseShift and stretch could incorrectly flag the last pixels of the curve to be in the pattern's next draw section but we needed it to end on a non draw section
 					//		when stretching a little more it will ensure the clipping does it's job so that we don't get dots at the end of the line.
-					ret = static_cast<float>((arcLen * reciprocalStipplePatternLen + CPULineStyle::PatternEpsilon) / nSegments);
+					ret = static_cast<float>((arcLen * reciprocalStipplePatternLen + LineStyleInfo::PatternEpsilon) / nSegments);
 				}
 			}
 		}
@@ -327,12 +327,6 @@ struct CPULineStyle
 	inline bool isVisible() const { return stipplePatternSize != InvalidStipplePatternSize; }
 };
 
-static_assert(sizeof(DrawObject) == 16u);
-static_assert(sizeof(MainObject) == 8u);
-static_assert(sizeof(Globals) == 128u);
-static_assert(sizeof(LineStyle) == 96u);
-static_assert(sizeof(ClipProjectionData) == 88u);
-
 class CPolylineBase
 {
 public:
@@ -495,7 +489,7 @@ class CPolyline : public CPolylineBase
 
 	typedef std::function<void(const float64_t2& /*position*/, const float64_t2& /*direction*/, float32_t /*stretch*/)> AddShapeFunc;
 
-	void preprocessPolylineWithStyle(const CPULineStyle& lineStyle, const AddShapeFunc& addShape = {})
+	void preprocessPolylineWithStyle(const LineStyleInfo& lineStyle, const AddShapeFunc& addShape = {})
 	{
 		//if (!lineStyle.isVisible())
 		//	return;
@@ -981,7 +975,7 @@ class CPolyline : public CPolylineBase
 	// Manual CPU Styling: breaks the current polyline into more polylines based the stipple pattern
 	// we could output a list/vector of polylines instead of using lambda but most of the time we need to work with the output and throw it away immediately.
 	typedef std::function<void(const CPolyline& /*current stipple*/)> OutputPolylineFunc; 
-	void stippleBreakDown(const CPULineStyle& lineStyle, const OutputPolylineFunc& addPolyline) const
+	void stippleBreakDown(const LineStyleInfo& lineStyle, const OutputPolylineFunc& addPolyline) const
 	{
 		if (!lineStyle.isVisible())
 			return;
@@ -1640,7 +1634,7 @@ class CPolyline : public CPolylineBase
 			connectorNormalInfos.push_back(connectorNormalInfoAtP2);
 		}
 
-		std::vector<PolylineConnector> buildConnectors(const CPULineStyle& lineStyle, bool isClosedPolygon)
+		std::vector<PolylineConnector> buildConnectors(const LineStyleInfo& lineStyle, bool isClosedPolygon)
 		{
 			std::vector<PolylineConnector> connectors;
 
@@ -1701,15 +1695,15 @@ class CPolyline : public CPolylineBase
 			}
 		}
 
-		bool checkIfInDrawSection(const CPULineStyle& lineStyle, float normalizedPlaceInPattern)
+		bool checkIfInDrawSection(const LineStyleInfo& lineStyle, float normalizedPlaceInPattern)
 		{
 			const uint32_t patternIdx = lineStyle.getPatternIdxFromNormalizedPosition(normalizedPlaceInPattern);
 			// odd patternIdx means a "no draw section" and current candidate should split into two nearest draw sections
 			return !(patternIdx & 0x1);
 		}
 
 		void constructMiterIfVisible(
-			const CPULineStyle& lineStyle,
+			const LineStyleInfo& lineStyle,
 			const PolylineConnectorNormalHelperInfo& prevLine,
 			const PolylineConnectorNormalHelperInfo& nextLine,
 			bool isMiterClosingPolyline,

62_CAD/Polyline.h

@@ -24,15 +24,14 @@ enum class MajorAxis : uint32_t
 // Consists of multiple DrawObjects
 struct MainObject
 {
-    // TODO[Erfan]: probably have objectType here as well?
     uint32_t styleIdx;
-    uint32_t clipProjectionIdx;
+    uint32_t pad; // do I even need this?
+    uint64_t clipProjectionAddress;
 };
 
 struct DrawObject
 {
-    // TODO: use struct bitfields in after DXC update and see if the invalid spirv bug still exists
-    uint32_t type_subsectionIdx; // packed to uint16 into uint32
+    uint32_t type_subsectionIdx; // packed two uint16 into uint32
     uint32_t mainObjIndex;
     uint64_t geometryAddress;
 };
@@ -193,8 +192,8 @@ NBL_CONSTEXPR uint32_t MainObjectIdxBits = 24u; // It will be packed next to alp
 NBL_CONSTEXPR uint32_t AlphaBits = 32u - MainObjectIdxBits;
 NBL_CONSTEXPR uint32_t MaxIndexableMainObjects = (1u << MainObjectIdxBits) - 1u;
 NBL_CONSTEXPR uint32_t InvalidMainObjectIdx = MaxIndexableMainObjects;
-NBL_CONSTEXPR uint32_t InvalidClipProjectionIdx = 0xffffffff;
-NBL_CONSTEXPR uint32_t UseDefaultClipProjectionIdx = InvalidClipProjectionIdx;
+NBL_CONSTEXPR uint64_t InvalidClipProjectionAddress = nbl::hlsl::numeric_limits<uint64_t>::max;
+NBL_CONSTEXPR uint32_t InvalidTextureIdx = nbl::hlsl::numeric_limits<uint32_t>::max;
 NBL_CONSTEXPR MajorAxis SelectedMajorAxis = MajorAxis::MAJOR_Y;
 // TODO: get automatic version working on HLSL
 NBL_CONSTEXPR MajorAxis SelectedMinorAxis = MajorAxis::MAJOR_X; //(MajorAxis) (1 - (uint32_t) SelectedMajorAxis);
@@ -435,9 +434,8 @@ struct PSInput
 // Set 0 - Scene Data and Globals, buffer bindings don't change the buffers only get updated
 [[vk::binding(0, 0)]] ConstantBuffer<Globals> globals : register(b0);
 [[vk::binding(1, 0)]] StructuredBuffer<DrawObject> drawObjects : register(t0);
-[[vk::binding(2, 0)]] StructuredBuffer<LineStyle> lineStyles : register(t1);
-[[vk::binding(3, 0)]] StructuredBuffer<MainObject> mainObjects : register(t2);
-[[vk::binding(4, 0)]] StructuredBuffer<ClipProjectionData> customClipProjections : register(t3);
+[[vk::binding(2, 0)]] StructuredBuffer<MainObject> mainObjects : register(t1);
+[[vk::binding(3, 0)]] StructuredBuffer<LineStyle> lineStyles : register(t2);
 
 // Set 1 - Window dependant data which has higher update frequency due to multiple windows and resize need image recreation and descriptor writes
 [[vk::binding(0, 1)]] globallycoherent RWTexture2D<uint> pseudoStencil : register(u0);