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,