Merge branch 'master' into ali_lib_shader2

Author: alichraghi

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

@@ -1380,8 +1380,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)
 		{
@@ -1479,6 +1488,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

@@ -338,14 +338,13 @@ typedef StyleClipper< nbl::hlsl::shapes::Line<float> > LineStyleClipper;
 // textureColor: color sampled from a texture
 // useStyleColor: instead of writing and reading from colorStorage, use main object Idx to find the style color for the object.
 template<bool FragmentShaderPixelInterlock>
-float32_t4 calculateFinalColor(const uint2 fragCoord, const float localAlpha, const uint32_t currentMainObjectIdx, float3 textureColor);
+float32_t4 calculateFinalColor(const uint2 fragCoord, const float localAlpha, const uint32_t currentMainObjectIdx, float3 textureColor, bool colorFromTexture);
 
 template<>
-float32_t4 calculateFinalColor<false>(const uint2 fragCoord, const float localAlpha, const uint32_t currentMainObjectIdx, float3 localTextureColor)
+float32_t4 calculateFinalColor<false>(const uint2 fragCoord, const float localAlpha, const uint32_t currentMainObjectIdx, float3 localTextureColor, bool colorFromTexture)
 {
     uint32_t styleIdx = mainObjects[currentMainObjectIdx].styleIdx;
-    const bool colorFromStyle = styleIdx != InvalidStyleIdx;
-    if (colorFromStyle)
+    if (!colorFromTexture)
     {
         float32_t4 col = lineStyles[styleIdx].color;
         col.w *= localAlpha;
@@ -355,10 +354,9 @@ float32_t4 calculateFinalColor<false>(const uint2 fragCoord, const float localAl
         return float4(localTextureColor, localAlpha);
 }
 template<>
-float32_t4 calculateFinalColor<true>(const uint2 fragCoord, const float localAlpha, const uint32_t currentMainObjectIdx, float3 localTextureColor)
+float32_t4 calculateFinalColor<true>(const uint2 fragCoord, const float localAlpha, const uint32_t currentMainObjectIdx, float3 localTextureColor, bool colorFromTexture)
 {
     float32_t4 color;
-    
     nbl::hlsl::spirv::beginInvocationInterlockEXT();
 
     const uint32_t packedData = pseudoStencil[fragCoord];
@@ -367,19 +365,26 @@ float32_t4 calculateFinalColor<true>(const uint2 fragCoord, const float localAlp
     const uint32_t storedQuantizedAlpha = nbl::hlsl::glsl::bitfieldExtract<uint32_t>(packedData,0,AlphaBits);
     const uint32_t storedMainObjectIdx = nbl::hlsl::glsl::bitfieldExtract<uint32_t>(packedData,AlphaBits,MainObjectIdxBits);
     // 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;
-    const bool resolveColorFromStyle = resolveStyleIdx != InvalidStyleIdx;
+    const bool differentMainObject = currentMainObjectIdx != storedMainObjectIdx; // meaning current pixel's main object is different than what is already stored
+    const bool resolve = differentMainObject && storedMainObjectIdx != InvalidMainObjectIdx;
+    uint32_t toResolveStyleIdx = InvalidStyleIdx;
 
     // load from colorStorage only if we want to resolve color from texture instead of style
     // sampling from colorStorage needs to happen in critical section because another fragment may also want to store into it at the same time + need to happen before store
-    if (resolve && !resolveColorFromStyle)
-        color = float32_t4(unpackR11G11B10_UNORM(colorStorage[fragCoord]), 1.0f);
-
-    if (resolve || localQuantizedAlpha > storedQuantizedAlpha)
+    if (resolve)
+    {
+        toResolveStyleIdx = mainObjects[storedMainObjectIdx].styleIdx;
+        if (toResolveStyleIdx == InvalidStyleIdx) // if style idx to resolve is invalid, then it means we should resolve from color
+            color = float32_t4(unpackR11G11B10_UNORM(colorStorage[fragCoord]), 1.0f);
+    }
+    
+    // If current localAlpha is higher than what is already stored in pseudoStencil we will update the value in pseudoStencil or the color in colorStorage, this is equivalent to programmable blending MAX operation.
+    // OR If previous pixel has a different ID than current's  (i.e. previous either empty/invalid or a differnet mainObject), we should update our alpha and color storages.
+    if (differentMainObject || localQuantizedAlpha > storedQuantizedAlpha)
     {
         pseudoStencil[fragCoord] = nbl::hlsl::glsl::bitfieldInsert<uint32_t>(localQuantizedAlpha,currentMainObjectIdx,AlphaBits,MainObjectIdxBits);
-        colorStorage[fragCoord] = packR11G11B10_UNORM(localTextureColor);
+        if (colorFromTexture) // writing color from texture
+            colorStorage[fragCoord] = packR11G11B10_UNORM(localTextureColor);
     }
 
     nbl::hlsl::spirv::endInvocationInterlockEXT();
@@ -389,8 +394,8 @@ float32_t4 calculateFinalColor<true>(const uint2 fragCoord, const float localAlp
 
     // draw with previous geometry's style's color or stored in texture buffer :kek:
     // we don't need to load the style's color in critical section because we've already retrieved the style index from the stored main obj
-    if (resolveColorFromStyle)
-        color = lineStyles[resolveStyleIdx].color;
+    if (toResolveStyleIdx != InvalidStyleIdx) // if toResolveStyleIdx is valid then that means our resolved color should come from line style
+        color = lineStyles[toResolveStyleIdx].color;
     color.a *= float(storedQuantizedAlpha) / 255.f;
 
     return color;
@@ -401,10 +406,12 @@ float32_t4 calculateFinalColor<true>(const uint2 fragCoord, const float localAlp
 float4 fragMain(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)
@@ -639,5 +646,10 @@ float4 fragMain(PSInput input) : SV_TARGET
     if (localAlpha <= 0)
         discard;
 
-    return calculateFinalColor<nbl::hlsl::jit::device_capabilities::fragmentShaderPixelInterlock>(fragCoord, localAlpha, currentMainObjectIdx, textureColor);
+    const bool colorFromTexture = objType == ObjectType::IMAGE;
+    
+    // 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, colorFromTexture);
 }

62_CAD/shaders/main_pipeline/resolve_alphas.hlsl

@@ -23,16 +23,29 @@ float32_t4 calculateFinalColor<true>(const uint2 fragCoord)
     const uint32_t storedQuantizedAlpha = nbl::hlsl::glsl::bitfieldExtract<uint32_t>(packedData,0,AlphaBits);
     const uint32_t storedMainObjectIdx = nbl::hlsl::glsl::bitfieldExtract<uint32_t>(packedData,AlphaBits,MainObjectIdxBits);
     pseudoStencil[fragCoord] = nbl::hlsl::glsl::bitfieldInsert<uint32_t>(0, InvalidMainObjectIdx, AlphaBits, MainObjectIdxBits);
+
+    // if geomID has changed, we resolve the SDF alpha (draw using blend), else accumulate
+    const bool resolve = storedMainObjectIdx != InvalidMainObjectIdx;
+    uint32_t toResolveStyleIdx = InvalidStyleIdx;
 
-    uint32_t resolveStyleIdx = mainObjects[storedMainObjectIdx].styleIdx;
-    const bool resolveColorFromStyle = resolveStyleIdx != InvalidStyleIdx;
-    if (!resolveColorFromStyle)
-        color = float32_t4(unpackR11G11B10_UNORM(colorStorage[fragCoord]), 1.0f);
+    // load from colorStorage only if we want to resolve color from texture instead of style
+    // sampling from colorStorage needs to happen in critical section because another fragment may also want to store into it at the same time + need to happen before store
+    if (resolve)
+    {
+        toResolveStyleIdx = mainObjects[storedMainObjectIdx].styleIdx;
+        if (toResolveStyleIdx == InvalidStyleIdx) // if style idx to resolve is invalid, then it means we should resolve from color
+            color = float32_t4(unpackR11G11B10_UNORM(colorStorage[fragCoord]), 1.0f);
+    }
 
     nbl::hlsl::spirv::endInvocationInterlockEXT();
 
-    if (resolveColorFromStyle)
-        color = lineStyles[resolveStyleIdx].color;
+    if (!resolve)
+        discard;
+
+    // draw with previous geometry's style's color or stored in texture buffer :kek:
+    // we don't need to load the style's color in critical section because we've already retrieved the style index from the stored main obj
+    if (toResolveStyleIdx != InvalidStyleIdx) // if toResolveStyleIdx is valid then that means our resolved color should come from line style
+        color = lineStyles[toResolveStyleIdx].color;
     color.a *= float(storedQuantizedAlpha) / 255.f;
 
     return color;

62_CAD/shaders/main_pipeline/vertex_shader.hlsl

@@ -87,6 +87,11 @@ 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.~~
+    // Ok, brainfart, a vertex can belong to multiple triangles, I was thinking of AA but triangles share vertices, nevermind my comment above.
+
     const uint vertexIdx = vertexID & 0x3u;
     const uint objectID = vertexID >> 2;
 

68_JpegLoading/CMakeLists.txt

@@ -0,0 +1,27 @@
+include(common RESULT_VARIABLE RES)
+if(NOT RES)
+	message(FATAL_ERROR "common.cmake not found. Should be in {repo_root}/cmake directory")
+endif()
+
+nbl_create_executable_project("" "" "" "" "${NBL_EXECUTABLE_PROJECT_CREATION_PCH_TARGET}")
+
+if(NBL_EMBED_BUILTIN_RESOURCES)
+	set(_BR_TARGET_ ${EXECUTABLE_NAME}_builtinResourceData)
+	set(RESOURCE_DIR "app_resources")
+
+	get_filename_component(_SEARCH_DIRECTORIES_ "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE)
+	get_filename_component(_OUTPUT_DIRECTORY_SOURCE_ "${CMAKE_CURRENT_BINARY_DIR}/src" ABSOLUTE)
+	get_filename_component(_OUTPUT_DIRECTORY_HEADER_ "${CMAKE_CURRENT_BINARY_DIR}/include" ABSOLUTE)
+
+    file(GLOB_RECURSE BUILTIN_RESOURCE_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/${RESOURCE_DIR}" CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${RESOURCE_DIR}/*")
+    foreach(RES_FILE ${BUILTIN_RESOURCE_FILES})
+      LIST_BUILTIN_RESOURCE(RESOURCES_TO_EMBED "${RES_FILE}")
+    endforeach()
+
+	ADD_CUSTOM_BUILTIN_RESOURCES(${_BR_TARGET_} RESOURCES_TO_EMBED "${_SEARCH_DIRECTORIES_}" "${RESOURCE_DIR}" "nbl::this_example::builtin" "${_OUTPUT_DIRECTORY_HEADER_}" "${_OUTPUT_DIRECTORY_SOURCE_}")
+
+	LINK_BUILTIN_RESOURCES_TO_TARGET(${EXECUTABLE_NAME} ${_BR_TARGET_})
+endif() 
+
+add_dependencies(${EXECUTABLE_NAME} argparse)
+target_include_directories(${EXECUTABLE_NAME} PUBLIC $<TARGET_PROPERTY:argparse,INTERFACE_INCLUDE_DIRECTORIES>)