public VkSampler(VkGraphicsDevice gd, ref SamplerDescription description)
{
_gd = gd;
VkFormats.GetFilterParams(description.Filter, out VkFilter minFilter, out VkFilter magFilter, out VkSamplerMipmapMode mipmapMode);
VkSamplerCreateInfo samplerCI = new VkSamplerCreateInfo
{
sType = VkStructureType.SamplerCreateInfo,
addressModeU = VkFormats.VdToVkSamplerAddressMode(description.AddressModeU),
addressModeV = VkFormats.VdToVkSamplerAddressMode(description.AddressModeV),
addressModeW = VkFormats.VdToVkSamplerAddressMode(description.AddressModeW),
minFilter = minFilter,
magFilter = magFilter,
mipmapMode = mipmapMode,
compareEnable = description.ComparisonKind != null,
compareOp = description.ComparisonKind != null
? VkFormats.VdToVkCompareOp(description.ComparisonKind.Value)
: VkCompareOp.Never,
anisotropyEnable = description.Filter == SamplerFilter.Anisotropic,
maxAnisotropy = description.MaximumAnisotropy,
minLod = description.MinimumLod,
maxLod = description.MaximumLod,
mipLodBias = description.LodBias,
borderColor = VkFormats.VdToVkSamplerBorderColor(description.BorderColor)
};
vkCreateSampler(_gd.Device, ref samplerCI, null, out _sampler);
RefCount = new ResourceRefCount(DisposeCore);
}
// Used to construct Swapchain textures.
internal VkTexture(
VkGraphicsDevice gd,
uint width,
uint height,
uint mipLevels,
uint arrayLayers,
VkFormat vkFormat,
TextureUsage usage,
TextureSampleCount sampleCount,
VkImage existingImage)
{
Debug.Assert(width > 0 && height > 0);
_gd = gd;
MipLevels = mipLevels;
_width = width;
_height = height;
_depth = 1;
VkFormat = vkFormat;
_format = VkFormats.VkToVdPixelFormat(VkFormat);
ArrayLayers = arrayLayers;
Usage = usage;
Type = TextureType.Texture2D;
SampleCount = sampleCount;
VkSampleCount = VkFormats.VdToVkSampleCount(sampleCount);
_optimalImage = existingImage;
_imageLayouts = new[] { VkImageLayout.Undefined };
_isSwapchainTexture = true;
ClearIfRenderTarget();
RefCount = new ResourceRefCount(DisposeCore);
}
public VkFramebufferBase(
FramebufferAttachmentDescription?depthTexture,
IReadOnlyList <FramebufferAttachmentDescription> colorTextures)
: base(depthTexture, colorTextures)
{
RefCount = new ResourceRefCount(DisposeCore);
}
public VkTextureView(VkGraphicsDevice gd, ref TextureViewDescription description)
: base(ref description)
{
_gd = gd;
VkImageViewCreateInfo imageViewCI = VkImageViewCreateInfo.New();
VkTexture tex = Util.AssertSubtype <Texture, VkTexture>(description.Target);
imageViewCI.image = tex.OptimalDeviceImage;
imageViewCI.format = VkFormats.VdToVkPixelFormat(Format, (Target.Usage & TextureUsage.DepthStencil) != 0);
VkImageAspectFlags aspectFlags;
if ((description.Target.Usage & TextureUsage.DepthStencil) == TextureUsage.DepthStencil)
{
aspectFlags = VkImageAspectFlags.Depth;
}
else
{
aspectFlags = VkImageAspectFlags.Color;
}
imageViewCI.subresourceRange = new VkImageSubresourceRange(
aspectFlags,
description.BaseMipLevel,
description.MipLevels,
description.BaseArrayLayer,
description.ArrayLayers);
if ((tex.Usage & TextureUsage.Cubemap) == TextureUsage.Cubemap)
{
imageViewCI.viewType = description.ArrayLayers == 1 ? VkImageViewType.ImageCube : VkImageViewType.ImageCubeArray;
imageViewCI.subresourceRange.layerCount *= 6;
}
else
{
switch (tex.Type)
{
case TextureType.Texture1D:
imageViewCI.viewType = description.ArrayLayers == 1
? VkImageViewType.Image1D
: VkImageViewType.Image1DArray;
break;
case TextureType.Texture2D:
imageViewCI.viewType = description.ArrayLayers == 1
? VkImageViewType.Image2D
: VkImageViewType.Image2DArray;
break;
case TextureType.Texture3D:
imageViewCI.viewType = VkImageViewType.Image3D;
break;
}
}
vkCreateImageView(_gd.Device, ref imageViewCI, null, out _imageView);
RefCount = new ResourceRefCount(DisposeCore);
}
public VkPipeline(VkGraphicsDevice gd, ref GraphicsPipelineDescription description)
: base(ref description)
{
_gd = gd;
IsComputePipeline = false;
RefCount = new ResourceRefCount(DisposeCore);
VkGraphicsPipelineCreateInfo pipelineCI = VkGraphicsPipelineCreateInfo.New();
// Blend State
VkPipelineColorBlendStateCreateInfo blendStateCI = VkPipelineColorBlendStateCreateInfo.New();
int attachmentsCount = description.BlendState.AttachmentStates.Length;
VkPipelineColorBlendAttachmentState *attachmentsPtr
= stackalloc VkPipelineColorBlendAttachmentState[attachmentsCount];
for (int i = 0; i < attachmentsCount; i++)
{
BlendAttachmentDescription vdDesc = description.BlendState.AttachmentStates[i];
VkPipelineColorBlendAttachmentState attachmentState = new VkPipelineColorBlendAttachmentState();
attachmentState.srcColorBlendFactor = VkFormats.VdToVkBlendFactor(vdDesc.SourceColorFactor);
attachmentState.dstColorBlendFactor = VkFormats.VdToVkBlendFactor(vdDesc.DestinationColorFactor);
attachmentState.colorBlendOp = VkFormats.VdToVkBlendOp(vdDesc.ColorFunction);
attachmentState.srcAlphaBlendFactor = VkFormats.VdToVkBlendFactor(vdDesc.SourceAlphaFactor);
attachmentState.dstAlphaBlendFactor = VkFormats.VdToVkBlendFactor(vdDesc.DestinationAlphaFactor);
attachmentState.alphaBlendOp = VkFormats.VdToVkBlendOp(vdDesc.AlphaFunction);
attachmentState.blendEnable = vdDesc.BlendEnabled;
attachmentState.colorWriteMask = VkColorComponentFlags.R | VkColorComponentFlags.G | VkColorComponentFlags.B | VkColorComponentFlags.A;
attachmentsPtr[i] = attachmentState;
}
blendStateCI.attachmentCount = (uint)attachmentsCount;
blendStateCI.pAttachments = attachmentsPtr;
RgbaFloat blendFactor = description.BlendState.BlendFactor;
blendStateCI.blendConstants_0 = blendFactor.R;
blendStateCI.blendConstants_1 = blendFactor.G;
blendStateCI.blendConstants_2 = blendFactor.B;
blendStateCI.blendConstants_3 = blendFactor.A;
pipelineCI.pColorBlendState = &blendStateCI;
// Rasterizer State
RasterizerStateDescription rsDesc = description.RasterizerState;
VkPipelineRasterizationStateCreateInfo rsCI = VkPipelineRasterizationStateCreateInfo.New();
rsCI.cullMode = VkFormats.VdToVkCullMode(rsDesc.CullMode);
rsCI.polygonMode = VkFormats.VdToVkPolygonMode(rsDesc.FillMode);
rsCI.depthClampEnable = !rsDesc.DepthClipEnabled;
rsCI.frontFace = rsDesc.FrontFace == FrontFace.Clockwise ? VkFrontFace.Clockwise : VkFrontFace.CounterClockwise;
rsCI.lineWidth = 1f;
pipelineCI.pRasterizationState = &rsCI;
ScissorTestEnabled = rsDesc.ScissorTestEnabled;
// Dynamic State
VkPipelineDynamicStateCreateInfo dynamicStateCI = VkPipelineDynamicStateCreateInfo.New();
VkDynamicState *dynamicStates = stackalloc VkDynamicState[2];
dynamicStates[0] = VkDynamicState.Viewport;
dynamicStates[1] = VkDynamicState.Scissor;
dynamicStateCI.dynamicStateCount = 2;
dynamicStateCI.pDynamicStates = dynamicStates;
pipelineCI.pDynamicState = &dynamicStateCI;
// Depth Stencil State
DepthStencilStateDescription vdDssDesc = description.DepthStencilState;
VkPipelineDepthStencilStateCreateInfo dssCI = VkPipelineDepthStencilStateCreateInfo.New();
dssCI.depthWriteEnable = vdDssDesc.DepthWriteEnabled;
dssCI.depthTestEnable = vdDssDesc.DepthTestEnabled;
dssCI.depthCompareOp = VkFormats.VdToVkCompareOp(vdDssDesc.DepthComparison);
dssCI.stencilTestEnable = vdDssDesc.StencilTestEnabled;
dssCI.front.failOp = VkFormats.VdToVkStencilOp(vdDssDesc.StencilFront.Fail);
dssCI.front.passOp = VkFormats.VdToVkStencilOp(vdDssDesc.StencilFront.Pass);
dssCI.front.depthFailOp = VkFormats.VdToVkStencilOp(vdDssDesc.StencilFront.DepthFail);
dssCI.front.compareOp = VkFormats.VdToVkCompareOp(vdDssDesc.StencilFront.Comparison);
dssCI.front.compareMask = vdDssDesc.StencilReadMask;
dssCI.front.writeMask = vdDssDesc.StencilWriteMask;
dssCI.front.reference = vdDssDesc.StencilReference;
dssCI.back.failOp = VkFormats.VdToVkStencilOp(vdDssDesc.StencilBack.Fail);
dssCI.back.passOp = VkFormats.VdToVkStencilOp(vdDssDesc.StencilBack.Pass);
dssCI.back.depthFailOp = VkFormats.VdToVkStencilOp(vdDssDesc.StencilBack.DepthFail);
dssCI.back.compareOp = VkFormats.VdToVkCompareOp(vdDssDesc.StencilBack.Comparison);
dssCI.back.compareMask = vdDssDesc.StencilReadMask;
dssCI.back.writeMask = vdDssDesc.StencilWriteMask;
dssCI.back.reference = vdDssDesc.StencilReference;
pipelineCI.pDepthStencilState = &dssCI;
// Multisample
VkPipelineMultisampleStateCreateInfo multisampleCI = VkPipelineMultisampleStateCreateInfo.New();
VkSampleCountFlags vkSampleCount = VkFormats.VdToVkSampleCount(description.Outputs.SampleCount);
multisampleCI.rasterizationSamples = vkSampleCount;
multisampleCI.alphaToCoverageEnable = description.BlendState.AlphaToCoverageEnabled;
pipelineCI.pMultisampleState = &multisampleCI;
// Input Assembly
VkPipelineInputAssemblyStateCreateInfo inputAssemblyCI = VkPipelineInputAssemblyStateCreateInfo.New();
inputAssemblyCI.topology = VkFormats.VdToVkPrimitiveTopology(description.PrimitiveTopology);
pipelineCI.pInputAssemblyState = &inputAssemblyCI;
// Vertex Input State
VkPipelineVertexInputStateCreateInfo vertexInputCI = VkPipelineVertexInputStateCreateInfo.New();
VertexLayoutDescription[] inputDescriptions = description.ShaderSet.VertexLayouts;
uint bindingCount = (uint)inputDescriptions.Length;
uint attributeCount = 0;
for (int i = 0; i < inputDescriptions.Length; i++)
{
attributeCount += (uint)inputDescriptions[i].Elements.Length;
}
VkVertexInputBindingDescription * bindingDescs = stackalloc VkVertexInputBindingDescription[(int)bindingCount];
VkVertexInputAttributeDescription *attributeDescs = stackalloc VkVertexInputAttributeDescription[(int)attributeCount];
int targetIndex = 0;
int targetLocation = 0;
for (int binding = 0; binding < inputDescriptions.Length; binding++)
{
VertexLayoutDescription inputDesc = inputDescriptions[binding];
bindingDescs[binding] = new VkVertexInputBindingDescription()
{
binding = (uint)binding,
inputRate = (inputDesc.InstanceStepRate != 0) ? VkVertexInputRate.Instance : VkVertexInputRate.Vertex,
stride = inputDesc.Stride
};
uint currentOffset = 0;
for (int location = 0; location < inputDesc.Elements.Length; location++)
{
VertexElementDescription inputElement = inputDesc.Elements[location];
attributeDescs[targetIndex] = new VkVertexInputAttributeDescription()
{
format = VkFormats.VdToVkVertexElementFormat(inputElement.Format),
binding = (uint)binding,
location = (uint)(targetLocation + location),
offset = inputElement.Offset != 0 ? inputElement.Offset : currentOffset
};
targetIndex += 1;
currentOffset += FormatHelpers.GetSizeInBytes(inputElement.Format);
}
targetLocation += inputDesc.Elements.Length;
}
vertexInputCI.vertexBindingDescriptionCount = bindingCount;
vertexInputCI.pVertexBindingDescriptions = bindingDescs;
vertexInputCI.vertexAttributeDescriptionCount = attributeCount;
vertexInputCI.pVertexAttributeDescriptions = attributeDescs;
pipelineCI.pVertexInputState = &vertexInputCI;
// Shader Stage
VkSpecializationInfo specializationInfo;
SpecializationConstant[] specDescs = description.ShaderSet.Specializations;
if (specDescs != null)
{
uint specDataSize = 0;
foreach (SpecializationConstant spec in specDescs)
{
specDataSize += VkFormats.GetSpecializationConstantSize(spec.Type);
}
byte *fullSpecData = stackalloc byte[(int)specDataSize];
int specializationCount = specDescs.Length;
VkSpecializationMapEntry *mapEntries = stackalloc VkSpecializationMapEntry[specializationCount];
uint specOffset = 0;
for (int i = 0; i < specializationCount; i++)
{
ulong data = specDescs[i].Data;
byte *srcData = (byte *)&data;
uint dataSize = VkFormats.GetSpecializationConstantSize(specDescs[i].Type);
Unsafe.CopyBlock(fullSpecData + specOffset, srcData, dataSize);
mapEntries[i].constantID = specDescs[i].ID;
mapEntries[i].offset = specOffset;
mapEntries[i].size = (UIntPtr)dataSize;
specOffset += dataSize;
}
specializationInfo.dataSize = (UIntPtr)specDataSize;
specializationInfo.pData = fullSpecData;
specializationInfo.mapEntryCount = (uint)specializationCount;
specializationInfo.pMapEntries = mapEntries;
}
Shader[] shaders = description.ShaderSet.Shaders;
StackList <VkPipelineShaderStageCreateInfo> stages = new StackList <VkPipelineShaderStageCreateInfo>();
foreach (Shader shader in shaders)
{
VkShader vkShader = Util.AssertSubtype <Shader, VkShader>(shader);
VkPipelineShaderStageCreateInfo stageCI = VkPipelineShaderStageCreateInfo.New();
stageCI.module = vkShader.ShaderModule;
stageCI.stage = VkFormats.VdToVkShaderStages(shader.Stage);
// stageCI.pName = CommonStrings.main; // Meh
stageCI.pName = new FixedUtf8String(shader.EntryPoint); // TODO: DONT ALLOCATE HERE
stageCI.pSpecializationInfo = &specializationInfo;
stages.Add(stageCI);
}
pipelineCI.stageCount = stages.Count;
pipelineCI.pStages = (VkPipelineShaderStageCreateInfo *)stages.Data;
// ViewportState
VkPipelineViewportStateCreateInfo viewportStateCI = VkPipelineViewportStateCreateInfo.New();
viewportStateCI.viewportCount = 1;
viewportStateCI.scissorCount = 1;
pipelineCI.pViewportState = &viewportStateCI;
// Pipeline Layout
ResourceLayout[] resourceLayouts = description.ResourceLayouts;
VkPipelineLayoutCreateInfo pipelineLayoutCI = VkPipelineLayoutCreateInfo.New();
pipelineLayoutCI.setLayoutCount = (uint)resourceLayouts.Length;
VkDescriptorSetLayout *dsls = stackalloc VkDescriptorSetLayout[resourceLayouts.Length];
for (int i = 0; i < resourceLayouts.Length; i++)
{
dsls[i] = Util.AssertSubtype <ResourceLayout, VkResourceLayout>(resourceLayouts[i]).DescriptorSetLayout;
}
pipelineLayoutCI.pSetLayouts = dsls;
vkCreatePipelineLayout(_gd.Device, ref pipelineLayoutCI, null, out _pipelineLayout);
pipelineCI.layout = _pipelineLayout;
// Create fake RenderPass for compatibility.
VkRenderPassCreateInfo renderPassCI = VkRenderPassCreateInfo.New();
OutputDescription outputDesc = description.Outputs;
StackList <VkAttachmentDescription, Size512Bytes> attachments = new StackList <VkAttachmentDescription, Size512Bytes>();
// TODO: A huge portion of this next part is duplicated in VkFramebuffer.cs.
StackList <VkAttachmentDescription> colorAttachmentDescs = new StackList <VkAttachmentDescription>();
StackList <VkAttachmentReference> colorAttachmentRefs = new StackList <VkAttachmentReference>();
for (uint i = 0; i < outputDesc.ColorAttachments.Length; i++)
{
colorAttachmentDescs[i].format = VkFormats.VdToVkPixelFormat(outputDesc.ColorAttachments[i].Format);
colorAttachmentDescs[i].samples = vkSampleCount;
colorAttachmentDescs[i].loadOp = VkAttachmentLoadOp.DontCare;
colorAttachmentDescs[i].storeOp = VkAttachmentStoreOp.Store;
colorAttachmentDescs[i].stencilLoadOp = VkAttachmentLoadOp.DontCare;
colorAttachmentDescs[i].stencilStoreOp = VkAttachmentStoreOp.DontCare;
colorAttachmentDescs[i].initialLayout = VkImageLayout.Undefined;
colorAttachmentDescs[i].finalLayout = VkImageLayout.ShaderReadOnlyOptimal;
attachments.Add(colorAttachmentDescs[i]);
colorAttachmentRefs[i].attachment = i;
colorAttachmentRefs[i].layout = VkImageLayout.ColorAttachmentOptimal;
}
VkAttachmentDescription depthAttachmentDesc = new VkAttachmentDescription();
VkAttachmentReference depthAttachmentRef = new VkAttachmentReference();
if (outputDesc.DepthAttachment != null)
{
PixelFormat depthFormat = outputDesc.DepthAttachment.Value.Format;
bool hasStencil = FormatHelpers.IsStencilFormat(depthFormat);
depthAttachmentDesc.format = VkFormats.VdToVkPixelFormat(outputDesc.DepthAttachment.Value.Format, toDepthFormat: true);
depthAttachmentDesc.samples = vkSampleCount;
depthAttachmentDesc.loadOp = VkAttachmentLoadOp.DontCare;
depthAttachmentDesc.storeOp = VkAttachmentStoreOp.Store;
depthAttachmentDesc.stencilLoadOp = VkAttachmentLoadOp.DontCare;
depthAttachmentDesc.stencilStoreOp = hasStencil ? VkAttachmentStoreOp.Store : VkAttachmentStoreOp.DontCare;
depthAttachmentDesc.initialLayout = VkImageLayout.Undefined;
depthAttachmentDesc.finalLayout = VkImageLayout.DepthStencilAttachmentOptimal;
depthAttachmentRef.attachment = (uint)outputDesc.ColorAttachments.Length;
depthAttachmentRef.layout = VkImageLayout.DepthStencilAttachmentOptimal;
}
VkSubpassDescription subpass = new VkSubpassDescription();
subpass.pipelineBindPoint = VkPipelineBindPoint.Graphics;
subpass.colorAttachmentCount = (uint)outputDesc.ColorAttachments.Length;
subpass.pColorAttachments = (VkAttachmentReference *)colorAttachmentRefs.Data;
for (int i = 0; i < colorAttachmentDescs.Count; i++)
{
attachments.Add(colorAttachmentDescs[i]);
}
if (outputDesc.DepthAttachment != null)
{
subpass.pDepthStencilAttachment = &depthAttachmentRef;
attachments.Add(depthAttachmentDesc);
}
VkSubpassDependency subpassDependency = new VkSubpassDependency();
subpassDependency.srcSubpass = SubpassExternal;
subpassDependency.srcStageMask = VkPipelineStageFlags.ColorAttachmentOutput;
subpassDependency.dstStageMask = VkPipelineStageFlags.ColorAttachmentOutput;
subpassDependency.dstAccessMask = VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite;
renderPassCI.attachmentCount = attachments.Count;
renderPassCI.pAttachments = (VkAttachmentDescription *)attachments.Data;
renderPassCI.subpassCount = 1;
renderPassCI.pSubpasses = &subpass;
renderPassCI.dependencyCount = 1;
renderPassCI.pDependencies = &subpassDependency;
VkResult creationResult = vkCreateRenderPass(_gd.Device, ref renderPassCI, null, out _renderPass);
CheckResult(creationResult);
pipelineCI.renderPass = _renderPass;
VkResult result = vkCreateGraphicsPipelines(_gd.Device, VkPipelineCache.Null, 1, ref pipelineCI, null, out _devicePipeline);
CheckResult(result);
ResourceSetCount = (uint)description.ResourceLayouts.Length;
DynamicOffsetsCount = 0;
foreach (VkResourceLayout layout in description.ResourceLayouts)
{
DynamicOffsetsCount += layout.DynamicBufferCount;
}
}
public VkPipeline(VkGraphicsDevice gd, ref ComputePipelineDescription description)
: base(ref description)
{
_gd = gd;
IsComputePipeline = true;
RefCount = new ResourceRefCount(DisposeCore);
VkComputePipelineCreateInfo pipelineCI = VkComputePipelineCreateInfo.New();
// Pipeline Layout
ResourceLayout[] resourceLayouts = description.ResourceLayouts;
VkPipelineLayoutCreateInfo pipelineLayoutCI = VkPipelineLayoutCreateInfo.New();
pipelineLayoutCI.setLayoutCount = (uint)resourceLayouts.Length;
VkDescriptorSetLayout *dsls = stackalloc VkDescriptorSetLayout[resourceLayouts.Length];
for (int i = 0; i < resourceLayouts.Length; i++)
{
dsls[i] = Util.AssertSubtype <ResourceLayout, VkResourceLayout>(resourceLayouts[i]).DescriptorSetLayout;
}
pipelineLayoutCI.pSetLayouts = dsls;
vkCreatePipelineLayout(_gd.Device, ref pipelineLayoutCI, null, out _pipelineLayout);
pipelineCI.layout = _pipelineLayout;
// Shader Stage
VkSpecializationInfo specializationInfo;
SpecializationConstant[] specDescs = description.Specializations;
if (specDescs != null)
{
uint specDataSize = 0;
foreach (SpecializationConstant spec in specDescs)
{
specDataSize += VkFormats.GetSpecializationConstantSize(spec.Type);
}
byte *fullSpecData = stackalloc byte[(int)specDataSize];
int specializationCount = specDescs.Length;
VkSpecializationMapEntry *mapEntries = stackalloc VkSpecializationMapEntry[specializationCount];
uint specOffset = 0;
for (int i = 0; i < specializationCount; i++)
{
ulong data = specDescs[i].Data;
byte *srcData = (byte *)&data;
uint dataSize = VkFormats.GetSpecializationConstantSize(specDescs[i].Type);
Unsafe.CopyBlock(fullSpecData + specOffset, srcData, dataSize);
mapEntries[i].constantID = specDescs[i].ID;
mapEntries[i].offset = specOffset;
mapEntries[i].size = (UIntPtr)dataSize;
specOffset += dataSize;
}
specializationInfo.dataSize = (UIntPtr)specDataSize;
specializationInfo.pData = fullSpecData;
specializationInfo.mapEntryCount = (uint)specializationCount;
specializationInfo.pMapEntries = mapEntries;
}
Shader shader = description.ComputeShader;
VkShader vkShader = Util.AssertSubtype <Shader, VkShader>(shader);
VkPipelineShaderStageCreateInfo stageCI = VkPipelineShaderStageCreateInfo.New();
stageCI.module = vkShader.ShaderModule;
stageCI.stage = VkFormats.VdToVkShaderStages(shader.Stage);
stageCI.pName = CommonStrings.main; // Meh
stageCI.pSpecializationInfo = &specializationInfo;
pipelineCI.stage = stageCI;
VkResult result = vkCreateComputePipelines(
_gd.Device,
VkPipelineCache.Null,
1,
ref pipelineCI,
null,
out _devicePipeline);
CheckResult(result);
ResourceSetCount = (uint)description.ResourceLayouts.Length;
DynamicOffsetsCount = 0;
foreach (VkResourceLayout layout in description.ResourceLayouts)
{
DynamicOffsetsCount += layout.DynamicBufferCount;
}
}
public VkResourceSet(VkGraphicsDevice gd, ref ResourceSetDescription description)
: base(ref description)
{
_gd = gd;
RefCount = new ResourceRefCount(DisposeCore);
VkResourceLayout vkLayout = Util.AssertSubtype <ResourceLayout, VkResourceLayout>(description.Layout);
VkDescriptorSetLayout dsl = vkLayout.DescriptorSetLayout;
_descriptorCounts = vkLayout.DescriptorResourceCounts;
_descriptorAllocationToken = _gd.DescriptorPoolManager.Allocate(_descriptorCounts, dsl);
BindableResource[] boundResources = description.BoundResources;
uint descriptorWriteCount = (uint)boundResources.Length;
VkWriteDescriptorSet * descriptorWrites = stackalloc VkWriteDescriptorSet[(int)descriptorWriteCount];
VkDescriptorBufferInfo *bufferInfos = stackalloc VkDescriptorBufferInfo[(int)descriptorWriteCount];
VkDescriptorImageInfo * imageInfos = stackalloc VkDescriptorImageInfo[(int)descriptorWriteCount];
for (int i = 0; i < descriptorWriteCount; i++)
{
VkDescriptorType type = vkLayout.DescriptorTypes[i];
descriptorWrites[i].sType = VkStructureType.WriteDescriptorSet;
descriptorWrites[i].descriptorCount = 1;
descriptorWrites[i].descriptorType = type;
descriptorWrites[i].dstBinding = (uint)i;
descriptorWrites[i].dstSet = _descriptorAllocationToken.Set;
if (type == VkDescriptorType.UniformBuffer || type == VkDescriptorType.UniformBufferDynamic ||
type == VkDescriptorType.StorageBuffer || type == VkDescriptorType.StorageBufferDynamic)
{
DeviceBufferRange range = Util.GetBufferRange(boundResources[i], 0);
VkBuffer rangedVkBuffer = Util.AssertSubtype <DeviceBuffer, VkBuffer>(range.Buffer);
bufferInfos[i].buffer = rangedVkBuffer.DeviceBuffer;
bufferInfos[i].offset = range.Offset;
bufferInfos[i].range = range.SizeInBytes;
descriptorWrites[i].pBufferInfo = &bufferInfos[i];
_refCounts.Add(rangedVkBuffer.RefCount);
}
else if (type == VkDescriptorType.SampledImage)
{
TextureView texView = Util.GetTextureView(_gd, boundResources[i]);
VkTextureView vkTexView = Util.AssertSubtype <TextureView, VkTextureView>(texView);
imageInfos[i].imageView = vkTexView.ImageView;
imageInfos[i].imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
descriptorWrites[i].pImageInfo = &imageInfos[i];
_sampledTextures.Add(Util.AssertSubtype <Texture, VkTexture>(texView.Target));
_refCounts.Add(vkTexView.RefCount);
}
else if (type == VkDescriptorType.StorageImage)
{
TextureView texView = Util.GetTextureView(_gd, boundResources[i]);
VkTextureView vkTexView = Util.AssertSubtype <TextureView, VkTextureView>(texView);
imageInfos[i].imageView = vkTexView.ImageView;
imageInfos[i].imageLayout = VkImageLayout.General;
descriptorWrites[i].pImageInfo = &imageInfos[i];
_storageImages.Add(Util.AssertSubtype <Texture, VkTexture>(texView.Target));
_refCounts.Add(vkTexView.RefCount);
}
else if (type == VkDescriptorType.Sampler)
{
VkSampler sampler = Util.AssertSubtype <BindableResource, VkSampler>(boundResources[i]);
imageInfos[i].sampler = sampler.DeviceSampler;
descriptorWrites[i].pImageInfo = &imageInfos[i];
_refCounts.Add(sampler.RefCount);
}
}
vkUpdateDescriptorSets(_gd.Device, descriptorWriteCount, descriptorWrites, 0, null);
}
public VkBuffer(VkGraphicsDevice gd, uint sizeInBytes, BufferUsage usage, string callerMember = null)
{
_gd = gd;
SizeInBytes = sizeInBytes;
Usage = usage;
VkBufferUsageFlags vkUsage = VkBufferUsageFlags.TransferSrc | VkBufferUsageFlags.TransferDst;
if ((usage & BufferUsage.VertexBuffer) == BufferUsage.VertexBuffer)
{
vkUsage |= VkBufferUsageFlags.VertexBuffer;
}
if ((usage & BufferUsage.IndexBuffer) == BufferUsage.IndexBuffer)
{
vkUsage |= VkBufferUsageFlags.IndexBuffer;
}
if ((usage & BufferUsage.UniformBuffer) == BufferUsage.UniformBuffer)
{
vkUsage |= VkBufferUsageFlags.UniformBuffer;
}
if ((usage & BufferUsage.StructuredBufferReadWrite) == BufferUsage.StructuredBufferReadWrite ||
(usage & BufferUsage.StructuredBufferReadOnly) == BufferUsage.StructuredBufferReadOnly)
{
vkUsage |= VkBufferUsageFlags.StorageBuffer;
}
if ((usage & BufferUsage.IndirectBuffer) == BufferUsage.IndirectBuffer)
{
vkUsage |= VkBufferUsageFlags.IndirectBuffer;
}
VkBufferCreateInfo bufferCI = VkBufferCreateInfo.New();
bufferCI.size = sizeInBytes;
bufferCI.usage = vkUsage;
VkResult result = vkCreateBuffer(gd.Device, ref bufferCI, null, out _deviceBuffer);
CheckResult(result);
bool prefersDedicatedAllocation;
if (_gd.GetBufferMemoryRequirements2 != null)
{
VkBufferMemoryRequirementsInfo2KHR memReqInfo2 = VkBufferMemoryRequirementsInfo2KHR.New();
memReqInfo2.buffer = _deviceBuffer;
VkMemoryRequirements2KHR memReqs2 = VkMemoryRequirements2KHR.New();
VkMemoryDedicatedRequirementsKHR dedicatedReqs = VkMemoryDedicatedRequirementsKHR.New();
memReqs2.pNext = &dedicatedReqs;
_gd.GetBufferMemoryRequirements2(_gd.Device, &memReqInfo2, &memReqs2);
_bufferMemoryRequirements = memReqs2.memoryRequirements;
prefersDedicatedAllocation = dedicatedReqs.prefersDedicatedAllocation || dedicatedReqs.requiresDedicatedAllocation;
}
else
{
vkGetBufferMemoryRequirements(gd.Device, _deviceBuffer, out _bufferMemoryRequirements);
prefersDedicatedAllocation = false;
}
bool hostVisible = (usage & BufferUsage.Dynamic) == BufferUsage.Dynamic ||
(usage & BufferUsage.Staging) == BufferUsage.Staging;
VkMemoryPropertyFlags memoryPropertyFlags =
hostVisible
? VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent
: VkMemoryPropertyFlags.DeviceLocal;
VkMemoryBlock memoryToken = gd.MemoryManager.Allocate(
gd.PhysicalDeviceMemProperties,
_bufferMemoryRequirements.memoryTypeBits,
memoryPropertyFlags,
hostVisible,
_bufferMemoryRequirements.size,
_bufferMemoryRequirements.alignment,
prefersDedicatedAllocation,
VkImage.Null,
_deviceBuffer);
_memory = memoryToken;
result = vkBindBufferMemory(gd.Device, _deviceBuffer, _memory.DeviceMemory, _memory.Offset);
CheckResult(result);
RefCount = new ResourceRefCount(DisposeCore);
}
internal VkTexture(VkGraphicsDevice gd, ref TextureDescription description)
{
_gd = gd;
_width = description.Width;
_height = description.Height;
_depth = description.Depth;
MipLevels = description.MipLevels;
ArrayLayers = description.ArrayLayers;
bool isCubemap = ((description.Usage) & TextureUsage.Cubemap) == TextureUsage.Cubemap;
_actualImageArrayLayers = isCubemap
? 6 * ArrayLayers
: ArrayLayers;
_format = description.Format;
Usage = description.Usage;
Type = description.Type;
SampleCount = description.SampleCount;
VkSampleCount = VkFormats.VdToVkSampleCount(SampleCount);
VkFormat = VkFormats.VdToVkPixelFormat(Format, (description.Usage & TextureUsage.DepthStencil) == TextureUsage.DepthStencil);
bool isStaging = (Usage & TextureUsage.Staging) == TextureUsage.Staging;
if (!isStaging)
{
VkImageCreateInfo imageCI = VkImageCreateInfo.New();
imageCI.mipLevels = MipLevels;
imageCI.arrayLayers = _actualImageArrayLayers;
imageCI.imageType = VkFormats.VdToVkTextureType(Type);
imageCI.extent.width = Width;
imageCI.extent.height = Height;
imageCI.extent.depth = Depth;
imageCI.initialLayout = VkImageLayout.Preinitialized;
imageCI.usage = VkFormats.VdToVkTextureUsage(Usage);
imageCI.tiling = isStaging ? VkImageTiling.Linear : VkImageTiling.Optimal;
imageCI.format = VkFormat;
imageCI.flags = VkImageCreateFlags.MutableFormat;
imageCI.samples = VkSampleCount;
if (isCubemap)
{
imageCI.flags |= VkImageCreateFlags.CubeCompatible;
}
uint subresourceCount = MipLevels * _actualImageArrayLayers * Depth;
VkResult result = vkCreateImage(gd.Device, ref imageCI, null, out _optimalImage);
CheckResult(result);
VkMemoryRequirements memoryRequirements;
bool prefersDedicatedAllocation;
if (_gd.GetImageMemoryRequirements2 != null)
{
VkImageMemoryRequirementsInfo2KHR memReqsInfo2 = VkImageMemoryRequirementsInfo2KHR.New();
memReqsInfo2.image = _optimalImage;
VkMemoryRequirements2KHR memReqs2 = VkMemoryRequirements2KHR.New();
VkMemoryDedicatedRequirementsKHR dedicatedReqs = VkMemoryDedicatedRequirementsKHR.New();
memReqs2.pNext = &dedicatedReqs;
_gd.GetImageMemoryRequirements2(_gd.Device, &memReqsInfo2, &memReqs2);
memoryRequirements = memReqs2.memoryRequirements;
prefersDedicatedAllocation = dedicatedReqs.prefersDedicatedAllocation || dedicatedReqs.requiresDedicatedAllocation;
}
else
{
vkGetImageMemoryRequirements(gd.Device, _optimalImage, out memoryRequirements);
prefersDedicatedAllocation = false;
}
VkMemoryBlock memoryToken = gd.MemoryManager.Allocate(
gd.PhysicalDeviceMemProperties,
memoryRequirements.memoryTypeBits,
VkMemoryPropertyFlags.DeviceLocal,
false,
memoryRequirements.size,
memoryRequirements.alignment,
prefersDedicatedAllocation,
_optimalImage,
Vulkan.VkBuffer.Null);
_memoryBlock = memoryToken;
result = vkBindImageMemory(gd.Device, _optimalImage, _memoryBlock.DeviceMemory, _memoryBlock.Offset);
CheckResult(result);
_imageLayouts = new VkImageLayout[subresourceCount];
for (int i = 0; i < _imageLayouts.Length; i++)
{
_imageLayouts[i] = VkImageLayout.Preinitialized;
}
}
else // isStaging
{
uint depthPitch = FormatHelpers.GetDepthPitch(
FormatHelpers.GetRowPitch(Width, Format),
Height,
Format);
uint stagingSize = depthPitch * Depth;
for (uint level = 1; level < MipLevels; level++)
{
Util.GetMipDimensions(this, level, out uint mipWidth, out uint mipHeight, out uint mipDepth);
depthPitch = FormatHelpers.GetDepthPitch(
FormatHelpers.GetRowPitch(mipWidth, Format),
mipHeight,
Format);
stagingSize += depthPitch * mipDepth;
}
stagingSize *= ArrayLayers;
VkBufferCreateInfo bufferCI = VkBufferCreateInfo.New();
bufferCI.usage = VkBufferUsageFlags.TransferSrc | VkBufferUsageFlags.TransferDst;
bufferCI.size = stagingSize;
VkResult result = vkCreateBuffer(_gd.Device, ref bufferCI, null, out _stagingBuffer);
CheckResult(result);
VkMemoryRequirements bufferMemReqs;
bool prefersDedicatedAllocation;
if (_gd.GetBufferMemoryRequirements2 != null)
{
VkBufferMemoryRequirementsInfo2KHR memReqInfo2 = VkBufferMemoryRequirementsInfo2KHR.New();
memReqInfo2.buffer = _stagingBuffer;
VkMemoryRequirements2KHR memReqs2 = VkMemoryRequirements2KHR.New();
VkMemoryDedicatedRequirementsKHR dedicatedReqs = VkMemoryDedicatedRequirementsKHR.New();
memReqs2.pNext = &dedicatedReqs;
_gd.GetBufferMemoryRequirements2(_gd.Device, &memReqInfo2, &memReqs2);
bufferMemReqs = memReqs2.memoryRequirements;
prefersDedicatedAllocation = dedicatedReqs.prefersDedicatedAllocation || dedicatedReqs.requiresDedicatedAllocation;
}
else
{
vkGetBufferMemoryRequirements(gd.Device, _stagingBuffer, out bufferMemReqs);
prefersDedicatedAllocation = false;
}
_memoryBlock = _gd.MemoryManager.Allocate(
_gd.PhysicalDeviceMemProperties,
bufferMemReqs.memoryTypeBits,
VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent,
true,
bufferMemReqs.size,
bufferMemReqs.alignment,
prefersDedicatedAllocation,
VkImage.Null,
_stagingBuffer);
result = vkBindBufferMemory(_gd.Device, _stagingBuffer, _memoryBlock.DeviceMemory, _memoryBlock.Offset);
CheckResult(result);
}
ClearIfRenderTarget();
TransitionIfSampled();
RefCount = new ResourceRefCount(RefCountedDispose);
}
public VkFramebufferBase()
{
RefCount = new ResourceRefCount(DisposeCore);
}
