DTM Task Comments

Author: Erfan-Ahmadi

62_CAD/DrawResourcesFiller.h

@@ -66,6 +66,11 @@ struct DrawResourcesFiller
 	void setGlyphMSDFTextureFunction(const GetGlyphMSDFTextureFunc& func);
 	void setHatchFillMSDFTextureFunction(const GetHatchFillPatternMSDFTextureFunc& func);
 
+	// TODO[Przemek]: try to draft up a `CTriangleMesh` Class in it's own header (like CPolyline), simplest form is basically two cpu buffers (1 array of uint index buffer, 1 array of float64_t3 vertexBuffer)
+	// TODO[Przemek]: Then have a `drawMesh` function here similar to drawXXX's below, this will fit both vertex and index buffer in the `geometryBuffer`.
+	// take a `SIntendedSubmitInfo` like others, but don't use it as I don't want you to handle anything regarding autoSubmit
+	// somehow retrieve or calculate the geometry buffer offsets of your vertex and index buffer to be used outside for binding purposes
+
 	//! 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 LineStyleInfo& lineStyleInfo, SIntendedSubmitInfo& intendedNextSubmit);
 
@@ -193,6 +198,10 @@ struct DrawResourcesFiller
 
 	uint32_t addLineStyle_SubmitIfNeeded(const LineStyleInfo& lineStyle, SIntendedSubmitInfo& intendedNextSubmit);
 
+	// TODO[Przemek]: Read after reading the fragment shader comments and having a basic understanding of the relationship between "mainObject" and our programmable blending resolve:
+	// Use `addMainObject_SubmitIfNeeded` to push your single mainObject you'll be using for the enitre triangle mesh (this will ensure overlaps between triangles of the same mesh is resolved correctly)
+	// Delete comment when you understand this
+
 	// [ADVANCED] Do not use this function unless you know what you're doing (It may cause auto submit)
 	// Never call this function multiple times in a row before indexing it in a drawable, because future auto-submits may invalidate mainObjects, so do them one by one, for example:
 	// Valid: addMainObject1 --> addXXX(mainObj1) ---> addMainObject2 ---> addXXX(mainObj2) ....

62_CAD/main.cpp

@@ -1378,8 +1378,17 @@ class ComputerAidedDesign final : public examples::SimpleWindowedApplication, pu
 		const uint32_t currentIndexCount = drawResourcesFiller.getDrawObjectCount() * 6u;
 		IGPUDescriptorSet* descriptorSets[] = { descriptorSet0.get(), descriptorSet1.get() };
 		cb->bindDescriptorSets(asset::EPBP_GRAPHICS, pipelineLayout.get(), 0u, 2u, descriptorSets);
+
+		// TODO[Przemek]: based on our call bind index buffer you uploaded to part of the `drawResourcesFiller.gpuDrawBuffers.geometryBuffer`
+		// Vertices will be pulled based on baseBDAPointer of where you uploaded the vertex + the VertexID in the vertex shader.
 		cb->bindIndexBuffer({ .offset = 0u, .buffer = drawResourcesFiller.gpuDrawBuffers.indexBuffer.get() }, asset::EIT_32BIT);
+
+		// TODO[Przemek]: binding the same pipelie, no need to change.
 		cb->bindGraphicsPipeline(graphicsPipeline.get());
