void SetupDescriptorSet(Pipeline pipeline, GraphicsDevice device, UniformBuffer uniformBuffer, Texture2D texture_colorMap)
{
var dsl = pipeline.descriptorSetLayout;
VkDescriptorSetAllocateInfo allocInfo =
Initializers.descriptorSetAllocateInfo(
pipeline.descriptorPool,
&dsl,
1);
Util.CheckResult(vkAllocateDescriptorSets(device.device, &allocInfo, out pipeline.descriptorSet));
VkDescriptorImageInfo texDescriptor =
Initializers.descriptorImageInfo(
texture_colorMap.sampler,
texture_colorMap.view,
VkImageLayout.General);
VkDescriptorBufferInfo temp = uniformBuffer.GetVkDescriptor();
FixedArray2 <VkWriteDescriptorSet> writeDescriptorSets = new FixedArray2 <VkWriteDescriptorSet>(
// Binding 0 : Vertex shader uniform buffer
Initializers.writeDescriptorSet(
pipeline.descriptorSet,
VkDescriptorType.UniformBuffer,
uniformBuffer.location,
&temp),
// Binding 1 : Color map
Initializers.writeDescriptorSet(
pipeline.descriptorSet,
VkDescriptorType.CombinedImageSampler,
1,
&texDescriptor));
vkUpdateDescriptorSets(device.device, (writeDescriptorSets.Count), ref writeDescriptorSets.First, 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);
}
}
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);
}
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
);
}
void CreateDescriptorSet()
{
var layouts = new List <VkDescriptorSetLayout> {
descriptorSetLayout
};
var info = new VkDescriptorSetAllocateInfo();
info.setLayouts = layouts;
descriptorSet = descriptorPool.Allocate(info)[0];
var bufferInfo = new VkDescriptorBufferInfo();
bufferInfo.buffer = uniformBuffer;
bufferInfo.offset = 0;
bufferInfo.range = Interop.SizeOf <UniformBufferObject>();
var descriptorWrites = new List <VkWriteDescriptorSet>();
descriptorWrites.Add(new VkWriteDescriptorSet());
descriptorWrites[0].dstSet = descriptorSet;
descriptorWrites[0].dstBinding = 0;
descriptorWrites[0].dstArrayElement = 0;
descriptorWrites[0].descriptorType = VkDescriptorType.UniformBuffer;
descriptorWrites[0].bufferInfo = new List <VkDescriptorBufferInfo> {
bufferInfo
};
descriptorSet.Update(descriptorWrites, null);
}
public VkDescriptorBufferInfo GetVkDescriptor()
{
VkDescriptorBufferInfo bufferInfo = new VkDescriptorBufferInfo();
bufferInfo.buffer = vkBuffer;
bufferInfo.offset = 0;
bufferInfo.range = size;
return(bufferInfo);
}
private DescriptorSet Bind(uint dstBinding, ref VkDescriptorBufferInfo bufferInfo, BufferView bufferView)
{
var descriptorType = resourceLayout.Bindings[(int)dstBinding].descriptorType;
for (int img = 0; img < Swapchain.IMAGE_COUNT; img++)
{
AddWriteDescriptorSet(img, new VkWriteDescriptorSet(dstBinding, descriptorSet[img], descriptorType, ref bufferInfo, ref bufferView.HandleRef));
}
return(this);
}
private void PrepareDescriptor(VkDevice device)
{
// 定数バッファを１つだけ持つものを作る.
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);
// ディスクリプタセットレイアウトの作成.
// 今は定数バッファを１つ持つだけのものを作成.
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];
// ディスクリプタを更新.
// 定数バッファ１つを持つレイアウトでディスクリプタを作る.
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);
}
public unsafe VkWriteDescriptorSet(uint binding, VkDescriptorSet dstSet, VkDescriptorType type,
ref VkDescriptorBufferInfo bufferInfo, uint descriptorCount = 1)
{
this.sType = VkStructureType.WriteDescriptorSet;
this.pNext = null;
this.dstSet = dstSet;
this.descriptorType = type;
this.dstBinding = binding;
this.pBufferInfo = (VkDescriptorBufferInfo *)Unsafe.AsPointer(ref bufferInfo);
this.descriptorCount = descriptorCount;
this.pImageInfo = null;
this.pTexelBufferView = null;
this.dstArrayElement = 0;
}
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();
}
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);
}
}
void CreateDescriptorSet()
{
var layouts = new List <VkDescriptorSetLayout> {
descriptorSetLayout
};
var info = new VkDescriptorSetAllocateInfo();
info.setLayouts = layouts;
descriptorSet = descriptorPool.Allocate(info)[0];
var bufferInfo = new VkDescriptorBufferInfo();
bufferInfo.buffer = uniformBuffer;
bufferInfo.offset = 0;
bufferInfo.range = Interop.SizeOf <UniformBufferObject>();
var imageInfo = new VkDescriptorImageInfo();
imageInfo.imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
imageInfo.imageView = textureImageView;
imageInfo.sampler = textureSampler;
var descriptorWrites = new List <VkWriteDescriptorSet>();
descriptorWrites.Add(new VkWriteDescriptorSet());
descriptorWrites[0].dstSet = descriptorSet;
descriptorWrites[0].dstBinding = 0;
descriptorWrites[0].dstArrayElement = 0;
descriptorWrites[0].descriptorType = VkDescriptorType.UniformBuffer;
descriptorWrites[0].bufferInfo = new List <VkDescriptorBufferInfo> {
bufferInfo
};
descriptorWrites.Add(new VkWriteDescriptorSet());
descriptorWrites[1].dstSet = descriptorSet;
descriptorWrites[1].dstBinding = 1;
descriptorWrites[1].dstArrayElement = 0;
descriptorWrites[1].descriptorType = VkDescriptorType.CombinedImageSampler;
descriptorWrites[1].imageInfo = new List <VkDescriptorImageInfo> {
imageInfo
};
descriptorSet.Update(descriptorWrites, 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);
}
}
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
);
}
private void PrepareDescriptor(VkDevice device)
{
// 今は定数バッファを１つを格納できるだけのディスクリプタプールを準備.
var descriptorPoolSize = new VkDescriptorPoolSize()
{
descriptorCount = 1,
type = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
};
m_descriptorPool = m_resourceManager.CreateDescriptorPool(device, new[] { descriptorPoolSize }, 1);
// ディスクリプタセットレイアウトの作成.
// - 定数バッファを１つ
var descLayoutBinding = new VkDescriptorSetLayoutBinding()
{
binding = 0,
descriptorCount = 1,
descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
stageFlags = VkShaderStageFlagBits.VK_SHADER_STAGE_VERTEX_BIT
};
m_descriptorSetLayout = m_resourceManager.CreateDescriptorSetLayout(device, new[] { descLayoutBinding });
// ディスクリプタを作成＆更新.
VkDescriptorSet[] descriptorSets;
var descriptorSetAllocateInfo = new VkDescriptorSetAllocateInfo(m_descriptorPool, new[] { m_descriptorSetLayout });
VulkanAPI.vkAllocateDescriptorSets(device, ref descriptorSetAllocateInfo, out descriptorSets);
m_descriptorSet = descriptorSets[0];
var descUniform = new VkDescriptorBufferInfo()
{
buffer = m_uniformBuffer,
range = Marshal.SizeOf <Transform>(),
};
var descForUniform = SampleHelpers.CreateDescriptorFromUniformBuffer(0, descUniform, m_descriptorSet);
var descriptorWrites = new[] { descForUniform };
VulkanAPI.vkUpdateDescriptorSets(device, descriptorWrites, 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);
}
private void PrepareDescriptor(VkDevice device)
{
// 今は定数バッファを１つ、サンプラーを１つを格納できるだけのディスクリプタプールを準備.
VkDescriptorPoolSize descriptorPoolSize = new VkDescriptorPoolSize()
{
descriptorCount = 1,
type = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
};
VkDescriptorPoolSize descriptorPoolSizeForSampler = new VkDescriptorPoolSize()
{
descriptorCount = 1,
type = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
};
var descriptorPoolCreateInfo = new VkDescriptorPoolCreateInfo()
{
poolSizes = new[] { descriptorPoolSize, descriptorPoolSizeForSampler },
maxSets = 1,
flags = VkDescriptorPoolCreateFlags.VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
};
VulkanAPI.vkCreateDescriptorPool(device, ref descriptorPoolCreateInfo, out m_descriptorPool);
// ディスクリプタセットレイアウトの作成.
// - 定数バッファを１つ
// - テクスチャサンプラ１つ
var descLayoutBindingForUniform = new VkDescriptorSetLayoutBinding();
descLayoutBindingForUniform.binding = 0;
descLayoutBindingForUniform.descriptorCount = 1;
descLayoutBindingForUniform.descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descLayoutBindingForUniform.stageFlags = VkShaderStageFlagBits.VK_SHADER_STAGE_VERTEX_BIT;
var descLayoutBindingForSampler = new VkDescriptorSetLayoutBinding();
descLayoutBindingForSampler.binding = 1;
descLayoutBindingForSampler.descriptorCount = 1;
descLayoutBindingForSampler.descriptorType = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
descLayoutBindingForSampler.stageFlags = VkShaderStageFlagBits.VK_SHADER_STAGE_FRAGMENT_BIT;
var descriptorSetLayoutCreateInfo = new VkDescriptorSetLayoutCreateInfo();
descriptorSetLayoutCreateInfo.bindings = new[] {
descLayoutBindingForUniform,
descLayoutBindingForSampler
};
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];
var descUniform = new VkDescriptorBufferInfo()
{
buffer = m_uniformBuffer,
range = Marshal.SizeOf <Transform>(),
};
var descSampler = new VkDescriptorImageInfo()
{
imageView = m_imageView,
sampler = m_imageSampler,
};
var descForUniform = SampleHelpers.CreateDescriptorFromUniformBuffer(0, descUniform, m_descriptorSet);
var descForSampler = SampleHelpers.CreateDescriptorFromImageSampler(1, descSampler, m_descriptorSet);
var descriptorWrites = new[] { descForUniform, descForSampler };
VulkanAPI.vkUpdateDescriptorSets(device, descriptorWrites, null);
}
private VkDescriptorSet CreateDescriptorSet(VkDescriptorPool descriptorPool)
{
VkDescriptorSetLayout layout = _descriptorSetLayout;
var allocInfo = new VkDescriptorSetAllocateInfo
{
sType = VkStructureType.DescriptorSetAllocateInfo,
pNext = null,
descriptorPool = descriptorPool,
descriptorSetCount = 1,
pSetLayouts = &layout
};
VkDescriptorSet descriptorSet;
vkAllocateDescriptorSets(Context.Device, &allocInfo, &descriptorSet);
VkBuffer uniformBuffer = _uniformBuffer.Buffer;
// Update the descriptor set for the shader binding point.
VkDescriptorBufferInfo bufferInfo1 = new VkDescriptorBufferInfo
{
buffer = _uniformBuffer.Buffer,
offset = 0,
range = ulong.MaxValue
};
VkDescriptorBufferInfo bufferInfo = new VkDescriptorBufferInfo
{
buffer = _uniformBuffer.Buffer,
offset = 0,
range = ulong.MaxValue
};
VkDescriptorImageInfo imageInfo = new VkDescriptorImageInfo
{
sampler = _sampler,
imageView = _cubeTexture.View,
imageLayout = VkImageLayout.ShaderReadOnlyOptimal
};
VkWriteDescriptorSet *writeDescriptorSetsPtr = stackalloc VkWriteDescriptorSet[2]
{
new VkWriteDescriptorSet
{
sType = VkStructureType.WriteDescriptorSet,
pNext = null,
dstBinding = 0,
descriptorCount = 1,
descriptorType = VkDescriptorType.UniformBuffer,
pBufferInfo = &bufferInfo,
dstSet = descriptorSet
},
new VkWriteDescriptorSet
{
sType = VkStructureType.WriteDescriptorSet,
pNext = null,
dstBinding = 1,
descriptorCount = 1,
descriptorType = VkDescriptorType.CombinedImageSampler,
pImageInfo = &imageInfo,
dstSet = descriptorSet,
}
};
vkUpdateDescriptorSets(Context.Device, 2, writeDescriptorSetsPtr, 0, null);
return(descriptorSet);
}
/// <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 Update(Device device, List <WriteDescriptorSet> writes)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
int totalBuffers = 0;
int totalImages = 0;
int totalBufferViews = 0;
for (int i = 0; i < writes.Count; i++)
{
var write = writes[i];
if (write.bufferInfo != null)
{
totalBuffers += write.bufferInfo.Count;
}
if (write.imageInfo != null)
{
totalImages += write.imageInfo.Count;
}
if (write.texelBufferView != null)
{
totalBufferViews += write.texelBufferView.Count;
}
}
unsafe
{
var bufferInfos = stackalloc VkDescriptorBufferInfo[totalBuffers];
var imageInfos = stackalloc VkDescriptorImageInfo[totalImages];
var bufferViews = stackalloc VkBufferView[totalBufferViews];
int bufferIndex = 0;
int imageIndex = 0;
int bufferViewIndex = 0;
var writesNative = stackalloc VkWriteDescriptorSet[writes.Count];
for (int i = 0; i < writes.Count; i++)
{
var mWrite = writes[i];
writesNative[i].sType = VkStructureType.WriteDescriptorSet;
writesNative[i].dstSet = mWrite.dstSet.Native;
writesNative[i].dstBinding = mWrite.dstBinding;
writesNative[i].dstArrayElement = mWrite.dstArrayElement;
writesNative[i].descriptorType = mWrite.descriptorType;
if (mWrite.bufferInfo != null)
{
writesNative[i].descriptorCount = (uint)mWrite.bufferInfo.Count;
writesNative[i].pBufferInfo = (IntPtr)(&bufferInfos[bufferViewIndex]);
for (int j = 0; j < writesNative[i].descriptorCount; j++)
{
VkDescriptorBufferInfo bufferInfo = new VkDescriptorBufferInfo();
bufferInfo.buffer = mWrite.bufferInfo[j].buffer.Native;
bufferInfo.offset = mWrite.bufferInfo[j].offset;
bufferInfo.range = mWrite.bufferInfo[j].range;
bufferInfos[bufferIndex] = bufferInfo;
bufferIndex++;
}
}
else if (mWrite.imageInfo != null)
{
writesNative[i].descriptorCount = (uint)mWrite.imageInfo.Count;
writesNative[i].pImageInfo = (IntPtr)(&imageInfos[imageIndex]);
for (int j = 0; j < writesNative[i].descriptorCount; j++)
{
VkDescriptorImageInfo imageInfo = new VkDescriptorImageInfo();
imageInfo.sampler = VkSampler.Null;
imageInfo.imageView = VkImageView.Null;
if (mWrite.imageInfo[j].sampler != null)
{
imageInfo.sampler = mWrite.imageInfo[j].sampler.Native;
}
if (mWrite.imageInfo[j].imageView != null)
{
imageInfo.imageView = mWrite.imageInfo[j].imageView.Native;
}
imageInfo.imageLayout = mWrite.imageInfo[j].imageLayout;
imageInfos[imageIndex] = imageInfo;
imageIndex++;
}
}
else if (mWrite.texelBufferView != null)
{
writesNative[i].descriptorCount = (uint)mWrite.texelBufferView.Count;
writesNative[i].pTexelBufferView = (IntPtr)(&bufferViews[bufferViewIndex]);
for (int j = 0; j < writesNative[i].descriptorCount; j++)
{
bufferViews[j] = mWrite.texelBufferView[j].Native;
bufferViewIndex++;
}
}
}
device.Commands.updateDescriptorSets(device.Native, (uint)writes.Count, (IntPtr)writesNative, 0, IntPtr.Zero);
}
}
/// <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, VkDescriptorBufferInfo 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.pBufferInfo = descriptor.Pin();
WriteDescriptorSets.Add(wds);
}
