private Pipeline CreatePipeline(
PipelineShaderStageCreateInfo[] shaderStages,
VertexInputBindingDescription[] vertexInputBindingDescription,
VertexInputAttributeDescription[] vertexInputAttributeDescription,
PipelineLayout pipelineLayout,
GraphicsPipelineCreateInfo customPipelineProperties = null)
{
return(VContext.Instance.device.CreateGraphicsPipelines
(
null,
new GraphicsPipelineCreateInfo[]
{
new GraphicsPipelineCreateInfo()
{
Stages = shaderStages,
VertexInputState = new PipelineVertexInputStateCreateInfo()
{
VertexBindingDescriptions = vertexInputBindingDescription,
VertexAttributeDescriptions = vertexInputAttributeDescription,
},
InputAssemblyState = customPipelineProperties?.InputAssemblyState ?? VContext.Instance.DefaultGraphicsPipelineCreateInfo.InputAssemblyState,
ViewportState = customPipelineProperties?.ViewportState ?? VContext.Instance.DefaultGraphicsPipelineCreateInfo.ViewportState,
RasterizationState = customPipelineProperties?.RasterizationState ?? VContext.Instance.DefaultGraphicsPipelineCreateInfo.RasterizationState,
DepthStencilState = customPipelineProperties?.DepthStencilState ?? VContext.Instance.DefaultGraphicsPipelineCreateInfo.DepthStencilState,
ColorBlendState = customPipelineProperties?.ColorBlendState ?? VContext.Instance.DefaultGraphicsPipelineCreateInfo.ColorBlendState,
MultisampleState = customPipelineProperties?.MultisampleState ?? VContext.Instance.DefaultGraphicsPipelineCreateInfo.MultisampleState,
RenderPass = VContext.Instance.RenderPass,
Layout = pipelineLayout
}
}
).First());
}
public void CreateComputePipeline()
{
var descriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo(
new DescriptorSetLayoutBinding(0, DescriptorType.StorageBuffer, 1, ShaderStages.Compute),
new DescriptorSetLayoutBinding(1, DescriptorType.StorageBuffer, 1, ShaderStages.Compute));
using (DescriptorSetLayout descriptorSetLayout = Device.CreateDescriptorSetLayout(descriptorSetLayoutCreateInfo))
using (PipelineLayout pipelineLayout = Device.CreatePipelineLayout(new PipelineLayoutCreateInfo(new[] { descriptorSetLayout })))
using (ShaderModule shader = Device.CreateShaderModule(new ShaderModuleCreateInfo(ReadAllBytes("Shader.comp.spv"))))
using (PipelineCache cache = Device.CreatePipelineCache())
{
var pipelineCreateInfo = new ComputePipelineCreateInfo(
new PipelineShaderStageCreateInfo(ShaderStages.Compute, shader, "main"),
pipelineLayout);
using (Device.CreateComputePipelines(new[] { pipelineCreateInfo })[0]) { }
using (Device.CreateComputePipelines(new[] { pipelineCreateInfo }, cache)[0]) { }
using (Device.CreateComputePipelines(new[] { pipelineCreateInfo }, allocator: CustomAllocator)[0]) { }
using (Device.CreateComputePipelines(new[] { pipelineCreateInfo }, cache, CustomAllocator)[0]) { }
using (Device.CreateComputePipeline(pipelineCreateInfo)) { }
using (Device.CreateComputePipeline(pipelineCreateInfo, allocator: CustomAllocator)) { }
using (Device.CreateComputePipeline(pipelineCreateInfo, cache)) { }
using (Device.CreateComputePipeline(pipelineCreateInfo, cache, CustomAllocator)) { }
}
}
public EnvironmentCube(string cubemapPath, PipelineLayout plLayout, Queue staggingQ, RenderPass renderPass, PipelineCache cache = null)
: base(renderPass, cache, "EnvCube pipeline")
{
using (GraphicPipelineConfig cfg = GraphicPipelineConfig.CreateDefault(VkPrimitiveTopology.TriangleList, renderPass.Samples, false)) {
cfg.RenderPass = renderPass;
cfg.Layout = plLayout;
cfg.AddVertexBinding(0, 3 * sizeof(float));
cfg.AddVertexAttributes(0, VkFormat.R32g32b32Sfloat);
cfg.AddShaders(
new ShaderInfo(Dev, VkShaderStageFlags.Vertex, "#EnvironmentPipeline.skybox.vert.spv"),
new ShaderInfo(Dev, VkShaderStageFlags.Fragment, STR_FRAG_PATH)
);
cfg.multisampleState.rasterizationSamples = Samples;
layout = cfg.Layout;
init(cfg);
}
using (CommandPool cmdPool = new CommandPool(staggingQ.Dev, staggingQ.index)) {
vboSkybox = new GPUBuffer <float> (staggingQ, cmdPool, VkBufferUsageFlags.VertexBuffer, box_vertices);
cubemap = KTX.KTX.Load(staggingQ, cmdPool, cubemapPath,
VkImageUsageFlags.Sampled, VkMemoryPropertyFlags.DeviceLocal, true);
cubemap.CreateView(VkImageViewType.Cube, VkImageAspectFlags.Color);
cubemap.CreateSampler(VkSamplerAddressMode.ClampToEdge);
cubemap.SetName("skybox Texture");
cubemap.Descriptor.imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
generateBRDFLUT(staggingQ, cmdPool);
generateCubemaps(staggingQ, cmdPool);
}
}
public override void Initialise(Device device, VulkanBufferManager bufferManager)
{
this.vertexShader = device.CreateVertexModule(shanq => from input in shanq.GetInput <Vertex>()
select new VertexOutput
{
Colour = input.Colour,
Position = new vec4(input.Position, 0, 1)
});
this.fragmentShader = device.CreateFragmentModule(shanq => from input in shanq.GetInput <FragmentInput>()
select new FragmentOutput
{
Colour = new vec4(input.Colour, 1)
});
indexCount = indices.Count();
this.vertexBuffer = bufferManager.CreateBuffer((uint)Marshal.SizeOf <Vertex>() * (uint)vertices.Length, BufferUsageFlags.TransferDestination | BufferUsageFlags.VertexBuffer, MemoryPropertyFlags.DeviceLocal);
this.vertexBuffer.Update(vertices);
this.indexBuffer = bufferManager.CreateBuffer((uint)Marshal.SizeOf <uint>() * (uint)indices.Length, BufferUsageFlags.TransferDestination | BufferUsageFlags.IndexBuffer, MemoryPropertyFlags.DeviceLocal);
this.indexBuffer.Update(indices);
this.pipelineLayout = device.CreatePipelineLayout(null, null);
}
protected Pipeline[] CreatePipelines(PipelineLayout pipelineLayout, RenderPass renderPass, PipelineShaderStageCreateInfo[] shaderStageCreateInfos, VertexData vertexData)
{
var inputAssemblyState = new PipelineInputAssemblyStateCreateInfo(PrimitiveTopology.TriangleList, false);
var vertexInputState = new PipelineVertexInputStateCreateInfo(vertexData.BindingDescriptions, vertexData.AttributeDescriptions);
var rasterizationState = new PipelineRasterizationStateCreateInfo();
//rasterizationState.RasterizerDiscardEnable = true;
rasterizationState.LineWidth = 1;
//PipelineDepthStencilStateCreateInfo
//PipelineDynamicStateCreateInfo
//viewportState
var createInfos = new[]
{
new GraphicsPipelineCreateInfo(shaderStageCreateInfos, vertexInputState, inputAssemblyState, rasterizationState, pipelineLayout, renderPass, 0, 0)
{
ViewportState = new PipelineViewportStateCreateInfo(),
MultisampleState = new PipelineMultisampleStateCreateInfo()
{
RasterizationSamples = SampleCountFlags.SampleCountFlags1
}
}
};
return(device.CreateGraphicsPipelines(null, createInfos));
}
public void GetData()
{
var descriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo(
new DescriptorSetLayoutBinding(0, DescriptorType.StorageBuffer, 1, ShaderStages.Compute),
new DescriptorSetLayoutBinding(1, DescriptorType.StorageBuffer, 1, ShaderStages.Compute));
using (DescriptorSetLayout descriptorSetLayout = Device.CreateDescriptorSetLayout(descriptorSetLayoutCreateInfo))
using (PipelineLayout pipelineLayout = Device.CreatePipelineLayout(new PipelineLayoutCreateInfo(new[] { descriptorSetLayout })))
using (ShaderModule shader = Device.CreateShaderModule(new ShaderModuleCreateInfo(ReadAllBytes("Shader.comp.spv"))))
{
var pipelineCreateInfo = new ComputePipelineCreateInfo(
new PipelineShaderStageCreateInfo(ShaderStages.Compute, shader, "main"),
pipelineLayout);
byte[] cacheBytes;
// Populate cache.
using (PipelineCache cache = Device.CreatePipelineCache())
{
using (Device.CreateComputePipeline(pipelineCreateInfo, cache)) { }
cacheBytes = cache.GetData();
}
Assert.False(cacheBytes.All(x => x == 0));
// Recreate pipeline from cache.
using (PipelineCache cache = Device.CreatePipelineCache(new PipelineCacheCreateInfo(cacheBytes)))
{
using (Device.CreateComputePipeline(pipelineCreateInfo, cache)) { }
}
}
}
public void CmdDraw()
{
var renderPassCreateInfo = new RenderPassCreateInfo(new[] { new SubpassDescription(
new[] { new AttachmentReference(0, ImageLayout.ColorAttachmentOptimal) }) },
new[] { new AttachmentDescription {
Format = Format.B8G8R8A8UNorm, Samples = SampleCounts.Count1
} });
var imageCreateInfo = new ImageCreateInfo
{
Usage = ImageUsages.ColorAttachment,
Format = Format.B8G8R8A8UNorm,
Extent = new Extent3D(2, 2, 1),
ImageType = ImageType.Image2D,
MipLevels = 1,
ArrayLayers = 1,
Samples = SampleCounts.Count1
};
var imageViewCreateInfo = new ImageViewCreateInfo(
Format.B8G8R8A8UNorm,
new ImageSubresourceRange(ImageAspects.Color, 0, 1, 0, 1));
using (ShaderModule vertexShader = Device.CreateShaderModule(new ShaderModuleCreateInfo(ReadAllBytes("Shader.vert.spv"))))
using (ShaderModule fragmentShader = Device.CreateShaderModule(new ShaderModuleCreateInfo(ReadAllBytes("Shader.frag.spv"))))
using (PipelineLayout pipelineLayout = Device.CreatePipelineLayout())
using (RenderPass renderPass = Device.CreateRenderPass(renderPassCreateInfo))
using (Image image = Device.CreateImage(imageCreateInfo))
{
MemoryRequirements imageMemReq = image.GetMemoryRequirements();
int memTypeIndex = PhysicalDeviceMemoryProperties.MemoryTypes.IndexOf(imageMemReq.MemoryTypeBits, MemoryProperties.DeviceLocal);
using (DeviceMemory imageMemory = Device.AllocateMemory(new MemoryAllocateInfo(imageMemReq.Size, memTypeIndex)))
{
image.BindMemory(imageMemory);
using (ImageView imageView = image.CreateView(imageViewCreateInfo))
using (Framebuffer framebuffer = renderPass.CreateFramebuffer(new FramebufferCreateInfo(new[] { imageView }, 2, 2)))
using (Pipeline pipeline = Device.CreateGraphicsPipeline(new GraphicsPipelineCreateInfo(
pipelineLayout,
renderPass,
0,
new[]
{
new PipelineShaderStageCreateInfo(ShaderStages.Vertex, vertexShader, "main"),
new PipelineShaderStageCreateInfo(ShaderStages.Fragment, fragmentShader, "main")
},
new PipelineInputAssemblyStateCreateInfo(),
new PipelineVertexInputStateCreateInfo(),
new PipelineRasterizationStateCreateInfo {
RasterizerDiscardEnable = true, LineWidth = 1.0f
})))
{
CommandBuffer.Begin();
CommandBuffer.CmdBeginRenderPass(new RenderPassBeginInfo(framebuffer, new Rect2D(0, 0, 2, 2)));
CommandBuffer.CmdBindPipeline(PipelineBindPoint.Graphics, pipeline);
CommandBuffer.CmdDraw(3);
CommandBuffer.CmdEndRenderPass();
CommandBuffer.End();
}
}
}
}
protected LayoutsExample() : base()
{
DescriptorSetLayouts = CreateDescriptorSetLayouts();
GraphicsPipelineLayout = CreatePipelineLayout();
//VkApi.descriptors
}
public void Draw(CommandBuffer cmd, PipelineLayout pipelineLayout, Scene scene, bool shadowPass = false)
{
if (scene.Root == null)
{
return;
}
RenderNode(cmd, pipelineLayout, scene.Root, Matrix4x4.Identity, shadowPass);
}
private void TearDown()
{
device.WaitIdle();
renderFinishedSemaphore.Dispose();
renderFinishedSemaphore = null;
imageAvailableSemaphore.Dispose();
imageAvailableSemaphore = null;
vertexBufferMemory.Free();
vertexBufferMemory = null;
vertexBuffer.Dispose();
vertexBuffer = null;
commandPool.Dispose();
commandPool = null;
foreach (var frameBuffer in frameBuffers)
{
frameBuffer.Dispose();
}
frameBuffers = null;
fragShader.Dispose();
fragShader = null;
vertShader.Dispose();
vertShader = null;
pipeline.Dispose();
pipeline = null;
pipelineLayout.Dispose();
pipelineLayout = null;
foreach (var imageView in swapChainImageViews)
{
imageView.Dispose();
}
swapChainImageViews = null;
renderPass.Dispose();
renderPass = null;
swapChain.Dispose();
swapChain = null;
device.Dispose();
device = null;
surface.Dispose();
surface = null;
instance.Dispose();
instance = null;
}
public void DrawAll(CommandBuffer cmd, PipelineLayout pipelineLayout, bool shadowPass = false)
{
foreach (Scene sc in Scenes)
{
foreach (Node node in sc.Root.Children)
{
RenderNode(cmd, pipelineLayout, node, sc.Root.localMatrix, shadowPass);
}
}
}
//private void CreateGraphicsPipeline()
//{
// var bindingDescription = Vertex.GetBindingDescription();
// var attributeDescriptions = Vertex.GetAttributeDescriptions();
// pipelineLayout = device.CreatePipelineLayout(null, null);
// pipeline = device.CreateGraphicsPipeline(
// null,
// new[]
// {
// new PipelineShaderStageCreateInfo
// {
// Stage = ShaderStageFlags.Vertex,
// Module = vertShader,
// Name = "main"
// },
// new PipelineShaderStageCreateInfo
// {
// Stage = ShaderStageFlags.Fragment,
// Module = fragShader,
// Name = "main"
// }
// },
// new PipelineRasterizationStateCreateInfo
// {
// DepthClampEnable = false,
// RasterizerDiscardEnable = false,
// PolygonMode = PolygonMode.Fill,
// LineWidth = 1,
// CullMode = CullModeFlags.Back,
// FrontFace = FrontFace.Clockwise,
// DepthBiasEnable = false
// },
// pipelineLayout,
// renderPass,
// 0,
// null,
// -1,
// vertexInputState: new PipelineVertexInputStateCreateInfo(),
// inputAssemblyState: new PipelineInputAssemblyStateCreateInfo
// {
// PrimitiveRestartEnable = false,
// Topology = PrimitiveTopology.TriangleList
// },
// viewportState: new PipelineViewportStateCreateInfo
// {
// Viewports = new[]
// {
// new Viewport(0f, 0f, swapChainExtent.Width, swapChainExtent.Height, 0, 1)
// },
// Scissors = new[]
// {
// new Rect2D(swapChainExtent)
// }
// },
// colorBlendState: new PipelineColorBlendStateCreateInfo
// {
// Attachments = new[]
// {
// new PipelineColorBlendAttachmentState
// {
// ColorWriteMask = ColorComponentFlags.R | ColorComponentFlags.G | ColorComponentFlags.B | ColorComponentFlags.A,
// BlendEnable = false
// }
// },
// LogicOpEnable = false
// },
// multisampleState: new PipelineMultisampleStateCreateInfo
// {
// SampleShadingEnable = false,
// RasterizationSamples = SampleCountFlags.SampleCount1,
// MinSampleShading = 1
// }
// );
//}
private void CreateGraphicsPipeline()
{
var bindingDescription = Vertex.GetBindingDescription();
var attributeDescriptions = Vertex.GetAttributeDescriptions();
pipelineLayout = device.CreatePipelineLayout(null, null);
pipeline = device.CreateGraphicsPipelines(
null,
new[]
void CreateComputePipeline()
{
/*
* We create a compute pipeline here.
*/
/*
* Create a shader module. A shader module basically just encapsulates some shader code.
*/
// the code in comp.spv was created by running the command:
// glslangValidator.exe -V shader.comp
byte[] code = ReadFile("shaders/shader.comp.spv");
ShaderModuleCreateInfo createInfo = new ShaderModuleCreateInfo()
{
Code = code
};
computeShaderModule = device.CreateShaderModule(createInfo);
/*
* Now let us actually create the compute pipeline.
* A compute pipeline is very simple compared to a graphics pipeline.
* It only consists of a single stage with a compute shader.
* So first we specify the compute shader stage, and it's entry point(main).
*/
PipelineShaderStageCreateInfo shaderStageCreateInfo = new PipelineShaderStageCreateInfo()
{
Stage = ShaderStages.Compute,// VK_SHADER_STAGE_COMPUTE_BIT;
Module = computeShaderModule,
Name = "main"
};
/*
* The pipeline layout allows the pipeline to access descriptor sets.
* So we just specify the descriptor set layout we created earlier.
*/
PipelineLayoutCreateInfo pipelineLayoutCreateInfo = new PipelineLayoutCreateInfo(new[] { descriptorSetLayout });
pipelineLayout = device.CreatePipelineLayout(pipelineLayoutCreateInfo);
ComputePipelineCreateInfo pipelineCreateInfo = new ComputePipelineCreateInfo()
{
Stage = shaderStageCreateInfo,
Layout = pipelineLayout
};
/*
* Now, we finally create the compute pipeline.
*/
ComputePipelineCreateInfo[] ci = { pipelineCreateInfo };
pipelines = device.CreateComputePipelines(ci);
}
private void CreateComputePipeline()
{
var pipelineLayoutCreateInfo = new PipelineLayoutCreateInfo(new[] { _descriptorSetLayout });
_pipelineLayout = Device.Logical.CreatePipelineLayout(pipelineLayoutCreateInfo);
using (ShaderModule shader = Device.Logical.CreateShaderModule(new ShaderModuleCreateInfo(SpirV)))
{
var computePipelineCreateInfo = new ComputePipelineCreateInfo(
new PipelineShaderStageCreateInfo(ShaderStages.Compute, shader, "main"),
_pipelineLayout);
_pipeline = Device.Logical.CreateComputePipeline(computePipelineCreateInfo);
}
}
public void Push(CommandBuffer commandBuffer, PipelineLayout pipelineLayout)
{
//If there is no data added then there is no need to push
if (entries.Count == 0)
{
return;
}
commandBuffer.CmdPushConstants(
pipelineLayout,
stages,
offset: 0,
size: (int)currentSize,
values: memory.Pointer);
}
private Pipeline CreateComputePipeline(
PipelineShaderStageCreateInfo shaderStage,
PipelineLayout pipelineLayout)
{
return(VContext.Instance.device.CreateComputePipelines(
null,
new ComputePipelineCreateInfo[]
{
new ComputePipelineCreateInfo()
{
Layout = pipelineLayout,
Stage = shaderStage,
}
}
).First());
}
public void Build()
{
DescriptorSetLayout?.Dispose();
PipelineLayout?.Dispose();
//UsingSamplers?.DisposeRange();
DescriptorPool?.Dispose();
RenderPass?.Dispose();
Pipeline?.Dispose();
DescriptorSetLayout = VKHelper.CreateDescriptorSetLayout(Graphics, DescriptorItems);
PipelineLayout = VKHelper.CreatePipelineLayout(Graphics, DescriptorSetLayout);
DescriptorPool = VKHelper.CreateDescriptorPool(Graphics, DescriptorItems);
DescriptorSet = VKHelper.CreateDescriptorSet(DescriptorPool, DescriptorSetLayout, DescriptorItems, out UsingSamplers);
RenderPass = VKHelper.CreateRenderPass(Graphics, ClearDepthOnBeginPass);
Pipeline = VKHelper.CreateGraphicsPipeline(Graphics, PipelineLayout, RenderPass, Shaders, DepthTest, DepthWrite, Instancing, InstanceInfoType, BlendMode, PrimitiveType, PrimitiveRenderMode, PrimitiveCullMode, LineWidth, ViewportPos, ViewportSize);
}
protected Effect(
GraphicsDevice graphicsDevice,
string vertexShaderName,
string pixelShaderName,
VertexDescriptor vertexDescriptor,
PipelineLayoutDescription pipelineLayoutDescription)
{
_graphicsDevice = graphicsDevice;
_vertexShader = AddDisposable(new Shader(graphicsDevice.ShaderLibrary, vertexShaderName));
_pixelShader = AddDisposable(new Shader(graphicsDevice.ShaderLibrary, pixelShaderName));
_cachedPipelineStates = new Dictionary <EffectPipelineStateHandle, PipelineState>();
_vertexDescriptor = vertexDescriptor;
_pipelineLayout = AddDisposable(new PipelineLayout(_graphicsDevice, ref pipelineLayoutDescription));
}
public void Draw(CommandBuffer cmd, PipelineLayout pipelineLayout, Buffer instanceBuf, bool shadowPass = false, params InstancedCmd[] instances)
{
cmd.BindVertexBuffer(instanceBuf, 1);
uint firstInstance = 0;
for (int i = 0; i < instances.Length; i++)
{
foreach (Primitive p in Meshes[instances[i].meshIdx].Primitives)
{
if (!shadowPass)
{
cmd.PushConstant(pipelineLayout, VkShaderStageFlags.Fragment, (int)p.material, (uint)Marshal.SizeOf <Matrix4x4>());
}
cmd.DrawIndexed(p.indexCount, instances[i].count, p.indexBase, p.vertexBase, firstInstance);
}
firstInstance += instances[i].count;
}
}
public void CreateResources(
Device logicalDevice,
ShaderInputManager shaderInputManager,
RenderPass renderPass,
ReadOnlySpan <DeviceTexture> targets,
ReadOnlySpan <IShaderInput> globalInputs)
{
//Update the shader inputs
//TODO: Get rid of all the array allocation here
var totalInputs = globalInputs.ToArray().Concat(renderObject.Inputs.ToArray());
if (inputBlock == null)
{
inputBlock = shaderInputManager.Allocate(totalInputs);
}
else
{
inputBlock.Value.Update(totalInputs);
}
//Create a pipeline layout if we don't have one allready
if (pipelineLayout == null)
{
pipelineLayout = logicalDevice.CreatePipelineLayout(new PipelineLayoutCreateInfo(
setLayouts: new [] { inputBlock.Value.Layout },
pushConstantRanges: pushDataContainer.GetRanges()));
}
//Create a pipeline if we don't have one allready
if (pipeline == null)
{
pipeline = PipelineUtils.CreatePipeline(
logicalDevice,
renderPass,
pipelineLayout,
vertModule,
fragModule,
specializationContainer,
depthClamp,
depthBias,
targets,
renderObject);
}
}
private void CreateGraphicsPipeline()
{
this.descriptorSetLayout = this.device.CreateDescriptorSetLayout(new[]
{
new DescriptorSetLayoutBinding
{
Binding = 1,
DescriptorCount = 1,
DescriptorType = DescriptorType.CombinedImageSampler,
StageFlags = ShaderStageFlags.Fragment
}
});
var bindingDescription = Vertex.GetBindingDescription();
var attributeDescriptions = Vertex.GetAttributeDescriptions();
this.pipelineLayout = device.CreatePipelineLayout(this.descriptorSetLayout, null);
this.pipeline = device.CreateGraphicsPipelines(null, new[]
Pipeline[] CreatePipelines(PipelineLayout pipelineLayout, RenderPass renderPass, PipelineShaderStageCreateInfo[] shaderStageCreateInfos, VertexData vertexData)
{
// Some Vulkan commands specify geometric objects to be drawn or computational work to be
// performed, while others specify state controlling how objects are handled by the various
// pipeline stages, or control data transfer between memory organized as images and
// buffers. Commands are effectively sent through a processing 'pipeline', either a
// graphics pipeline or a compute pipeline.
// (In our case, we want a graphics pipeline)
// The first stage of the graphics pipeline (Input Assembler) assembles vertices to form
// geometric primitives such as points, lines, and triangles, based on a requested
// primitive topology.
var inputAssemblyState = new PipelineInputAssemblyStateCreateInfo(PrimitiveTopology.TriangleList, false);
// In the next stage (Vertex Shader) vertices can be transformed, computing positions and
// attributes for each vertex.
var vertexInputState = new PipelineVertexInputStateCreateInfo(vertexData.BindingDescriptions, vertexData.AttributeDescriptions);
// The final resulting primitives are clipped to a clip volume in preparation for the next
// stage, Rasterization. The rasterizer produces a series of framebuffer addresses and
// values using a two-dimensional description of a point, line segment, or triangle. Each
// fragment so produced is fed to the next stage (Fragment Shader) that performs operations
// on individual fragments before they finally alter the framebuffer.
var rasterizationState = new PipelineRasterizationStateCreateInfo();
rasterizationState.LineWidth = 1;
var createInfos = new[]
{
new GraphicsPipelineCreateInfo(shaderStageCreateInfos, vertexInputState, inputAssemblyState, rasterizationState, pipelineLayout, renderPass, 0, 0)
{
ViewportState = new PipelineViewportStateCreateInfo(),
MultisampleState = new PipelineMultisampleStateCreateInfo()
{
RasterizationSamples = SampleCountFlags.SampleCountFlags1
}
}
};
return(device.CreateGraphicsPipelines(null, createInfos));
}
public void CmdBindPipeline()
{
var descriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo(
new DescriptorSetLayoutBinding(0, DescriptorType.StorageBuffer, 1, ShaderStages.Compute),
new DescriptorSetLayoutBinding(1, DescriptorType.StorageBuffer, 1, ShaderStages.Compute));
using (DescriptorSetLayout descriptorSetLayout = Device.CreateDescriptorSetLayout(descriptorSetLayoutCreateInfo))
using (PipelineLayout pipelineLayout = Device.CreatePipelineLayout(new PipelineLayoutCreateInfo(new[] { descriptorSetLayout })))
using (ShaderModule shader = Device.CreateShaderModule(new ShaderModuleCreateInfo(ReadAllBytes("Shader.comp.spv"))))
{
var pipelineCreateInfo = new ComputePipelineCreateInfo(
new PipelineShaderStageCreateInfo(ShaderStages.Compute, shader, "main"),
pipelineLayout);
using (Pipeline pipeline = Device.CreateComputePipeline(pipelineCreateInfo))
{
CommandBuffer.Begin();
CommandBuffer.CmdBindPipeline(PipelineBindPoint.Compute, pipeline);
CommandBuffer.End();
}
}
}
public PipelineLayoutCacheEntry(VulkanGraphicsDevice gd, Device device, uint stages)
{
_gd = gd;
_device = device;
_stages = stages;
DescriptorSetLayouts = PipelineLayoutFactory.Create(gd, device, stages, out var pipelineLayout);
PipelineLayout = pipelineLayout;
_dsCache = new List <Auto <DescriptorSetCollection> > [CommandBufferPool.MaxCommandBuffers][];
for (int i = 0; i < CommandBufferPool.MaxCommandBuffers; i++)
{
_dsCache[i] = new List <Auto <DescriptorSetCollection> > [PipelineBase.DescriptorSetLayouts];
for (int j = 0; j < PipelineBase.DescriptorSetLayouts; j++)
{
_dsCache[i][j] = new List <Auto <DescriptorSetCollection> >();
}
}
_dsCacheCursor = new int[PipelineBase.DescriptorSetLayouts];
}
public void CmdBindDescriptorSet()
{
const int bufferSize = 256;
var layoutCreateInfo = new DescriptorSetLayoutCreateInfo(
new DescriptorSetLayoutBinding(0, DescriptorType.StorageBuffer, 1));
var descriptorPoolCreateInfo = new DescriptorPoolCreateInfo(
1,
new[] { new DescriptorPoolSize(DescriptorType.StorageBuffer, 1) });
using (DescriptorSetLayout descriptorSetLayout = Device.CreateDescriptorSetLayout(layoutCreateInfo))
using (DescriptorPool descriptorPool = Device.CreateDescriptorPool(descriptorPoolCreateInfo))
using (PipelineLayout pipelineLayout = Device.CreatePipelineLayout(new PipelineLayoutCreateInfo(new[] { descriptorSetLayout })))
using (Buffer buffer = Device.CreateBuffer(new BufferCreateInfo(bufferSize, BufferUsages.StorageBuffer)))
using (DeviceMemory memory = Device.AllocateMemory(new MemoryAllocateInfo(bufferSize, 0)))
{
// Required to satisfy the validation layer.
buffer.GetMemoryRequirements();
buffer.BindMemory(memory);
DescriptorSet descriptorSet =
descriptorPool.AllocateSets(new DescriptorSetAllocateInfo(1, descriptorSetLayout))[0];
var descriptorWrite = new WriteDescriptorSet(descriptorSet, 0, 0, 1, DescriptorType.StorageBuffer,
bufferInfo: new[] { new DescriptorBufferInfo(buffer) });
descriptorPool.UpdateSets(new[] { descriptorWrite });
CommandBuffer.Begin();
CommandBuffer.CmdBindDescriptorSet(PipelineBindPoint.Graphics, pipelineLayout, descriptorSet);
CommandBuffer.CmdBindDescriptorSets(PipelineBindPoint.Graphics, pipelineLayout, 0, new[] { descriptorSet });
CommandBuffer.End();
descriptorPool.Reset();
}
}
internal static unsafe extern Result vkCreatePipelineLayout(Device device, PipelineLayoutCreateInfo* createInfo, AllocationCallbacks* allocator, PipelineLayout* pipelineLayout);
private unsafe void CreatePipelineLayout()
{
var binding = new DescriptorSetLayoutBinding
{
Binding = 0,
DescriptorCount = 1,
DescriptorType = DescriptorType.UniformBuffer,
StageFlags = ShaderStageFlags.Vertex
};
var descriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo
{
StructureType = StructureType.DescriptorSetLayoutCreateInfo,
BindingCount = 1,
Bindings = new IntPtr(&binding)
};
descriptorSetLayout = device.CreateDescriptorSetLayout(ref descriptorSetLayoutCreateInfo);
var localDescriptorSetLayout = descriptorSetLayout;
var createInfo = new PipelineLayoutCreateInfo
{
StructureType = StructureType.PipelineLayoutCreateInfo,
SetLayoutCount = 1,
SetLayouts = new IntPtr(&localDescriptorSetLayout)
};
pipelineLayout = device.CreatePipelineLayout(ref createInfo);
var poolSize = new DescriptorPoolSize { DescriptorCount = 2, Type = DescriptorType.UniformBuffer };
var descriptorPoolCreateinfo = new DescriptorPoolCreateInfo
{
StructureType = StructureType.DescriptorPoolCreateInfo,
PoolSizeCount = 1,
PoolSizes = new IntPtr(&poolSize),
MaxSets = 2
};
descriptorPool = device.CreateDescriptorPool(ref descriptorPoolCreateinfo);
var bufferCreateInfo = new BufferCreateInfo
{
StructureType = StructureType.BufferCreateInfo,
Usage = BufferUsageFlags.UniformBuffer,
Size = 64,
};
uniformBuffer = device.CreateBuffer(ref bufferCreateInfo);
MemoryRequirements memoryRequirements;
device.GetBufferMemoryRequirements(uniformBuffer, out memoryRequirements);
var memory = AllocateMemory(MemoryPropertyFlags.HostVisible | MemoryPropertyFlags.HostCoherent, memoryRequirements);
device.BindBufferMemory(uniformBuffer, memory, 0);
var mappedMemory = device.MapMemory(memory, 0, 64, MemoryMapFlags.None);
var data = new[]
{
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f,
};
Utilities.Write(mappedMemory, data, 0, data.Length);
device.UnmapMemory(memory);
}
internal static unsafe extern void vkDestroyPipelineLayout(Device device, PipelineLayout pipelineLayout, AllocationCallbacks* allocator);
public unsafe void PushConstants(PipelineLayout layout, ShaderStageFlags stageFlags, uint offset, uint size, IntPtr values)
{
vkCmdPushConstants(this, layout, stageFlags, offset, size, values);
}
internal static unsafe extern void vkCmdBindDescriptorSets(CommandBuffer commandBuffer, PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint firstSet, uint descriptorSetCount, DescriptorSet* descriptorSets, uint dynamicOffsetCount, uint* dynamicOffsets);
public unsafe void BindDescriptorSets(PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint firstSet, uint descriptorSetCount, DescriptorSet* descriptorSets, uint dynamicOffsetCount, uint* dynamicOffsets)
{
vkCmdBindDescriptorSets(this, pipelineBindPoint, layout, firstSet, descriptorSetCount, descriptorSets, dynamicOffsetCount, dynamicOffsets);
}
internal static unsafe extern void vkCmdPushConstants(CommandBuffer commandBuffer, PipelineLayout layout, ShaderStageFlags stageFlags, uint offset, uint size, IntPtr values);
public unsafe void DestroyPipelineLayout(PipelineLayout pipelineLayout, AllocationCallbacks* allocator = null)
{
vkDestroyPipelineLayout(this, pipelineLayout, allocator);
}
private unsafe void CreatePipelineLayout(PipelineStateDescription pipelineStateDescription)
{
// Remap descriptor set indices to those in the shader. This ordering generated by the ShaderCompiler
var resourceGroups = pipelineStateDescription.EffectBytecode.Reflection.ResourceBindings.Select(x => x.ResourceGroup ?? "Globals").Distinct().ToList();
ResourceGroupCount = resourceGroups.Count;
var layouts = pipelineStateDescription.RootSignature.EffectDescriptorSetReflection.Layouts;
// Get binding indices used by the shader
var destinationBindings = pipelineStateDescription.EffectBytecode.Stages
.SelectMany(x => BinarySerialization.Read<ShaderInputBytecode>(x.Data).ResourceBindings)
.GroupBy(x => x.Key, x => x.Value)
.ToDictionary(x => x.Key, x => x.First());
var maxBindingIndex = destinationBindings.Max(x => x.Value);
var destinationEntries = new DescriptorSetLayoutBuilder.Entry[maxBindingIndex + 1];
DescriptorBindingMapping = new List<DescriptorSetInfo>();
for (int i = 0; i < resourceGroups.Count; i++)
{
var resourceGroupName = resourceGroups[i] == "Globals" ? pipelineStateDescription.RootSignature.EffectDescriptorSetReflection.DefaultSetSlot : resourceGroups[i];
var layoutIndex = resourceGroups[i] == null ? 0 : layouts.FindIndex(x => x.Name == resourceGroupName);
// Check if the resource group is used by the shader
if (layoutIndex == -1)
continue;
var sourceEntries = layouts[layoutIndex].Layout.Entries;
for (int sourceBinding = 0; sourceBinding < sourceEntries.Count; sourceBinding++)
{
var sourceEntry = sourceEntries[sourceBinding];
int destinationBinding;
if (destinationBindings.TryGetValue(sourceEntry.Key.Name, out destinationBinding))
{
destinationEntries[destinationBinding] = sourceEntry;
// No need to umpdate immutable samplers
if (sourceEntry.Class == EffectParameterClass.Sampler && sourceEntry.ImmutableSampler != null)
{
continue;
}
DescriptorBindingMapping.Add(new DescriptorSetInfo
{
SourceSet = layoutIndex,
SourceBinding = sourceBinding,
DestinationBinding = destinationBinding,
DescriptorType = VulkanConvertExtensions.ConvertDescriptorType(sourceEntry.Class, sourceEntry.Type)
});
}
}
}
// Create default sampler, used by texture and buffer loads
destinationEntries[0] = new DescriptorSetLayoutBuilder.Entry
{
Class = EffectParameterClass.Sampler,
Type = EffectParameterType.Sampler,
ImmutableSampler = GraphicsDevice.SamplerStates.PointWrap,
ArraySize = 1,
};
// Create descriptor set layout
NativeDescriptorSetLayout = DescriptorSetLayout.CreateNativeDescriptorSetLayout(GraphicsDevice, destinationEntries, out DescriptorTypeCounts);
// Create pipeline layout
var nativeDescriptorSetLayout = NativeDescriptorSetLayout;
var pipelineLayoutCreateInfo = new PipelineLayoutCreateInfo
{
StructureType = StructureType.PipelineLayoutCreateInfo,
SetLayoutCount = 1,
SetLayouts = new IntPtr(&nativeDescriptorSetLayout)
};
NativeLayout = GraphicsDevice.NativeDevice.CreatePipelineLayout(ref pipelineLayoutCreateInfo);
}
