WIP: Transform feedback

Docs/Whats_New.md

@@ -730,6 +730,7 @@ Released 2020/12/09
 	- `VK_EXT_descriptor_indexing` (initial release limited to Metal Tier 1: 96/128 textures, 16 samplers)
 	- `VK_EXT_post_depth_coverage` (macOS)
 	- `VK_EXT_private_data`
+	- `VK_EXT_shader_demote_to_helper_invocation`
 	- `VK_EXT_subgroup_size_control`
 	- `VK_EXT_texture_compression_astc_hdr`
 	- `VK_AMD_shader_image_load_store` (macOS)

ExternalRevisions/SPIRV-Cross_repo_revision

@@ -1 +1 @@
-4818f7e7ef7b7078a3a7a5a52c4a338e0dda22f4
+15a8b709ffb9f941ed7fc48013bc7deda5659275

MoltenVK/MoltenVK/API/mvk_private_api.h

@@ -152,6 +152,7 @@ typedef struct {
 	VkBool32 needsSampleDrefLodArrayWorkaround;		/**< If true, sampling from arrayed depth images with explicit LoD is broken and needs a workaround. */
 	VkDeviceSize hostMemoryPageSize;				/**< The size of a page of host memory on this platform. */
 	VkBool32 dynamicVertexStride;					/**< If true, VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE is supported. */
+	uint32_t maxTransformFeedbackBuffers;           /**< The maximum transform feedback Buffers to support */
 } MVKPhysicalDeviceMetalFeatures;
 
 /**

MoltenVK/MoltenVK/Commands/MVKCmdDraw.h

@@ -191,3 +191,105 @@ class MVKCmdDrawIndexedIndirect : public MVKCommand {
 	uint32_t _drawCount;
 	uint32_t _directCmdFirstInstance;
 };
+
+
+#pragma mark -
+#pragma mark MVKCmdBeginTransformFeedback
+
+/*
+ * The active transform feedback buffers will capture primitives emitted from the corresponding XfbBuffer in the bound
+ * graphics pipeline. Any XfbBuffer emitted that does not output to an active transform feedback buffer will not be
+ * captured.
+ */
+
+template <size_t N>
+class MVKCmdBeginTransformFeedback : public MVKCommand {
+public:
+    VkResult setContent(MVKCommandBuffer* cmdBuffer,
+                        uint32_t firstCounterBuffer,
+                        uint32_t counterBufferCount,
+                        const VkBuffer* counterBuffers,
+                        const VkDeviceSize* counterBufferOffsets);
+    void encode(MVKCommandEncoder* cmdEncoder) override;
+
+protected:
+    MVKCommandTypePool<MVKCommand>* getTypePool(MVKCommandPool* cmdPool) override;
+
+    MVKSmallVector<MVKMTLBufferBinding, N> _counterBuffers;
+};
+
+// Concrete template class implementations.
+typedef MVKCmdBeginTransformFeedback<1> MVKCmdBeginTransformFeedback1;
+typedef MVKCmdBeginTransformFeedback<2> MVKCmdBeginTransformFeedback2;
+typedef MVKCmdBeginTransformFeedback<4> MVKCmdBeginTransformFeedbackMulti;
+
+#pragma mark -
+#pragma mark MVKCmdBindTransformFeedbackBuffers
+
+/*
+ * The values taken from elements i of pBuffers, pOffsets and pSizes replace the current state for the transform
+ * feedback binding firstBinding + i, for i in [0, bindingCount). The transform feedback binding is updated to start
+ * at the offset indicated by pOffsets[i] from the start of the buffer pBuffers[i].
+ */
+template <size_t N>
+class MVKCmdBindTransformFeedbackBuffers : public MVKCommand {
+public:
+    VkResult setContent(MVKCommandBuffer* cmdBuffer,
+                        uint32_t firstBinding,
+                        uint32_t bindingCount,
+                        const VkBuffer* pBuffers,
+                        const VkDeviceSize* pOffsets,
+                        const VkDeviceSize* pSizes);
+    void encode(MVKCommandEncoder* cmdEncoder) override;
+
+protected:
+    MVKCommandTypePool<MVKCommand>* getTypePool(MVKCommandPool* cmdPool) override;
+
+    MVKSmallVector<MVKMTLBufferBinding, N> _bindings;
+};
+
+// Concrete template class implementations.
+typedef MVKCmdBindTransformFeedbackBuffers<1> MVKCmdBindTransformFeedbackBuffers1;
+typedef MVKCmdBindTransformFeedbackBuffers<2> MVKCmdBindTransformFeedbackBuffers2;
+typedef MVKCmdBindTransformFeedbackBuffers<4> MVKCmdBindTransformFeedbackBuffersMulti;
+
+#pragma mark -
+#pragma mark MVKCmdDrawIndirectByteCount
+
+/*
+ * Draw primitives where the vertex count is derived from the counter byte value in the counter buffer
+ */
+
+class MVKCmdDrawIndirectByteCount : public MVKCommand {
+public:
+    MVKCmdDrawIndirectByteCount() :
+            instanceCount(0), firstInstance(0), counterBuffer(), deviceSize(), stride() {}
+    VkResult setContent(MVKCommandBuffer* cmdBuffer,
+                   uint32_t instanceCount,
+                   uint32_t firstInstance,
+                   VkBuffer counterBuffer,
+                   uint32_t deviceSize,
+                   uint32_t stride);
+    void encode(MVKCommandEncoder* cmdEncoder) override;
+
+protected:
+    MVKCommandTypePool<MVKCommand>* getTypePool(MVKCommandPool* cmdPool) override;
+
+    uint32_t instanceCount;
+    uint32_t firstInstance;
+    VkBuffer counterBuffer;
+    uint32_t deviceSize;
+    uint32_t stride;
+};
+
+#pragma mark -
+#pragma mark MVKCmdEndTransformFeedback
+
+class MVKCmdEndTransformFeedback : public MVKCommand {
+public:
+    VkResult setContent(MVKCommandBuffer* cmdBuffer);
+    void encode(MVKCommandEncoder* cmdEncoder) override;
+
+protected:
+    MVKCommandTypePool<MVKCommand>* getTypePool(MVKCommandPool* cmdPool) override;
+};