+		
+		// TODO[Przemek]: contour settings, height shading settings, base bda pointers will need to be pushed via pushConstants before the draw currently as it's the easiest thing to do.
+
+		// TODO[Przemek]: draw parameters needs to reflect the mesh involved
 		cb->drawIndexed(currentIndexCount, 1u, 0u, 0u, 0u);
 		if (fragmentShaderInterlockEnabled)
 		{
@@ -1477,6 +1486,9 @@ class ComputerAidedDesign final : public examples::SimpleWindowedApplication, pu
 
 	void addObjects(SIntendedSubmitInfo& intendedNextSubmit)
 	{
+		
+		// TODO[Przemek]: add your own case, you won't call any other drawResourcesFiller function, only drawMesh with your custom made Mesh (for start it can be a single triangle)
+
 		// we record upload of our objects and if we failed to allocate we submit everything
 		if (!intendedNextSubmit.valid())
 		{

62_CAD/shaders/globals.hlsl

@@ -260,6 +260,10 @@ static_assert(sizeof(CurveBox) == 80u);
 NBL_CONSTEXPR uint32_t InvalidRigidSegmentIndex = 0xffffffff;
 NBL_CONSTEXPR float InvalidStyleStretchValue = nbl::hlsl::numeric_limits<float>::infinity;
 
+
+// TODO[Przemek]: we will need something similar to LineStyles but related to heigh shading settings which is user customizable (like LineStyle stipple patterns) and requires upper_bound to figure out the color based on height value.
+// We'll discuss that later or what it will be looking like and how it's gonna get passed to our shaders.
+
 // The color parameter is also used for styling non-curve objects such as text glyphs and hatches with solid color
 struct LineStyle
 {

62_CAD/shaders/main_pipeline/common.hlsl

@@ -62,6 +62,8 @@ struct PrecomputedRootFinder
     }
 };
 
+ // TODO[Przemek]: your triangle mesh passed parameters from vtx to fragment will need to be here (e.g. height).
+ //     As always try to reuse parameters and try not to introduce new ones
 struct PSInput
 {
     float4 position : SV_Position;

62_CAD/shaders/main_pipeline/fragment_shader.hlsl

@@ -372,6 +372,8 @@ float32_t4 calculateFinalColor<true>(const uint2 fragCoord, const float localAlp
     // if geomID has changed, we resolve the SDF alpha (draw using blend), else accumulate
     const bool resolve = currentMainObjectIdx != storedMainObjectIdx;
     uint32_t resolveStyleIdx = mainObjects[storedMainObjectIdx].styleIdx;
+    
+    // TODO[Przemek]: REMOVE when READ --> if linestyle value in mainObject is invalid then we're using localTextureColor instead of the linestyle color, this should be true for DTM meshes to resolve color with what's stored in colorStorage and not from the lineStyle color
     const bool resolveColorFromStyle = resolveStyleIdx != InvalidStyleIdx;
 
     // load from colorStorage only if we want to resolve color from texture instead of style
@@ -403,10 +405,13 @@ float32_t4 calculateFinalColor<true>(const uint2 fragCoord, const float localAlp
 float4 main(PSInput input) : SV_TARGET
 {
     float localAlpha = 0.0f;
+    float3 textureColor = float3(0, 0, 0); // color sampled from a texture
+
+
+    // TODO[Przemek]: Disable All the object rendering paths if you want.
     ObjectType objType = input.getObjType();
     const uint32_t currentMainObjectIdx = input.getMainObjectIdx();
     const MainObject mainObj = mainObjects[currentMainObjectIdx];
-    float3 textureColor = float3(0, 0, 0); // color sampled from a texture
 
     // figure out local alpha with sdf
     if (objType == ObjectType::LINE || objType == ObjectType::QUAD_BEZIER || objType == ObjectType::POLYLINE_CONNECTOR)
@@ -641,5 +646,9 @@ float4 main(PSInput input) : SV_TARGET
     if (localAlpha <= 0)
         discard;
 
+    
+    // TODO[Przemek]: But make sure you're still calling this, correctly calculating alpha and texture color.
+    // you can add 1 main object and push via DrawResourcesFiller like we already do for other objects (this go in the mainObjects StorageBuffer) and then set the currentMainObjectIdx to 0 here
+    // having 1 main object temporarily means that all triangle meshes will be treated as a unified object in blending operations. 
     return calculateFinalColor<nbl::hlsl::jit::device_capabilities::fragmentShaderPixelInterlock>(fragCoord, localAlpha, currentMainObjectIdx, textureColor);
 }

62_CAD/shaders/main_pipeline/vertex_shader.hlsl

@@ -87,6 +87,10 @@ void dilateHatch<false>(out float2 outOffsetVec, out float2 outUV, const float2
 
 PSInput main(uint vertexID : SV_VertexID)
 {
+    // TODO[Przemek]: Disable Everything here and do your own thing as we already discussed, but let's have the same PSInput data passed to fragment.
+    // your programmable pulling will use the baseVertexBufferAddress BDA address and `vertexID` to RawBufferLoad it's vertex. 
+    // Later, most likely We will require pulling all 3 vertices of the triangle, that's where you need to know which triangle you're currently on, and instead of objectID = vertexID/4 which we currently do, you will do vertexID/3 and pull all 3 of it's vertices.
+
     const uint vertexIdx = vertexID & 0x3u;
     const uint objectID = vertexID >> 2;