void setupDescriptorSetLayout() { var bindings = VkDescriptorSetLayoutBinding.Alloc(2); { // Binding 0 : Vertex shader uniform buffer bindings[0].binding = 0; bindings[0].descriptorType = VkDescriptorType.UniformBuffer; bindings[0].descriptorCount = 1; bindings[0].stageFlags = VkShaderStageFlagBits.Vertex; // Binding 1 : Fragment shader image sampler bindings[1].binding = 1; bindings[1].descriptorType = VkDescriptorType.CombinedImageSampler; bindings[1].descriptorCount = 1; bindings[1].stageFlags = VkShaderStageFlagBits.Fragment; } { var info = VkDescriptorSetLayoutCreateInfo.Alloc(); info[0].bindings.count = 2; info[0].bindings.pointer = bindings; VkDescriptorSetLayout layout; vkCreateDescriptorSetLayout(device, info, null, &layout); this.layout = layout; } { VkDescriptorSetLayout layout = this.layout; var info = VkPipelineLayoutCreateInfo.Alloc(); info[0].setLayouts = layout; VkPipelineLayout pipelineLayout; vkCreatePipelineLayout(device, info, null, &pipelineLayout); this.pipelineLayout = pipelineLayout; } }
void setupDescriptorSet() { // Scene rendering { VkDescriptorSetLayout dsl = setLayoutScene; var info = VkDescriptorSetAllocateInfo.Alloc(); info->setLayouts = dsl; info->descriptorPool = descriptorPool; VkDescriptorSet set; vkAllocateDescriptorSets(device, info, &set); this.setScene = set; } { var descriptor0 = uniformBufferScene.descriptor; var descriptor1 = textures_gradient.descriptor; var writes = VkWriteDescriptorSet.Alloc(2); { // Binding 0: Vertex shader uniform buffer writes[0].dstSet = setScene; writes[0].data.descriptorType = VkDescriptorType.UniformBuffer; writes[0].dstBinding = 0; writes[0].data.Set(descriptor0); // Binding 1: Color gradient sampler writes[1].dstSet = setScene; writes[1].data.descriptorType = VkDescriptorType.CombinedImageSampler; writes[1].dstBinding = 1; writes[1].data.Set(descriptor1); } vkUpdateDescriptorSets(device, 2, writes, 0, null); } // Fullscreen radial blur { VkDescriptorSetLayout dsl = setLayoutRadialBlur; var info = VkDescriptorSetAllocateInfo.Alloc(); info->setLayouts = dsl; info->descriptorPool = descriptorPool; VkDescriptorSet set; vkAllocateDescriptorSets(device, info, &set); this.setRadialBlur = set; } { VkDescriptorBufferInfo descriptor0 = uniformBufferBlurParams.descriptor; VkDescriptorImageInfo descriptor1 = offscreenPass.descriptorImage; var writes = VkWriteDescriptorSet.Alloc(2); { // Binding 0: Vertex shader uniform buffer writes[0].dstSet = setRadialBlur; writes[0].data.descriptorType = VkDescriptorType.UniformBuffer; writes[0].dstBinding = 0; writes[0].data.Set(descriptor0); // Binding 0: Fragment shader texture sampler writes[1].dstSet = setRadialBlur; writes[1].data.descriptorType = VkDescriptorType.CombinedImageSampler; writes[1].dstBinding = 1; writes[1].data.Set(descriptor1); } vkUpdateDescriptorSets(device, 2, writes, 0, null); } }
public void Allocate(VkDescriptorSetLayout setLayout) { uint *variable_desc_counts = stackalloc uint[1] { (uint)DeviceLimits.BindingsBindless }; VkDescriptorSetVariableDescriptorCountAllocateInfo variable_descriptor_count_alloc_info = new() { sType = VkStructureType.DescriptorSetVariableDescriptorCountAllocateInfo, descriptorSetCount = 2, pDescriptorCounts = variable_desc_counts, }; bool descriptor_indexing = NativeDevice.supports_descriptor_indexing(); VkDescriptorSetAllocateInfo descriptor_set_allocate_info = new() { sType = VkStructureType.DescriptorSetAllocateInfo, pNext = descriptor_indexing ? &variable_descriptor_count_alloc_info : null, descriptorSetCount = 1, pSetLayouts = &setLayout, descriptorPool = pool, }; VkDescriptorSet descriptor_set; vkAllocateDescriptorSets(NativeDevice.handle, &descriptor_set_allocate_info, &descriptor_set).CheckResult(); handle = descriptor_set; }
/// <inheritdoc/> protected internal override unsafe void OnDestroyed() { GraphicsDevice.NativeDevice.DestroyDescriptorSetLayout(NativeLayout); NativeLayout = VkDescriptorSetLayout.Null; base.OnDestroyed(); }
private static VkDescriptorSetLayout CreateDescriptorLayout(VkDevice device, uint textureCount) { VkDescriptorSetLayoutBinding samplerLayoutBinding = new VkDescriptorSetLayoutBinding(); samplerLayoutBinding.binding = 0; samplerLayoutBinding.descriptorCount = textureCount; samplerLayoutBinding.descriptorType = VkDescriptorType.CombinedImageSampler; samplerLayoutBinding.pImmutableSamplers = null; samplerLayoutBinding.stageFlags = VkShaderStageFlags.Fragment; VkDescriptorSetLayoutBinding uboLayoutBinding = new VkDescriptorSetLayoutBinding(); uboLayoutBinding.binding = 1; uboLayoutBinding.descriptorCount = 1; uboLayoutBinding.descriptorType = VkDescriptorType.UniformBuffer; uboLayoutBinding.stageFlags = VkShaderStageFlags.Vertex; VkDescriptorSetLayoutBinding[] bindings = new VkDescriptorSetLayoutBinding[2]; bindings[0] = samplerLayoutBinding; bindings[1] = uboLayoutBinding; VkDescriptorSetLayoutCreateInfo layoutInfo = VkDescriptorSetLayoutCreateInfo.New(); layoutInfo.bindingCount = (uint)bindings.Length; fixed(VkDescriptorSetLayoutBinding *ptr = bindings) layoutInfo.pBindings = ptr; VkDescriptorSetLayout descriptorSetLayout = VkDescriptorSetLayout.Null; Assert(vkCreateDescriptorSetLayout(device, &layoutInfo, null, &descriptorSetLayout)); return(descriptorSetLayout); }
void setupDescriptorSetLayout() { var bindings = new VkDescriptorSetLayoutBinding[] { // layout (binding = 0) uniform UboView new VkDescriptorSetLayoutBinding(0, VkDescriptorType.UniformBuffer, 1, VkShaderStageFlagBits.Vertex), // layout (binding = 1) uniform UboInstance new VkDescriptorSetLayoutBinding(1, VkDescriptorType.UniformBufferDynamic, 1, VkShaderStageFlagBits.Vertex), // no matching uniform sampler2D in shader. new VkDescriptorSetLayoutBinding(2, VkDescriptorType.CombinedImageSampler, 1, VkShaderStageFlagBits.Fragment), }; var descriptorLayoutInfo = new VkDescriptorSetLayoutCreateInfo(); descriptorLayoutInfo.sType = DescriptorSetLayoutCreateInfo; descriptorLayoutInfo.bindings = bindings; VkDescriptorSetLayout layout; vkCreateDescriptorSetLayout(device, &descriptorLayoutInfo, null, &layout); this.descriptorSetLayout = layout; VkPipelineLayoutCreateInfo info = new VkPipelineLayoutCreateInfo(); info.sType = PipelineLayoutCreateInfo; info.setLayouts = layout; VkPipelineLayout pipelineLayout; vkCreatePipelineLayout(device, &info, null, &pipelineLayout); this.pipelineLayout = pipelineLayout; }
VkDescriptorSet CreateDescriptorSet(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) { VkDescriptorPool descriptorPool; { // this pool can allocate one uniform descriptor. var info = new VkDescriptorPoolCreateInfo { sType = VkStructureType.DescriptorPoolCreateInfo }; var size = new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer, 1); info.poolSizes = size; info.maxSets = 1; vkAPI.vkCreateDescriptorPool(device, &info, null, &descriptorPool).Check(); info.Free(); } VkDescriptorSet descriptorSet; { var info = new VkDescriptorSetAllocateInfo { sType = VkStructureType.DescriptorSetAllocateInfo }; info.setLayouts = descriptorSetLayout; info.descriptorPool = descriptorPool; vkAPI.vkAllocateDescriptorSets(device, &info, &descriptorSet).Check(); info.Free(); } return(descriptorSet); }
public VkResourceSet(VkGraphicsDevice gd, ref ResourceSetDescription description) : base(ref description) { _gd = gd; VkResourceLayout vkLayout = Util.AssertSubtype <ResourceLayout, VkResourceLayout>(description.Layout); VkDescriptorSetLayout dsl = vkLayout.DescriptorSetLayout; _descriptorCounts = vkLayout.DescriptorResourceCounts; _descriptorAllocationToken = _gd.DescriptorPoolManager.Allocate(_descriptorCounts, dsl); BindableResource[] boundResources = description.BoundResources; uint descriptorWriteCount = (uint)boundResources.Length; VkWriteDescriptorSet * descriptorWrites = stackalloc VkWriteDescriptorSet[(int)descriptorWriteCount]; VkDescriptorBufferInfo *bufferInfos = stackalloc VkDescriptorBufferInfo[(int)descriptorWriteCount]; VkDescriptorImageInfo * imageInfos = stackalloc VkDescriptorImageInfo[(int)descriptorWriteCount]; for (int i = 0; i < descriptorWriteCount; i++) { VkDescriptorType type = vkLayout.DescriptorTypes[i]; descriptorWrites[i].sType = VkStructureType.WriteDescriptorSet; descriptorWrites[i].descriptorCount = 1; descriptorWrites[i].descriptorType = type; descriptorWrites[i].dstBinding = (uint)i; descriptorWrites[i].dstSet = _descriptorAllocationToken.Set; if (type == VkDescriptorType.UniformBuffer || type == VkDescriptorType.StorageBuffer) { VkBuffer vkBuffer = Util.AssertSubtype <BindableResource, VkBuffer>(boundResources[i]); bufferInfos[i].buffer = vkBuffer.DeviceBuffer; bufferInfos[i].range = vkBuffer.SizeInBytes; descriptorWrites[i].pBufferInfo = &bufferInfos[i]; } else if (type == VkDescriptorType.SampledImage) { VkTextureView textureView = Util.AssertSubtype <BindableResource, VkTextureView>(boundResources[i]); imageInfos[i].imageView = textureView.ImageView; imageInfos[i].imageLayout = VkImageLayout.ShaderReadOnlyOptimal; descriptorWrites[i].pImageInfo = &imageInfos[i]; } else if (type == VkDescriptorType.StorageImage) { VkTextureView textureView = Util.AssertSubtype <BindableResource, VkTextureView>(boundResources[i]); imageInfos[i].imageView = textureView.ImageView; imageInfos[i].imageLayout = VkImageLayout.General; descriptorWrites[i].pImageInfo = &imageInfos[i]; } else if (type == VkDescriptorType.Sampler) { VkSampler sampler = Util.AssertSubtype <BindableResource, VkSampler>(boundResources[i]); imageInfos[i].sampler = sampler.DeviceSampler; descriptorWrites[i].pImageInfo = &imageInfos[i]; } } vkUpdateDescriptorSets(_gd.Device, descriptorWriteCount, descriptorWrites, 0, null); }
public VkResourceSet(VkGraphicsDevice gd, ref ResourceSetDescription description) { _gd = gd; VkResourceLayout vkLayout = Util.AssertSubtype <ResourceLayout, VkResourceLayout>(description.Layout); VkDescriptorSetAllocateInfo dsAI = VkDescriptorSetAllocateInfo.New(); dsAI.descriptorSetCount = 1; VkDescriptorSetLayout dsl = vkLayout.DescriptorSetLayout; dsAI.pSetLayouts = &dsl; dsAI.descriptorPool = _gd.SharedDescriptorPool; VkResult result = vkAllocateDescriptorSets(_gd.Device, ref dsAI, out _descriptorSet); CheckResult(result); BindableResource[] boundResources = description.BoundResources; uint descriptorWriteCount = (uint)boundResources.Length; VkWriteDescriptorSet * descriptorWrites = stackalloc VkWriteDescriptorSet[(int)descriptorWriteCount]; VkDescriptorBufferInfo *bufferInfos = stackalloc VkDescriptorBufferInfo[(int)descriptorWriteCount]; VkDescriptorImageInfo * imageInfos = stackalloc VkDescriptorImageInfo[(int)descriptorWriteCount]; for (int i = 0; i < descriptorWriteCount; i++) { VkDescriptorType type = vkLayout.DescriptorTypes[i]; descriptorWrites[i].sType = VkStructureType.WriteDescriptorSet; descriptorWrites[i].descriptorCount = 1; descriptorWrites[i].descriptorType = type; descriptorWrites[i].dstBinding = (uint)i; descriptorWrites[i].dstSet = _descriptorSet; if (type == VkDescriptorType.UniformBuffer) { VkUniformBuffer uniformBuffer = Util.AssertSubtype <BindableResource, VkUniformBuffer>(boundResources[i]); bufferInfos[i].buffer = uniformBuffer.DeviceBuffer; bufferInfos[i].range = uniformBuffer.SizeInBytes; descriptorWrites[i].pBufferInfo = &bufferInfos[i]; } else if (type == VkDescriptorType.SampledImage) { VkTextureView textureView = Util.AssertSubtype <BindableResource, VkTextureView>(boundResources[i]); imageInfos[i].imageView = textureView.ImageView; imageInfos[i].imageLayout = VkImageLayout.ShaderReadOnlyOptimal; descriptorWrites[i].pImageInfo = &imageInfos[i]; } else if (type == VkDescriptorType.Sampler) { VkSampler sampler = Util.AssertSubtype <BindableResource, VkSampler>(boundResources[i]); imageInfos[i].sampler = sampler.DeviceSampler; descriptorWrites[i].pImageInfo = &imageInfos[i]; } } vkUpdateDescriptorSets(_gd.Device, descriptorWriteCount, descriptorWrites, 0, null); }
public VkDescriptorSetLayout CreateDescriptorSetLayout(VkDevice device, VkDescriptorSetLayoutBinding[] bindings) { VkDescriptorSetLayout layout = null; var descriptorSetLayoutCreateInfo = new VkDescriptorSetLayoutCreateInfo(); descriptorSetLayoutCreateInfo.bindings = bindings; VulkanAPI.vkCreateDescriptorSetLayout(device, ref descriptorSetLayoutCreateInfo, out layout); m_descLayouts.Add(layout); return(layout); }
public VkPipelineLayout CreatePipelineLayout(VkDevice device, VkDescriptorSetLayout descSetLayout) { var createInfo = new VkPipelineLayoutCreateInfo(); createInfo.setLayouts = new[] { descSetLayout }; VkPipelineLayout layout = null; VulkanAPI.vkCreatePipelineLayout(device, ref createInfo, out layout); m_pipelineLayouts.Add(layout); return(layout); }
static VkPipelineLayout CreatePipelineLayout(VkDevice device, VkDescriptorSetLayout setLayout) { VkPipelineLayoutCreateInfo pCreateInfo = VkPipelineLayoutCreateInfo.New(); pCreateInfo.pushConstantRangeCount = 0; pCreateInfo.setLayoutCount = 1; pCreateInfo.pSetLayouts = &setLayout; VkPipelineLayout layout = VkPipelineLayout.Null; Assert(vkCreatePipelineLayout(device, &pCreateInfo, null, &layout)); return(layout); }
VkPipelineLayout CreatePipelineLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) { var info = new VkPipelineLayoutCreateInfo { sType = VkStructureType.PipelineLayoutCreateInfo }; info.setLayouts = descriptorSetLayout; //return device.CreatePipelineLayout(ref info); VkPipelineLayout layout; vkAPI.vkCreatePipelineLayout(device, &info, null, &layout).Check(); info.Free(); return(layout); }
private VkPipelineLayout CreatePipelineLayout() { VkDescriptorSetLayout layout = _descriptorSetLayout; var createInfo = new VkPipelineLayoutCreateInfo { sType = VkStructureType.PipelineLayoutCreateInfo, pNext = null, setLayoutCount = 1, pSetLayouts = &layout }; VkPipelineLayout pipelineLayout; vkCreatePipelineLayout(Context.Device, &createInfo, null, out pipelineLayout).CheckResult(); return(pipelineLayout); }
void CreateDescriptorSetLayout() { var uboLayoutBinding = new VkDescriptorSetLayoutBinding(); uboLayoutBinding.binding = 0; uboLayoutBinding.descriptorType = VkDescriptorType.UniformBuffer; uboLayoutBinding.descriptorCount = 1; uboLayoutBinding.stageFlags = VkShaderStageFlags.VertexBit; var info = new VkDescriptorSetLayoutCreateInfo(); info.bindings = new List <VkDescriptorSetLayoutBinding> { uboLayoutBinding }; descriptorSetLayout = new VkDescriptorSetLayout(device, info); }
void setupDescriptorSet() { VkDescriptorSetLayout dsl = descriptorSetLayout; VkDescriptorSetAllocateInfo allocInfo = new VkDescriptorSetAllocateInfo(); allocInfo.sType = DescriptorSetAllocateInfo; allocInfo.descriptorPool = descriptorPool; allocInfo.setLayouts = dsl; { VkDescriptorSet set; vkAllocateDescriptorSets(device, &allocInfo, &set); this.descriptorSet = set; } VkDescriptorImageInfo texDescriptor = new VkDescriptorImageInfo(); texDescriptor.sampler = textures_colorMap.sampler; texDescriptor.imageView = textures_colorMap.view; texDescriptor.imageLayout = VkImageLayout.General; VkDescriptorBufferInfo temp = uniformBuffers_scene.descriptor; var writes = new VkWriteDescriptorSet[2]; // Binding 0 : Vertex shader uniform buffer writes[0] = new VkWriteDescriptorSet(); writes[0].sType = WriteDescriptorSet; writes[0].dstSet = descriptorSet; writes[0].data.descriptorType = VkDescriptorType.UniformBuffer; writes[0].dstBinding = 0; writes[0].data.Set(temp); // Binding 1 : Color map writes[1] = new VkWriteDescriptorSet(); writes[1].sType = WriteDescriptorSet; writes[1].dstSet = descriptorSet; writes[1].data.descriptorType = VkDescriptorType.CombinedImageSampler; writes[1].dstBinding = 1; writes[1].data.Set(texDescriptor); fixed(VkWriteDescriptorSet *pointer = writes) { vkUpdateDescriptorSets(device, (UInt32)writes.Length, pointer, 0, null); } }
private static VkDescriptorSet[] AllocateDescriptorSets(VkDevice device, VkDescriptorSetLayout layout, VkDescriptorPool pool, uint swapchainImageCount) { VkDescriptorSetLayout[] localLayouts = new VkDescriptorSetLayout[swapchainImageCount]; for (int i = 0; i < localLayouts.Length; i++) { localLayouts[i] = layout; } VkDescriptorSetAllocateInfo allocateInfo = VkDescriptorSetAllocateInfo.New(); allocateInfo.descriptorPool = pool; allocateInfo.descriptorSetCount = swapchainImageCount; fixed(VkDescriptorSetLayout *ptr = localLayouts) allocateInfo.pSetLayouts = ptr; VkDescriptorSet[] sets = new VkDescriptorSet[swapchainImageCount]; fixed(VkDescriptorSet *ptr = sets) Assert(vkAllocateDescriptorSets(device, &allocateInfo, ptr)); return(sets); }
protected override void InitializePermanent() { var cube = GeometricPrimitive.Box(1.0f, 1.0f, 1.0f); _cubeTexture = Content.LoadVulkanImage("IndustryForgedDark512.ktx"); _cubeVertices = ToDispose(VulkanBuffer.Vertex(Context, cube.Vertices)); _cubeIndices = ToDispose(VulkanBuffer.Index(Context, cube.Indices)); var sampler = CreateSampler(); _sampler = sampler; ToDispose(new ActionDisposable(() => { vkDestroySampler(Context.Device, sampler, null); })); _uniformBuffer = ToDispose(VulkanBuffer.DynamicUniform <WorldViewProjection>(Context, 1)); var descriptorSetLayout = CreateDescriptorSetLayout(); _descriptorSetLayout = descriptorSetLayout; ToDispose(new ActionDisposable(() => { vkDestroyDescriptorSetLayout(Context.Device, descriptorSetLayout, null); })); var pipelineLayout = CreatePipelineLayout(); _pipelineLayout = pipelineLayout; ToDispose(new ActionDisposable(() => { vkDestroyPipelineLayout(Context.Device, pipelineLayout, null); })); var descriptorPool = CreateDescriptorPool(); _descriptorPool = descriptorPool; ToDispose(new ActionDisposable(() => { vkDestroyDescriptorPool(Context.Device, descriptorPool, null); })); _descriptorSet = CreateDescriptorSet(_descriptorPool); // Will be freed when pool is destroyed. }
public unsafe DescriptorLayout(Device device, List <DescriptorBindingInfo> bindings) { _device = device; _bindings = bindings; var vulkanBindings = new NativeList <VkDescriptorSetLayoutBinding>(); foreach (var binding in bindings) { vulkanBindings.Add(new VkDescriptorSetLayoutBinding { binding = binding.Index, descriptorType = binding.DescriptorType, descriptorCount = binding.DescriptorCounts, stageFlags = binding.ShaderStageFlags }); } var createInfo = new VkDescriptorSetLayoutCreateInfo { sType = VkStructureType.DescriptorSetLayoutCreateInfo, bindingCount = vulkanBindings.Count, pBindings = (VkDescriptorSetLayoutBinding *)vulkanBindings.Data.ToPointer() }; VkDescriptorSetLayout layout; if (VulkanNative.vkCreateDescriptorSetLayout( device.Handle, &createInfo, null, &layout ) != VkResult.Success) { throw new Exception("failed to create descriptor set layout"); } _handle = layout; }
public unsafe DescriptorSetLayout Build() { if (!needRebuild) { return(this); } needRebuild = false; Destroy(true); bindings = new VkDescriptorSetLayoutBinding[Bindings.Count]; for (int i = 0; i < Bindings.Count; i++) { bindings[i] = new VkDescriptorSetLayoutBinding { descriptorType = Bindings[i].descriptorType, stageFlags = Bindings[i].stageFlags, binding = Bindings[i].binding, descriptorCount = Bindings[i].descriptorCount }; } var descriptorSetLayoutCreateInfo = new VkDescriptorSetLayoutCreateInfo { sType = VkStructureType.DescriptorSetLayoutCreateInfo }; descriptorSetLayoutCreateInfo.pBindings = (VkDescriptorSetLayoutBinding *)Utilities.AsPointer(ref bindings[0]); descriptorSetLayoutCreateInfo.bindingCount = (uint)bindings.Length; descriptorSetLayout = Device.CreateDescriptorSetLayout(ref descriptorSetLayoutCreateInfo); descriptorResourceCounts = new DescriptorResourceCounts(); foreach (var binding in bindings) { int index = binding.descriptorType switch {
void setupDescriptorSet() { VkDescriptorSetLayout layout = this.layout; var allocInfo = VkDescriptorSetAllocateInfo.Alloc(); allocInfo[0].descriptorPool = descriptorPool; allocInfo[0].setLayouts = layout; { VkDescriptorSet set; vkAllocateDescriptorSets(device, allocInfo, &set); this.descriptorSet = set; } // Setup a descriptor image info for the current texture to be used as a combined image sampler VkDescriptorImageInfo imageInfo; imageInfo.imageView = texture.view; // The image's view (images are never directly accessed by the shader, but rather through views defining subresources) imageInfo.sampler = texture.sampler; // The sampler (Telling the pipeline how to sample the texture, including repeat, border, etc.) imageInfo.imageLayout = texture.imageLayout; // The current layout of the image (Note: Should always fit the actual use, e.g. shader read) VkDescriptorBufferInfo bufferInfo = uniformBufferVS.descriptor; var writes = VkWriteDescriptorSet.Alloc(2); { // Binding 0 : Vertex shader uniform buffer writes[0].dstSet = descriptorSet; writes[0].dstBinding = 0; writes[0].data.descriptorType = VkDescriptorType.UniformBuffer; writes[0].data.Set(bufferInfo); // Binding 1 : Fragment shader texture sampler // Fragment shader: layout (binding = 1) uniform sampler2D samplerColor; writes[1].dstSet = descriptorSet; writes[1].dstBinding = 1; writes[1].data.descriptorType = VkDescriptorType.CombinedImageSampler; writes[1].data.Set(imageInfo); } vkUpdateDescriptorSets(device, 2, writes, 0, null); }
void setupDescriptorSetLayout() { var bindings = new VkDescriptorSetLayoutBinding[2]; // Binding 0 : Vertex shader uniform buffer bindings[0] = new VkDescriptorSetLayoutBinding(); bindings[0].descriptorType = VkDescriptorType.UniformBuffer; bindings[0].stageFlags = VkShaderStageFlagBits.Vertex; bindings[0].binding = 0; bindings[0].descriptorCount = 1; // Binding 1 : Fragment shader combined sampler bindings[1] = new VkDescriptorSetLayoutBinding(); bindings[1].descriptorType = VkDescriptorType.CombinedImageSampler; bindings[1].stageFlags = VkShaderStageFlagBits.Fragment; bindings[1].binding = 1; bindings[1].descriptorCount = 1; var descriptorLayout = VkDescriptorSetLayoutCreateInfo.Alloc(); descriptorLayout->bindings = bindings; VkDescriptorSetLayout dsl; vkCreateDescriptorSetLayout(device, descriptorLayout, null, &dsl); this.descriptorSetLayout = dsl; var info = new VkPipelineLayoutCreateInfo(); info.sType = PipelineLayoutCreateInfo; info.setLayouts = dsl; { VkPipelineLayout layout; vkCreatePipelineLayout(device, &info, null, &layout); this.pipelineLayout = layout; } }
public void Init(IntPtr hwnd, IntPtr processHandle) { if (this.isInitialized) { return; } this.instance = InitInstance(); InitDebugCallback(this.instance); this.surface = InitSurface(this.instance, hwnd, processHandle); this.vkPhysicalDevice = InitPhysicalDevice(this.instance); VkSurfaceFormatKHR surfaceFormat = SelectFormat(this.vkPhysicalDevice, this.surface); this.device = CreateDevice(this.vkPhysicalDevice, this.surface); this.vkQueue = this.device.GetQueue(0, 0); VkSurfaceCapabilitiesKHR surfaceCapabilities; //this.vkPhysicalDevice.GetSurfaceCapabilitiesKhr(this.vkSurface, out surfaceCapabilities); vkAPI.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(this.vkPhysicalDevice, this.surface, &surfaceCapabilities).Check(); this.swapchain = CreateSwapchain(this.device, this.surface, surfaceFormat, surfaceCapabilities); this.vkImages = this.device.GetSwapchainImages(this.swapchain); this.renderPass = CreateRenderPass(this.device, surfaceFormat); this.framebuffers = CreateFramebuffers(this.device, this.vkImages, surfaceFormat, this.renderPass, surfaceCapabilities); this.vkFence = this.device.CreateFence(); this.vkSemaphore = this.device.CreateSemaphore(); // buffers for vertex data. VkBuffer vertexBuffer = CreateBuffer(this.vkPhysicalDevice, this.device, Vertices, VkBufferUsageFlagBits.VertexBuffer, typeof(float)); VkBuffer indexBuffer = CreateBuffer(this.vkPhysicalDevice, this.device, Indexes, VkBufferUsageFlagBits.IndexBuffer, typeof(short)); var uniformBufferData = new AreaUniformBuffer(1, 1); this.originalWidth = 1; this.width = this.originalWidth; this.originalHeight = 1; this.height = this.originalHeight; this.uniformBuffer = CreateBuffer(this.vkPhysicalDevice, this.device, uniformBufferData, VkBufferUsageFlagBits.UniformBuffer, typeof(AreaUniformBuffer)); this.descriptorSetLayout = CreateDescriptorSetLayout(this.device); this.vkPipelineLayout = CreatePipelineLayout(this.device, this.descriptorSetLayout); VkPipeline pipeline = CreatePipeline(this.device, surfaceCapabilities, this.renderPass, this.vkPipelineLayout); this.descriptorSet = CreateDescriptorSet(this.device, this.descriptorSetLayout); UpdateDescriptorSets(this.device, this.uniformBuffer, this.descriptorSet); this.commandBuffers = CreateCommandBuffers( this.device, this.renderPass, surfaceCapabilities, this.vkImages, this.framebuffers, pipeline, vertexBuffer, indexBuffer, (uint)Indexes.Length, this.vkPipelineLayout, this.descriptorSet); this.isInitialized = true; }
public unsafe DescriptorAllocationToken Allocate(DescriptorResourceCounts counts, VkDescriptorSetLayout setLayout) { lock (_lock) { VkDescriptorPool pool = GetPool(counts); VkDescriptorSetAllocateInfo dsAI = VkDescriptorSetAllocateInfo.New(); dsAI.descriptorSetCount = 1; dsAI.pSetLayouts = &setLayout; dsAI.descriptorPool = pool; VkResult result = vkAllocateDescriptorSets(_gd.Device, ref dsAI, out VkDescriptorSet set); VulkanUtil.CheckResult(result); return(new DescriptorAllocationToken(set, pool)); } }
public static VkResult vkCreateDescriptorSetLayout(VkDevice device, VkDescriptorSetLayoutCreateInfo pCreateInfo, VkAllocationCallbacks pAllocator, out VkDescriptorSetLayout pSetLayout) { VkPreconditions.CheckNull(device, nameof(device)); return(GetDevice(device).CreateDescriptorSetLayout(pCreateInfo, out pSetLayout)); }
public static void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks pAllocator) { VkPreconditions.CheckNull(device, nameof(device)); GetDevice(device).DestroyDescriptorSetLayout(descriptorSetLayout); }
public VkResourceSet(VkGraphicsDevice gd, ref ResourceSetDescription description) : base(ref description) { _gd = gd; RefCount = new ResourceRefCount(DisposeCore); VkResourceLayout vkLayout = Util.AssertSubtype <ResourceLayout, VkResourceLayout>(description.Layout); VkDescriptorSetLayout dsl = vkLayout.DescriptorSetLayout; _descriptorCounts = vkLayout.DescriptorResourceCounts; _descriptorAllocationToken = _gd.DescriptorPoolManager.Allocate(_descriptorCounts, dsl); BindableResource[] boundResources = description.BoundResources; uint descriptorWriteCount = (uint)boundResources.Length; VkWriteDescriptorSet * descriptorWrites = stackalloc VkWriteDescriptorSet[(int)descriptorWriteCount]; VkDescriptorBufferInfo *bufferInfos = stackalloc VkDescriptorBufferInfo[(int)descriptorWriteCount]; VkDescriptorImageInfo * imageInfos = stackalloc VkDescriptorImageInfo[(int)descriptorWriteCount]; for (int i = 0; i < descriptorWriteCount; i++) { VkDescriptorType type = vkLayout.DescriptorTypes[i]; descriptorWrites[i].sType = VkStructureType.WriteDescriptorSet; descriptorWrites[i].descriptorCount = 1; descriptorWrites[i].descriptorType = type; descriptorWrites[i].dstBinding = (uint)i; descriptorWrites[i].dstSet = _descriptorAllocationToken.Set; if (type == VkDescriptorType.UniformBuffer || type == VkDescriptorType.UniformBufferDynamic || type == VkDescriptorType.StorageBuffer || type == VkDescriptorType.StorageBufferDynamic) { DeviceBufferRange range = Util.GetBufferRange(boundResources[i], 0); VkBuffer rangedVkBuffer = Util.AssertSubtype <DeviceBuffer, VkBuffer>(range.Buffer); bufferInfos[i].buffer = rangedVkBuffer.DeviceBuffer; bufferInfos[i].offset = range.Offset; bufferInfos[i].range = range.SizeInBytes; descriptorWrites[i].pBufferInfo = &bufferInfos[i]; _refCounts.Add(rangedVkBuffer.RefCount); } else if (type == VkDescriptorType.SampledImage) { TextureView texView = Util.GetTextureView(_gd, boundResources[i]); VkTextureView vkTexView = Util.AssertSubtype <TextureView, VkTextureView>(texView); imageInfos[i].imageView = vkTexView.ImageView; imageInfos[i].imageLayout = VkImageLayout.ShaderReadOnlyOptimal; descriptorWrites[i].pImageInfo = &imageInfos[i]; _sampledTextures.Add(Util.AssertSubtype <Texture, VkTexture>(texView.Target)); _refCounts.Add(vkTexView.RefCount); } else if (type == VkDescriptorType.StorageImage) { TextureView texView = Util.GetTextureView(_gd, boundResources[i]); VkTextureView vkTexView = Util.AssertSubtype <TextureView, VkTextureView>(texView); imageInfos[i].imageView = vkTexView.ImageView; imageInfos[i].imageLayout = VkImageLayout.General; descriptorWrites[i].pImageInfo = &imageInfos[i]; _storageImages.Add(Util.AssertSubtype <Texture, VkTexture>(texView.Target)); _refCounts.Add(vkTexView.RefCount); } else if (type == VkDescriptorType.Sampler) { VkSampler sampler = Util.AssertSubtype <BindableResource, VkSampler>(boundResources[i]); imageInfos[i].sampler = sampler.DeviceSampler; descriptorWrites[i].pImageInfo = &imageInfos[i]; _refCounts.Add(sampler.RefCount); } } vkUpdateDescriptorSets(_gd.Device, descriptorWriteCount, descriptorWrites, 0, null); }
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), ResourceElementIsInteger = sourceEntry.ElementType != EffectParameterType.Float && sourceEntry.ElementType != EffectParameterType.Double, }); } } } // 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 VkPipelineLayoutCreateInfo { sType = VkStructureType.PipelineLayoutCreateInfo, setLayoutCount = 1, pSetLayouts = &nativeDescriptorSetLayout, }; vkCreatePipelineLayout(GraphicsDevice.NativeDevice, &pipelineLayoutCreateInfo, null, out NativeLayout); }
public static extern void DestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, IntPtr pAllocator );
public static extern VkResult CreateDescriptorSetLayout( VkDevice device, ref VkDescriptorSetLayoutCreateInfo pCreateInfo, IntPtr pAllocator, out VkDescriptorSetLayout pSetLayout );