| //////////////////////////////////////////////////////////////////////////////// |
| // Do not modify! |
| // Generated by codergen |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| |
| #ifndef GAPIC_CODER_VULKAN_H |
| #define GAPIC_CODER_VULKAN_H |
| |
| #include <gapic/schema.h> |
| #include <gapic/coder/memory.h> |
| #include <gapic/coder/vulkan.h> |
| #include <gapic/vector.h> |
| |
| #include <gapic/static_array.h> |
| namespace gapic { |
| |
| class Encodable; |
| class Encoder; |
| |
| namespace coder { |
| namespace vulkan { |
| class ANativeWindow__S: public Encodable { |
| public: |
| ANativeWindow__S() = default; |
| ANativeWindow__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class ANativeWindow__P: public Encodable { |
| public: |
| ANativeWindow__P() = default; |
| ANativeWindow__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class Void__P: public Encodable { |
| public: |
| Void__P() = default; |
| Void__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class U8__S: public Encodable { |
| public: |
| U8__S() = default; |
| U8__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Char__256__A: public Encodable { |
| public: |
| Char__256__A() = default; |
| Char__256__A(const gapic::StaticArray<char, 256>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| for (int i = 0; i < 256; i++) { |
| e->Uint8(this->mElements[i]); |
| } |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<char, 256> mElements; |
| }; |
| |
| class Char__S: public Encodable { |
| public: |
| Char__S() = default; |
| Char__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Char__P: public Encodable { |
| public: |
| Char__P() = default; |
| Char__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class Char__CP: public Encodable { |
| public: |
| Char__CP() = default; |
| Char__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class Char__CP__S: public Encodable { |
| public: |
| Char__CP__S() = default; |
| Char__CP__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Char__CP__P: public Encodable { |
| public: |
| Char__CP__P() = default; |
| Char__CP__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class Char__CP__CP: public Encodable { |
| public: |
| Char__CP__CP() = default; |
| Char__CP__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferCopy: public Encodable { |
| public: |
| VkBufferCopy() = default; |
| VkBufferCopy(uint64_t SrcOffset, uint64_t DstOffset, uint64_t Size) |
| : mSrcOffset(SrcOffset) |
| , mDstOffset(DstOffset) |
| , mSize(Size) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mSrcOffset); |
| e->Uint64(this->mDstOffset); |
| e->Uint64(this->mSize); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mSrcOffset; |
| uint64_t mDstOffset; |
| uint64_t mSize; |
| }; |
| |
| class VkImageSubresourceLayers: public Encodable { |
| public: |
| VkImageSubresourceLayers() = default; |
| VkImageSubresourceLayers(uint32_t AspectMask, uint32_t MipLevel, uint32_t BaseArrayLayer, uint32_t LayerCount) |
| : mAspectMask(AspectMask) |
| , mMipLevel(MipLevel) |
| , mBaseArrayLayer(BaseArrayLayer) |
| , mLayerCount(LayerCount) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mAspectMask; |
| uint32_t mMipLevel; |
| uint32_t mBaseArrayLayer; |
| uint32_t mLayerCount; |
| }; |
| |
| class VkOffset3D: public Encodable { |
| public: |
| VkOffset3D() = default; |
| VkOffset3D(int32_t X, int32_t Y, int32_t Z) |
| : mX(X) |
| , mY(Y) |
| , mZ(Z) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Int32(this->mX); |
| e->Int32(this->mY); |
| e->Int32(this->mZ); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| int32_t mX; |
| int32_t mY; |
| int32_t mZ; |
| }; |
| |
| class VkExtent3D: public Encodable { |
| public: |
| VkExtent3D() = default; |
| VkExtent3D(uint32_t Width, uint32_t Height, uint32_t Depth) |
| : mWidth(Width) |
| , mHeight(Height) |
| , mDepth(Depth) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mWidth); |
| e->Uint32(this->mHeight); |
| e->Uint32(this->mDepth); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mWidth; |
| uint32_t mHeight; |
| uint32_t mDepth; |
| }; |
| |
| class VkBufferImageCopy: public Encodable { |
| public: |
| VkBufferImageCopy() = default; |
| VkBufferImageCopy(uint64_t BufferOffset, uint32_t BufferRowLength, uint32_t BufferImageHeight, VkImageSubresourceLayers ImageSubresource, VkOffset3D ImageOffset, VkExtent3D ImageExtent) |
| : mBufferOffset(BufferOffset) |
| , mBufferRowLength(BufferRowLength) |
| , mBufferImageHeight(BufferImageHeight) |
| , mImageSubresource(ImageSubresource) |
| , mImageOffset(ImageOffset) |
| , mImageExtent(ImageExtent) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mBufferOffset; |
| uint32_t mBufferRowLength; |
| uint32_t mBufferImageHeight; |
| VkImageSubresourceLayers mImageSubresource; |
| VkOffset3D mImageOffset; |
| VkExtent3D mImageExtent; |
| }; |
| |
| class VkImageCopy: public Encodable { |
| public: |
| VkImageCopy() = default; |
| VkImageCopy(VkImageSubresourceLayers SrcSubresource, VkOffset3D SrcOffset, VkImageSubresourceLayers DstSubresource, VkOffset3D DstOffset, VkExtent3D Extent) |
| : mSrcSubresource(SrcSubresource) |
| , mSrcOffset(SrcOffset) |
| , mDstSubresource(DstSubresource) |
| , mDstOffset(DstOffset) |
| , mExtent(Extent) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkImageSubresourceLayers mSrcSubresource; |
| VkOffset3D mSrcOffset; |
| VkImageSubresourceLayers mDstSubresource; |
| VkOffset3D mDstOffset; |
| VkExtent3D mExtent; |
| }; |
| |
| class Void__CP: public Encodable { |
| public: |
| Void__CP() = default; |
| Void__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageSubresourceRange: public Encodable { |
| public: |
| VkImageSubresourceRange() = default; |
| VkImageSubresourceRange(uint32_t AspectMask, uint32_t BaseMipLevel, uint32_t LevelCount, uint32_t BaseArrayLayer, uint32_t LayerCount) |
| : mAspectMask(AspectMask) |
| , mBaseMipLevel(BaseMipLevel) |
| , mLevelCount(LevelCount) |
| , mBaseArrayLayer(BaseArrayLayer) |
| , mLayerCount(LayerCount) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mAspectMask; |
| uint32_t mBaseMipLevel; |
| uint32_t mLevelCount; |
| uint32_t mBaseArrayLayer; |
| uint32_t mLayerCount; |
| }; |
| |
| class VkImageMemoryBarrier: public Encodable { |
| public: |
| VkImageMemoryBarrier() = default; |
| VkImageMemoryBarrier(uint32_t SType, Void__CP PNext, uint32_t SrcAccessMask, uint32_t DstAccessMask, uint32_t OldLayout, uint32_t NewLayout, uint32_t SrcQueueFamilyIndex, uint32_t DstQueueFamilyIndex, uint64_t Image, VkImageSubresourceRange SubresourceRange) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mSrcAccessMask(SrcAccessMask) |
| , mDstAccessMask(DstAccessMask) |
| , mOldLayout(OldLayout) |
| , mNewLayout(NewLayout) |
| , mSrcQueueFamilyIndex(SrcQueueFamilyIndex) |
| , mDstQueueFamilyIndex(DstQueueFamilyIndex) |
| , mImage(Image) |
| , mSubresourceRange(SubresourceRange) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mSrcAccessMask; |
| uint32_t mDstAccessMask; |
| uint32_t mOldLayout; |
| uint32_t mNewLayout; |
| uint32_t mSrcQueueFamilyIndex; |
| uint32_t mDstQueueFamilyIndex; |
| uint64_t mImage; |
| VkImageSubresourceRange mSubresourceRange; |
| }; |
| |
| class VkVertexInputBindingDescription: public Encodable { |
| public: |
| VkVertexInputBindingDescription() = default; |
| VkVertexInputBindingDescription(uint32_t Binding, uint32_t Stride, uint32_t InputRate) |
| : mBinding(Binding) |
| , mStride(Stride) |
| , mInputRate(InputRate) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mBinding); |
| e->Uint32(this->mStride); |
| e->Uint32(this->mInputRate); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mBinding; |
| uint32_t mStride; |
| uint32_t mInputRate; |
| }; |
| |
| class VkVertexInputAttributeDescription: public Encodable { |
| public: |
| VkVertexInputAttributeDescription() = default; |
| VkVertexInputAttributeDescription(uint32_t Location, uint32_t Binding, uint32_t Format, uint32_t Offset) |
| : mLocation(Location) |
| , mBinding(Binding) |
| , mFormat(Format) |
| , mOffset(Offset) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mLocation; |
| uint32_t mBinding; |
| uint32_t mFormat; |
| uint32_t mOffset; |
| }; |
| |
| class VkPhysicalDeviceFeatures: public Encodable { |
| public: |
| VkPhysicalDeviceFeatures() = default; |
| VkPhysicalDeviceFeatures(uint32_t RobustBufferAccess, uint32_t FullDrawIndexUint32, uint32_t ImageCubeArray, uint32_t IndependentBlend, uint32_t GeometryShader, uint32_t TessellationShader, uint32_t SampleRateShading, uint32_t DualSrcBlend, uint32_t LogicOp, uint32_t MultiDrawIndirect, uint32_t DrawIndirectFirstInstance, uint32_t DepthClamp, uint32_t DepthBiasClamp, uint32_t FillModeNonSolid, uint32_t DepthBounds, uint32_t WideLines, uint32_t LargePoints, uint32_t AlphaToOne, uint32_t MultiViewport, uint32_t SamplerAnisotropy, uint32_t TextureCompressionETC2, uint32_t TextureCompressionASTC_LDR, uint32_t TextureCompressionBC, uint32_t OcclusionQueryPrecise, uint32_t PipelineStatisticsQuery, uint32_t VertexPipelineStoresAndAtomics, uint32_t FragmentStoresAndAtomics, uint32_t ShaderTessellationAndGeometryPointSize, uint32_t ShaderImageGatherExtended, uint32_t ShaderStorageImageExtendedFormats, uint32_t ShaderStorageImageMultisample, uint32_t ShaderStorageImageReadWithoutFormat, uint32_t ShaderStorageImageWriteWithoutFormat, uint32_t ShaderUniformBufferArrayDynamicIndexing, uint32_t ShaderSampledImageArrayDynamicIndexing, uint32_t ShaderStorageBufferArrayDynamicIndexing, uint32_t ShaderStorageImageArrayDynamicIndexing, uint32_t ShaderClipDistance, uint32_t ShaderCullDistance, uint32_t ShaderFloat64, uint32_t ShaderInt64, uint32_t ShaderInt16, uint32_t ShaderResourceResidency, uint32_t ShaderResourceMinLod, uint32_t SparseBinding, uint32_t SparseResidencyBuffer, uint32_t SparseResidencyImage2D, uint32_t SparseResidencyImage3D, uint32_t SparseResidency2Samples, uint32_t SparseResidency4Samples, uint32_t SparseResidency8Samples, uint32_t SparseResidency16Samples, uint32_t SparseResidencyAliased, uint32_t VariableMultisampleRate, uint32_t InheritedQueries) |
| : mRobustBufferAccess(RobustBufferAccess) |
| , mFullDrawIndexUint32(FullDrawIndexUint32) |
| , mImageCubeArray(ImageCubeArray) |
| , mIndependentBlend(IndependentBlend) |
| , mGeometryShader(GeometryShader) |
| , mTessellationShader(TessellationShader) |
| , mSampleRateShading(SampleRateShading) |
| , mDualSrcBlend(DualSrcBlend) |
| , mLogicOp(LogicOp) |
| , mMultiDrawIndirect(MultiDrawIndirect) |
| , mDrawIndirectFirstInstance(DrawIndirectFirstInstance) |
| , mDepthClamp(DepthClamp) |
| , mDepthBiasClamp(DepthBiasClamp) |
| , mFillModeNonSolid(FillModeNonSolid) |
| , mDepthBounds(DepthBounds) |
| , mWideLines(WideLines) |
| , mLargePoints(LargePoints) |
| , mAlphaToOne(AlphaToOne) |
| , mMultiViewport(MultiViewport) |
| , mSamplerAnisotropy(SamplerAnisotropy) |
| , mTextureCompressionETC2(TextureCompressionETC2) |
| , mTextureCompressionASTC_LDR(TextureCompressionASTC_LDR) |
| , mTextureCompressionBC(TextureCompressionBC) |
| , mOcclusionQueryPrecise(OcclusionQueryPrecise) |
| , mPipelineStatisticsQuery(PipelineStatisticsQuery) |
| , mVertexPipelineStoresAndAtomics(VertexPipelineStoresAndAtomics) |
| , mFragmentStoresAndAtomics(FragmentStoresAndAtomics) |
| , mShaderTessellationAndGeometryPointSize(ShaderTessellationAndGeometryPointSize) |
| , mShaderImageGatherExtended(ShaderImageGatherExtended) |
| , mShaderStorageImageExtendedFormats(ShaderStorageImageExtendedFormats) |
| , mShaderStorageImageMultisample(ShaderStorageImageMultisample) |
| , mShaderStorageImageReadWithoutFormat(ShaderStorageImageReadWithoutFormat) |
| , mShaderStorageImageWriteWithoutFormat(ShaderStorageImageWriteWithoutFormat) |
| , mShaderUniformBufferArrayDynamicIndexing(ShaderUniformBufferArrayDynamicIndexing) |
| , mShaderSampledImageArrayDynamicIndexing(ShaderSampledImageArrayDynamicIndexing) |
| , mShaderStorageBufferArrayDynamicIndexing(ShaderStorageBufferArrayDynamicIndexing) |
| , mShaderStorageImageArrayDynamicIndexing(ShaderStorageImageArrayDynamicIndexing) |
| , mShaderClipDistance(ShaderClipDistance) |
| , mShaderCullDistance(ShaderCullDistance) |
| , mShaderFloat64(ShaderFloat64) |
| , mShaderInt64(ShaderInt64) |
| , mShaderInt16(ShaderInt16) |
| , mShaderResourceResidency(ShaderResourceResidency) |
| , mShaderResourceMinLod(ShaderResourceMinLod) |
| , mSparseBinding(SparseBinding) |
| , mSparseResidencyBuffer(SparseResidencyBuffer) |
| , mSparseResidencyImage2D(SparseResidencyImage2D) |
| , mSparseResidencyImage3D(SparseResidencyImage3D) |
| , mSparseResidency2Samples(SparseResidency2Samples) |
| , mSparseResidency4Samples(SparseResidency4Samples) |
| , mSparseResidency8Samples(SparseResidency8Samples) |
| , mSparseResidency16Samples(SparseResidency16Samples) |
| , mSparseResidencyAliased(SparseResidencyAliased) |
| , mVariableMultisampleRate(VariableMultisampleRate) |
| , mInheritedQueries(InheritedQueries) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mRobustBufferAccess; |
| uint32_t mFullDrawIndexUint32; |
| uint32_t mImageCubeArray; |
| uint32_t mIndependentBlend; |
| uint32_t mGeometryShader; |
| uint32_t mTessellationShader; |
| uint32_t mSampleRateShading; |
| uint32_t mDualSrcBlend; |
| uint32_t mLogicOp; |
| uint32_t mMultiDrawIndirect; |
| uint32_t mDrawIndirectFirstInstance; |
| uint32_t mDepthClamp; |
| uint32_t mDepthBiasClamp; |
| uint32_t mFillModeNonSolid; |
| uint32_t mDepthBounds; |
| uint32_t mWideLines; |
| uint32_t mLargePoints; |
| uint32_t mAlphaToOne; |
| uint32_t mMultiViewport; |
| uint32_t mSamplerAnisotropy; |
| uint32_t mTextureCompressionETC2; |
| uint32_t mTextureCompressionASTC_LDR; |
| uint32_t mTextureCompressionBC; |
| uint32_t mOcclusionQueryPrecise; |
| uint32_t mPipelineStatisticsQuery; |
| uint32_t mVertexPipelineStoresAndAtomics; |
| uint32_t mFragmentStoresAndAtomics; |
| uint32_t mShaderTessellationAndGeometryPointSize; |
| uint32_t mShaderImageGatherExtended; |
| uint32_t mShaderStorageImageExtendedFormats; |
| uint32_t mShaderStorageImageMultisample; |
| uint32_t mShaderStorageImageReadWithoutFormat; |
| uint32_t mShaderStorageImageWriteWithoutFormat; |
| uint32_t mShaderUniformBufferArrayDynamicIndexing; |
| uint32_t mShaderSampledImageArrayDynamicIndexing; |
| uint32_t mShaderStorageBufferArrayDynamicIndexing; |
| uint32_t mShaderStorageImageArrayDynamicIndexing; |
| uint32_t mShaderClipDistance; |
| uint32_t mShaderCullDistance; |
| uint32_t mShaderFloat64; |
| uint32_t mShaderInt64; |
| uint32_t mShaderInt16; |
| uint32_t mShaderResourceResidency; |
| uint32_t mShaderResourceMinLod; |
| uint32_t mSparseBinding; |
| uint32_t mSparseResidencyBuffer; |
| uint32_t mSparseResidencyImage2D; |
| uint32_t mSparseResidencyImage3D; |
| uint32_t mSparseResidency2Samples; |
| uint32_t mSparseResidency4Samples; |
| uint32_t mSparseResidency8Samples; |
| uint32_t mSparseResidency16Samples; |
| uint32_t mSparseResidencyAliased; |
| uint32_t mVariableMultisampleRate; |
| uint32_t mInheritedQueries; |
| }; |
| |
| class Display__S: public Encodable { |
| public: |
| Display__S() = default; |
| Display__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Display__P: public Encodable { |
| public: |
| Display__P() = default; |
| Display__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class F32__2__A: public Encodable { |
| public: |
| F32__2__A() = default; |
| F32__2__A(const gapic::StaticArray<float, 2>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| for (int i = 0; i < 2; i++) { |
| e->Float32(this->mElements[i]); |
| } |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<float, 2> mElements; |
| }; |
| |
| class F32__4__A: public Encodable { |
| public: |
| F32__4__A() = default; |
| F32__4__A(const gapic::StaticArray<float, 4>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| for (int i = 0; i < 4; i++) { |
| e->Float32(this->mElements[i]); |
| } |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<float, 4> mElements; |
| }; |
| |
| class F32__S: public Encodable { |
| public: |
| F32__S() = default; |
| F32__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class F32__P: public Encodable { |
| public: |
| F32__P() = default; |
| F32__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class F32__CP: public Encodable { |
| public: |
| F32__CP() = default; |
| F32__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class Int__S: public Encodable { |
| public: |
| Int__S() = default; |
| Int__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Int__P: public Encodable { |
| public: |
| Int__P() = default; |
| Int__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class MirConnection__S: public Encodable { |
| public: |
| MirConnection__S() = default; |
| MirConnection__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class MirConnection__P: public Encodable { |
| public: |
| MirConnection__P() = default; |
| MirConnection__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class MirSurface__S: public Encodable { |
| public: |
| MirSurface__S() = default; |
| MirSurface__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class MirSurface__P: public Encodable { |
| public: |
| MirSurface__P() = default; |
| MirSurface__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class PFN_vkAllocationFunction: public Encodable { |
| public: |
| PFN_vkAllocationFunction() = default; |
| PFN_vkAllocationFunction(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class PFN_vkDebugReportCallbackEXT: public Encodable { |
| public: |
| PFN_vkDebugReportCallbackEXT() = default; |
| PFN_vkDebugReportCallbackEXT(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class PFN_vkFreeFunction: public Encodable { |
| public: |
| PFN_vkFreeFunction() = default; |
| PFN_vkFreeFunction(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class PFN_vkInternalAllocationNotification: public Encodable { |
| public: |
| PFN_vkInternalAllocationNotification() = default; |
| PFN_vkInternalAllocationNotification(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class PFN_vkInternalFreeNotification: public Encodable { |
| public: |
| PFN_vkInternalFreeNotification() = default; |
| PFN_vkInternalFreeNotification(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class PFN_vkReallocationFunction: public Encodable { |
| public: |
| PFN_vkReallocationFunction() = default; |
| PFN_vkReallocationFunction(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class PFN_vkVoidFunction: public Encodable { |
| public: |
| PFN_vkVoidFunction() = default; |
| PFN_vkVoidFunction(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkMemoryType: public Encodable { |
| public: |
| VkMemoryType() = default; |
| VkMemoryType(uint32_t PropertyFlags, uint32_t HeapIndex) |
| : mPropertyFlags(PropertyFlags) |
| , mHeapIndex(HeapIndex) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mPropertyFlags); |
| e->Uint32(this->mHeapIndex); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mPropertyFlags; |
| uint32_t mHeapIndex; |
| }; |
| |
| class VkMemoryType__32__A: public Encodable { |
| public: |
| VkMemoryType__32__A() = default; |
| VkMemoryType__32__A(const gapic::StaticArray<VkMemoryType, 32>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| for (int i = 0; i < 32; i++) { |
| e->Struct(this->mElements[i]); |
| } |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<VkMemoryType, 32> mElements; |
| }; |
| |
| class VkMemoryHeap: public Encodable { |
| public: |
| VkMemoryHeap() = default; |
| VkMemoryHeap(uint64_t Size, uint32_t Flags) |
| : mSize(Size) |
| , mFlags(Flags) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mSize); |
| e->Uint32(this->mFlags); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mSize; |
| uint32_t mFlags; |
| }; |
| |
| class VkMemoryHeap__16__A: public Encodable { |
| public: |
| VkMemoryHeap__16__A() = default; |
| VkMemoryHeap__16__A(const gapic::StaticArray<VkMemoryHeap, 16>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| for (int i = 0; i < 16; i++) { |
| e->Struct(this->mElements[i]); |
| } |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<VkMemoryHeap, 16> mElements; |
| }; |
| |
| class VkPhysicalDeviceMemoryProperties: public Encodable { |
| public: |
| VkPhysicalDeviceMemoryProperties() = default; |
| VkPhysicalDeviceMemoryProperties(uint32_t MemoryTypeCount, VkMemoryType__32__A MemoryTypes, uint32_t MemoryHeapCount, VkMemoryHeap__16__A MemoryHeaps) |
| : mMemoryTypeCount(MemoryTypeCount) |
| , mMemoryTypes(MemoryTypes) |
| , mMemoryHeapCount(MemoryHeapCount) |
| , mMemoryHeaps(MemoryHeaps) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mMemoryTypeCount; |
| VkMemoryType__32__A mMemoryTypes; |
| uint32_t mMemoryHeapCount; |
| VkMemoryHeap__16__A mMemoryHeaps; |
| }; |
| |
| class VkPhysicalDeviceMemoryProperties__P: public Encodable { |
| public: |
| VkPhysicalDeviceMemoryProperties__P() = default; |
| VkPhysicalDeviceMemoryProperties__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDeviceMemory__P: public Encodable { |
| public: |
| VkDeviceMemory__P() = default; |
| VkDeviceMemory__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class ReplayAllocateImageMemory: public Encodable { |
| public: |
| ReplayAllocateImageMemory() = default; |
| ReplayAllocateImageMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkPhysicalDeviceMemoryProperties__P PPhysicalDeviceMemoryProperties, uint64_t Image, VkDeviceMemory__P PMemory, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPPhysicalDeviceMemoryProperties(PPhysicalDeviceMemoryProperties) |
| , mImage(Image) |
| , mPMemory(PMemory) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkPhysicalDeviceMemoryProperties__P mPPhysicalDeviceMemoryProperties; |
| uint64_t mImage; |
| VkDeviceMemory__P mPMemory; |
| uint32_t mResult; |
| }; |
| |
| class VkDeviceCreateInfo__CP: public Encodable { |
| public: |
| VkDeviceCreateInfo__CP() = default; |
| VkDeviceCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAllocationCallbacks__CP: public Encodable { |
| public: |
| VkAllocationCallbacks__CP() = default; |
| VkAllocationCallbacks__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDevice__P: public Encodable { |
| public: |
| VkDevice__P() = default; |
| VkDevice__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class ReplayCreateVkDevice: public Encodable { |
| public: |
| ReplayCreateVkDevice() = default; |
| ReplayCreateVkDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkDeviceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDevice__P PDevice, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPDevice(PDevice) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| VkDeviceCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkDevice__P mPDevice; |
| uint32_t mResult; |
| }; |
| |
| class VkInstanceCreateInfo__CP: public Encodable { |
| public: |
| VkInstanceCreateInfo__CP() = default; |
| VkInstanceCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkInstance__P: public Encodable { |
| public: |
| VkInstance__P() = default; |
| VkInstance__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class ReplayCreateVkInstance: public Encodable { |
| public: |
| ReplayCreateVkInstance() = default; |
| ReplayCreateVkInstance(const gapic::Vector<gapic::Encodable*>& extras, VkInstanceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkInstance__P PInstance, uint32_t Result) |
| : mextras(extras) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPInstance(PInstance) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| VkInstanceCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkInstance__P mPInstance; |
| uint32_t mResult; |
| }; |
| |
| class ReplayGetFenceStatus: public Encodable { |
| public: |
| ReplayGetFenceStatus() = default; |
| ReplayGetFenceStatus(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Fence, uint32_t Expected, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mFence(Fence) |
| , mExpected(Expected) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mFence; |
| uint32_t mExpected; |
| uint32_t mResult; |
| }; |
| |
| class VkCommandBuffer__P: public Encodable { |
| public: |
| VkCommandBuffer__P() = default; |
| VkCommandBuffer__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class ReplayRegisterVkCommandBuffers: public Encodable { |
| public: |
| ReplayRegisterVkCommandBuffers() = default; |
| ReplayRegisterVkCommandBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t Count, VkCommandBuffer__P CommandBuffers) |
| : mextras(extras) |
| , mDevice(Device) |
| , mCount(Count) |
| , mCommandBuffers(CommandBuffers) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mCount; |
| VkCommandBuffer__P mCommandBuffers; |
| }; |
| |
| class VkDeviceCreateInfo__P: public Encodable { |
| public: |
| VkDeviceCreateInfo__P() = default; |
| VkDeviceCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class ReplayRegisterVkDevice: public Encodable { |
| public: |
| ReplayRegisterVkDevice() = default; |
| ReplayRegisterVkDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Device, VkDeviceCreateInfo__P CreateInfo) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mDevice(Device) |
| , mCreateInfo(CreateInfo) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint64_t mDevice; |
| VkDeviceCreateInfo__P mCreateInfo; |
| }; |
| |
| class ReplayRegisterVkInstance: public Encodable { |
| public: |
| ReplayRegisterVkInstance() = default; |
| ReplayRegisterVkInstance(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance) |
| : mextras(extras) |
| , mInstance(Instance) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mInstance); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| }; |
| |
| class ReplayUnregisterVkCommandBuffers: public Encodable { |
| public: |
| ReplayUnregisterVkCommandBuffers() = default; |
| ReplayUnregisterVkCommandBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Count, VkCommandBuffer__P CommandBuffers) |
| : mextras(extras) |
| , mCount(Count) |
| , mCommandBuffers(CommandBuffers) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint32(this->mCount); |
| e->Struct(this->mCommandBuffers); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint32_t mCount; |
| VkCommandBuffer__P mCommandBuffers; |
| }; |
| |
| class ReplayUnregisterVkDevice: public Encodable { |
| public: |
| ReplayUnregisterVkDevice() = default; |
| ReplayUnregisterVkDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device) |
| : mextras(extras) |
| , mDevice(Device) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mDevice); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| }; |
| |
| class ReplayUnregisterVkInstance: public Encodable { |
| public: |
| ReplayUnregisterVkInstance() = default; |
| ReplayUnregisterVkInstance(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance) |
| : mextras(extras) |
| , mInstance(Instance) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mInstance); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| }; |
| |
| class U32__S: public Encodable { |
| public: |
| U32__S() = default; |
| U32__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Size__S: public Encodable { |
| public: |
| Size__S() = default; |
| Size__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Size__P: public Encodable { |
| public: |
| Size__P() = default; |
| Size__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSwapchainKHR__P: public Encodable { |
| public: |
| VkSwapchainKHR__P() = default; |
| VkSwapchainKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class ToggleVirtualSwapchainReturnAcquiredImage: public Encodable { |
| public: |
| ToggleVirtualSwapchainReturnAcquiredImage() = default; |
| ToggleVirtualSwapchainReturnAcquiredImage(const gapic::Vector<gapic::Encodable*>& extras, VkSwapchainKHR__P PSwapchain) |
| : mextras(extras) |
| , mPSwapchain(PSwapchain) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Struct(this->mPSwapchain); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| VkSwapchainKHR__P mPSwapchain; |
| }; |
| |
| class U16__S: public Encodable { |
| public: |
| U16__S() = default; |
| U16__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class U16__P: public Encodable { |
| public: |
| U16__P() = default; |
| U16__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class U32__2__A: public Encodable { |
| public: |
| U32__2__A() = default; |
| U32__2__A(const gapic::StaticArray<uint32_t, 2>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| for (int i = 0; i < 2; i++) { |
| e->Uint32(this->mElements[i]); |
| } |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<uint32_t, 2> mElements; |
| }; |
| |
| class U32__3__A: public Encodable { |
| public: |
| U32__3__A() = default; |
| U32__3__A(const gapic::StaticArray<uint32_t, 3>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| for (int i = 0; i < 3; i++) { |
| e->Uint32(this->mElements[i]); |
| } |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<uint32_t, 3> mElements; |
| }; |
| |
| class U32__4__A: public Encodable { |
| public: |
| U32__4__A() = default; |
| U32__4__A(const gapic::StaticArray<uint32_t, 4>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| for (int i = 0; i < 4; i++) { |
| e->Uint32(this->mElements[i]); |
| } |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<uint32_t, 4> mElements; |
| }; |
| |
| class U32__P: public Encodable { |
| public: |
| U32__P() = default; |
| U32__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class U32__CP: public Encodable { |
| public: |
| U32__CP() = default; |
| U32__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class U8__16__A: public Encodable { |
| public: |
| U8__16__A() = default; |
| U8__16__A(const gapic::StaticArray<uint8_t, 16>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Data(this->mElements, 16); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<uint8_t, 16> mElements; |
| }; |
| |
| class U8__P: public Encodable { |
| public: |
| U8__P() = default; |
| U8__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAcquireImageANDROID: public Encodable { |
| public: |
| VkAcquireImageANDROID() = default; |
| VkAcquireImageANDROID(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, int64_t NativeFenceFd, uint64_t Semaphore, uint64_t Fence, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mImage(Image) |
| , mNativeFenceFd(NativeFenceFd) |
| , mSemaphore(Semaphore) |
| , mFence(Fence) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mImage; |
| int64_t mNativeFenceFd; |
| uint64_t mSemaphore; |
| uint64_t mFence; |
| uint32_t mResult; |
| }; |
| |
| class VkAcquireNextImageKHR: public Encodable { |
| public: |
| VkAcquireNextImageKHR() = default; |
| VkAcquireNextImageKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Swapchain, uint64_t Timeout, uint64_t Semaphore, uint64_t Fence, U32__P PImageIndex, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mSwapchain(Swapchain) |
| , mTimeout(Timeout) |
| , mSemaphore(Semaphore) |
| , mFence(Fence) |
| , mPImageIndex(PImageIndex) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mSwapchain; |
| uint64_t mTimeout; |
| uint64_t mSemaphore; |
| uint64_t mFence; |
| U32__P mPImageIndex; |
| uint32_t mResult; |
| }; |
| |
| class VkCommandBufferAllocateInfo__CP: public Encodable { |
| public: |
| VkCommandBufferAllocateInfo__CP() = default; |
| VkCommandBufferAllocateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAllocateCommandBuffers: public Encodable { |
| public: |
| VkAllocateCommandBuffers() = default; |
| VkAllocateCommandBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkCommandBufferAllocateInfo__CP PAllocateInfo, VkCommandBuffer__P PCommandBuffers, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPAllocateInfo(PAllocateInfo) |
| , mPCommandBuffers(PCommandBuffers) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkCommandBufferAllocateInfo__CP mPAllocateInfo; |
| VkCommandBuffer__P mPCommandBuffers; |
| uint32_t mResult; |
| }; |
| |
| class VkDescriptorSetAllocateInfo__CP: public Encodable { |
| public: |
| VkDescriptorSetAllocateInfo__CP() = default; |
| VkDescriptorSetAllocateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorSet__P: public Encodable { |
| public: |
| VkDescriptorSet__P() = default; |
| VkDescriptorSet__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAllocateDescriptorSets: public Encodable { |
| public: |
| VkAllocateDescriptorSets() = default; |
| VkAllocateDescriptorSets(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkDescriptorSetAllocateInfo__CP PAllocateInfo, VkDescriptorSet__P PDescriptorSets, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPAllocateInfo(PAllocateInfo) |
| , mPDescriptorSets(PDescriptorSets) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkDescriptorSetAllocateInfo__CP mPAllocateInfo; |
| VkDescriptorSet__P mPDescriptorSets; |
| uint32_t mResult; |
| }; |
| |
| class VkMemoryAllocateInfo__CP: public Encodable { |
| public: |
| VkMemoryAllocateInfo__CP() = default; |
| VkMemoryAllocateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAllocateMemory: public Encodable { |
| public: |
| VkAllocateMemory() = default; |
| VkAllocateMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkMemoryAllocateInfo__CP PAllocateInfo, VkAllocationCallbacks__CP PAllocator, VkDeviceMemory__P PMemory, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPAllocateInfo(PAllocateInfo) |
| , mPAllocator(PAllocator) |
| , mPMemory(PMemory) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkMemoryAllocateInfo__CP mPAllocateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkDeviceMemory__P mPMemory; |
| uint32_t mResult; |
| }; |
| |
| class VkAllocationCallbacks: public Encodable { |
| public: |
| VkAllocationCallbacks() = default; |
| VkAllocationCallbacks(Void__P PUserData, PFN_vkAllocationFunction PfnAllocation, PFN_vkReallocationFunction PfnReallocation, PFN_vkFreeFunction PfnFree, PFN_vkInternalAllocationNotification PfnInternalAllocation, PFN_vkInternalFreeNotification PfnInternalFree) |
| : mPUserData(PUserData) |
| , mPfnAllocation(PfnAllocation) |
| , mPfnReallocation(PfnReallocation) |
| , mPfnFree(PfnFree) |
| , mPfnInternalAllocation(PfnInternalAllocation) |
| , mPfnInternalFree(PfnInternalFree) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| Void__P mPUserData; |
| PFN_vkAllocationFunction mPfnAllocation; |
| PFN_vkReallocationFunction mPfnReallocation; |
| PFN_vkFreeFunction mPfnFree; |
| PFN_vkInternalAllocationNotification mPfnInternalAllocation; |
| PFN_vkInternalFreeNotification mPfnInternalFree; |
| }; |
| |
| class VkAllocationCallbacks__S: public Encodable { |
| public: |
| VkAllocationCallbacks__S() = default; |
| VkAllocationCallbacks__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkAllocationCallbacks__P: public Encodable { |
| public: |
| VkAllocationCallbacks__P() = default; |
| VkAllocationCallbacks__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAndroidSurfaceCreateInfoKHR__S: public Encodable { |
| public: |
| VkAndroidSurfaceCreateInfoKHR__S() = default; |
| VkAndroidSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkAndroidSurfaceCreateInfoKHR__P: public Encodable { |
| public: |
| VkAndroidSurfaceCreateInfoKHR__P() = default; |
| VkAndroidSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAndroidSurfaceCreateInfoKHR__CP: public Encodable { |
| public: |
| VkAndroidSurfaceCreateInfoKHR__CP() = default; |
| VkAndroidSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkApplicationInfo: public Encodable { |
| public: |
| VkApplicationInfo() = default; |
| VkApplicationInfo(uint32_t SType, Void__CP PNext, Char__CP PApplicationName, uint32_t ApplicationVersion, Char__CP PEngineName, uint32_t EngineVersion, uint32_t ApiVersion) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mPApplicationName(PApplicationName) |
| , mApplicationVersion(ApplicationVersion) |
| , mPEngineName(PEngineName) |
| , mEngineVersion(EngineVersion) |
| , mApiVersion(ApiVersion) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| Char__CP mPApplicationName; |
| uint32_t mApplicationVersion; |
| Char__CP mPEngineName; |
| uint32_t mEngineVersion; |
| uint32_t mApiVersion; |
| }; |
| |
| class VkApplicationInfo__S: public Encodable { |
| public: |
| VkApplicationInfo__S() = default; |
| VkApplicationInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkApplicationInfo__P: public Encodable { |
| public: |
| VkApplicationInfo__P() = default; |
| VkApplicationInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkApplicationInfo__CP: public Encodable { |
| public: |
| VkApplicationInfo__CP() = default; |
| VkApplicationInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAttachmentDescription: public Encodable { |
| public: |
| VkAttachmentDescription() = default; |
| VkAttachmentDescription(uint32_t Flags, uint32_t Format, uint32_t Samples, uint32_t LoadOp, uint32_t StoreOp, uint32_t StencilLoadOp, uint32_t StencilStoreOp, uint32_t InitialLayout, uint32_t FinalLayout) |
| : mFlags(Flags) |
| , mFormat(Format) |
| , mSamples(Samples) |
| , mLoadOp(LoadOp) |
| , mStoreOp(StoreOp) |
| , mStencilLoadOp(StencilLoadOp) |
| , mStencilStoreOp(StencilStoreOp) |
| , mInitialLayout(InitialLayout) |
| , mFinalLayout(FinalLayout) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mFlags; |
| uint32_t mFormat; |
| uint32_t mSamples; |
| uint32_t mLoadOp; |
| uint32_t mStoreOp; |
| uint32_t mStencilLoadOp; |
| uint32_t mStencilStoreOp; |
| uint32_t mInitialLayout; |
| uint32_t mFinalLayout; |
| }; |
| |
| class VkAttachmentDescription__S: public Encodable { |
| public: |
| VkAttachmentDescription__S() = default; |
| VkAttachmentDescription__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkAttachmentDescription__P: public Encodable { |
| public: |
| VkAttachmentDescription__P() = default; |
| VkAttachmentDescription__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAttachmentDescription__CP: public Encodable { |
| public: |
| VkAttachmentDescription__CP() = default; |
| VkAttachmentDescription__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAttachmentReference: public Encodable { |
| public: |
| VkAttachmentReference() = default; |
| VkAttachmentReference(uint32_t Attachment, uint32_t Layout) |
| : mAttachment(Attachment) |
| , mLayout(Layout) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mAttachment); |
| e->Uint32(this->mLayout); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mAttachment; |
| uint32_t mLayout; |
| }; |
| |
| class VkAttachmentReference__S: public Encodable { |
| public: |
| VkAttachmentReference__S() = default; |
| VkAttachmentReference__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkAttachmentReference__P: public Encodable { |
| public: |
| VkAttachmentReference__P() = default; |
| VkAttachmentReference__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkAttachmentReference__CP: public Encodable { |
| public: |
| VkAttachmentReference__CP() = default; |
| VkAttachmentReference__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCommandBufferBeginInfo__CP: public Encodable { |
| public: |
| VkCommandBufferBeginInfo__CP() = default; |
| VkCommandBufferBeginInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBeginCommandBuffer: public Encodable { |
| public: |
| VkBeginCommandBuffer() = default; |
| VkBeginCommandBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, VkCommandBufferBeginInfo__CP PBeginInfo, uint32_t Result) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mPBeginInfo(PBeginInfo) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| VkCommandBufferBeginInfo__CP mPBeginInfo; |
| uint32_t mResult; |
| }; |
| |
| class VkBindBufferMemory: public Encodable { |
| public: |
| VkBindBufferMemory() = default; |
| VkBindBufferMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Buffer, uint64_t Memory, uint64_t MemoryOffset, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mBuffer(Buffer) |
| , mMemory(Memory) |
| , mMemoryOffset(MemoryOffset) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mBuffer; |
| uint64_t mMemory; |
| uint64_t mMemoryOffset; |
| uint32_t mResult; |
| }; |
| |
| class VkBindImageMemory: public Encodable { |
| public: |
| VkBindImageMemory() = default; |
| VkBindImageMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, uint64_t Memory, uint64_t MemoryOffset, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mImage(Image) |
| , mMemory(Memory) |
| , mMemoryOffset(MemoryOffset) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mImage; |
| uint64_t mMemory; |
| uint64_t mMemoryOffset; |
| uint32_t mResult; |
| }; |
| |
| class VkSemaphore__CP: public Encodable { |
| public: |
| VkSemaphore__CP() = default; |
| VkSemaphore__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSparseBufferMemoryBindInfo__CP: public Encodable { |
| public: |
| VkSparseBufferMemoryBindInfo__CP() = default; |
| VkSparseBufferMemoryBindInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSparseImageOpaqueMemoryBindInfo__CP: public Encodable { |
| public: |
| VkSparseImageOpaqueMemoryBindInfo__CP() = default; |
| VkSparseImageOpaqueMemoryBindInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSparseImageMemoryBindInfo__CP: public Encodable { |
| public: |
| VkSparseImageMemoryBindInfo__CP() = default; |
| VkSparseImageMemoryBindInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBindSparseInfo: public Encodable { |
| public: |
| VkBindSparseInfo() = default; |
| VkBindSparseInfo(uint32_t SType, Void__CP PNext, uint32_t WaitSemaphoreCount, VkSemaphore__CP PWaitSemaphores, uint32_t NumBufferBinds, VkSparseBufferMemoryBindInfo__CP PBufferBinds, uint32_t NumImageOpaqueBinds, VkSparseImageOpaqueMemoryBindInfo__CP PImageOpaqueBinds, uint32_t NumImageBinds, VkSparseImageMemoryBindInfo__CP PImageBinds, uint32_t SignalSemaphoreCount, VkSemaphore__CP PSignalSemaphores) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mWaitSemaphoreCount(WaitSemaphoreCount) |
| , mPWaitSemaphores(PWaitSemaphores) |
| , mNumBufferBinds(NumBufferBinds) |
| , mPBufferBinds(PBufferBinds) |
| , mNumImageOpaqueBinds(NumImageOpaqueBinds) |
| , mPImageOpaqueBinds(PImageOpaqueBinds) |
| , mNumImageBinds(NumImageBinds) |
| , mPImageBinds(PImageBinds) |
| , mSignalSemaphoreCount(SignalSemaphoreCount) |
| , mPSignalSemaphores(PSignalSemaphores) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mWaitSemaphoreCount; |
| VkSemaphore__CP mPWaitSemaphores; |
| uint32_t mNumBufferBinds; |
| VkSparseBufferMemoryBindInfo__CP mPBufferBinds; |
| uint32_t mNumImageOpaqueBinds; |
| VkSparseImageOpaqueMemoryBindInfo__CP mPImageOpaqueBinds; |
| uint32_t mNumImageBinds; |
| VkSparseImageMemoryBindInfo__CP mPImageBinds; |
| uint32_t mSignalSemaphoreCount; |
| VkSemaphore__CP mPSignalSemaphores; |
| }; |
| |
| class VkBindSparseInfo__S: public Encodable { |
| public: |
| VkBindSparseInfo__S() = default; |
| VkBindSparseInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkBindSparseInfo__P: public Encodable { |
| public: |
| VkBindSparseInfo__P() = default; |
| VkBindSparseInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBindSparseInfo__CP: public Encodable { |
| public: |
| VkBindSparseInfo__CP() = default; |
| VkBindSparseInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBool32__S: public Encodable { |
| public: |
| VkBool32__S() = default; |
| VkBool32__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkBool32__P: public Encodable { |
| public: |
| VkBool32__P() = default; |
| VkBool32__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferCopy__S: public Encodable { |
| public: |
| VkBufferCopy__S() = default; |
| VkBufferCopy__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkBufferCopy__P: public Encodable { |
| public: |
| VkBufferCopy__P() = default; |
| VkBufferCopy__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferCopy__CP: public Encodable { |
| public: |
| VkBufferCopy__CP() = default; |
| VkBufferCopy__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferCreateInfo: public Encodable { |
| public: |
| VkBufferCreateInfo() = default; |
| VkBufferCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t Size, uint32_t Usage, uint32_t SharingMode, uint32_t QueueFamilyIndexCount, U32__CP PQueueFamilyIndices) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mSize(Size) |
| , mUsage(Usage) |
| , mSharingMode(SharingMode) |
| , mQueueFamilyIndexCount(QueueFamilyIndexCount) |
| , mPQueueFamilyIndices(PQueueFamilyIndices) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint64_t mSize; |
| uint32_t mUsage; |
| uint32_t mSharingMode; |
| uint32_t mQueueFamilyIndexCount; |
| U32__CP mPQueueFamilyIndices; |
| }; |
| |
| class VkBufferCreateInfo__S: public Encodable { |
| public: |
| VkBufferCreateInfo__S() = default; |
| VkBufferCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkBufferCreateInfo__P: public Encodable { |
| public: |
| VkBufferCreateInfo__P() = default; |
| VkBufferCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferCreateInfo__CP: public Encodable { |
| public: |
| VkBufferCreateInfo__CP() = default; |
| VkBufferCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferImageCopy__S: public Encodable { |
| public: |
| VkBufferImageCopy__S() = default; |
| VkBufferImageCopy__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkBufferImageCopy__P: public Encodable { |
| public: |
| VkBufferImageCopy__P() = default; |
| VkBufferImageCopy__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferImageCopy__CP: public Encodable { |
| public: |
| VkBufferImageCopy__CP() = default; |
| VkBufferImageCopy__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferMemoryBarrier: public Encodable { |
| public: |
| VkBufferMemoryBarrier() = default; |
| VkBufferMemoryBarrier(uint32_t SType, Void__CP PNext, uint32_t SrcAccessMask, uint32_t DstAccessMask, uint32_t SrcQueueFamilyIndex, uint32_t DstQueueFamilyIndex, uint64_t Buffer, uint64_t Offset, uint64_t Size) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mSrcAccessMask(SrcAccessMask) |
| , mDstAccessMask(DstAccessMask) |
| , mSrcQueueFamilyIndex(SrcQueueFamilyIndex) |
| , mDstQueueFamilyIndex(DstQueueFamilyIndex) |
| , mBuffer(Buffer) |
| , mOffset(Offset) |
| , mSize(Size) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mSrcAccessMask; |
| uint32_t mDstAccessMask; |
| uint32_t mSrcQueueFamilyIndex; |
| uint32_t mDstQueueFamilyIndex; |
| uint64_t mBuffer; |
| uint64_t mOffset; |
| uint64_t mSize; |
| }; |
| |
| class VkBufferMemoryBarrier__S: public Encodable { |
| public: |
| VkBufferMemoryBarrier__S() = default; |
| VkBufferMemoryBarrier__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkBufferMemoryBarrier__P: public Encodable { |
| public: |
| VkBufferMemoryBarrier__P() = default; |
| VkBufferMemoryBarrier__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferMemoryBarrier__CP: public Encodable { |
| public: |
| VkBufferMemoryBarrier__CP() = default; |
| VkBufferMemoryBarrier__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferViewCreateInfo: public Encodable { |
| public: |
| VkBufferViewCreateInfo() = default; |
| VkBufferViewCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t Buffer, uint32_t Format, uint64_t Offset, uint64_t Range) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mBuffer(Buffer) |
| , mFormat(Format) |
| , mOffset(Offset) |
| , mRange(Range) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint64_t mBuffer; |
| uint32_t mFormat; |
| uint64_t mOffset; |
| uint64_t mRange; |
| }; |
| |
| class VkBufferViewCreateInfo__S: public Encodable { |
| public: |
| VkBufferViewCreateInfo__S() = default; |
| VkBufferViewCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkBufferViewCreateInfo__P: public Encodable { |
| public: |
| VkBufferViewCreateInfo__P() = default; |
| VkBufferViewCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferViewCreateInfo__CP: public Encodable { |
| public: |
| VkBufferViewCreateInfo__CP() = default; |
| VkBufferViewCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferView__S: public Encodable { |
| public: |
| VkBufferView__S() = default; |
| VkBufferView__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkBufferView__P: public Encodable { |
| public: |
| VkBufferView__P() = default; |
| VkBufferView__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBufferView__CP: public Encodable { |
| public: |
| VkBufferView__CP() = default; |
| VkBufferView__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBuffer__S: public Encodable { |
| public: |
| VkBuffer__S() = default; |
| VkBuffer__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkBuffer__P: public Encodable { |
| public: |
| VkBuffer__P() = default; |
| VkBuffer__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkBuffer__CP: public Encodable { |
| public: |
| VkBuffer__CP() = default; |
| VkBuffer__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkClearColorValue: public Encodable { |
| public: |
| VkClearColorValue() = default; |
| VkClearColorValue(U32__4__A Uint32) |
| : mUint32(Uint32) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mUint32); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| U32__4__A mUint32; |
| }; |
| |
| class VkClearValue: public Encodable { |
| public: |
| VkClearValue() = default; |
| VkClearValue(VkClearColorValue Color) |
| : mColor(Color) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mColor); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkClearColorValue mColor; |
| }; |
| |
| class VkClearAttachment: public Encodable { |
| public: |
| VkClearAttachment() = default; |
| VkClearAttachment(uint32_t AspectMask, uint32_t ColorAttachment, VkClearValue ClearValue) |
| : mAspectMask(AspectMask) |
| , mColorAttachment(ColorAttachment) |
| , mClearValue(ClearValue) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mAspectMask); |
| e->Uint32(this->mColorAttachment); |
| e->Struct(this->mClearValue); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mAspectMask; |
| uint32_t mColorAttachment; |
| VkClearValue mClearValue; |
| }; |
| |
| class VkClearAttachment__S: public Encodable { |
| public: |
| VkClearAttachment__S() = default; |
| VkClearAttachment__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkClearAttachment__P: public Encodable { |
| public: |
| VkClearAttachment__P() = default; |
| VkClearAttachment__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkClearAttachment__CP: public Encodable { |
| public: |
| VkClearAttachment__CP() = default; |
| VkClearAttachment__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkClearColorValue__S: public Encodable { |
| public: |
| VkClearColorValue__S() = default; |
| VkClearColorValue__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkClearColorValue__P: public Encodable { |
| public: |
| VkClearColorValue__P() = default; |
| VkClearColorValue__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkClearColorValue__CP: public Encodable { |
| public: |
| VkClearColorValue__CP() = default; |
| VkClearColorValue__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkClearDepthStencilValue: public Encodable { |
| public: |
| VkClearDepthStencilValue() = default; |
| VkClearDepthStencilValue(float Depth, uint32_t Stencil) |
| : mDepth(Depth) |
| , mStencil(Stencil) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Float32(this->mDepth); |
| e->Uint32(this->mStencil); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| float mDepth; |
| uint32_t mStencil; |
| }; |
| |
| class VkClearDepthStencilValue__S: public Encodable { |
| public: |
| VkClearDepthStencilValue__S() = default; |
| VkClearDepthStencilValue__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkClearDepthStencilValue__P: public Encodable { |
| public: |
| VkClearDepthStencilValue__P() = default; |
| VkClearDepthStencilValue__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkClearDepthStencilValue__CP: public Encodable { |
| public: |
| VkClearDepthStencilValue__CP() = default; |
| VkClearDepthStencilValue__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkOffset2D: public Encodable { |
| public: |
| VkOffset2D() = default; |
| VkOffset2D(int32_t X, int32_t Y) |
| : mX(X) |
| , mY(Y) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Int32(this->mX); |
| e->Int32(this->mY); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| int32_t mX; |
| int32_t mY; |
| }; |
| |
| class VkExtent2D: public Encodable { |
| public: |
| VkExtent2D() = default; |
| VkExtent2D(uint32_t Width, uint32_t Height) |
| : mWidth(Width) |
| , mHeight(Height) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mWidth); |
| e->Uint32(this->mHeight); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mWidth; |
| uint32_t mHeight; |
| }; |
| |
| class VkRect2D: public Encodable { |
| public: |
| VkRect2D() = default; |
| VkRect2D(VkOffset2D Offset, VkExtent2D Extent) |
| : mOffset(Offset) |
| , mExtent(Extent) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mOffset); |
| e->Struct(this->mExtent); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkOffset2D mOffset; |
| VkExtent2D mExtent; |
| }; |
| |
| class VkClearRect: public Encodable { |
| public: |
| VkClearRect() = default; |
| VkClearRect(VkRect2D Rect, uint32_t BaseArrayLayer, uint32_t LayerCount) |
| : mRect(Rect) |
| , mBaseArrayLayer(BaseArrayLayer) |
| , mLayerCount(LayerCount) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mRect); |
| e->Uint32(this->mBaseArrayLayer); |
| e->Uint32(this->mLayerCount); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkRect2D mRect; |
| uint32_t mBaseArrayLayer; |
| uint32_t mLayerCount; |
| }; |
| |
| class VkClearRect__S: public Encodable { |
| public: |
| VkClearRect__S() = default; |
| VkClearRect__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkClearRect__P: public Encodable { |
| public: |
| VkClearRect__P() = default; |
| VkClearRect__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkClearRect__CP: public Encodable { |
| public: |
| VkClearRect__CP() = default; |
| VkClearRect__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkClearValue__S: public Encodable { |
| public: |
| VkClearValue__S() = default; |
| VkClearValue__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkClearValue__P: public Encodable { |
| public: |
| VkClearValue__P() = default; |
| VkClearValue__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkClearValue__CP: public Encodable { |
| public: |
| VkClearValue__CP() = default; |
| VkClearValue__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdBeginQuery: public Encodable { |
| public: |
| VkCmdBeginQuery() = default; |
| VkCmdBeginQuery(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t QueryPool, uint32_t Query, uint32_t Flags) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mQueryPool(QueryPool) |
| , mQuery(Query) |
| , mFlags(Flags) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mQueryPool; |
| uint32_t mQuery; |
| uint32_t mFlags; |
| }; |
| |
| class VkRenderPassBeginInfo__CP: public Encodable { |
| public: |
| VkRenderPassBeginInfo__CP() = default; |
| VkRenderPassBeginInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdBeginRenderPass: public Encodable { |
| public: |
| VkCmdBeginRenderPass() = default; |
| VkCmdBeginRenderPass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, VkRenderPassBeginInfo__CP PRenderPassBegin, uint32_t Contents) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mPRenderPassBegin(PRenderPassBegin) |
| , mContents(Contents) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| VkRenderPassBeginInfo__CP mPRenderPassBegin; |
| uint32_t mContents; |
| }; |
| |
| class VkDescriptorSet__CP: public Encodable { |
| public: |
| VkDescriptorSet__CP() = default; |
| VkDescriptorSet__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdBindDescriptorSets: public Encodable { |
| public: |
| VkCmdBindDescriptorSets() = default; |
| VkCmdBindDescriptorSets(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t PipelineBindPoint, uint64_t Layout, uint32_t FirstSet, uint32_t DescriptorSetCount, VkDescriptorSet__CP PDescriptorSets, uint32_t DynamicOffsetCount, U32__CP PDynamicOffsets) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mPipelineBindPoint(PipelineBindPoint) |
| , mLayout(Layout) |
| , mFirstSet(FirstSet) |
| , mDescriptorSetCount(DescriptorSetCount) |
| , mPDescriptorSets(PDescriptorSets) |
| , mDynamicOffsetCount(DynamicOffsetCount) |
| , mPDynamicOffsets(PDynamicOffsets) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mPipelineBindPoint; |
| uint64_t mLayout; |
| uint32_t mFirstSet; |
| uint32_t mDescriptorSetCount; |
| VkDescriptorSet__CP mPDescriptorSets; |
| uint32_t mDynamicOffsetCount; |
| U32__CP mPDynamicOffsets; |
| }; |
| |
| class VkCmdBindIndexBuffer: public Encodable { |
| public: |
| VkCmdBindIndexBuffer() = default; |
| VkCmdBindIndexBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Buffer, uint64_t Offset, uint32_t IndexType) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mBuffer(Buffer) |
| , mOffset(Offset) |
| , mIndexType(IndexType) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mBuffer; |
| uint64_t mOffset; |
| uint32_t mIndexType; |
| }; |
| |
| class VkCmdBindPipeline: public Encodable { |
| public: |
| VkCmdBindPipeline() = default; |
| VkCmdBindPipeline(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t PipelineBindPoint, uint64_t Pipeline) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mPipelineBindPoint(PipelineBindPoint) |
| , mPipeline(Pipeline) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mPipelineBindPoint; |
| uint64_t mPipeline; |
| }; |
| |
| class VkDeviceSize__CP: public Encodable { |
| public: |
| VkDeviceSize__CP() = default; |
| VkDeviceSize__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdBindVertexBuffers: public Encodable { |
| public: |
| VkCmdBindVertexBuffers() = default; |
| VkCmdBindVertexBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FirstBinding, uint32_t BindingCount, VkBuffer__CP PBuffers, VkDeviceSize__CP POffsets) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mFirstBinding(FirstBinding) |
| , mBindingCount(BindingCount) |
| , mPBuffers(PBuffers) |
| , mPOffsets(POffsets) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mFirstBinding; |
| uint32_t mBindingCount; |
| VkBuffer__CP mPBuffers; |
| VkDeviceSize__CP mPOffsets; |
| }; |
| |
| class VkImageBlit__CP: public Encodable { |
| public: |
| VkImageBlit__CP() = default; |
| VkImageBlit__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdBlitImage: public Encodable { |
| public: |
| VkCmdBlitImage() = default; |
| VkCmdBlitImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcImage, uint32_t SrcImageLayout, uint64_t DstImage, uint32_t DstImageLayout, uint32_t RegionCount, VkImageBlit__CP PRegions, uint32_t Filter) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mSrcImage(SrcImage) |
| , mSrcImageLayout(SrcImageLayout) |
| , mDstImage(DstImage) |
| , mDstImageLayout(DstImageLayout) |
| , mRegionCount(RegionCount) |
| , mPRegions(PRegions) |
| , mFilter(Filter) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mSrcImage; |
| uint32_t mSrcImageLayout; |
| uint64_t mDstImage; |
| uint32_t mDstImageLayout; |
| uint32_t mRegionCount; |
| VkImageBlit__CP mPRegions; |
| uint32_t mFilter; |
| }; |
| |
| class VkCmdClearAttachments: public Encodable { |
| public: |
| VkCmdClearAttachments() = default; |
| VkCmdClearAttachments(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t AttachmentCount, VkClearAttachment__CP PAttachments, uint32_t RectCount, VkClearRect__CP PRects) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mAttachmentCount(AttachmentCount) |
| , mPAttachments(PAttachments) |
| , mRectCount(RectCount) |
| , mPRects(PRects) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mAttachmentCount; |
| VkClearAttachment__CP mPAttachments; |
| uint32_t mRectCount; |
| VkClearRect__CP mPRects; |
| }; |
| |
| class VkImageSubresourceRange__CP: public Encodable { |
| public: |
| VkImageSubresourceRange__CP() = default; |
| VkImageSubresourceRange__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdClearColorImage: public Encodable { |
| public: |
| VkCmdClearColorImage() = default; |
| VkCmdClearColorImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Image, uint32_t ImageLayout, VkClearColorValue__CP PColor, uint32_t RangeCount, VkImageSubresourceRange__CP PRanges) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mImage(Image) |
| , mImageLayout(ImageLayout) |
| , mPColor(PColor) |
| , mRangeCount(RangeCount) |
| , mPRanges(PRanges) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mImage; |
| uint32_t mImageLayout; |
| VkClearColorValue__CP mPColor; |
| uint32_t mRangeCount; |
| VkImageSubresourceRange__CP mPRanges; |
| }; |
| |
| class VkCmdClearDepthStencilImage: public Encodable { |
| public: |
| VkCmdClearDepthStencilImage() = default; |
| VkCmdClearDepthStencilImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Image, uint32_t ImageLayout, VkClearDepthStencilValue__CP PDepthStencil, uint32_t RangeCount, VkImageSubresourceRange__CP PRanges) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mImage(Image) |
| , mImageLayout(ImageLayout) |
| , mPDepthStencil(PDepthStencil) |
| , mRangeCount(RangeCount) |
| , mPRanges(PRanges) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mImage; |
| uint32_t mImageLayout; |
| VkClearDepthStencilValue__CP mPDepthStencil; |
| uint32_t mRangeCount; |
| VkImageSubresourceRange__CP mPRanges; |
| }; |
| |
| class VkCmdCopyBuffer: public Encodable { |
| public: |
| VkCmdCopyBuffer() = default; |
| VkCmdCopyBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcBuffer, uint64_t DstBuffer, uint32_t RegionCount, VkBufferCopy__CP PRegions) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mSrcBuffer(SrcBuffer) |
| , mDstBuffer(DstBuffer) |
| , mRegionCount(RegionCount) |
| , mPRegions(PRegions) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mSrcBuffer; |
| uint64_t mDstBuffer; |
| uint32_t mRegionCount; |
| VkBufferCopy__CP mPRegions; |
| }; |
| |
| class VkCmdCopyBufferToImage: public Encodable { |
| public: |
| VkCmdCopyBufferToImage() = default; |
| VkCmdCopyBufferToImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcBuffer, uint64_t DstImage, uint32_t DstImageLayout, uint32_t RegionCount, VkBufferImageCopy__CP PRegions) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mSrcBuffer(SrcBuffer) |
| , mDstImage(DstImage) |
| , mDstImageLayout(DstImageLayout) |
| , mRegionCount(RegionCount) |
| , mPRegions(PRegions) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mSrcBuffer; |
| uint64_t mDstImage; |
| uint32_t mDstImageLayout; |
| uint32_t mRegionCount; |
| VkBufferImageCopy__CP mPRegions; |
| }; |
| |
| class VkImageCopy__CP: public Encodable { |
| public: |
| VkImageCopy__CP() = default; |
| VkImageCopy__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdCopyImage: public Encodable { |
| public: |
| VkCmdCopyImage() = default; |
| VkCmdCopyImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcImage, uint32_t SrcImageLayout, uint64_t DstImage, uint32_t DstImageLayout, uint32_t RegionCount, VkImageCopy__CP PRegions) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mSrcImage(SrcImage) |
| , mSrcImageLayout(SrcImageLayout) |
| , mDstImage(DstImage) |
| , mDstImageLayout(DstImageLayout) |
| , mRegionCount(RegionCount) |
| , mPRegions(PRegions) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mSrcImage; |
| uint32_t mSrcImageLayout; |
| uint64_t mDstImage; |
| uint32_t mDstImageLayout; |
| uint32_t mRegionCount; |
| VkImageCopy__CP mPRegions; |
| }; |
| |
| class VkCmdCopyImageToBuffer: public Encodable { |
| public: |
| VkCmdCopyImageToBuffer() = default; |
| VkCmdCopyImageToBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcImage, uint32_t SrcImageLayout, uint64_t DstBuffer, uint32_t RegionCount, VkBufferImageCopy__CP PRegions) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mSrcImage(SrcImage) |
| , mSrcImageLayout(SrcImageLayout) |
| , mDstBuffer(DstBuffer) |
| , mRegionCount(RegionCount) |
| , mPRegions(PRegions) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mSrcImage; |
| uint32_t mSrcImageLayout; |
| uint64_t mDstBuffer; |
| uint32_t mRegionCount; |
| VkBufferImageCopy__CP mPRegions; |
| }; |
| |
| class VkCmdCopyQueryPoolResults: public Encodable { |
| public: |
| VkCmdCopyQueryPoolResults() = default; |
| VkCmdCopyQueryPoolResults(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t QueryPool, uint32_t FirstQuery, uint32_t QueryCount, uint64_t DstBuffer, uint64_t DstOffset, uint64_t Stride, uint32_t Flags) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mQueryPool(QueryPool) |
| , mFirstQuery(FirstQuery) |
| , mQueryCount(QueryCount) |
| , mDstBuffer(DstBuffer) |
| , mDstOffset(DstOffset) |
| , mStride(Stride) |
| , mFlags(Flags) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mQueryPool; |
| uint32_t mFirstQuery; |
| uint32_t mQueryCount; |
| uint64_t mDstBuffer; |
| uint64_t mDstOffset; |
| uint64_t mStride; |
| uint32_t mFlags; |
| }; |
| |
| class VkCmdDispatch: public Encodable { |
| public: |
| VkCmdDispatch() = default; |
| VkCmdDispatch(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t X, uint32_t Y, uint32_t Z) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mX(X) |
| , mY(Y) |
| , mZ(Z) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mX; |
| uint32_t mY; |
| uint32_t mZ; |
| }; |
| |
| class VkCmdDispatchIndirect: public Encodable { |
| public: |
| VkCmdDispatchIndirect() = default; |
| VkCmdDispatchIndirect(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Buffer, uint64_t Offset) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mBuffer(Buffer) |
| , mOffset(Offset) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mBuffer; |
| uint64_t mOffset; |
| }; |
| |
| class VkCmdDraw: public Encodable { |
| public: |
| VkCmdDraw() = default; |
| VkCmdDraw(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t VertexCount, uint32_t InstanceCount, uint32_t FirstVertex, uint32_t FirstInstance) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mVertexCount(VertexCount) |
| , mInstanceCount(InstanceCount) |
| , mFirstVertex(FirstVertex) |
| , mFirstInstance(FirstInstance) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mVertexCount; |
| uint32_t mInstanceCount; |
| uint32_t mFirstVertex; |
| uint32_t mFirstInstance; |
| }; |
| |
| class VkCmdDrawIndexed: public Encodable { |
| public: |
| VkCmdDrawIndexed() = default; |
| VkCmdDrawIndexed(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t IndexCount, uint32_t InstanceCount, uint32_t FirstIndex, int32_t VertexOffset, uint32_t FirstInstance) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mIndexCount(IndexCount) |
| , mInstanceCount(InstanceCount) |
| , mFirstIndex(FirstIndex) |
| , mVertexOffset(VertexOffset) |
| , mFirstInstance(FirstInstance) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mIndexCount; |
| uint32_t mInstanceCount; |
| uint32_t mFirstIndex; |
| int32_t mVertexOffset; |
| uint32_t mFirstInstance; |
| }; |
| |
| class VkCmdDrawIndexedIndirect: public Encodable { |
| public: |
| VkCmdDrawIndexedIndirect() = default; |
| VkCmdDrawIndexedIndirect(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Buffer, uint64_t Offset, uint32_t DrawCount, uint32_t Stride) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mBuffer(Buffer) |
| , mOffset(Offset) |
| , mDrawCount(DrawCount) |
| , mStride(Stride) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mBuffer; |
| uint64_t mOffset; |
| uint32_t mDrawCount; |
| uint32_t mStride; |
| }; |
| |
| class VkCmdDrawIndirect: public Encodable { |
| public: |
| VkCmdDrawIndirect() = default; |
| VkCmdDrawIndirect(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Buffer, uint64_t Offset, uint32_t DrawCount, uint32_t Stride) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mBuffer(Buffer) |
| , mOffset(Offset) |
| , mDrawCount(DrawCount) |
| , mStride(Stride) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mBuffer; |
| uint64_t mOffset; |
| uint32_t mDrawCount; |
| uint32_t mStride; |
| }; |
| |
| class VkCmdEndQuery: public Encodable { |
| public: |
| VkCmdEndQuery() = default; |
| VkCmdEndQuery(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t QueryPool, uint32_t Query) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mQueryPool(QueryPool) |
| , mQuery(Query) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mQueryPool; |
| uint32_t mQuery; |
| }; |
| |
| class VkCmdEndRenderPass: public Encodable { |
| public: |
| VkCmdEndRenderPass() = default; |
| VkCmdEndRenderPass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mCommandBuffer); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| }; |
| |
| class VkCommandBuffer__CP: public Encodable { |
| public: |
| VkCommandBuffer__CP() = default; |
| VkCommandBuffer__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdExecuteCommands: public Encodable { |
| public: |
| VkCmdExecuteCommands() = default; |
| VkCmdExecuteCommands(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t CommandBufferCount, VkCommandBuffer__CP PCommandBuffers) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mCommandBufferCount(CommandBufferCount) |
| , mPCommandBuffers(PCommandBuffers) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mCommandBufferCount; |
| VkCommandBuffer__CP mPCommandBuffers; |
| }; |
| |
| class VkCmdFillBuffer: public Encodable { |
| public: |
| VkCmdFillBuffer() = default; |
| VkCmdFillBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t DstBuffer, uint64_t DstOffset, uint64_t Size, uint32_t Data) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mDstBuffer(DstBuffer) |
| , mDstOffset(DstOffset) |
| , mSize(Size) |
| , mData(Data) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mDstBuffer; |
| uint64_t mDstOffset; |
| uint64_t mSize; |
| uint32_t mData; |
| }; |
| |
| class VkCmdNextSubpass: public Encodable { |
| public: |
| VkCmdNextSubpass() = default; |
| VkCmdNextSubpass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t Contents) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mContents(Contents) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mCommandBuffer); |
| e->Uint32(this->mContents); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mContents; |
| }; |
| |
| class VkMemoryBarrier__CP: public Encodable { |
| public: |
| VkMemoryBarrier__CP() = default; |
| VkMemoryBarrier__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageMemoryBarrier__CP: public Encodable { |
| public: |
| VkImageMemoryBarrier__CP() = default; |
| VkImageMemoryBarrier__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdPipelineBarrier: public Encodable { |
| public: |
| VkCmdPipelineBarrier() = default; |
| VkCmdPipelineBarrier(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t SrcStageMask, uint32_t DstStageMask, uint32_t DependencyFlags, uint32_t MemoryBarrierCount, VkMemoryBarrier__CP PMemoryBarriers, uint32_t BufferMemoryBarrierCount, VkBufferMemoryBarrier__CP PBufferMemoryBarriers, uint32_t ImageMemoryBarrierCount, VkImageMemoryBarrier__CP PImageMemoryBarriers) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mSrcStageMask(SrcStageMask) |
| , mDstStageMask(DstStageMask) |
| , mDependencyFlags(DependencyFlags) |
| , mMemoryBarrierCount(MemoryBarrierCount) |
| , mPMemoryBarriers(PMemoryBarriers) |
| , mBufferMemoryBarrierCount(BufferMemoryBarrierCount) |
| , mPBufferMemoryBarriers(PBufferMemoryBarriers) |
| , mImageMemoryBarrierCount(ImageMemoryBarrierCount) |
| , mPImageMemoryBarriers(PImageMemoryBarriers) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mSrcStageMask; |
| uint32_t mDstStageMask; |
| uint32_t mDependencyFlags; |
| uint32_t mMemoryBarrierCount; |
| VkMemoryBarrier__CP mPMemoryBarriers; |
| uint32_t mBufferMemoryBarrierCount; |
| VkBufferMemoryBarrier__CP mPBufferMemoryBarriers; |
| uint32_t mImageMemoryBarrierCount; |
| VkImageMemoryBarrier__CP mPImageMemoryBarriers; |
| }; |
| |
| class VkCmdPushConstants: public Encodable { |
| public: |
| VkCmdPushConstants() = default; |
| VkCmdPushConstants(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Layout, uint32_t StageFlags, uint32_t Offset, uint32_t Size, Void__CP PValues) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mLayout(Layout) |
| , mStageFlags(StageFlags) |
| , mOffset(Offset) |
| , mSize(Size) |
| , mPValues(PValues) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mLayout; |
| uint32_t mStageFlags; |
| uint32_t mOffset; |
| uint32_t mSize; |
| Void__CP mPValues; |
| }; |
| |
| class VkCmdResetEvent: public Encodable { |
| public: |
| VkCmdResetEvent() = default; |
| VkCmdResetEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Event, uint32_t StageMask) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mEvent(Event) |
| , mStageMask(StageMask) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mEvent; |
| uint32_t mStageMask; |
| }; |
| |
| class VkCmdResetQueryPool: public Encodable { |
| public: |
| VkCmdResetQueryPool() = default; |
| VkCmdResetQueryPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t QueryPool, uint32_t FirstQuery, uint32_t QueryCount) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mQueryPool(QueryPool) |
| , mFirstQuery(FirstQuery) |
| , mQueryCount(QueryCount) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mQueryPool; |
| uint32_t mFirstQuery; |
| uint32_t mQueryCount; |
| }; |
| |
| class VkImageResolve__CP: public Encodable { |
| public: |
| VkImageResolve__CP() = default; |
| VkImageResolve__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdResolveImage: public Encodable { |
| public: |
| VkCmdResolveImage() = default; |
| VkCmdResolveImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t SrcImage, uint32_t SrcImageLayout, uint64_t DstImage, uint32_t DstImageLayout, uint32_t RegionCount, VkImageResolve__CP PRegions) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mSrcImage(SrcImage) |
| , mSrcImageLayout(SrcImageLayout) |
| , mDstImage(DstImage) |
| , mDstImageLayout(DstImageLayout) |
| , mRegionCount(RegionCount) |
| , mPRegions(PRegions) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mSrcImage; |
| uint32_t mSrcImageLayout; |
| uint64_t mDstImage; |
| uint32_t mDstImageLayout; |
| uint32_t mRegionCount; |
| VkImageResolve__CP mPRegions; |
| }; |
| |
| class VkCmdSetBlendConstants: public Encodable { |
| public: |
| VkCmdSetBlendConstants() = default; |
| VkCmdSetBlendConstants(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, F32__4__A BlendConstants) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mBlendConstants(BlendConstants) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mCommandBuffer); |
| e->Struct(this->mBlendConstants); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| F32__4__A mBlendConstants; |
| }; |
| |
| class VkCmdSetDepthBias: public Encodable { |
| public: |
| VkCmdSetDepthBias() = default; |
| VkCmdSetDepthBias(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, float DepthBiasConstantFactor, float DepthBiasClamp, float DepthBiasSlopeFactor) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mDepthBiasConstantFactor(DepthBiasConstantFactor) |
| , mDepthBiasClamp(DepthBiasClamp) |
| , mDepthBiasSlopeFactor(DepthBiasSlopeFactor) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| float mDepthBiasConstantFactor; |
| float mDepthBiasClamp; |
| float mDepthBiasSlopeFactor; |
| }; |
| |
| class VkCmdSetDepthBounds: public Encodable { |
| public: |
| VkCmdSetDepthBounds() = default; |
| VkCmdSetDepthBounds(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, float MinDepthBounds, float MaxDepthBounds) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mMinDepthBounds(MinDepthBounds) |
| , mMaxDepthBounds(MaxDepthBounds) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| float mMinDepthBounds; |
| float mMaxDepthBounds; |
| }; |
| |
| class VkCmdSetEvent: public Encodable { |
| public: |
| VkCmdSetEvent() = default; |
| VkCmdSetEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t Event, uint32_t StageMask) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mEvent(Event) |
| , mStageMask(StageMask) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mEvent; |
| uint32_t mStageMask; |
| }; |
| |
| class VkCmdSetLineWidth: public Encodable { |
| public: |
| VkCmdSetLineWidth() = default; |
| VkCmdSetLineWidth(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, float LineWidth) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mLineWidth(LineWidth) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mCommandBuffer); |
| e->Float32(this->mLineWidth); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| float mLineWidth; |
| }; |
| |
| class VkRect2D__CP: public Encodable { |
| public: |
| VkRect2D__CP() = default; |
| VkRect2D__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdSetScissor: public Encodable { |
| public: |
| VkCmdSetScissor() = default; |
| VkCmdSetScissor(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FirstScissor, uint32_t ScissorCount, VkRect2D__CP PScissors) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mFirstScissor(FirstScissor) |
| , mScissorCount(ScissorCount) |
| , mPScissors(PScissors) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mFirstScissor; |
| uint32_t mScissorCount; |
| VkRect2D__CP mPScissors; |
| }; |
| |
| class VkCmdSetStencilCompareMask: public Encodable { |
| public: |
| VkCmdSetStencilCompareMask() = default; |
| VkCmdSetStencilCompareMask(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FaceMask, uint32_t CompareMask) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mFaceMask(FaceMask) |
| , mCompareMask(CompareMask) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mFaceMask; |
| uint32_t mCompareMask; |
| }; |
| |
| class VkCmdSetStencilReference: public Encodable { |
| public: |
| VkCmdSetStencilReference() = default; |
| VkCmdSetStencilReference(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FaceMask, uint32_t Reference) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mFaceMask(FaceMask) |
| , mReference(Reference) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mFaceMask; |
| uint32_t mReference; |
| }; |
| |
| class VkCmdSetStencilWriteMask: public Encodable { |
| public: |
| VkCmdSetStencilWriteMask() = default; |
| VkCmdSetStencilWriteMask(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FaceMask, uint32_t WriteMask) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mFaceMask(FaceMask) |
| , mWriteMask(WriteMask) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mFaceMask; |
| uint32_t mWriteMask; |
| }; |
| |
| class VkViewport__CP: public Encodable { |
| public: |
| VkViewport__CP() = default; |
| VkViewport__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdSetViewport: public Encodable { |
| public: |
| VkCmdSetViewport() = default; |
| VkCmdSetViewport(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t FirstViewport, uint32_t ViewportCount, VkViewport__CP PViewports) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mFirstViewport(FirstViewport) |
| , mViewportCount(ViewportCount) |
| , mPViewports(PViewports) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mFirstViewport; |
| uint32_t mViewportCount; |
| VkViewport__CP mPViewports; |
| }; |
| |
| class VkCmdUpdateBuffer: public Encodable { |
| public: |
| VkCmdUpdateBuffer() = default; |
| VkCmdUpdateBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint64_t DstBuffer, uint64_t DstOffset, uint64_t DataSize, Void__CP PData) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mDstBuffer(DstBuffer) |
| , mDstOffset(DstOffset) |
| , mDataSize(DataSize) |
| , mPData(PData) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint64_t mDstBuffer; |
| uint64_t mDstOffset; |
| uint64_t mDataSize; |
| Void__CP mPData; |
| }; |
| |
| class VkEvent__CP: public Encodable { |
| public: |
| VkEvent__CP() = default; |
| VkEvent__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCmdWaitEvents: public Encodable { |
| public: |
| VkCmdWaitEvents() = default; |
| VkCmdWaitEvents(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t EventCount, VkEvent__CP PEvents, uint32_t SrcStageMask, uint32_t DstStageMask, uint32_t MemoryBarrierCount, VkMemoryBarrier__CP PMemoryBarriers, uint32_t BufferMemoryBarrierCount, VkBufferMemoryBarrier__CP PBufferMemoryBarriers, uint32_t ImageMemoryBarrierCount, VkImageMemoryBarrier__CP PImageMemoryBarriers) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mEventCount(EventCount) |
| , mPEvents(PEvents) |
| , mSrcStageMask(SrcStageMask) |
| , mDstStageMask(DstStageMask) |
| , mMemoryBarrierCount(MemoryBarrierCount) |
| , mPMemoryBarriers(PMemoryBarriers) |
| , mBufferMemoryBarrierCount(BufferMemoryBarrierCount) |
| , mPBufferMemoryBarriers(PBufferMemoryBarriers) |
| , mImageMemoryBarrierCount(ImageMemoryBarrierCount) |
| , mPImageMemoryBarriers(PImageMemoryBarriers) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mEventCount; |
| VkEvent__CP mPEvents; |
| uint32_t mSrcStageMask; |
| uint32_t mDstStageMask; |
| uint32_t mMemoryBarrierCount; |
| VkMemoryBarrier__CP mPMemoryBarriers; |
| uint32_t mBufferMemoryBarrierCount; |
| VkBufferMemoryBarrier__CP mPBufferMemoryBarriers; |
| uint32_t mImageMemoryBarrierCount; |
| VkImageMemoryBarrier__CP mPImageMemoryBarriers; |
| }; |
| |
| class VkCmdWriteTimestamp: public Encodable { |
| public: |
| VkCmdWriteTimestamp() = default; |
| VkCmdWriteTimestamp(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t PipelineStage, uint64_t QueryPool, uint32_t Query) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mPipelineStage(PipelineStage) |
| , mQueryPool(QueryPool) |
| , mQuery(Query) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mPipelineStage; |
| uint64_t mQueryPool; |
| uint32_t mQuery; |
| }; |
| |
| class VkCommandBufferAllocateInfo: public Encodable { |
| public: |
| VkCommandBufferAllocateInfo() = default; |
| VkCommandBufferAllocateInfo(uint32_t SType, Void__CP PNext, uint64_t CommandPool, uint32_t Level, uint32_t CommandBufferCount) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mCommandPool(CommandPool) |
| , mLevel(Level) |
| , mCommandBufferCount(CommandBufferCount) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint64_t mCommandPool; |
| uint32_t mLevel; |
| uint32_t mCommandBufferCount; |
| }; |
| |
| class VkCommandBufferAllocateInfo__S: public Encodable { |
| public: |
| VkCommandBufferAllocateInfo__S() = default; |
| VkCommandBufferAllocateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkCommandBufferAllocateInfo__P: public Encodable { |
| public: |
| VkCommandBufferAllocateInfo__P() = default; |
| VkCommandBufferAllocateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCommandBufferInheritanceInfo__CP: public Encodable { |
| public: |
| VkCommandBufferInheritanceInfo__CP() = default; |
| VkCommandBufferInheritanceInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCommandBufferBeginInfo: public Encodable { |
| public: |
| VkCommandBufferBeginInfo() = default; |
| VkCommandBufferBeginInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, VkCommandBufferInheritanceInfo__CP PInheritanceInfo) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mPInheritanceInfo(PInheritanceInfo) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| VkCommandBufferInheritanceInfo__CP mPInheritanceInfo; |
| }; |
| |
| class VkCommandBufferBeginInfo__S: public Encodable { |
| public: |
| VkCommandBufferBeginInfo__S() = default; |
| VkCommandBufferBeginInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkCommandBufferBeginInfo__P: public Encodable { |
| public: |
| VkCommandBufferBeginInfo__P() = default; |
| VkCommandBufferBeginInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCommandBufferInheritanceInfo: public Encodable { |
| public: |
| VkCommandBufferInheritanceInfo() = default; |
| VkCommandBufferInheritanceInfo(uint32_t SType, Void__CP PNext, uint64_t RenderPass, uint32_t Subpass, uint64_t Framebuffer, uint32_t OcclusionQueryEnable, uint32_t QueryFlags, uint32_t PipelineStatistics) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mRenderPass(RenderPass) |
| , mSubpass(Subpass) |
| , mFramebuffer(Framebuffer) |
| , mOcclusionQueryEnable(OcclusionQueryEnable) |
| , mQueryFlags(QueryFlags) |
| , mPipelineStatistics(PipelineStatistics) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint64_t mRenderPass; |
| uint32_t mSubpass; |
| uint64_t mFramebuffer; |
| uint32_t mOcclusionQueryEnable; |
| uint32_t mQueryFlags; |
| uint32_t mPipelineStatistics; |
| }; |
| |
| class VkCommandBufferInheritanceInfo__S: public Encodable { |
| public: |
| VkCommandBufferInheritanceInfo__S() = default; |
| VkCommandBufferInheritanceInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkCommandBufferInheritanceInfo__P: public Encodable { |
| public: |
| VkCommandBufferInheritanceInfo__P() = default; |
| VkCommandBufferInheritanceInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCommandBuffer__S: public Encodable { |
| public: |
| VkCommandBuffer__S() = default; |
| VkCommandBuffer__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkCommandPoolCreateInfo: public Encodable { |
| public: |
| VkCommandPoolCreateInfo() = default; |
| VkCommandPoolCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t QueueFamilyIndex) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mQueueFamilyIndex(QueueFamilyIndex) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mQueueFamilyIndex; |
| }; |
| |
| class VkCommandPoolCreateInfo__S: public Encodable { |
| public: |
| VkCommandPoolCreateInfo__S() = default; |
| VkCommandPoolCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkCommandPoolCreateInfo__P: public Encodable { |
| public: |
| VkCommandPoolCreateInfo__P() = default; |
| VkCommandPoolCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCommandPoolCreateInfo__CP: public Encodable { |
| public: |
| VkCommandPoolCreateInfo__CP() = default; |
| VkCommandPoolCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCommandPool__S: public Encodable { |
| public: |
| VkCommandPool__S() = default; |
| VkCommandPool__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkCommandPool__P: public Encodable { |
| public: |
| VkCommandPool__P() = default; |
| VkCommandPool__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkComponentMapping: public Encodable { |
| public: |
| VkComponentMapping() = default; |
| VkComponentMapping(uint32_t R, uint32_t G, uint32_t B, uint32_t A) |
| : mR(R) |
| , mG(G) |
| , mB(B) |
| , mA(A) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mR; |
| uint32_t mG; |
| uint32_t mB; |
| uint32_t mA; |
| }; |
| |
| class VkSpecializationInfo__CP: public Encodable { |
| public: |
| VkSpecializationInfo__CP() = default; |
| VkSpecializationInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineShaderStageCreateInfo: public Encodable { |
| public: |
| VkPipelineShaderStageCreateInfo() = default; |
| VkPipelineShaderStageCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t Stage, uint64_t Module, Char__CP PName, VkSpecializationInfo__CP PSpecializationInfo) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mStage(Stage) |
| , mModule(Module) |
| , mPName(PName) |
| , mPSpecializationInfo(PSpecializationInfo) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mStage; |
| uint64_t mModule; |
| Char__CP mPName; |
| VkSpecializationInfo__CP mPSpecializationInfo; |
| }; |
| |
| class VkComputePipelineCreateInfo: public Encodable { |
| public: |
| VkComputePipelineCreateInfo() = default; |
| VkComputePipelineCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, VkPipelineShaderStageCreateInfo Stage, uint64_t Layout, uint64_t BasePipelineHandle, int32_t BasePipelineIndex) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mStage(Stage) |
| , mLayout(Layout) |
| , mBasePipelineHandle(BasePipelineHandle) |
| , mBasePipelineIndex(BasePipelineIndex) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| VkPipelineShaderStageCreateInfo mStage; |
| uint64_t mLayout; |
| uint64_t mBasePipelineHandle; |
| int32_t mBasePipelineIndex; |
| }; |
| |
| class VkComputePipelineCreateInfo__S: public Encodable { |
| public: |
| VkComputePipelineCreateInfo__S() = default; |
| VkComputePipelineCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkComputePipelineCreateInfo__P: public Encodable { |
| public: |
| VkComputePipelineCreateInfo__P() = default; |
| VkComputePipelineCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkComputePipelineCreateInfo__CP: public Encodable { |
| public: |
| VkComputePipelineCreateInfo__CP() = default; |
| VkComputePipelineCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCopyDescriptorSet: public Encodable { |
| public: |
| VkCopyDescriptorSet() = default; |
| VkCopyDescriptorSet(uint32_t SType, Void__CP PNext, uint64_t SrcSet, uint32_t SrcBinding, uint32_t SrcArrayElement, uint64_t DstSet, uint32_t DstBinding, uint32_t DstArrayElement, uint32_t DescriptorCount) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mSrcSet(SrcSet) |
| , mSrcBinding(SrcBinding) |
| , mSrcArrayElement(SrcArrayElement) |
| , mDstSet(DstSet) |
| , mDstBinding(DstBinding) |
| , mDstArrayElement(DstArrayElement) |
| , mDescriptorCount(DescriptorCount) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint64_t mSrcSet; |
| uint32_t mSrcBinding; |
| uint32_t mSrcArrayElement; |
| uint64_t mDstSet; |
| uint32_t mDstBinding; |
| uint32_t mDstArrayElement; |
| uint32_t mDescriptorCount; |
| }; |
| |
| class VkCopyDescriptorSet__S: public Encodable { |
| public: |
| VkCopyDescriptorSet__S() = default; |
| VkCopyDescriptorSet__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkCopyDescriptorSet__P: public Encodable { |
| public: |
| VkCopyDescriptorSet__P() = default; |
| VkCopyDescriptorSet__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCopyDescriptorSet__CP: public Encodable { |
| public: |
| VkCopyDescriptorSet__CP() = default; |
| VkCopyDescriptorSet__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSurfaceKHR__P: public Encodable { |
| public: |
| VkSurfaceKHR__P() = default; |
| VkSurfaceKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateAndroidSurfaceKHR: public Encodable { |
| public: |
| VkCreateAndroidSurfaceKHR() = default; |
| VkCreateAndroidSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkAndroidSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSurface(PSurface) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| VkAndroidSurfaceCreateInfoKHR__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSurfaceKHR__P mPSurface; |
| uint32_t mResult; |
| }; |
| |
| class VkCreateBuffer: public Encodable { |
| public: |
| VkCreateBuffer() = default; |
| VkCreateBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkBufferCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkBuffer__P PBuffer, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPBuffer(PBuffer) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkBufferCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkBuffer__P mPBuffer; |
| uint32_t mResult; |
| }; |
| |
| class VkCreateBufferView: public Encodable { |
| public: |
| VkCreateBufferView() = default; |
| VkCreateBufferView(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkBufferViewCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkBufferView__P PView, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPView(PView) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkBufferViewCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkBufferView__P mPView; |
| uint32_t mResult; |
| }; |
| |
| class VkCreateCommandPool: public Encodable { |
| public: |
| VkCreateCommandPool() = default; |
| VkCreateCommandPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkCommandPoolCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkCommandPool__P PCommandPool, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPCommandPool(PCommandPool) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkCommandPoolCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkCommandPool__P mPCommandPool; |
| uint32_t mResult; |
| }; |
| |
| class VkPipeline__P: public Encodable { |
| public: |
| VkPipeline__P() = default; |
| VkPipeline__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateComputePipelines: public Encodable { |
| public: |
| VkCreateComputePipelines() = default; |
| VkCreateComputePipelines(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineCache, uint32_t CreateInfoCount, VkComputePipelineCreateInfo__CP PCreateInfos, VkAllocationCallbacks__CP PAllocator, VkPipeline__P PPipelines, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPipelineCache(PipelineCache) |
| , mCreateInfoCount(CreateInfoCount) |
| , mPCreateInfos(PCreateInfos) |
| , mPAllocator(PAllocator) |
| , mPPipelines(PPipelines) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mPipelineCache; |
| uint32_t mCreateInfoCount; |
| VkComputePipelineCreateInfo__CP mPCreateInfos; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkPipeline__P mPPipelines; |
| uint32_t mResult; |
| }; |
| |
| class VkDebugReportCallbackCreateInfoEXT__CP: public Encodable { |
| public: |
| VkDebugReportCallbackCreateInfoEXT__CP() = default; |
| VkDebugReportCallbackCreateInfoEXT__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDebugReportCallbackEXT__P: public Encodable { |
| public: |
| VkDebugReportCallbackEXT__P() = default; |
| VkDebugReportCallbackEXT__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateDebugReportCallbackEXT: public Encodable { |
| public: |
| VkCreateDebugReportCallbackEXT() = default; |
| VkCreateDebugReportCallbackEXT(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkDebugReportCallbackCreateInfoEXT__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDebugReportCallbackEXT__P PCallback, uint32_t Result) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPCallback(PCallback) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| VkDebugReportCallbackCreateInfoEXT__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkDebugReportCallbackEXT__P mPCallback; |
| uint32_t mResult; |
| }; |
| |
| class VkDescriptorPoolCreateInfo__CP: public Encodable { |
| public: |
| VkDescriptorPoolCreateInfo__CP() = default; |
| VkDescriptorPoolCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorPool__P: public Encodable { |
| public: |
| VkDescriptorPool__P() = default; |
| VkDescriptorPool__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateDescriptorPool: public Encodable { |
| public: |
| VkCreateDescriptorPool() = default; |
| VkCreateDescriptorPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkDescriptorPoolCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDescriptorPool__P PDescriptorPool, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPDescriptorPool(PDescriptorPool) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkDescriptorPoolCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkDescriptorPool__P mPDescriptorPool; |
| uint32_t mResult; |
| }; |
| |
| class VkDescriptorSetLayoutCreateInfo__CP: public Encodable { |
| public: |
| VkDescriptorSetLayoutCreateInfo__CP() = default; |
| VkDescriptorSetLayoutCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorSetLayout__P: public Encodable { |
| public: |
| VkDescriptorSetLayout__P() = default; |
| VkDescriptorSetLayout__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateDescriptorSetLayout: public Encodable { |
| public: |
| VkCreateDescriptorSetLayout() = default; |
| VkCreateDescriptorSetLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkDescriptorSetLayoutCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDescriptorSetLayout__P PSetLayout, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSetLayout(PSetLayout) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkDescriptorSetLayoutCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkDescriptorSetLayout__P mPSetLayout; |
| uint32_t mResult; |
| }; |
| |
| class VkCreateDevice: public Encodable { |
| public: |
| VkCreateDevice() = default; |
| VkCreateDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkDeviceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDevice__P PDevice, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPDevice(PDevice) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| VkDeviceCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkDevice__P mPDevice; |
| uint32_t mResult; |
| }; |
| |
| class VkDisplayModeCreateInfoKHR__CP: public Encodable { |
| public: |
| VkDisplayModeCreateInfoKHR__CP() = default; |
| VkDisplayModeCreateInfoKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDisplayModeKHR__P: public Encodable { |
| public: |
| VkDisplayModeKHR__P() = default; |
| VkDisplayModeKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateDisplayModeKHR: public Encodable { |
| public: |
| VkCreateDisplayModeKHR() = default; |
| VkCreateDisplayModeKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Display, VkDisplayModeCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkDisplayModeKHR__P PMode, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mDisplay(Display) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPMode(PMode) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint64_t mDisplay; |
| VkDisplayModeCreateInfoKHR__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkDisplayModeKHR__P mPMode; |
| uint32_t mResult; |
| }; |
| |
| class VkDisplaySurfaceCreateInfoKHR__CP: public Encodable { |
| public: |
| VkDisplaySurfaceCreateInfoKHR__CP() = default; |
| VkDisplaySurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateDisplayPlaneSurfaceKHR: public Encodable { |
| public: |
| VkCreateDisplayPlaneSurfaceKHR() = default; |
| VkCreateDisplayPlaneSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkDisplaySurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSurface(PSurface) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| VkDisplaySurfaceCreateInfoKHR__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSurfaceKHR__P mPSurface; |
| uint32_t mResult; |
| }; |
| |
| class VkEventCreateInfo__CP: public Encodable { |
| public: |
| VkEventCreateInfo__CP() = default; |
| VkEventCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkEvent__P: public Encodable { |
| public: |
| VkEvent__P() = default; |
| VkEvent__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateEvent: public Encodable { |
| public: |
| VkCreateEvent() = default; |
| VkCreateEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkEventCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkEvent__P PEvent, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPEvent(PEvent) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkEventCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkEvent__P mPEvent; |
| uint32_t mResult; |
| }; |
| |
| class VkFenceCreateInfo__CP: public Encodable { |
| public: |
| VkFenceCreateInfo__CP() = default; |
| VkFenceCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkFence__P: public Encodable { |
| public: |
| VkFence__P() = default; |
| VkFence__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateFence: public Encodable { |
| public: |
| VkCreateFence() = default; |
| VkCreateFence(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkFenceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkFence__P PFence, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPFence(PFence) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkFenceCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkFence__P mPFence; |
| uint32_t mResult; |
| }; |
| |
| class VkFramebufferCreateInfo__CP: public Encodable { |
| public: |
| VkFramebufferCreateInfo__CP() = default; |
| VkFramebufferCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkFramebuffer__P: public Encodable { |
| public: |
| VkFramebuffer__P() = default; |
| VkFramebuffer__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateFramebuffer: public Encodable { |
| public: |
| VkCreateFramebuffer() = default; |
| VkCreateFramebuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkFramebufferCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkFramebuffer__P PFramebuffer, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPFramebuffer(PFramebuffer) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkFramebufferCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkFramebuffer__P mPFramebuffer; |
| uint32_t mResult; |
| }; |
| |
| class VkGraphicsPipelineCreateInfo__CP: public Encodable { |
| public: |
| VkGraphicsPipelineCreateInfo__CP() = default; |
| VkGraphicsPipelineCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateGraphicsPipelines: public Encodable { |
| public: |
| VkCreateGraphicsPipelines() = default; |
| VkCreateGraphicsPipelines(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineCache, uint32_t CreateInfoCount, VkGraphicsPipelineCreateInfo__CP PCreateInfos, VkAllocationCallbacks__CP PAllocator, VkPipeline__P PPipelines, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPipelineCache(PipelineCache) |
| , mCreateInfoCount(CreateInfoCount) |
| , mPCreateInfos(PCreateInfos) |
| , mPAllocator(PAllocator) |
| , mPPipelines(PPipelines) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mPipelineCache; |
| uint32_t mCreateInfoCount; |
| VkGraphicsPipelineCreateInfo__CP mPCreateInfos; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkPipeline__P mPPipelines; |
| uint32_t mResult; |
| }; |
| |
| class VkImageCreateInfo__CP: public Encodable { |
| public: |
| VkImageCreateInfo__CP() = default; |
| VkImageCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImage__P: public Encodable { |
| public: |
| VkImage__P() = default; |
| VkImage__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateImage: public Encodable { |
| public: |
| VkCreateImage() = default; |
| VkCreateImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkImageCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkImage__P PImage, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPImage(PImage) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkImageCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkImage__P mPImage; |
| uint32_t mResult; |
| }; |
| |
| class VkImageViewCreateInfo__CP: public Encodable { |
| public: |
| VkImageViewCreateInfo__CP() = default; |
| VkImageViewCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageView__P: public Encodable { |
| public: |
| VkImageView__P() = default; |
| VkImageView__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateImageView: public Encodable { |
| public: |
| VkCreateImageView() = default; |
| VkCreateImageView(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkImageViewCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkImageView__P PView, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPView(PView) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkImageViewCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkImageView__P mPView; |
| uint32_t mResult; |
| }; |
| |
| class VkCreateInstance: public Encodable { |
| public: |
| VkCreateInstance() = default; |
| VkCreateInstance(const gapic::Vector<gapic::Encodable*>& extras, VkInstanceCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkInstance__P PInstance, uint32_t Result) |
| : mextras(extras) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPInstance(PInstance) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| VkInstanceCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkInstance__P mPInstance; |
| uint32_t mResult; |
| }; |
| |
| class VkMirSurfaceCreateInfoKHR__CP: public Encodable { |
| public: |
| VkMirSurfaceCreateInfoKHR__CP() = default; |
| VkMirSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateMirSurfaceKHR: public Encodable { |
| public: |
| VkCreateMirSurfaceKHR() = default; |
| VkCreateMirSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkMirSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSurface(PSurface) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| VkMirSurfaceCreateInfoKHR__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSurfaceKHR__P mPSurface; |
| uint32_t mResult; |
| }; |
| |
| class VkPipelineCacheCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineCacheCreateInfo__CP() = default; |
| VkPipelineCacheCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineCache__P: public Encodable { |
| public: |
| VkPipelineCache__P() = default; |
| VkPipelineCache__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreatePipelineCache: public Encodable { |
| public: |
| VkCreatePipelineCache() = default; |
| VkCreatePipelineCache(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkPipelineCacheCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkPipelineCache__P PPipelineCache, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPPipelineCache(PPipelineCache) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkPipelineCacheCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkPipelineCache__P mPPipelineCache; |
| uint32_t mResult; |
| }; |
| |
| class VkPipelineLayoutCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineLayoutCreateInfo__CP() = default; |
| VkPipelineLayoutCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineLayout__P: public Encodable { |
| public: |
| VkPipelineLayout__P() = default; |
| VkPipelineLayout__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreatePipelineLayout: public Encodable { |
| public: |
| VkCreatePipelineLayout() = default; |
| VkCreatePipelineLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkPipelineLayoutCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkPipelineLayout__P PPipelineLayout, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPPipelineLayout(PPipelineLayout) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkPipelineLayoutCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkPipelineLayout__P mPPipelineLayout; |
| uint32_t mResult; |
| }; |
| |
| class VkQueryPoolCreateInfo__CP: public Encodable { |
| public: |
| VkQueryPoolCreateInfo__CP() = default; |
| VkQueryPoolCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkQueryPool__P: public Encodable { |
| public: |
| VkQueryPool__P() = default; |
| VkQueryPool__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateQueryPool: public Encodable { |
| public: |
| VkCreateQueryPool() = default; |
| VkCreateQueryPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkQueryPoolCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkQueryPool__P PQueryPool, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPQueryPool(PQueryPool) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkQueryPoolCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkQueryPool__P mPQueryPool; |
| uint32_t mResult; |
| }; |
| |
| class VkRenderPassCreateInfo__CP: public Encodable { |
| public: |
| VkRenderPassCreateInfo__CP() = default; |
| VkRenderPassCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkRenderPass__P: public Encodable { |
| public: |
| VkRenderPass__P() = default; |
| VkRenderPass__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateRenderPass: public Encodable { |
| public: |
| VkCreateRenderPass() = default; |
| VkCreateRenderPass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkRenderPassCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkRenderPass__P PRenderPass, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPRenderPass(PRenderPass) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkRenderPassCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkRenderPass__P mPRenderPass; |
| uint32_t mResult; |
| }; |
| |
| class VkSamplerCreateInfo__CP: public Encodable { |
| public: |
| VkSamplerCreateInfo__CP() = default; |
| VkSamplerCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSampler__P: public Encodable { |
| public: |
| VkSampler__P() = default; |
| VkSampler__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateSampler: public Encodable { |
| public: |
| VkCreateSampler() = default; |
| VkCreateSampler(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkSamplerCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSampler__P PSampler, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSampler(PSampler) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkSamplerCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSampler__P mPSampler; |
| uint32_t mResult; |
| }; |
| |
| class VkSemaphoreCreateInfo__CP: public Encodable { |
| public: |
| VkSemaphoreCreateInfo__CP() = default; |
| VkSemaphoreCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSemaphore__P: public Encodable { |
| public: |
| VkSemaphore__P() = default; |
| VkSemaphore__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateSemaphore: public Encodable { |
| public: |
| VkCreateSemaphore() = default; |
| VkCreateSemaphore(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkSemaphoreCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSemaphore__P PSemaphore, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSemaphore(PSemaphore) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkSemaphoreCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSemaphore__P mPSemaphore; |
| uint32_t mResult; |
| }; |
| |
| class VkShaderModuleCreateInfo__CP: public Encodable { |
| public: |
| VkShaderModuleCreateInfo__CP() = default; |
| VkShaderModuleCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkShaderModule__P: public Encodable { |
| public: |
| VkShaderModule__P() = default; |
| VkShaderModule__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateShaderModule: public Encodable { |
| public: |
| VkCreateShaderModule() = default; |
| VkCreateShaderModule(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkShaderModuleCreateInfo__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkShaderModule__P PShaderModule, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPShaderModule(PShaderModule) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkShaderModuleCreateInfo__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkShaderModule__P mPShaderModule; |
| uint32_t mResult; |
| }; |
| |
| class VkSwapchainCreateInfoKHR__CP: public Encodable { |
| public: |
| VkSwapchainCreateInfoKHR__CP() = default; |
| VkSwapchainCreateInfoKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateSharedSwapchainsKHR: public Encodable { |
| public: |
| VkCreateSharedSwapchainsKHR() = default; |
| VkCreateSharedSwapchainsKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t SwapchainCount, VkSwapchainCreateInfoKHR__CP PCreateInfos, VkAllocationCallbacks__CP PAllocator, VkSwapchainKHR__P PSwapchains, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mSwapchainCount(SwapchainCount) |
| , mPCreateInfos(PCreateInfos) |
| , mPAllocator(PAllocator) |
| , mPSwapchains(PSwapchains) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mSwapchainCount; |
| VkSwapchainCreateInfoKHR__CP mPCreateInfos; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSwapchainKHR__P mPSwapchains; |
| uint32_t mResult; |
| }; |
| |
| class VkCreateSwapchainKHR: public Encodable { |
| public: |
| VkCreateSwapchainKHR() = default; |
| VkCreateSwapchainKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkSwapchainCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSwapchainKHR__P PSwapchain, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSwapchain(PSwapchain) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkSwapchainCreateInfoKHR__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSwapchainKHR__P mPSwapchain; |
| uint32_t mResult; |
| }; |
| |
| class VkWaylandSurfaceCreateInfoKHR__CP: public Encodable { |
| public: |
| VkWaylandSurfaceCreateInfoKHR__CP() = default; |
| VkWaylandSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateWaylandSurfaceKHR: public Encodable { |
| public: |
| VkCreateWaylandSurfaceKHR() = default; |
| VkCreateWaylandSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkWaylandSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSurface(PSurface) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| VkWaylandSurfaceCreateInfoKHR__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSurfaceKHR__P mPSurface; |
| uint32_t mResult; |
| }; |
| |
| class VkXcbSurfaceCreateInfoKHR__CP: public Encodable { |
| public: |
| VkXcbSurfaceCreateInfoKHR__CP() = default; |
| VkXcbSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateXcbSurfaceKHR: public Encodable { |
| public: |
| VkCreateXcbSurfaceKHR() = default; |
| VkCreateXcbSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkXcbSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSurface(PSurface) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| VkXcbSurfaceCreateInfoKHR__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSurfaceKHR__P mPSurface; |
| uint32_t mResult; |
| }; |
| |
| class VkXlibSurfaceCreateInfoKHR__CP: public Encodable { |
| public: |
| VkXlibSurfaceCreateInfoKHR__CP() = default; |
| VkXlibSurfaceCreateInfoKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkCreateXlibSurfaceKHR: public Encodable { |
| public: |
| VkCreateXlibSurfaceKHR() = default; |
| VkCreateXlibSurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkXlibSurfaceCreateInfoKHR__CP PCreateInfo, VkAllocationCallbacks__CP PAllocator, VkSurfaceKHR__P PSurface, uint32_t Result) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPCreateInfo(PCreateInfo) |
| , mPAllocator(PAllocator) |
| , mPSurface(PSurface) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| VkXlibSurfaceCreateInfoKHR__CP mPCreateInfo; |
| VkAllocationCallbacks__CP mPAllocator; |
| VkSurfaceKHR__P mPSurface; |
| uint32_t mResult; |
| }; |
| |
| class VkDebugReportCallbackCreateInfoEXT: public Encodable { |
| public: |
| VkDebugReportCallbackCreateInfoEXT() = default; |
| VkDebugReportCallbackCreateInfoEXT(uint32_t SType, Void__CP PNext, uint32_t Flags, PFN_vkDebugReportCallbackEXT PfnCallback, Void__P PUserData) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mPfnCallback(PfnCallback) |
| , mPUserData(PUserData) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| PFN_vkDebugReportCallbackEXT mPfnCallback; |
| Void__P mPUserData; |
| }; |
| |
| class VkDebugReportCallbackCreateInfoEXT__S: public Encodable { |
| public: |
| VkDebugReportCallbackCreateInfoEXT__S() = default; |
| VkDebugReportCallbackCreateInfoEXT__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDebugReportCallbackCreateInfoEXT__P: public Encodable { |
| public: |
| VkDebugReportCallbackCreateInfoEXT__P() = default; |
| VkDebugReportCallbackCreateInfoEXT__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDebugReportCallbackEXT__S: public Encodable { |
| public: |
| VkDebugReportCallbackEXT__S() = default; |
| VkDebugReportCallbackEXT__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDebugReportMessageEXT: public Encodable { |
| public: |
| VkDebugReportMessageEXT() = default; |
| VkDebugReportMessageEXT(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, uint32_t Flags, uint32_t ObjectType, uint64_t Object, uint64_t Location, int32_t MessageCode, const char* PLayerPrefix, const char* PMessage) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mFlags(Flags) |
| , mObjectType(ObjectType) |
| , mObject(Object) |
| , mLocation(Location) |
| , mMessageCode(MessageCode) |
| , mPLayerPrefix(PLayerPrefix) |
| , mPMessage(PMessage) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| uint32_t mFlags; |
| uint32_t mObjectType; |
| uint64_t mObject; |
| uint64_t mLocation; |
| int32_t mMessageCode; |
| const char* mPLayerPrefix; |
| const char* mPMessage; |
| }; |
| |
| class VkDedicatedAllocationBufferCreateInfoNV: public Encodable { |
| public: |
| VkDedicatedAllocationBufferCreateInfoNV() = default; |
| VkDedicatedAllocationBufferCreateInfoNV(uint32_t SType, Void__CP PNext, uint32_t DedicatedAllocation) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mDedicatedAllocation(DedicatedAllocation) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mSType); |
| e->Struct(this->mPNext); |
| e->Uint32(this->mDedicatedAllocation); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mDedicatedAllocation; |
| }; |
| |
| class VkDedicatedAllocationBufferCreateInfoNV__S: public Encodable { |
| public: |
| VkDedicatedAllocationBufferCreateInfoNV__S() = default; |
| VkDedicatedAllocationBufferCreateInfoNV__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDedicatedAllocationBufferCreateInfoNV__P: public Encodable { |
| public: |
| VkDedicatedAllocationBufferCreateInfoNV__P() = default; |
| VkDedicatedAllocationBufferCreateInfoNV__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDedicatedAllocationImageCreateInfoNV: public Encodable { |
| public: |
| VkDedicatedAllocationImageCreateInfoNV() = default; |
| VkDedicatedAllocationImageCreateInfoNV(uint32_t SType, Void__CP PNext, uint32_t DedicatedAllocation) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mDedicatedAllocation(DedicatedAllocation) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mSType); |
| e->Struct(this->mPNext); |
| e->Uint32(this->mDedicatedAllocation); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mDedicatedAllocation; |
| }; |
| |
| class VkDedicatedAllocationImageCreateInfoNV__S: public Encodable { |
| public: |
| VkDedicatedAllocationImageCreateInfoNV__S() = default; |
| VkDedicatedAllocationImageCreateInfoNV__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDedicatedAllocationImageCreateInfoNV__P: public Encodable { |
| public: |
| VkDedicatedAllocationImageCreateInfoNV__P() = default; |
| VkDedicatedAllocationImageCreateInfoNV__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDedicatedAllocationMemoryAllocateInfoNV: public Encodable { |
| public: |
| VkDedicatedAllocationMemoryAllocateInfoNV() = default; |
| VkDedicatedAllocationMemoryAllocateInfoNV(uint32_t SType, Void__CP PNext, uint64_t Image, uint64_t Buffer) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mImage(Image) |
| , mBuffer(Buffer) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint64_t mImage; |
| uint64_t mBuffer; |
| }; |
| |
| class VkDedicatedAllocationMemoryAllocateInfoNV__S: public Encodable { |
| public: |
| VkDedicatedAllocationMemoryAllocateInfoNV__S() = default; |
| VkDedicatedAllocationMemoryAllocateInfoNV__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDedicatedAllocationMemoryAllocateInfoNV__P: public Encodable { |
| public: |
| VkDedicatedAllocationMemoryAllocateInfoNV__P() = default; |
| VkDedicatedAllocationMemoryAllocateInfoNV__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorBufferInfo: public Encodable { |
| public: |
| VkDescriptorBufferInfo() = default; |
| VkDescriptorBufferInfo(uint64_t Buffer, uint64_t Offset, uint64_t Range) |
| : mBuffer(Buffer) |
| , mOffset(Offset) |
| , mRange(Range) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mBuffer); |
| e->Uint64(this->mOffset); |
| e->Uint64(this->mRange); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mBuffer; |
| uint64_t mOffset; |
| uint64_t mRange; |
| }; |
| |
| class VkDescriptorBufferInfo__S: public Encodable { |
| public: |
| VkDescriptorBufferInfo__S() = default; |
| VkDescriptorBufferInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDescriptorBufferInfo__P: public Encodable { |
| public: |
| VkDescriptorBufferInfo__P() = default; |
| VkDescriptorBufferInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorBufferInfo__CP: public Encodable { |
| public: |
| VkDescriptorBufferInfo__CP() = default; |
| VkDescriptorBufferInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorImageInfo: public Encodable { |
| public: |
| VkDescriptorImageInfo() = default; |
| VkDescriptorImageInfo(uint64_t Sampler, uint64_t ImageView, uint32_t ImageLayout) |
| : mSampler(Sampler) |
| , mImageView(ImageView) |
| , mImageLayout(ImageLayout) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mSampler); |
| e->Uint64(this->mImageView); |
| e->Uint32(this->mImageLayout); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mSampler; |
| uint64_t mImageView; |
| uint32_t mImageLayout; |
| }; |
| |
| class VkDescriptorImageInfo__S: public Encodable { |
| public: |
| VkDescriptorImageInfo__S() = default; |
| VkDescriptorImageInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDescriptorImageInfo__P: public Encodable { |
| public: |
| VkDescriptorImageInfo__P() = default; |
| VkDescriptorImageInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorImageInfo__CP: public Encodable { |
| public: |
| VkDescriptorImageInfo__CP() = default; |
| VkDescriptorImageInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorPoolSize__CP: public Encodable { |
| public: |
| VkDescriptorPoolSize__CP() = default; |
| VkDescriptorPoolSize__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorPoolCreateInfo: public Encodable { |
| public: |
| VkDescriptorPoolCreateInfo() = default; |
| VkDescriptorPoolCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t MaxSets, uint32_t PoolSizeCount, VkDescriptorPoolSize__CP PPoolSizes) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mMaxSets(MaxSets) |
| , mPoolSizeCount(PoolSizeCount) |
| , mPPoolSizes(PPoolSizes) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mMaxSets; |
| uint32_t mPoolSizeCount; |
| VkDescriptorPoolSize__CP mPPoolSizes; |
| }; |
| |
| class VkDescriptorPoolCreateInfo__S: public Encodable { |
| public: |
| VkDescriptorPoolCreateInfo__S() = default; |
| VkDescriptorPoolCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDescriptorPoolCreateInfo__P: public Encodable { |
| public: |
| VkDescriptorPoolCreateInfo__P() = default; |
| VkDescriptorPoolCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorPoolSize: public Encodable { |
| public: |
| VkDescriptorPoolSize() = default; |
| VkDescriptorPoolSize(uint32_t Type, uint32_t DescriptorCount) |
| : mType(Type) |
| , mDescriptorCount(DescriptorCount) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mType); |
| e->Uint32(this->mDescriptorCount); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mType; |
| uint32_t mDescriptorCount; |
| }; |
| |
| class VkDescriptorPoolSize__S: public Encodable { |
| public: |
| VkDescriptorPoolSize__S() = default; |
| VkDescriptorPoolSize__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDescriptorPoolSize__P: public Encodable { |
| public: |
| VkDescriptorPoolSize__P() = default; |
| VkDescriptorPoolSize__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorPool__S: public Encodable { |
| public: |
| VkDescriptorPool__S() = default; |
| VkDescriptorPool__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDescriptorSetLayout__CP: public Encodable { |
| public: |
| VkDescriptorSetLayout__CP() = default; |
| VkDescriptorSetLayout__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorSetAllocateInfo: public Encodable { |
| public: |
| VkDescriptorSetAllocateInfo() = default; |
| VkDescriptorSetAllocateInfo(uint32_t SType, Void__CP PNext, uint64_t DescriptorPool, uint32_t DescriptorSetCount, VkDescriptorSetLayout__CP PSetLayouts) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mDescriptorPool(DescriptorPool) |
| , mDescriptorSetCount(DescriptorSetCount) |
| , mPSetLayouts(PSetLayouts) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint64_t mDescriptorPool; |
| uint32_t mDescriptorSetCount; |
| VkDescriptorSetLayout__CP mPSetLayouts; |
| }; |
| |
| class VkDescriptorSetAllocateInfo__S: public Encodable { |
| public: |
| VkDescriptorSetAllocateInfo__S() = default; |
| VkDescriptorSetAllocateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDescriptorSetAllocateInfo__P: public Encodable { |
| public: |
| VkDescriptorSetAllocateInfo__P() = default; |
| VkDescriptorSetAllocateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSampler__CP: public Encodable { |
| public: |
| VkSampler__CP() = default; |
| VkSampler__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorSetLayoutBinding: public Encodable { |
| public: |
| VkDescriptorSetLayoutBinding() = default; |
| VkDescriptorSetLayoutBinding(uint32_t Binding, uint32_t DescriptorType, uint32_t DescriptorCount, uint32_t StageFlags, VkSampler__CP PImmutableSamplers) |
| : mBinding(Binding) |
| , mDescriptorType(DescriptorType) |
| , mDescriptorCount(DescriptorCount) |
| , mStageFlags(StageFlags) |
| , mPImmutableSamplers(PImmutableSamplers) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mBinding; |
| uint32_t mDescriptorType; |
| uint32_t mDescriptorCount; |
| uint32_t mStageFlags; |
| VkSampler__CP mPImmutableSamplers; |
| }; |
| |
| class VkDescriptorSetLayoutBinding__S: public Encodable { |
| public: |
| VkDescriptorSetLayoutBinding__S() = default; |
| VkDescriptorSetLayoutBinding__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDescriptorSetLayoutBinding__P: public Encodable { |
| public: |
| VkDescriptorSetLayoutBinding__P() = default; |
| VkDescriptorSetLayoutBinding__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorSetLayoutBinding__CP: public Encodable { |
| public: |
| VkDescriptorSetLayoutBinding__CP() = default; |
| VkDescriptorSetLayoutBinding__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorSetLayoutCreateInfo: public Encodable { |
| public: |
| VkDescriptorSetLayoutCreateInfo() = default; |
| VkDescriptorSetLayoutCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t BindingCount, VkDescriptorSetLayoutBinding__CP PBindings) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mBindingCount(BindingCount) |
| , mPBindings(PBindings) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mBindingCount; |
| VkDescriptorSetLayoutBinding__CP mPBindings; |
| }; |
| |
| class VkDescriptorSetLayoutCreateInfo__S: public Encodable { |
| public: |
| VkDescriptorSetLayoutCreateInfo__S() = default; |
| VkDescriptorSetLayoutCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDescriptorSetLayoutCreateInfo__P: public Encodable { |
| public: |
| VkDescriptorSetLayoutCreateInfo__P() = default; |
| VkDescriptorSetLayoutCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDescriptorSetLayout__S: public Encodable { |
| public: |
| VkDescriptorSetLayout__S() = default; |
| VkDescriptorSetLayout__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDescriptorSet__S: public Encodable { |
| public: |
| VkDescriptorSet__S() = default; |
| VkDescriptorSet__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDestroyBuffer: public Encodable { |
| public: |
| VkDestroyBuffer() = default; |
| VkDestroyBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Buffer, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mBuffer(Buffer) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mBuffer; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyBufferView: public Encodable { |
| public: |
| VkDestroyBufferView() = default; |
| VkDestroyBufferView(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t BufferView, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mBufferView(BufferView) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mBufferView; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyCommandPool: public Encodable { |
| public: |
| VkDestroyCommandPool() = default; |
| VkDestroyCommandPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t CommandPool, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mCommandPool(CommandPool) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mCommandPool; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyDebugReportCallbackEXT: public Encodable { |
| public: |
| VkDestroyDebugReportCallbackEXT() = default; |
| VkDestroyDebugReportCallbackEXT(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, uint64_t Callback, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mCallback(Callback) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| uint64_t mCallback; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyDescriptorPool: public Encodable { |
| public: |
| VkDestroyDescriptorPool() = default; |
| VkDestroyDescriptorPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DescriptorPool, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mDescriptorPool(DescriptorPool) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mDescriptorPool; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyDescriptorSetLayout: public Encodable { |
| public: |
| VkDestroyDescriptorSetLayout() = default; |
| VkDestroyDescriptorSetLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DescriptorSetLayout, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mDescriptorSetLayout(DescriptorSetLayout) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mDescriptorSetLayout; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyDevice: public Encodable { |
| public: |
| VkDestroyDevice() = default; |
| VkDestroyDevice(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mDevice); |
| e->Struct(this->mPAllocator); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyEvent: public Encodable { |
| public: |
| VkDestroyEvent() = default; |
| VkDestroyEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Event, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mEvent(Event) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mEvent; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyFence: public Encodable { |
| public: |
| VkDestroyFence() = default; |
| VkDestroyFence(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Fence, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mFence(Fence) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mFence; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyFramebuffer: public Encodable { |
| public: |
| VkDestroyFramebuffer() = default; |
| VkDestroyFramebuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Framebuffer, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mFramebuffer(Framebuffer) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mFramebuffer; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyImage: public Encodable { |
| public: |
| VkDestroyImage() = default; |
| VkDestroyImage(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mImage(Image) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mImage; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyImageView: public Encodable { |
| public: |
| VkDestroyImageView() = default; |
| VkDestroyImageView(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t ImageView, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mImageView(ImageView) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mImageView; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyInstance: public Encodable { |
| public: |
| VkDestroyInstance() = default; |
| VkDestroyInstance(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mInstance); |
| e->Struct(this->mPAllocator); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyPipeline: public Encodable { |
| public: |
| VkDestroyPipeline() = default; |
| VkDestroyPipeline(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Pipeline, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPipeline(Pipeline) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mPipeline; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyPipelineCache: public Encodable { |
| public: |
| VkDestroyPipelineCache() = default; |
| VkDestroyPipelineCache(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineCache, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPipelineCache(PipelineCache) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mPipelineCache; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyPipelineLayout: public Encodable { |
| public: |
| VkDestroyPipelineLayout() = default; |
| VkDestroyPipelineLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineLayout, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPipelineLayout(PipelineLayout) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mPipelineLayout; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyQueryPool: public Encodable { |
| public: |
| VkDestroyQueryPool() = default; |
| VkDestroyQueryPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t QueryPool, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mQueryPool(QueryPool) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mQueryPool; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyRenderPass: public Encodable { |
| public: |
| VkDestroyRenderPass() = default; |
| VkDestroyRenderPass(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t RenderPass, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mRenderPass(RenderPass) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mRenderPass; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroySampler: public Encodable { |
| public: |
| VkDestroySampler() = default; |
| VkDestroySampler(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Sampler, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mSampler(Sampler) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mSampler; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroySemaphore: public Encodable { |
| public: |
| VkDestroySemaphore() = default; |
| VkDestroySemaphore(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Semaphore, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mSemaphore(Semaphore) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mSemaphore; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroyShaderModule: public Encodable { |
| public: |
| VkDestroyShaderModule() = default; |
| VkDestroyShaderModule(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t ShaderModule, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mShaderModule(ShaderModule) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mShaderModule; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroySurfaceKHR: public Encodable { |
| public: |
| VkDestroySurfaceKHR() = default; |
| VkDestroySurfaceKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, uint64_t Surface, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mSurface(Surface) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| uint64_t mSurface; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDestroySwapchainKHR: public Encodable { |
| public: |
| VkDestroySwapchainKHR() = default; |
| VkDestroySwapchainKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Swapchain, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mSwapchain(Swapchain) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mSwapchain; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkDeviceQueueCreateInfo__CP: public Encodable { |
| public: |
| VkDeviceQueueCreateInfo__CP() = default; |
| VkDeviceQueueCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPhysicalDeviceFeatures__CP: public Encodable { |
| public: |
| VkPhysicalDeviceFeatures__CP() = default; |
| VkPhysicalDeviceFeatures__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDeviceCreateInfo: public Encodable { |
| public: |
| VkDeviceCreateInfo() = default; |
| VkDeviceCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t QueueCreateInfoCount, VkDeviceQueueCreateInfo__CP PQueueCreateInfos, uint32_t EnabledLayerCount, Char__CP__CP PpEnabledLayerNames, uint32_t EnabledExtensionCount, Char__CP__CP PpEnabledExtensionNames, VkPhysicalDeviceFeatures__CP PEnabledFeatures) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mQueueCreateInfoCount(QueueCreateInfoCount) |
| , mPQueueCreateInfos(PQueueCreateInfos) |
| , mEnabledLayerCount(EnabledLayerCount) |
| , mPpEnabledLayerNames(PpEnabledLayerNames) |
| , mEnabledExtensionCount(EnabledExtensionCount) |
| , mPpEnabledExtensionNames(PpEnabledExtensionNames) |
| , mPEnabledFeatures(PEnabledFeatures) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mQueueCreateInfoCount; |
| VkDeviceQueueCreateInfo__CP mPQueueCreateInfos; |
| uint32_t mEnabledLayerCount; |
| Char__CP__CP mPpEnabledLayerNames; |
| uint32_t mEnabledExtensionCount; |
| Char__CP__CP mPpEnabledExtensionNames; |
| VkPhysicalDeviceFeatures__CP mPEnabledFeatures; |
| }; |
| |
| class VkDeviceCreateInfo__S: public Encodable { |
| public: |
| VkDeviceCreateInfo__S() = default; |
| VkDeviceCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDeviceMemory__S: public Encodable { |
| public: |
| VkDeviceMemory__S() = default; |
| VkDeviceMemory__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDeviceQueueCreateInfo: public Encodable { |
| public: |
| VkDeviceQueueCreateInfo() = default; |
| VkDeviceQueueCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t QueueFamilyIndex, uint32_t QueueCount, F32__CP PQueuePriorities) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mQueueFamilyIndex(QueueFamilyIndex) |
| , mQueueCount(QueueCount) |
| , mPQueuePriorities(PQueuePriorities) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mQueueFamilyIndex; |
| uint32_t mQueueCount; |
| F32__CP mPQueuePriorities; |
| }; |
| |
| class VkDeviceQueueCreateInfo__S: public Encodable { |
| public: |
| VkDeviceQueueCreateInfo__S() = default; |
| VkDeviceQueueCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDeviceQueueCreateInfo__P: public Encodable { |
| public: |
| VkDeviceQueueCreateInfo__P() = default; |
| VkDeviceQueueCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDeviceSize__S: public Encodable { |
| public: |
| VkDeviceSize__S() = default; |
| VkDeviceSize__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDeviceSize__P: public Encodable { |
| public: |
| VkDeviceSize__P() = default; |
| VkDeviceSize__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDeviceWaitIdle: public Encodable { |
| public: |
| VkDeviceWaitIdle() = default; |
| VkDeviceWaitIdle(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mDevice); |
| e->Uint32(this->mResult); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mResult; |
| }; |
| |
| class VkDevice__S: public Encodable { |
| public: |
| VkDevice__S() = default; |
| VkDevice__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDispatchIndirectCommand: public Encodable { |
| public: |
| VkDispatchIndirectCommand() = default; |
| VkDispatchIndirectCommand(uint32_t X, uint32_t Y, uint32_t Z) |
| : mX(X) |
| , mY(Y) |
| , mZ(Z) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mX); |
| e->Uint32(this->mY); |
| e->Uint32(this->mZ); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mX; |
| uint32_t mY; |
| uint32_t mZ; |
| }; |
| |
| class VkDisplayKHR__S: public Encodable { |
| public: |
| VkDisplayKHR__S() = default; |
| VkDisplayKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDisplayKHR__P: public Encodable { |
| public: |
| VkDisplayKHR__P() = default; |
| VkDisplayKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDisplayModeParametersKHR: public Encodable { |
| public: |
| VkDisplayModeParametersKHR() = default; |
| VkDisplayModeParametersKHR(VkExtent2D VisibleRegion, uint32_t RefreshRate) |
| : mVisibleRegion(VisibleRegion) |
| , mRefreshRate(RefreshRate) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mVisibleRegion); |
| e->Uint32(this->mRefreshRate); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkExtent2D mVisibleRegion; |
| uint32_t mRefreshRate; |
| }; |
| |
| class VkDisplayModeCreateInfoKHR: public Encodable { |
| public: |
| VkDisplayModeCreateInfoKHR() = default; |
| VkDisplayModeCreateInfoKHR(uint32_t SType, Void__CP PNext, uint32_t Flags, VkDisplayModeParametersKHR Parameters) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mParameters(Parameters) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| VkDisplayModeParametersKHR mParameters; |
| }; |
| |
| class VkDisplayModeCreateInfoKHR__S: public Encodable { |
| public: |
| VkDisplayModeCreateInfoKHR__S() = default; |
| VkDisplayModeCreateInfoKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDisplayModeCreateInfoKHR__P: public Encodable { |
| public: |
| VkDisplayModeCreateInfoKHR__P() = default; |
| VkDisplayModeCreateInfoKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDisplayModeKHR__S: public Encodable { |
| public: |
| VkDisplayModeKHR__S() = default; |
| VkDisplayModeKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDisplayModePropertiesKHR: public Encodable { |
| public: |
| VkDisplayModePropertiesKHR() = default; |
| VkDisplayModePropertiesKHR(uint64_t DisplayMode, VkDisplayModeParametersKHR Parameters) |
| : mDisplayMode(DisplayMode) |
| , mParameters(Parameters) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mDisplayMode); |
| e->Struct(this->mParameters); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mDisplayMode; |
| VkDisplayModeParametersKHR mParameters; |
| }; |
| |
| class VkDisplayModePropertiesKHR__S: public Encodable { |
| public: |
| VkDisplayModePropertiesKHR__S() = default; |
| VkDisplayModePropertiesKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDisplayModePropertiesKHR__P: public Encodable { |
| public: |
| VkDisplayModePropertiesKHR__P() = default; |
| VkDisplayModePropertiesKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDisplayPlaneCapabilitiesKHR: public Encodable { |
| public: |
| VkDisplayPlaneCapabilitiesKHR() = default; |
| VkDisplayPlaneCapabilitiesKHR(uint32_t SupportedAlpha, VkOffset2D MinSrcPosition, VkOffset2D MaxSrcPosition, VkExtent2D MinSrcExtent, VkExtent2D MaxSrcExtent, VkOffset2D MinDstPosition, VkOffset2D MaxDstPosition, VkExtent2D MinDstExtent, VkExtent2D MaxDstExtent) |
| : mSupportedAlpha(SupportedAlpha) |
| , mMinSrcPosition(MinSrcPosition) |
| , mMaxSrcPosition(MaxSrcPosition) |
| , mMinSrcExtent(MinSrcExtent) |
| , mMaxSrcExtent(MaxSrcExtent) |
| , mMinDstPosition(MinDstPosition) |
| , mMaxDstPosition(MaxDstPosition) |
| , mMinDstExtent(MinDstExtent) |
| , mMaxDstExtent(MaxDstExtent) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSupportedAlpha; |
| VkOffset2D mMinSrcPosition; |
| VkOffset2D mMaxSrcPosition; |
| VkExtent2D mMinSrcExtent; |
| VkExtent2D mMaxSrcExtent; |
| VkOffset2D mMinDstPosition; |
| VkOffset2D mMaxDstPosition; |
| VkExtent2D mMinDstExtent; |
| VkExtent2D mMaxDstExtent; |
| }; |
| |
| class VkDisplayPlaneCapabilitiesKHR__S: public Encodable { |
| public: |
| VkDisplayPlaneCapabilitiesKHR__S() = default; |
| VkDisplayPlaneCapabilitiesKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDisplayPlaneCapabilitiesKHR__P: public Encodable { |
| public: |
| VkDisplayPlaneCapabilitiesKHR__P() = default; |
| VkDisplayPlaneCapabilitiesKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDisplayPlanePropertiesKHR: public Encodable { |
| public: |
| VkDisplayPlanePropertiesKHR() = default; |
| VkDisplayPlanePropertiesKHR(uint64_t CurrentDisplay, uint32_t CurrentStackIndex) |
| : mCurrentDisplay(CurrentDisplay) |
| , mCurrentStackIndex(CurrentStackIndex) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mCurrentDisplay); |
| e->Uint32(this->mCurrentStackIndex); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mCurrentDisplay; |
| uint32_t mCurrentStackIndex; |
| }; |
| |
| class VkDisplayPlanePropertiesKHR__S: public Encodable { |
| public: |
| VkDisplayPlanePropertiesKHR__S() = default; |
| VkDisplayPlanePropertiesKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDisplayPlanePropertiesKHR__P: public Encodable { |
| public: |
| VkDisplayPlanePropertiesKHR__P() = default; |
| VkDisplayPlanePropertiesKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDisplayPresentInfoKHR: public Encodable { |
| public: |
| VkDisplayPresentInfoKHR() = default; |
| VkDisplayPresentInfoKHR(uint32_t SType, Void__CP PNext, VkRect2D SrcRect, VkRect2D DstRect, uint32_t Persistent) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mSrcRect(SrcRect) |
| , mDstRect(DstRect) |
| , mPersistent(Persistent) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| VkRect2D mSrcRect; |
| VkRect2D mDstRect; |
| uint32_t mPersistent; |
| }; |
| |
| class VkDisplayPropertiesKHR: public Encodable { |
| public: |
| VkDisplayPropertiesKHR() = default; |
| VkDisplayPropertiesKHR(uint64_t Display, const char* DisplayName, VkExtent2D PhysicalDimensions, VkExtent2D PhysicalResolution, uint32_t SupportedTransforms, uint32_t PlaneReorderPossible, uint32_t PersistentContent) |
| : mDisplay(Display) |
| , mDisplayName(DisplayName) |
| , mPhysicalDimensions(PhysicalDimensions) |
| , mPhysicalResolution(PhysicalResolution) |
| , mSupportedTransforms(SupportedTransforms) |
| , mPlaneReorderPossible(PlaneReorderPossible) |
| , mPersistentContent(PersistentContent) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mDisplay; |
| const char* mDisplayName; |
| VkExtent2D mPhysicalDimensions; |
| VkExtent2D mPhysicalResolution; |
| uint32_t mSupportedTransforms; |
| uint32_t mPlaneReorderPossible; |
| uint32_t mPersistentContent; |
| }; |
| |
| class VkDisplayPropertiesKHR__S: public Encodable { |
| public: |
| VkDisplayPropertiesKHR__S() = default; |
| VkDisplayPropertiesKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDisplayPropertiesKHR__P: public Encodable { |
| public: |
| VkDisplayPropertiesKHR__P() = default; |
| VkDisplayPropertiesKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDisplaySurfaceCreateInfoKHR: public Encodable { |
| public: |
| VkDisplaySurfaceCreateInfoKHR() = default; |
| VkDisplaySurfaceCreateInfoKHR(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t DisplayMode, uint32_t PlaneIndex, uint32_t PlaneStackIndex, uint32_t Transform, float GlobalAlpha, uint32_t AlphaMode, VkExtent2D ImageExtent) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mDisplayMode(DisplayMode) |
| , mPlaneIndex(PlaneIndex) |
| , mPlaneStackIndex(PlaneStackIndex) |
| , mTransform(Transform) |
| , mGlobalAlpha(GlobalAlpha) |
| , mAlphaMode(AlphaMode) |
| , mImageExtent(ImageExtent) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint64_t mDisplayMode; |
| uint32_t mPlaneIndex; |
| uint32_t mPlaneStackIndex; |
| uint32_t mTransform; |
| float mGlobalAlpha; |
| uint32_t mAlphaMode; |
| VkExtent2D mImageExtent; |
| }; |
| |
| class VkDisplaySurfaceCreateInfoKHR__S: public Encodable { |
| public: |
| VkDisplaySurfaceCreateInfoKHR__S() = default; |
| VkDisplaySurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDisplaySurfaceCreateInfoKHR__P: public Encodable { |
| public: |
| VkDisplaySurfaceCreateInfoKHR__P() = default; |
| VkDisplaySurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDrawIndexedIndirectCommand: public Encodable { |
| public: |
| VkDrawIndexedIndirectCommand() = default; |
| VkDrawIndexedIndirectCommand(uint32_t IndexCount, uint32_t InstanceCount, uint32_t FirstIndex, int32_t VertexOffset, uint32_t FirstInstance) |
| : mIndexCount(IndexCount) |
| , mInstanceCount(InstanceCount) |
| , mFirstIndex(FirstIndex) |
| , mVertexOffset(VertexOffset) |
| , mFirstInstance(FirstInstance) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mIndexCount; |
| uint32_t mInstanceCount; |
| uint32_t mFirstIndex; |
| int32_t mVertexOffset; |
| uint32_t mFirstInstance; |
| }; |
| |
| class VkDrawIndirectCommand: public Encodable { |
| public: |
| VkDrawIndirectCommand() = default; |
| VkDrawIndirectCommand(uint32_t VertexCount, uint32_t InstanceCount, uint32_t FirstVertex, uint32_t FirstInstance) |
| : mVertexCount(VertexCount) |
| , mInstanceCount(InstanceCount) |
| , mFirstVertex(FirstVertex) |
| , mFirstInstance(FirstInstance) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mVertexCount; |
| uint32_t mInstanceCount; |
| uint32_t mFirstVertex; |
| uint32_t mFirstInstance; |
| }; |
| |
| class VkDynamicState__S: public Encodable { |
| public: |
| VkDynamicState__S() = default; |
| VkDynamicState__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkDynamicState__P: public Encodable { |
| public: |
| VkDynamicState__P() = default; |
| VkDynamicState__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkDynamicState__CP: public Encodable { |
| public: |
| VkDynamicState__CP() = default; |
| VkDynamicState__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkEndCommandBuffer: public Encodable { |
| public: |
| VkEndCommandBuffer() = default; |
| VkEndCommandBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t Result) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mCommandBuffer); |
| e->Uint32(this->mResult); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mResult; |
| }; |
| |
| class VkExtensionProperties__P: public Encodable { |
| public: |
| VkExtensionProperties__P() = default; |
| VkExtensionProperties__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkEnumerateDeviceExtensionProperties: public Encodable { |
| public: |
| VkEnumerateDeviceExtensionProperties() = default; |
| VkEnumerateDeviceExtensionProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, const char* PLayerName, U32__P PPropertyCount, VkExtensionProperties__P PProperties, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPLayerName(PLayerName) |
| , mPPropertyCount(PPropertyCount) |
| , mPProperties(PProperties) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| const char* mPLayerName; |
| U32__P mPPropertyCount; |
| VkExtensionProperties__P mPProperties; |
| uint32_t mResult; |
| }; |
| |
| class VkLayerProperties__P: public Encodable { |
| public: |
| VkLayerProperties__P() = default; |
| VkLayerProperties__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkEnumerateDeviceLayerProperties: public Encodable { |
| public: |
| VkEnumerateDeviceLayerProperties() = default; |
| VkEnumerateDeviceLayerProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, U32__P PPropertyCount, VkLayerProperties__P PProperties, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPPropertyCount(PPropertyCount) |
| , mPProperties(PProperties) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| U32__P mPPropertyCount; |
| VkLayerProperties__P mPProperties; |
| uint32_t mResult; |
| }; |
| |
| class VkEnumerateInstanceExtensionProperties: public Encodable { |
| public: |
| VkEnumerateInstanceExtensionProperties() = default; |
| VkEnumerateInstanceExtensionProperties(const gapic::Vector<gapic::Encodable*>& extras, const char* PLayerName, U32__P PPropertyCount, VkExtensionProperties__P PProperties, uint32_t Result) |
| : mextras(extras) |
| , mPLayerName(PLayerName) |
| , mPPropertyCount(PPropertyCount) |
| , mPProperties(PProperties) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| const char* mPLayerName; |
| U32__P mPPropertyCount; |
| VkExtensionProperties__P mPProperties; |
| uint32_t mResult; |
| }; |
| |
| class VkEnumerateInstanceLayerProperties: public Encodable { |
| public: |
| VkEnumerateInstanceLayerProperties() = default; |
| VkEnumerateInstanceLayerProperties(const gapic::Vector<gapic::Encodable*>& extras, U32__P PPropertyCount, VkLayerProperties__P PProperties, uint32_t Result) |
| : mextras(extras) |
| , mPPropertyCount(PPropertyCount) |
| , mPProperties(PProperties) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| U32__P mPPropertyCount; |
| VkLayerProperties__P mPProperties; |
| uint32_t mResult; |
| }; |
| |
| class VkPhysicalDevice__P: public Encodable { |
| public: |
| VkPhysicalDevice__P() = default; |
| VkPhysicalDevice__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkEnumeratePhysicalDevices: public Encodable { |
| public: |
| VkEnumeratePhysicalDevices() = default; |
| VkEnumeratePhysicalDevices(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, U32__P PPhysicalDeviceCount, VkPhysicalDevice__P PPhysicalDevices, uint32_t Result) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPPhysicalDeviceCount(PPhysicalDeviceCount) |
| , mPPhysicalDevices(PPhysicalDevices) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| U32__P mPPhysicalDeviceCount; |
| VkPhysicalDevice__P mPPhysicalDevices; |
| uint32_t mResult; |
| }; |
| |
| class VkEventCreateInfo: public Encodable { |
| public: |
| VkEventCreateInfo() = default; |
| VkEventCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mSType); |
| e->Struct(this->mPNext); |
| e->Uint32(this->mFlags); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| }; |
| |
| class VkEventCreateInfo__S: public Encodable { |
| public: |
| VkEventCreateInfo__S() = default; |
| VkEventCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkEventCreateInfo__P: public Encodable { |
| public: |
| VkEventCreateInfo__P() = default; |
| VkEventCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkEvent__S: public Encodable { |
| public: |
| VkEvent__S() = default; |
| VkEvent__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkExtensionProperties: public Encodable { |
| public: |
| VkExtensionProperties() = default; |
| VkExtensionProperties(Char__256__A ExtensionName, uint32_t SpecVersion) |
| : mExtensionName(ExtensionName) |
| , mSpecVersion(SpecVersion) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mExtensionName); |
| e->Uint32(this->mSpecVersion); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| Char__256__A mExtensionName; |
| uint32_t mSpecVersion; |
| }; |
| |
| class VkExtensionProperties__S: public Encodable { |
| public: |
| VkExtensionProperties__S() = default; |
| VkExtensionProperties__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkExtent2D__S: public Encodable { |
| public: |
| VkExtent2D__S() = default; |
| VkExtent2D__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkExtent2D__P: public Encodable { |
| public: |
| VkExtent2D__P() = default; |
| VkExtent2D__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkFenceCreateInfo: public Encodable { |
| public: |
| VkFenceCreateInfo() = default; |
| VkFenceCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mSType); |
| e->Struct(this->mPNext); |
| e->Uint32(this->mFlags); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| }; |
| |
| class VkFenceCreateInfo__S: public Encodable { |
| public: |
| VkFenceCreateInfo__S() = default; |
| VkFenceCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkFenceCreateInfo__P: public Encodable { |
| public: |
| VkFenceCreateInfo__P() = default; |
| VkFenceCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkFence__S: public Encodable { |
| public: |
| VkFence__S() = default; |
| VkFence__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkFence__CP: public Encodable { |
| public: |
| VkFence__CP() = default; |
| VkFence__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkMappedMemoryRange__CP: public Encodable { |
| public: |
| VkMappedMemoryRange__CP() = default; |
| VkMappedMemoryRange__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkFlushMappedMemoryRanges: public Encodable { |
| public: |
| VkFlushMappedMemoryRanges() = default; |
| VkFlushMappedMemoryRanges(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t MemoryRangeCount, VkMappedMemoryRange__CP PMemoryRanges, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mMemoryRangeCount(MemoryRangeCount) |
| , mPMemoryRanges(PMemoryRanges) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mMemoryRangeCount; |
| VkMappedMemoryRange__CP mPMemoryRanges; |
| uint32_t mResult; |
| }; |
| |
| class VkFormatProperties: public Encodable { |
| public: |
| VkFormatProperties() = default; |
| VkFormatProperties(uint32_t LinearTilingFeatures, uint32_t OptimalTilingFeatures, uint32_t BufferFeatures) |
| : mLinearTilingFeatures(LinearTilingFeatures) |
| , mOptimalTilingFeatures(OptimalTilingFeatures) |
| , mBufferFeatures(BufferFeatures) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mLinearTilingFeatures); |
| e->Uint32(this->mOptimalTilingFeatures); |
| e->Uint32(this->mBufferFeatures); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mLinearTilingFeatures; |
| uint32_t mOptimalTilingFeatures; |
| uint32_t mBufferFeatures; |
| }; |
| |
| class VkFormatProperties__S: public Encodable { |
| public: |
| VkFormatProperties__S() = default; |
| VkFormatProperties__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkFormatProperties__P: public Encodable { |
| public: |
| VkFormatProperties__P() = default; |
| VkFormatProperties__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageView__CP: public Encodable { |
| public: |
| VkImageView__CP() = default; |
| VkImageView__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkFramebufferCreateInfo: public Encodable { |
| public: |
| VkFramebufferCreateInfo() = default; |
| VkFramebufferCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t RenderPass, uint32_t AttachmentCount, VkImageView__CP PAttachments, uint32_t Width, uint32_t Height, uint32_t Layers) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mRenderPass(RenderPass) |
| , mAttachmentCount(AttachmentCount) |
| , mPAttachments(PAttachments) |
| , mWidth(Width) |
| , mHeight(Height) |
| , mLayers(Layers) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint64_t mRenderPass; |
| uint32_t mAttachmentCount; |
| VkImageView__CP mPAttachments; |
| uint32_t mWidth; |
| uint32_t mHeight; |
| uint32_t mLayers; |
| }; |
| |
| class VkFramebufferCreateInfo__S: public Encodable { |
| public: |
| VkFramebufferCreateInfo__S() = default; |
| VkFramebufferCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkFramebufferCreateInfo__P: public Encodable { |
| public: |
| VkFramebufferCreateInfo__P() = default; |
| VkFramebufferCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkFramebuffer__S: public Encodable { |
| public: |
| VkFramebuffer__S() = default; |
| VkFramebuffer__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkFreeCommandBuffers: public Encodable { |
| public: |
| VkFreeCommandBuffers() = default; |
| VkFreeCommandBuffers(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t CommandPool, uint32_t CommandBufferCount, VkCommandBuffer__CP PCommandBuffers) |
| : mextras(extras) |
| , mDevice(Device) |
| , mCommandPool(CommandPool) |
| , mCommandBufferCount(CommandBufferCount) |
| , mPCommandBuffers(PCommandBuffers) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mCommandPool; |
| uint32_t mCommandBufferCount; |
| VkCommandBuffer__CP mPCommandBuffers; |
| }; |
| |
| class VkFreeDescriptorSets: public Encodable { |
| public: |
| VkFreeDescriptorSets() = default; |
| VkFreeDescriptorSets(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DescriptorPool, uint32_t DescriptorSetCount, VkDescriptorSet__CP PDescriptorSets, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mDescriptorPool(DescriptorPool) |
| , mDescriptorSetCount(DescriptorSetCount) |
| , mPDescriptorSets(PDescriptorSets) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mDescriptorPool; |
| uint32_t mDescriptorSetCount; |
| VkDescriptorSet__CP mPDescriptorSets; |
| uint32_t mResult; |
| }; |
| |
| class VkFreeMemory: public Encodable { |
| public: |
| VkFreeMemory() = default; |
| VkFreeMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Memory, VkAllocationCallbacks__CP PAllocator) |
| : mextras(extras) |
| , mDevice(Device) |
| , mMemory(Memory) |
| , mPAllocator(PAllocator) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mMemory; |
| VkAllocationCallbacks__CP mPAllocator; |
| }; |
| |
| class VkMemoryRequirements__P: public Encodable { |
| public: |
| VkMemoryRequirements__P() = default; |
| VkMemoryRequirements__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetBufferMemoryRequirements: public Encodable { |
| public: |
| VkGetBufferMemoryRequirements() = default; |
| VkGetBufferMemoryRequirements(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Buffer, VkMemoryRequirements__P PMemoryRequirements) |
| : mextras(extras) |
| , mDevice(Device) |
| , mBuffer(Buffer) |
| , mPMemoryRequirements(PMemoryRequirements) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mBuffer; |
| VkMemoryRequirements__P mPMemoryRequirements; |
| }; |
| |
| class VkGetDeviceMemoryCommitment: public Encodable { |
| public: |
| VkGetDeviceMemoryCommitment() = default; |
| VkGetDeviceMemoryCommitment(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Memory, VkDeviceSize__P PCommittedMemoryInBytes) |
| : mextras(extras) |
| , mDevice(Device) |
| , mMemory(Memory) |
| , mPCommittedMemoryInBytes(PCommittedMemoryInBytes) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mMemory; |
| VkDeviceSize__P mPCommittedMemoryInBytes; |
| }; |
| |
| class VkGetDeviceProcAddr: public Encodable { |
| public: |
| VkGetDeviceProcAddr() = default; |
| VkGetDeviceProcAddr(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, const char* PName, PFN_vkVoidFunction Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPName(PName) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| const char* mPName; |
| PFN_vkVoidFunction mResult; |
| }; |
| |
| class VkQueue__P: public Encodable { |
| public: |
| VkQueue__P() = default; |
| VkQueue__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetDeviceQueue: public Encodable { |
| public: |
| VkGetDeviceQueue() = default; |
| VkGetDeviceQueue(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t QueueFamilyIndex, uint32_t QueueIndex, VkQueue__P PQueue) |
| : mextras(extras) |
| , mDevice(Device) |
| , mQueueFamilyIndex(QueueFamilyIndex) |
| , mQueueIndex(QueueIndex) |
| , mPQueue(PQueue) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mQueueFamilyIndex; |
| uint32_t mQueueIndex; |
| VkQueue__P mPQueue; |
| }; |
| |
| class VkGetDisplayModePropertiesKHR: public Encodable { |
| public: |
| VkGetDisplayModePropertiesKHR() = default; |
| VkGetDisplayModePropertiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Display, U32__P PPropertyCount, VkDisplayModePropertiesKHR__P PProperties, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mDisplay(Display) |
| , mPPropertyCount(PPropertyCount) |
| , mPProperties(PProperties) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint64_t mDisplay; |
| U32__P mPPropertyCount; |
| VkDisplayModePropertiesKHR__P mPProperties; |
| uint32_t mResult; |
| }; |
| |
| class VkGetDisplayPlaneCapabilitiesKHR: public Encodable { |
| public: |
| VkGetDisplayPlaneCapabilitiesKHR() = default; |
| VkGetDisplayPlaneCapabilitiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Mode, uint32_t PlaneIndex, VkDisplayPlaneCapabilitiesKHR__P PCapabilities, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mMode(Mode) |
| , mPlaneIndex(PlaneIndex) |
| , mPCapabilities(PCapabilities) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint64_t mMode; |
| uint32_t mPlaneIndex; |
| VkDisplayPlaneCapabilitiesKHR__P mPCapabilities; |
| uint32_t mResult; |
| }; |
| |
| class VkGetDisplayPlaneSupportedDisplaysKHR: public Encodable { |
| public: |
| VkGetDisplayPlaneSupportedDisplaysKHR() = default; |
| VkGetDisplayPlaneSupportedDisplaysKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t PlaneIndex, U32__P PDisplayCount, VkDisplayKHR__P PDisplays, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPlaneIndex(PlaneIndex) |
| , mPDisplayCount(PDisplayCount) |
| , mPDisplays(PDisplays) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint32_t mPlaneIndex; |
| U32__P mPDisplayCount; |
| VkDisplayKHR__P mPDisplays; |
| uint32_t mResult; |
| }; |
| |
| class VkGetEventStatus: public Encodable { |
| public: |
| VkGetEventStatus() = default; |
| VkGetEventStatus(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Event, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mEvent(Event) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mEvent; |
| uint32_t mResult; |
| }; |
| |
| class VkGetFenceStatus: public Encodable { |
| public: |
| VkGetFenceStatus() = default; |
| VkGetFenceStatus(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Fence, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mFence(Fence) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mFence; |
| uint32_t mResult; |
| }; |
| |
| class VkGetImageMemoryRequirements: public Encodable { |
| public: |
| VkGetImageMemoryRequirements() = default; |
| VkGetImageMemoryRequirements(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, VkMemoryRequirements__P PMemoryRequirements) |
| : mextras(extras) |
| , mDevice(Device) |
| , mImage(Image) |
| , mPMemoryRequirements(PMemoryRequirements) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mImage; |
| VkMemoryRequirements__P mPMemoryRequirements; |
| }; |
| |
| class VkSparseImageMemoryRequirements__P: public Encodable { |
| public: |
| VkSparseImageMemoryRequirements__P() = default; |
| VkSparseImageMemoryRequirements__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetImageSparseMemoryRequirements: public Encodable { |
| public: |
| VkGetImageSparseMemoryRequirements() = default; |
| VkGetImageSparseMemoryRequirements(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, U32__P PSparseMemoryRequirementCount, VkSparseImageMemoryRequirements__P PSparseMemoryRequirements) |
| : mextras(extras) |
| , mDevice(Device) |
| , mImage(Image) |
| , mPSparseMemoryRequirementCount(PSparseMemoryRequirementCount) |
| , mPSparseMemoryRequirements(PSparseMemoryRequirements) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mImage; |
| U32__P mPSparseMemoryRequirementCount; |
| VkSparseImageMemoryRequirements__P mPSparseMemoryRequirements; |
| }; |
| |
| class VkImageSubresource__CP: public Encodable { |
| public: |
| VkImageSubresource__CP() = default; |
| VkImageSubresource__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSubresourceLayout__P: public Encodable { |
| public: |
| VkSubresourceLayout__P() = default; |
| VkSubresourceLayout__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetImageSubresourceLayout: public Encodable { |
| public: |
| VkGetImageSubresourceLayout() = default; |
| VkGetImageSubresourceLayout(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Image, VkImageSubresource__CP PSubresource, VkSubresourceLayout__P PLayout) |
| : mextras(extras) |
| , mDevice(Device) |
| , mImage(Image) |
| , mPSubresource(PSubresource) |
| , mPLayout(PLayout) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mImage; |
| VkImageSubresource__CP mPSubresource; |
| VkSubresourceLayout__P mPLayout; |
| }; |
| |
| class VkGetInstanceProcAddr: public Encodable { |
| public: |
| VkGetInstanceProcAddr() = default; |
| VkGetInstanceProcAddr(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Instance, const char* PName, PFN_vkVoidFunction Result) |
| : mextras(extras) |
| , mInstance(Instance) |
| , mPName(PName) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mInstance; |
| const char* mPName; |
| PFN_vkVoidFunction mResult; |
| }; |
| |
| class VkGetPhysicalDeviceDisplayPlanePropertiesKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceDisplayPlanePropertiesKHR() = default; |
| VkGetPhysicalDeviceDisplayPlanePropertiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, U32__P PPropertyCount, VkDisplayPlanePropertiesKHR__P PProperties, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPPropertyCount(PPropertyCount) |
| , mPProperties(PProperties) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| U32__P mPPropertyCount; |
| VkDisplayPlanePropertiesKHR__P mPProperties; |
| uint32_t mResult; |
| }; |
| |
| class VkGetPhysicalDeviceDisplayPropertiesKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceDisplayPropertiesKHR() = default; |
| VkGetPhysicalDeviceDisplayPropertiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, U32__P PPropertyCount, VkDisplayPropertiesKHR__P PProperties, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPPropertyCount(PPropertyCount) |
| , mPProperties(PProperties) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| U32__P mPPropertyCount; |
| VkDisplayPropertiesKHR__P mPProperties; |
| uint32_t mResult; |
| }; |
| |
| class VkPhysicalDeviceFeatures__P: public Encodable { |
| public: |
| VkPhysicalDeviceFeatures__P() = default; |
| VkPhysicalDeviceFeatures__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceFeatures: public Encodable { |
| public: |
| VkGetPhysicalDeviceFeatures() = default; |
| VkGetPhysicalDeviceFeatures(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkPhysicalDeviceFeatures__P PFeatures) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPFeatures(PFeatures) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mPhysicalDevice); |
| e->Struct(this->mPFeatures); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| VkPhysicalDeviceFeatures__P mPFeatures; |
| }; |
| |
| class VkGetPhysicalDeviceFormatProperties: public Encodable { |
| public: |
| VkGetPhysicalDeviceFormatProperties() = default; |
| VkGetPhysicalDeviceFormatProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t Format, VkFormatProperties__P PFormatProperties) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mFormat(Format) |
| , mPFormatProperties(PFormatProperties) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint32_t mFormat; |
| VkFormatProperties__P mPFormatProperties; |
| }; |
| |
| class VkImageFormatProperties__P: public Encodable { |
| public: |
| VkImageFormatProperties__P() = default; |
| VkImageFormatProperties__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceImageFormatProperties: public Encodable { |
| public: |
| VkGetPhysicalDeviceImageFormatProperties() = default; |
| VkGetPhysicalDeviceImageFormatProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t Format, uint32_t Type, uint32_t Tiling, uint32_t Usage, uint32_t Flags, VkImageFormatProperties__P PImageFormatProperties, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mFormat(Format) |
| , mType(Type) |
| , mTiling(Tiling) |
| , mUsage(Usage) |
| , mFlags(Flags) |
| , mPImageFormatProperties(PImageFormatProperties) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint32_t mFormat; |
| uint32_t mType; |
| uint32_t mTiling; |
| uint32_t mUsage; |
| uint32_t mFlags; |
| VkImageFormatProperties__P mPImageFormatProperties; |
| uint32_t mResult; |
| }; |
| |
| class VkGetPhysicalDeviceMemoryProperties: public Encodable { |
| public: |
| VkGetPhysicalDeviceMemoryProperties() = default; |
| VkGetPhysicalDeviceMemoryProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkPhysicalDeviceMemoryProperties__P PMemoryProperties) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPMemoryProperties(PMemoryProperties) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mPhysicalDevice); |
| e->Struct(this->mPMemoryProperties); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| VkPhysicalDeviceMemoryProperties__P mPMemoryProperties; |
| }; |
| |
| class VkGetPhysicalDeviceMirPresentationSupportKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceMirPresentationSupportKHR() = default; |
| VkGetPhysicalDeviceMirPresentationSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, MirConnection__P Connection, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mQueueFamilyIndex(QueueFamilyIndex) |
| , mConnection(Connection) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint32_t mQueueFamilyIndex; |
| MirConnection__P mConnection; |
| uint32_t mResult; |
| }; |
| |
| class VkPhysicalDeviceProperties__P: public Encodable { |
| public: |
| VkPhysicalDeviceProperties__P() = default; |
| VkPhysicalDeviceProperties__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceProperties: public Encodable { |
| public: |
| VkGetPhysicalDeviceProperties() = default; |
| VkGetPhysicalDeviceProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, VkPhysicalDeviceProperties__P PProperties) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPProperties(PProperties) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mPhysicalDevice); |
| e->Struct(this->mPProperties); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| VkPhysicalDeviceProperties__P mPProperties; |
| }; |
| |
| class VkQueueFamilyProperties__P: public Encodable { |
| public: |
| VkQueueFamilyProperties__P() = default; |
| VkQueueFamilyProperties__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceQueueFamilyProperties: public Encodable { |
| public: |
| VkGetPhysicalDeviceQueueFamilyProperties() = default; |
| VkGetPhysicalDeviceQueueFamilyProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, U32__P PQueueFamilyPropertyCount, VkQueueFamilyProperties__P PQueueFamilyProperties) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mPQueueFamilyPropertyCount(PQueueFamilyPropertyCount) |
| , mPQueueFamilyProperties(PQueueFamilyProperties) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| U32__P mPQueueFamilyPropertyCount; |
| VkQueueFamilyProperties__P mPQueueFamilyProperties; |
| }; |
| |
| class VkSparseImageFormatProperties__P: public Encodable { |
| public: |
| VkSparseImageFormatProperties__P() = default; |
| VkSparseImageFormatProperties__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceSparseImageFormatProperties: public Encodable { |
| public: |
| VkGetPhysicalDeviceSparseImageFormatProperties() = default; |
| VkGetPhysicalDeviceSparseImageFormatProperties(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t Format, uint32_t Type, uint32_t Samples, uint32_t Usage, uint32_t Tiling, U32__P PPropertyCount, VkSparseImageFormatProperties__P PProperties) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mFormat(Format) |
| , mType(Type) |
| , mSamples(Samples) |
| , mUsage(Usage) |
| , mTiling(Tiling) |
| , mPPropertyCount(PPropertyCount) |
| , mPProperties(PProperties) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint32_t mFormat; |
| uint32_t mType; |
| uint32_t mSamples; |
| uint32_t mUsage; |
| uint32_t mTiling; |
| U32__P mPPropertyCount; |
| VkSparseImageFormatProperties__P mPProperties; |
| }; |
| |
| class VkSurfaceCapabilitiesKHR__P: public Encodable { |
| public: |
| VkSurfaceCapabilitiesKHR__P() = default; |
| VkSurfaceCapabilitiesKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceSurfaceCapabilitiesKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceSurfaceCapabilitiesKHR() = default; |
| VkGetPhysicalDeviceSurfaceCapabilitiesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Surface, VkSurfaceCapabilitiesKHR__P PSurfaceCapabilities, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mSurface(Surface) |
| , mPSurfaceCapabilities(PSurfaceCapabilities) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint64_t mSurface; |
| VkSurfaceCapabilitiesKHR__P mPSurfaceCapabilities; |
| uint32_t mResult; |
| }; |
| |
| class VkSurfaceFormatKHR__P: public Encodable { |
| public: |
| VkSurfaceFormatKHR__P() = default; |
| VkSurfaceFormatKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceSurfaceFormatsKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceSurfaceFormatsKHR() = default; |
| VkGetPhysicalDeviceSurfaceFormatsKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Surface, U32__P PSurfaceFormatCount, VkSurfaceFormatKHR__P PSurfaceFormats, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mSurface(Surface) |
| , mPSurfaceFormatCount(PSurfaceFormatCount) |
| , mPSurfaceFormats(PSurfaceFormats) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint64_t mSurface; |
| U32__P mPSurfaceFormatCount; |
| VkSurfaceFormatKHR__P mPSurfaceFormats; |
| uint32_t mResult; |
| }; |
| |
| class VkPresentModeKHR__P: public Encodable { |
| public: |
| VkPresentModeKHR__P() = default; |
| VkPresentModeKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceSurfacePresentModesKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceSurfacePresentModesKHR() = default; |
| VkGetPhysicalDeviceSurfacePresentModesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint64_t Surface, U32__P PPresentModeCount, VkPresentModeKHR__P PPresentModes, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mSurface(Surface) |
| , mPPresentModeCount(PPresentModeCount) |
| , mPPresentModes(PPresentModes) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint64_t mSurface; |
| U32__P mPPresentModeCount; |
| VkPresentModeKHR__P mPPresentModes; |
| uint32_t mResult; |
| }; |
| |
| class VkGetPhysicalDeviceSurfaceSupportKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceSurfaceSupportKHR() = default; |
| VkGetPhysicalDeviceSurfaceSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, uint64_t Surface, VkBool32__P PSupported, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mQueueFamilyIndex(QueueFamilyIndex) |
| , mSurface(Surface) |
| , mPSupported(PSupported) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint32_t mQueueFamilyIndex; |
| uint64_t mSurface; |
| VkBool32__P mPSupported; |
| uint32_t mResult; |
| }; |
| |
| class Wl_display__P: public Encodable { |
| public: |
| Wl_display__P() = default; |
| Wl_display__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceWaylandPresentationSupportKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceWaylandPresentationSupportKHR() = default; |
| VkGetPhysicalDeviceWaylandPresentationSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, Wl_display__P Display, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mQueueFamilyIndex(QueueFamilyIndex) |
| , mDisplay(Display) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint32_t mQueueFamilyIndex; |
| Wl_display__P mDisplay; |
| uint32_t mResult; |
| }; |
| |
| class Xcb_connection_t__P: public Encodable { |
| public: |
| Xcb_connection_t__P() = default; |
| Xcb_connection_t__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGetPhysicalDeviceXcbPresentationSupportKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceXcbPresentationSupportKHR() = default; |
| VkGetPhysicalDeviceXcbPresentationSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, Xcb_connection_t__P Connection, uint32_t VisualId, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mQueueFamilyIndex(QueueFamilyIndex) |
| , mConnection(Connection) |
| , mVisualId(VisualId) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint32_t mQueueFamilyIndex; |
| Xcb_connection_t__P mConnection; |
| uint32_t mVisualId; |
| uint32_t mResult; |
| }; |
| |
| class VkGetPhysicalDeviceXlibPresentationSupportKHR: public Encodable { |
| public: |
| VkGetPhysicalDeviceXlibPresentationSupportKHR() = default; |
| VkGetPhysicalDeviceXlibPresentationSupportKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t PhysicalDevice, uint32_t QueueFamilyIndex, Display__P Dpy, uint64_t VisualID, uint32_t Result) |
| : mextras(extras) |
| , mPhysicalDevice(PhysicalDevice) |
| , mQueueFamilyIndex(QueueFamilyIndex) |
| , mDpy(Dpy) |
| , mVisualID(VisualID) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mPhysicalDevice; |
| uint32_t mQueueFamilyIndex; |
| Display__P mDpy; |
| uint64_t mVisualID; |
| uint32_t mResult; |
| }; |
| |
| class VkGetPipelineCacheData: public Encodable { |
| public: |
| VkGetPipelineCacheData() = default; |
| VkGetPipelineCacheData(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t PipelineCache, Size__P PDataSize, Void__P PData, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mPipelineCache(PipelineCache) |
| , mPDataSize(PDataSize) |
| , mPData(PData) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mPipelineCache; |
| Size__P mPDataSize; |
| Void__P mPData; |
| uint32_t mResult; |
| }; |
| |
| class VkGetQueryPoolResults: public Encodable { |
| public: |
| VkGetQueryPoolResults() = default; |
| VkGetQueryPoolResults(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t QueryPool, uint32_t FirstQuery, uint32_t QueryCount, uint64_t DataSize, Void__P PData, uint64_t Stride, uint32_t Flags, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mQueryPool(QueryPool) |
| , mFirstQuery(FirstQuery) |
| , mQueryCount(QueryCount) |
| , mDataSize(DataSize) |
| , mPData(PData) |
| , mStride(Stride) |
| , mFlags(Flags) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mQueryPool; |
| uint32_t mFirstQuery; |
| uint32_t mQueryCount; |
| uint64_t mDataSize; |
| Void__P mPData; |
| uint64_t mStride; |
| uint32_t mFlags; |
| uint32_t mResult; |
| }; |
| |
| class VkGetRenderAreaGranularity: public Encodable { |
| public: |
| VkGetRenderAreaGranularity() = default; |
| VkGetRenderAreaGranularity(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t RenderPass, VkExtent2D__P PGranularity) |
| : mextras(extras) |
| , mDevice(Device) |
| , mRenderPass(RenderPass) |
| , mPGranularity(PGranularity) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mRenderPass; |
| VkExtent2D__P mPGranularity; |
| }; |
| |
| class VkGetSwapchainGrallocUsageANDROID: public Encodable { |
| public: |
| VkGetSwapchainGrallocUsageANDROID() = default; |
| VkGetSwapchainGrallocUsageANDROID(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t Format, uint32_t ImageUsage, Int__P GrallocUsage, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mFormat(Format) |
| , mImageUsage(ImageUsage) |
| , mGrallocUsage(GrallocUsage) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mFormat; |
| uint32_t mImageUsage; |
| Int__P mGrallocUsage; |
| uint32_t mResult; |
| }; |
| |
| class VkGetSwapchainImagesKHR: public Encodable { |
| public: |
| VkGetSwapchainImagesKHR() = default; |
| VkGetSwapchainImagesKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Swapchain, U32__P PSwapchainImageCount, VkImage__P PSwapchainImages, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mSwapchain(Swapchain) |
| , mPSwapchainImageCount(PSwapchainImageCount) |
| , mPSwapchainImages(PSwapchainImages) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mSwapchain; |
| U32__P mPSwapchainImageCount; |
| VkImage__P mPSwapchainImages; |
| uint32_t mResult; |
| }; |
| |
| class VkPipelineShaderStageCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineShaderStageCreateInfo__CP() = default; |
| VkPipelineShaderStageCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineVertexInputStateCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineVertexInputStateCreateInfo__CP() = default; |
| VkPipelineVertexInputStateCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineInputAssemblyStateCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineInputAssemblyStateCreateInfo__CP() = default; |
| VkPipelineInputAssemblyStateCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineTessellationStateCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineTessellationStateCreateInfo__CP() = default; |
| VkPipelineTessellationStateCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineViewportStateCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineViewportStateCreateInfo__CP() = default; |
| VkPipelineViewportStateCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineRasterizationStateCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineRasterizationStateCreateInfo__CP() = default; |
| VkPipelineRasterizationStateCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineMultisampleStateCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineMultisampleStateCreateInfo__CP() = default; |
| VkPipelineMultisampleStateCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineDepthStencilStateCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineDepthStencilStateCreateInfo__CP() = default; |
| VkPipelineDepthStencilStateCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineColorBlendStateCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineColorBlendStateCreateInfo__CP() = default; |
| VkPipelineColorBlendStateCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineDynamicStateCreateInfo__CP: public Encodable { |
| public: |
| VkPipelineDynamicStateCreateInfo__CP() = default; |
| VkPipelineDynamicStateCreateInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkGraphicsPipelineCreateInfo: public Encodable { |
| public: |
| VkGraphicsPipelineCreateInfo() = default; |
| VkGraphicsPipelineCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t StageCount, VkPipelineShaderStageCreateInfo__CP PStages, VkPipelineVertexInputStateCreateInfo__CP PVertexInputState, VkPipelineInputAssemblyStateCreateInfo__CP PInputAssemblyState, VkPipelineTessellationStateCreateInfo__CP PTessellationState, VkPipelineViewportStateCreateInfo__CP PViewportState, VkPipelineRasterizationStateCreateInfo__CP PRasterizationState, VkPipelineMultisampleStateCreateInfo__CP PMultisampleState, VkPipelineDepthStencilStateCreateInfo__CP PDepthStencilState, VkPipelineColorBlendStateCreateInfo__CP PColorBlendState, VkPipelineDynamicStateCreateInfo__CP PDynamicState, uint64_t Layout, uint64_t RenderPass, uint32_t Subpass, uint64_t BasePipelineHandle, int32_t BasePipelineIndex) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mStageCount(StageCount) |
| , mPStages(PStages) |
| , mPVertexInputState(PVertexInputState) |
| , mPInputAssemblyState(PInputAssemblyState) |
| , mPTessellationState(PTessellationState) |
| , mPViewportState(PViewportState) |
| , mPRasterizationState(PRasterizationState) |
| , mPMultisampleState(PMultisampleState) |
| , mPDepthStencilState(PDepthStencilState) |
| , mPColorBlendState(PColorBlendState) |
| , mPDynamicState(PDynamicState) |
| , mLayout(Layout) |
| , mRenderPass(RenderPass) |
| , mSubpass(Subpass) |
| , mBasePipelineHandle(BasePipelineHandle) |
| , mBasePipelineIndex(BasePipelineIndex) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mStageCount; |
| VkPipelineShaderStageCreateInfo__CP mPStages; |
| VkPipelineVertexInputStateCreateInfo__CP mPVertexInputState; |
| VkPipelineInputAssemblyStateCreateInfo__CP mPInputAssemblyState; |
| VkPipelineTessellationStateCreateInfo__CP mPTessellationState; |
| VkPipelineViewportStateCreateInfo__CP mPViewportState; |
| VkPipelineRasterizationStateCreateInfo__CP mPRasterizationState; |
| VkPipelineMultisampleStateCreateInfo__CP mPMultisampleState; |
| VkPipelineDepthStencilStateCreateInfo__CP mPDepthStencilState; |
| VkPipelineColorBlendStateCreateInfo__CP mPColorBlendState; |
| VkPipelineDynamicStateCreateInfo__CP mPDynamicState; |
| uint64_t mLayout; |
| uint64_t mRenderPass; |
| uint32_t mSubpass; |
| uint64_t mBasePipelineHandle; |
| int32_t mBasePipelineIndex; |
| }; |
| |
| class VkGraphicsPipelineCreateInfo__S: public Encodable { |
| public: |
| VkGraphicsPipelineCreateInfo__S() = default; |
| VkGraphicsPipelineCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkGraphicsPipelineCreateInfo__P: public Encodable { |
| public: |
| VkGraphicsPipelineCreateInfo__P() = default; |
| VkGraphicsPipelineCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkOffset3D__2__A: public Encodable { |
| public: |
| VkOffset3D__2__A() = default; |
| VkOffset3D__2__A(const gapic::StaticArray<VkOffset3D, 2>& Elements) |
| : mElements(Elements) {} |
| virtual void Encode(Encoder* e) const{ |
| for (int i = 0; i < 2; i++) { |
| e->Struct(this->mElements[i]); |
| } |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::StaticArray<VkOffset3D, 2> mElements; |
| }; |
| |
| class VkImageBlit: public Encodable { |
| public: |
| VkImageBlit() = default; |
| VkImageBlit(VkImageSubresourceLayers SrcSubresource, VkOffset3D__2__A SrcOffsets, VkImageSubresourceLayers DstSubresource, VkOffset3D__2__A DstOffsets) |
| : mSrcSubresource(SrcSubresource) |
| , mSrcOffsets(SrcOffsets) |
| , mDstSubresource(DstSubresource) |
| , mDstOffsets(DstOffsets) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkImageSubresourceLayers mSrcSubresource; |
| VkOffset3D__2__A mSrcOffsets; |
| VkImageSubresourceLayers mDstSubresource; |
| VkOffset3D__2__A mDstOffsets; |
| }; |
| |
| class VkImageBlit__S: public Encodable { |
| public: |
| VkImageBlit__S() = default; |
| VkImageBlit__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImageBlit__P: public Encodable { |
| public: |
| VkImageBlit__P() = default; |
| VkImageBlit__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageCopy__S: public Encodable { |
| public: |
| VkImageCopy__S() = default; |
| VkImageCopy__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImageCopy__P: public Encodable { |
| public: |
| VkImageCopy__P() = default; |
| VkImageCopy__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageCreateInfo: public Encodable { |
| public: |
| VkImageCreateInfo() = default; |
| VkImageCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t ImageType, uint32_t Format, VkExtent3D Extent, uint32_t MipLevels, uint32_t ArrayLayers, uint32_t Samples, uint32_t Tiling, uint32_t Usage, uint32_t SharingMode, uint32_t QueueFamilyIndexCount, U32__CP PQueueFamilyIndices, uint32_t InitialLayout) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mImageType(ImageType) |
| , mFormat(Format) |
| , mExtent(Extent) |
| , mMipLevels(MipLevels) |
| , mArrayLayers(ArrayLayers) |
| , mSamples(Samples) |
| , mTiling(Tiling) |
| , mUsage(Usage) |
| , mSharingMode(SharingMode) |
| , mQueueFamilyIndexCount(QueueFamilyIndexCount) |
| , mPQueueFamilyIndices(PQueueFamilyIndices) |
| , mInitialLayout(InitialLayout) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mImageType; |
| uint32_t mFormat; |
| VkExtent3D mExtent; |
| uint32_t mMipLevels; |
| uint32_t mArrayLayers; |
| uint32_t mSamples; |
| uint32_t mTiling; |
| uint32_t mUsage; |
| uint32_t mSharingMode; |
| uint32_t mQueueFamilyIndexCount; |
| U32__CP mPQueueFamilyIndices; |
| uint32_t mInitialLayout; |
| }; |
| |
| class VkImageCreateInfo__S: public Encodable { |
| public: |
| VkImageCreateInfo__S() = default; |
| VkImageCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImageCreateInfo__P: public Encodable { |
| public: |
| VkImageCreateInfo__P() = default; |
| VkImageCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageFormatProperties: public Encodable { |
| public: |
| VkImageFormatProperties() = default; |
| VkImageFormatProperties(VkExtent3D MaxExtent, uint32_t MaxMipLevels, uint32_t MaxArrayLayers, uint32_t SampleCounts, uint64_t MaxResourceSize) |
| : mMaxExtent(MaxExtent) |
| , mMaxMipLevels(MaxMipLevels) |
| , mMaxArrayLayers(MaxArrayLayers) |
| , mSampleCounts(SampleCounts) |
| , mMaxResourceSize(MaxResourceSize) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkExtent3D mMaxExtent; |
| uint32_t mMaxMipLevels; |
| uint32_t mMaxArrayLayers; |
| uint32_t mSampleCounts; |
| uint64_t mMaxResourceSize; |
| }; |
| |
| class VkImageFormatProperties__S: public Encodable { |
| public: |
| VkImageFormatProperties__S() = default; |
| VkImageFormatProperties__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImageMemoryBarrier__S: public Encodable { |
| public: |
| VkImageMemoryBarrier__S() = default; |
| VkImageMemoryBarrier__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImageMemoryBarrier__P: public Encodable { |
| public: |
| VkImageMemoryBarrier__P() = default; |
| VkImageMemoryBarrier__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageResolve: public Encodable { |
| public: |
| VkImageResolve() = default; |
| VkImageResolve(VkImageSubresourceLayers SrcSubresource, VkOffset3D SrcOffset, VkImageSubresourceLayers DstSubresource, VkOffset3D DstOffset, VkExtent3D Extent) |
| : mSrcSubresource(SrcSubresource) |
| , mSrcOffset(SrcOffset) |
| , mDstSubresource(DstSubresource) |
| , mDstOffset(DstOffset) |
| , mExtent(Extent) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkImageSubresourceLayers mSrcSubresource; |
| VkOffset3D mSrcOffset; |
| VkImageSubresourceLayers mDstSubresource; |
| VkOffset3D mDstOffset; |
| VkExtent3D mExtent; |
| }; |
| |
| class VkImageResolve__S: public Encodable { |
| public: |
| VkImageResolve__S() = default; |
| VkImageResolve__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImageResolve__P: public Encodable { |
| public: |
| VkImageResolve__P() = default; |
| VkImageResolve__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageSubresource: public Encodable { |
| public: |
| VkImageSubresource() = default; |
| VkImageSubresource(uint32_t AspectMask, uint32_t MipLevel, uint32_t ArrayLayer) |
| : mAspectMask(AspectMask) |
| , mMipLevel(MipLevel) |
| , mArrayLayer(ArrayLayer) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mAspectMask); |
| e->Uint32(this->mMipLevel); |
| e->Uint32(this->mArrayLayer); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mAspectMask; |
| uint32_t mMipLevel; |
| uint32_t mArrayLayer; |
| }; |
| |
| class VkImageSubresourceRange__S: public Encodable { |
| public: |
| VkImageSubresourceRange__S() = default; |
| VkImageSubresourceRange__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImageSubresourceRange__P: public Encodable { |
| public: |
| VkImageSubresourceRange__P() = default; |
| VkImageSubresourceRange__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageSubresource__S: public Encodable { |
| public: |
| VkImageSubresource__S() = default; |
| VkImageSubresource__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImageSubresource__P: public Encodable { |
| public: |
| VkImageSubresource__P() = default; |
| VkImageSubresource__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageViewCreateInfo: public Encodable { |
| public: |
| VkImageViewCreateInfo() = default; |
| VkImageViewCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t Image, uint32_t ViewType, uint32_t Format, VkComponentMapping Components, VkImageSubresourceRange SubresourceRange) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mImage(Image) |
| , mViewType(ViewType) |
| , mFormat(Format) |
| , mComponents(Components) |
| , mSubresourceRange(SubresourceRange) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint64_t mImage; |
| uint32_t mViewType; |
| uint32_t mFormat; |
| VkComponentMapping mComponents; |
| VkImageSubresourceRange mSubresourceRange; |
| }; |
| |
| class VkImageViewCreateInfo__S: public Encodable { |
| public: |
| VkImageViewCreateInfo__S() = default; |
| VkImageViewCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImageViewCreateInfo__P: public Encodable { |
| public: |
| VkImageViewCreateInfo__P() = default; |
| VkImageViewCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkImageView__S: public Encodable { |
| public: |
| VkImageView__S() = default; |
| VkImageView__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkImage__S: public Encodable { |
| public: |
| VkImage__S() = default; |
| VkImage__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkInstanceCreateInfo: public Encodable { |
| public: |
| VkInstanceCreateInfo() = default; |
| VkInstanceCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, VkApplicationInfo__CP PApplicationInfo, uint32_t EnabledLayerCount, Char__CP__CP PpEnabledLayerNames, uint32_t EnabledExtensionCount, Char__CP__CP PpEnabledExtensionNames) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mPApplicationInfo(PApplicationInfo) |
| , mEnabledLayerCount(EnabledLayerCount) |
| , mPpEnabledLayerNames(PpEnabledLayerNames) |
| , mEnabledExtensionCount(EnabledExtensionCount) |
| , mPpEnabledExtensionNames(PpEnabledExtensionNames) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| VkApplicationInfo__CP mPApplicationInfo; |
| uint32_t mEnabledLayerCount; |
| Char__CP__CP mPpEnabledLayerNames; |
| uint32_t mEnabledExtensionCount; |
| Char__CP__CP mPpEnabledExtensionNames; |
| }; |
| |
| class VkInstanceCreateInfo__S: public Encodable { |
| public: |
| VkInstanceCreateInfo__S() = default; |
| VkInstanceCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkInstanceCreateInfo__P: public Encodable { |
| public: |
| VkInstanceCreateInfo__P() = default; |
| VkInstanceCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkInstance__S: public Encodable { |
| public: |
| VkInstance__S() = default; |
| VkInstance__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkInvalidateMappedMemoryRanges: public Encodable { |
| public: |
| VkInvalidateMappedMemoryRanges() = default; |
| VkInvalidateMappedMemoryRanges(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t MemoryRangeCount, VkMappedMemoryRange__CP PMemoryRanges, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mMemoryRangeCount(MemoryRangeCount) |
| , mPMemoryRanges(PMemoryRanges) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mMemoryRangeCount; |
| VkMappedMemoryRange__CP mPMemoryRanges; |
| uint32_t mResult; |
| }; |
| |
| class VkLayerProperties: public Encodable { |
| public: |
| VkLayerProperties() = default; |
| VkLayerProperties(Char__256__A LayerName, uint32_t SpecVersion, uint32_t ImplementationVersion, Char__256__A Description) |
| : mLayerName(LayerName) |
| , mSpecVersion(SpecVersion) |
| , mImplementationVersion(ImplementationVersion) |
| , mDescription(Description) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| Char__256__A mLayerName; |
| uint32_t mSpecVersion; |
| uint32_t mImplementationVersion; |
| Char__256__A mDescription; |
| }; |
| |
| class VkLayerProperties__S: public Encodable { |
| public: |
| VkLayerProperties__S() = default; |
| VkLayerProperties__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Void__P__P: public Encodable { |
| public: |
| Void__P__P() = default; |
| Void__P__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkMapMemory: public Encodable { |
| public: |
| VkMapMemory() = default; |
| VkMapMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Memory, uint64_t Offset, uint64_t Size, uint32_t Flags, Void__P__P PpData, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mMemory(Memory) |
| , mOffset(Offset) |
| , mSize(Size) |
| , mFlags(Flags) |
| , mPpData(PpData) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mMemory; |
| uint64_t mOffset; |
| uint64_t mSize; |
| uint32_t mFlags; |
| Void__P__P mPpData; |
| uint32_t mResult; |
| }; |
| |
| class VkMappedMemoryRange: public Encodable { |
| public: |
| VkMappedMemoryRange() = default; |
| VkMappedMemoryRange(uint32_t SType, Void__CP PNext, uint64_t Memory, uint64_t Offset, uint64_t Size) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mMemory(Memory) |
| , mOffset(Offset) |
| , mSize(Size) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint64_t mMemory; |
| uint64_t mOffset; |
| uint64_t mSize; |
| }; |
| |
| class VkMappedMemoryRange__S: public Encodable { |
| public: |
| VkMappedMemoryRange__S() = default; |
| VkMappedMemoryRange__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkMappedMemoryRange__P: public Encodable { |
| public: |
| VkMappedMemoryRange__P() = default; |
| VkMappedMemoryRange__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkMemoryAllocateInfo: public Encodable { |
| public: |
| VkMemoryAllocateInfo() = default; |
| VkMemoryAllocateInfo(uint32_t SType, Void__CP PNext, uint64_t AllocationSize, uint32_t MemoryTypeIndex) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mAllocationSize(AllocationSize) |
| , mMemoryTypeIndex(MemoryTypeIndex) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint64_t mAllocationSize; |
| uint32_t mMemoryTypeIndex; |
| }; |
| |
| class VkMemoryAllocateInfo__S: public Encodable { |
| public: |
| VkMemoryAllocateInfo__S() = default; |
| VkMemoryAllocateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkMemoryAllocateInfo__P: public Encodable { |
| public: |
| VkMemoryAllocateInfo__P() = default; |
| VkMemoryAllocateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkMemoryBarrier: public Encodable { |
| public: |
| VkMemoryBarrier() = default; |
| VkMemoryBarrier(uint32_t SType, Void__CP PNext, uint32_t SrcAccessMask, uint32_t DstAccessMask) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mSrcAccessMask(SrcAccessMask) |
| , mDstAccessMask(DstAccessMask) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mSrcAccessMask; |
| uint32_t mDstAccessMask; |
| }; |
| |
| class VkMemoryBarrier__S: public Encodable { |
| public: |
| VkMemoryBarrier__S() = default; |
| VkMemoryBarrier__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkMemoryBarrier__P: public Encodable { |
| public: |
| VkMemoryBarrier__P() = default; |
| VkMemoryBarrier__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkMemoryRequirements: public Encodable { |
| public: |
| VkMemoryRequirements() = default; |
| VkMemoryRequirements(uint64_t Size, uint64_t Alignment, uint32_t MemoryTypeBits) |
| : mSize(Size) |
| , mAlignment(Alignment) |
| , mMemoryTypeBits(MemoryTypeBits) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mSize); |
| e->Uint64(this->mAlignment); |
| e->Uint32(this->mMemoryTypeBits); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mSize; |
| uint64_t mAlignment; |
| uint32_t mMemoryTypeBits; |
| }; |
| |
| class VkMemoryRequirements__S: public Encodable { |
| public: |
| VkMemoryRequirements__S() = default; |
| VkMemoryRequirements__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineCache__CP: public Encodable { |
| public: |
| VkPipelineCache__CP() = default; |
| VkPipelineCache__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkMergePipelineCaches: public Encodable { |
| public: |
| VkMergePipelineCaches() = default; |
| VkMergePipelineCaches(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DstCache, uint32_t SrcCacheCount, VkPipelineCache__CP PSrcCaches, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mDstCache(DstCache) |
| , mSrcCacheCount(SrcCacheCount) |
| , mPSrcCaches(PSrcCaches) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mDstCache; |
| uint32_t mSrcCacheCount; |
| VkPipelineCache__CP mPSrcCaches; |
| uint32_t mResult; |
| }; |
| |
| class VkMirSurfaceCreateInfoKHR__S: public Encodable { |
| public: |
| VkMirSurfaceCreateInfoKHR__S() = default; |
| VkMirSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkMirSurfaceCreateInfoKHR__P: public Encodable { |
| public: |
| VkMirSurfaceCreateInfoKHR__P() = default; |
| VkMirSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class buffer_handle_t: public Encodable { |
| public: |
| buffer_handle_t() = default; |
| buffer_handle_t(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPhysicalDeviceFeatures__S: public Encodable { |
| public: |
| VkPhysicalDeviceFeatures__S() = default; |
| VkPhysicalDeviceFeatures__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPhysicalDeviceLimits: public Encodable { |
| public: |
| VkPhysicalDeviceLimits() = default; |
| VkPhysicalDeviceLimits(uint32_t MaxImageDimension1D, uint32_t MaxImageDimension2D, uint32_t MaxImageDimension3D, uint32_t MaxImageDimensionCube, uint32_t MaxImageArrayLayers, uint32_t MaxTexelBufferElements, uint32_t MaxUniformBufferRange, uint32_t MaxStorageBufferRange, uint32_t MaxPushConstantsSize, uint32_t MaxMemoryAllocationCount, uint32_t MaxSamplerAllocationCount, uint64_t BufferImageGranularity, uint64_t SparseAddressSpaceSize, uint32_t MaxBoundDescriptorSets, uint32_t MaxPerStageDescriptorSamplers, uint32_t MaxPerStageDescriptorUniformBuffers, uint32_t MaxPerStageDescriptorStorageBuffers, uint32_t MaxPerStageDescriptorSampledImages, uint32_t MaxPerStageDescriptorStorageImages, uint32_t MaxPerStageDescriptorInputAttachments, uint32_t MaxPerStageResources, uint32_t MaxDescriptorSetSamplers, uint32_t MaxDescriptorSetUniformBuffers, uint32_t MaxDescriptorSetUniformBuffersDynamic, uint32_t MaxDescriptorSetStorageBuffers, uint32_t MaxDescriptorSetStorageBuffersDynamic, uint32_t MaxDescriptorSetSampledImages, uint32_t MaxDescriptorSetStorageImages, uint32_t MaxDescriptorSetInputAttachments, uint32_t MaxVertexInputAttributes, uint32_t MaxVertexInputBindings, uint32_t MaxVertexInputAttributeOffset, uint32_t MaxVertexInputBindingStride, uint32_t MaxVertexOutputComponents, uint32_t MaxTessellationGenerationLevel, uint32_t MaxTessellationPatchSize, uint32_t MaxTessellationControlPerVertexInputComponents, uint32_t MaxTessellationControlPerVertexOutputComponents, uint32_t MaxTessellationControlPerPatchOutputComponents, uint32_t MaxTessellationControlTotalOutputComponents, uint32_t MaxTessellationEvaluationInputComponents, uint32_t MaxTessellationEvaluationOutputComponents, uint32_t MaxGeometryShaderInvocations, uint32_t MaxGeometryInputComponents, uint32_t MaxGeometryOutputComponents, uint32_t MaxGeometryOutputVertices, uint32_t MaxGeometryTotalOutputComponents, uint32_t MaxFragmentInputComponents, uint32_t MaxFragmentOutputAttachments, uint32_t MaxFragmentDualSrcAttachments, uint32_t MaxFragmentCombinedOutputResources, uint32_t MaxComputeSharedMemorySize, U32__3__A MaxComputeWorkGroupCount, uint32_t MaxComputeWorkGroupInvocations, U32__3__A MaxComputeWorkGroupSize, uint32_t SubPixelPrecisionBits, uint32_t SubTexelPrecisionBits, uint32_t MipmapPrecisionBits, uint32_t MaxDrawIndexedIndexValue, uint32_t MaxDrawIndirectCount, float MaxSamplerLodBias, float MaxSamplerAnisotropy, uint32_t MaxViewports, U32__2__A MaxViewportDimensions, F32__2__A ViewportBoundsRange, uint32_t ViewportSubPixelBits, uint64_t MinMemoryMapAlignment, uint64_t MinTexelBufferOffsetAlignment, uint64_t MinUniformBufferOffsetAlignment, uint64_t MinStorageBufferOffsetAlignment, int32_t MinTexelOffset, uint32_t MaxTexelOffset, int32_t MinTexelGatherOffset, uint32_t MaxTexelGatherOffset, float MinInterpolationOffset, float MaxInterpolationOffset, uint32_t SubPixelInterpolationOffsetBits, uint32_t MaxFramebufferWidth, uint32_t MaxFramebufferHeight, uint32_t MaxFramebufferLayers, uint32_t FramebufferColorSampleCounts, uint32_t FramebufferDepthSampleCounts, uint32_t FramebufferStencilSampleCounts, uint32_t FramebufferNoAttachmentSampleCounts, uint32_t MaxColorAttachments, uint32_t SampledImageColorSampleCounts, uint32_t SampledImageIntegerSampleCounts, uint32_t SampledImageDepthSampleCounts, uint32_t SampledImageStencilSampleCounts, uint32_t StorageImageSampleCounts, uint32_t MaxSampleMaskWords, uint32_t TimestampComputeAndGraphics, float TimestampPeriod, uint32_t MaxClipDistances, uint32_t MaxCullDistances, uint32_t MaxCombinedClipAndCullDistances, uint32_t DiscreteQueuePriorities, F32__2__A PointSizeRange, F32__2__A LineWidthRange, float PointSizeGranularity, float LineWidthGranularity, uint32_t StrictLines, uint32_t StandardSampleLocations, uint64_t OptimalBufferCopyOffsetAlignment, uint64_t OptimalBufferCopyRowPitchAlignment, uint64_t NonCoherentAtomSize) |
| : mMaxImageDimension1D(MaxImageDimension1D) |
| , mMaxImageDimension2D(MaxImageDimension2D) |
| , mMaxImageDimension3D(MaxImageDimension3D) |
| , mMaxImageDimensionCube(MaxImageDimensionCube) |
| , mMaxImageArrayLayers(MaxImageArrayLayers) |
| , mMaxTexelBufferElements(MaxTexelBufferElements) |
| , mMaxUniformBufferRange(MaxUniformBufferRange) |
| , mMaxStorageBufferRange(MaxStorageBufferRange) |
| , mMaxPushConstantsSize(MaxPushConstantsSize) |
| , mMaxMemoryAllocationCount(MaxMemoryAllocationCount) |
| , mMaxSamplerAllocationCount(MaxSamplerAllocationCount) |
| , mBufferImageGranularity(BufferImageGranularity) |
| , mSparseAddressSpaceSize(SparseAddressSpaceSize) |
| , mMaxBoundDescriptorSets(MaxBoundDescriptorSets) |
| , mMaxPerStageDescriptorSamplers(MaxPerStageDescriptorSamplers) |
| , mMaxPerStageDescriptorUniformBuffers(MaxPerStageDescriptorUniformBuffers) |
| , mMaxPerStageDescriptorStorageBuffers(MaxPerStageDescriptorStorageBuffers) |
| , mMaxPerStageDescriptorSampledImages(MaxPerStageDescriptorSampledImages) |
| , mMaxPerStageDescriptorStorageImages(MaxPerStageDescriptorStorageImages) |
| , mMaxPerStageDescriptorInputAttachments(MaxPerStageDescriptorInputAttachments) |
| , mMaxPerStageResources(MaxPerStageResources) |
| , mMaxDescriptorSetSamplers(MaxDescriptorSetSamplers) |
| , mMaxDescriptorSetUniformBuffers(MaxDescriptorSetUniformBuffers) |
| , mMaxDescriptorSetUniformBuffersDynamic(MaxDescriptorSetUniformBuffersDynamic) |
| , mMaxDescriptorSetStorageBuffers(MaxDescriptorSetStorageBuffers) |
| , mMaxDescriptorSetStorageBuffersDynamic(MaxDescriptorSetStorageBuffersDynamic) |
| , mMaxDescriptorSetSampledImages(MaxDescriptorSetSampledImages) |
| , mMaxDescriptorSetStorageImages(MaxDescriptorSetStorageImages) |
| , mMaxDescriptorSetInputAttachments(MaxDescriptorSetInputAttachments) |
| , mMaxVertexInputAttributes(MaxVertexInputAttributes) |
| , mMaxVertexInputBindings(MaxVertexInputBindings) |
| , mMaxVertexInputAttributeOffset(MaxVertexInputAttributeOffset) |
| , mMaxVertexInputBindingStride(MaxVertexInputBindingStride) |
| , mMaxVertexOutputComponents(MaxVertexOutputComponents) |
| , mMaxTessellationGenerationLevel(MaxTessellationGenerationLevel) |
| , mMaxTessellationPatchSize(MaxTessellationPatchSize) |
| , mMaxTessellationControlPerVertexInputComponents(MaxTessellationControlPerVertexInputComponents) |
| , mMaxTessellationControlPerVertexOutputComponents(MaxTessellationControlPerVertexOutputComponents) |
| , mMaxTessellationControlPerPatchOutputComponents(MaxTessellationControlPerPatchOutputComponents) |
| , mMaxTessellationControlTotalOutputComponents(MaxTessellationControlTotalOutputComponents) |
| , mMaxTessellationEvaluationInputComponents(MaxTessellationEvaluationInputComponents) |
| , mMaxTessellationEvaluationOutputComponents(MaxTessellationEvaluationOutputComponents) |
| , mMaxGeometryShaderInvocations(MaxGeometryShaderInvocations) |
| , mMaxGeometryInputComponents(MaxGeometryInputComponents) |
| , mMaxGeometryOutputComponents(MaxGeometryOutputComponents) |
| , mMaxGeometryOutputVertices(MaxGeometryOutputVertices) |
| , mMaxGeometryTotalOutputComponents(MaxGeometryTotalOutputComponents) |
| , mMaxFragmentInputComponents(MaxFragmentInputComponents) |
| , mMaxFragmentOutputAttachments(MaxFragmentOutputAttachments) |
| , mMaxFragmentDualSrcAttachments(MaxFragmentDualSrcAttachments) |
| , mMaxFragmentCombinedOutputResources(MaxFragmentCombinedOutputResources) |
| , mMaxComputeSharedMemorySize(MaxComputeSharedMemorySize) |
| , mMaxComputeWorkGroupCount(MaxComputeWorkGroupCount) |
| , mMaxComputeWorkGroupInvocations(MaxComputeWorkGroupInvocations) |
| , mMaxComputeWorkGroupSize(MaxComputeWorkGroupSize) |
| , mSubPixelPrecisionBits(SubPixelPrecisionBits) |
| , mSubTexelPrecisionBits(SubTexelPrecisionBits) |
| , mMipmapPrecisionBits(MipmapPrecisionBits) |
| , mMaxDrawIndexedIndexValue(MaxDrawIndexedIndexValue) |
| , mMaxDrawIndirectCount(MaxDrawIndirectCount) |
| , mMaxSamplerLodBias(MaxSamplerLodBias) |
| , mMaxSamplerAnisotropy(MaxSamplerAnisotropy) |
| , mMaxViewports(MaxViewports) |
| , mMaxViewportDimensions(MaxViewportDimensions) |
| , mViewportBoundsRange(ViewportBoundsRange) |
| , mViewportSubPixelBits(ViewportSubPixelBits) |
| , mMinMemoryMapAlignment(MinMemoryMapAlignment) |
| , mMinTexelBufferOffsetAlignment(MinTexelBufferOffsetAlignment) |
| , mMinUniformBufferOffsetAlignment(MinUniformBufferOffsetAlignment) |
| , mMinStorageBufferOffsetAlignment(MinStorageBufferOffsetAlignment) |
| , mMinTexelOffset(MinTexelOffset) |
| , mMaxTexelOffset(MaxTexelOffset) |
| , mMinTexelGatherOffset(MinTexelGatherOffset) |
| , mMaxTexelGatherOffset(MaxTexelGatherOffset) |
| , mMinInterpolationOffset(MinInterpolationOffset) |
| , mMaxInterpolationOffset(MaxInterpolationOffset) |
| , mSubPixelInterpolationOffsetBits(SubPixelInterpolationOffsetBits) |
| , mMaxFramebufferWidth(MaxFramebufferWidth) |
| , mMaxFramebufferHeight(MaxFramebufferHeight) |
| , mMaxFramebufferLayers(MaxFramebufferLayers) |
| , mFramebufferColorSampleCounts(FramebufferColorSampleCounts) |
| , mFramebufferDepthSampleCounts(FramebufferDepthSampleCounts) |
| , mFramebufferStencilSampleCounts(FramebufferStencilSampleCounts) |
| , mFramebufferNoAttachmentSampleCounts(FramebufferNoAttachmentSampleCounts) |
| , mMaxColorAttachments(MaxColorAttachments) |
| , mSampledImageColorSampleCounts(SampledImageColorSampleCounts) |
| , mSampledImageIntegerSampleCounts(SampledImageIntegerSampleCounts) |
| , mSampledImageDepthSampleCounts(SampledImageDepthSampleCounts) |
| , mSampledImageStencilSampleCounts(SampledImageStencilSampleCounts) |
| , mStorageImageSampleCounts(StorageImageSampleCounts) |
| , mMaxSampleMaskWords(MaxSampleMaskWords) |
| , mTimestampComputeAndGraphics(TimestampComputeAndGraphics) |
| , mTimestampPeriod(TimestampPeriod) |
| , mMaxClipDistances(MaxClipDistances) |
| , mMaxCullDistances(MaxCullDistances) |
| , mMaxCombinedClipAndCullDistances(MaxCombinedClipAndCullDistances) |
| , mDiscreteQueuePriorities(DiscreteQueuePriorities) |
| , mPointSizeRange(PointSizeRange) |
| , mLineWidthRange(LineWidthRange) |
| , mPointSizeGranularity(PointSizeGranularity) |
| , mLineWidthGranularity(LineWidthGranularity) |
| , mStrictLines(StrictLines) |
| , mStandardSampleLocations(StandardSampleLocations) |
| , mOptimalBufferCopyOffsetAlignment(OptimalBufferCopyOffsetAlignment) |
| , mOptimalBufferCopyRowPitchAlignment(OptimalBufferCopyRowPitchAlignment) |
| , mNonCoherentAtomSize(NonCoherentAtomSize) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mMaxImageDimension1D; |
| uint32_t mMaxImageDimension2D; |
| uint32_t mMaxImageDimension3D; |
| uint32_t mMaxImageDimensionCube; |
| uint32_t mMaxImageArrayLayers; |
| uint32_t mMaxTexelBufferElements; |
| uint32_t mMaxUniformBufferRange; |
| uint32_t mMaxStorageBufferRange; |
| uint32_t mMaxPushConstantsSize; |
| uint32_t mMaxMemoryAllocationCount; |
| uint32_t mMaxSamplerAllocationCount; |
| uint64_t mBufferImageGranularity; |
| uint64_t mSparseAddressSpaceSize; |
| uint32_t mMaxBoundDescriptorSets; |
| uint32_t mMaxPerStageDescriptorSamplers; |
| uint32_t mMaxPerStageDescriptorUniformBuffers; |
| uint32_t mMaxPerStageDescriptorStorageBuffers; |
| uint32_t mMaxPerStageDescriptorSampledImages; |
| uint32_t mMaxPerStageDescriptorStorageImages; |
| uint32_t mMaxPerStageDescriptorInputAttachments; |
| uint32_t mMaxPerStageResources; |
| uint32_t mMaxDescriptorSetSamplers; |
| uint32_t mMaxDescriptorSetUniformBuffers; |
| uint32_t mMaxDescriptorSetUniformBuffersDynamic; |
| uint32_t mMaxDescriptorSetStorageBuffers; |
| uint32_t mMaxDescriptorSetStorageBuffersDynamic; |
| uint32_t mMaxDescriptorSetSampledImages; |
| uint32_t mMaxDescriptorSetStorageImages; |
| uint32_t mMaxDescriptorSetInputAttachments; |
| uint32_t mMaxVertexInputAttributes; |
| uint32_t mMaxVertexInputBindings; |
| uint32_t mMaxVertexInputAttributeOffset; |
| uint32_t mMaxVertexInputBindingStride; |
| uint32_t mMaxVertexOutputComponents; |
| uint32_t mMaxTessellationGenerationLevel; |
| uint32_t mMaxTessellationPatchSize; |
| uint32_t mMaxTessellationControlPerVertexInputComponents; |
| uint32_t mMaxTessellationControlPerVertexOutputComponents; |
| uint32_t mMaxTessellationControlPerPatchOutputComponents; |
| uint32_t mMaxTessellationControlTotalOutputComponents; |
| uint32_t mMaxTessellationEvaluationInputComponents; |
| uint32_t mMaxTessellationEvaluationOutputComponents; |
| uint32_t mMaxGeometryShaderInvocations; |
| uint32_t mMaxGeometryInputComponents; |
| uint32_t mMaxGeometryOutputComponents; |
| uint32_t mMaxGeometryOutputVertices; |
| uint32_t mMaxGeometryTotalOutputComponents; |
| uint32_t mMaxFragmentInputComponents; |
| uint32_t mMaxFragmentOutputAttachments; |
| uint32_t mMaxFragmentDualSrcAttachments; |
| uint32_t mMaxFragmentCombinedOutputResources; |
| uint32_t mMaxComputeSharedMemorySize; |
| U32__3__A mMaxComputeWorkGroupCount; |
| uint32_t mMaxComputeWorkGroupInvocations; |
| U32__3__A mMaxComputeWorkGroupSize; |
| uint32_t mSubPixelPrecisionBits; |
| uint32_t mSubTexelPrecisionBits; |
| uint32_t mMipmapPrecisionBits; |
| uint32_t mMaxDrawIndexedIndexValue; |
| uint32_t mMaxDrawIndirectCount; |
| float mMaxSamplerLodBias; |
| float mMaxSamplerAnisotropy; |
| uint32_t mMaxViewports; |
| U32__2__A mMaxViewportDimensions; |
| F32__2__A mViewportBoundsRange; |
| uint32_t mViewportSubPixelBits; |
| uint64_t mMinMemoryMapAlignment; |
| uint64_t mMinTexelBufferOffsetAlignment; |
| uint64_t mMinUniformBufferOffsetAlignment; |
| uint64_t mMinStorageBufferOffsetAlignment; |
| int32_t mMinTexelOffset; |
| uint32_t mMaxTexelOffset; |
| int32_t mMinTexelGatherOffset; |
| uint32_t mMaxTexelGatherOffset; |
| float mMinInterpolationOffset; |
| float mMaxInterpolationOffset; |
| uint32_t mSubPixelInterpolationOffsetBits; |
| uint32_t mMaxFramebufferWidth; |
| uint32_t mMaxFramebufferHeight; |
| uint32_t mMaxFramebufferLayers; |
| uint32_t mFramebufferColorSampleCounts; |
| uint32_t mFramebufferDepthSampleCounts; |
| uint32_t mFramebufferStencilSampleCounts; |
| uint32_t mFramebufferNoAttachmentSampleCounts; |
| uint32_t mMaxColorAttachments; |
| uint32_t mSampledImageColorSampleCounts; |
| uint32_t mSampledImageIntegerSampleCounts; |
| uint32_t mSampledImageDepthSampleCounts; |
| uint32_t mSampledImageStencilSampleCounts; |
| uint32_t mStorageImageSampleCounts; |
| uint32_t mMaxSampleMaskWords; |
| uint32_t mTimestampComputeAndGraphics; |
| float mTimestampPeriod; |
| uint32_t mMaxClipDistances; |
| uint32_t mMaxCullDistances; |
| uint32_t mMaxCombinedClipAndCullDistances; |
| uint32_t mDiscreteQueuePriorities; |
| F32__2__A mPointSizeRange; |
| F32__2__A mLineWidthRange; |
| float mPointSizeGranularity; |
| float mLineWidthGranularity; |
| uint32_t mStrictLines; |
| uint32_t mStandardSampleLocations; |
| uint64_t mOptimalBufferCopyOffsetAlignment; |
| uint64_t mOptimalBufferCopyRowPitchAlignment; |
| uint64_t mNonCoherentAtomSize; |
| }; |
| |
| class VkPhysicalDeviceMemoryProperties__S: public Encodable { |
| public: |
| VkPhysicalDeviceMemoryProperties__S() = default; |
| VkPhysicalDeviceMemoryProperties__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPhysicalDeviceSparseProperties: public Encodable { |
| public: |
| VkPhysicalDeviceSparseProperties() = default; |
| VkPhysicalDeviceSparseProperties(uint32_t ResidencyStandard2DBlockShape, uint32_t ResidencyStandard2DMultisampleBlockShape, uint32_t ResidencyStandard3DBlockShape, uint32_t ResidencyAlignedMipSize, uint32_t ResidencyNonResidentStrict) |
| : mResidencyStandard2DBlockShape(ResidencyStandard2DBlockShape) |
| , mResidencyStandard2DMultisampleBlockShape(ResidencyStandard2DMultisampleBlockShape) |
| , mResidencyStandard3DBlockShape(ResidencyStandard3DBlockShape) |
| , mResidencyAlignedMipSize(ResidencyAlignedMipSize) |
| , mResidencyNonResidentStrict(ResidencyNonResidentStrict) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mResidencyStandard2DBlockShape; |
| uint32_t mResidencyStandard2DMultisampleBlockShape; |
| uint32_t mResidencyStandard3DBlockShape; |
| uint32_t mResidencyAlignedMipSize; |
| uint32_t mResidencyNonResidentStrict; |
| }; |
| |
| class VkPhysicalDeviceProperties: public Encodable { |
| public: |
| VkPhysicalDeviceProperties() = default; |
| VkPhysicalDeviceProperties(uint32_t ApiVersion, uint32_t DriverVersion, uint32_t VendorID, uint32_t DeviceID, uint32_t DeviceType, Char__256__A DeviceName, U8__16__A PipelineCacheUUID, VkPhysicalDeviceLimits Limits, VkPhysicalDeviceSparseProperties SparseProperties) |
| : mApiVersion(ApiVersion) |
| , mDriverVersion(DriverVersion) |
| , mVendorID(VendorID) |
| , mDeviceID(DeviceID) |
| , mDeviceType(DeviceType) |
| , mDeviceName(DeviceName) |
| , mPipelineCacheUUID(PipelineCacheUUID) |
| , mLimits(Limits) |
| , mSparseProperties(SparseProperties) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mApiVersion; |
| uint32_t mDriverVersion; |
| uint32_t mVendorID; |
| uint32_t mDeviceID; |
| uint32_t mDeviceType; |
| Char__256__A mDeviceName; |
| U8__16__A mPipelineCacheUUID; |
| VkPhysicalDeviceLimits mLimits; |
| VkPhysicalDeviceSparseProperties mSparseProperties; |
| }; |
| |
| class VkPhysicalDeviceProperties__S: public Encodable { |
| public: |
| VkPhysicalDeviceProperties__S() = default; |
| VkPhysicalDeviceProperties__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPhysicalDevice__S: public Encodable { |
| public: |
| VkPhysicalDevice__S() = default; |
| VkPhysicalDevice__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineCacheCreateInfo: public Encodable { |
| public: |
| VkPipelineCacheCreateInfo() = default; |
| VkPipelineCacheCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t InitialDataSize, Void__CP PInitialData) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mInitialDataSize(InitialDataSize) |
| , mPInitialData(PInitialData) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint64_t mInitialDataSize; |
| Void__CP mPInitialData; |
| }; |
| |
| class VkPipelineCacheCreateInfo__S: public Encodable { |
| public: |
| VkPipelineCacheCreateInfo__S() = default; |
| VkPipelineCacheCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineCacheCreateInfo__P: public Encodable { |
| public: |
| VkPipelineCacheCreateInfo__P() = default; |
| VkPipelineCacheCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineCache__S: public Encodable { |
| public: |
| VkPipelineCache__S() = default; |
| VkPipelineCache__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineColorBlendAttachmentState: public Encodable { |
| public: |
| VkPipelineColorBlendAttachmentState() = default; |
| VkPipelineColorBlendAttachmentState(uint32_t BlendEnable, uint32_t SrcColorBlendFactor, uint32_t DstColorBlendFactor, uint32_t ColorBlendOp, uint32_t SrcAlphaBlendFactor, uint32_t DstAlphaBlendFactor, uint32_t AlphaBlendOp, uint32_t ColorWriteMask) |
| : mBlendEnable(BlendEnable) |
| , mSrcColorBlendFactor(SrcColorBlendFactor) |
| , mDstColorBlendFactor(DstColorBlendFactor) |
| , mColorBlendOp(ColorBlendOp) |
| , mSrcAlphaBlendFactor(SrcAlphaBlendFactor) |
| , mDstAlphaBlendFactor(DstAlphaBlendFactor) |
| , mAlphaBlendOp(AlphaBlendOp) |
| , mColorWriteMask(ColorWriteMask) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mBlendEnable; |
| uint32_t mSrcColorBlendFactor; |
| uint32_t mDstColorBlendFactor; |
| uint32_t mColorBlendOp; |
| uint32_t mSrcAlphaBlendFactor; |
| uint32_t mDstAlphaBlendFactor; |
| uint32_t mAlphaBlendOp; |
| uint32_t mColorWriteMask; |
| }; |
| |
| class VkPipelineColorBlendAttachmentState__S: public Encodable { |
| public: |
| VkPipelineColorBlendAttachmentState__S() = default; |
| VkPipelineColorBlendAttachmentState__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineColorBlendAttachmentState__P: public Encodable { |
| public: |
| VkPipelineColorBlendAttachmentState__P() = default; |
| VkPipelineColorBlendAttachmentState__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineColorBlendAttachmentState__CP: public Encodable { |
| public: |
| VkPipelineColorBlendAttachmentState__CP() = default; |
| VkPipelineColorBlendAttachmentState__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineColorBlendStateCreateInfo: public Encodable { |
| public: |
| VkPipelineColorBlendStateCreateInfo() = default; |
| VkPipelineColorBlendStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t LogicOpEnable, uint32_t LogicOp, uint32_t AttachmentCount, VkPipelineColorBlendAttachmentState__CP PAttachments, F32__4__A BlendConstants) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mLogicOpEnable(LogicOpEnable) |
| , mLogicOp(LogicOp) |
| , mAttachmentCount(AttachmentCount) |
| , mPAttachments(PAttachments) |
| , mBlendConstants(BlendConstants) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mLogicOpEnable; |
| uint32_t mLogicOp; |
| uint32_t mAttachmentCount; |
| VkPipelineColorBlendAttachmentState__CP mPAttachments; |
| F32__4__A mBlendConstants; |
| }; |
| |
| class VkPipelineColorBlendStateCreateInfo__S: public Encodable { |
| public: |
| VkPipelineColorBlendStateCreateInfo__S() = default; |
| VkPipelineColorBlendStateCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineColorBlendStateCreateInfo__P: public Encodable { |
| public: |
| VkPipelineColorBlendStateCreateInfo__P() = default; |
| VkPipelineColorBlendStateCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkStencilOpState: public Encodable { |
| public: |
| VkStencilOpState() = default; |
| VkStencilOpState(uint32_t FailOp, uint32_t PassOp, uint32_t DepthFailOp, uint32_t CompareOp, uint32_t CompareMask, uint32_t WriteMask, uint32_t Reference) |
| : mFailOp(FailOp) |
| , mPassOp(PassOp) |
| , mDepthFailOp(DepthFailOp) |
| , mCompareOp(CompareOp) |
| , mCompareMask(CompareMask) |
| , mWriteMask(WriteMask) |
| , mReference(Reference) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mFailOp; |
| uint32_t mPassOp; |
| uint32_t mDepthFailOp; |
| uint32_t mCompareOp; |
| uint32_t mCompareMask; |
| uint32_t mWriteMask; |
| uint32_t mReference; |
| }; |
| |
| class VkPipelineDepthStencilStateCreateInfo: public Encodable { |
| public: |
| VkPipelineDepthStencilStateCreateInfo() = default; |
| VkPipelineDepthStencilStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t DepthTestEnable, uint32_t DepthWriteEnable, uint32_t DepthCompareOp, uint32_t DepthBoundsTestEnable, uint32_t StencilTestEnable, VkStencilOpState Front, VkStencilOpState Back, float MinDepthBounds, float MaxDepthBounds) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mDepthTestEnable(DepthTestEnable) |
| , mDepthWriteEnable(DepthWriteEnable) |
| , mDepthCompareOp(DepthCompareOp) |
| , mDepthBoundsTestEnable(DepthBoundsTestEnable) |
| , mStencilTestEnable(StencilTestEnable) |
| , mFront(Front) |
| , mBack(Back) |
| , mMinDepthBounds(MinDepthBounds) |
| , mMaxDepthBounds(MaxDepthBounds) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mDepthTestEnable; |
| uint32_t mDepthWriteEnable; |
| uint32_t mDepthCompareOp; |
| uint32_t mDepthBoundsTestEnable; |
| uint32_t mStencilTestEnable; |
| VkStencilOpState mFront; |
| VkStencilOpState mBack; |
| float mMinDepthBounds; |
| float mMaxDepthBounds; |
| }; |
| |
| class VkPipelineDepthStencilStateCreateInfo__S: public Encodable { |
| public: |
| VkPipelineDepthStencilStateCreateInfo__S() = default; |
| VkPipelineDepthStencilStateCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineDepthStencilStateCreateInfo__P: public Encodable { |
| public: |
| VkPipelineDepthStencilStateCreateInfo__P() = default; |
| VkPipelineDepthStencilStateCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineDynamicStateCreateInfo: public Encodable { |
| public: |
| VkPipelineDynamicStateCreateInfo() = default; |
| VkPipelineDynamicStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t DynamicStateCount, VkDynamicState__CP PDynamicStates) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mDynamicStateCount(DynamicStateCount) |
| , mPDynamicStates(PDynamicStates) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mDynamicStateCount; |
| VkDynamicState__CP mPDynamicStates; |
| }; |
| |
| class VkPipelineDynamicStateCreateInfo__S: public Encodable { |
| public: |
| VkPipelineDynamicStateCreateInfo__S() = default; |
| VkPipelineDynamicStateCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineDynamicStateCreateInfo__P: public Encodable { |
| public: |
| VkPipelineDynamicStateCreateInfo__P() = default; |
| VkPipelineDynamicStateCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineInputAssemblyStateCreateInfo: public Encodable { |
| public: |
| VkPipelineInputAssemblyStateCreateInfo() = default; |
| VkPipelineInputAssemblyStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t Topology, uint32_t PrimitiveRestartEnable) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mTopology(Topology) |
| , mPrimitiveRestartEnable(PrimitiveRestartEnable) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mTopology; |
| uint32_t mPrimitiveRestartEnable; |
| }; |
| |
| class VkPipelineInputAssemblyStateCreateInfo__S: public Encodable { |
| public: |
| VkPipelineInputAssemblyStateCreateInfo__S() = default; |
| VkPipelineInputAssemblyStateCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineInputAssemblyStateCreateInfo__P: public Encodable { |
| public: |
| VkPipelineInputAssemblyStateCreateInfo__P() = default; |
| VkPipelineInputAssemblyStateCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPushConstantRange__CP: public Encodable { |
| public: |
| VkPushConstantRange__CP() = default; |
| VkPushConstantRange__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineLayoutCreateInfo: public Encodable { |
| public: |
| VkPipelineLayoutCreateInfo() = default; |
| VkPipelineLayoutCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t SetLayoutCount, VkDescriptorSetLayout__CP PSetLayouts, uint32_t PushConstantRangeCount, VkPushConstantRange__CP PPushConstantRanges) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mSetLayoutCount(SetLayoutCount) |
| , mPSetLayouts(PSetLayouts) |
| , mPushConstantRangeCount(PushConstantRangeCount) |
| , mPPushConstantRanges(PPushConstantRanges) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mSetLayoutCount; |
| VkDescriptorSetLayout__CP mPSetLayouts; |
| uint32_t mPushConstantRangeCount; |
| VkPushConstantRange__CP mPPushConstantRanges; |
| }; |
| |
| class VkPipelineLayoutCreateInfo__S: public Encodable { |
| public: |
| VkPipelineLayoutCreateInfo__S() = default; |
| VkPipelineLayoutCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineLayoutCreateInfo__P: public Encodable { |
| public: |
| VkPipelineLayoutCreateInfo__P() = default; |
| VkPipelineLayoutCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineLayout__S: public Encodable { |
| public: |
| VkPipelineLayout__S() = default; |
| VkPipelineLayout__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSampleMask__CP: public Encodable { |
| public: |
| VkSampleMask__CP() = default; |
| VkSampleMask__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineMultisampleStateCreateInfo: public Encodable { |
| public: |
| VkPipelineMultisampleStateCreateInfo() = default; |
| VkPipelineMultisampleStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t RasterizationSamples, uint32_t SampleShadingEnable, float MinSampleShading, VkSampleMask__CP PSampleMask, uint32_t AlphaToCoverageEnable, uint32_t AlphaToOneEnable) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mRasterizationSamples(RasterizationSamples) |
| , mSampleShadingEnable(SampleShadingEnable) |
| , mMinSampleShading(MinSampleShading) |
| , mPSampleMask(PSampleMask) |
| , mAlphaToCoverageEnable(AlphaToCoverageEnable) |
| , mAlphaToOneEnable(AlphaToOneEnable) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mRasterizationSamples; |
| uint32_t mSampleShadingEnable; |
| float mMinSampleShading; |
| VkSampleMask__CP mPSampleMask; |
| uint32_t mAlphaToCoverageEnable; |
| uint32_t mAlphaToOneEnable; |
| }; |
| |
| class VkPipelineMultisampleStateCreateInfo__S: public Encodable { |
| public: |
| VkPipelineMultisampleStateCreateInfo__S() = default; |
| VkPipelineMultisampleStateCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineMultisampleStateCreateInfo__P: public Encodable { |
| public: |
| VkPipelineMultisampleStateCreateInfo__P() = default; |
| VkPipelineMultisampleStateCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineRasterizationStateCreateInfo: public Encodable { |
| public: |
| VkPipelineRasterizationStateCreateInfo() = default; |
| VkPipelineRasterizationStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t DepthClampEnable, uint32_t RasterizerDiscardEnable, uint32_t PolygonMode, uint32_t CullMode, uint32_t FrontFace, uint32_t DepthBiasEnable, float DepthBiasConstantFactor, float DepthBiasClamp, float DepthBiasSlopeFactor, float LineWidth) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mDepthClampEnable(DepthClampEnable) |
| , mRasterizerDiscardEnable(RasterizerDiscardEnable) |
| , mPolygonMode(PolygonMode) |
| , mCullMode(CullMode) |
| , mFrontFace(FrontFace) |
| , mDepthBiasEnable(DepthBiasEnable) |
| , mDepthBiasConstantFactor(DepthBiasConstantFactor) |
| , mDepthBiasClamp(DepthBiasClamp) |
| , mDepthBiasSlopeFactor(DepthBiasSlopeFactor) |
| , mLineWidth(LineWidth) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mDepthClampEnable; |
| uint32_t mRasterizerDiscardEnable; |
| uint32_t mPolygonMode; |
| uint32_t mCullMode; |
| uint32_t mFrontFace; |
| uint32_t mDepthBiasEnable; |
| float mDepthBiasConstantFactor; |
| float mDepthBiasClamp; |
| float mDepthBiasSlopeFactor; |
| float mLineWidth; |
| }; |
| |
| class VkPipelineRasterizationStateCreateInfo__S: public Encodable { |
| public: |
| VkPipelineRasterizationStateCreateInfo__S() = default; |
| VkPipelineRasterizationStateCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineRasterizationStateCreateInfo__P: public Encodable { |
| public: |
| VkPipelineRasterizationStateCreateInfo__P() = default; |
| VkPipelineRasterizationStateCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineShaderStageCreateInfo__S: public Encodable { |
| public: |
| VkPipelineShaderStageCreateInfo__S() = default; |
| VkPipelineShaderStageCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineShaderStageCreateInfo__P: public Encodable { |
| public: |
| VkPipelineShaderStageCreateInfo__P() = default; |
| VkPipelineShaderStageCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineStageFlags__S: public Encodable { |
| public: |
| VkPipelineStageFlags__S() = default; |
| VkPipelineStageFlags__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineStageFlags__P: public Encodable { |
| public: |
| VkPipelineStageFlags__P() = default; |
| VkPipelineStageFlags__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineStageFlags__CP: public Encodable { |
| public: |
| VkPipelineStageFlags__CP() = default; |
| VkPipelineStageFlags__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineTessellationStateCreateInfo: public Encodable { |
| public: |
| VkPipelineTessellationStateCreateInfo() = default; |
| VkPipelineTessellationStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t PatchControlPoints) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mPatchControlPoints(PatchControlPoints) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mPatchControlPoints; |
| }; |
| |
| class VkPipelineTessellationStateCreateInfo__S: public Encodable { |
| public: |
| VkPipelineTessellationStateCreateInfo__S() = default; |
| VkPipelineTessellationStateCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineTessellationStateCreateInfo__P: public Encodable { |
| public: |
| VkPipelineTessellationStateCreateInfo__P() = default; |
| VkPipelineTessellationStateCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkVertexInputBindingDescription__CP: public Encodable { |
| public: |
| VkVertexInputBindingDescription__CP() = default; |
| VkVertexInputBindingDescription__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkVertexInputAttributeDescription__CP: public Encodable { |
| public: |
| VkVertexInputAttributeDescription__CP() = default; |
| VkVertexInputAttributeDescription__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineVertexInputStateCreateInfo: public Encodable { |
| public: |
| VkPipelineVertexInputStateCreateInfo() = default; |
| VkPipelineVertexInputStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t VertexBindingDescriptionCount, VkVertexInputBindingDescription__CP PVertexBindingDescriptions, uint32_t VertexAttributeDescriptionCount, VkVertexInputAttributeDescription__CP PVertexAttributeDescriptions) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mVertexBindingDescriptionCount(VertexBindingDescriptionCount) |
| , mPVertexBindingDescriptions(PVertexBindingDescriptions) |
| , mVertexAttributeDescriptionCount(VertexAttributeDescriptionCount) |
| , mPVertexAttributeDescriptions(PVertexAttributeDescriptions) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mVertexBindingDescriptionCount; |
| VkVertexInputBindingDescription__CP mPVertexBindingDescriptions; |
| uint32_t mVertexAttributeDescriptionCount; |
| VkVertexInputAttributeDescription__CP mPVertexAttributeDescriptions; |
| }; |
| |
| class VkPipelineVertexInputStateCreateInfo__S: public Encodable { |
| public: |
| VkPipelineVertexInputStateCreateInfo__S() = default; |
| VkPipelineVertexInputStateCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineVertexInputStateCreateInfo__P: public Encodable { |
| public: |
| VkPipelineVertexInputStateCreateInfo__P() = default; |
| VkPipelineVertexInputStateCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipelineViewportStateCreateInfo: public Encodable { |
| public: |
| VkPipelineViewportStateCreateInfo() = default; |
| VkPipelineViewportStateCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t ViewportCount, VkViewport__CP PViewports, uint32_t ScissorCount, VkRect2D__CP PScissors) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mViewportCount(ViewportCount) |
| , mPViewports(PViewports) |
| , mScissorCount(ScissorCount) |
| , mPScissors(PScissors) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mViewportCount; |
| VkViewport__CP mPViewports; |
| uint32_t mScissorCount; |
| VkRect2D__CP mPScissors; |
| }; |
| |
| class VkPipelineViewportStateCreateInfo__S: public Encodable { |
| public: |
| VkPipelineViewportStateCreateInfo__S() = default; |
| VkPipelineViewportStateCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPipelineViewportStateCreateInfo__P: public Encodable { |
| public: |
| VkPipelineViewportStateCreateInfo__P() = default; |
| VkPipelineViewportStateCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPipeline__S: public Encodable { |
| public: |
| VkPipeline__S() = default; |
| VkPipeline__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSwapchainKHR__CP: public Encodable { |
| public: |
| VkSwapchainKHR__CP() = default; |
| VkSwapchainKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkResult__P: public Encodable { |
| public: |
| VkResult__P() = default; |
| VkResult__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPresentInfoKHR: public Encodable { |
| public: |
| VkPresentInfoKHR() = default; |
| VkPresentInfoKHR(uint32_t SType, Void__CP PNext, uint32_t WaitSemaphoreCount, VkSemaphore__CP PWaitSemaphores, uint32_t SwapchainCount, VkSwapchainKHR__CP PSwapchains, U32__CP PImageIndices, VkResult__P PResults) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mWaitSemaphoreCount(WaitSemaphoreCount) |
| , mPWaitSemaphores(PWaitSemaphores) |
| , mSwapchainCount(SwapchainCount) |
| , mPSwapchains(PSwapchains) |
| , mPImageIndices(PImageIndices) |
| , mPResults(PResults) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mWaitSemaphoreCount; |
| VkSemaphore__CP mPWaitSemaphores; |
| uint32_t mSwapchainCount; |
| VkSwapchainKHR__CP mPSwapchains; |
| U32__CP mPImageIndices; |
| VkResult__P mPResults; |
| }; |
| |
| class VkPresentInfoKHR__S: public Encodable { |
| public: |
| VkPresentInfoKHR__S() = default; |
| VkPresentInfoKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPresentInfoKHR__P: public Encodable { |
| public: |
| VkPresentInfoKHR__P() = default; |
| VkPresentInfoKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPresentInfoKHR__CP: public Encodable { |
| public: |
| VkPresentInfoKHR__CP() = default; |
| VkPresentInfoKHR__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkPresentModeKHR__S: public Encodable { |
| public: |
| VkPresentModeKHR__S() = default; |
| VkPresentModeKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPushConstantRange: public Encodable { |
| public: |
| VkPushConstantRange() = default; |
| VkPushConstantRange(uint32_t StageFlags, uint32_t Offset, uint32_t Size) |
| : mStageFlags(StageFlags) |
| , mOffset(Offset) |
| , mSize(Size) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mStageFlags); |
| e->Uint32(this->mOffset); |
| e->Uint32(this->mSize); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mStageFlags; |
| uint32_t mOffset; |
| uint32_t mSize; |
| }; |
| |
| class VkPushConstantRange__S: public Encodable { |
| public: |
| VkPushConstantRange__S() = default; |
| VkPushConstantRange__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkPushConstantRange__P: public Encodable { |
| public: |
| VkPushConstantRange__P() = default; |
| VkPushConstantRange__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkQueryPoolCreateInfo: public Encodable { |
| public: |
| VkQueryPoolCreateInfo() = default; |
| VkQueryPoolCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t QueryType, uint32_t QueryCount, uint32_t PipelineStatistics) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mQueryType(QueryType) |
| , mQueryCount(QueryCount) |
| , mPipelineStatistics(PipelineStatistics) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mQueryType; |
| uint32_t mQueryCount; |
| uint32_t mPipelineStatistics; |
| }; |
| |
| class VkQueryPoolCreateInfo__S: public Encodable { |
| public: |
| VkQueryPoolCreateInfo__S() = default; |
| VkQueryPoolCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkQueryPoolCreateInfo__P: public Encodable { |
| public: |
| VkQueryPoolCreateInfo__P() = default; |
| VkQueryPoolCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkQueryPool__S: public Encodable { |
| public: |
| VkQueryPool__S() = default; |
| VkQueryPool__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkQueueBindSparse: public Encodable { |
| public: |
| VkQueueBindSparse() = default; |
| VkQueueBindSparse(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, uint32_t BindInfoCount, VkBindSparseInfo__CP PBindInfo, uint64_t Fence, uint32_t Result) |
| : mextras(extras) |
| , mQueue(Queue) |
| , mBindInfoCount(BindInfoCount) |
| , mPBindInfo(PBindInfo) |
| , mFence(Fence) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mQueue; |
| uint32_t mBindInfoCount; |
| VkBindSparseInfo__CP mPBindInfo; |
| uint64_t mFence; |
| uint32_t mResult; |
| }; |
| |
| class VkQueueFamilyProperties: public Encodable { |
| public: |
| VkQueueFamilyProperties() = default; |
| VkQueueFamilyProperties(uint32_t QueueFlags, uint32_t QueueCount, uint32_t TimestampValidBits, VkExtent3D MinImageTransferGranularity) |
| : mQueueFlags(QueueFlags) |
| , mQueueCount(QueueCount) |
| , mTimestampValidBits(TimestampValidBits) |
| , mMinImageTransferGranularity(MinImageTransferGranularity) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mQueueFlags; |
| uint32_t mQueueCount; |
| uint32_t mTimestampValidBits; |
| VkExtent3D mMinImageTransferGranularity; |
| }; |
| |
| class VkQueueFamilyProperties__S: public Encodable { |
| public: |
| VkQueueFamilyProperties__S() = default; |
| VkQueueFamilyProperties__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkQueuePresentKHR: public Encodable { |
| public: |
| VkQueuePresentKHR() = default; |
| VkQueuePresentKHR(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, VkPresentInfoKHR__CP PPresentInfo, uint32_t Result) |
| : mextras(extras) |
| , mQueue(Queue) |
| , mPPresentInfo(PPresentInfo) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mQueue; |
| VkPresentInfoKHR__CP mPPresentInfo; |
| uint32_t mResult; |
| }; |
| |
| class VkQueueSignalReleaseImageANDROID: public Encodable { |
| public: |
| VkQueueSignalReleaseImageANDROID() = default; |
| VkQueueSignalReleaseImageANDROID(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, uint32_t WaitSemaphoreCount, VkSemaphore__CP PWaitSemaphores, uint64_t Image, Int__P PNativeFenceFd, uint32_t Result) |
| : mextras(extras) |
| , mQueue(Queue) |
| , mWaitSemaphoreCount(WaitSemaphoreCount) |
| , mPWaitSemaphores(PWaitSemaphores) |
| , mImage(Image) |
| , mPNativeFenceFd(PNativeFenceFd) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mQueue; |
| uint32_t mWaitSemaphoreCount; |
| VkSemaphore__CP mPWaitSemaphores; |
| uint64_t mImage; |
| Int__P mPNativeFenceFd; |
| uint32_t mResult; |
| }; |
| |
| class VkSubmitInfo__CP: public Encodable { |
| public: |
| VkSubmitInfo__CP() = default; |
| VkSubmitInfo__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkQueueSubmit: public Encodable { |
| public: |
| VkQueueSubmit() = default; |
| VkQueueSubmit(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, uint32_t SubmitCount, VkSubmitInfo__CP PSubmits, uint64_t Fence, uint32_t Result) |
| : mextras(extras) |
| , mQueue(Queue) |
| , mSubmitCount(SubmitCount) |
| , mPSubmits(PSubmits) |
| , mFence(Fence) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mQueue; |
| uint32_t mSubmitCount; |
| VkSubmitInfo__CP mPSubmits; |
| uint64_t mFence; |
| uint32_t mResult; |
| }; |
| |
| class VkQueueWaitIdle: public Encodable { |
| public: |
| VkQueueWaitIdle() = default; |
| VkQueueWaitIdle(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Queue, uint32_t Result) |
| : mextras(extras) |
| , mQueue(Queue) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mQueue); |
| e->Uint32(this->mResult); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mQueue; |
| uint32_t mResult; |
| }; |
| |
| class VkQueue__S: public Encodable { |
| public: |
| VkQueue__S() = default; |
| VkQueue__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkRect2D__S: public Encodable { |
| public: |
| VkRect2D__S() = default; |
| VkRect2D__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkRect2D__P: public Encodable { |
| public: |
| VkRect2D__P() = default; |
| VkRect2D__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkRenderPassBeginInfo: public Encodable { |
| public: |
| VkRenderPassBeginInfo() = default; |
| VkRenderPassBeginInfo(uint32_t SType, Void__CP PNext, uint64_t RenderPass, uint64_t Framebuffer, VkRect2D RenderArea, uint32_t ClearValueCount, VkClearValue__CP PClearValues) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mRenderPass(RenderPass) |
| , mFramebuffer(Framebuffer) |
| , mRenderArea(RenderArea) |
| , mClearValueCount(ClearValueCount) |
| , mPClearValues(PClearValues) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint64_t mRenderPass; |
| uint64_t mFramebuffer; |
| VkRect2D mRenderArea; |
| uint32_t mClearValueCount; |
| VkClearValue__CP mPClearValues; |
| }; |
| |
| class VkRenderPassBeginInfo__S: public Encodable { |
| public: |
| VkRenderPassBeginInfo__S() = default; |
| VkRenderPassBeginInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkRenderPassBeginInfo__P: public Encodable { |
| public: |
| VkRenderPassBeginInfo__P() = default; |
| VkRenderPassBeginInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSubpassDescription__CP: public Encodable { |
| public: |
| VkSubpassDescription__CP() = default; |
| VkSubpassDescription__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSubpassDependency__CP: public Encodable { |
| public: |
| VkSubpassDependency__CP() = default; |
| VkSubpassDependency__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkRenderPassCreateInfo: public Encodable { |
| public: |
| VkRenderPassCreateInfo() = default; |
| VkRenderPassCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t AttachmentCount, VkAttachmentDescription__CP PAttachments, uint32_t SubpassCount, VkSubpassDescription__CP PSubpasses, uint32_t DependencyCount, VkSubpassDependency__CP PDependencies) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mAttachmentCount(AttachmentCount) |
| , mPAttachments(PAttachments) |
| , mSubpassCount(SubpassCount) |
| , mPSubpasses(PSubpasses) |
| , mDependencyCount(DependencyCount) |
| , mPDependencies(PDependencies) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mAttachmentCount; |
| VkAttachmentDescription__CP mPAttachments; |
| uint32_t mSubpassCount; |
| VkSubpassDescription__CP mPSubpasses; |
| uint32_t mDependencyCount; |
| VkSubpassDependency__CP mPDependencies; |
| }; |
| |
| class VkRenderPassCreateInfo__S: public Encodable { |
| public: |
| VkRenderPassCreateInfo__S() = default; |
| VkRenderPassCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkRenderPassCreateInfo__P: public Encodable { |
| public: |
| VkRenderPassCreateInfo__P() = default; |
| VkRenderPassCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkRenderPass__S: public Encodable { |
| public: |
| VkRenderPass__S() = default; |
| VkRenderPass__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkResetCommandBuffer: public Encodable { |
| public: |
| VkResetCommandBuffer() = default; |
| VkResetCommandBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint64_t CommandBuffer, uint32_t Flags, uint32_t Result) |
| : mextras(extras) |
| , mCommandBuffer(CommandBuffer) |
| , mFlags(Flags) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mCommandBuffer; |
| uint32_t mFlags; |
| uint32_t mResult; |
| }; |
| |
| class VkResetCommandPool: public Encodable { |
| public: |
| VkResetCommandPool() = default; |
| VkResetCommandPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t CommandPool, uint32_t Flags, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mCommandPool(CommandPool) |
| , mFlags(Flags) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mCommandPool; |
| uint32_t mFlags; |
| uint32_t mResult; |
| }; |
| |
| class VkResetDescriptorPool: public Encodable { |
| public: |
| VkResetDescriptorPool() = default; |
| VkResetDescriptorPool(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t DescriptorPool, uint32_t Flags, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mDescriptorPool(DescriptorPool) |
| , mFlags(Flags) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mDescriptorPool; |
| uint32_t mFlags; |
| uint32_t mResult; |
| }; |
| |
| class VkResetEvent: public Encodable { |
| public: |
| VkResetEvent() = default; |
| VkResetEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Event, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mEvent(Event) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mEvent; |
| uint32_t mResult; |
| }; |
| |
| class VkResetFences: public Encodable { |
| public: |
| VkResetFences() = default; |
| VkResetFences(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t FenceCount, VkFence__CP PFences, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mFenceCount(FenceCount) |
| , mPFences(PFences) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mFenceCount; |
| VkFence__CP mPFences; |
| uint32_t mResult; |
| }; |
| |
| class VkResult__S: public Encodable { |
| public: |
| VkResult__S() = default; |
| VkResult__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSampleMask__S: public Encodable { |
| public: |
| VkSampleMask__S() = default; |
| VkSampleMask__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSampleMask__P: public Encodable { |
| public: |
| VkSampleMask__P() = default; |
| VkSampleMask__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSamplerCreateInfo: public Encodable { |
| public: |
| VkSamplerCreateInfo() = default; |
| VkSamplerCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint32_t MagFilter, uint32_t MinFilter, uint32_t MipmapMode, uint32_t AddressModeU, uint32_t AddressModeV, uint32_t AddressModeW, float MipLodBias, uint32_t AnisotropyEnable, float MaxAnisotropy, uint32_t CompareEnable, uint32_t CompareOp, float MinLod, float MaxLod, uint32_t BorderColor, uint32_t UnnormalizedCoordinates) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mMagFilter(MagFilter) |
| , mMinFilter(MinFilter) |
| , mMipmapMode(MipmapMode) |
| , mAddressModeU(AddressModeU) |
| , mAddressModeV(AddressModeV) |
| , mAddressModeW(AddressModeW) |
| , mMipLodBias(MipLodBias) |
| , mAnisotropyEnable(AnisotropyEnable) |
| , mMaxAnisotropy(MaxAnisotropy) |
| , mCompareEnable(CompareEnable) |
| , mCompareOp(CompareOp) |
| , mMinLod(MinLod) |
| , mMaxLod(MaxLod) |
| , mBorderColor(BorderColor) |
| , mUnnormalizedCoordinates(UnnormalizedCoordinates) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint32_t mMagFilter; |
| uint32_t mMinFilter; |
| uint32_t mMipmapMode; |
| uint32_t mAddressModeU; |
| uint32_t mAddressModeV; |
| uint32_t mAddressModeW; |
| float mMipLodBias; |
| uint32_t mAnisotropyEnable; |
| float mMaxAnisotropy; |
| uint32_t mCompareEnable; |
| uint32_t mCompareOp; |
| float mMinLod; |
| float mMaxLod; |
| uint32_t mBorderColor; |
| uint32_t mUnnormalizedCoordinates; |
| }; |
| |
| class VkSamplerCreateInfo__S: public Encodable { |
| public: |
| VkSamplerCreateInfo__S() = default; |
| VkSamplerCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSamplerCreateInfo__P: public Encodable { |
| public: |
| VkSamplerCreateInfo__P() = default; |
| VkSamplerCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSampler__S: public Encodable { |
| public: |
| VkSampler__S() = default; |
| VkSampler__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSemaphoreCreateInfo: public Encodable { |
| public: |
| VkSemaphoreCreateInfo() = default; |
| VkSemaphoreCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mSType); |
| e->Struct(this->mPNext); |
| e->Uint32(this->mFlags); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| }; |
| |
| class VkSemaphoreCreateInfo__S: public Encodable { |
| public: |
| VkSemaphoreCreateInfo__S() = default; |
| VkSemaphoreCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSemaphoreCreateInfo__P: public Encodable { |
| public: |
| VkSemaphoreCreateInfo__P() = default; |
| VkSemaphoreCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSemaphore__S: public Encodable { |
| public: |
| VkSemaphore__S() = default; |
| VkSemaphore__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSetEvent: public Encodable { |
| public: |
| VkSetEvent() = default; |
| VkSetEvent(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Event, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mEvent(Event) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mEvent; |
| uint32_t mResult; |
| }; |
| |
| class VkShaderModuleCreateInfo: public Encodable { |
| public: |
| VkShaderModuleCreateInfo() = default; |
| VkShaderModuleCreateInfo(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t CodeSize, U32__CP PCode) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mCodeSize(CodeSize) |
| , mPCode(PCode) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint64_t mCodeSize; |
| U32__CP mPCode; |
| }; |
| |
| class VkShaderModuleCreateInfo__S: public Encodable { |
| public: |
| VkShaderModuleCreateInfo__S() = default; |
| VkShaderModuleCreateInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkShaderModuleCreateInfo__P: public Encodable { |
| public: |
| VkShaderModuleCreateInfo__P() = default; |
| VkShaderModuleCreateInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkShaderModule__S: public Encodable { |
| public: |
| VkShaderModule__S() = default; |
| VkShaderModule__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSparseMemoryBind__CP: public Encodable { |
| public: |
| VkSparseMemoryBind__CP() = default; |
| VkSparseMemoryBind__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSparseBufferMemoryBindInfo: public Encodable { |
| public: |
| VkSparseBufferMemoryBindInfo() = default; |
| VkSparseBufferMemoryBindInfo(uint64_t Buffer, uint32_t BindCount, VkSparseMemoryBind__CP PBinds) |
| : mBuffer(Buffer) |
| , mBindCount(BindCount) |
| , mPBinds(PBinds) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mBuffer); |
| e->Uint32(this->mBindCount); |
| e->Struct(this->mPBinds); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mBuffer; |
| uint32_t mBindCount; |
| VkSparseMemoryBind__CP mPBinds; |
| }; |
| |
| class VkSparseBufferMemoryBindInfo__S: public Encodable { |
| public: |
| VkSparseBufferMemoryBindInfo__S() = default; |
| VkSparseBufferMemoryBindInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSparseBufferMemoryBindInfo__P: public Encodable { |
| public: |
| VkSparseBufferMemoryBindInfo__P() = default; |
| VkSparseBufferMemoryBindInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSparseImageFormatProperties: public Encodable { |
| public: |
| VkSparseImageFormatProperties() = default; |
| VkSparseImageFormatProperties(uint32_t AspectMask, VkExtent3D ImageGranularity, uint32_t Flags) |
| : mAspectMask(AspectMask) |
| , mImageGranularity(ImageGranularity) |
| , mFlags(Flags) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mAspectMask); |
| e->Struct(this->mImageGranularity); |
| e->Uint32(this->mFlags); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mAspectMask; |
| VkExtent3D mImageGranularity; |
| uint32_t mFlags; |
| }; |
| |
| class VkSparseImageFormatProperties__S: public Encodable { |
| public: |
| VkSparseImageFormatProperties__S() = default; |
| VkSparseImageFormatProperties__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSparseImageMemoryBind: public Encodable { |
| public: |
| VkSparseImageMemoryBind() = default; |
| VkSparseImageMemoryBind(VkImageSubresource Subresource, VkOffset3D Offset, VkExtent3D Extent, uint64_t Memory, uint64_t MemoryOffset, uint32_t Flags) |
| : mSubresource(Subresource) |
| , mOffset(Offset) |
| , mExtent(Extent) |
| , mMemory(Memory) |
| , mMemoryOffset(MemoryOffset) |
| , mFlags(Flags) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkImageSubresource mSubresource; |
| VkOffset3D mOffset; |
| VkExtent3D mExtent; |
| uint64_t mMemory; |
| uint64_t mMemoryOffset; |
| uint32_t mFlags; |
| }; |
| |
| class VkSparseImageMemoryBindInfo: public Encodable { |
| public: |
| VkSparseImageMemoryBindInfo() = default; |
| VkSparseImageMemoryBindInfo(uint64_t Image, uint32_t BindCount, VkSparseMemoryBind__CP PBinds) |
| : mImage(Image) |
| , mBindCount(BindCount) |
| , mPBinds(PBinds) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mImage); |
| e->Uint32(this->mBindCount); |
| e->Struct(this->mPBinds); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mImage; |
| uint32_t mBindCount; |
| VkSparseMemoryBind__CP mPBinds; |
| }; |
| |
| class VkSparseImageMemoryBindInfo__S: public Encodable { |
| public: |
| VkSparseImageMemoryBindInfo__S() = default; |
| VkSparseImageMemoryBindInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSparseImageMemoryBindInfo__P: public Encodable { |
| public: |
| VkSparseImageMemoryBindInfo__P() = default; |
| VkSparseImageMemoryBindInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSparseImageMemoryRequirements: public Encodable { |
| public: |
| VkSparseImageMemoryRequirements() = default; |
| VkSparseImageMemoryRequirements(VkSparseImageFormatProperties FormatProperties, uint32_t ImageMipTailFirstLod, uint64_t ImageMipTailSize, uint64_t ImageMipTailOffset, uint64_t ImageMipTailStride) |
| : mFormatProperties(FormatProperties) |
| , mImageMipTailFirstLod(ImageMipTailFirstLod) |
| , mImageMipTailSize(ImageMipTailSize) |
| , mImageMipTailOffset(ImageMipTailOffset) |
| , mImageMipTailStride(ImageMipTailStride) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| VkSparseImageFormatProperties mFormatProperties; |
| uint32_t mImageMipTailFirstLod; |
| uint64_t mImageMipTailSize; |
| uint64_t mImageMipTailOffset; |
| uint64_t mImageMipTailStride; |
| }; |
| |
| class VkSparseImageMemoryRequirements__S: public Encodable { |
| public: |
| VkSparseImageMemoryRequirements__S() = default; |
| VkSparseImageMemoryRequirements__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSparseImageOpaqueMemoryBindInfo: public Encodable { |
| public: |
| VkSparseImageOpaqueMemoryBindInfo() = default; |
| VkSparseImageOpaqueMemoryBindInfo(uint64_t Image, uint32_t BindCount, VkSparseMemoryBind__CP PBinds) |
| : mImage(Image) |
| , mBindCount(BindCount) |
| , mPBinds(PBinds) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mImage); |
| e->Uint32(this->mBindCount); |
| e->Struct(this->mPBinds); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mImage; |
| uint32_t mBindCount; |
| VkSparseMemoryBind__CP mPBinds; |
| }; |
| |
| class VkSparseImageOpaqueMemoryBindInfo__S: public Encodable { |
| public: |
| VkSparseImageOpaqueMemoryBindInfo__S() = default; |
| VkSparseImageOpaqueMemoryBindInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSparseImageOpaqueMemoryBindInfo__P: public Encodable { |
| public: |
| VkSparseImageOpaqueMemoryBindInfo__P() = default; |
| VkSparseImageOpaqueMemoryBindInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSparseMemoryBind: public Encodable { |
| public: |
| VkSparseMemoryBind() = default; |
| VkSparseMemoryBind(uint64_t ResourceOffset, uint64_t Size, uint64_t Memory, uint64_t MemoryOffset, uint32_t Flags) |
| : mResourceOffset(ResourceOffset) |
| , mSize(Size) |
| , mMemory(Memory) |
| , mMemoryOffset(MemoryOffset) |
| , mFlags(Flags) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mResourceOffset; |
| uint64_t mSize; |
| uint64_t mMemory; |
| uint64_t mMemoryOffset; |
| uint32_t mFlags; |
| }; |
| |
| class VkSparseMemoryBind__S: public Encodable { |
| public: |
| VkSparseMemoryBind__S() = default; |
| VkSparseMemoryBind__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSparseMemoryBind__P: public Encodable { |
| public: |
| VkSparseMemoryBind__P() = default; |
| VkSparseMemoryBind__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSpecializationMapEntry__CP: public Encodable { |
| public: |
| VkSpecializationMapEntry__CP() = default; |
| VkSpecializationMapEntry__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSpecializationInfo: public Encodable { |
| public: |
| VkSpecializationInfo() = default; |
| VkSpecializationInfo(uint32_t MapEntryCount, VkSpecializationMapEntry__CP PMapEntries, uint64_t DataSize, Void__CP PData) |
| : mMapEntryCount(MapEntryCount) |
| , mPMapEntries(PMapEntries) |
| , mDataSize(DataSize) |
| , mPData(PData) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mMapEntryCount; |
| VkSpecializationMapEntry__CP mPMapEntries; |
| uint64_t mDataSize; |
| Void__CP mPData; |
| }; |
| |
| class VkSpecializationInfo__S: public Encodable { |
| public: |
| VkSpecializationInfo__S() = default; |
| VkSpecializationInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSpecializationInfo__P: public Encodable { |
| public: |
| VkSpecializationInfo__P() = default; |
| VkSpecializationInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSpecializationMapEntry: public Encodable { |
| public: |
| VkSpecializationMapEntry() = default; |
| VkSpecializationMapEntry(uint32_t ConstantID, uint32_t Offset, uint64_t Size) |
| : mConstantID(ConstantID) |
| , mOffset(Offset) |
| , mSize(Size) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mConstantID); |
| e->Uint32(this->mOffset); |
| e->Uint64(this->mSize); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mConstantID; |
| uint32_t mOffset; |
| uint64_t mSize; |
| }; |
| |
| class VkSpecializationMapEntry__S: public Encodable { |
| public: |
| VkSpecializationMapEntry__S() = default; |
| VkSpecializationMapEntry__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSpecializationMapEntry__P: public Encodable { |
| public: |
| VkSpecializationMapEntry__P() = default; |
| VkSpecializationMapEntry__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkStructureType__S: public Encodable { |
| public: |
| VkStructureType__S() = default; |
| VkStructureType__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkStructureType__P: public Encodable { |
| public: |
| VkStructureType__P() = default; |
| VkStructureType__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSubmitInfo: public Encodable { |
| public: |
| VkSubmitInfo() = default; |
| VkSubmitInfo(uint32_t SType, Void__CP PNext, uint32_t WaitSemaphoreCount, VkSemaphore__CP PWaitSemaphores, VkPipelineStageFlags__CP PWaitDstStageMask, uint32_t CommandBufferCount, VkCommandBuffer__CP PCommandBuffers, uint32_t SignalSemaphoreCount, VkSemaphore__CP PSignalSemaphores) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mWaitSemaphoreCount(WaitSemaphoreCount) |
| , mPWaitSemaphores(PWaitSemaphores) |
| , mPWaitDstStageMask(PWaitDstStageMask) |
| , mCommandBufferCount(CommandBufferCount) |
| , mPCommandBuffers(PCommandBuffers) |
| , mSignalSemaphoreCount(SignalSemaphoreCount) |
| , mPSignalSemaphores(PSignalSemaphores) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mWaitSemaphoreCount; |
| VkSemaphore__CP mPWaitSemaphores; |
| VkPipelineStageFlags__CP mPWaitDstStageMask; |
| uint32_t mCommandBufferCount; |
| VkCommandBuffer__CP mPCommandBuffers; |
| uint32_t mSignalSemaphoreCount; |
| VkSemaphore__CP mPSignalSemaphores; |
| }; |
| |
| class VkSubmitInfo__S: public Encodable { |
| public: |
| VkSubmitInfo__S() = default; |
| VkSubmitInfo__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSubmitInfo__P: public Encodable { |
| public: |
| VkSubmitInfo__P() = default; |
| VkSubmitInfo__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSubpassDependency: public Encodable { |
| public: |
| VkSubpassDependency() = default; |
| VkSubpassDependency(uint32_t SrcSubpass, uint32_t DstSubpass, uint32_t SrcStageMask, uint32_t DstStageMask, uint32_t SrcAccessMask, uint32_t DstAccessMask, uint32_t DependencyFlags) |
| : mSrcSubpass(SrcSubpass) |
| , mDstSubpass(DstSubpass) |
| , mSrcStageMask(SrcStageMask) |
| , mDstStageMask(DstStageMask) |
| , mSrcAccessMask(SrcAccessMask) |
| , mDstAccessMask(DstAccessMask) |
| , mDependencyFlags(DependencyFlags) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSrcSubpass; |
| uint32_t mDstSubpass; |
| uint32_t mSrcStageMask; |
| uint32_t mDstStageMask; |
| uint32_t mSrcAccessMask; |
| uint32_t mDstAccessMask; |
| uint32_t mDependencyFlags; |
| }; |
| |
| class VkSubpassDependency__S: public Encodable { |
| public: |
| VkSubpassDependency__S() = default; |
| VkSubpassDependency__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSubpassDependency__P: public Encodable { |
| public: |
| VkSubpassDependency__P() = default; |
| VkSubpassDependency__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSubpassDescription: public Encodable { |
| public: |
| VkSubpassDescription() = default; |
| VkSubpassDescription(uint32_t Flags, uint32_t PipelineBindPoint, uint32_t InputAttachmentCount, VkAttachmentReference__CP PInputAttachments, uint32_t ColorAttachmentCount, VkAttachmentReference__CP PColorAttachments, VkAttachmentReference__CP PResolveAttachments, VkAttachmentReference__CP PDepthStencilAttachment, uint32_t PreserveAttachmentCount, U32__CP PPreserveAttachments) |
| : mFlags(Flags) |
| , mPipelineBindPoint(PipelineBindPoint) |
| , mInputAttachmentCount(InputAttachmentCount) |
| , mPInputAttachments(PInputAttachments) |
| , mColorAttachmentCount(ColorAttachmentCount) |
| , mPColorAttachments(PColorAttachments) |
| , mPResolveAttachments(PResolveAttachments) |
| , mPDepthStencilAttachment(PDepthStencilAttachment) |
| , mPreserveAttachmentCount(PreserveAttachmentCount) |
| , mPPreserveAttachments(PPreserveAttachments) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mFlags; |
| uint32_t mPipelineBindPoint; |
| uint32_t mInputAttachmentCount; |
| VkAttachmentReference__CP mPInputAttachments; |
| uint32_t mColorAttachmentCount; |
| VkAttachmentReference__CP mPColorAttachments; |
| VkAttachmentReference__CP mPResolveAttachments; |
| VkAttachmentReference__CP mPDepthStencilAttachment; |
| uint32_t mPreserveAttachmentCount; |
| U32__CP mPPreserveAttachments; |
| }; |
| |
| class VkSubpassDescription__S: public Encodable { |
| public: |
| VkSubpassDescription__S() = default; |
| VkSubpassDescription__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSubpassDescription__P: public Encodable { |
| public: |
| VkSubpassDescription__P() = default; |
| VkSubpassDescription__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSubresourceLayout: public Encodable { |
| public: |
| VkSubresourceLayout() = default; |
| VkSubresourceLayout(uint64_t Offset, uint64_t Size, uint64_t RowPitch, uint64_t ArrayPitch, uint64_t DepthPitch) |
| : mOffset(Offset) |
| , mSize(Size) |
| , mRowPitch(RowPitch) |
| , mArrayPitch(ArrayPitch) |
| , mDepthPitch(DepthPitch) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mOffset; |
| uint64_t mSize; |
| uint64_t mRowPitch; |
| uint64_t mArrayPitch; |
| uint64_t mDepthPitch; |
| }; |
| |
| class VkSubresourceLayout__S: public Encodable { |
| public: |
| VkSubresourceLayout__S() = default; |
| VkSubresourceLayout__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSurfaceCapabilitiesKHR: public Encodable { |
| public: |
| VkSurfaceCapabilitiesKHR() = default; |
| VkSurfaceCapabilitiesKHR(uint32_t MinImageCount, uint32_t MaxImageCount, VkExtent2D CurrentExtent, VkExtent2D MinImageExtent, VkExtent2D MaxImageExtent, uint32_t MaxImageArrayLayers, uint32_t SupportedTransforms, uint32_t CurrentTransform, uint32_t SupportedCompositeAlpha, uint32_t SupportedUsageFlags) |
| : mMinImageCount(MinImageCount) |
| , mMaxImageCount(MaxImageCount) |
| , mCurrentExtent(CurrentExtent) |
| , mMinImageExtent(MinImageExtent) |
| , mMaxImageExtent(MaxImageExtent) |
| , mMaxImageArrayLayers(MaxImageArrayLayers) |
| , mSupportedTransforms(SupportedTransforms) |
| , mCurrentTransform(CurrentTransform) |
| , mSupportedCompositeAlpha(SupportedCompositeAlpha) |
| , mSupportedUsageFlags(SupportedUsageFlags) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mMinImageCount; |
| uint32_t mMaxImageCount; |
| VkExtent2D mCurrentExtent; |
| VkExtent2D mMinImageExtent; |
| VkExtent2D mMaxImageExtent; |
| uint32_t mMaxImageArrayLayers; |
| uint32_t mSupportedTransforms; |
| uint32_t mCurrentTransform; |
| uint32_t mSupportedCompositeAlpha; |
| uint32_t mSupportedUsageFlags; |
| }; |
| |
| class VkSurfaceCapabilitiesKHR__S: public Encodable { |
| public: |
| VkSurfaceCapabilitiesKHR__S() = default; |
| VkSurfaceCapabilitiesKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSurfaceFormatKHR: public Encodable { |
| public: |
| VkSurfaceFormatKHR() = default; |
| VkSurfaceFormatKHR(uint32_t Format, uint32_t ColorSpace) |
| : mFormat(Format) |
| , mColorSpace(ColorSpace) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mFormat); |
| e->Uint32(this->mColorSpace); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mFormat; |
| uint32_t mColorSpace; |
| }; |
| |
| class VkSurfaceFormatKHR__S: public Encodable { |
| public: |
| VkSurfaceFormatKHR__S() = default; |
| VkSurfaceFormatKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSurfaceKHR__S: public Encodable { |
| public: |
| VkSurfaceKHR__S() = default; |
| VkSurfaceKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSwapchainCreateInfoKHR: public Encodable { |
| public: |
| VkSwapchainCreateInfoKHR() = default; |
| VkSwapchainCreateInfoKHR(uint32_t SType, Void__CP PNext, uint32_t Flags, uint64_t Surface, uint32_t MinImageCount, uint32_t ImageFormat, uint32_t ImageColorSpace, VkExtent2D ImageExtent, uint32_t ImageArrayLayers, uint32_t ImageUsage, uint32_t ImageSharingMode, uint32_t QueueFamilyIndexCount, U32__CP PQueueFamilyIndices, uint32_t PreTransform, uint32_t CompositeAlpha, uint32_t PresentMode, uint32_t Clipped, uint64_t OldSwapchain) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mFlags(Flags) |
| , mSurface(Surface) |
| , mMinImageCount(MinImageCount) |
| , mImageFormat(ImageFormat) |
| , mImageColorSpace(ImageColorSpace) |
| , mImageExtent(ImageExtent) |
| , mImageArrayLayers(ImageArrayLayers) |
| , mImageUsage(ImageUsage) |
| , mImageSharingMode(ImageSharingMode) |
| , mQueueFamilyIndexCount(QueueFamilyIndexCount) |
| , mPQueueFamilyIndices(PQueueFamilyIndices) |
| , mPreTransform(PreTransform) |
| , mCompositeAlpha(CompositeAlpha) |
| , mPresentMode(PresentMode) |
| , mClipped(Clipped) |
| , mOldSwapchain(OldSwapchain) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint32_t mFlags; |
| uint64_t mSurface; |
| uint32_t mMinImageCount; |
| uint32_t mImageFormat; |
| uint32_t mImageColorSpace; |
| VkExtent2D mImageExtent; |
| uint32_t mImageArrayLayers; |
| uint32_t mImageUsage; |
| uint32_t mImageSharingMode; |
| uint32_t mQueueFamilyIndexCount; |
| U32__CP mPQueueFamilyIndices; |
| uint32_t mPreTransform; |
| uint32_t mCompositeAlpha; |
| uint32_t mPresentMode; |
| uint32_t mClipped; |
| uint64_t mOldSwapchain; |
| }; |
| |
| class VkSwapchainCreateInfoKHR__S: public Encodable { |
| public: |
| VkSwapchainCreateInfoKHR__S() = default; |
| VkSwapchainCreateInfoKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkSwapchainCreateInfoKHR__P: public Encodable { |
| public: |
| VkSwapchainCreateInfoKHR__P() = default; |
| VkSwapchainCreateInfoKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkSwapchainKHR__S: public Encodable { |
| public: |
| VkSwapchainKHR__S() = default; |
| VkSwapchainKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkUnmapMemory: public Encodable { |
| public: |
| VkUnmapMemory() = default; |
| VkUnmapMemory(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint64_t Memory) |
| : mextras(extras) |
| , mDevice(Device) |
| , mMemory(Memory) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint32(this->mextras.count()); |
| for (auto v : this->mextras) { |
| e->Object(v); |
| } |
| e->Uint64(this->mDevice); |
| e->Uint64(this->mMemory); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint64_t mMemory; |
| }; |
| |
| class VkWriteDescriptorSet__CP: public Encodable { |
| public: |
| VkWriteDescriptorSet__CP() = default; |
| VkWriteDescriptorSet__CP(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkUpdateDescriptorSets: public Encodable { |
| public: |
| VkUpdateDescriptorSets() = default; |
| VkUpdateDescriptorSets(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t DescriptorWriteCount, VkWriteDescriptorSet__CP PDescriptorWrites, uint32_t DescriptorCopyCount, VkCopyDescriptorSet__CP PDescriptorCopies) |
| : mextras(extras) |
| , mDevice(Device) |
| , mDescriptorWriteCount(DescriptorWriteCount) |
| , mPDescriptorWrites(PDescriptorWrites) |
| , mDescriptorCopyCount(DescriptorCopyCount) |
| , mPDescriptorCopies(PDescriptorCopies) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mDescriptorWriteCount; |
| VkWriteDescriptorSet__CP mPDescriptorWrites; |
| uint32_t mDescriptorCopyCount; |
| VkCopyDescriptorSet__CP mPDescriptorCopies; |
| }; |
| |
| class VkVertexInputAttributeDescription__S: public Encodable { |
| public: |
| VkVertexInputAttributeDescription__S() = default; |
| VkVertexInputAttributeDescription__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkVertexInputAttributeDescription__P: public Encodable { |
| public: |
| VkVertexInputAttributeDescription__P() = default; |
| VkVertexInputAttributeDescription__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkVertexInputBindingDescription__S: public Encodable { |
| public: |
| VkVertexInputBindingDescription__S() = default; |
| VkVertexInputBindingDescription__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkVertexInputBindingDescription__P: public Encodable { |
| public: |
| VkVertexInputBindingDescription__P() = default; |
| VkVertexInputBindingDescription__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkViewport: public Encodable { |
| public: |
| VkViewport() = default; |
| VkViewport(float X, float Y, float Width, float Height, float MinDepth, float MaxDepth) |
| : mX(X) |
| , mY(Y) |
| , mWidth(Width) |
| , mHeight(Height) |
| , mMinDepth(MinDepth) |
| , mMaxDepth(MaxDepth) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| float mX; |
| float mY; |
| float mWidth; |
| float mHeight; |
| float mMinDepth; |
| float mMaxDepth; |
| }; |
| |
| class VkViewport__S: public Encodable { |
| public: |
| VkViewport__S() = default; |
| VkViewport__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkViewport__P: public Encodable { |
| public: |
| VkViewport__P() = default; |
| VkViewport__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkWaitForFences: public Encodable { |
| public: |
| VkWaitForFences() = default; |
| VkWaitForFences(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Device, uint32_t FenceCount, VkFence__CP PFences, uint32_t WaitAll, uint64_t Timeout, uint32_t Result) |
| : mextras(extras) |
| , mDevice(Device) |
| , mFenceCount(FenceCount) |
| , mPFences(PFences) |
| , mWaitAll(WaitAll) |
| , mTimeout(Timeout) |
| , mResult(Result) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| gapic::Vector<gapic::Encodable*> mextras; |
| uint64_t mDevice; |
| uint32_t mFenceCount; |
| VkFence__CP mPFences; |
| uint32_t mWaitAll; |
| uint64_t mTimeout; |
| uint32_t mResult; |
| }; |
| |
| class Wl_surface__P: public Encodable { |
| public: |
| Wl_surface__P() = default; |
| Wl_surface__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkWaylandSurfaceCreateInfoKHR__S: public Encodable { |
| public: |
| VkWaylandSurfaceCreateInfoKHR__S() = default; |
| VkWaylandSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkWaylandSurfaceCreateInfoKHR__P: public Encodable { |
| public: |
| VkWaylandSurfaceCreateInfoKHR__P() = default; |
| VkWaylandSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkWriteDescriptorSet: public Encodable { |
| public: |
| VkWriteDescriptorSet() = default; |
| VkWriteDescriptorSet(uint32_t SType, Void__CP PNext, uint64_t DstSet, uint32_t DstBinding, uint32_t DstArrayElement, uint32_t DescriptorCount, uint32_t DescriptorType, VkDescriptorImageInfo__CP PImageInfo, VkDescriptorBufferInfo__CP PBufferInfo, VkBufferView__CP PTexelBufferView) |
| : mSType(SType) |
| , mPNext(PNext) |
| , mDstSet(DstSet) |
| , mDstBinding(DstBinding) |
| , mDstArrayElement(DstArrayElement) |
| , mDescriptorCount(DescriptorCount) |
| , mDescriptorType(DescriptorType) |
| , mPImageInfo(PImageInfo) |
| , mPBufferInfo(PBufferInfo) |
| , mPTexelBufferView(PTexelBufferView) {} |
| virtual void Encode(Encoder* e) const; |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint32_t mSType; |
| Void__CP mPNext; |
| uint64_t mDstSet; |
| uint32_t mDstBinding; |
| uint32_t mDstArrayElement; |
| uint32_t mDescriptorCount; |
| uint32_t mDescriptorType; |
| VkDescriptorImageInfo__CP mPImageInfo; |
| VkDescriptorBufferInfo__CP mPBufferInfo; |
| VkBufferView__CP mPTexelBufferView; |
| }; |
| |
| class VkWriteDescriptorSet__S: public Encodable { |
| public: |
| VkWriteDescriptorSet__S() = default; |
| VkWriteDescriptorSet__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkWriteDescriptorSet__P: public Encodable { |
| public: |
| VkWriteDescriptorSet__P() = default; |
| VkWriteDescriptorSet__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkXcbSurfaceCreateInfoKHR__S: public Encodable { |
| public: |
| VkXcbSurfaceCreateInfoKHR__S() = default; |
| VkXcbSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkXcbSurfaceCreateInfoKHR__P: public Encodable { |
| public: |
| VkXcbSurfaceCreateInfoKHR__P() = default; |
| VkXcbSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class VkXlibSurfaceCreateInfoKHR__S: public Encodable { |
| public: |
| VkXlibSurfaceCreateInfoKHR__S() = default; |
| VkXlibSurfaceCreateInfoKHR__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class VkXlibSurfaceCreateInfoKHR__P: public Encodable { |
| public: |
| VkXlibSurfaceCreateInfoKHR__P() = default; |
| VkXlibSurfaceCreateInfoKHR__P(uint64_t Address, uint32_t Pool) |
| : mAddress(Address) |
| , mPool(Pool) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Uint64(this->mAddress); |
| e->Uint32(this->mPool); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| uint64_t mAddress; |
| uint32_t mPool; |
| }; |
| |
| class Void__S: public Encodable { |
| public: |
| Void__S() = default; |
| Void__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Void__P__S: public Encodable { |
| public: |
| Void__P__S() = default; |
| Void__P__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Wl_display__S: public Encodable { |
| public: |
| Wl_display__S() = default; |
| Wl_display__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Wl_surface__S: public Encodable { |
| public: |
| Wl_surface__S() = default; |
| Wl_surface__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| class Xcb_connection_t__S: public Encodable { |
| public: |
| Xcb_connection_t__S() = default; |
| Xcb_connection_t__S(memory::SliceInfo SliceInfo) |
| : mSliceInfo(SliceInfo) {} |
| virtual void Encode(Encoder* e) const{ |
| e->Struct(this->mSliceInfo); |
| } |
| virtual const schema::Entity* Schema() const { |
| return StaticSchema(); |
| } |
| static const schema::Entity* StaticSchema(); |
| memory::SliceInfo mSliceInfo; |
| }; |
| |
| |
| |
| } // namespace vulkan |
| } // namespace coder |
| } // namespace gapic |
| |
| #endif // GAPIC_CODER_VULKAN_H |