mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-20 05:16:01 +00:00
Mali bridge (#517, by ASEbrahim) on the non-Adreno test branch
Squash of Droid-Deck/DroidDeck#517 (ASEbrahim/DroidDeck mali-bridge @ 6b823341): the Vulkan
bridge (tools/vkbridge) that runs the guest's Vulkan on the phone's own driver, with BC1-BC7,
clip/cull distance, vertex-divisor and depth-clip emulation and dma-heap memory sharing for Mali.
All of the bridge is ASEbrahim's work; squashed only to carry it on this test branch.
Combined with #570 on this branch, a device draws through exactly one path:
- Adreno: Turnip, unchanged (checked first; the bridge setting is ignored there).
- PowerVR / Xclipse with the system HAL and a render node: the system-Vulkan path (#570).
- Anything else with the Setup toggle on (Mali): the bridge.
This commit is contained in:
1 parent
cf06f89c11
commit
ee0fb08268
125 files changed
+119982
-12
No files matched your search
@@ -0,0 +1,422 @@
|
||||
/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.4.341 - do not edit. */
|
||||
|
||||
#ifndef VKB_CLIENT_GEN_H
|
||||
#define VKB_CLIENT_GEN_H
|
||||
#include "vkb_gen.h"
|
||||
VkResult vkb_wire_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
|
||||
VkResult vkb_wire_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
|
||||
VkResult vkb_wire_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
|
||||
VkResult vkb_wire_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
|
||||
VkResult vkb_wire_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
|
||||
VkResult vkb_wire_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
|
||||
VkResult vkb_wire_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
|
||||
VkResult vkb_wire_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
|
||||
VkResult vkb_wire_vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos);
|
||||
void vkb_wire_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
|
||||
void vkb_wire_vkCmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo);
|
||||
void vkb_wire_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
|
||||
void vkb_wire_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index);
|
||||
void vkb_wire_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
|
||||
void vkb_wire_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo);
|
||||
void vkb_wire_vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo);
|
||||
void vkb_wire_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
|
||||
void vkb_wire_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
|
||||
void vkb_wire_vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo);
|
||||
void vkb_wire_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
|
||||
void vkb_wire_vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType);
|
||||
void vkb_wire_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
|
||||
void vkb_wire_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);
|
||||
void vkb_wire_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
|
||||
void vkb_wire_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);
|
||||
void vkb_wire_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
|
||||
void vkb_wire_vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo);
|
||||
void vkb_wire_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
|
||||
void vkb_wire_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
|
||||
void vkb_wire_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
|
||||
void vkb_wire_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
|
||||
void vkb_wire_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo);
|
||||
void vkb_wire_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
|
||||
void vkb_wire_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
|
||||
void vkb_wire_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
|
||||
void vkb_wire_vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo);
|
||||
void vkb_wire_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
|
||||
void vkb_wire_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
|
||||
void vkb_wire_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
|
||||
void vkb_wire_vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo);
|
||||
void vkb_wire_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
|
||||
void vkb_wire_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
|
||||
void vkb_wire_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
|
||||
void vkb_wire_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
|
||||
void vkb_wire_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
|
||||
void vkb_wire_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
|
||||
void vkb_wire_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
|
||||
void vkb_wire_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
|
||||
void vkb_wire_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride);
|
||||
void vkb_wire_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
|
||||
void vkb_wire_vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride);
|
||||
void vkb_wire_vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset);
|
||||
void vkb_wire_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer);
|
||||
void vkb_wire_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
|
||||
void vkb_wire_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
|
||||
void vkb_wire_vkCmdEndRenderPass(VkCommandBuffer commandBuffer);
|
||||
void vkb_wire_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo);
|
||||
void vkb_wire_vkCmdEndRendering(VkCommandBuffer commandBuffer);
|
||||
void vkb_wire_vkCmdEndRendering2KHR(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo);
|
||||
void vkb_wire_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
|
||||
void vkb_wire_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
|
||||
void vkb_wire_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
|
||||
void vkb_wire_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
|
||||
void vkb_wire_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo);
|
||||
void vkb_wire_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
|
||||
void vkb_wire_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo);
|
||||
void vkb_wire_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
|
||||
void vkb_wire_vkCmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo);
|
||||
void vkb_wire_vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
|
||||
void vkb_wire_vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo);
|
||||
void vkb_wire_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
|
||||
void vkb_wire_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask);
|
||||
void vkb_wire_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
|
||||
void vkb_wire_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
|
||||
void vkb_wire_vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo);
|
||||
void vkb_wire_vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable);
|
||||
void vkb_wire_vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable);
|
||||
void vkb_wire_vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask);
|
||||
void vkb_wire_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]);
|
||||
void vkb_wire_vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced);
|
||||
void vkb_wire_vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables);
|
||||
void vkb_wire_vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations);
|
||||
void vkb_wire_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables);
|
||||
void vkb_wire_vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks);
|
||||
void vkb_wire_vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode);
|
||||
void vkb_wire_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
|
||||
void vkb_wire_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
|
||||
void vkb_wire_vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo);
|
||||
void vkb_wire_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);
|
||||
void vkb_wire_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
|
||||
void vkb_wire_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
|
||||
void vkb_wire_vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable);
|
||||
void vkb_wire_vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange);
|
||||
void vkb_wire_vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable);
|
||||
void vkb_wire_vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne);
|
||||
void vkb_wire_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
|
||||
void vkb_wire_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);
|
||||
void vkb_wire_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);
|
||||
void vkb_wire_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask);
|
||||
void vkb_wire_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
|
||||
void vkb_wire_vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable);
|
||||
void vkb_wire_vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode);
|
||||
void vkb_wire_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
|
||||
void vkb_wire_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo);
|
||||
void vkb_wire_vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize);
|
||||
void vkb_wire_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
|
||||
void vkb_wire_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
|
||||
void vkb_wire_vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode);
|
||||
void vkb_wire_vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
|
||||
void vkb_wire_vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable);
|
||||
void vkb_wire_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth);
|
||||
void vkb_wire_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp);
|
||||
void vkb_wire_vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable);
|
||||
void vkb_wire_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints);
|
||||
void vkb_wire_vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode);
|
||||
void vkb_wire_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
|
||||
void vkb_wire_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
|
||||
void vkb_wire_vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode);
|
||||
void vkb_wire_vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples);
|
||||
void vkb_wire_vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream);
|
||||
void vkb_wire_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
|
||||
void vkb_wire_vkCmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo);
|
||||
void vkb_wire_vkCmdSetRenderingInputAttachmentIndices(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo);
|
||||
void vkb_wire_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
|
||||
void vkb_wire_vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable);
|
||||
void vkb_wire_vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask);
|
||||
void vkb_wire_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
|
||||
void vkb_wire_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
|
||||
void vkb_wire_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
|
||||
void vkb_wire_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
|
||||
void vkb_wire_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
|
||||
void vkb_wire_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
|
||||
void vkb_wire_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
|
||||
void vkb_wire_vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin);
|
||||
void vkb_wire_vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
|
||||
void vkb_wire_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
|
||||
void vkb_wire_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
|
||||
void vkb_wire_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
|
||||
void vkb_wire_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
|
||||
void vkb_wire_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos);
|
||||
void vkb_wire_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
|
||||
void vkb_wire_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);
|
||||
VkResult vkb_wire_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
|
||||
VkResult vkb_wire_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
|
||||
VkResult vkb_wire_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
|
||||
VkResult vkb_wire_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
|
||||
VkResult vkb_wire_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
|
||||
VkResult vkb_wire_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
|
||||
VkResult vkb_wire_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
|
||||
VkResult vkb_wire_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
|
||||
VkResult vkb_wire_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
|
||||
VkResult vkb_wire_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
|
||||
VkResult vkb_wire_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
|
||||
VkResult vkb_wire_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
|
||||
VkResult vkb_wire_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
|
||||
VkResult vkb_wire_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
|
||||
VkResult vkb_wire_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
|
||||
VkResult vkb_wire_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
|
||||
VkResult vkb_wire_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
|
||||
VkResult vkb_wire_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
|
||||
VkResult vkb_wire_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
|
||||
VkResult vkb_wire_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
|
||||
VkResult vkb_wire_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
|
||||
VkResult vkb_wire_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
|
||||
VkResult vkb_wire_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
|
||||
VkResult vkb_wire_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
|
||||
VkResult vkb_wire_vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor);
|
||||
VkResult vkb_wire_vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView);
|
||||
void vkb_wire_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator);
|
||||
void vkb_wire_vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator);
|
||||
VkResult vkb_wire_vkDeviceWaitIdle(VkDevice device);
|
||||
VkResult vkb_wire_vkEndCommandBuffer(VkCommandBuffer commandBuffer);
|
||||
VkResult vkb_wire_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
|
||||
VkResult vkb_wire_vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
|
||||
VkResult vkb_wire_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
|
||||
VkResult vkb_wire_vkEnumerateInstanceVersion(uint32_t* pApiVersion);
|
||||
VkResult vkb_wire_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
|
||||
VkResult vkb_wire_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions);
|
||||
VkResult vkb_wire_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
|
||||
VkResult vkb_wire_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
|
||||
void vkb_wire_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
|
||||
VkResult vkb_wire_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
|
||||
void vkb_wire_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
|
||||
VkDeviceAddress vkb_wire_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
|
||||
void vkb_wire_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
|
||||
void vkb_wire_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
uint64_t vkb_wire_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
|
||||
VkResult vkb_wire_vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
|
||||
void vkb_wire_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
|
||||
void vkb_wire_vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
void vkb_wire_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
|
||||
void vkb_wire_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
void vkb_wire_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
|
||||
void vkb_wire_vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout);
|
||||
void vkb_wire_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
|
||||
uint64_t vkb_wire_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
|
||||
void vkb_wire_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
|
||||
void vkb_wire_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
|
||||
void vkb_wire_vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
VkResult vkb_wire_vkGetEventStatus(VkDevice device, VkEvent event);
|
||||
VkResult vkb_wire_vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
|
||||
VkResult vkb_wire_vkGetFenceStatus(VkDevice device, VkFence fence);
|
||||
VkResult vkb_wire_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties);
|
||||
void vkb_wire_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
|
||||
void vkb_wire_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
void vkb_wire_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
|
||||
void vkb_wire_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
|
||||
void vkb_wire_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
|
||||
void vkb_wire_vkGetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout);
|
||||
VkResult vkb_wire_vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
|
||||
VkResult vkb_wire_vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
|
||||
VkResult vkb_wire_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains);
|
||||
VkResult vkb_wire_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
|
||||
void vkb_wire_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
|
||||
void vkb_wire_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
|
||||
VkResult vkb_wire_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);
|
||||
VkResult vkb_wire_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
|
||||
VkResult vkb_wire_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
|
||||
void vkb_wire_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
|
||||
VkResult vkb_wire_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties);
|
||||
VkResult vkb_wire_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
|
||||
VkResult vkb_wire_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
|
||||
void vkb_wire_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
|
||||
void vkb_wire_vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity);
|
||||
VkResult vkb_wire_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
|
||||
VkResult vkb_wire_vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
|
||||
void vkb_wire_vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier);
|
||||
void vkb_wire_vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier);
|
||||
void vkb_wire_vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
VkResult vkb_wire_vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
|
||||
VkResult vkb_wire_vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
|
||||
VkResult vkb_wire_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
|
||||
VkResult vkb_wire_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
|
||||
VkResult vkb_wire_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
|
||||
VkResult vkb_wire_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
|
||||
VkResult vkb_wire_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
|
||||
VkResult vkb_wire_vkQueueWaitIdle(VkQueue queue);
|
||||
VkResult vkb_wire_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
|
||||
VkResult vkb_wire_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
|
||||
VkResult vkb_wire_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
|
||||
VkResult vkb_wire_vkResetEvent(VkDevice device, VkEvent event);
|
||||
VkResult vkb_wire_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
|
||||
void vkb_wire_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
|
||||
void vkb_wire_vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority);
|
||||
VkResult vkb_wire_vkSetEvent(VkDevice device, VkEvent event);
|
||||
VkResult vkb_wire_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
|
||||
void vkb_wire_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
|
||||
void vkb_wire_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
|
||||
VkResult vkb_wire_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
|
||||
VkResult vkb_wire_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPushDescriptorSetWithTemplate2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCopyImageToImage(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkDeviceWaitIdle(VkDevice device);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEndCommandBuffer(VkCommandBuffer commandBuffer);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateInstanceVersion(uint32_t* pApiVersion);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
|
||||
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkb_ep_vkGetDeviceProcAddr(VkDevice device, const char* pName);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetFenceStatus(VkDevice device, VkFence fence);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
|
||||
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkb_ep_vkGetInstanceProcAddr(VkInstance instance, const char* pName);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties);
|
||||
VKAPI_ATTR VkBool32 VKAPI_CALL vkb_ep_vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
|
||||
VKAPI_ATTR VkBool32 VKAPI_CALL vkb_ep_vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
|
||||
VKAPI_ATTR VkBool32 VKAPI_CALL vkb_ep_vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkMapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkQueueEndDebugUtilsLabelEXT(VkQueue queue);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueWaitIdle(VkQueue queue);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkTransitionImageLayout(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkUnmapMemory(VkDevice device, VkDeviceMemory memory);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo);
|
||||
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
|
||||
#endif
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,300 @@
|
||||
/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.4.341 - do not edit. */
|
||||
|
||||
#ifndef VKB_SERVER_GEN_H
|
||||
#define VKB_SERVER_GEN_H
|
||||
#include "vkb_gen.h"
|
||||
typedef struct vkb_srv_call vkb_srv_call;
|
||||
typedef void (*vkb_srv_handler)(vkb_srv_call *c);
|
||||
extern const vkb_srv_handler vkb_srv_handlers[VKB_CMD_COUNT];
|
||||
void vkb_sv_vkAllocateCommandBuffers(vkb_srv_call *c);
|
||||
void vkb_sv_vkAllocateDescriptorSets(vkb_srv_call *c);
|
||||
void vkb_sv_vkAllocateMemory(vkb_srv_call *c);
|
||||
void vkb_sv_vkBeginCommandBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkBindBufferMemory(vkb_srv_call *c);
|
||||
void vkb_sv_vkBindBufferMemory2(vkb_srv_call *c);
|
||||
void vkb_sv_vkBindImageMemory(vkb_srv_call *c);
|
||||
void vkb_sv_vkBindImageMemory2(vkb_srv_call *c);
|
||||
void vkb_sv_vkBindTensorMemoryARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBeginConditionalRenderingEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBeginCustomResolveEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBeginQuery(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBeginQueryIndexedEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBeginRenderPass(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBeginRenderPass2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBeginRendering(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBeginTransformFeedbackEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBindDescriptorSets(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBindDescriptorSets2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBindIndexBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBindIndexBuffer2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBindPipeline(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBindTransformFeedbackBuffersEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBindVertexBuffers(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBindVertexBuffers2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBlitImage(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdBlitImage2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdClearAttachments(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdClearColorImage(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdClearDepthStencilImage(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyBuffer2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyBufferToImage(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyBufferToImage2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyImage(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyImage2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyImageToBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyImageToBuffer2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyQueryPoolResults(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdCopyTensorARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDispatch(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDispatchBase(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDispatchIndirect(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDraw(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDrawIndexed(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDrawIndexedIndirect(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDrawIndexedIndirectCount(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDrawIndirect(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDrawIndirectByteCountEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDrawIndirectCount(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDrawMultiEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdDrawMultiIndexedEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdEndConditionalRenderingEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdEndQuery(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdEndQueryIndexedEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdEndRenderPass(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdEndRenderPass2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdEndRendering(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdEndRendering2KHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdEndTransformFeedbackEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdExecuteCommands(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdFillBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdNextSubpass(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdNextSubpass2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdPipelineBarrier(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdPipelineBarrier2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdPushConstants(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdPushConstants2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdPushDescriptorSet(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdPushDescriptorSet2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdResetEvent(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdResetEvent2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdResetQueryPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdResolveImage(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdResolveImage2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetAlphaToCoverageEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetAlphaToOneEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetAttachmentFeedbackLoopEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetBlendConstants(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetColorBlendAdvancedEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetColorBlendEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetColorBlendEquationEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetColorWriteEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetColorWriteMaskEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetConservativeRasterizationModeEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetCullMode(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthBias(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthBias2EXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthBiasEnable(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthBounds(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthBoundsTestEnable(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthClampEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthClampRangeEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthClipEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthClipNegativeOneToOneEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthCompareOp(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthTestEnable(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDepthWriteEnable(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDeviceMask(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDiscardRectangleEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDiscardRectangleEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetDiscardRectangleModeEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetEvent(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetEvent2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetExtraPrimitiveOverestimationSizeEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetFragmentShadingRateKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetFrontFace(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetLineRasterizationModeEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetLineStipple(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetLineStippleEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetLineWidth(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetLogicOpEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetLogicOpEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetPatchControlPointsEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetPolygonModeEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetPrimitiveRestartEnable(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetPrimitiveTopology(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetProvokingVertexModeEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetRasterizationSamplesEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetRasterizationStreamEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetRasterizerDiscardEnable(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetRenderingAttachmentLocations(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetRenderingInputAttachmentIndices(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetSampleLocationsEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetSampleLocationsEnableEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetSampleMaskEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetScissor(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetScissorWithCount(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetStencilCompareMask(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetStencilOp(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetStencilReference(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetStencilTestEnable(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetStencilWriteMask(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetTessellationDomainOriginEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetVertexInputEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetViewport(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdSetViewportWithCount(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdUpdateBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdWaitEvents(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdWaitEvents2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdWriteTimestamp(vkb_srv_call *c);
|
||||
void vkb_sv_vkCmdWriteTimestamp2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateBufferView(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateCommandPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateComputePipelines(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateDescriptorPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateDescriptorSetLayout(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateDescriptorUpdateTemplate(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateDevice(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateEvent(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateFence(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateFramebuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateGraphicsPipelines(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateImage(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateImageView(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateInstance(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreatePipelineCache(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreatePipelineLayout(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateQueryPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateRenderPass(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateRenderPass2(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateSampler(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateSamplerYcbcrConversion(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateSemaphore(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateShaderModule(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateTensorARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkCreateTensorViewARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyBufferView(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyCommandPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyDescriptorPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyDescriptorSetLayout(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyDescriptorUpdateTemplate(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyDevice(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyEvent(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyFence(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyFramebuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyImage(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyImageView(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyInstance(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyPipeline(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyPipelineCache(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyPipelineLayout(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyQueryPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyRenderPass(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroySampler(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroySamplerYcbcrConversion(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroySemaphore(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyShaderModule(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyTensorARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkDestroyTensorViewARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkDeviceWaitIdle(vkb_srv_call *c);
|
||||
void vkb_sv_vkEndCommandBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkEnumerateDeviceExtensionProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkEnumerateInstanceExtensionProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkEnumerateInstanceLayerProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkEnumerateInstanceVersion(vkb_srv_call *c);
|
||||
void vkb_sv_vkEnumeratePhysicalDeviceGroups(vkb_srv_call *c);
|
||||
void vkb_sv_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkEnumeratePhysicalDevices(vkb_srv_call *c);
|
||||
void vkb_sv_vkFlushMappedMemoryRanges(vkb_srv_call *c);
|
||||
void vkb_sv_vkFreeCommandBuffers(vkb_srv_call *c);
|
||||
void vkb_sv_vkFreeDescriptorSets(vkb_srv_call *c);
|
||||
void vkb_sv_vkFreeMemory(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetBufferDeviceAddress(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetBufferMemoryRequirements(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetBufferMemoryRequirements2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetBufferOpaqueCaptureAddress(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetCalibratedTimestampsKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDescriptorSetLayoutSupport(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceBufferMemoryRequirements(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceGroupPeerMemoryFeatures(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceImageMemoryRequirements(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceImageSparseMemoryRequirements(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceImageSubresourceLayout(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceMemoryCommitment(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceMemoryOpaqueCaptureAddress(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceQueue(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceQueue2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetDeviceTensorMemoryRequirementsARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetEventStatus(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetFenceFdKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetFenceStatus(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetImageDrmFormatModifierPropertiesEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetImageMemoryRequirements(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetImageMemoryRequirements2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetImageSparseMemoryRequirements(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetImageSparseMemoryRequirements2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetImageSubresourceLayout(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetImageSubresourceLayout2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetMemoryFdKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetMemoryFdPropertiesKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceExternalBufferProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceExternalFenceProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceExternalSemaphoreProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceExternalTensorPropertiesARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceFeatures(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceFeatures2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceFormatProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceFormatProperties2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceFragmentShadingRatesKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceImageFormatProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceImageFormatProperties2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceMemoryProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceMemoryProperties2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceMultisamplePropertiesEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceProperties2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceQueueFamilyProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceQueueFamilyProperties2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceSparseImageFormatProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceSparseImageFormatProperties2(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPhysicalDeviceToolProperties(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetPipelineCacheData(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetQueryPoolResults(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetRenderAreaGranularity(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetRenderingAreaGranularity(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetSemaphoreCounterValue(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetSemaphoreFdKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetShaderModuleCreateInfoIdentifierEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetShaderModuleIdentifierEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkGetTensorMemoryRequirementsARM(vkb_srv_call *c);
|
||||
void vkb_sv_vkImportFenceFdKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkImportSemaphoreFdKHR(vkb_srv_call *c);
|
||||
void vkb_sv_vkInvalidateMappedMemoryRanges(vkb_srv_call *c);
|
||||
void vkb_sv_vkMergePipelineCaches(vkb_srv_call *c);
|
||||
void vkb_sv_vkQueueBindSparse(vkb_srv_call *c);
|
||||
void vkb_sv_vkQueueSubmit(vkb_srv_call *c);
|
||||
void vkb_sv_vkQueueSubmit2(vkb_srv_call *c);
|
||||
void vkb_sv_vkQueueWaitIdle(vkb_srv_call *c);
|
||||
void vkb_sv_vkResetCommandBuffer(vkb_srv_call *c);
|
||||
void vkb_sv_vkResetCommandPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkResetDescriptorPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkResetEvent(vkb_srv_call *c);
|
||||
void vkb_sv_vkResetFences(vkb_srv_call *c);
|
||||
void vkb_sv_vkResetQueryPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkSetDeviceMemoryPriorityEXT(vkb_srv_call *c);
|
||||
void vkb_sv_vkSetEvent(vkb_srv_call *c);
|
||||
void vkb_sv_vkSignalSemaphore(vkb_srv_call *c);
|
||||
void vkb_sv_vkTrimCommandPool(vkb_srv_call *c);
|
||||
void vkb_sv_vkUpdateDescriptorSets(vkb_srv_call *c);
|
||||
void vkb_sv_vkWaitForFences(vkb_srv_call *c);
|
||||
void vkb_sv_vkWaitSemaphores(vkb_srv_call *c);
|
||||
void vkb_sv_vkbHello(vkb_srv_call *c);
|
||||
void vkb_sv_vkbQueryServer(vkb_srv_call *c);
|
||||
void vkb_sv_vkbDescUpdateRaw(vkb_srv_call *c);
|
||||
void vkb_sv_vkbPushDescRaw(vkb_srv_call *c);
|
||||
void vkb_sv_vkbAllocDescSets(vkb_srv_call *c);
|
||||
#endif
|
||||
@@ -0,0 +1,71 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* BCn emulation: what each block-compressed format is decoded into. Shared by the client (format
|
||||
* queries) and the server (image creation, decode). The decoded image is created with the UNORM
|
||||
* base format and MUTABLE_FORMAT so the decoder can write it through a storage view, and the
|
||||
* app's sRGB views still work.
|
||||
*/
|
||||
#ifndef VKB_EMU_FORMATS_H
|
||||
#define VKB_EMU_FORMATS_H
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
static inline int vkb_is_bc(VkFormat f)
|
||||
{
|
||||
return f >= VK_FORMAT_BC1_RGB_UNORM_BLOCK && f <= VK_FORMAT_BC7_SRGB_BLOCK;
|
||||
}
|
||||
|
||||
/* The format an app's view of a BC format becomes (keeps sRGB/SNORM meaning). */
|
||||
static inline VkFormat vkb_bc_view_format(VkFormat f)
|
||||
{
|
||||
switch (f) {
|
||||
case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
|
||||
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
|
||||
case VK_FORMAT_BC2_UNORM_BLOCK:
|
||||
case VK_FORMAT_BC3_UNORM_BLOCK:
|
||||
case VK_FORMAT_BC7_UNORM_BLOCK: return VK_FORMAT_R8G8B8A8_UNORM;
|
||||
case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
|
||||
case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
|
||||
case VK_FORMAT_BC2_SRGB_BLOCK:
|
||||
case VK_FORMAT_BC3_SRGB_BLOCK:
|
||||
case VK_FORMAT_BC7_SRGB_BLOCK: return VK_FORMAT_R8G8B8A8_SRGB;
|
||||
case VK_FORMAT_BC4_UNORM_BLOCK: return VK_FORMAT_R8_UNORM;
|
||||
case VK_FORMAT_BC4_SNORM_BLOCK: return VK_FORMAT_R8_SNORM;
|
||||
case VK_FORMAT_BC5_UNORM_BLOCK: return VK_FORMAT_R8G8_UNORM;
|
||||
case VK_FORMAT_BC5_SNORM_BLOCK: return VK_FORMAT_R8G8_SNORM;
|
||||
case VK_FORMAT_BC6H_UFLOAT_BLOCK:
|
||||
case VK_FORMAT_BC6H_SFLOAT_BLOCK: return VK_FORMAT_R16G16B16A16_SFLOAT;
|
||||
default: return f;
|
||||
}
|
||||
}
|
||||
|
||||
/* The format the decoded image is created with and written through (storage-capable). */
|
||||
static inline VkFormat vkb_bc_storage_format(VkFormat f)
|
||||
{
|
||||
switch (vkb_bc_view_format(f)) {
|
||||
case VK_FORMAT_R8G8B8A8_SRGB:
|
||||
case VK_FORMAT_R8G8B8A8_UNORM: return VK_FORMAT_R8G8B8A8_UNORM;
|
||||
case VK_FORMAT_R8_SNORM:
|
||||
case VK_FORMAT_R8_UNORM: return VK_FORMAT_R8_UNORM;
|
||||
case VK_FORMAT_R8G8_SNORM:
|
||||
case VK_FORMAT_R8G8_UNORM: return VK_FORMAT_R8G8_UNORM;
|
||||
case VK_FORMAT_R16G16B16A16_SFLOAT: return VK_FORMAT_R16G16B16A16_SFLOAT;
|
||||
default: return f;
|
||||
}
|
||||
}
|
||||
|
||||
/* Bytes per 4x4 block. */
|
||||
static inline uint32_t vkb_bc_block_bytes(VkFormat f)
|
||||
{
|
||||
switch (f) {
|
||||
case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
|
||||
case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
|
||||
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
|
||||
case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
|
||||
case VK_FORMAT_BC4_UNORM_BLOCK:
|
||||
case VK_FORMAT_BC4_SNORM_BLOCK: return 8;
|
||||
default: return 16;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,24 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later */
|
||||
#ifndef VKB_LOG_H
|
||||
#define VKB_LOG_H
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#define VKB_LOG_ERROR 0
|
||||
#define VKB_LOG_WARN 1
|
||||
#define VKB_LOG_INFO 2
|
||||
#define VKB_LOG_DEBUG 3
|
||||
|
||||
/* Each side provides the sink (client: stderr + optional file; server: logcat + file). */
|
||||
void vkb_log(int level, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
|
||||
int vkb_log_level(void);
|
||||
|
||||
#define VKB_ERR(...) vkb_log(VKB_LOG_ERROR, __VA_ARGS__)
|
||||
#define VKB_WARN(...) vkb_log(VKB_LOG_WARN, __VA_ARGS__)
|
||||
#define VKB_INFO(...) vkb_log(VKB_LOG_INFO, __VA_ARGS__)
|
||||
#define VKB_DBG(...) do { if (vkb_log_level() >= VKB_LOG_DEBUG) vkb_log(VKB_LOG_DEBUG, __VA_ARGS__); } while (0)
|
||||
|
||||
/* Logs a message only the first time this call site is reached. */
|
||||
#define VKB_ONCE(level, ...) do { static int once_; if (!__atomic_exchange_n(&once_, 1, __ATOMIC_RELAXED)) vkb_log(level, __VA_ARGS__); } while (0)
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,63 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Bridge-specific (non-Vulkan) parts of the protocol: hello, server query, memory sharing.
|
||||
*/
|
||||
#ifndef VKB_PROTO_H
|
||||
#define VKB_PROTO_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#define VKB_DEFAULT_SOCKET_ENV "VKBRIDGE_SOCKET"
|
||||
|
||||
/* How host-visible memory is shared between the client's address space and the GPU. */
|
||||
enum vkb_mem_strategy {
|
||||
VKB_MEM_NONE = 0, /* no sharing works: host-visible memory is not offered */
|
||||
VKB_MEM_HOSTPTR = 1, /* client memfd, server imports it (VK_EXT_external_memory_host) */
|
||||
VKB_MEM_DMABUF = 2, /* server exports a dma-buf (VK_EXT_external_memory_dma_buf), client mmaps */
|
||||
VKB_MEM_AHB = 3, /* server allocates an AHardwareBuffer (BLOB), client mmaps its dma-buf */
|
||||
VKB_MEM_DMAHEAP = 4, /* server allocates from /dev/dma_heap and imports it as a dma-buf, client mmaps */
|
||||
};
|
||||
|
||||
static inline const char *vkb_mem_strategy_name(uint32_t s)
|
||||
{
|
||||
switch (s) {
|
||||
case VKB_MEM_HOSTPTR: return "hostptr";
|
||||
case VKB_MEM_DMABUF: return "dmabuf";
|
||||
case VKB_MEM_AHB: return "ahb";
|
||||
case VKB_MEM_DMAHEAP: return "dmaheap";
|
||||
default: return "none";
|
||||
}
|
||||
}
|
||||
|
||||
/* Emulated features (server rewrites resources/shaders; client reports them as supported). */
|
||||
#define VKB_EMU_BCN (1u << 0) /* BC1-BC7 textures decoded on upload */
|
||||
#define VKB_EMU_DIVISOR (1u << 1) /* VK_EXT_vertex_attribute_divisor */
|
||||
#define VKB_EMU_CLIP_DISTANCE (1u << 2) /* shaderClipDistance */
|
||||
#define VKB_EMU_CULL_DISTANCE (1u << 3) /* shaderCullDistance (accepted, not applied) */
|
||||
#define VKB_EMU_POINT_SIZE (1u << 4) /* strip PointSize from geometry/tessellation stages */
|
||||
#define VKB_EMU_DEPTH_CLIP (1u << 5) /* VK_EXT_depth_clip_enable via depthClamp */
|
||||
#define VKB_EMU_MAINT5 (1u << 6) /* VK_KHR_maintenance5 on a driver without it */
|
||||
#define VKB_EMU_ROBUSTNESS2 (1u << 7) /* VK_EXT_robustness2 reported, not enforced (GameNative's r44 profile) */
|
||||
|
||||
/* vkbQueryServer reply (per physical device). */
|
||||
typedef struct vkb_server_pd_info {
|
||||
uint32_t strategy; /* enum vkb_mem_strategy */
|
||||
uint32_t buffer_handle_types; /* VkExternalMemoryHandleTypeFlags to put on buffers */
|
||||
uint32_t shareable_types; /* server memory type bits that can be shared */
|
||||
uint32_t coherent_types; /* of those, verified coherent without flushes */
|
||||
uint64_t import_alignment; /* hostptr: minImportedHostPointerAlignment */
|
||||
uint32_t emu; /* VKB_EMU_* the server will perform */
|
||||
uint32_t emu_available; /* VKB_EMU_* the server could perform */
|
||||
uint32_t real_api_version;
|
||||
uint32_t missing; /* VKB_EMU_* features the GPU lacks (emulated or not) */
|
||||
uint32_t reserved[6];
|
||||
} vkb_server_pd_info;
|
||||
|
||||
/* vkAllocateMemory wire extras (after VkMemoryAllocateInfo). */
|
||||
#define VKB_ALLOC_PLAIN 0u
|
||||
#define VKB_ALLOC_SHARED 1u
|
||||
|
||||
/* Extra structure the client hangs on create infos to tell the server which shared handle
|
||||
* types were injected (so the server can remove them if the driver refuses). Not on the wire. */
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,29 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* What the generated server handlers need from the server: the per-call context.
|
||||
*/
|
||||
#ifndef VKB_SERVER_IFACE_H
|
||||
#define VKB_SERVER_IFACE_H
|
||||
|
||||
#include "vkb_wire.h"
|
||||
|
||||
struct vkb_srv_table;
|
||||
struct vkb_srv_conn;
|
||||
|
||||
struct vkb_srv_call {
|
||||
vkb_dec d; /* request */
|
||||
vkb_enc r; /* reply payload */
|
||||
vkb_dispatch *dt; /* dispatch for the table named in the request */
|
||||
struct vkb_srv_table *table; /* NULL for global commands */
|
||||
struct vkb_srv_conn *conn;
|
||||
uint32_t status; /* reply status (VKB_ST_*) */
|
||||
int close_after[VKB_MAX_FDS]; /* server fds to close once the reply is sent */
|
||||
int nclose;
|
||||
int in_stream; /* replaying a command buffer stream */
|
||||
};
|
||||
|
||||
void vkb_srv_bad_message(struct vkb_srv_call *c);
|
||||
void vkb_srv_missing(struct vkb_srv_call *c, const char *name);
|
||||
void vkb_srv_close_after_send(struct vkb_srv_call *c, int fd);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,710 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later */
|
||||
#include "vkb_wire.h"
|
||||
#include "vkb_log.h"
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/uio.h>
|
||||
#include <unistd.h>
|
||||
|
||||
/* ------------------------------------------------------------------ arena */
|
||||
|
||||
struct vkb_arena_block {
|
||||
vkb_arena_block *next;
|
||||
size_t used, cap;
|
||||
/* data follows, 16-aligned */
|
||||
};
|
||||
|
||||
#define ARENA_HDR ((sizeof(vkb_arena_block) + 15) & ~(size_t)15)
|
||||
|
||||
void *vkb_arena_alloc(vkb_arena *a, size_t n)
|
||||
{
|
||||
n = (n + 15) & ~(size_t)15;
|
||||
if (n == 0) n = 16;
|
||||
vkb_arena_block *b = a->head;
|
||||
if (!b || b->cap - b->used < n) {
|
||||
size_t cap = n > 65536 ? n : 65536;
|
||||
b = malloc(ARENA_HDR + cap);
|
||||
if (!b) return NULL;
|
||||
b->next = a->head;
|
||||
b->used = 0;
|
||||
b->cap = cap;
|
||||
a->head = b;
|
||||
}
|
||||
void *p = (uint8_t *)b + ARENA_HDR + b->used;
|
||||
b->used += n;
|
||||
a->used_total += n;
|
||||
memset(p, 0, n);
|
||||
return p;
|
||||
}
|
||||
|
||||
void vkb_arena_reset(vkb_arena *a)
|
||||
{
|
||||
/* Keep the most recent block if it is the default size; free the rest. */
|
||||
vkb_arena_block *b = a->head, *keep = NULL;
|
||||
while (b) {
|
||||
vkb_arena_block *n = b->next;
|
||||
if (!keep && b->cap == 65536) {
|
||||
keep = b;
|
||||
keep->next = NULL;
|
||||
keep->used = 0;
|
||||
} else {
|
||||
free(b);
|
||||
}
|
||||
b = n;
|
||||
}
|
||||
a->head = keep;
|
||||
a->used_total = 0;
|
||||
}
|
||||
|
||||
void vkb_arena_free(vkb_arena *a)
|
||||
{
|
||||
vkb_arena_block *b = a->head;
|
||||
while (b) {
|
||||
vkb_arena_block *n = b->next;
|
||||
free(b);
|
||||
b = n;
|
||||
}
|
||||
a->head = NULL;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ encoder */
|
||||
|
||||
void vkb_enc_init(vkb_enc *e)
|
||||
{
|
||||
memset(e, 0, sizeof(*e));
|
||||
}
|
||||
|
||||
void vkb_enc_reset(vkb_enc *e)
|
||||
{
|
||||
e->len = 0;
|
||||
e->nfds = 0;
|
||||
e->oom = 0;
|
||||
}
|
||||
|
||||
void vkb_enc_free(vkb_enc *e)
|
||||
{
|
||||
free(e->buf);
|
||||
memset(e, 0, sizeof(*e));
|
||||
}
|
||||
|
||||
static int enc_grow(vkb_enc *e, size_t add)
|
||||
{
|
||||
if (e->oom) return 0;
|
||||
size_t need = e->len + add;
|
||||
if (need <= e->cap) return 1;
|
||||
size_t cap = e->cap ? e->cap : 4096;
|
||||
while (cap < need) cap *= 2;
|
||||
uint8_t *nb = realloc(e->buf, cap);
|
||||
if (!nb) {
|
||||
e->oom = 1;
|
||||
return 0;
|
||||
}
|
||||
e->buf = nb;
|
||||
e->cap = cap;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void vkb_enc_bytes(vkb_enc *e, const void *p, size_t n)
|
||||
{
|
||||
if (!n || !enc_grow(e, n)) return;
|
||||
if (p) memcpy(e->buf + e->len, p, n);
|
||||
else memset(e->buf + e->len, 0, n);
|
||||
e->len += n;
|
||||
}
|
||||
|
||||
void vkb_enc_u8(vkb_enc *e, uint8_t v) { vkb_enc_bytes(e, &v, 1); }
|
||||
void vkb_enc_u32(vkb_enc *e, uint32_t v) { vkb_enc_bytes(e, &v, 4); }
|
||||
void vkb_enc_u64(vkb_enc *e, uint64_t v) { vkb_enc_bytes(e, &v, 8); }
|
||||
|
||||
static void enc_align(vkb_enc *e)
|
||||
{
|
||||
size_t pad = (8 - (e->len & 7)) & 7;
|
||||
if (pad) vkb_enc_bytes(e, NULL, pad);
|
||||
}
|
||||
|
||||
size_t vkb_enc_raw(vkb_enc *e, const void *p, size_t n)
|
||||
{
|
||||
enc_align(e);
|
||||
size_t off = e->len;
|
||||
vkb_enc_bytes(e, p, n);
|
||||
return off;
|
||||
}
|
||||
|
||||
void vkb_enc_patch_u64(vkb_enc *e, size_t off, uint64_t v)
|
||||
{
|
||||
if (e->oom || off + 8 > e->len) return;
|
||||
memcpy(e->buf + off, &v, 8);
|
||||
}
|
||||
|
||||
void vkb_enc_str(vkb_enc *e, const char *s)
|
||||
{
|
||||
if (!s) {
|
||||
vkb_enc_u8(e, 0);
|
||||
return;
|
||||
}
|
||||
uint32_t n = (uint32_t)strlen(s);
|
||||
vkb_enc_u8(e, 1);
|
||||
vkb_enc_u32(e, n);
|
||||
vkb_enc_bytes(e, s, n);
|
||||
}
|
||||
|
||||
void vkb_enc_strarray(vkb_enc *e, const char *const *a, uint32_t n)
|
||||
{
|
||||
if (!a) {
|
||||
vkb_enc_u8(e, 0);
|
||||
return;
|
||||
}
|
||||
vkb_enc_u8(e, 1);
|
||||
vkb_enc_u32(e, n);
|
||||
for (uint32_t i = 0; i < n; i++) vkb_enc_str(e, a[i]);
|
||||
}
|
||||
|
||||
void vkb_enc_blob(vkb_enc *e, const void *p, size_t n)
|
||||
{
|
||||
if (!p) {
|
||||
vkb_enc_u8(e, 0);
|
||||
return;
|
||||
}
|
||||
vkb_enc_u8(e, 1);
|
||||
vkb_enc_u64(e, n);
|
||||
vkb_enc_raw(e, p, n);
|
||||
}
|
||||
|
||||
void vkb_enc_fd(vkb_enc *e, int fd)
|
||||
{
|
||||
if (fd < 0) {
|
||||
vkb_enc_u32(e, VKB_FD_NONE);
|
||||
return;
|
||||
}
|
||||
if (e->nfds >= VKB_MAX_FDS) {
|
||||
VKB_ERR("too many file descriptors in one message");
|
||||
e->oom = 1;
|
||||
return;
|
||||
}
|
||||
e->fds[e->nfds] = fd;
|
||||
vkb_enc_u32(e, (uint32_t)e->nfds);
|
||||
e->nfds++;
|
||||
}
|
||||
|
||||
void vkb_enc_append(vkb_enc *e, const vkb_enc *src)
|
||||
{
|
||||
enc_align(e);
|
||||
/* fd indices inside src are relative to src; a stream that carries fds is not appendable. */
|
||||
if (src->nfds) {
|
||||
VKB_ERR("internal: appending a message that carries file descriptors");
|
||||
e->oom = 1;
|
||||
return;
|
||||
}
|
||||
vkb_enc_bytes(e, src->buf, src->len);
|
||||
}
|
||||
|
||||
static const VkBaseInStructure *next_known(const void *p)
|
||||
{
|
||||
const VkBaseInStructure *b = p;
|
||||
while (b) {
|
||||
if (vkb_struct_size(b->sType)) return b;
|
||||
VKB_ONCE(VKB_LOG_WARN, "pNext: structure type %d is not bridged; dropped (logged once)", (int)b->sType);
|
||||
b = b->pNext;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void vkb_enc_chain(vkb_enc *e, const void *pNext)
|
||||
{
|
||||
const VkBaseInStructure *b = next_known(pNext);
|
||||
if (!b) {
|
||||
vkb_enc_u32(e, VKB_CHAIN_END);
|
||||
return;
|
||||
}
|
||||
vkb_enc_u32(e, (uint32_t)b->sType);
|
||||
vkb_enc_chain_elem(e, b);
|
||||
}
|
||||
|
||||
/* Out-structs that carry caller-provided arrays (the two-call idiom inside a struct). An
|
||||
* "empty" one is always answered with no elements (its elements carry chains of their own). */
|
||||
typedef struct out_arr {
|
||||
VkStructureType t;
|
||||
size_t count_off, ptr_off, elem;
|
||||
int empty;
|
||||
} out_arr;
|
||||
|
||||
#define OA(T, ST, CNT, PTR, ELEM, EMPTY) {ST, offsetof(T, CNT), offsetof(T, PTR), sizeof(ELEM), EMPTY}
|
||||
static const out_arr out_arrays[] = {
|
||||
OA(VkDrmFormatModifierPropertiesListEXT, VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
|
||||
drmFormatModifierCount, pDrmFormatModifierProperties, VkDrmFormatModifierPropertiesEXT, 0),
|
||||
OA(VkDrmFormatModifierPropertiesList2EXT, VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT,
|
||||
drmFormatModifierCount, pDrmFormatModifierProperties, VkDrmFormatModifierProperties2EXT, 0),
|
||||
OA(VkPhysicalDeviceVulkan14Properties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES,
|
||||
copySrcLayoutCount, pCopySrcLayouts, VkImageLayout, 0),
|
||||
OA(VkPhysicalDeviceVulkan14Properties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES,
|
||||
copyDstLayoutCount, pCopyDstLayouts, VkImageLayout, 0),
|
||||
OA(VkPhysicalDeviceHostImageCopyProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES,
|
||||
copySrcLayoutCount, pCopySrcLayouts, VkImageLayout, 0),
|
||||
OA(VkPhysicalDeviceHostImageCopyProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES,
|
||||
copyDstLayoutCount, pCopyDstLayouts, VkImageLayout, 0),
|
||||
OA(VkPhysicalDeviceLayeredApiPropertiesListKHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR,
|
||||
layeredApiCount, pLayeredApis, VkPhysicalDeviceLayeredApiPropertiesKHR, 1),
|
||||
};
|
||||
#undef OA
|
||||
#define N_OUT_ARRAYS (sizeof(out_arrays) / sizeof(out_arrays[0]))
|
||||
|
||||
static uint32_t rd32(const void *base, size_t off) { uint32_t v; memcpy(&v, (const uint8_t *)base + off, 4); return v; }
|
||||
static void wr32(void *base, size_t off, uint32_t v) { memcpy((uint8_t *)base + off, &v, 4); }
|
||||
static void *rdp(const void *base, size_t off) { void *v; memcpy(&v, (const uint8_t *)base + off, sizeof(v)); return v; }
|
||||
static void wrp(void *base, size_t off, void *v) { memcpy((uint8_t *)base + off, &v, sizeof(v)); }
|
||||
|
||||
static const VkBaseInStructure *next_known_out(const void *p)
|
||||
{
|
||||
const VkBaseInStructure *b = p;
|
||||
while (b) {
|
||||
if (vkb_struct_size(b->sType)) return b;
|
||||
VKB_ONCE(VKB_LOG_WARN, "output pNext: structure type %d is not bridged; left unfilled (logged once)", (int)b->sType);
|
||||
b = b->pNext;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void vkb_enc_out_template(vkb_enc *e, const void *s, size_t size)
|
||||
{
|
||||
vkb_enc_raw(e, s, size);
|
||||
const VkBaseInStructure *b = next_known_out(((const VkBaseInStructure *)s)->pNext);
|
||||
while (b) {
|
||||
size_t sz = vkb_struct_size(b->sType);
|
||||
vkb_enc_u32(e, (uint32_t)b->sType);
|
||||
vkb_enc_raw(e, b, sz);
|
||||
for (size_t i = 0; i < N_OUT_ARRAYS; i++)
|
||||
if (out_arrays[i].t == b->sType) vkb_enc_u8(e, !out_arrays[i].empty && rdp(b, out_arrays[i].ptr_off) != NULL);
|
||||
b = next_known_out(b->pNext);
|
||||
}
|
||||
vkb_enc_u32(e, VKB_CHAIN_END);
|
||||
}
|
||||
|
||||
void vkb_enc_out_struct(vkb_enc *e, const void *s, size_t size)
|
||||
{
|
||||
vkb_enc_raw(e, s, size);
|
||||
const VkBaseInStructure *b = ((const VkBaseInStructure *)s)->pNext;
|
||||
for (; b; b = b->pNext) {
|
||||
size_t sz = vkb_struct_size(b->sType);
|
||||
if (!sz) continue;
|
||||
vkb_enc_u32(e, (uint32_t)b->sType);
|
||||
vkb_enc_raw(e, b, sz);
|
||||
for (size_t i = 0; i < N_OUT_ARRAYS; i++) {
|
||||
const out_arr *oa = &out_arrays[i];
|
||||
if (oa->t != b->sType) continue;
|
||||
const void *arr = rdp(b, oa->ptr_off);
|
||||
vkb_enc_u8(e, arr != NULL);
|
||||
if (arr) {
|
||||
uint32_t n = rd32(b, oa->count_off);
|
||||
vkb_enc_u32(e, n);
|
||||
vkb_enc_raw(e, arr, (size_t)n * oa->elem);
|
||||
}
|
||||
}
|
||||
}
|
||||
vkb_enc_u32(e, VKB_CHAIN_END);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ decoder */
|
||||
|
||||
void vkb_dec_init(vkb_dec *d, const void *buf, size_t len, vkb_arena *a, int *fds, int nfds)
|
||||
{
|
||||
memset(d, 0, sizeof(*d));
|
||||
d->buf = buf;
|
||||
d->len = len;
|
||||
d->arena = a;
|
||||
d->fds = fds;
|
||||
d->nfds = nfds;
|
||||
}
|
||||
|
||||
void vkb_dec_bytes(vkb_dec *d, void *dst, size_t n)
|
||||
{
|
||||
if (d->err || d->len - d->pos < n) {
|
||||
d->err = 1;
|
||||
if (dst) memset(dst, 0, n);
|
||||
return;
|
||||
}
|
||||
if (dst) memcpy(dst, d->buf + d->pos, n);
|
||||
d->pos += n;
|
||||
}
|
||||
|
||||
uint8_t vkb_dec_u8(vkb_dec *d) { uint8_t v; vkb_dec_bytes(d, &v, 1); return v; }
|
||||
uint32_t vkb_dec_u32(vkb_dec *d) { uint32_t v; vkb_dec_bytes(d, &v, 4); return v; }
|
||||
uint64_t vkb_dec_u64(vkb_dec *d) { uint64_t v; vkb_dec_bytes(d, &v, 8); return v; }
|
||||
|
||||
static void dec_align(vkb_dec *d)
|
||||
{
|
||||
size_t pad = (8 - (d->pos & 7)) & 7;
|
||||
if (d->len - d->pos < pad) {
|
||||
d->err = 1;
|
||||
return;
|
||||
}
|
||||
d->pos += pad;
|
||||
}
|
||||
|
||||
void vkb_dec_raw_into(vkb_dec *d, void *dst, size_t n)
|
||||
{
|
||||
dec_align(d);
|
||||
vkb_dec_bytes(d, dst, n);
|
||||
}
|
||||
|
||||
const void *vkb_dec_raw_view(vkb_dec *d, size_t n)
|
||||
{
|
||||
dec_align(d);
|
||||
if (d->err || d->len - d->pos < n) {
|
||||
d->err = 1;
|
||||
return NULL;
|
||||
}
|
||||
const void *p = d->buf + d->pos;
|
||||
d->pos += n;
|
||||
return p;
|
||||
}
|
||||
|
||||
void *vkb_dec_alloc(vkb_dec *d, size_t n)
|
||||
{
|
||||
if (d->err) return NULL;
|
||||
if (n > ((size_t)1 << 32)) {
|
||||
d->err = 1;
|
||||
return NULL;
|
||||
}
|
||||
void *p = vkb_arena_alloc(d->arena, n);
|
||||
if (!p) d->err = 1;
|
||||
return p;
|
||||
}
|
||||
|
||||
void *vkb_dec_alloc_zero(vkb_dec *d, size_t n) { return vkb_dec_alloc(d, n); }
|
||||
|
||||
const char *vkb_dec_str(vkb_dec *d)
|
||||
{
|
||||
if (!vkb_dec_u8(d)) return NULL;
|
||||
uint32_t n = vkb_dec_u32(d);
|
||||
if (d->err || d->len - d->pos < n) {
|
||||
d->err = 1;
|
||||
return NULL;
|
||||
}
|
||||
char *s = vkb_dec_alloc(d, (size_t)n + 1);
|
||||
if (!s) return NULL;
|
||||
memcpy(s, d->buf + d->pos, n);
|
||||
s[n] = 0;
|
||||
d->pos += n;
|
||||
return s;
|
||||
}
|
||||
|
||||
const char *const *vkb_dec_strarray(vkb_dec *d)
|
||||
{
|
||||
if (!vkb_dec_u8(d)) return NULL;
|
||||
uint32_t n = vkb_dec_u32(d);
|
||||
if (d->err || n > (d->len - d->pos)) {
|
||||
d->err = 1;
|
||||
return NULL;
|
||||
}
|
||||
const char **a = vkb_dec_alloc(d, (size_t)(n ? n : 1) * sizeof(char *));
|
||||
for (uint32_t i = 0; a && i < n; i++) a[i] = vkb_dec_str(d);
|
||||
return a;
|
||||
}
|
||||
|
||||
const void *vkb_dec_blob(vkb_dec *d, size_t *n)
|
||||
{
|
||||
if (!vkb_dec_u8(d)) {
|
||||
if (n) *n = 0;
|
||||
return NULL;
|
||||
}
|
||||
uint64_t sz = vkb_dec_u64(d);
|
||||
if (n) *n = (size_t)sz;
|
||||
return vkb_dec_raw_view(d, (size_t)sz);
|
||||
}
|
||||
|
||||
void vkb_dec_blob_into(vkb_dec *d, void *dst, size_t cap)
|
||||
{
|
||||
size_t n = 0;
|
||||
const void *p = vkb_dec_blob(d, &n);
|
||||
if (p && dst) memcpy(dst, p, n < cap ? n : cap);
|
||||
}
|
||||
|
||||
int vkb_dec_fd(vkb_dec *d)
|
||||
{
|
||||
uint32_t i = vkb_dec_u32(d);
|
||||
if (i == VKB_FD_NONE || d->err) return -1;
|
||||
if ((int)i >= d->nfds || (d->fd_taken & (1u << i))) {
|
||||
d->err = 1;
|
||||
return -1;
|
||||
}
|
||||
d->fd_taken |= 1u << i;
|
||||
return d->fds[i];
|
||||
}
|
||||
|
||||
void vkb_dec_close_untaken(vkb_dec *d)
|
||||
{
|
||||
for (int i = 0; i < d->nfds; i++) {
|
||||
if (!(d->fd_taken & (1u << i)) && d->fds[i] >= 0) close(d->fds[i]);
|
||||
}
|
||||
d->fd_taken = 0xffffffffu;
|
||||
}
|
||||
|
||||
const void *vkb_dec_chain(vkb_dec *d)
|
||||
{
|
||||
uint32_t t = vkb_dec_u32(d);
|
||||
if (d->err || t == VKB_CHAIN_END) return NULL;
|
||||
size_t sz = vkb_struct_size((VkStructureType)t);
|
||||
if (!sz) {
|
||||
VKB_ERR("protocol: unknown structure type %u in a chain", t);
|
||||
d->err = 1;
|
||||
return NULL;
|
||||
}
|
||||
void *p = vkb_dec_alloc(d, sz);
|
||||
if (!p) return NULL;
|
||||
vkb_dec_chain_elem(d, (VkStructureType)t, p);
|
||||
return p;
|
||||
}
|
||||
|
||||
void vkb_dec_out_template(vkb_dec *d, void *dst, size_t size)
|
||||
{
|
||||
vkb_dec_raw_into(d, dst, size);
|
||||
VkBaseOutStructure *prev = dst;
|
||||
prev->pNext = NULL;
|
||||
for (;;) {
|
||||
uint32_t t = vkb_dec_u32(d);
|
||||
if (d->err || t == VKB_CHAIN_END) break;
|
||||
size_t sz = vkb_struct_size((VkStructureType)t);
|
||||
if (!sz) {
|
||||
d->err = 1;
|
||||
break;
|
||||
}
|
||||
VkBaseOutStructure *el = vkb_dec_alloc(d, sz);
|
||||
if (!el) break;
|
||||
vkb_dec_raw_into(d, el, sz);
|
||||
el->pNext = NULL;
|
||||
for (size_t i = 0; i < N_OUT_ARRAYS; i++) {
|
||||
const out_arr *oa = &out_arrays[i];
|
||||
if (oa->t != (VkStructureType)t) continue;
|
||||
void *arr = NULL;
|
||||
if (vkb_dec_u8(d)) {
|
||||
uint32_t n = rd32(el, oa->count_off);
|
||||
arr = vkb_dec_alloc(d, (size_t)(n ? n : 1) * oa->elem);
|
||||
} else {
|
||||
wr32(el, oa->count_off, 0);
|
||||
}
|
||||
wrp(el, oa->ptr_off, arr);
|
||||
}
|
||||
prev->pNext = el;
|
||||
prev = el;
|
||||
}
|
||||
}
|
||||
|
||||
void vkb_dec_out_struct(vkb_dec *d, void *dst, size_t size)
|
||||
{
|
||||
VkBaseOutStructure *top = dst;
|
||||
VkBaseOutStructure *keep = top->pNext;
|
||||
vkb_dec_raw_into(d, dst, size);
|
||||
top->pNext = keep;
|
||||
VkBaseOutStructure *app = (VkBaseOutStructure *)next_known_out(keep);
|
||||
for (;;) {
|
||||
uint32_t t = vkb_dec_u32(d);
|
||||
if (d->err || t == VKB_CHAIN_END) break;
|
||||
size_t sz = vkb_struct_size((VkStructureType)t);
|
||||
const uint8_t *src = vkb_dec_raw_view(d, sz);
|
||||
if (!src || !sz) {
|
||||
d->err = 1;
|
||||
break;
|
||||
}
|
||||
if (!app || (uint32_t)app->sType != t) {
|
||||
/* The server answered for a structure we did not send: protocol mismatch. */
|
||||
d->err = 1;
|
||||
break;
|
||||
}
|
||||
/* The caller's own pointers and array capacities survive the copy. */
|
||||
VkBaseOutStructure *keep_next = app->pNext;
|
||||
void *app_arr[4] = {0};
|
||||
uint32_t cap[4] = {0};
|
||||
int na = 0;
|
||||
for (size_t i = 0; i < N_OUT_ARRAYS && na < 4; i++) {
|
||||
if (out_arrays[i].t != (VkStructureType)t) continue;
|
||||
app_arr[na] = rdp(app, out_arrays[i].ptr_off);
|
||||
cap[na] = rd32(app, out_arrays[i].count_off);
|
||||
na++;
|
||||
}
|
||||
memcpy(app, src, sz);
|
||||
app->pNext = keep_next;
|
||||
na = 0;
|
||||
for (size_t i = 0; i < N_OUT_ARRAYS && na < 4; i++) {
|
||||
const out_arr *oa = &out_arrays[i];
|
||||
if (oa->t != (VkStructureType)t) continue;
|
||||
wrp(app, oa->ptr_off, app_arr[na]);
|
||||
uint8_t present = vkb_dec_u8(d);
|
||||
uint32_t n = 0;
|
||||
const uint8_t *arr_src = NULL;
|
||||
if (present) {
|
||||
n = vkb_dec_u32(d);
|
||||
arr_src = vkb_dec_raw_view(d, (size_t)n * oa->elem);
|
||||
}
|
||||
if (oa->empty) {
|
||||
wr32(app, oa->count_off, 0);
|
||||
} else if (app_arr[na] && arr_src) {
|
||||
uint32_t m = n < cap[na] ? n : cap[na];
|
||||
memcpy(app_arr[na], arr_src, (size_t)m * oa->elem);
|
||||
wr32(app, oa->count_off, m);
|
||||
}
|
||||
na++;
|
||||
}
|
||||
app = (VkBaseOutStructure *)next_known_out(keep_next);
|
||||
}
|
||||
}
|
||||
|
||||
void vkb_close_fd(int fd)
|
||||
{
|
||||
if (fd >= 0) close(fd);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ predicates */
|
||||
|
||||
int vkb_desc_has_image(VkDescriptorType t)
|
||||
{
|
||||
return t == VK_DESCRIPTOR_TYPE_SAMPLER || t == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER ||
|
||||
t == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || t == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ||
|
||||
t == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT || t == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM ||
|
||||
t == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM;
|
||||
}
|
||||
|
||||
int vkb_desc_has_buffer(VkDescriptorType t)
|
||||
{
|
||||
return t == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || t == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER ||
|
||||
t == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || t == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
|
||||
}
|
||||
|
||||
int vkb_desc_has_texel(VkDescriptorType t)
|
||||
{
|
||||
return t == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER || t == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
|
||||
}
|
||||
|
||||
int vkb_gp_has_tess(const VkGraphicsPipelineCreateInfo *s)
|
||||
{
|
||||
if (!s->pStages) return 1; /* library pieces: trust the pointer */
|
||||
for (uint32_t i = 0; i < s->stageCount; i++) {
|
||||
if (s->pStages[i].stage & (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT))
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ transport */
|
||||
|
||||
int vkb_send_msg(int sock, const vkb_msg_hdr *h, const void *payload, const int *fds, int nfds)
|
||||
{
|
||||
struct iovec iov[2];
|
||||
iov[0].iov_base = (void *)h;
|
||||
iov[0].iov_len = sizeof(*h);
|
||||
iov[1].iov_base = (void *)payload;
|
||||
iov[1].iov_len = h->size;
|
||||
union {
|
||||
char buf[CMSG_SPACE(sizeof(int) * VKB_MAX_FDS)];
|
||||
struct cmsghdr align;
|
||||
} cm;
|
||||
struct msghdr msg;
|
||||
memset(&msg, 0, sizeof(msg));
|
||||
msg.msg_iov = iov;
|
||||
msg.msg_iovlen = h->size ? 2 : 1;
|
||||
if (nfds > 0) {
|
||||
memset(&cm, 0, sizeof(cm));
|
||||
msg.msg_control = cm.buf;
|
||||
msg.msg_controllen = CMSG_SPACE(sizeof(int) * nfds);
|
||||
struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
|
||||
c->cmsg_level = SOL_SOCKET;
|
||||
c->cmsg_type = SCM_RIGHTS;
|
||||
c->cmsg_len = CMSG_LEN(sizeof(int) * nfds);
|
||||
memcpy(CMSG_DATA(c), fds, sizeof(int) * nfds);
|
||||
}
|
||||
size_t total = sizeof(*h) + h->size;
|
||||
size_t sent = 0;
|
||||
while (sent < total) {
|
||||
ssize_t r = sendmsg(sock, &msg, MSG_NOSIGNAL);
|
||||
if (r < 0) {
|
||||
if (errno == EINTR) continue;
|
||||
return -1;
|
||||
}
|
||||
sent += (size_t)r;
|
||||
if (sent >= total) break;
|
||||
/* Partial write: advance the iovecs; fds went with the first chunk. */
|
||||
msg.msg_control = NULL;
|
||||
msg.msg_controllen = 0;
|
||||
size_t skip = (size_t)r;
|
||||
while (msg.msg_iovlen && skip >= msg.msg_iov[0].iov_len) {
|
||||
skip -= msg.msg_iov[0].iov_len;
|
||||
msg.msg_iov++;
|
||||
msg.msg_iovlen--;
|
||||
}
|
||||
if (msg.msg_iovlen) {
|
||||
msg.msg_iov[0].iov_base = (uint8_t *)msg.msg_iov[0].iov_base + skip;
|
||||
msg.msg_iov[0].iov_len -= skip;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int read_full(int sock, void *buf, size_t n)
|
||||
{
|
||||
size_t got = 0;
|
||||
while (got < n) {
|
||||
ssize_t r = recv(sock, (uint8_t *)buf + got, n - got, 0);
|
||||
if (r == 0) return -1;
|
||||
if (r < 0) {
|
||||
if (errno == EINTR) continue;
|
||||
return -1;
|
||||
}
|
||||
got += (size_t)r;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int vkb_recv_msg(int sock, vkb_msg_hdr *h, uint8_t **payload, size_t *cap, int *fds, int *nfds)
|
||||
{
|
||||
union {
|
||||
char buf[CMSG_SPACE(sizeof(int) * VKB_MAX_FDS)];
|
||||
struct cmsghdr align;
|
||||
} cm;
|
||||
struct iovec iov = {h, sizeof(*h)};
|
||||
struct msghdr msg;
|
||||
memset(&msg, 0, sizeof(msg));
|
||||
msg.msg_iov = &iov;
|
||||
msg.msg_iovlen = 1;
|
||||
msg.msg_control = cm.buf;
|
||||
msg.msg_controllen = sizeof(cm.buf);
|
||||
*nfds = 0;
|
||||
ssize_t r;
|
||||
do {
|
||||
r = recvmsg(sock, &msg, MSG_CMSG_CLOEXEC);
|
||||
} while (r < 0 && errno == EINTR);
|
||||
if (r <= 0) return -1;
|
||||
for (struct cmsghdr *c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
|
||||
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_RIGHTS) {
|
||||
int n = (int)((c->cmsg_len - CMSG_LEN(0)) / sizeof(int));
|
||||
for (int i = 0; i < n; i++) {
|
||||
int fd;
|
||||
memcpy(&fd, CMSG_DATA(c) + i * sizeof(int), sizeof(int));
|
||||
if (*nfds < VKB_MAX_FDS) fds[(*nfds)++] = fd;
|
||||
else close(fd);
|
||||
}
|
||||
}
|
||||
}
|
||||
if ((size_t)r < sizeof(*h) && read_full(sock, (uint8_t *)h + r, sizeof(*h) - (size_t)r) < 0) goto fail;
|
||||
if (h->magic != VKB_MAGIC) {
|
||||
VKB_ERR("transport: bad message magic 0x%08x", h->magic);
|
||||
goto fail;
|
||||
}
|
||||
if (h->size) {
|
||||
if (h->size > *cap) {
|
||||
size_t nc = *cap ? *cap : 65536;
|
||||
while (nc < h->size) nc *= 2;
|
||||
uint8_t *nb = realloc(*payload, nc);
|
||||
if (!nb) goto fail;
|
||||
*payload = nb;
|
||||
*cap = nc;
|
||||
}
|
||||
if (read_full(sock, *payload, h->size) < 0) goto fail;
|
||||
}
|
||||
return 0;
|
||||
fail:
|
||||
for (int i = 0; i < *nfds; i++) close(fds[i]);
|
||||
*nfds = 0;
|
||||
return -1;
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Wire primitives shared by the bridge's client ICD (glibc) and server (bionic).
|
||||
* See tools/vkbridge/README.md for the protocol.
|
||||
*/
|
||||
#ifndef VKB_WIRE_H
|
||||
#define VKB_WIRE_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include "gen/vkb_gen.h"
|
||||
|
||||
#define VKB_MAX_FDS 16
|
||||
#define VKB_CHAIN_END 0x7FFFFFFFu
|
||||
#define VKB_FD_NONE 0xFFFFFFFFu
|
||||
|
||||
/* ---- arena: per-call scratch memory on the decoding side ---- */
|
||||
typedef struct vkb_arena_block vkb_arena_block;
|
||||
typedef struct vkb_arena {
|
||||
vkb_arena_block *head;
|
||||
size_t used_total;
|
||||
} vkb_arena;
|
||||
void *vkb_arena_alloc(vkb_arena *a, size_t n);
|
||||
void vkb_arena_reset(vkb_arena *a);
|
||||
void vkb_arena_free(vkb_arena *a);
|
||||
|
||||
/* ---- encoder ---- */
|
||||
struct vkb_enc {
|
||||
uint8_t *buf;
|
||||
size_t len, cap;
|
||||
int fds[VKB_MAX_FDS];
|
||||
int nfds;
|
||||
int oom;
|
||||
};
|
||||
void vkb_enc_init(vkb_enc *e);
|
||||
void vkb_enc_reset(vkb_enc *e); /* keeps the buffer */
|
||||
void vkb_enc_free(vkb_enc *e);
|
||||
void vkb_enc_bytes(vkb_enc *e, const void *p, size_t n);
|
||||
void vkb_enc_u8(vkb_enc *e, uint8_t v);
|
||||
void vkb_enc_u32(vkb_enc *e, uint32_t v);
|
||||
void vkb_enc_u64(vkb_enc *e, uint64_t v);
|
||||
size_t vkb_enc_raw(vkb_enc *e, const void *p, size_t n); /* 8-aligned; returns offset */
|
||||
void vkb_enc_patch_u64(vkb_enc *e, size_t off, uint64_t v);
|
||||
void vkb_enc_str(vkb_enc *e, const char *s);
|
||||
void vkb_enc_strarray(vkb_enc *e, const char *const *a, uint32_t n);
|
||||
void vkb_enc_blob(vkb_enc *e, const void *p, size_t n);
|
||||
void vkb_enc_fd(vkb_enc *e, int fd); /* sent with the message */
|
||||
void vkb_enc_chain(vkb_enc *e, const void *pNext);
|
||||
void vkb_enc_out_template(vkb_enc *e, const void *s, size_t size); /* client */
|
||||
void vkb_enc_out_struct(vkb_enc *e, const void *s, size_t size); /* server */
|
||||
void vkb_enc_append(vkb_enc *e, const vkb_enc *src); /* bytes + fds */
|
||||
|
||||
/* ---- decoder ---- */
|
||||
struct vkb_dec {
|
||||
const uint8_t *buf;
|
||||
size_t pos, len;
|
||||
int err;
|
||||
vkb_arena *arena;
|
||||
int *fds;
|
||||
int nfds;
|
||||
uint32_t fd_taken; /* bitmask of fds handed out */
|
||||
};
|
||||
void vkb_dec_init(vkb_dec *d, const void *buf, size_t len, vkb_arena *a, int *fds, int nfds);
|
||||
void vkb_dec_bytes(vkb_dec *d, void *dst, size_t n);
|
||||
uint8_t vkb_dec_u8(vkb_dec *d);
|
||||
uint32_t vkb_dec_u32(vkb_dec *d);
|
||||
uint64_t vkb_dec_u64(vkb_dec *d);
|
||||
void vkb_dec_raw_into(vkb_dec *d, void *dst, size_t n);
|
||||
const void *vkb_dec_raw_view(vkb_dec *d, size_t n);
|
||||
void *vkb_dec_alloc(vkb_dec *d, size_t n); /* zeroed */
|
||||
void *vkb_dec_alloc_zero(vkb_dec *d, size_t n);
|
||||
const char *vkb_dec_str(vkb_dec *d);
|
||||
const char *const *vkb_dec_strarray(vkb_dec *d);
|
||||
const void *vkb_dec_blob(vkb_dec *d, size_t *n);
|
||||
void vkb_dec_blob_into(vkb_dec *d, void *dst, size_t cap);
|
||||
int vkb_dec_fd(vkb_dec *d); /* caller owns the fd */
|
||||
const void *vkb_dec_chain(vkb_dec *d);
|
||||
void vkb_dec_out_template(vkb_dec *d, void *dst, size_t size); /* server */
|
||||
void vkb_dec_out_struct(vkb_dec *d, void *dst, size_t size); /* client */
|
||||
void vkb_dec_close_untaken(vkb_dec *d);
|
||||
|
||||
void vkb_close_fd(int fd);
|
||||
|
||||
/* Descriptor-type predicates used by generated encoders. */
|
||||
int vkb_desc_has_image(VkDescriptorType t);
|
||||
int vkb_desc_has_buffer(VkDescriptorType t);
|
||||
int vkb_desc_has_texel(VkDescriptorType t);
|
||||
int vkb_gp_has_tess(const VkGraphicsPipelineCreateInfo *s);
|
||||
/* Defined per side: on the client it consults the command buffer's level. */
|
||||
int vkb_cb_begin_is_secondary(const VkCommandBufferBeginInfo *s);
|
||||
|
||||
/* Defined per side: client maps a dispatchable handle to the server's value; server: identity. */
|
||||
uint64_t vkb_remote(const void *dispatchable);
|
||||
|
||||
/* ---- transport ---- */
|
||||
typedef struct vkb_msg_hdr {
|
||||
uint32_t magic; /* VKB_MAGIC */
|
||||
uint32_t size; /* payload bytes after the header */
|
||||
uint32_t cmd; /* request: command id; reply: status (0 = ok) */
|
||||
uint32_t table; /* request: server dispatch table id */
|
||||
uint32_t nfds;
|
||||
uint32_t flags;
|
||||
/* Ordering of asynchronous requests across a process's connections: an async request has
|
||||
* seq > 0; every request carries barrier = the highest async seq its process had issued
|
||||
* before it, and is not executed until all of those have been. */
|
||||
uint64_t seq;
|
||||
uint64_t barrier;
|
||||
} vkb_msg_hdr;
|
||||
#define VKB_MAGIC 0x32424b56u /* "VKB2" */
|
||||
#define VKB_F_NOREPLY 1u
|
||||
|
||||
/* Reply status codes (vkb_msg_hdr.cmd in replies). */
|
||||
#define VKB_ST_OK 0u
|
||||
#define VKB_ST_BAD_MESSAGE 1u
|
||||
#define VKB_ST_MISSING 2u
|
||||
#define VKB_ST_BAD_TABLE 3u
|
||||
|
||||
int vkb_send_msg(int sock, const vkb_msg_hdr *h, const void *payload, const int *fds, int nfds);
|
||||
/* Receives one message; *payload is malloc'd (or reused when *cap suffices). Returns 0 on
|
||||
* success, -1 on EOF/error. fds[] receives up to VKB_MAX_FDS descriptors. */
|
||||
int vkb_recv_msg(int sock, vkb_msg_hdr *h, uint8_t **payload, size_t *cap, int *fds, int *nfds);
|
||||
|
||||
#endif
|
||||
Reference in new issue
Block a user