blob: 55257d4360fbf28ad2023c0bd7d889dbf8f00bc2 [file] [log] [blame]
// Copyright 2020 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef vk_Context_hpp
#define vk_Context_hpp
#include "Config.hpp"
#include "Memset.hpp"
#include "Stream.hpp"
#include "System/Types.hpp"
#include "Vulkan/VkDescriptorSet.hpp"
#include "Vulkan/VkFormat.hpp"
#include <vector>
namespace vk {
class Buffer;
class Device;
class ImageView;
class PipelineLayout;
class RenderPass;
struct VertexInputBinding
{
Buffer *buffer = nullptr;
VkDeviceSize offset = 0;
VkDeviceSize size = 0;
VkDeviceSize stride = 0;
};
struct IndexBuffer
{
inline VkIndexType getIndexType() const { return indexType; }
void setIndexBufferBinding(const VertexInputBinding &indexBufferBinding, VkIndexType type);
void getIndexBuffers(VkPrimitiveTopology topology, uint32_t count, uint32_t first, bool indexed, bool hasPrimitiveRestartEnable, std::vector<std::pair<uint32_t, void *>> *indexBuffers) const;
private:
int bytesPerIndex() const;
VertexInputBinding binding;
VkIndexType indexType;
};
struct Attachments
{
ImageView *colorBuffer[sw::MAX_COLOR_BUFFERS] = {};
ImageView *depthBuffer = nullptr;
ImageView *stencilBuffer = nullptr;
VkFormat colorFormat(int index) const;
VkFormat depthFormat() const;
};
struct Inputs
{
void initialize(const VkPipelineVertexInputStateCreateInfo *vertexInputState);
void updateDescriptorSets(const DescriptorSet::Array &dso,
const DescriptorSet::Bindings &ds,
const DescriptorSet::DynamicOffsets &ddo);
inline const DescriptorSet::Array &getDescriptorSetObjects() const { return descriptorSetObjects; }
inline const DescriptorSet::Bindings &getDescriptorSets() const { return descriptorSets; }
inline const DescriptorSet::DynamicOffsets &getDescriptorDynamicOffsets() const { return descriptorDynamicOffsets; }
inline const sw::Stream &getStream(uint32_t i) const { return stream[i]; }
void bindVertexInputs(int firstInstance, bool dynamicInstanceStride);
void setVertexInputBinding(const VertexInputBinding vertexInputBindings[]);
void advanceInstanceAttributes(bool dynamicInstanceStride);
VkDeviceSize getVertexStride(uint32_t i, bool dynamicVertexStride) const;
VkDeviceSize getInstanceStride(uint32_t i, bool dynamicVertexStride) const;
private:
VertexInputBinding vertexInputBindings[MAX_VERTEX_INPUT_BINDINGS] = {};
DescriptorSet::Array descriptorSetObjects = {};
DescriptorSet::Bindings descriptorSets = {};
DescriptorSet::DynamicOffsets descriptorDynamicOffsets = {};
sw::Stream stream[sw::MAX_INTERFACE_COMPONENTS / 4];
};
struct MultisampleState
{
bool sampleShadingEnable = false;
bool alphaToCoverage = false;
int sampleCount = 0;
unsigned int multiSampleMask = 0;
float minSampleShading = 0.0f;
void set(const VkPipelineMultisampleStateCreateInfo *multisampleState);
};
struct BlendState : sw::Memset<BlendState>
{
BlendState()
: Memset(this, 0)
{}
BlendState(bool alphaBlendEnable,
VkBlendFactor sourceBlendFactor,
VkBlendFactor destBlendFactor,
VkBlendOp blendOperation,
VkBlendFactor sourceBlendFactorAlpha,
VkBlendFactor destBlendFactorAlpha,
VkBlendOp blendOperationAlpha)
: Memset(this, 0)
, alphaBlendEnable(alphaBlendEnable)
, sourceBlendFactor(sourceBlendFactor)
, destBlendFactor(destBlendFactor)
, blendOperation(blendOperation)
, sourceBlendFactorAlpha(sourceBlendFactorAlpha)
, destBlendFactorAlpha(destBlendFactorAlpha)
, blendOperationAlpha(blendOperationAlpha)
{}
bool alphaBlendEnable;
VkBlendFactor sourceBlendFactor;
VkBlendFactor destBlendFactor;
VkBlendOp blendOperation;
VkBlendFactor sourceBlendFactorAlpha;
VkBlendFactor destBlendFactorAlpha;
VkBlendOp blendOperationAlpha;
};
struct DynamicState
{
VkViewport viewport = {};
VkRect2D scissor = {};
sw::float4 blendConstants = {};
float depthBiasConstantFactor = 0.0f;
float depthBiasClamp = 0.0f;
float depthBiasSlopeFactor = 0.0f;
float minDepthBounds = 0.0f;
float maxDepthBounds = 0.0f;
float lineWidth = 0.0f;
VkCullModeFlags cullMode = VK_CULL_MODE_NONE;
VkBool32 depthBoundsTestEnable = VK_FALSE;
VkCompareOp depthCompareOp = VK_COMPARE_OP_NEVER;
VkBool32 depthTestEnable = VK_FALSE;
VkBool32 depthWriteEnable = VK_FALSE;
VkFrontFace frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
VkPrimitiveTopology primitiveTopology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
uint32_t scissorCount = 0;
VkRect2D scissors[vk::MAX_VIEWPORTS] = {};
VkStencilFaceFlags faceMask = (VkStencilFaceFlags)0;
VkStencilOpState frontStencil = {};
VkStencilOpState backStencil = {};
VkBool32 stencilTestEnable = VK_FALSE;
uint32_t viewportCount = 0;
VkRect2D viewports[vk::MAX_VIEWPORTS] = {};
VkBool32 rasterizerDiscardEnable = VK_FALSE;
VkBool32 depthBiasEnable = VK_FALSE;
VkBool32 primitiveRestartEnable = VK_FALSE;
};
struct VertexInputInterfaceDynamicStateFlags
{
bool dynamicPrimitiveRestartEnable : 1;
bool dynamicPrimitiveTopology : 1;
bool dynamicVertexInputBindingStride : 1;
};
struct PreRasterizationDynamicStateFlags
{
bool dynamicLineWidth : 1;
bool dynamicDepthBias : 1;
bool dynamicDepthBiasEnable : 1;
bool dynamicCullMode : 1;
bool dynamicFrontFace : 1;
bool dynamicViewport : 1;
bool dynamicScissor : 1;
bool dynamicViewportWithCount : 1;
bool dynamicScissorWithCount : 1;
bool dynamicRasterizerDiscardEnable : 1;
};
struct FragmentDynamicStateFlags
{
bool dynamicDepthTestEnable : 1;
bool dynamicDepthWriteEnable : 1;
bool dynamicDepthBoundsTestEnable : 1;
bool dynamicDepthBounds : 1;
bool dynamicDepthCompareOp : 1;
bool dynamicStencilTestEnable : 1;
bool dynamicStencilOp : 1;
bool dynamicStencilCompareMask : 1;
bool dynamicStencilWriteMask : 1;
bool dynamicStencilReference : 1;
};
struct FragmentOutputInterfaceDynamicStateFlags
{
bool dynamicBlendConstants : 1;
};
struct DynamicStateFlags
{
VertexInputInterfaceDynamicStateFlags vertexInputInterface;
PreRasterizationDynamicStateFlags preRasterization;
FragmentDynamicStateFlags fragment;
FragmentOutputInterfaceDynamicStateFlags fragmentOutputInterface;
};
struct VertexInputInterfaceState
{
void initialize(const VkPipelineVertexInputStateCreateInfo *vertexInputState,
const VkPipelineInputAssemblyStateCreateInfo *inputAssemblyState,
const DynamicStateFlags &allDynamicStateFlags);
void applyState(const DynamicState &dynamicState);
inline VkPrimitiveTopology getTopology() const { return topology; }
inline bool hasPrimitiveRestartEnable() const { return primitiveRestartEnable; }
inline bool hasDynamicVertexStride() const { return dynamicStateFlags.dynamicVertexInputBindingStride; }
inline bool hasDynamicTopology() const { return dynamicStateFlags.dynamicPrimitiveTopology; }
inline bool hasDynamicPrimitiveRestartEnable() const { return dynamicStateFlags.dynamicPrimitiveRestartEnable; }
bool isDrawPoint(bool polygonModeAware, VkPolygonMode polygonMode) const;
bool isDrawLine(bool polygonModeAware, VkPolygonMode polygonMode) const;
bool isDrawTriangle(bool polygonModeAware, VkPolygonMode polygonMode) const;
private:
VertexInputInterfaceDynamicStateFlags dynamicStateFlags = {};
bool primitiveRestartEnable = false;
VkPrimitiveTopology topology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
};
struct PreRasterizationState
{
void initialize(const vk::Device *device,
const PipelineLayout *layout,
const VkPipelineViewportStateCreateInfo *viewportState,
const VkPipelineRasterizationStateCreateInfo *rasterizationState,
const vk::RenderPass *renderPass, uint32_t subpassIndex,
const VkPipelineRenderingCreateInfo *rendering,
const DynamicStateFlags &allDynamicStateFlags);
inline const PipelineLayout *getPipelineLayout() const { return pipelineLayout; }
inline void overridePipelineLayout(const PipelineLayout *linkedLayout) { pipelineLayout = linkedLayout; }
void applyState(const DynamicState &dynamicState);
inline VkCullModeFlags getCullMode() const { return cullMode; }
inline VkFrontFace getFrontFace() const { return frontFace; }
inline VkPolygonMode getPolygonMode() const { return polygonMode; }
inline VkProvokingVertexModeEXT getProvokingVertexMode() const { return provokingVertexMode; }
inline VkLineRasterizationModeEXT getLineRasterizationMode() const { return lineRasterizationMode; }
inline bool hasRasterizerDiscard() const { return rasterizerDiscard; }
inline float getConstantDepthBias() const { return depthBiasEnable ? constantDepthBias : 0; }
inline float getSlopeDepthBias() const { return depthBiasEnable ? slopeDepthBias : 0; }
inline float getDepthBiasClamp() const { return depthBiasEnable ? depthBiasClamp : 0; }
inline bool hasDepthRangeUnrestricted() const { return depthRangeUnrestricted; }
inline bool getDepthClampEnable() const { return depthClampEnable; }
inline bool getDepthClipEnable() const { return depthClipEnable; }
inline bool getDepthClipNegativeOneToOne() const { return depthClipNegativeOneToOne; }
inline float getLineWidth() const { return lineWidth; }
inline const VkRect2D &getScissor() const { return scissor; }
inline const VkViewport &getViewport() const { return viewport; }
private:
const PipelineLayout *pipelineLayout = nullptr;
PreRasterizationDynamicStateFlags dynamicStateFlags = {};
bool rasterizerDiscard = false;
bool depthClampEnable = false;
bool depthClipEnable = false;
bool depthClipNegativeOneToOne = false;
bool depthBiasEnable = false;
bool depthRangeUnrestricted = false;
VkCullModeFlags cullMode = 0;
VkFrontFace frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
VkPolygonMode polygonMode = VK_POLYGON_MODE_FILL;
VkProvokingVertexModeEXT provokingVertexMode = VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT;
VkLineRasterizationModeEXT lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT;
float depthBiasClamp = 0.0f;
float constantDepthBias = 0.0f;
float slopeDepthBias = 0.0f;
float lineWidth = 0.0f;
VkRect2D scissor = {};
VkViewport viewport = {};
};
struct FragmentState
{
void initialize(const PipelineLayout *layout,
const VkPipelineDepthStencilStateCreateInfo *depthStencilState,
const vk::RenderPass *renderPass, uint32_t subpassIndex,
const VkPipelineRenderingCreateInfo *rendering,
const DynamicStateFlags &allDynamicStateFlags);
inline const PipelineLayout *getPipelineLayout() const { return pipelineLayout; }
inline void overridePipelineLayout(const PipelineLayout *linkedLayout) { pipelineLayout = linkedLayout; }
void applyState(const DynamicState &dynamicState);
inline VkStencilOpState getFrontStencil() const { return frontStencil; }
inline VkStencilOpState getBackStencil() const { return backStencil; }
inline float getMinDepthBounds() const { return minDepthBounds; }
inline float getMaxDepthBounds() const { return maxDepthBounds; }
inline VkCompareOp getDepthCompareMode() const { return depthCompareMode; }
bool depthWriteActive(const Attachments &attachments) const;
bool depthTestActive(const Attachments &attachments) const;
bool stencilActive(const Attachments &attachments) const;
bool depthBoundsTestActive(const Attachments &attachments) const;
private:
void setDepthStencilState(const VkPipelineDepthStencilStateCreateInfo *depthStencilState);
const PipelineLayout *pipelineLayout = nullptr;
FragmentDynamicStateFlags dynamicStateFlags = {};
bool depthTestEnable = false;
bool depthWriteEnable = false;
bool depthBoundsTestEnable = false;
bool stencilEnable = false;
float minDepthBounds = 0.0f;
float maxDepthBounds = 0.0f;
VkCompareOp depthCompareMode = VK_COMPARE_OP_NEVER;
VkStencilOpState frontStencil = {};
VkStencilOpState backStencil = {};
// Note: if a pipeline library is created with the fragment state only, and sample shading
// is enabled or a render pass is provided, VkPipelineMultisampleStateCreateInfo must be
// provided. This must identically match with the one provided for the fragment output
// interface library.
//
// Currently, SwiftShader can always use the copy provided and stored in
// FragmentOutputInterfaceState. If a future optimization requires access to this state in
// a pipeline library without fragment output interface, a copy of MultisampleState can be
// placed here and initialized under the above condition.
//
// Ref: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/chap10.html#pipeline-graphics-subsets
};
struct FragmentOutputInterfaceState
{
void initialize(const VkPipelineColorBlendStateCreateInfo *colorBlendState,
const VkPipelineMultisampleStateCreateInfo *multisampleState,
const vk::RenderPass *renderPass, uint32_t subpassIndex,
const VkPipelineRenderingCreateInfo *rendering,
const DynamicStateFlags &allDynamicStateFlags);
void applyState(const DynamicState &dynamicState);
inline unsigned int getMultiSampleMask() const { return multisample.multiSampleMask; }
inline int getSampleCount() const { return multisample.sampleCount; }
inline bool hasSampleShadingEnabled() const { return multisample.sampleShadingEnable; }
inline float getMinSampleShading() const { return multisample.minSampleShading; }
inline bool hasAlphaToCoverage() const { return multisample.alphaToCoverage; }
inline const sw::float4 &getBlendConstants() const { return blendConstants; }
BlendState getBlendState(int index, const Attachments &attachments, bool fragmentContainsKill) const;
int colorWriteActive(int index, const Attachments &attachments) const;
private:
void setColorBlendState(const VkPipelineColorBlendStateCreateInfo *colorBlendState);
VkBlendFactor blendFactor(VkBlendOp blendOperation, VkBlendFactor blendFactor) const;
VkBlendOp blendOperation(VkBlendOp blendOperation, VkBlendFactor sourceBlendFactor, VkBlendFactor destBlendFactor, vk::Format format) const;
bool alphaBlendActive(int index, const Attachments &attachments, bool fragmentContainsKill) const;
bool colorWriteActive(const Attachments &attachments) const;
int colorWriteMask[sw::MAX_COLOR_BUFFERS] = {}; // RGBA
FragmentOutputInterfaceDynamicStateFlags dynamicStateFlags = {};
sw::float4 blendConstants = {};
BlendState blendState[sw::MAX_COLOR_BUFFERS] = {};
MultisampleState multisample;
};
struct GraphicsState
{
GraphicsState(const Device *device, const VkGraphicsPipelineCreateInfo *pCreateInfo, const PipelineLayout *layout);
GraphicsState combineStates(const DynamicState &dynamicState) const;
bool hasVertexInputInterfaceState() const
{
return (validSubset & VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT) != 0;
}
bool hasPreRasterizationState() const
{
return (validSubset & VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT) != 0;
}
bool hasFragmentState() const
{
return (validSubset & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT) != 0;
}
bool hasFragmentOutputInterfaceState() const
{
return (validSubset & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT) != 0;
}
const VertexInputInterfaceState &getVertexInputInterfaceState() const
{
ASSERT(hasVertexInputInterfaceState());
return vertexInputInterfaceState;
}
const PreRasterizationState &getPreRasterizationState() const
{
ASSERT(hasPreRasterizationState());
return preRasterizationState;
}
const FragmentState &getFragmentState() const
{
ASSERT(hasFragmentState());
return fragmentState;
}
const FragmentOutputInterfaceState &getFragmentOutputInterfaceState() const
{
ASSERT(hasFragmentOutputInterfaceState());
return fragmentOutputInterfaceState;
}
private:
// The four subsets of a graphics pipeline as described in the spec. With
// VK_EXT_graphics_pipeline_library, a number of these may be valid.
VertexInputInterfaceState vertexInputInterfaceState;
PreRasterizationState preRasterizationState;
FragmentState fragmentState;
FragmentOutputInterfaceState fragmentOutputInterfaceState;
VkGraphicsPipelineLibraryFlagsEXT validSubset = 0;
};
} // namespace vk
#endif // vk_Context_hpp