public unsafe void UpdateSampledImage(ImageView view, Sampler sampler, int binding) { var vulkanBinding = _descriptorPool.Layout.Bindings[binding]; var descriptorImageInfo = new VkDescriptorImageInfo { imageLayout = view.Image.Layout.First(), imageView = view.Handle, sampler = sampler.Handle }; var writeDescriptorSet = new VkWriteDescriptorSet { sType = VkStructureType.WriteDescriptorSet, dstSet = _handle, dstBinding = vulkanBinding.Index, dstArrayElement = 0, descriptorCount = vulkanBinding.DescriptorCounts, descriptorType = vulkanBinding.DescriptorType, pImageInfo = &descriptorImageInfo }; VulkanNative.vkUpdateDescriptorSets( _device.Handle, 1, &writeDescriptorSet, 0, null ); }
public void Set(uint binding, uint idx, ImageView img, bool rw) { var img_info = new VkDescriptorImageInfo() { sampler = IntPtr.Zero, imageView = img.hndl, imageLayout = rw ? VkImageLayout.ImageLayoutGeneral : VkImageLayout.ImageLayoutShaderReadOnlyOptimal }; var img_info_ptr = img_info.Pointer(); var desc_write = new VkWriteDescriptorSet() { sType = VkStructureType.StructureTypeWriteDescriptorSet, dstSet = hndl, dstBinding = binding, dstArrayElement = idx, descriptorCount = 1, pImageInfo = img_info_ptr, pBufferInfo = IntPtr.Zero, pTexelBufferView = null, descriptorType = (VkDescriptorType)Layout.Layouts[(int)binding].Type }; vkUpdateDescriptorSets(GraphicsDevice.GetDeviceInfo(devID).Device, 1, desc_write.Pointer(), 0, null); }
public unsafe void UpdateBuffer(Buffer buffer, int binding) { var vulkanBinding = _descriptorPool.Layout.Bindings[binding]; var descriptorSetBufferInfo = new VkDescriptorBufferInfo { buffer = buffer.Handle, offset = 0, range = buffer.Size }; var writeDescriptorSet = new VkWriteDescriptorSet { sType = VkStructureType.WriteDescriptorSet, dstSet = _handle, dstBinding = vulkanBinding.Index, dstArrayElement = 0, descriptorCount = vulkanBinding.DescriptorCounts, descriptorType = vulkanBinding.DescriptorType, pBufferInfo = &descriptorSetBufferInfo, }; VulkanNative.vkUpdateDescriptorSets( _device.Handle, 1, &writeDescriptorSet, 0, null ); }
public void Set(uint binding, uint idx, GpuBuffer buf, ulong off, ulong len) { var buf_info = new VkDescriptorBufferInfo() { buffer = buf.hndl, offset = off, range = len }; var buf_info_ptr = buf_info.Pointer(); var desc_write = new VkWriteDescriptorSet() { sType = VkStructureType.StructureTypeWriteDescriptorSet, dstSet = hndl, dstBinding = binding, dstArrayElement = idx, descriptorCount = 1, pImageInfo = IntPtr.Zero, pBufferInfo = buf_info_ptr, pTexelBufferView = null, descriptorType = (VkDescriptorType)Layout.Layouts[(int)binding].Type }; vkUpdateDescriptorSets(GraphicsDevice.GetDeviceInfo(devID).Device, 1, desc_write.Pointer(), 0, null); }
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); } }
/// <summary> /// execute the descriptors writes targeting descriptorSets setted on AddWriteInfo call /// </summary> public void Write(Device dev, params object[] descriptors) { //if (descriptors.Length != WriteDescriptorSets.Count) // throw new Exception ("descriptors count must equal the WriteInfo count."); List <object> descriptorsLists = new List <object> (); //strore temp arrays of pDesc for unpinning //if descriptorCount>1 int i = 0; int wdsPtr = 0; while (i < descriptors.Length) { int firstDescriptor = i; VkWriteDescriptorSet wds = WriteDescriptorSets[wdsPtr]; if (dstSetOverride != null) { wds.dstSet = dstSetOverride.Value.Handle; } IntPtr pDescriptors = IntPtr.Zero; if (wds.descriptorCount > 1) { List <IntPtr> descPtrArray = new List <IntPtr> (); for (int d = 0; d < wds.descriptorCount; d++) { descPtrArray.Add(descriptors[i].Pin()); i++; } descriptorsLists.Add(descPtrArray); pDescriptors = descPtrArray.Pin(); } else { pDescriptors = descriptors[i].Pin(); i++; } if (descriptors[firstDescriptor] is VkDescriptorBufferInfo) { wds.pBufferInfo = pDescriptors; } else if (descriptors[firstDescriptor] is VkDescriptorImageInfo) { wds.pImageInfo = pDescriptors; } WriteDescriptorSets[wdsPtr] = wds; wdsPtr++; } vkUpdateDescriptorSets(dev.VkDev, (uint)WriteDescriptorSets.Count, WriteDescriptorSets.Pin(), 0, IntPtr.Zero); WriteDescriptorSets.Unpin(); foreach (object descArray in descriptorsLists) { descArray.Unpin(); } for (i = 0; i < descriptors.Length; i++) { descriptors[i].Unpin(); } }
/// <summary> /// Adds write info without specifying a destination descriptor set, this imply that on calling Write, you MUST /// provide a desDescriptor! /// </summary> public void AddWriteInfo(VkDescriptorSetLayoutBinding binding) { VkWriteDescriptorSet wds = VkWriteDescriptorSet.New(); wds.descriptorType = binding.descriptorType; wds.descriptorCount = binding.descriptorCount; wds.dstBinding = binding.binding; WriteDescriptorSets.Add(wds); }
private void PrepareDescriptor(VkDevice device) { // 定数バッファを1つだけ持つものを作る. VkDescriptorPoolSize descriptorPoolSize = new VkDescriptorPoolSize() { descriptorCount = 1, type = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, }; var descriptorPoolCreateInfo = new VkDescriptorPoolCreateInfo() { poolSizes = new[] { descriptorPoolSize }, maxSets = 1, flags = VkDescriptorPoolCreateFlags.VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, }; VulkanAPI.vkCreateDescriptorPool(device, ref descriptorPoolCreateInfo, out m_descriptorPool); // ディスクリプタセットレイアウトの作成. // 今は定数バッファを1つ持つだけのものを作成. var descriptorLayoutBinding = new VkDescriptorSetLayoutBinding(); descriptorLayoutBinding.binding = 0; descriptorLayoutBinding.descriptorCount = 1; descriptorLayoutBinding.descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; descriptorLayoutBinding.stageFlags = VkShaderStageFlagBits.VK_SHADER_STAGE_VERTEX_BIT; var descriptorSetLayoutCreateInfo = new VkDescriptorSetLayoutCreateInfo(); descriptorSetLayoutCreateInfo.bindings = new[] { descriptorLayoutBinding }; VulkanAPI.vkCreateDescriptorSetLayout(device, ref descriptorSetLayoutCreateInfo, out m_descriptorSetLayout); // ディスクリプタセットを作成. VkDescriptorSet[] descriptorSets; var descriptorSetAllocateInfo = new VkDescriptorSetAllocateInfo(m_descriptorPool, new[] { m_descriptorSetLayout }); VulkanAPI.vkAllocateDescriptorSets(device, ref descriptorSetAllocateInfo, out descriptorSets); m_descriptorSet = descriptorSets[0]; // ディスクリプタを更新. // 定数バッファ1つを持つレイアウトでディスクリプタを作る. VkDescriptorBufferInfo descUniformBufferInfo = new VkDescriptorBufferInfo(); descUniformBufferInfo.buffer = m_uniformBuffer; descUniformBufferInfo.range = Marshal.SizeOf <Transform>(); var descriptor = new VkWriteDescriptorSet(); descriptor.descriptorCount = 1; descriptor.descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; descriptor.pBufferInfo = new[] { descUniformBufferInfo }; descriptor.dstBinding = 0; descriptor.dstSet = m_descriptorSet; VulkanAPI.vkUpdateDescriptorSets(device, new[] { descriptor }, null); }
/// <summary> /// テクスチャのためのディスクリプタの生成. /// </summary> /// <param name="destBinding"></param> /// <param name="imageView"></param> /// <param name="sampler"></param> /// <param name="descriptorSet"></param> /// <returns></returns> public static VkWriteDescriptorSet CreateDescriptorFromImageSampler(uint destBinding, VkDescriptorImageInfo descImageSampler, VkDescriptorSet descriptorSet) { var descriptorImageSampler = new VkWriteDescriptorSet() { descriptorCount = 1, descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, pImageInfo = new[] { descImageSampler }, dstBinding = destBinding, dstSet = descriptorSet, }; return(descriptorImageSampler); }
/// <summary> /// ユニフォームバッファのディスクリプタの生成. /// </summary> /// <param name="destBinding"></param> /// <param name="uniformBuffer"></param> /// <param name="size"></param> /// <param name="descriptorSet"></param> /// <returns></returns> public static VkWriteDescriptorSet CreateDescriptorFromUniformBuffer(uint destBinding, VkDescriptorBufferInfo descUniformBufferInfo, VkDescriptorSet descriptorSet) { var descriptorUniform = new VkWriteDescriptorSet() { descriptorCount = 1, descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, pBufferInfo = new[] { descUniformBufferInfo, }, dstBinding = destBinding, dstSet = descriptorSet }; return(descriptorUniform); }
public void AddWriteInfo(DescriptorSet destSet, VkDescriptorSetLayoutBinding binding, VkDescriptorImageInfo descriptor) { if (!descriptors.Contains(descriptor)) { descriptors.Add(descriptor); } VkWriteDescriptorSet wds = VkWriteDescriptorSet.New(); wds.descriptorType = binding.descriptorType; wds.descriptorCount = binding.descriptorCount; wds.dstBinding = binding.binding; wds.dstSet = destSet.handle; wds.pImageInfo = descriptor.Pin(); WriteDescriptorSets.Add(wds); }
public static VkWriteDescriptorSet writeDescriptorSet( VkDescriptorSet dstSet, VkDescriptorType type, uint binding, VkDescriptorImageInfo *imageInfo, uint descriptorCount = 1) { VkWriteDescriptorSet writeDescriptorSet = VkWriteDescriptorSet.New(); writeDescriptorSet.dstSet = dstSet; writeDescriptorSet.descriptorType = type; writeDescriptorSet.dstBinding = binding; writeDescriptorSet.pImageInfo = imageInfo; writeDescriptorSet.descriptorCount = descriptorCount; return(writeDescriptorSet); }
void UpdateDescriptorSets(VkDevice device, VkBuffer uniformBuffer, VkDescriptorSet descriptorSet) { var write = new VkWriteDescriptorSet { sType = VkStructureType.WriteDescriptorSet }; write.dstSet = descriptorSet; write.data.descriptorType = VkDescriptorType.UniformBuffer; var info = new VkDescriptorBufferInfo(uniformBuffer, 0, 2 * sizeof(float)); write.data.Set(info); //device.UpdateDescriptorSets(new VkWriteDescriptorSet[] { write }, null); vkAPI.vkUpdateDescriptorSets(device, 1, &write, 0, null); write.Free(); }
/// <summary> /// execute the descriptors writes targeting descriptorSets setted on AddWriteInfo call /// </summary> public void Write(Device dev, params object[] descriptors) { using (PinnedObjects pinCtx = new PinnedObjects()) { int i = 0; int wdsPtr = 0; while (i < descriptors.Length) { int firstDescriptor = i; VkWriteDescriptorSet wds = WriteDescriptorSets[wdsPtr]; if (dstSetOverride != null) { wds.dstSet = dstSetOverride.Value.Handle; } IntPtr pDescriptors = IntPtr.Zero; if (wds.descriptorCount > 1) { List <IntPtr> descPtrArray = new List <IntPtr> (); for (int d = 0; d < wds.descriptorCount; d++) { descPtrArray.Add(descriptors[i].Pin(pinCtx)); i++; } pDescriptors = descPtrArray.Pin(pinCtx); } else { pDescriptors = descriptors[i].Pin(pinCtx); i++; } if (descriptors[firstDescriptor] is VkDescriptorBufferInfo) { wds.pBufferInfo = pDescriptors; } else if (descriptors[firstDescriptor] is VkDescriptorImageInfo) { wds.pImageInfo = pDescriptors; } WriteDescriptorSets[wdsPtr] = wds; wdsPtr++; } vkUpdateDescriptorSets(dev.VkDev, (uint)WriteDescriptorSets.Count, WriteDescriptorSets.Pin(pinCtx), 0, IntPtr.Zero); } }
void setupDescriptorSet() { var allocInfo = new VkDescriptorSetAllocateInfo(); allocInfo.sType = DescriptorSetAllocateInfo; allocInfo.descriptorPool = descriptorPool; allocInfo.setLayouts = descriptorSetLayout; VkDescriptorSet set; vkAllocateDescriptorSets(device, &allocInfo, &set); this.descriptorSet = set; VkDescriptorBufferInfo descriptor0 = uniformBuffers_view.descriptor; VkDescriptorBufferInfo descriptor1 = uniformBuffers_dynamic.descriptor; var writeDescriptorSets = new VkWriteDescriptorSet[2]; { // Binding 0 : Projection/View matrix uniform buffer var a = new VkWriteDescriptorSet() { sType = WriteDescriptorSet, dstSet = descriptorSet, dstBinding = 0, }; a.data.descriptorType = VkDescriptorType.UniformBuffer; a.data.Set(descriptor0); writeDescriptorSets[0] = a; // Binding 1 : Instance matrix as dynamic uniform buffer var b = new VkWriteDescriptorSet() { sType = WriteDescriptorSet, dstSet = descriptorSet, dstBinding = 1, }; b.data.descriptorType = VkDescriptorType.UniformBufferDynamic; b.data.Set(descriptor1); writeDescriptorSets[1] = b; }; fixed(VkWriteDescriptorSet *pointer = writeDescriptorSets) { vkUpdateDescriptorSets(device, (UInt32)writeDescriptorSets.Length, pointer, 0, null); } }
public unsafe void UpdateSampledImages(List <ImageView> views, List <Sampler> samplers) { if (views.Count != _descriptorPool.Layout.Bindings.Count) { throw new InvalidOperationException("views length should match descriptor layout bindings"); } if (samplers.Count != _descriptorPool.Layout.Bindings.Count) { throw new InvalidOperationException("samplers length should match descriptor layout bindings"); } var descriptorImageInfos = new NativeList <VkDescriptorImageInfo>(); var writeDescriptorSets = new NativeList <VkWriteDescriptorSet>(); for (int i = 0; i < _descriptorPool.Layout.Bindings.Count; i++) { var binding = _descriptorPool.Layout.Bindings[i]; var descriptorImageInfo = new VkDescriptorImageInfo { imageLayout = views[i].Image.Layout.First(), imageView = views[i].Handle, sampler = samplers[i].Handle }; var writeDescriptorSet = new VkWriteDescriptorSet { sType = VkStructureType.WriteDescriptorSet, dstSet = _handle, dstBinding = binding.Index, dstArrayElement = 0, descriptorCount = binding.DescriptorCounts, descriptorType = binding.DescriptorType, pImageInfo = &descriptorImageInfo }; descriptorImageInfos.Add(descriptorImageInfo); writeDescriptorSets.Add(writeDescriptorSet); } VulkanNative.vkUpdateDescriptorSets( _device.Handle, writeDescriptorSets.Count, (VkWriteDescriptorSet *)writeDescriptorSets.Data.ToPointer(), 0, null ); }
void setupDescriptorSet() { VkDescriptorSetAllocateInfo allocInfo = VkDescriptorSetAllocateInfo.New(); allocInfo.descriptorPool = descriptorPool; allocInfo.pSetLayouts = (VkDescriptorSetLayout *)descriptorSetLayout.Data.ToPointer(); allocInfo.descriptorSetCount = 1; Util.CheckResult(vkAllocateDescriptorSets(Device, &allocInfo, out descriptorSet)); var descriptor = uniformBuffer.descriptor; VkWriteDescriptorSet writeDescriptorSets = Initializers.writeDescriptorSet( descriptorSet, VkDescriptorType.UniformBuffer, 0, &descriptor); vkUpdateDescriptorSets(Device, 1, ref writeDescriptorSets, 0, null); }
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); } }
/// <summary> /// execute the descriptors writes targeting descriptorSets setted on AddWriteInfo call /// </summary> public void Push(PrimaryCommandBuffer cmd, PipelineLayout plLayout, params object[] descriptors) { using (PinnedObjects pinCtx = new PinnedObjects()) { int i = 0; int wdsPtr = 0; while (i < descriptors.Length) { int firstDescriptor = i; VkWriteDescriptorSet wds = WriteDescriptorSets[wdsPtr]; wds.dstSet = 0; IntPtr pDescriptors = IntPtr.Zero; if (wds.descriptorCount > 1) { List <IntPtr> descPtrArray = new List <IntPtr> (); for (int d = 0; d < wds.descriptorCount; d++) { descPtrArray.Add(descriptors[i].Pin(pinCtx)); i++; } pDescriptors = descPtrArray.Pin(pinCtx); } else { pDescriptors = descriptors[i].Pin(pinCtx); i++; } if (descriptors[firstDescriptor] is VkDescriptorBufferInfo) { wds.pBufferInfo = pDescriptors; } else if (descriptors[firstDescriptor] is VkDescriptorImageInfo) { wds.pImageInfo = pDescriptors; } WriteDescriptorSets[wdsPtr] = wds; wdsPtr++; } vkCmdPushDescriptorSetKHR(cmd.Handle, VkPipelineBindPoint.Graphics, plLayout.handle, 0, (uint)WriteDescriptorSets.Count, WriteDescriptorSets.Pin(pinCtx)); } }
private void UpdateUniformData(FDataBuffer <float> uniformBuffer, uint swapchainImageIndex) { VkDescriptorBufferInfo bufferInfo = new VkDescriptorBufferInfo(); bufferInfo.buffer = uniformBuffer.Buffer; bufferInfo.offset = 0; bufferInfo.range = (uint)uniformBuffer.Length * 4; VkWriteDescriptorSet[] writes = new VkWriteDescriptorSet[1]; writes[0].dstSet = descriptorSets[swapchainImageIndex]; writes[0].dstBinding = 1; writes[0].dstArrayElement = 0; writes[0].descriptorType = VkDescriptorType.UniformBuffer; writes[0].descriptorCount = 1; writes[0].pBufferInfo = &bufferInfo; fixed(VkWriteDescriptorSet *ptr = writes) vkUpdateDescriptorSets(device, (uint)writes.Length, ptr, 0, null); }
public unsafe void UpdateBuffers(List <Buffer> buffers) { if (buffers.Count != _descriptorPool.Layout.Bindings.Count) { throw new InvalidOperationException("buffers length should match descriptor layout bindings"); } var descriptorSetBufferInfos = new NativeList <VkDescriptorBufferInfo>(); var writeDescriptorSets = new NativeList <VkWriteDescriptorSet>(); for (int i = 0; i < _descriptorPool.Layout.Bindings.Count; i++) { var binding = _descriptorPool.Layout.Bindings[i]; var descriptorSetBufferInfo = new VkDescriptorBufferInfo { buffer = buffers[i].Handle, offset = 0, range = buffers[i].Size }; var writeDescriptorSet = new VkWriteDescriptorSet { sType = VkStructureType.WriteDescriptorSet, dstSet = _handle, dstBinding = binding.Index, dstArrayElement = 0, descriptorCount = binding.DescriptorCounts, descriptorType = binding.DescriptorType, pBufferInfo = &descriptorSetBufferInfo, }; descriptorSetBufferInfos.Add(descriptorSetBufferInfo); writeDescriptorSets.Add(writeDescriptorSet); } VulkanNative.vkUpdateDescriptorSets( _device.Handle, writeDescriptorSets.Count, (VkWriteDescriptorSet *)writeDescriptorSets.Data.ToPointer(), 0, null ); }
public void Set(uint binding, uint idx, GpuBufferView buf) { unsafe { IntPtr p_l = buf.hndl; var desc_write = new VkWriteDescriptorSet() { sType = VkStructureType.StructureTypeWriteDescriptorSet, dstSet = hndl, dstBinding = binding, dstArrayElement = idx, descriptorCount = 1, pImageInfo = IntPtr.Zero, pBufferInfo = buf.parent.hndl, pTexelBufferView = &p_l, descriptorType = (VkDescriptorType)Layout.Layouts[(int)binding].Type }; vkUpdateDescriptorSets(GraphicsDevice.GetDeviceInfo(devID).Device, 1, desc_write.Pointer(), 0, null); } }
void setupDescriptorSet() { var dsl = descriptorSetLayout; VkDescriptorSetAllocateInfo allocInfo = Initializers.descriptorSetAllocateInfo( descriptorPool, &dsl, 1); Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSet)); var descriptor = uniformBuffer.descriptor; // Binding 0 : Vertex shader uniform buffer VkWriteDescriptorSet writeDescriptorSet = Initializers.writeDescriptorSet( descriptorSet, VkDescriptorType.UniformBuffer, 0, &descriptor); vkUpdateDescriptorSets(device, 1, &writeDescriptorSet, 0, null); }
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); }
/// <inheritdoc cref="Draw(GraphicsPrimitive)" /> public void Draw(VulkanGraphicsPrimitive graphicsPrimitive) { ThrowIfNull(graphicsPrimitive, nameof(graphicsPrimitive)); var graphicsCommandBuffer = VulkanCommandBuffer; var graphicsPipeline = graphicsPrimitive.VulkanGraphicsPipeline; var graphicsPipelineSignature = graphicsPipeline.VulkanSignature; var vulkanPipeline = graphicsPipeline.VulkanPipeline; var vertexBuffer = graphicsPrimitive.VulkanVertexBuffer; var vulkanVertexBuffer = vertexBuffer.VulkanBuffer; var vulkanVertexBufferOffset = 0ul; vkCmdBindPipeline(graphicsCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vulkanPipeline); vkCmdBindVertexBuffers(graphicsCommandBuffer, firstBinding: 0, bindingCount: 1, (ulong *)&vulkanVertexBuffer, &vulkanVertexBufferOffset); var vulkanDescriptorSet = graphicsPipelineSignature.VulkanDescriptorSet; if (vulkanDescriptorSet != VK_NULL_HANDLE) { var inputResources = graphicsPrimitive.InputResources; var inputResourcesLength = inputResources.Length; for (var index = 0; index < inputResourcesLength; index++) { var inputResource = inputResources[index]; VkWriteDescriptorSet writeDescriptorSet; if (inputResource is VulkanGraphicsBuffer vulkanGraphicsBuffer) { var descriptorBufferInfo = new VkDescriptorBufferInfo { buffer = vulkanGraphicsBuffer.VulkanBuffer, offset = 0, range = vulkanGraphicsBuffer.Size, }; writeDescriptorSet = new VkWriteDescriptorSet { sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = vulkanDescriptorSet, dstBinding = unchecked ((uint)index), descriptorCount = 1, descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, pBufferInfo = &descriptorBufferInfo, }; } else if (inputResource is VulkanGraphicsTexture vulkanGraphicsTexture) { var descriptorImageInfo = new VkDescriptorImageInfo { sampler = vulkanGraphicsTexture.VulkanSampler, imageView = vulkanGraphicsTexture.VulkanImageView, imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, }; writeDescriptorSet = new VkWriteDescriptorSet { sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = vulkanDescriptorSet, dstBinding = unchecked ((uint)index), descriptorCount = 1, descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, pImageInfo = &descriptorImageInfo, }; } vkUpdateDescriptorSets(VulkanGraphicsDevice.VulkanDevice, 1, &writeDescriptorSet, 0, pDescriptorCopies: null); } vkCmdBindDescriptorSets(graphicsCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipelineSignature.VulkanPipelineLayout, firstSet: 0, 1, (ulong *)&vulkanDescriptorSet, dynamicOffsetCount: 0, pDynamicOffsets: null); } var indexBuffer = graphicsPrimitive.VulkanIndexBuffer; if (indexBuffer != null) { var indexBufferStride = indexBuffer.Stride; var indexType = VK_INDEX_TYPE_UINT16; if (indexBufferStride != 2) { Assert(indexBufferStride == 4, "Index Buffer has an unsupported stride."); indexType = VK_INDEX_TYPE_UINT32; } vkCmdBindIndexBuffer(graphicsCommandBuffer, indexBuffer.VulkanBuffer, offset: 0, indexType); vkCmdDrawIndexed(graphicsCommandBuffer, indexCount: (uint)(indexBuffer.Size / indexBufferStride), instanceCount: 1, firstIndex: 0, vertexOffset: 0, firstInstance: 0); } else { vkCmdDraw(graphicsCommandBuffer, vertexCount: (uint)(vertexBuffer.Size / vertexBuffer.Stride), instanceCount: 1, firstVertex: 0, firstInstance: 0); } }
public static void vkUpdateDescriptorSets(VkDevice device, VkWriteDescriptorSet writeDescriptorSet, VkCopyDescriptorSet copyDescriptorSet) { vkUpdateDescriptorSets(device, 1, &writeDescriptorSet, 1, ©DescriptorSet); }
public FGraphicsPipeline(VkDevice device, VkPhysicalDevice physicalDevice, VkPipelineCache pipelineCache, VkRenderPass renderPass, string shaderPath, uint swapchainImageCount, FTexture textureArray) { this.device = device; this.swapchainImageCount = swapchainImageCount; this.renderPass = renderPass; desclayout = CreateDescriptorLayout(device, 1); descriptorPool = CreateDescriptorPool(device, swapchainImageCount, 7); descriptorSets = AllocateDescriptorSets(device, desclayout, descriptorPool, swapchainImageCount); sampler = CreateSampler(device, textureArray.MipLevels); for (int i = 0; i < swapchainImageCount; i++) { VkDescriptorImageInfo imageInfo = new VkDescriptorImageInfo(); imageInfo.imageLayout = VkImageLayout.ShaderReadOnlyOptimal; imageInfo.imageView = textureArray.imageView; imageInfo.sampler = sampler; VkWriteDescriptorSet[] writes = new VkWriteDescriptorSet[1]; writes[0].dstSet = descriptorSets[i]; writes[0].dstBinding = 0; writes[0].dstArrayElement = 0; writes[0].descriptorType = VkDescriptorType.CombinedImageSampler; writes[0].descriptorCount = 1; writes[0].pImageInfo = &imageInfo; fixed(VkWriteDescriptorSet *ptr = writes) vkUpdateDescriptorSets(device, (uint)writes.Length, ptr, 0, null); } uniformdata = CreateUniformBuffer(device, physicalDevice, 1); VkShaderModule vs = LoadShader(device, $"{shaderPath}.vert.spv"); VkShaderModule fs = LoadShader(device, $"{shaderPath}.frag.spv"); VkGraphicsPipelineCreateInfo pCreateInfo = VkGraphicsPipelineCreateInfo.New(); pCreateInfo.flags = VkPipelineCreateFlags.DisableOptimization; VkPipelineShaderStageCreateInfo[] shaderStages = new VkPipelineShaderStageCreateInfo[2]; shaderStages[0] = VkPipelineShaderStageCreateInfo.New(); shaderStages[0].stage = VkShaderStageFlags.Vertex; shaderStages[0].module = vs; byte[] vsFuncName = Encoding.UTF8.GetBytes("main" + char.MinValue); fixed(byte *ptr = &(vsFuncName[0])) shaderStages[0].pName = ptr; shaderStages[1] = VkPipelineShaderStageCreateInfo.New(); shaderStages[1].stage = VkShaderStageFlags.Fragment; shaderStages[1].module = fs; byte[] fsFuncName = Encoding.UTF8.GetBytes("main" + char.MinValue); fixed(byte *ptr = &(fsFuncName[0])) shaderStages[1].pName = ptr; fixed(VkPipelineShaderStageCreateInfo *ptr = shaderStages) pCreateInfo.pStages = ptr; pCreateInfo.stageCount = 2; VkVertexInputBindingDescription[] bindings = new VkVertexInputBindingDescription[4]; bindings[0] = new VkVertexInputBindingDescription(); bindings[0].binding = 0; bindings[0].stride = (uint)sizeof(VoxelRenderer.VoxelVertex); bindings[0].inputRate = VkVertexInputRate.Vertex; bindings[1] = new VkVertexInputBindingDescription(); bindings[1].binding = 1; bindings[1].stride = (uint)sizeof(VoxelRenderer.VoxelVertex); bindings[1].inputRate = VkVertexInputRate.Vertex; bindings[2] = new VkVertexInputBindingDescription(); bindings[2].binding = 2; bindings[2].stride = (uint)sizeof(VoxelRenderer.VoxelVertex); bindings[2].inputRate = VkVertexInputRate.Vertex; bindings[3] = new VkVertexInputBindingDescription(); bindings[3].binding = 3; bindings[3].stride = (uint)sizeof(VoxelRenderer.VoxelVertex); bindings[3].inputRate = VkVertexInputRate.Vertex; VkVertexInputAttributeDescription[] attribs = new VkVertexInputAttributeDescription[4]; attribs[0].binding = 0; attribs[0].location = 0; attribs[0].format = VkFormat.R32g32b32Sfloat; attribs[0].offset = 0; attribs[1].binding = 1; attribs[1].location = 1; attribs[1].format = VkFormat.R32g32b32Sfloat; attribs[1].offset = 0; attribs[2].binding = 2; attribs[2].location = 2; attribs[2].format = VkFormat.R32g32b32Sfloat; attribs[2].offset = 0; attribs[3].binding = 3; attribs[3].location = 3; attribs[3].format = VkFormat.R32Uint; attribs[3].offset = 0; VkPipelineVertexInputStateCreateInfo vertexInput = VkPipelineVertexInputStateCreateInfo.New(); fixed(VkVertexInputBindingDescription *ptr = bindings) vertexInput.pVertexBindingDescriptions = ptr; vertexInput.vertexBindingDescriptionCount = (uint)bindings.Length; fixed(VkVertexInputAttributeDescription *ptr = attribs) vertexInput.pVertexAttributeDescriptions = ptr; vertexInput.vertexAttributeDescriptionCount = (uint)attribs.Length; pCreateInfo.pVertexInputState = &vertexInput; VkPipelineInputAssemblyStateCreateInfo inputAssembly = VkPipelineInputAssemblyStateCreateInfo.New(); inputAssembly.topology = VkPrimitiveTopology.TriangleList; pCreateInfo.pInputAssemblyState = &inputAssembly; VkPipelineViewportStateCreateInfo viewportState = VkPipelineViewportStateCreateInfo.New(); viewportState.viewportCount = 1; viewportState.scissorCount = 1; pCreateInfo.pViewportState = &viewportState; VkPipelineRasterizationStateCreateInfo rasterizationState = VkPipelineRasterizationStateCreateInfo.New(); rasterizationState.lineWidth = 1; rasterizationState.frontFace = VkFrontFace.Clockwise; rasterizationState.cullMode = VkCullModeFlags.Back; rasterizationState.polygonMode = VkPolygonMode.Fill;//TODO add line debug render pCreateInfo.pRasterizationState = &rasterizationState; VkPipelineMultisampleStateCreateInfo multisampleState = VkPipelineMultisampleStateCreateInfo.New(); multisampleState.rasterizationSamples = VkSampleCountFlags.Count1; pCreateInfo.pMultisampleState = &multisampleState; VkPipelineDepthStencilStateCreateInfo depthState = VkPipelineDepthStencilStateCreateInfo.New(); depthState.depthTestEnable = VkBool32.True; depthState.depthWriteEnable = VkBool32.True; depthState.depthCompareOp = VkCompareOp.Less; pCreateInfo.pDepthStencilState = &depthState; VkPipelineColorBlendAttachmentState colourAttachment = new VkPipelineColorBlendAttachmentState(); colourAttachment.colorWriteMask = VkColorComponentFlags.R | VkColorComponentFlags.G | VkColorComponentFlags.B | VkColorComponentFlags.A; VkPipelineColorBlendStateCreateInfo colourState = VkPipelineColorBlendStateCreateInfo.New(); colourState.pAttachments = &colourAttachment; colourState.attachmentCount = 1; pCreateInfo.pColorBlendState = &colourState; VkDynamicState[] dynamicStates = new VkDynamicState[2]; dynamicStates[0] = VkDynamicState.Viewport; dynamicStates[1] = VkDynamicState.Scissor; VkPipelineDynamicStateCreateInfo dynamicState = VkPipelineDynamicStateCreateInfo.New(); dynamicState.dynamicStateCount = (uint)dynamicStates.Length; fixed(VkDynamicState *ptr = &(dynamicStates[0])) dynamicState.pDynamicStates = ptr; pCreateInfo.pDynamicState = &dynamicState; this.pipelineLayout = CreatePipelineLayout(device, desclayout); pCreateInfo.layout = this.pipelineLayout; pCreateInfo.renderPass = renderPass; pCreateInfo.subpass = 0; VkPipeline pipeline = VkPipeline.Null; Assert(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pCreateInfo, null, &pipeline)); this.pipeline = pipeline; }
private VkDescriptorSet CreateNewDescriptorSet(ref VkDescriptorSetCacheKey cacheKey) { { VkDescriptorSetAllocateInfo descriptorSetAI = VkDescriptorSetAllocateInfo.New(); descriptorSetAI.descriptorPool = _descriptorPool; descriptorSetAI.descriptorSetCount = 1; VkDescriptorSetLayout layout = cacheKey.ShaderResourceBindingSlots.DescriptorSetLayout; descriptorSetAI.pSetLayouts = &layout; VkResult result = vkAllocateDescriptorSets(_device, ref descriptorSetAI, out VkDescriptorSet descriptorSet); CheckResult(result); int resourceCount = cacheKey.ShaderResourceBindingSlots.Resources.Length; VkWriteDescriptorSet[] descriptorWrites = new VkWriteDescriptorSet[resourceCount]; VkDescriptorBufferInfo *bufferInfos = stackalloc VkDescriptorBufferInfo[resourceCount]; // TODO: Fix this. VkDescriptorImageInfo * imageInfos = stackalloc VkDescriptorImageInfo[resourceCount]; // TODO: Fix this. for (uint binding = 0; binding < resourceCount; binding++) { descriptorWrites[binding].sType = VkStructureType.WriteDescriptorSet; descriptorWrites[binding].descriptorCount = 1; descriptorWrites[binding].dstBinding = binding; descriptorWrites[binding].dstSet = descriptorSet; ShaderResourceDescription resource = cacheKey.ShaderResourceBindingSlots.Resources[binding]; switch (resource.Type) { case ShaderResourceType.ConstantBuffer: { descriptorWrites[binding].descriptorType = VkDescriptorType.UniformBuffer; VkConstantBuffer cb = cacheKey.ConstantBuffers[binding]; if (cb == null) { throw new VeldridException($"No constant buffer bound to required binding slot {binding}."); } VkDescriptorBufferInfo *cbInfo = &bufferInfos[binding]; cbInfo->buffer = cb.DeviceBuffer; cbInfo->offset = 0; cbInfo->range = (ulong)resource.DataSizeInBytes; descriptorWrites[binding].pBufferInfo = cbInfo; break; } case ShaderResourceType.Texture: { descriptorWrites[binding].descriptorType = VkDescriptorType.SampledImage; VkShaderTextureBinding textureBinding = cacheKey.TextureBindings[binding]; if (textureBinding == null) { throw new VeldridException($"No texture bound to required binding slot {binding}."); } VkDescriptorImageInfo *imageInfo = &imageInfos[binding]; imageInfo->imageLayout = textureBinding.ImageLayout; imageInfo->imageView = textureBinding.ImageView; descriptorWrites[binding].pImageInfo = imageInfo; } break; case ShaderResourceType.Sampler: { descriptorWrites[binding].descriptorType = VkDescriptorType.Sampler; VkSamplerState samplerState = cacheKey.SamplerStates[binding] ?? (VkSamplerState)_defaultSamplerState; VkDescriptorImageInfo *imageInfo = &imageInfos[binding]; imageInfo->sampler = samplerState.Sampler; descriptorWrites[binding].pImageInfo = imageInfo; } break; default: throw Illegal.Value <ShaderResourceType>(); } } vkUpdateDescriptorSets(_device, (uint)resourceCount, ref descriptorWrites[0], 0, null); return(descriptorSet); } }
public static void vkUpdateDescriptorSets(VkDevice device, VkWriteDescriptorSet writeDescriptorSet) { vkUpdateDescriptorSets(device, 1, &writeDescriptorSet, 0, null); }
void setupDescriptorSet() { var dsl = descriptorSetLayouts_textured; // Mirror plane descriptor set VkDescriptorSetAllocateInfo allocInfo = Initializers.descriptorSetAllocateInfo( descriptorPool, &dsl, 1); Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_mirror)); var descriptor0 = uniformBuffers_vsMirror.descriptor; var descriptor1 = offscreenPass.descriptor; var descriptor2 = textures_colorMap.descriptor; FixedArray3<VkWriteDescriptorSet> writeDescriptorSets = new FixedArray3<VkWriteDescriptorSet>( // Binding 0 : Vertex shader uniform buffer Initializers.writeDescriptorSet( descriptorSets_mirror, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &descriptor0), // Binding 1 : Fragment shader texture sampler Initializers.writeDescriptorSet( descriptorSets_mirror, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &descriptor1), // Binding 2 : Fragment shader texture sampler Initializers.writeDescriptorSet( descriptorSets_mirror, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2, &descriptor2)); vkUpdateDescriptorSets(device, writeDescriptorSets.Count, &writeDescriptorSets.First, 0, null); // Debug quad Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_debugQuad)); var descriptor3 = uniformBuffers_vsDebugQuad.descriptor; var descriptor4 = offscreenPass.descriptor; FixedArray2<VkWriteDescriptorSet> debugQuadWriteDescriptorSets = new FixedArray2<VkWriteDescriptorSet>( // Binding 0 : Vertex shader uniform buffer Initializers.writeDescriptorSet( descriptorSets_debugQuad, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &descriptor3), // Binding 1 : Fragment shader texture sampler Initializers.writeDescriptorSet( descriptorSets_debugQuad, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &descriptor4)); vkUpdateDescriptorSets(device, debugQuadWriteDescriptorSets.Count, &debugQuadWriteDescriptorSets.First, 0, null); var dsls_shaded = descriptorSetLayouts_shaded; // Shaded descriptor sets allocInfo.pSetLayouts = &dsls_shaded; // Model // No texture Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_model)); var descriptor5 = uniformBuffers_vsShared.descriptor; VkWriteDescriptorSet modelWriteDescriptorSets = // Binding 0 : Vertex shader uniform buffer Initializers.writeDescriptorSet( descriptorSets_model, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &descriptor5); vkUpdateDescriptorSets(device, 1, &modelWriteDescriptorSets, 0, null); // Offscreen Util.CheckResult(vkAllocateDescriptorSets(device, &allocInfo, out descriptorSets_offscreen)); var descriptor6 = uniformBuffers_vsOffScreen.descriptor; VkWriteDescriptorSet offScreenWriteDescriptorSets = // Binding 0 : Vertex shader uniform buffer Initializers.writeDescriptorSet( descriptorSets_offscreen, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &descriptor6); vkUpdateDescriptorSets(device, 1, &offScreenWriteDescriptorSets, 0, null); }