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)
{
// 定数バッファを１つだけ持つものを作る.
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);
}
/// <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);
}
