Merge branch 'asset-conversion-v3' into intended_submit_info_changes

# Conflicts:
#	include/nbl/video/utilities/SIntendedSubmitInfo.h

Author: Erfan-Ahmadi

examples_tests

@@ -17,6 +17,63 @@ namespace nbl::video
 //!     The "current recording commandBuffer" is returned by `getCurrentRecordingCommandBufferInfo` or updated via the pointer ref in beginNextCommandBuffer or overflowSubmit)
 struct SIntendedSubmitInfo final : core::Uncopyable
 {
+        // All commandbuffers must be compatible with the queue we're about to submit to
+        bool cmdbufNotSubmittableToQueue(const IGPUCommandBuffer* cmdbuf) const
+        {
+            return !cmdbuf || cmdbuf->getPool()->getQueueFamilyIndex()!=queue->getFamilyIndex();
+        }
+
+        // Returns the scratch to use if valid, nullptr otherwise
+        template<bool AllChecks>
+        inline const IQueue::SSubmitInfo::SCommandBufferInfo* valid_impl() const
+        {
+            if (!queue || scratchCommandBuffers.empty() || !scratchSemaphore.semaphore)
+                return nullptr;
+            // the found scratch
+            const IQueue::SSubmitInfo::SCommandBufferInfo* scratch = nullptr;
+            // skip expensive stuff
+            std::conditional_t<AllChecks,core::unordered_set<const IGPUCommandBuffer*>,const void*> uniqueCmdBufs;
+            if constexpr (AllChecks)
+            {
+                // All commandbuffers before the scratch must be executable (ready to be submitted)
+                for (const auto& info : prevCommandBuffers)
+                if (cmdbufNotSubmittableToQueue(info.cmdbuf) || info.cmdbuf->getState()!=IGPUCommandBuffer::STATE::EXECUTABLE)
+                    return nullptr;
+                //
+                uniqueCmdBufs.reserve(scratchCommandBuffers.size());
+            }
+            for (auto& info : scratchCommandBuffers)
+            {
+                if constexpr (AllChecks)
+                {
+                    // Must be resettable so we can end, submit, wait, reset and continue recording commands into it as-if nothing happened
+                    if (cmdbufNotSubmittableToQueue(info.cmdbuf) || !info.cmdbuf->isResettable())
+                        return nullptr;
+                    uniqueCmdBufs.insert(info.cmdbuf);
+                }
+                // not our scratch
+                if (info.cmdbuf->getState()!=IGPUCommandBuffer::STATE::RECORDING)
+                    continue;
+                // there can only be one scratch!
+                if (scratch)
+                    return nullptr;
+                scratch = &info;
+            }
+            // a commandbuffer repeats itself
+            if constexpr (AllChecks)
+            if (uniqueCmdBufs.size()!=scratchCommandBuffers.size())
+                return nullptr;
+            // there is no scratch cmdbuf at all!
+            if (!scratch)
+                return nullptr;
+            // It makes no sense to reuse the same commands for a second submission.
+            // Moreover its dangerous because the utilities record their own internal commands which might use subresources for which
+            // frees have already been latched on the scratch semaphore you must signal anyway.
+            if (!scratch->cmdbuf->getRecordingFlags().hasFlags(IGPUCommandBuffer::USAGE::ONE_TIME_SUBMIT_BIT))
+                return nullptr;
+            return scratch;
+        }
+
     public:
         // This parameter is required but may be unused if there is no need (no overflow) to do submit
         IQueue* queue = nullptr;
@@ -49,69 +106,11 @@ struct SIntendedSubmitInfo final : core::Uncopyable
         //
         inline ISemaphore::SWaitInfo getFutureScratchSemaphore() const {return {scratchSemaphore.semaphore,scratchSemaphore.value+1};}
 
-        // Returns the command buffer to use for recording if valid, nullptr otherwise
-        inline const IQueue::SSubmitInfo::SCommandBufferInfo* getCurrentRecordingCommandBufferInfo() const
-        {
-            if (scratchCommandBuffers.empty())
-                return nullptr;
-
-            // All commandbuffers must be compatible with the queue we're about to submit to
-            auto cmdbufNotSubmittableToQueue = [this](const IGPUCommandBuffer* cmdbuf)->bool
-            {
-                return !cmdbuf || cmdbuf->getPool()->getQueueFamilyIndex()!=queue->getFamilyIndex();
-            };
-
-            // finding command buffer toRecord
-            const IQueue::SSubmitInfo::SCommandBufferInfo* toRecord = nullptr;
-            core::unordered_set<const IGPUCommandBuffer*> uniqueCmdBufs;
-            uniqueCmdBufs.reserve(scratchCommandBuffers.size());
-            for (auto& info : scratchCommandBuffers)
-            {
-                // Must be resettable so we can end, submit, wait, reset and continue recording commands into it as-if nothing happened
-                if (cmdbufNotSubmittableToQueue(info.cmdbuf) || !info.cmdbuf->isResettable())
-                    return nullptr;
-                uniqueCmdBufs.insert(info.cmdbuf);
-                // not our toRecord
-                if (info.cmdbuf->getState()!=IGPUCommandBuffer::STATE::RECORDING)
-                    continue;
-                // there can only be one toRecord!
-                if (toRecord)
-                    return nullptr;
-                toRecord = &info;
-            }
-            // a commandbuffer repeats itself
-            if (uniqueCmdBufs.size()!=scratchCommandBuffers.size())
-                return nullptr;
-            // there is no toRecord cmdbuf at all!
-            if (!toRecord)
-                return nullptr;
-            // It makes no sense to reuse the same commands for a second submission.
-            // Moreover its dangerous because the utilities record their own internal commands which might use subresources for which
-            // frees have already been latched on the scratch semaphore you must signal anyway.
-            if (!toRecord->cmdbuf->getRecordingFlags().hasFlags(IGPUCommandBuffer::USAGE::ONE_TIME_SUBMIT_BIT))
-                return nullptr;
-            return toRecord;
-        }
-        
-        // Returns the command buffer to use for recording if valid, nullptr otherwise
-        inline const IQueue::SSubmitInfo::SCommandBufferInfo* valid() const
-        {
-            if (!queue || !scratchSemaphore.semaphore)
-                return nullptr;
-
-            // All commandbuffers must be compatible with the queue we're about to submit to
-            auto cmdbufNotSubmittableToQueue = [this](const IGPUCommandBuffer* cmdbuf)->bool
-            {
-                return !cmdbuf || cmdbuf->getPool()->getQueueFamilyIndex()!=queue->getFamilyIndex();
-            };
-
-            // All prevCommandBuffers must be executable (ready to be submitted)
-            for (const auto& info : prevCommandBuffers)
-            if (cmdbufNotSubmittableToQueue(info.cmdbuf) || info.cmdbuf->getState()!=IGPUCommandBuffer::STATE::EXECUTABLE)
-                return nullptr;
+        //
+        inline const auto* getCommandBufferForRecording() const {return valid_impl<false>();}
 
-            return getCurrentRecordingCommandBufferInfo();
-        }
+        //
+        inline const auto* valid() const {return valid_impl<true>();}
 
         //! xxxx
         class CSubmitStorage final : core::Uncopyable
@@ -164,7 +163,7 @@ struct SIntendedSubmitInfo final : core::Uncopyable
         // - clear the `waitSemaphores` which we'll use in the future because they will already be awaited on this `queue`
         inline CSubmitStorage popSubmit(IGPUCommandBuffer* recordingCmdBuf, const std::span<const IQueue::SSubmitInfo::SSemaphoreInfo> signalSemaphores)
         {
-            assert(scratch);
+            assert(recordingCmdBuf);
             CSubmitStorage retval(*this,recordingCmdBuf,signalSemaphores);
 
             // If you want to wait for the result of this popped submit, you need to wait for this new value