1474 lines
73 KiB
C++
1474 lines
73 KiB
C++
#include <VulkanPP/CommandBuffer.hpp>
|
|
#include <VulkanPP/AccelerationStructureKHR.hpp>
|
|
#include <VulkanPP/AccelerationStructureNV.hpp>
|
|
#include <VulkanPP/Buffer.hpp>
|
|
#include <VulkanPP/CommandPool.hpp>
|
|
#include <VulkanPP/DescriptorSet.hpp>
|
|
#include <VulkanPP/DescriptorUpdateTemplate.hpp>
|
|
#include <VulkanPP/Device.hpp>
|
|
#include <VulkanPP/Event.hpp>
|
|
#include <VulkanPP/Image.hpp>
|
|
#include <VulkanPP/ImageView.hpp>
|
|
#include <VulkanPP/MicromapEXT.hpp>
|
|
#include <VulkanPP/OpticalFlowSessionNV.hpp>
|
|
#include <VulkanPP/Pipeline.hpp>
|
|
#include <VulkanPP/PipelineLayout.hpp>
|
|
#include <VulkanPP/QueryPool.hpp>
|
|
#include <VulkanPP/ShaderEXT.hpp>
|
|
|
|
|
|
namespace VulkanPP {
|
|
|
|
CommandBuffer::CommandBuffer(IntrusivePtr<Device> owner0, IntrusivePtr<CommandPool> owner1, VkCommandBuffer handle, bool owned)
|
|
: _handle(handle), _owned(owned)
|
|
, _owner0(std::move(owner0))
|
|
, _owner1(std::move(owner1))
|
|
{ }
|
|
|
|
CommandBuffer::~CommandBuffer() {
|
|
if (_handle && _owned) {
|
|
(void)vk.vkFreeCommandBuffers(_owner0 ? _owner0->getHandle() : (VkDevice)VK_NULL_HANDLE, _owner1 ? _owner1->getHandle() : (VkCommandPool)VK_NULL_HANDLE, 0, 1, &_handle);
|
|
_handle = VK_NULL_HANDLE;
|
|
}
|
|
}
|
|
|
|
// Original: vkAllocateCommandBuffers
|
|
std::vector<IntrusivePtr<CommandBuffer>> CommandBuffer::createMany(IntrusivePtr<Device> parent, const VkCommandBufferAllocateInfo* pAllocateInfo) {
|
|
std::vector<VkCommandBuffer> _out;
|
|
_out.resize(pAllocateInfo->commandBufferCount);
|
|
auto _res = vk.vkAllocateCommandBuffers(parent->getHandle(), pAllocateInfo, _out.data());
|
|
if (_res != VK_SUCCESS) throw std::runtime_error("vkAllocateCommandBuffers failed");
|
|
std::vector<IntrusivePtr<CommandBuffer>> _ret; _ret.reserve(_out.size());
|
|
for (auto h : _out) {
|
|
_ret.emplace_back(new CommandBuffer(parent, parent, h, true));
|
|
}
|
|
return _ret;
|
|
}
|
|
|
|
// Original: vkBeginCommandBuffer
|
|
VkResult CommandBuffer::begin(const VkCommandBufferBeginInfo* pBeginInfo) {
|
|
return vk.vkBeginCommandBuffer(_handle, pBeginInfo);
|
|
}
|
|
|
|
// Original: vkEndCommandBuffer
|
|
VkResult CommandBuffer::end() {
|
|
return vk.vkEndCommandBuffer(_handle);
|
|
}
|
|
|
|
// Original: vkResetCommandBuffer
|
|
VkResult CommandBuffer::reset(VkCommandBufferResetFlags flags) {
|
|
return vk.vkResetCommandBuffer(_handle, flags);
|
|
}
|
|
|
|
// Original: vkCmdBindPipeline
|
|
void CommandBuffer::bindPipeline(VkPipelineBindPoint pipelineBindPoint, IntrusivePtr<Pipeline> pipeline) {
|
|
vk.vkCmdBindPipeline(_handle, pipelineBindPoint, pipeline->getHandle());
|
|
}
|
|
|
|
// Original: vkCmdSetAttachmentFeedbackLoopEnableEXT
|
|
void CommandBuffer::setAttachmentFeedbackLoopEnableEXT(VkImageAspectFlags aspectMask) {
|
|
vk.vkCmdSetAttachmentFeedbackLoopEnableEXT(_handle, aspectMask);
|
|
}
|
|
|
|
// Original: vkCmdSetViewport
|
|
void CommandBuffer::setViewport(uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
|
|
vk.vkCmdSetViewport(_handle, firstViewport, viewportCount, pViewports);
|
|
}
|
|
|
|
// Original: vkCmdSetScissor
|
|
void CommandBuffer::setScissor(uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
|
|
vk.vkCmdSetScissor(_handle, firstScissor, scissorCount, pScissors);
|
|
}
|
|
|
|
// Original: vkCmdSetLineWidth
|
|
void CommandBuffer::setLineWidth(float lineWidth) {
|
|
vk.vkCmdSetLineWidth(_handle, lineWidth);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthBias
|
|
void CommandBuffer::setDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
|
|
vk.vkCmdSetDepthBias(_handle, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
|
|
}
|
|
|
|
// Original: vkCmdSetBlendConstants
|
|
void CommandBuffer::setBlendConstants(const float blendConstants) {
|
|
vk.vkCmdSetBlendConstants(_handle, blendConstants);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthBounds
|
|
void CommandBuffer::setDepthBounds(float minDepthBounds, float maxDepthBounds) {
|
|
vk.vkCmdSetDepthBounds(_handle, minDepthBounds, maxDepthBounds);
|
|
}
|
|
|
|
// Original: vkCmdSetStencilCompareMask
|
|
void CommandBuffer::setStencilCompareMask(VkStencilFaceFlags faceMask, uint32_t compareMask) {
|
|
vk.vkCmdSetStencilCompareMask(_handle, faceMask, compareMask);
|
|
}
|
|
|
|
// Original: vkCmdSetStencilWriteMask
|
|
void CommandBuffer::setStencilWriteMask(VkStencilFaceFlags faceMask, uint32_t writeMask) {
|
|
vk.vkCmdSetStencilWriteMask(_handle, faceMask, writeMask);
|
|
}
|
|
|
|
// Original: vkCmdSetStencilReference
|
|
void CommandBuffer::setStencilReference(VkStencilFaceFlags faceMask, uint32_t reference) {
|
|
vk.vkCmdSetStencilReference(_handle, faceMask, reference);
|
|
}
|
|
|
|
// Original: vkCmdBindDescriptorSets
|
|
void CommandBuffer::bindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, IntrusivePtr<PipelineLayout> layout, uint32_t firstSet, uint32_t descriptorSetCount, const std::vector<IntrusivePtr<DescriptorSet>>& pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
|
|
std::vector<VkDescriptorSet> _raw_pDescriptorSets; _raw_pDescriptorSets.reserve(pDescriptorSets.size());
|
|
for (auto const& it : pDescriptorSets) _raw_pDescriptorSets.push_back(it->getHandle());
|
|
vk.vkCmdBindDescriptorSets(_handle, pipelineBindPoint, layout->getHandle(), firstSet, descriptorSetCount, pDescriptorSets.size(), _raw_pDescriptorSets.data(), dynamicOffsetCount, pDynamicOffsets);
|
|
}
|
|
|
|
// Original: vkCmdBindIndexBuffer
|
|
void CommandBuffer::bindIndexBuffer(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, VkIndexType indexType) {
|
|
vk.vkCmdBindIndexBuffer(_handle, buffer->getHandle(), offset, indexType);
|
|
}
|
|
|
|
// Original: vkCmdBindVertexBuffers
|
|
void CommandBuffer::bindVertexBuffers(uint32_t firstBinding, uint32_t bindingCount, const std::vector<IntrusivePtr<Buffer>>& pBuffers, const VkDeviceSize* pOffsets) {
|
|
std::vector<VkBuffer> _raw_pBuffers; _raw_pBuffers.reserve(pBuffers.size());
|
|
for (auto const& it : pBuffers) _raw_pBuffers.push_back(it->getHandle());
|
|
vk.vkCmdBindVertexBuffers(_handle, firstBinding, bindingCount, pBuffers.size(), _raw_pBuffers.data(), pOffsets);
|
|
}
|
|
|
|
// Original: vkCmdDraw
|
|
void CommandBuffer::draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
|
|
vk.vkCmdDraw(_handle, vertexCount, instanceCount, firstVertex, firstInstance);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndexed
|
|
void CommandBuffer::drawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
|
|
vk.vkCmdDrawIndexed(_handle, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
|
|
}
|
|
|
|
// Original: vkCmdDrawMultiEXT
|
|
void CommandBuffer::drawMultiEXT(uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) {
|
|
vk.vkCmdDrawMultiEXT(_handle, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawMultiIndexedEXT
|
|
void CommandBuffer::drawMultiIndexedEXT(uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) {
|
|
vk.vkCmdDrawMultiIndexedEXT(_handle, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndirect
|
|
void CommandBuffer::drawIndirect(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
|
|
vk.vkCmdDrawIndirect(_handle, buffer->getHandle(), offset, drawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndexedIndirect
|
|
void CommandBuffer::drawIndexedIndirect(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
|
|
vk.vkCmdDrawIndexedIndirect(_handle, buffer->getHandle(), offset, drawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDispatch
|
|
void CommandBuffer::dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
|
|
vk.vkCmdDispatch(_handle, groupCountX, groupCountY, groupCountZ);
|
|
}
|
|
|
|
// Original: vkCmdDispatchIndirect
|
|
void CommandBuffer::dispatchIndirect(IntrusivePtr<Buffer> buffer, VkDeviceSize offset) {
|
|
vk.vkCmdDispatchIndirect(_handle, buffer->getHandle(), offset);
|
|
}
|
|
|
|
// Original: vkCmdSubpassShadingHUAWEI
|
|
void CommandBuffer::subpassShadingHUAWEI() {
|
|
vk.vkCmdSubpassShadingHUAWEI(_handle);
|
|
}
|
|
|
|
// Original: vkCmdDrawClusterHUAWEI
|
|
void CommandBuffer::drawClusterHUAWEI(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
|
|
vk.vkCmdDrawClusterHUAWEI(_handle, groupCountX, groupCountY, groupCountZ);
|
|
}
|
|
|
|
// Original: vkCmdDrawClusterIndirectHUAWEI
|
|
void CommandBuffer::drawClusterIndirectHUAWEI(IntrusivePtr<Buffer> buffer, VkDeviceSize offset) {
|
|
vk.vkCmdDrawClusterIndirectHUAWEI(_handle, buffer->getHandle(), offset);
|
|
}
|
|
|
|
// Original: vkCmdUpdatePipelineIndirectBufferNV
|
|
void CommandBuffer::updatePipelineIndirectBufferNV(VkPipelineBindPoint pipelineBindPoint, IntrusivePtr<Pipeline> pipeline) {
|
|
vk.vkCmdUpdatePipelineIndirectBufferNV(_handle, pipelineBindPoint, pipeline->getHandle());
|
|
}
|
|
|
|
// Original: vkCmdCopyBuffer
|
|
void CommandBuffer::copyBuffer(IntrusivePtr<Buffer> srcBuffer, IntrusivePtr<Buffer> dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
|
|
vk.vkCmdCopyBuffer(_handle, srcBuffer->getHandle(), dstBuffer->getHandle(), regionCount, pRegions);
|
|
}
|
|
|
|
// Original: vkCmdCopyImage
|
|
void CommandBuffer::copyImage(IntrusivePtr<Image> srcImage, VkImageLayout srcImageLayout, IntrusivePtr<Image> dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
|
|
vk.vkCmdCopyImage(_handle, srcImage->getHandle(), srcImageLayout, dstImage->getHandle(), dstImageLayout, regionCount, pRegions);
|
|
}
|
|
|
|
// Original: vkCmdBlitImage
|
|
void CommandBuffer::blitImage(IntrusivePtr<Image> srcImage, VkImageLayout srcImageLayout, IntrusivePtr<Image> dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
|
|
vk.vkCmdBlitImage(_handle, srcImage->getHandle(), srcImageLayout, dstImage->getHandle(), dstImageLayout, regionCount, pRegions, filter);
|
|
}
|
|
|
|
// Original: vkCmdCopyBufferToImage
|
|
void CommandBuffer::copyBufferToImage(IntrusivePtr<Buffer> srcBuffer, IntrusivePtr<Image> dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
|
|
vk.vkCmdCopyBufferToImage(_handle, srcBuffer->getHandle(), dstImage->getHandle(), dstImageLayout, regionCount, pRegions);
|
|
}
|
|
|
|
// Original: vkCmdCopyImageToBuffer
|
|
void CommandBuffer::copyImageToBuffer(IntrusivePtr<Image> srcImage, VkImageLayout srcImageLayout, IntrusivePtr<Buffer> dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
|
|
vk.vkCmdCopyImageToBuffer(_handle, srcImage->getHandle(), srcImageLayout, dstBuffer->getHandle(), regionCount, pRegions);
|
|
}
|
|
|
|
// Original: vkCmdCopyMemoryIndirectNV
|
|
void CommandBuffer::copyMemoryIndirectNV(VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) {
|
|
vk.vkCmdCopyMemoryIndirectNV(_handle, copyBufferAddress, copyCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdCopyMemoryToImageIndirectNV
|
|
void CommandBuffer::copyMemoryToImageIndirectNV(VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, IntrusivePtr<Image> dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) {
|
|
vk.vkCmdCopyMemoryToImageIndirectNV(_handle, copyBufferAddress, copyCount, stride, dstImage->getHandle(), dstImageLayout, pImageSubresources);
|
|
}
|
|
|
|
// Original: vkCmdUpdateBuffer
|
|
void CommandBuffer::updateBuffer(IntrusivePtr<Buffer> dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {
|
|
vk.vkCmdUpdateBuffer(_handle, dstBuffer->getHandle(), dstOffset, dataSize, pData);
|
|
}
|
|
|
|
// Original: vkCmdFillBuffer
|
|
void CommandBuffer::fillBuffer(IntrusivePtr<Buffer> dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
|
|
vk.vkCmdFillBuffer(_handle, dstBuffer->getHandle(), dstOffset, size, data);
|
|
}
|
|
|
|
// Original: vkCmdClearColorImage
|
|
void CommandBuffer::clearColorImage(IntrusivePtr<Image> image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
|
|
vk.vkCmdClearColorImage(_handle, image->getHandle(), imageLayout, pColor, rangeCount, pRanges);
|
|
}
|
|
|
|
// Original: vkCmdClearDepthStencilImage
|
|
void CommandBuffer::clearDepthStencilImage(IntrusivePtr<Image> image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
|
|
vk.vkCmdClearDepthStencilImage(_handle, image->getHandle(), imageLayout, pDepthStencil, rangeCount, pRanges);
|
|
}
|
|
|
|
// Original: vkCmdClearAttachments
|
|
void CommandBuffer::clearAttachments(uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
|
|
vk.vkCmdClearAttachments(_handle, attachmentCount, pAttachments, rectCount, pRects);
|
|
}
|
|
|
|
// Original: vkCmdResolveImage
|
|
void CommandBuffer::resolveImage(IntrusivePtr<Image> srcImage, VkImageLayout srcImageLayout, IntrusivePtr<Image> dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
|
|
vk.vkCmdResolveImage(_handle, srcImage->getHandle(), srcImageLayout, dstImage->getHandle(), dstImageLayout, regionCount, pRegions);
|
|
}
|
|
|
|
// Original: vkCmdSetEvent
|
|
void CommandBuffer::setEvent(IntrusivePtr<Event> event, VkPipelineStageFlags stageMask) {
|
|
vk.vkCmdSetEvent(_handle, event->getHandle(), stageMask);
|
|
}
|
|
|
|
// Original: vkCmdResetEvent
|
|
void CommandBuffer::resetEvent(IntrusivePtr<Event> event, VkPipelineStageFlags stageMask) {
|
|
vk.vkCmdResetEvent(_handle, event->getHandle(), stageMask);
|
|
}
|
|
|
|
// Original: vkCmdWaitEvents
|
|
void CommandBuffer::waitEvents(uint32_t eventCount, const std::vector<IntrusivePtr<Event>>& pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
|
|
std::vector<VkEvent> _raw_pEvents; _raw_pEvents.reserve(pEvents.size());
|
|
for (auto const& it : pEvents) _raw_pEvents.push_back(it->getHandle());
|
|
vk.vkCmdWaitEvents(_handle, eventCount, pEvents.size(), _raw_pEvents.data(), srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
|
|
}
|
|
|
|
// Original: vkCmdPipelineBarrier
|
|
void CommandBuffer::pipelineBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
|
|
vk.vkCmdPipelineBarrier(_handle, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
|
|
}
|
|
|
|
// Original: vkCmdBeginQuery
|
|
void CommandBuffer::beginQuery(IntrusivePtr<QueryPool> queryPool, uint32_t query, VkQueryControlFlags flags) {
|
|
vk.vkCmdBeginQuery(_handle, queryPool->getHandle(), query, flags);
|
|
}
|
|
|
|
// Original: vkCmdEndQuery
|
|
void CommandBuffer::endQuery(IntrusivePtr<QueryPool> queryPool, uint32_t query) {
|
|
vk.vkCmdEndQuery(_handle, queryPool->getHandle(), query);
|
|
}
|
|
|
|
// Original: vkCmdBeginConditionalRenderingEXT
|
|
void CommandBuffer::beginConditionalRenderingEXT(const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
|
|
vk.vkCmdBeginConditionalRenderingEXT(_handle, pConditionalRenderingBegin);
|
|
}
|
|
|
|
// Original: vkCmdEndConditionalRenderingEXT
|
|
void CommandBuffer::endConditionalRenderingEXT() {
|
|
vk.vkCmdEndConditionalRenderingEXT(_handle);
|
|
}
|
|
|
|
// Original: vkCmdResetQueryPool
|
|
void CommandBuffer::resetQueryPool(IntrusivePtr<QueryPool> queryPool, uint32_t firstQuery, uint32_t queryCount) {
|
|
vk.vkCmdResetQueryPool(_handle, queryPool->getHandle(), firstQuery, queryCount);
|
|
}
|
|
|
|
// Original: vkCmdWriteTimestamp
|
|
void CommandBuffer::writeTimestamp(VkPipelineStageFlagBits pipelineStage, IntrusivePtr<QueryPool> queryPool, uint32_t query) {
|
|
vk.vkCmdWriteTimestamp(_handle, pipelineStage, queryPool->getHandle(), query);
|
|
}
|
|
|
|
// Original: vkCmdCopyQueryPoolResults
|
|
void CommandBuffer::copyQueryPoolResults(IntrusivePtr<QueryPool> queryPool, uint32_t firstQuery, uint32_t queryCount, IntrusivePtr<Buffer> dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
|
|
vk.vkCmdCopyQueryPoolResults(_handle, queryPool->getHandle(), firstQuery, queryCount, dstBuffer->getHandle(), dstOffset, stride, flags);
|
|
}
|
|
|
|
// Original: vkCmdPushConstants
|
|
void CommandBuffer::pushConstants(IntrusivePtr<PipelineLayout> layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
|
|
vk.vkCmdPushConstants(_handle, layout->getHandle(), stageFlags, offset, size, pValues);
|
|
}
|
|
|
|
// Original: vkCmdBeginRenderPass
|
|
void CommandBuffer::beginRenderPass(const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
|
|
vk.vkCmdBeginRenderPass(_handle, pRenderPassBegin, contents);
|
|
}
|
|
|
|
// Original: vkCmdNextSubpass
|
|
void CommandBuffer::nextSubpass(VkSubpassContents contents) {
|
|
vk.vkCmdNextSubpass(_handle, contents);
|
|
}
|
|
|
|
// Original: vkCmdEndRenderPass
|
|
void CommandBuffer::endRenderPass() {
|
|
vk.vkCmdEndRenderPass(_handle);
|
|
}
|
|
|
|
// Original: vkCmdExecuteCommands
|
|
void CommandBuffer::executeCommands(uint32_t commandBufferCount, const std::vector<IntrusivePtr<CommandBuffer>>& pCommandBuffers) {
|
|
std::vector<VkCommandBuffer> _raw_pCommandBuffers; _raw_pCommandBuffers.reserve(pCommandBuffers.size());
|
|
for (auto const& it : pCommandBuffers) _raw_pCommandBuffers.push_back(it->getHandle());
|
|
vk.vkCmdExecuteCommands(_handle, commandBufferCount, pCommandBuffers.size(), _raw_pCommandBuffers.data());
|
|
}
|
|
|
|
// Original: vkCmdDebugMarkerBeginEXT
|
|
void CommandBuffer::debugMarkerBeginEXT(const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
|
|
vk.vkCmdDebugMarkerBeginEXT(_handle, pMarkerInfo);
|
|
}
|
|
|
|
// Original: vkCmdDebugMarkerEndEXT
|
|
void CommandBuffer::debugMarkerEndEXT() {
|
|
vk.vkCmdDebugMarkerEndEXT(_handle);
|
|
}
|
|
|
|
// Original: vkCmdDebugMarkerInsertEXT
|
|
void CommandBuffer::debugMarkerInsertEXT(const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
|
|
vk.vkCmdDebugMarkerInsertEXT(_handle, pMarkerInfo);
|
|
}
|
|
|
|
// Original: vkCmdExecuteGeneratedCommandsNV
|
|
void CommandBuffer::executeGeneratedCommandsNV(VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
|
|
vk.vkCmdExecuteGeneratedCommandsNV(_handle, isPreprocessed, pGeneratedCommandsInfo);
|
|
}
|
|
|
|
// Original: vkCmdPreprocessGeneratedCommandsNV
|
|
void CommandBuffer::preprocessGeneratedCommandsNV(const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
|
|
vk.vkCmdPreprocessGeneratedCommandsNV(_handle, pGeneratedCommandsInfo);
|
|
}
|
|
|
|
// Original: vkCmdBindPipelineShaderGroupNV
|
|
void CommandBuffer::bindPipelineShaderGroupNV(VkPipelineBindPoint pipelineBindPoint, IntrusivePtr<Pipeline> pipeline, uint32_t groupIndex) {
|
|
vk.vkCmdBindPipelineShaderGroupNV(_handle, pipelineBindPoint, pipeline->getHandle(), groupIndex);
|
|
}
|
|
|
|
// Original: vkCmdExecuteGeneratedCommandsEXT
|
|
void CommandBuffer::executeGeneratedCommandsEXT(VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) {
|
|
vk.vkCmdExecuteGeneratedCommandsEXT(_handle, isPreprocessed, pGeneratedCommandsInfo);
|
|
}
|
|
|
|
// Original: vkCmdPreprocessGeneratedCommandsEXT
|
|
void CommandBuffer::preprocessGeneratedCommandsEXT(const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, IntrusivePtr<CommandBuffer> stateCommandBuffer) {
|
|
vk.vkCmdPreprocessGeneratedCommandsEXT(_handle, pGeneratedCommandsInfo, stateCommandBuffer->getHandle());
|
|
}
|
|
|
|
// Original: vkCmdPushDescriptorSet
|
|
void CommandBuffer::pushDescriptorSet(VkPipelineBindPoint pipelineBindPoint, IntrusivePtr<PipelineLayout> layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
|
|
vk.vkCmdPushDescriptorSet(_handle, pipelineBindPoint, layout->getHandle(), set, descriptorWriteCount, pDescriptorWrites);
|
|
}
|
|
|
|
// Original: vkCmdPushDescriptorSetKHR
|
|
void CommandBuffer::pushDescriptorSetKHR(VkPipelineBindPoint pipelineBindPoint, IntrusivePtr<PipelineLayout> layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
|
|
vk.vkCmdPushDescriptorSetKHR(_handle, pipelineBindPoint, layout->getHandle(), set, descriptorWriteCount, pDescriptorWrites);
|
|
}
|
|
|
|
// Original: vkCmdSetDeviceMask
|
|
void CommandBuffer::setDeviceMask(uint32_t deviceMask) {
|
|
vk.vkCmdSetDeviceMask(_handle, deviceMask);
|
|
}
|
|
|
|
// Original: vkCmdSetDeviceMaskKHR
|
|
void CommandBuffer::setDeviceMaskKHR(uint32_t deviceMask) {
|
|
vk.vkCmdSetDeviceMaskKHR(_handle, deviceMask);
|
|
}
|
|
|
|
// Original: vkCmdDispatchBase
|
|
void CommandBuffer::dispatchBase(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
|
|
vk.vkCmdDispatchBase(_handle, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
|
|
}
|
|
|
|
// Original: vkCmdDispatchBaseKHR
|
|
void CommandBuffer::dispatchBaseKHR(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
|
|
vk.vkCmdDispatchBaseKHR(_handle, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
|
|
}
|
|
|
|
// Original: vkCmdPushDescriptorSetWithTemplate
|
|
void CommandBuffer::pushDescriptorSetWithTemplate(IntrusivePtr<DescriptorUpdateTemplate> descriptorUpdateTemplate, IntrusivePtr<PipelineLayout> layout, uint32_t set, const void* pData) {
|
|
vk.vkCmdPushDescriptorSetWithTemplate(_handle, descriptorUpdateTemplate->getHandle(), layout->getHandle(), set, pData);
|
|
}
|
|
|
|
// Original: vkCmdPushDescriptorSetWithTemplateKHR
|
|
void CommandBuffer::pushDescriptorSetWithTemplateKHR(IntrusivePtr<DescriptorUpdateTemplate> descriptorUpdateTemplate, IntrusivePtr<PipelineLayout> layout, uint32_t set, const void* pData) {
|
|
vk.vkCmdPushDescriptorSetWithTemplateKHR(_handle, descriptorUpdateTemplate->getHandle(), layout->getHandle(), set, pData);
|
|
}
|
|
|
|
// Original: vkCmdSetViewportWScalingNV
|
|
void CommandBuffer::setViewportWScalingNV(uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {
|
|
vk.vkCmdSetViewportWScalingNV(_handle, firstViewport, viewportCount, pViewportWScalings);
|
|
}
|
|
|
|
// Original: vkCmdSetDiscardRectangleEXT
|
|
void CommandBuffer::setDiscardRectangleEXT(uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {
|
|
vk.vkCmdSetDiscardRectangleEXT(_handle, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
|
|
}
|
|
|
|
// Original: vkCmdSetDiscardRectangleEnableEXT
|
|
void CommandBuffer::setDiscardRectangleEnableEXT(VkBool32 discardRectangleEnable) {
|
|
vk.vkCmdSetDiscardRectangleEnableEXT(_handle, discardRectangleEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetDiscardRectangleModeEXT
|
|
void CommandBuffer::setDiscardRectangleModeEXT(VkDiscardRectangleModeEXT discardRectangleMode) {
|
|
vk.vkCmdSetDiscardRectangleModeEXT(_handle, discardRectangleMode);
|
|
}
|
|
|
|
// Original: vkCmdSetSampleLocationsEXT
|
|
void CommandBuffer::setSampleLocationsEXT(const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
|
|
vk.vkCmdSetSampleLocationsEXT(_handle, pSampleLocationsInfo);
|
|
}
|
|
|
|
// Original: vkCmdBeginDebugUtilsLabelEXT
|
|
void CommandBuffer::beginDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* pLabelInfo) {
|
|
vk.vkCmdBeginDebugUtilsLabelEXT(_handle, pLabelInfo);
|
|
}
|
|
|
|
// Original: vkCmdEndDebugUtilsLabelEXT
|
|
void CommandBuffer::endDebugUtilsLabelEXT() {
|
|
vk.vkCmdEndDebugUtilsLabelEXT(_handle);
|
|
}
|
|
|
|
// Original: vkCmdInsertDebugUtilsLabelEXT
|
|
void CommandBuffer::insertDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* pLabelInfo) {
|
|
vk.vkCmdInsertDebugUtilsLabelEXT(_handle, pLabelInfo);
|
|
}
|
|
|
|
// Original: vkCmdWriteBufferMarkerAMD
|
|
void CommandBuffer::writeBufferMarkerAMD(VkPipelineStageFlagBits pipelineStage, IntrusivePtr<Buffer> dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
|
|
vk.vkCmdWriteBufferMarkerAMD(_handle, pipelineStage, dstBuffer->getHandle(), dstOffset, marker);
|
|
}
|
|
|
|
// Original: vkCmdBeginRenderPass2
|
|
void CommandBuffer::beginRenderPass2(const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) {
|
|
vk.vkCmdBeginRenderPass2(_handle, pRenderPassBegin, pSubpassBeginInfo);
|
|
}
|
|
|
|
// Original: vkCmdBeginRenderPass2KHR
|
|
void CommandBuffer::beginRenderPass2KHR(const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) {
|
|
vk.vkCmdBeginRenderPass2KHR(_handle, pRenderPassBegin, pSubpassBeginInfo);
|
|
}
|
|
|
|
// Original: vkCmdNextSubpass2
|
|
void CommandBuffer::nextSubpass2(const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) {
|
|
vk.vkCmdNextSubpass2(_handle, pSubpassBeginInfo, pSubpassEndInfo);
|
|
}
|
|
|
|
// Original: vkCmdNextSubpass2KHR
|
|
void CommandBuffer::nextSubpass2KHR(const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) {
|
|
vk.vkCmdNextSubpass2KHR(_handle, pSubpassBeginInfo, pSubpassEndInfo);
|
|
}
|
|
|
|
// Original: vkCmdEndRenderPass2
|
|
void CommandBuffer::endRenderPass2(const VkSubpassEndInfo* pSubpassEndInfo) {
|
|
vk.vkCmdEndRenderPass2(_handle, pSubpassEndInfo);
|
|
}
|
|
|
|
// Original: vkCmdEndRenderPass2KHR
|
|
void CommandBuffer::endRenderPass2KHR(const VkSubpassEndInfo* pSubpassEndInfo) {
|
|
vk.vkCmdEndRenderPass2KHR(_handle, pSubpassEndInfo);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndirectCount
|
|
void CommandBuffer::drawIndirectCount(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, IntrusivePtr<Buffer> countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
|
|
vk.vkCmdDrawIndirectCount(_handle, buffer->getHandle(), offset, countBuffer->getHandle(), countBufferOffset, maxDrawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndirectCountKHR
|
|
void CommandBuffer::drawIndirectCountKHR(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, IntrusivePtr<Buffer> countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
|
|
vk.vkCmdDrawIndirectCountKHR(_handle, buffer->getHandle(), offset, countBuffer->getHandle(), countBufferOffset, maxDrawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndirectCountAMD
|
|
void CommandBuffer::drawIndirectCountAMD(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, IntrusivePtr<Buffer> countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
|
|
vk.vkCmdDrawIndirectCountAMD(_handle, buffer->getHandle(), offset, countBuffer->getHandle(), countBufferOffset, maxDrawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndexedIndirectCount
|
|
void CommandBuffer::drawIndexedIndirectCount(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, IntrusivePtr<Buffer> countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
|
|
vk.vkCmdDrawIndexedIndirectCount(_handle, buffer->getHandle(), offset, countBuffer->getHandle(), countBufferOffset, maxDrawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndexedIndirectCountKHR
|
|
void CommandBuffer::drawIndexedIndirectCountKHR(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, IntrusivePtr<Buffer> countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
|
|
vk.vkCmdDrawIndexedIndirectCountKHR(_handle, buffer->getHandle(), offset, countBuffer->getHandle(), countBufferOffset, maxDrawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndexedIndirectCountAMD
|
|
void CommandBuffer::drawIndexedIndirectCountAMD(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, IntrusivePtr<Buffer> countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
|
|
vk.vkCmdDrawIndexedIndirectCountAMD(_handle, buffer->getHandle(), offset, countBuffer->getHandle(), countBufferOffset, maxDrawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdSetCheckpointNV
|
|
void CommandBuffer::setCheckpointNV(const void* pCheckpointMarker) {
|
|
vk.vkCmdSetCheckpointNV(_handle, pCheckpointMarker);
|
|
}
|
|
|
|
// Original: vkCmdBindTransformFeedbackBuffersEXT
|
|
void CommandBuffer::bindTransformFeedbackBuffersEXT(uint32_t firstBinding, uint32_t bindingCount, const std::vector<IntrusivePtr<Buffer>>& pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
|
|
std::vector<VkBuffer> _raw_pBuffers; _raw_pBuffers.reserve(pBuffers.size());
|
|
for (auto const& it : pBuffers) _raw_pBuffers.push_back(it->getHandle());
|
|
vk.vkCmdBindTransformFeedbackBuffersEXT(_handle, firstBinding, bindingCount, pBuffers.size(), _raw_pBuffers.data(), pOffsets, pSizes);
|
|
}
|
|
|
|
// Original: vkCmdBeginTransformFeedbackEXT
|
|
void CommandBuffer::beginTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const std::vector<IntrusivePtr<Buffer>>& pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
|
|
std::vector<VkBuffer> _raw_pCounterBuffers; _raw_pCounterBuffers.reserve(pCounterBuffers.size());
|
|
for (auto const& it : pCounterBuffers) _raw_pCounterBuffers.push_back(it->getHandle());
|
|
vk.vkCmdBeginTransformFeedbackEXT(_handle, firstCounterBuffer, counterBufferCount, pCounterBuffers.size(), _raw_pCounterBuffers.data(), pCounterBufferOffsets);
|
|
}
|
|
|
|
// Original: vkCmdEndTransformFeedbackEXT
|
|
void CommandBuffer::endTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const std::vector<IntrusivePtr<Buffer>>& pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
|
|
std::vector<VkBuffer> _raw_pCounterBuffers; _raw_pCounterBuffers.reserve(pCounterBuffers.size());
|
|
for (auto const& it : pCounterBuffers) _raw_pCounterBuffers.push_back(it->getHandle());
|
|
vk.vkCmdEndTransformFeedbackEXT(_handle, firstCounterBuffer, counterBufferCount, pCounterBuffers.size(), _raw_pCounterBuffers.data(), pCounterBufferOffsets);
|
|
}
|
|
|
|
// Original: vkCmdBeginQueryIndexedEXT
|
|
void CommandBuffer::beginQueryIndexedEXT(IntrusivePtr<QueryPool> queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) {
|
|
vk.vkCmdBeginQueryIndexedEXT(_handle, queryPool->getHandle(), query, flags, index);
|
|
}
|
|
|
|
// Original: vkCmdEndQueryIndexedEXT
|
|
void CommandBuffer::endQueryIndexedEXT(IntrusivePtr<QueryPool> queryPool, uint32_t query, uint32_t index) {
|
|
vk.vkCmdEndQueryIndexedEXT(_handle, queryPool->getHandle(), query, index);
|
|
}
|
|
|
|
// Original: vkCmdDrawIndirectByteCountEXT
|
|
void CommandBuffer::drawIndirectByteCountEXT(uint32_t instanceCount, uint32_t firstInstance, IntrusivePtr<Buffer> counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) {
|
|
vk.vkCmdDrawIndirectByteCountEXT(_handle, instanceCount, firstInstance, counterBuffer->getHandle(), counterBufferOffset, counterOffset, vertexStride);
|
|
}
|
|
|
|
// Original: vkCmdSetExclusiveScissorNV
|
|
void CommandBuffer::setExclusiveScissorNV(uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {
|
|
vk.vkCmdSetExclusiveScissorNV(_handle, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
|
|
}
|
|
|
|
// Original: vkCmdSetExclusiveScissorEnableNV
|
|
void CommandBuffer::setExclusiveScissorEnableNV(uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) {
|
|
vk.vkCmdSetExclusiveScissorEnableNV(_handle, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables);
|
|
}
|
|
|
|
// Original: vkCmdBindShadingRateImageNV
|
|
void CommandBuffer::bindShadingRateImageNV(IntrusivePtr<ImageView> imageView, VkImageLayout imageLayout) {
|
|
vk.vkCmdBindShadingRateImageNV(_handle, imageView->getHandle(), imageLayout);
|
|
}
|
|
|
|
// Original: vkCmdSetViewportShadingRatePaletteNV
|
|
void CommandBuffer::setViewportShadingRatePaletteNV(uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) {
|
|
vk.vkCmdSetViewportShadingRatePaletteNV(_handle, firstViewport, viewportCount, pShadingRatePalettes);
|
|
}
|
|
|
|
// Original: vkCmdSetCoarseSampleOrderNV
|
|
void CommandBuffer::setCoarseSampleOrderNV(VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
|
|
vk.vkCmdSetCoarseSampleOrderNV(_handle, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
|
|
}
|
|
|
|
// Original: vkCmdDrawMeshTasksNV
|
|
void CommandBuffer::drawMeshTasksNV(uint32_t taskCount, uint32_t firstTask) {
|
|
vk.vkCmdDrawMeshTasksNV(_handle, taskCount, firstTask);
|
|
}
|
|
|
|
// Original: vkCmdDrawMeshTasksIndirectNV
|
|
void CommandBuffer::drawMeshTasksIndirectNV(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
|
|
vk.vkCmdDrawMeshTasksIndirectNV(_handle, buffer->getHandle(), offset, drawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawMeshTasksIndirectCountNV
|
|
void CommandBuffer::drawMeshTasksIndirectCountNV(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, IntrusivePtr<Buffer> countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
|
|
vk.vkCmdDrawMeshTasksIndirectCountNV(_handle, buffer->getHandle(), offset, countBuffer->getHandle(), countBufferOffset, maxDrawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawMeshTasksEXT
|
|
void CommandBuffer::drawMeshTasksEXT(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
|
|
vk.vkCmdDrawMeshTasksEXT(_handle, groupCountX, groupCountY, groupCountZ);
|
|
}
|
|
|
|
// Original: vkCmdDrawMeshTasksIndirectEXT
|
|
void CommandBuffer::drawMeshTasksIndirectEXT(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
|
|
vk.vkCmdDrawMeshTasksIndirectEXT(_handle, buffer->getHandle(), offset, drawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdDrawMeshTasksIndirectCountEXT
|
|
void CommandBuffer::drawMeshTasksIndirectCountEXT(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, IntrusivePtr<Buffer> countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
|
|
vk.vkCmdDrawMeshTasksIndirectCountEXT(_handle, buffer->getHandle(), offset, countBuffer->getHandle(), countBufferOffset, maxDrawCount, stride);
|
|
}
|
|
|
|
// Original: vkCmdBindInvocationMaskHUAWEI
|
|
void CommandBuffer::bindInvocationMaskHUAWEI(IntrusivePtr<ImageView> imageView, VkImageLayout imageLayout) {
|
|
vk.vkCmdBindInvocationMaskHUAWEI(_handle, imageView->getHandle(), imageLayout);
|
|
}
|
|
|
|
// Original: vkCmdCopyAccelerationStructureNV
|
|
void CommandBuffer::copyAccelerationStructureNV(IntrusivePtr<AccelerationStructureNV> dst, IntrusivePtr<AccelerationStructureNV> src, VkCopyAccelerationStructureModeKHR mode) {
|
|
vk.vkCmdCopyAccelerationStructureNV(_handle, dst->getHandle(), src->getHandle(), mode);
|
|
}
|
|
|
|
// Original: vkCmdCopyAccelerationStructureKHR
|
|
void CommandBuffer::copyAccelerationStructureKHR(const VkCopyAccelerationStructureInfoKHR* pInfo) {
|
|
vk.vkCmdCopyAccelerationStructureKHR(_handle, pInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyAccelerationStructureToMemoryKHR
|
|
void CommandBuffer::copyAccelerationStructureToMemoryKHR(const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
|
|
vk.vkCmdCopyAccelerationStructureToMemoryKHR(_handle, pInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyMemoryToAccelerationStructureKHR
|
|
void CommandBuffer::copyMemoryToAccelerationStructureKHR(const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
|
|
vk.vkCmdCopyMemoryToAccelerationStructureKHR(_handle, pInfo);
|
|
}
|
|
|
|
// Original: vkCmdWriteAccelerationStructuresPropertiesKHR
|
|
void CommandBuffer::writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const std::vector<IntrusivePtr<AccelerationStructureKHR>>& pAccelerationStructures, VkQueryType queryType, IntrusivePtr<QueryPool> queryPool, uint32_t firstQuery) {
|
|
std::vector<VkAccelerationStructureKHR> _raw_pAccelerationStructures; _raw_pAccelerationStructures.reserve(pAccelerationStructures.size());
|
|
for (auto const& it : pAccelerationStructures) _raw_pAccelerationStructures.push_back(it->getHandle());
|
|
vk.vkCmdWriteAccelerationStructuresPropertiesKHR(_handle, accelerationStructureCount, pAccelerationStructures.size(), _raw_pAccelerationStructures.data(), queryType, queryPool->getHandle(), firstQuery);
|
|
}
|
|
|
|
// Original: vkCmdWriteAccelerationStructuresPropertiesNV
|
|
void CommandBuffer::writeAccelerationStructuresPropertiesNV(uint32_t accelerationStructureCount, const std::vector<IntrusivePtr<AccelerationStructureNV>>& pAccelerationStructures, VkQueryType queryType, IntrusivePtr<QueryPool> queryPool, uint32_t firstQuery) {
|
|
std::vector<VkAccelerationStructureNV> _raw_pAccelerationStructures; _raw_pAccelerationStructures.reserve(pAccelerationStructures.size());
|
|
for (auto const& it : pAccelerationStructures) _raw_pAccelerationStructures.push_back(it->getHandle());
|
|
vk.vkCmdWriteAccelerationStructuresPropertiesNV(_handle, accelerationStructureCount, pAccelerationStructures.size(), _raw_pAccelerationStructures.data(), queryType, queryPool->getHandle(), firstQuery);
|
|
}
|
|
|
|
// Original: vkCmdBuildAccelerationStructureNV
|
|
void CommandBuffer::buildAccelerationStructureNV(const VkAccelerationStructureInfoNV* pInfo, IntrusivePtr<Buffer> instanceData, VkDeviceSize instanceOffset, VkBool32 update, IntrusivePtr<AccelerationStructureNV> dst, IntrusivePtr<AccelerationStructureNV> src, IntrusivePtr<Buffer> scratch, VkDeviceSize scratchOffset) {
|
|
vk.vkCmdBuildAccelerationStructureNV(_handle, pInfo, instanceData->getHandle(), instanceOffset, update, dst->getHandle(), src->getHandle(), scratch->getHandle(), scratchOffset);
|
|
}
|
|
|
|
// Original: vkCmdTraceRaysKHR
|
|
void CommandBuffer::traceRaysKHR(const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) {
|
|
vk.vkCmdTraceRaysKHR(_handle, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
|
|
}
|
|
|
|
// Original: vkCmdTraceRaysNV
|
|
void CommandBuffer::traceRaysNV(IntrusivePtr<Buffer> raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, IntrusivePtr<Buffer> missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, IntrusivePtr<Buffer> hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, IntrusivePtr<Buffer> callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) {
|
|
vk.vkCmdTraceRaysNV(_handle, raygenShaderBindingTableBuffer->getHandle(), raygenShaderBindingOffset, missShaderBindingTableBuffer->getHandle(), missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer->getHandle(), hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer->getHandle(), callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
|
|
}
|
|
|
|
// Original: vkCmdTraceRaysIndirectKHR
|
|
void CommandBuffer::traceRaysIndirectKHR(const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) {
|
|
vk.vkCmdTraceRaysIndirectKHR(_handle, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
|
|
}
|
|
|
|
// Original: vkCmdTraceRaysIndirect2KHR
|
|
void CommandBuffer::traceRaysIndirect2KHR(VkDeviceAddress indirectDeviceAddress) {
|
|
vk.vkCmdTraceRaysIndirect2KHR(_handle, indirectDeviceAddress);
|
|
}
|
|
|
|
// Original: vkCmdBuildClusterAccelerationStructureIndirectNV
|
|
void CommandBuffer::buildClusterAccelerationStructureIndirectNV(const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) {
|
|
vk.vkCmdBuildClusterAccelerationStructureIndirectNV(_handle, pCommandInfos);
|
|
}
|
|
|
|
// Original: vkCmdSetRayTracingPipelineStackSizeKHR
|
|
void CommandBuffer::setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize) {
|
|
vk.vkCmdSetRayTracingPipelineStackSizeKHR(_handle, pipelineStackSize);
|
|
}
|
|
|
|
// Original: vkCmdSetPerformanceMarkerINTEL
|
|
VkResult CommandBuffer::setPerformanceMarkerINTEL(const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {
|
|
return vk.vkCmdSetPerformanceMarkerINTEL(_handle, pMarkerInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetPerformanceStreamMarkerINTEL
|
|
VkResult CommandBuffer::setPerformanceStreamMarkerINTEL(const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {
|
|
return vk.vkCmdSetPerformanceStreamMarkerINTEL(_handle, pMarkerInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetPerformanceOverrideINTEL
|
|
VkResult CommandBuffer::setPerformanceOverrideINTEL(const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {
|
|
return vk.vkCmdSetPerformanceOverrideINTEL(_handle, pOverrideInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetLineStipple
|
|
void CommandBuffer::setLineStipple(uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
|
|
vk.vkCmdSetLineStipple(_handle, lineStippleFactor, lineStipplePattern);
|
|
}
|
|
|
|
// Original: vkCmdSetLineStippleKHR
|
|
void CommandBuffer::setLineStippleKHR(uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
|
|
vk.vkCmdSetLineStippleKHR(_handle, lineStippleFactor, lineStipplePattern);
|
|
}
|
|
|
|
// Original: vkCmdSetLineStippleEXT
|
|
void CommandBuffer::setLineStippleEXT(uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
|
|
vk.vkCmdSetLineStippleEXT(_handle, lineStippleFactor, lineStipplePattern);
|
|
}
|
|
|
|
// Original: vkCmdBuildAccelerationStructuresKHR
|
|
void CommandBuffer::buildAccelerationStructuresKHR(uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* ppBuildRangeInfos) {
|
|
vk.vkCmdBuildAccelerationStructuresKHR(_handle, infoCount, pInfos, ppBuildRangeInfos);
|
|
}
|
|
|
|
// Original: vkCmdBuildAccelerationStructuresIndirectKHR
|
|
void CommandBuffer::buildAccelerationStructuresIndirectKHR(uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* ppMaxPrimitiveCounts) {
|
|
vk.vkCmdBuildAccelerationStructuresIndirectKHR(_handle, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
|
|
}
|
|
|
|
// Original: vkCmdSetCullMode
|
|
void CommandBuffer::setCullMode(VkCullModeFlags cullMode) {
|
|
vk.vkCmdSetCullMode(_handle, cullMode);
|
|
}
|
|
|
|
// Original: vkCmdSetCullModeEXT
|
|
void CommandBuffer::setCullModeEXT(VkCullModeFlags cullMode) {
|
|
vk.vkCmdSetCullModeEXT(_handle, cullMode);
|
|
}
|
|
|
|
// Original: vkCmdSetFrontFace
|
|
void CommandBuffer::setFrontFace(VkFrontFace frontFace) {
|
|
vk.vkCmdSetFrontFace(_handle, frontFace);
|
|
}
|
|
|
|
// Original: vkCmdSetFrontFaceEXT
|
|
void CommandBuffer::setFrontFaceEXT(VkFrontFace frontFace) {
|
|
vk.vkCmdSetFrontFaceEXT(_handle, frontFace);
|
|
}
|
|
|
|
// Original: vkCmdSetPrimitiveTopology
|
|
void CommandBuffer::setPrimitiveTopology(VkPrimitiveTopology primitiveTopology) {
|
|
vk.vkCmdSetPrimitiveTopology(_handle, primitiveTopology);
|
|
}
|
|
|
|
// Original: vkCmdSetPrimitiveTopologyEXT
|
|
void CommandBuffer::setPrimitiveTopologyEXT(VkPrimitiveTopology primitiveTopology) {
|
|
vk.vkCmdSetPrimitiveTopologyEXT(_handle, primitiveTopology);
|
|
}
|
|
|
|
// Original: vkCmdSetViewportWithCount
|
|
void CommandBuffer::setViewportWithCount(uint32_t viewportCount, const VkViewport* pViewports) {
|
|
vk.vkCmdSetViewportWithCount(_handle, viewportCount, pViewports);
|
|
}
|
|
|
|
// Original: vkCmdSetViewportWithCountEXT
|
|
void CommandBuffer::setViewportWithCountEXT(uint32_t viewportCount, const VkViewport* pViewports) {
|
|
vk.vkCmdSetViewportWithCountEXT(_handle, viewportCount, pViewports);
|
|
}
|
|
|
|
// Original: vkCmdSetScissorWithCount
|
|
void CommandBuffer::setScissorWithCount(uint32_t scissorCount, const VkRect2D* pScissors) {
|
|
vk.vkCmdSetScissorWithCount(_handle, scissorCount, pScissors);
|
|
}
|
|
|
|
// Original: vkCmdSetScissorWithCountEXT
|
|
void CommandBuffer::setScissorWithCountEXT(uint32_t scissorCount, const VkRect2D* pScissors) {
|
|
vk.vkCmdSetScissorWithCountEXT(_handle, scissorCount, pScissors);
|
|
}
|
|
|
|
// Original: vkCmdBindIndexBuffer2
|
|
void CommandBuffer::bindIndexBuffer2(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) {
|
|
vk.vkCmdBindIndexBuffer2(_handle, buffer->getHandle(), offset, size, indexType);
|
|
}
|
|
|
|
// Original: vkCmdBindIndexBuffer2KHR
|
|
void CommandBuffer::bindIndexBuffer2KHR(IntrusivePtr<Buffer> buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) {
|
|
vk.vkCmdBindIndexBuffer2KHR(_handle, buffer->getHandle(), offset, size, indexType);
|
|
}
|
|
|
|
// Original: vkCmdBindVertexBuffers2
|
|
void CommandBuffer::bindVertexBuffers2(uint32_t firstBinding, uint32_t bindingCount, const std::vector<IntrusivePtr<Buffer>>& pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
|
|
std::vector<VkBuffer> _raw_pBuffers; _raw_pBuffers.reserve(pBuffers.size());
|
|
for (auto const& it : pBuffers) _raw_pBuffers.push_back(it->getHandle());
|
|
vk.vkCmdBindVertexBuffers2(_handle, firstBinding, bindingCount, pBuffers.size(), _raw_pBuffers.data(), pOffsets, pSizes, pStrides);
|
|
}
|
|
|
|
// Original: vkCmdBindVertexBuffers2EXT
|
|
void CommandBuffer::bindVertexBuffers2EXT(uint32_t firstBinding, uint32_t bindingCount, const std::vector<IntrusivePtr<Buffer>>& pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
|
|
std::vector<VkBuffer> _raw_pBuffers; _raw_pBuffers.reserve(pBuffers.size());
|
|
for (auto const& it : pBuffers) _raw_pBuffers.push_back(it->getHandle());
|
|
vk.vkCmdBindVertexBuffers2EXT(_handle, firstBinding, bindingCount, pBuffers.size(), _raw_pBuffers.data(), pOffsets, pSizes, pStrides);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthTestEnable
|
|
void CommandBuffer::setDepthTestEnable(VkBool32 depthTestEnable) {
|
|
vk.vkCmdSetDepthTestEnable(_handle, depthTestEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthTestEnableEXT
|
|
void CommandBuffer::setDepthTestEnableEXT(VkBool32 depthTestEnable) {
|
|
vk.vkCmdSetDepthTestEnableEXT(_handle, depthTestEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthWriteEnable
|
|
void CommandBuffer::setDepthWriteEnable(VkBool32 depthWriteEnable) {
|
|
vk.vkCmdSetDepthWriteEnable(_handle, depthWriteEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthWriteEnableEXT
|
|
void CommandBuffer::setDepthWriteEnableEXT(VkBool32 depthWriteEnable) {
|
|
vk.vkCmdSetDepthWriteEnableEXT(_handle, depthWriteEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthCompareOp
|
|
void CommandBuffer::setDepthCompareOp(VkCompareOp depthCompareOp) {
|
|
vk.vkCmdSetDepthCompareOp(_handle, depthCompareOp);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthCompareOpEXT
|
|
void CommandBuffer::setDepthCompareOpEXT(VkCompareOp depthCompareOp) {
|
|
vk.vkCmdSetDepthCompareOpEXT(_handle, depthCompareOp);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthBoundsTestEnable
|
|
void CommandBuffer::setDepthBoundsTestEnable(VkBool32 depthBoundsTestEnable) {
|
|
vk.vkCmdSetDepthBoundsTestEnable(_handle, depthBoundsTestEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthBoundsTestEnableEXT
|
|
void CommandBuffer::setDepthBoundsTestEnableEXT(VkBool32 depthBoundsTestEnable) {
|
|
vk.vkCmdSetDepthBoundsTestEnableEXT(_handle, depthBoundsTestEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetStencilTestEnable
|
|
void CommandBuffer::setStencilTestEnable(VkBool32 stencilTestEnable) {
|
|
vk.vkCmdSetStencilTestEnable(_handle, stencilTestEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetStencilTestEnableEXT
|
|
void CommandBuffer::setStencilTestEnableEXT(VkBool32 stencilTestEnable) {
|
|
vk.vkCmdSetStencilTestEnableEXT(_handle, stencilTestEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetStencilOp
|
|
void CommandBuffer::setStencilOp(VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
|
|
vk.vkCmdSetStencilOp(_handle, faceMask, failOp, passOp, depthFailOp, compareOp);
|
|
}
|
|
|
|
// Original: vkCmdSetStencilOpEXT
|
|
void CommandBuffer::setStencilOpEXT(VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
|
|
vk.vkCmdSetStencilOpEXT(_handle, faceMask, failOp, passOp, depthFailOp, compareOp);
|
|
}
|
|
|
|
// Original: vkCmdSetPatchControlPointsEXT
|
|
void CommandBuffer::setPatchControlPointsEXT(uint32_t patchControlPoints) {
|
|
vk.vkCmdSetPatchControlPointsEXT(_handle, patchControlPoints);
|
|
}
|
|
|
|
// Original: vkCmdSetRasterizerDiscardEnable
|
|
void CommandBuffer::setRasterizerDiscardEnable(VkBool32 rasterizerDiscardEnable) {
|
|
vk.vkCmdSetRasterizerDiscardEnable(_handle, rasterizerDiscardEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetRasterizerDiscardEnableEXT
|
|
void CommandBuffer::setRasterizerDiscardEnableEXT(VkBool32 rasterizerDiscardEnable) {
|
|
vk.vkCmdSetRasterizerDiscardEnableEXT(_handle, rasterizerDiscardEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthBiasEnable
|
|
void CommandBuffer::setDepthBiasEnable(VkBool32 depthBiasEnable) {
|
|
vk.vkCmdSetDepthBiasEnable(_handle, depthBiasEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthBiasEnableEXT
|
|
void CommandBuffer::setDepthBiasEnableEXT(VkBool32 depthBiasEnable) {
|
|
vk.vkCmdSetDepthBiasEnableEXT(_handle, depthBiasEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetLogicOpEXT
|
|
void CommandBuffer::setLogicOpEXT(VkLogicOp logicOp) {
|
|
vk.vkCmdSetLogicOpEXT(_handle, logicOp);
|
|
}
|
|
|
|
// Original: vkCmdSetPrimitiveRestartEnable
|
|
void CommandBuffer::setPrimitiveRestartEnable(VkBool32 primitiveRestartEnable) {
|
|
vk.vkCmdSetPrimitiveRestartEnable(_handle, primitiveRestartEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetPrimitiveRestartEnableEXT
|
|
void CommandBuffer::setPrimitiveRestartEnableEXT(VkBool32 primitiveRestartEnable) {
|
|
vk.vkCmdSetPrimitiveRestartEnableEXT(_handle, primitiveRestartEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetTessellationDomainOriginEXT
|
|
void CommandBuffer::setTessellationDomainOriginEXT(VkTessellationDomainOrigin domainOrigin) {
|
|
vk.vkCmdSetTessellationDomainOriginEXT(_handle, domainOrigin);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthClampEnableEXT
|
|
void CommandBuffer::setDepthClampEnableEXT(VkBool32 depthClampEnable) {
|
|
vk.vkCmdSetDepthClampEnableEXT(_handle, depthClampEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetPolygonModeEXT
|
|
void CommandBuffer::setPolygonModeEXT(VkPolygonMode polygonMode) {
|
|
vk.vkCmdSetPolygonModeEXT(_handle, polygonMode);
|
|
}
|
|
|
|
// Original: vkCmdSetRasterizationSamplesEXT
|
|
void CommandBuffer::setRasterizationSamplesEXT(VkSampleCountFlagBits rasterizationSamples) {
|
|
vk.vkCmdSetRasterizationSamplesEXT(_handle, rasterizationSamples);
|
|
}
|
|
|
|
// Original: vkCmdSetSampleMaskEXT
|
|
void CommandBuffer::setSampleMaskEXT(VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) {
|
|
vk.vkCmdSetSampleMaskEXT(_handle, samples, pSampleMask);
|
|
}
|
|
|
|
// Original: vkCmdSetAlphaToCoverageEnableEXT
|
|
void CommandBuffer::setAlphaToCoverageEnableEXT(VkBool32 alphaToCoverageEnable) {
|
|
vk.vkCmdSetAlphaToCoverageEnableEXT(_handle, alphaToCoverageEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetAlphaToOneEnableEXT
|
|
void CommandBuffer::setAlphaToOneEnableEXT(VkBool32 alphaToOneEnable) {
|
|
vk.vkCmdSetAlphaToOneEnableEXT(_handle, alphaToOneEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetLogicOpEnableEXT
|
|
void CommandBuffer::setLogicOpEnableEXT(VkBool32 logicOpEnable) {
|
|
vk.vkCmdSetLogicOpEnableEXT(_handle, logicOpEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetColorBlendEnableEXT
|
|
void CommandBuffer::setColorBlendEnableEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) {
|
|
vk.vkCmdSetColorBlendEnableEXT(_handle, firstAttachment, attachmentCount, pColorBlendEnables);
|
|
}
|
|
|
|
// Original: vkCmdSetColorBlendEquationEXT
|
|
void CommandBuffer::setColorBlendEquationEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) {
|
|
vk.vkCmdSetColorBlendEquationEXT(_handle, firstAttachment, attachmentCount, pColorBlendEquations);
|
|
}
|
|
|
|
// Original: vkCmdSetColorWriteMaskEXT
|
|
void CommandBuffer::setColorWriteMaskEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) {
|
|
vk.vkCmdSetColorWriteMaskEXT(_handle, firstAttachment, attachmentCount, pColorWriteMasks);
|
|
}
|
|
|
|
// Original: vkCmdSetRasterizationStreamEXT
|
|
void CommandBuffer::setRasterizationStreamEXT(uint32_t rasterizationStream) {
|
|
vk.vkCmdSetRasterizationStreamEXT(_handle, rasterizationStream);
|
|
}
|
|
|
|
// Original: vkCmdSetConservativeRasterizationModeEXT
|
|
void CommandBuffer::setConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT conservativeRasterizationMode) {
|
|
vk.vkCmdSetConservativeRasterizationModeEXT(_handle, conservativeRasterizationMode);
|
|
}
|
|
|
|
// Original: vkCmdSetExtraPrimitiveOverestimationSizeEXT
|
|
void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT(float extraPrimitiveOverestimationSize) {
|
|
vk.vkCmdSetExtraPrimitiveOverestimationSizeEXT(_handle, extraPrimitiveOverestimationSize);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthClipEnableEXT
|
|
void CommandBuffer::setDepthClipEnableEXT(VkBool32 depthClipEnable) {
|
|
vk.vkCmdSetDepthClipEnableEXT(_handle, depthClipEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetSampleLocationsEnableEXT
|
|
void CommandBuffer::setSampleLocationsEnableEXT(VkBool32 sampleLocationsEnable) {
|
|
vk.vkCmdSetSampleLocationsEnableEXT(_handle, sampleLocationsEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetColorBlendAdvancedEXT
|
|
void CommandBuffer::setColorBlendAdvancedEXT(uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) {
|
|
vk.vkCmdSetColorBlendAdvancedEXT(_handle, firstAttachment, attachmentCount, pColorBlendAdvanced);
|
|
}
|
|
|
|
// Original: vkCmdSetProvokingVertexModeEXT
|
|
void CommandBuffer::setProvokingVertexModeEXT(VkProvokingVertexModeEXT provokingVertexMode) {
|
|
vk.vkCmdSetProvokingVertexModeEXT(_handle, provokingVertexMode);
|
|
}
|
|
|
|
// Original: vkCmdSetLineRasterizationModeEXT
|
|
void CommandBuffer::setLineRasterizationModeEXT(VkLineRasterizationModeEXT lineRasterizationMode) {
|
|
vk.vkCmdSetLineRasterizationModeEXT(_handle, lineRasterizationMode);
|
|
}
|
|
|
|
// Original: vkCmdSetLineStippleEnableEXT
|
|
void CommandBuffer::setLineStippleEnableEXT(VkBool32 stippledLineEnable) {
|
|
vk.vkCmdSetLineStippleEnableEXT(_handle, stippledLineEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthClipNegativeOneToOneEXT
|
|
void CommandBuffer::setDepthClipNegativeOneToOneEXT(VkBool32 negativeOneToOne) {
|
|
vk.vkCmdSetDepthClipNegativeOneToOneEXT(_handle, negativeOneToOne);
|
|
}
|
|
|
|
// Original: vkCmdSetViewportWScalingEnableNV
|
|
void CommandBuffer::setViewportWScalingEnableNV(VkBool32 viewportWScalingEnable) {
|
|
vk.vkCmdSetViewportWScalingEnableNV(_handle, viewportWScalingEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetViewportSwizzleNV
|
|
void CommandBuffer::setViewportSwizzleNV(uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) {
|
|
vk.vkCmdSetViewportSwizzleNV(_handle, firstViewport, viewportCount, pViewportSwizzles);
|
|
}
|
|
|
|
// Original: vkCmdSetCoverageToColorEnableNV
|
|
void CommandBuffer::setCoverageToColorEnableNV(VkBool32 coverageToColorEnable) {
|
|
vk.vkCmdSetCoverageToColorEnableNV(_handle, coverageToColorEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetCoverageToColorLocationNV
|
|
void CommandBuffer::setCoverageToColorLocationNV(uint32_t coverageToColorLocation) {
|
|
vk.vkCmdSetCoverageToColorLocationNV(_handle, coverageToColorLocation);
|
|
}
|
|
|
|
// Original: vkCmdSetCoverageModulationModeNV
|
|
void CommandBuffer::setCoverageModulationModeNV(VkCoverageModulationModeNV coverageModulationMode) {
|
|
vk.vkCmdSetCoverageModulationModeNV(_handle, coverageModulationMode);
|
|
}
|
|
|
|
// Original: vkCmdSetCoverageModulationTableEnableNV
|
|
void CommandBuffer::setCoverageModulationTableEnableNV(VkBool32 coverageModulationTableEnable) {
|
|
vk.vkCmdSetCoverageModulationTableEnableNV(_handle, coverageModulationTableEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetCoverageModulationTableNV
|
|
void CommandBuffer::setCoverageModulationTableNV(uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) {
|
|
vk.vkCmdSetCoverageModulationTableNV(_handle, coverageModulationTableCount, pCoverageModulationTable);
|
|
}
|
|
|
|
// Original: vkCmdSetShadingRateImageEnableNV
|
|
void CommandBuffer::setShadingRateImageEnableNV(VkBool32 shadingRateImageEnable) {
|
|
vk.vkCmdSetShadingRateImageEnableNV(_handle, shadingRateImageEnable);
|
|
}
|
|
|
|
// Original: vkCmdSetCoverageReductionModeNV
|
|
void CommandBuffer::setCoverageReductionModeNV(VkCoverageReductionModeNV coverageReductionMode) {
|
|
vk.vkCmdSetCoverageReductionModeNV(_handle, coverageReductionMode);
|
|
}
|
|
|
|
// Original: vkCmdSetRepresentativeFragmentTestEnableNV
|
|
void CommandBuffer::setRepresentativeFragmentTestEnableNV(VkBool32 representativeFragmentTestEnable) {
|
|
vk.vkCmdSetRepresentativeFragmentTestEnableNV(_handle, representativeFragmentTestEnable);
|
|
}
|
|
|
|
// Original: vkCmdCopyBuffer2
|
|
void CommandBuffer::copyBuffer2(const VkCopyBufferInfo2* pCopyBufferInfo) {
|
|
vk.vkCmdCopyBuffer2(_handle, pCopyBufferInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyBuffer2KHR
|
|
void CommandBuffer::copyBuffer2KHR(const VkCopyBufferInfo2* pCopyBufferInfo) {
|
|
vk.vkCmdCopyBuffer2KHR(_handle, pCopyBufferInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyImage2
|
|
void CommandBuffer::copyImage2(const VkCopyImageInfo2* pCopyImageInfo) {
|
|
vk.vkCmdCopyImage2(_handle, pCopyImageInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyImage2KHR
|
|
void CommandBuffer::copyImage2KHR(const VkCopyImageInfo2* pCopyImageInfo) {
|
|
vk.vkCmdCopyImage2KHR(_handle, pCopyImageInfo);
|
|
}
|
|
|
|
// Original: vkCmdBlitImage2
|
|
void CommandBuffer::blitImage2(const VkBlitImageInfo2* pBlitImageInfo) {
|
|
vk.vkCmdBlitImage2(_handle, pBlitImageInfo);
|
|
}
|
|
|
|
// Original: vkCmdBlitImage2KHR
|
|
void CommandBuffer::blitImage2KHR(const VkBlitImageInfo2* pBlitImageInfo) {
|
|
vk.vkCmdBlitImage2KHR(_handle, pBlitImageInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyBufferToImage2
|
|
void CommandBuffer::copyBufferToImage2(const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
|
|
vk.vkCmdCopyBufferToImage2(_handle, pCopyBufferToImageInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyBufferToImage2KHR
|
|
void CommandBuffer::copyBufferToImage2KHR(const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
|
|
vk.vkCmdCopyBufferToImage2KHR(_handle, pCopyBufferToImageInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyImageToBuffer2
|
|
void CommandBuffer::copyImageToBuffer2(const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
|
|
vk.vkCmdCopyImageToBuffer2(_handle, pCopyImageToBufferInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyImageToBuffer2KHR
|
|
void CommandBuffer::copyImageToBuffer2KHR(const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
|
|
vk.vkCmdCopyImageToBuffer2KHR(_handle, pCopyImageToBufferInfo);
|
|
}
|
|
|
|
// Original: vkCmdResolveImage2
|
|
void CommandBuffer::resolveImage2(const VkResolveImageInfo2* pResolveImageInfo) {
|
|
vk.vkCmdResolveImage2(_handle, pResolveImageInfo);
|
|
}
|
|
|
|
// Original: vkCmdResolveImage2KHR
|
|
void CommandBuffer::resolveImage2KHR(const VkResolveImageInfo2* pResolveImageInfo) {
|
|
vk.vkCmdResolveImage2KHR(_handle, pResolveImageInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetFragmentShadingRateKHR
|
|
void CommandBuffer::setFragmentShadingRateKHR(const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps) {
|
|
vk.vkCmdSetFragmentShadingRateKHR(_handle, pFragmentSize, combinerOps);
|
|
}
|
|
|
|
// Original: vkCmdSetFragmentShadingRateEnumNV
|
|
void CommandBuffer::setFragmentShadingRateEnumNV(VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps) {
|
|
vk.vkCmdSetFragmentShadingRateEnumNV(_handle, shadingRate, combinerOps);
|
|
}
|
|
|
|
// Original: vkCmdSetVertexInputEXT
|
|
void CommandBuffer::setVertexInputEXT(uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) {
|
|
vk.vkCmdSetVertexInputEXT(_handle, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
|
|
}
|
|
|
|
// Original: vkCmdSetColorWriteEnableEXT
|
|
void CommandBuffer::setColorWriteEnableEXT(uint32_t attachmentCount, const VkBool32* pColorWriteEnables) {
|
|
vk.vkCmdSetColorWriteEnableEXT(_handle, attachmentCount, pColorWriteEnables);
|
|
}
|
|
|
|
// Original: vkCmdSetEvent2
|
|
void CommandBuffer::setEvent2(IntrusivePtr<Event> event, const VkDependencyInfo* pDependencyInfo) {
|
|
vk.vkCmdSetEvent2(_handle, event->getHandle(), pDependencyInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetEvent2KHR
|
|
void CommandBuffer::setEvent2KHR(IntrusivePtr<Event> event, const VkDependencyInfo* pDependencyInfo) {
|
|
vk.vkCmdSetEvent2KHR(_handle, event->getHandle(), pDependencyInfo);
|
|
}
|
|
|
|
// Original: vkCmdResetEvent2
|
|
void CommandBuffer::resetEvent2(IntrusivePtr<Event> event, VkPipelineStageFlags2 stageMask) {
|
|
vk.vkCmdResetEvent2(_handle, event->getHandle(), stageMask);
|
|
}
|
|
|
|
// Original: vkCmdResetEvent2KHR
|
|
void CommandBuffer::resetEvent2KHR(IntrusivePtr<Event> event, VkPipelineStageFlags2 stageMask) {
|
|
vk.vkCmdResetEvent2KHR(_handle, event->getHandle(), stageMask);
|
|
}
|
|
|
|
// Original: vkCmdWaitEvents2
|
|
void CommandBuffer::waitEvents2(uint32_t eventCount, const std::vector<IntrusivePtr<Event>>& pEvents, const VkDependencyInfo* pDependencyInfos) {
|
|
std::vector<VkEvent> _raw_pEvents; _raw_pEvents.reserve(pEvents.size());
|
|
for (auto const& it : pEvents) _raw_pEvents.push_back(it->getHandle());
|
|
vk.vkCmdWaitEvents2(_handle, eventCount, pEvents.size(), _raw_pEvents.data(), pDependencyInfos);
|
|
}
|
|
|
|
// Original: vkCmdWaitEvents2KHR
|
|
void CommandBuffer::waitEvents2KHR(uint32_t eventCount, const std::vector<IntrusivePtr<Event>>& pEvents, const VkDependencyInfo* pDependencyInfos) {
|
|
std::vector<VkEvent> _raw_pEvents; _raw_pEvents.reserve(pEvents.size());
|
|
for (auto const& it : pEvents) _raw_pEvents.push_back(it->getHandle());
|
|
vk.vkCmdWaitEvents2KHR(_handle, eventCount, pEvents.size(), _raw_pEvents.data(), pDependencyInfos);
|
|
}
|
|
|
|
// Original: vkCmdPipelineBarrier2
|
|
void CommandBuffer::pipelineBarrier2(const VkDependencyInfo* pDependencyInfo) {
|
|
vk.vkCmdPipelineBarrier2(_handle, pDependencyInfo);
|
|
}
|
|
|
|
// Original: vkCmdPipelineBarrier2KHR
|
|
void CommandBuffer::pipelineBarrier2KHR(const VkDependencyInfo* pDependencyInfo) {
|
|
vk.vkCmdPipelineBarrier2KHR(_handle, pDependencyInfo);
|
|
}
|
|
|
|
// Original: vkCmdWriteTimestamp2
|
|
void CommandBuffer::writeTimestamp2(VkPipelineStageFlags2 stage, IntrusivePtr<QueryPool> queryPool, uint32_t query) {
|
|
vk.vkCmdWriteTimestamp2(_handle, stage, queryPool->getHandle(), query);
|
|
}
|
|
|
|
// Original: vkCmdWriteTimestamp2KHR
|
|
void CommandBuffer::writeTimestamp2KHR(VkPipelineStageFlags2 stage, IntrusivePtr<QueryPool> queryPool, uint32_t query) {
|
|
vk.vkCmdWriteTimestamp2KHR(_handle, stage, queryPool->getHandle(), query);
|
|
}
|
|
|
|
// Original: vkCmdWriteBufferMarker2AMD
|
|
void CommandBuffer::writeBufferMarker2AMD(VkPipelineStageFlags2 stage, IntrusivePtr<Buffer> dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
|
|
vk.vkCmdWriteBufferMarker2AMD(_handle, stage, dstBuffer->getHandle(), dstOffset, marker);
|
|
}
|
|
|
|
// Original: vkCmdDecodeVideoKHR
|
|
void CommandBuffer::decodeVideoKHR(const VkVideoDecodeInfoKHR* pDecodeInfo) {
|
|
vk.vkCmdDecodeVideoKHR(_handle, pDecodeInfo);
|
|
}
|
|
|
|
// Original: vkCmdBeginVideoCodingKHR
|
|
void CommandBuffer::beginVideoCodingKHR(const VkVideoBeginCodingInfoKHR* pBeginInfo) {
|
|
vk.vkCmdBeginVideoCodingKHR(_handle, pBeginInfo);
|
|
}
|
|
|
|
// Original: vkCmdControlVideoCodingKHR
|
|
void CommandBuffer::controlVideoCodingKHR(const VkVideoCodingControlInfoKHR* pCodingControlInfo) {
|
|
vk.vkCmdControlVideoCodingKHR(_handle, pCodingControlInfo);
|
|
}
|
|
|
|
// Original: vkCmdEndVideoCodingKHR
|
|
void CommandBuffer::endVideoCodingKHR(const VkVideoEndCodingInfoKHR* pEndCodingInfo) {
|
|
vk.vkCmdEndVideoCodingKHR(_handle, pEndCodingInfo);
|
|
}
|
|
|
|
// Original: vkCmdEncodeVideoKHR
|
|
void CommandBuffer::encodeVideoKHR(const VkVideoEncodeInfoKHR* pEncodeInfo) {
|
|
vk.vkCmdEncodeVideoKHR(_handle, pEncodeInfo);
|
|
}
|
|
|
|
// Original: vkCmdDecompressMemoryNV
|
|
void CommandBuffer::decompressMemoryNV(uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) {
|
|
vk.vkCmdDecompressMemoryNV(_handle, decompressRegionCount, pDecompressMemoryRegions);
|
|
}
|
|
|
|
// Original: vkCmdDecompressMemoryIndirectCountNV
|
|
void CommandBuffer::decompressMemoryIndirectCountNV(VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) {
|
|
vk.vkCmdDecompressMemoryIndirectCountNV(_handle, indirectCommandsAddress, indirectCommandsCountAddress, stride);
|
|
}
|
|
|
|
// Original: vkCmdBuildPartitionedAccelerationStructuresNV
|
|
void CommandBuffer::buildPartitionedAccelerationStructuresNV(const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) {
|
|
vk.vkCmdBuildPartitionedAccelerationStructuresNV(_handle, pBuildInfo);
|
|
}
|
|
|
|
// Original: vkCmdCuLaunchKernelNVX
|
|
void CommandBuffer::cuLaunchKernelNVX(const VkCuLaunchInfoNVX* pLaunchInfo) {
|
|
vk.vkCmdCuLaunchKernelNVX(_handle, pLaunchInfo);
|
|
}
|
|
|
|
// Original: vkCmdBindDescriptorBuffersEXT
|
|
void CommandBuffer::bindDescriptorBuffersEXT(uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) {
|
|
vk.vkCmdBindDescriptorBuffersEXT(_handle, bufferCount, pBindingInfos);
|
|
}
|
|
|
|
// Original: vkCmdSetDescriptorBufferOffsetsEXT
|
|
void CommandBuffer::setDescriptorBufferOffsetsEXT(VkPipelineBindPoint pipelineBindPoint, IntrusivePtr<PipelineLayout> layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) {
|
|
vk.vkCmdSetDescriptorBufferOffsetsEXT(_handle, pipelineBindPoint, layout->getHandle(), firstSet, setCount, pBufferIndices, pOffsets);
|
|
}
|
|
|
|
// Original: vkCmdBindDescriptorBufferEmbeddedSamplersEXT
|
|
void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT(VkPipelineBindPoint pipelineBindPoint, IntrusivePtr<PipelineLayout> layout, uint32_t set) {
|
|
vk.vkCmdBindDescriptorBufferEmbeddedSamplersEXT(_handle, pipelineBindPoint, layout->getHandle(), set);
|
|
}
|
|
|
|
#if defined(VK_ENABLE_BETA_EXTENSIONS)
|
|
// Original: vkCmdCudaLaunchKernelNV
|
|
void CommandBuffer::cudaLaunchKernelNV(const VkCudaLaunchInfoNV* pLaunchInfo) {
|
|
vk.vkCmdCudaLaunchKernelNV(_handle, pLaunchInfo);
|
|
}
|
|
#endif
|
|
|
|
// Original: vkCmdBeginRendering
|
|
void CommandBuffer::beginRendering(const VkRenderingInfo* pRenderingInfo) {
|
|
vk.vkCmdBeginRendering(_handle, pRenderingInfo);
|
|
}
|
|
|
|
// Original: vkCmdBeginRenderingKHR
|
|
void CommandBuffer::beginRenderingKHR(const VkRenderingInfo* pRenderingInfo) {
|
|
vk.vkCmdBeginRenderingKHR(_handle, pRenderingInfo);
|
|
}
|
|
|
|
// Original: vkCmdEndRendering
|
|
void CommandBuffer::endRendering() {
|
|
vk.vkCmdEndRendering(_handle);
|
|
}
|
|
|
|
// Original: vkCmdEndRendering2EXT
|
|
void CommandBuffer::endRendering2EXT(const VkRenderingEndInfoEXT* pRenderingEndInfo) {
|
|
vk.vkCmdEndRendering2EXT(_handle, pRenderingEndInfo);
|
|
}
|
|
|
|
// Original: vkCmdEndRenderingKHR
|
|
void CommandBuffer::endRenderingKHR() {
|
|
vk.vkCmdEndRenderingKHR(_handle);
|
|
}
|
|
|
|
// Original: vkCmdBuildMicromapsEXT
|
|
void CommandBuffer::buildMicromapsEXT(uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
|
|
vk.vkCmdBuildMicromapsEXT(_handle, infoCount, pInfos);
|
|
}
|
|
|
|
// Original: vkCmdCopyMicromapEXT
|
|
void CommandBuffer::copyMicromapEXT(const VkCopyMicromapInfoEXT* pInfo) {
|
|
vk.vkCmdCopyMicromapEXT(_handle, pInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyMicromapToMemoryEXT
|
|
void CommandBuffer::copyMicromapToMemoryEXT(const VkCopyMicromapToMemoryInfoEXT* pInfo) {
|
|
vk.vkCmdCopyMicromapToMemoryEXT(_handle, pInfo);
|
|
}
|
|
|
|
// Original: vkCmdCopyMemoryToMicromapEXT
|
|
void CommandBuffer::copyMemoryToMicromapEXT(const VkCopyMemoryToMicromapInfoEXT* pInfo) {
|
|
vk.vkCmdCopyMemoryToMicromapEXT(_handle, pInfo);
|
|
}
|
|
|
|
// Original: vkCmdWriteMicromapsPropertiesEXT
|
|
void CommandBuffer::writeMicromapsPropertiesEXT(uint32_t micromapCount, const std::vector<IntrusivePtr<MicromapEXT>>& pMicromaps, VkQueryType queryType, IntrusivePtr<QueryPool> queryPool, uint32_t firstQuery) {
|
|
std::vector<VkMicromapEXT> _raw_pMicromaps; _raw_pMicromaps.reserve(pMicromaps.size());
|
|
for (auto const& it : pMicromaps) _raw_pMicromaps.push_back(it->getHandle());
|
|
vk.vkCmdWriteMicromapsPropertiesEXT(_handle, micromapCount, pMicromaps.size(), _raw_pMicromaps.data(), queryType, queryPool->getHandle(), firstQuery);
|
|
}
|
|
|
|
// Original: vkCmdBindTileMemoryQCOM
|
|
void CommandBuffer::bindTileMemoryQCOM(const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) {
|
|
vk.vkCmdBindTileMemoryQCOM(_handle, pTileMemoryBindInfo);
|
|
}
|
|
|
|
// Original: vkCmdOpticalFlowExecuteNV
|
|
void CommandBuffer::opticalFlowExecuteNV(IntrusivePtr<OpticalFlowSessionNV> session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) {
|
|
vk.vkCmdOpticalFlowExecuteNV(_handle, session->getHandle(), pExecuteInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthBias2EXT
|
|
void CommandBuffer::setDepthBias2EXT(const VkDepthBiasInfoEXT* pDepthBiasInfo) {
|
|
vk.vkCmdSetDepthBias2EXT(_handle, pDepthBiasInfo);
|
|
}
|
|
|
|
// Original: vkCmdBindShadersEXT
|
|
void CommandBuffer::bindShadersEXT(uint32_t stageCount, const VkShaderStageFlagBits* pStages, const std::vector<IntrusivePtr<ShaderEXT>>& pShaders) {
|
|
std::vector<VkShaderEXT> _raw_pShaders; _raw_pShaders.reserve(pShaders.size());
|
|
for (auto const& it : pShaders) _raw_pShaders.push_back(it->getHandle());
|
|
vk.vkCmdBindShadersEXT(_handle, stageCount, pStages, pShaders.size(), _raw_pShaders.data());
|
|
}
|
|
|
|
#if defined(VK_ENABLE_BETA_EXTENSIONS)
|
|
// Original: vkCmdInitializeGraphScratchMemoryAMDX
|
|
void CommandBuffer::initializeGraphScratchMemoryAMDX(IntrusivePtr<Pipeline> executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize) {
|
|
vk.vkCmdInitializeGraphScratchMemoryAMDX(_handle, executionGraph->getHandle(), scratch, scratchSize);
|
|
}
|
|
#endif
|
|
|
|
#if defined(VK_ENABLE_BETA_EXTENSIONS)
|
|
// Original: vkCmdDispatchGraphAMDX
|
|
void CommandBuffer::dispatchGraphAMDX(VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) {
|
|
vk.vkCmdDispatchGraphAMDX(_handle, scratch, scratchSize, pCountInfo);
|
|
}
|
|
#endif
|
|
|
|
#if defined(VK_ENABLE_BETA_EXTENSIONS)
|
|
// Original: vkCmdDispatchGraphIndirectAMDX
|
|
void CommandBuffer::dispatchGraphIndirectAMDX(VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) {
|
|
vk.vkCmdDispatchGraphIndirectAMDX(_handle, scratch, scratchSize, pCountInfo);
|
|
}
|
|
#endif
|
|
|
|
#if defined(VK_ENABLE_BETA_EXTENSIONS)
|
|
// Original: vkCmdDispatchGraphIndirectCountAMDX
|
|
void CommandBuffer::dispatchGraphIndirectCountAMDX(VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo) {
|
|
vk.vkCmdDispatchGraphIndirectCountAMDX(_handle, scratch, scratchSize, countInfo);
|
|
}
|
|
#endif
|
|
|
|
// Original: vkCmdBindDescriptorSets2
|
|
void CommandBuffer::bindDescriptorSets2(const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
|
|
vk.vkCmdBindDescriptorSets2(_handle, pBindDescriptorSetsInfo);
|
|
}
|
|
|
|
// Original: vkCmdBindDescriptorSets2KHR
|
|
void CommandBuffer::bindDescriptorSets2KHR(const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
|
|
vk.vkCmdBindDescriptorSets2KHR(_handle, pBindDescriptorSetsInfo);
|
|
}
|
|
|
|
// Original: vkCmdPushConstants2
|
|
void CommandBuffer::pushConstants2(const VkPushConstantsInfo* pPushConstantsInfo) {
|
|
vk.vkCmdPushConstants2(_handle, pPushConstantsInfo);
|
|
}
|
|
|
|
// Original: vkCmdPushConstants2KHR
|
|
void CommandBuffer::pushConstants2KHR(const VkPushConstantsInfo* pPushConstantsInfo) {
|
|
vk.vkCmdPushConstants2KHR(_handle, pPushConstantsInfo);
|
|
}
|
|
|
|
// Original: vkCmdPushDescriptorSet2
|
|
void CommandBuffer::pushDescriptorSet2(const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
|
|
vk.vkCmdPushDescriptorSet2(_handle, pPushDescriptorSetInfo);
|
|
}
|
|
|
|
// Original: vkCmdPushDescriptorSet2KHR
|
|
void CommandBuffer::pushDescriptorSet2KHR(const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
|
|
vk.vkCmdPushDescriptorSet2KHR(_handle, pPushDescriptorSetInfo);
|
|
}
|
|
|
|
// Original: vkCmdPushDescriptorSetWithTemplate2
|
|
void CommandBuffer::pushDescriptorSetWithTemplate2(const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
|
|
vk.vkCmdPushDescriptorSetWithTemplate2(_handle, pPushDescriptorSetWithTemplateInfo);
|
|
}
|
|
|
|
// Original: vkCmdPushDescriptorSetWithTemplate2KHR
|
|
void CommandBuffer::pushDescriptorSetWithTemplate2KHR(const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
|
|
vk.vkCmdPushDescriptorSetWithTemplate2KHR(_handle, pPushDescriptorSetWithTemplateInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetDescriptorBufferOffsets2EXT
|
|
void CommandBuffer::setDescriptorBufferOffsets2EXT(const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) {
|
|
vk.vkCmdSetDescriptorBufferOffsets2EXT(_handle, pSetDescriptorBufferOffsetsInfo);
|
|
}
|
|
|
|
// Original: vkCmdBindDescriptorBufferEmbeddedSamplers2EXT
|
|
void CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) {
|
|
vk.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(_handle, pBindDescriptorBufferEmbeddedSamplersInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetRenderingAttachmentLocations
|
|
void CommandBuffer::setRenderingAttachmentLocations(const VkRenderingAttachmentLocationInfo* pLocationInfo) {
|
|
vk.vkCmdSetRenderingAttachmentLocations(_handle, pLocationInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetRenderingAttachmentLocationsKHR
|
|
void CommandBuffer::setRenderingAttachmentLocationsKHR(const VkRenderingAttachmentLocationInfo* pLocationInfo) {
|
|
vk.vkCmdSetRenderingAttachmentLocationsKHR(_handle, pLocationInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetRenderingInputAttachmentIndices
|
|
void CommandBuffer::setRenderingInputAttachmentIndices(const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
|
|
vk.vkCmdSetRenderingInputAttachmentIndices(_handle, pInputAttachmentIndexInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetRenderingInputAttachmentIndicesKHR
|
|
void CommandBuffer::setRenderingInputAttachmentIndicesKHR(const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
|
|
vk.vkCmdSetRenderingInputAttachmentIndicesKHR(_handle, pInputAttachmentIndexInfo);
|
|
}
|
|
|
|
// Original: vkCmdSetDepthClampRangeEXT
|
|
void CommandBuffer::setDepthClampRangeEXT(VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange) {
|
|
vk.vkCmdSetDepthClampRangeEXT(_handle, depthClampMode, pDepthClampRange);
|
|
}
|
|
|
|
// Original: vkCmdConvertCooperativeVectorMatrixNV
|
|
void CommandBuffer::convertCooperativeVectorMatrixNV(uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos) {
|
|
vk.vkCmdConvertCooperativeVectorMatrixNV(_handle, infoCount, pInfos);
|
|
}
|
|
|
|
// Original: vkCmdDispatchTileQCOM
|
|
void CommandBuffer::dispatchTileQCOM() {
|
|
vk.vkCmdDispatchTileQCOM(_handle);
|
|
}
|
|
|
|
// Original: vkCmdBeginPerTileExecutionQCOM
|
|
void CommandBuffer::beginPerTileExecutionQCOM(const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) {
|
|
vk.vkCmdBeginPerTileExecutionQCOM(_handle, pPerTileBeginInfo);
|
|
}
|
|
|
|
// Original: vkCmdEndPerTileExecutionQCOM
|
|
void CommandBuffer::endPerTileExecutionQCOM(const VkPerTileEndInfoQCOM* pPerTileEndInfo) {
|
|
vk.vkCmdEndPerTileExecutionQCOM(_handle, pPerTileEndInfo);
|
|
}
|
|
|
|
} // namespace VulkanPP
|