MoltenVK/MoltenVK/Commands/MVKCmdDraw.mm

@@ -19,10 +19,7 @@
 #include "MVKCmdDraw.h"
 #include "MVKCommandBuffer.h"
 #include "MVKCommandPool.h"
-#include "MVKBuffer.h"
 #include "MVKPipeline.h"
-#include "MVKFoundation.h"
-#include "mvk_datatypes.hpp"
 
 
 #pragma mark -
@@ -41,7 +38,7 @@
     _bindings.reserve(bindingCount);
     MVKMTLBufferBinding b;
     for (uint32_t bindIdx = 0; bindIdx < bindingCount; bindIdx++) {
-        MVKBuffer* mvkBuffer = (MVKBuffer*)pBuffers[bindIdx];
+        auto* mvkBuffer = (MVKBuffer*)pBuffers[bindIdx];
         b.index = mvkDvc->getMetalBufferIndexForVertexAttributeBinding(firstBinding + bindIdx);
         b.mtlBuffer = mvkBuffer->getMTLBuffer();
         b.offset = mvkBuffer->getMTLBufferOffset() + pOffsets[bindIdx];
@@ -66,11 +63,11 @@
 #pragma mark -
 #pragma mark MVKCmdBindIndexBuffer
 
-VkResult MVKCmdBindIndexBuffer::setContent(MVKCommandBuffer* cmdBuff,
+VkResult MVKCmdBindIndexBuffer::setContent(MVKCommandBuffer*,
 										   VkBuffer buffer,
 										   VkDeviceSize offset,
 										   VkIndexType indexType) {
-	MVKBuffer* mvkBuffer = (MVKBuffer*)buffer;
+	auto* mvkBuffer = (MVKBuffer*)buffer;
 	_binding.mtlBuffer = mvkBuffer->getMTLBuffer();
 	_binding.offset = mvkBuffer->getMTLBufferOffset() + offset;
 	_binding.mtlIndexType = mvkMTLIndexTypeFromVkIndexType(indexType);
@@ -188,6 +185,16 @@
                 mtlTessCtlEncoder = cmdEncoder->getMTLComputeEncoder(kMVKCommandUseTessellationVertexTessCtl);
                 if (pipeline->needsVertexOutputBuffer()) {
                     vtxOutBuff = cmdEncoder->getTempMTLBuffer(_vertexCount * _instanceCount * 4 * cmdEncoder->_pDeviceProperties->limits.maxVertexOutputComponents, true);
+                    if (cmdEncoder->getDevice()->_enabledTransformFeedbackFeatures.transformFeedback &&
+                        cmdEncoder->_transformFeedbackRunning) {
+                        for (auto& xfbBufferBinding : cmdEncoder->_graphicsResourcesState
+                                ._transformFeedbackBufferBindings)
+                        {
+                            [mtlTessCtlEncoder setBuffer:xfbBufferBinding.mtlBuffer
+                                                  offset:xfbBufferBinding.offset
+                                                 atIndex:xfbBufferBinding.index];
+                        }
+                    }
                     [mtlTessCtlEncoder setBuffer: vtxOutBuff->_mtlBuffer
                                           offset: vtxOutBuff->_offset
                                          atIndex: pipeline->getOutputBufferIndex().stages[kMVKShaderStageVertex]];
@@ -196,7 +203,7 @@
 				// If there are vertex bindings with a zero vertex divisor, I need to offset them by
 				// _firstInstance * stride, since that is the expected behaviour for a divisor of 0.
                 cmdEncoder->_graphicsResourcesState.offsetZeroDivisorVertexBuffers(stage, pipeline, _firstInstance);
-				id<MTLComputePipelineState> vtxState = pipeline->getTessVertexStageState();
+				id<MTLComputePipelineState> vtxState = pipeline->getVertexStageState();
 				if (cmdEncoder->getDevice()->_pMetalFeatures->nonUniformThreadgroups) {
 #if MVK_MACOS_OR_IOS
 					[mtlTessCtlEncoder dispatchThreads: MTLSizeMake(_vertexCount, _instanceCount, 1)
@@ -426,7 +433,7 @@
 				// If there are vertex bindings with a zero vertex divisor, I need to offset them by
 				// _firstInstance * stride, since that is the expected behaviour for a divisor of 0.
                 cmdEncoder->_graphicsResourcesState.offsetZeroDivisorVertexBuffers(stage, pipeline, _firstInstance);
-				id<MTLComputePipelineState> vtxState = ibb.mtlIndexType == MTLIndexTypeUInt16 ? pipeline->getTessVertexStageIndex16State() : pipeline->getTessVertexStageIndex32State();
+				id<MTLComputePipelineState> vtxState = ibb.mtlIndexType == MTLIndexTypeUInt16 ? pipeline->getVertexStageIndex16State() : pipeline->getVertexStageIndex32State();
 				if (cmdEncoder->getDevice()->_pMetalFeatures->nonUniformThreadgroups) {
 #if MVK_MACOS_OR_IOS
 					[mtlTessCtlEncoder dispatchThreads: MTLSizeMake(_indexCount, _instanceCount, 1)
@@ -568,7 +575,7 @@
 										VkDeviceSize offset,
 										uint32_t drawCount,
 										uint32_t stride) {
-	MVKBuffer* mvkBuffer = (MVKBuffer*)buffer;
+	auto* mvkBuffer = (MVKBuffer*)buffer;
 	_mtlIndirectBuffer = mvkBuffer->getMTLBuffer();
 	_mtlIndirectBufferOffset = mvkBuffer->getMTLBufferOffset() + offset;
 	_mtlIndirectBufferStride = stride;
@@ -694,7 +701,7 @@
         if (cmdEncoder->_pDeviceMetalFeatures->mslVersion >= 20100) {
             indirectSize += sizeof(MTLStageInRegionIndirectArguments) * _drawCount;
         }
-		paramsIncr = std::max((size_t)cmdEncoder->getDevice()->_pProperties->limits.minUniformBufferOffsetAlignment, sizeof(uint32_t) * 2);
+		paramsIncr = std::max<size_t>((size_t)cmdEncoder->getDevice()->_pProperties->limits.minUniformBufferOffsetAlignment, sizeof(uint32_t) * 2);
 		VkDeviceSize paramsSize = paramsIncr * _drawCount;
         tempIndirectBuff = cmdEncoder->getTempMTLBuffer(indirectSize, true);
         mtlIndBuff = tempIndirectBuff->_mtlBuffer;
@@ -712,7 +719,7 @@
         }
         tcLevelBuff = cmdEncoder->getTempMTLBuffer(patchCount * sizeof(MTLQuadTessellationFactorsHalf), true);
 
-        vtxThreadExecWidth = pipeline->getTessVertexStageState().threadExecutionWidth;
+        vtxThreadExecWidth = pipeline->getVertexStageState().threadExecutionWidth;
         NSUInteger sgSize = pipeline->getTessControlStageState().threadExecutionWidth;
         tcWorkgroupSize = mvkLeastCommonMultiple(outControlPointCount, sgSize);
         while (tcWorkgroupSize > cmdEncoder->getDevice()->_pProperties->limits.maxComputeWorkGroupSize[0]) {
@@ -836,6 +843,7 @@
 			if ( !pipeline->hasValidMTLPipelineStates() ) { return; }	// Abort if this pipeline stage could not be compiled.
 
             switch (stage) {
+                //look for tesselation stage
                 case kMVKGraphicsStageVertex:
                     mtlTessCtlEncoder = cmdEncoder->getMTLComputeEncoder(kMVKCommandUseTessellationVertexTessCtl);
                     if (pipeline->needsVertexOutputBuffer()) {
@@ -1043,7 +1051,7 @@
         if (cmdEncoder->_pDeviceMetalFeatures->mslVersion >= 20100) {
             indirectSize += sizeof(MTLStageInRegionIndirectArguments) * _drawCount;
         }
-		paramsIncr = std::max((size_t)cmdEncoder->getDevice()->_pProperties->limits.minUniformBufferOffsetAlignment, sizeof(uint32_t) * 2);
+		paramsIncr = std::max<size_t>((size_t)cmdEncoder->getDevice()->_pProperties->limits.minUniformBufferOffsetAlignment, sizeof(uint32_t) * 2);
 		VkDeviceSize paramsSize = paramsIncr * _drawCount;
         tempIndirectBuff = cmdEncoder->getTempMTLBuffer(indirectSize, true);
         mtlIndBuff = tempIndirectBuff->_mtlBuffer;
@@ -1063,7 +1071,7 @@
         vtxIndexBuff = cmdEncoder->getTempMTLBuffer(ibb.mtlBuffer.length, true);
 
         id<MTLComputePipelineState> vtxState;
-        vtxState = ibb.mtlIndexType == MTLIndexTypeUInt16 ? pipeline->getTessVertexStageIndex16State() : pipeline->getTessVertexStageIndex32State();
+        vtxState = ibb.mtlIndexType == MTLIndexTypeUInt16 ? pipeline->getVertexStageIndex16State() : pipeline->getVertexStageIndex32State();
         vtxThreadExecWidth = vtxState.threadExecutionWidth;
 
         NSUInteger sgSize = pipeline->getTessControlStageState().threadExecutionWidth;
@@ -1330,3 +1338,116 @@
     }
 }
 
+#pragma mark -
+#pragma mark MVKCmdBeginTransformFeedback
+
+template <size_t N>
+VkResult MVKCmdBeginTransformFeedback<N>::setContent(MVKCommandBuffer* cmdBuff,
+                                                     uint32_t firstCounterBuffer,
+                                                     uint32_t counterBufferCount,
+                                                     const VkBuffer* pCounterBuffers,
+                                                     const VkDeviceSize* pCounterBufferOffsets) {
+    MVKDevice* mvkDvc = cmdBuff->getDevice();
+    _counterBuffers.clear();    // Clear for reuse
+    _counterBuffers.reserve(counterBufferCount);
+    MVKMTLBufferBinding b;
+    for (uint32_t bindIdx = 0; bindIdx < counterBufferCount; bindIdx++) {
+        auto* mvkBuffer = (MVKBuffer*)pCounterBuffers[bindIdx];
+        b.index = mvkDvc->getMetalBufferIndexForTransformFeedbackCounterBinding(kMVKShaderStageVertex, firstCounterBuffer + bindIdx);
+        b.mtlBuffer = mvkBuffer->getMTLBuffer();
+        b.offset = mvkBuffer->getMTLBufferOffset() + pCounterBufferOffsets[bindIdx];
+        _counterBuffers.push_back(b);
+    }
+
+    return VK_SUCCESS;
+}
+
+template <size_t N>
+void MVKCmdBeginTransformFeedback<N>::encode(MVKCommandEncoder* cmdEncoder) {
+    if (cmdEncoder->_transformFeedbackRunning) {
+        return;
+    }
+
+    cmdEncoder->_graphicsResourcesState._transformFeedbackCounterBufferBinding = _counterBuffers[0];
+    cmdEncoder->_transformFeedbackRunning = true;
+}
+
+template class MVKCmdBeginTransformFeedback<1>;
+template class MVKCmdBeginTransformFeedback<2>;
+template class MVKCmdBeginTransformFeedback<4>;
+
+
+#pragma mark -
+#pragma mark MVKCmdBindTransformFeedbackBuffers
+
+template <size_t N>
+VkResult MVKCmdBindTransformFeedbackBuffers<N>::setContent(MVKCommandBuffer *cmdBuffer,
+                                                        uint32_t firstBinding, uint32_t bindingCount,
+                                                        const VkBuffer *pBuffers,
+                                                        const VkDeviceSize *pOffsets,
+                                                       const VkDeviceSize *pSizes) {
+    MVKDevice* mvkDvc = cmdBuffer->getDevice();
+    _bindings.clear();	// Clear for reuse
+    _bindings.reserve(bindingCount);
+    MVKMTLBufferBinding b;
+    for (uint32_t bindIdx = 0; bindIdx < bindingCount; bindIdx++) {
+        auto* mvkBuffer = (MVKBuffer*)pBuffers[bindIdx];
+        b.index = mvkDvc->getMetalBufferIndexForTransformFeedbackBinding(kMVKShaderStageVertex, firstBinding + bindIdx);
+        b.mtlBuffer = mvkBuffer->getMTLBuffer();
+        b.offset = mvkBuffer->getMTLBufferOffset() + pOffsets[bindIdx];
+        if (pSizes != nullptr) {
+            if (pSizes[bindIdx] == VK_WHOLE_SIZE) {
+                b.size = b.mtlBuffer.allocatedSize - b.offset;
+            } else {
+                b.size = pSizes[bindIdx];
+            }
+        } else {
+            b.size = b.mtlBuffer.allocatedSize - b.offset;
+        }
+        _bindings.push_back(b);
+    }
+
+    return VK_SUCCESS;
+}
+
+template <size_t N>
+void MVKCmdBindTransformFeedbackBuffers<N>::encode(MVKCommandEncoder *cmdEncoder) {
+    cmdEncoder->_graphicsResourcesState._transformFeedbackBufferBindings.clear();
+    for (auto& b : _bindings) { cmdEncoder->_graphicsResourcesState._transformFeedbackBufferBindings.push_back(b); }
+}
+
+template class MVKCmdBindTransformFeedbackBuffers<1>;
+template class MVKCmdBindTransformFeedbackBuffers<2>;
+template class MVKCmdBindTransformFeedbackBuffers<4>;
+
+
+#pragma mark -
+#pragma mark MVKCmdDrawIndirectByteCount
+
+VkResult MVKCmdDrawIndirectByteCount::setContent(MVKCommandBuffer *cmdBuffer,
+                                              uint32_t _instanceCount, uint32_t _firstInstance,
+                                              VkBuffer _counterBuffer, uint32_t _deviceSize, uint32_t _stride) {
+    /// @TODO SW: this extension allows drawing from the transform feedback buffers
+    instanceCount = _instanceCount;
+    firstInstance = _firstInstance;
+    counterBuffer = _counterBuffer;
+    deviceSize = _deviceSize;
+    stride = _stride;
+    return cmdBuffer->reportError(VK_ERROR_FEATURE_NOT_PRESENT,  "DrawIndirectByteCount is not yet implemented");
+}
+
+void MVKCmdDrawIndirectByteCount::encode(MVKCommandEncoder *cmdEncoder) {
+    /// @TODO SW: this extension allows drawing from the transform feedback buffers
+    (void) cmdEncoder;
+}
+
+#pragma mark -
+#pragma mark MVKCmdEndTransformFeedback
+
+VkResult MVKCmdEndTransformFeedback::setContent(MVKCommandBuffer *) {
+    return VK_SUCCESS;
+}
+
+void MVKCmdEndTransformFeedback::encode(MVKCommandEncoder *cmdEncoder) {
+    cmdEncoder->_transformFeedbackRunning = false;
+}

MoltenVK/MoltenVK/Commands/MVKCommandBuffer.h

@@ -466,6 +466,10 @@ class MVKCommandEncoder : public MVKBaseDeviceObject {
 	/** Indicates whether the current draw is an indexed draw. */
 	bool _isIndexedDraw;
 
+    /** If true, transform feedback is currently running. */
+    VkBool32 _transformFeedbackRunning;
+
+
 #pragma mark Construction
 
 	MVKCommandEncoder(MVKCommandBuffer* cmdBuffer,

MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.h

@@ -507,6 +507,8 @@ class MVKGraphicsResourcesCommandEncoderState : public MVKResourcesCommandEncode
 
     /** The type of index that will be used to render primitives. Exposed directly. */
     MVKIndexMTLBufferBinding _mtlIndexBufferBinding;
+    MVKMTLBufferBinding _transformFeedbackCounterBufferBinding;
+    MVKSmallVector<MVKMTLBufferBinding, 4> _transformFeedbackBufferBindings;
 
     /** Binds the specified index buffer. */
     void bindIndexBuffer(const MVKIndexMTLBufferBinding& binding) {
@@ -539,6 +541,8 @@ class MVKGraphicsResourcesCommandEncoderState : public MVKResourcesCommandEncode
                              bool needVertexViewBuffer,
                              bool needFragmentViewBuffer);
 
+    void bindTransformFeedbackBuffer(MVKMTLBufferBinding binding);
+
     void encodeBindings(MVKShaderStage stage,
                         const char* pStageName,
                         bool fullImageViewSwizzle,