public override MTLRenderPassDescriptor CreateRenderPassDescriptor()
{
MTLRenderPassDescriptor ret = MTLRenderPassDescriptor.New();
for (int i = 0; i < ColorTargets.Count; i++)
{
FramebufferAttachment colorTarget = ColorTargets[i];
MTLTexture mtlTarget = Util.AssertSubtype <Texture, MTLTexture>(colorTarget.Target);
MTLRenderPassColorAttachmentDescriptor colorDescriptor = ret.colorAttachments[(uint)i];
colorDescriptor.texture = mtlTarget.DeviceTexture;
colorDescriptor.loadAction = MTLLoadAction.Load;
colorDescriptor.slice = (UIntPtr)colorTarget.ArrayLayer;
}
if (DepthTarget != null)
{
MTLTexture mtlDepthTarget = Util.AssertSubtype <Texture, MTLTexture>(DepthTarget.Value.Target);
MTLRenderPassDepthAttachmentDescriptor depthDescriptor = ret.depthAttachment;
depthDescriptor.loadAction = MTLLoadAction.Load;
depthDescriptor.storeAction = MTLStoreAction.Store;
depthDescriptor.texture = mtlDepthTarget.DeviceTexture;
depthDescriptor.slice = (UIntPtr)DepthTarget.Value.ArrayLayer;
if (FormatHelpers.IsStencilFormat(mtlDepthTarget.Format))
{
MTLRenderPassStencilAttachmentDescriptor stencilDescriptor = ret.stencilAttachment;
stencilDescriptor.loadAction = MTLLoadAction.Load;
stencilDescriptor.storeAction = MTLStoreAction.Store;
stencilDescriptor.texture = mtlDepthTarget.DeviceTexture;
stencilDescriptor.slice = (UIntPtr)DepthTarget.Value.ArrayLayer;
}
}
return(ret);
}
internal void TransitionImageLayout(
VkCommandBuffer cb,
uint baseMipLevel,
uint levelCount,
uint baseArrayLayer,
uint layerCount,
VkImageLayout newLayout)
{
if (_stagingBuffer != Vulkan.VkBuffer.Null)
{
return;
}
VkImageLayout oldLayout = _imageLayouts[CalculateSubresource(baseMipLevel, baseArrayLayer)];
#if DEBUG
for (uint level = 0; level < levelCount; level++)
{
for (uint layer = 0; layer < layerCount; layer++)
{
if (_imageLayouts[CalculateSubresource(baseMipLevel + level, baseArrayLayer + layer)] != oldLayout)
{
throw new VeldridException("Unexpected image layout.");
}
}
}
#endif
if (oldLayout != newLayout)
{
VkImageAspectFlags aspectMask;
if ((Usage & TextureUsage.DepthStencil) != 0)
{
aspectMask = FormatHelpers.IsStencilFormat(Format)
? aspectMask = VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil
: aspectMask = VkImageAspectFlags.Depth;
}
else
{
aspectMask = VkImageAspectFlags.Color;
}
VulkanUtil.TransitionImageLayout(
cb,
OptimalDeviceImage,
baseMipLevel,
levelCount,
baseArrayLayer,
layerCount,
aspectMask,
_imageLayouts[CalculateSubresource(baseMipLevel, baseArrayLayer)],
newLayout);
for (uint level = 0; level < levelCount; level++)
{
for (uint layer = 0; layer < layerCount; layer++)
{
_imageLayouts[CalculateSubresource(baseMipLevel + level, baseArrayLayer + layer)] = newLayout;
}
}
}
}
internal void TransitionImageLayoutNonmatching(
VkCommandBuffer cb,
uint baseMipLevel,
uint levelCount,
uint baseArrayLayer,
uint layerCount,
VkImageLayout newLayout)
{
if (_stagingBuffer != Vulkan.VkBuffer.Null)
{
return;
}
for (uint level = baseMipLevel; level < baseMipLevel + levelCount; level++)
{
for (uint layer = baseArrayLayer; layer < baseArrayLayer + layerCount; layer++)
{
uint subresource = CalculateSubresource(level, layer);
VkImageLayout oldLayout = _imageLayouts[subresource];
if (oldLayout != newLayout)
{
VkImageAspectFlags aspectMask;
if ((Usage & TextureUsage.DepthStencil) != 0)
{
aspectMask = FormatHelpers.IsStencilFormat(Format)
? VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil
: VkImageAspectFlags.Depth;
}
else
{
aspectMask = VkImageAspectFlags.Color;
}
VulkanUtil.TransitionImageLayout(
cb,
OptimalDeviceImage,
level,
1,
layer,
1,
aspectMask,
oldLayout,
newLayout);
_imageLayouts[subresource] = newLayout;
}
}
}
}
protected override void ClearDepthStencilCore(float depth, byte stencil)
{
VkClearValue clearValue = new VkClearValue {
depthStencil = new VkClearDepthStencilValue(depth, stencil)
};
if (_activeRenderPass != VkRenderPass.Null)
{
VkImageAspectFlags aspectMask = VkImageAspectFlags.Depth;
if (FormatHelpers.IsStencilFormat(_currentFramebuffer.DepthTarget.Value.Target.Format))
{
aspectMask |= VkImageAspectFlags.Stencil;
}
VkClearAttachment clearAttachment = new VkClearAttachment
{
aspectMask = aspectMask,
clearValue = clearValue
};
Texture depthTex = _currentFramebuffer.DepthTarget.Value.Target;
uint renderableWidth = _currentFramebuffer.RenderableWidth;
uint renderableHeight = _currentFramebuffer.RenderableHeight;
if (renderableWidth > 0 && renderableHeight > 0)
{
VkClearRect clearRect = new VkClearRect
{
baseArrayLayer = 0,
layerCount = 1,
rect = new VkRect2D(0, 0, renderableWidth, renderableHeight)
};
vkCmdClearAttachments(_cb, 1, ref clearAttachment, 1, ref clearRect);
}
}
else
{
// Queue up the clear value for the next RenderPass.
_depthClearValue = clearValue;
}
}
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 VkFramebuffer(VkGraphicsDevice gd, ref FramebufferDescription description, bool isPresented)
: base(description.DepthTarget, description.ColorTargets)
{
_gd = gd;
VkRenderPassCreateInfo renderPassCI = VkRenderPassCreateInfo.New();
StackList <VkAttachmentDescription> attachments = new StackList <VkAttachmentDescription>();
uint colorAttachmentCount = (uint)ColorTargets.Count;
StackList <VkAttachmentReference> colorAttachmentRefs = new StackList <VkAttachmentReference>();
for (int i = 0; i < colorAttachmentCount; i++)
{
VkTexture vkColorTex = Util.AssertSubtype <Texture, VkTexture>(ColorTargets[i].Target);
VkAttachmentDescription colorAttachmentDesc = new VkAttachmentDescription();
colorAttachmentDesc.format = vkColorTex.VkFormat;
colorAttachmentDesc.samples = vkColorTex.VkSampleCount;
colorAttachmentDesc.loadOp = VkAttachmentLoadOp.DontCare;
colorAttachmentDesc.storeOp = VkAttachmentStoreOp.Store;
colorAttachmentDesc.stencilLoadOp = VkAttachmentLoadOp.DontCare;
colorAttachmentDesc.stencilStoreOp = VkAttachmentStoreOp.DontCare;
colorAttachmentDesc.initialLayout = VkImageLayout.Undefined;
colorAttachmentDesc.finalLayout = VkImageLayout.ColorAttachmentOptimal;
attachments.Add(colorAttachmentDesc);
VkAttachmentReference colorAttachmentRef = new VkAttachmentReference();
colorAttachmentRef.attachment = (uint)i;
colorAttachmentRef.layout = VkImageLayout.ColorAttachmentOptimal;
colorAttachmentRefs.Add(colorAttachmentRef);
}
VkAttachmentDescription depthAttachmentDesc = new VkAttachmentDescription();
VkAttachmentReference depthAttachmentRef = new VkAttachmentReference();
if (DepthTarget != null)
{
VkTexture vkDepthTex = Util.AssertSubtype <Texture, VkTexture>(DepthTarget.Value.Target);
bool hasStencil = FormatHelpers.IsStencilFormat(vkDepthTex.Format);
depthAttachmentDesc.format = vkDepthTex.VkFormat;
depthAttachmentDesc.samples = vkDepthTex.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)description.ColorTargets.Length;
depthAttachmentRef.layout = VkImageLayout.DepthStencilAttachmentOptimal;
}
VkSubpassDescription subpass = new VkSubpassDescription();
subpass.pipelineBindPoint = VkPipelineBindPoint.Graphics;
if (ColorTargets.Count > 0)
{
subpass.colorAttachmentCount = colorAttachmentCount;
subpass.pColorAttachments = (VkAttachmentReference *)colorAttachmentRefs.Data;
}
if (DepthTarget != 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;
if (DepthTarget != null)
{
subpassDependency.dstAccessMask |= VkAccessFlags.DepthStencilAttachmentRead | VkAccessFlags.DepthStencilAttachmentWrite;
}
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 _renderPassNoClear);
CheckResult(creationResult);
for (int i = 0; i < colorAttachmentCount; i++)
{
attachments[i].loadOp = VkAttachmentLoadOp.Load;
attachments[i].initialLayout = VkImageLayout.ColorAttachmentOptimal;
}
if (DepthTarget != null)
{
attachments[attachments.Count - 1].loadOp = VkAttachmentLoadOp.Load;
attachments[attachments.Count - 1].initialLayout = VkImageLayout.DepthStencilAttachmentOptimal;
bool hasStencil = FormatHelpers.IsStencilFormat(DepthTarget.Value.Target.Format);
if (hasStencil)
{
attachments[attachments.Count - 1].stencilLoadOp = VkAttachmentLoadOp.Load;
}
}
creationResult = vkCreateRenderPass(_gd.Device, ref renderPassCI, null, out _renderPassNoClearLoad);
CheckResult(creationResult);
// Load version
if (DepthTarget != null)
{
attachments[attachments.Count - 1].loadOp = VkAttachmentLoadOp.Clear;
attachments[attachments.Count - 1].initialLayout = VkImageLayout.Undefined;
bool hasStencil = FormatHelpers.IsStencilFormat(DepthTarget.Value.Target.Format);
if (hasStencil)
{
attachments[attachments.Count - 1].stencilLoadOp = VkAttachmentLoadOp.Clear;
}
}
for (int i = 0; i < colorAttachmentCount; i++)
{
attachments[i].loadOp = VkAttachmentLoadOp.Clear;
attachments[i].initialLayout = VkImageLayout.Undefined;
}
creationResult = vkCreateRenderPass(_gd.Device, ref renderPassCI, null, out _renderPassClear);
CheckResult(creationResult);
VkFramebufferCreateInfo fbCI = VkFramebufferCreateInfo.New();
uint fbAttachmentsCount = (uint)description.ColorTargets.Length;
if (description.DepthTarget != null)
{
fbAttachmentsCount += 1;
}
VkImageView *fbAttachments = stackalloc VkImageView[(int)fbAttachmentsCount];
for (int i = 0; i < colorAttachmentCount; i++)
{
VkTexture vkColorTarget = Util.AssertSubtype <Texture, VkTexture>(description.ColorTargets[i].Target);
VkImageViewCreateInfo imageViewCI = VkImageViewCreateInfo.New();
imageViewCI.image = vkColorTarget.OptimalDeviceImage;
imageViewCI.format = vkColorTarget.VkFormat;
imageViewCI.viewType = VkImageViewType.Image2D;
imageViewCI.subresourceRange = new VkImageSubresourceRange(
VkImageAspectFlags.Color,
description.ColorTargets[i].MipLevel,
1,
description.ColorTargets[i].ArrayLayer,
1);
VkImageView *dest = (fbAttachments + i);
VkResult result = vkCreateImageView(_gd.Device, ref imageViewCI, null, dest);
CheckResult(result);
_attachmentViews.Add(*dest);
}
// Depth
if (description.DepthTarget != null)
{
VkTexture vkDepthTarget = Util.AssertSubtype <Texture, VkTexture>(description.DepthTarget.Value.Target);
bool hasStencil = FormatHelpers.IsStencilFormat(vkDepthTarget.Format);
VkImageViewCreateInfo depthViewCI = VkImageViewCreateInfo.New();
depthViewCI.image = vkDepthTarget.OptimalDeviceImage;
depthViewCI.format = vkDepthTarget.VkFormat;
depthViewCI.viewType = description.DepthTarget.Value.Target.ArrayLayers == 1 ? VkImageViewType.Image2D : VkImageViewType.Image2DArray;
depthViewCI.subresourceRange = new VkImageSubresourceRange(
hasStencil ? VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil : VkImageAspectFlags.Depth,
description.DepthTarget.Value.MipLevel,
1,
description.DepthTarget.Value.ArrayLayer,
1);
VkImageView *dest = (fbAttachments + (fbAttachmentsCount - 1));
VkResult result = vkCreateImageView(_gd.Device, ref depthViewCI, null, dest);
CheckResult(result);
_attachmentViews.Add(*dest);
}
Texture dimTex;
uint mipLevel;
if (ColorTargets.Count > 0)
{
dimTex = ColorTargets[0].Target;
mipLevel = ColorTargets[0].MipLevel;
}
else
{
Debug.Assert(DepthTarget != null);
dimTex = DepthTarget.Value.Target;
mipLevel = DepthTarget.Value.MipLevel;
}
Util.GetMipDimensions(
dimTex,
mipLevel,
out uint mipWidth,
out uint mipHeight,
out _);
fbCI.width = mipWidth;
fbCI.height = mipHeight;
fbCI.attachmentCount = fbAttachmentsCount;
fbCI.pAttachments = fbAttachments;
fbCI.layers = 1;
fbCI.renderPass = _renderPassNoClear;
creationResult = vkCreateFramebuffer(_gd.Device, ref fbCI, null, out _deviceFramebuffer);
CheckResult(creationResult);
if (DepthTarget != null)
{
AttachmentCount += 1;
}
AttachmentCount += (uint)ColorTargets.Count;
}
public MTLPipeline(ref GraphicsPipelineDescription description, MTLGraphicsDevice gd)
: base(ref description)
{
PrimitiveType = MTLFormats.VdToMTLPrimitiveTopology(description.PrimitiveTopology);
ResourceLayouts = new MTLResourceLayout[description.ResourceLayouts.Length];
NonVertexBufferCount = 0;
for (int i = 0; i < ResourceLayouts.Length; i++)
{
ResourceLayouts[i] = Util.AssertSubtype <ResourceLayout, MTLResourceLayout>(description.ResourceLayouts[i]);
NonVertexBufferCount += ResourceLayouts[i].BufferCount;
}
ResourceBindingModel = description.ResourceBindingModel ?? gd.ResourceBindingModel;
CullMode = MTLFormats.VdToMTLCullMode(description.RasterizerState.CullMode);
FrontFace = MTLFormats.VdVoMTLFrontFace(description.RasterizerState.FrontFace);
FillMode = MTLFormats.VdToMTLFillMode(description.RasterizerState.FillMode);
ScissorTestEnabled = description.RasterizerState.ScissorTestEnabled;
MTLRenderPipelineDescriptor mtlDesc = MTLRenderPipelineDescriptor.New();
foreach (Shader shader in description.ShaderSet.Shaders)
{
MTLShader mtlShader = Util.AssertSubtype <Shader, MTLShader>(shader);
MTLFunction specializedFunction;
if (mtlShader.HasFunctionConstants)
{
// Need to create specialized MTLFunction.
MTLFunctionConstantValues constantValues = CreateConstantValues(description.ShaderSet.Specializations);
specializedFunction = mtlShader.Library.newFunctionWithNameConstantValues(mtlShader.EntryPoint, constantValues);
AddSpecializedFunction(specializedFunction);
ObjectiveCRuntime.release(constantValues.NativePtr);
Debug.Assert(specializedFunction.NativePtr != IntPtr.Zero, "Failed to create specialized MTLFunction");
}
else
{
specializedFunction = mtlShader.Function;
}
if (shader.Stage == ShaderStages.Vertex)
{
mtlDesc.vertexFunction = specializedFunction;
}
else if (shader.Stage == ShaderStages.Fragment)
{
mtlDesc.fragmentFunction = specializedFunction;
}
}
// Vertex layouts
VertexLayoutDescription[] vdVertexLayouts = description.ShaderSet.VertexLayouts;
MTLVertexDescriptor vertexDescriptor = mtlDesc.vertexDescriptor;
for (uint i = 0; i < vdVertexLayouts.Length; i++)
{
uint layoutIndex = ResourceBindingModel == ResourceBindingModel.Improved
? NonVertexBufferCount + i
: i;
MTLVertexBufferLayoutDescriptor mtlLayout = vertexDescriptor.layouts[layoutIndex];
mtlLayout.stride = (UIntPtr)vdVertexLayouts[i].Stride;
uint stepRate = vdVertexLayouts[i].InstanceStepRate;
mtlLayout.stepFunction = stepRate == 0 ? MTLVertexStepFunction.PerVertex : MTLVertexStepFunction.PerInstance;
mtlLayout.stepRate = (UIntPtr)Math.Max(1, stepRate);
}
uint element = 0;
for (uint i = 0; i < vdVertexLayouts.Length; i++)
{
uint offset = 0;
VertexLayoutDescription vdDesc = vdVertexLayouts[i];
for (uint j = 0; j < vdDesc.Elements.Length; j++)
{
VertexElementDescription elementDesc = vdDesc.Elements[j];
MTLVertexAttributeDescriptor mtlAttribute = vertexDescriptor.attributes[element];
mtlAttribute.bufferIndex = (UIntPtr)(ResourceBindingModel == ResourceBindingModel.Improved
? NonVertexBufferCount + i
: i);
mtlAttribute.format = MTLFormats.VdToMTLVertexFormat(elementDesc.Format);
mtlAttribute.offset = elementDesc.Offset != 0 ? (UIntPtr)elementDesc.Offset : (UIntPtr)offset;
offset += FormatHelpers.GetSizeInBytes(elementDesc.Format);
element += 1;
}
}
VertexBufferCount = (uint)vdVertexLayouts.Length;
// Outputs
OutputDescription outputs = description.Outputs;
BlendStateDescription blendStateDesc = description.BlendState;
BlendColor = blendStateDesc.BlendFactor;
if (outputs.SampleCount != TextureSampleCount.Count1)
{
mtlDesc.sampleCount = (UIntPtr)FormatHelpers.GetSampleCountUInt32(outputs.SampleCount);
}
if (outputs.DepthAttachment != null)
{
PixelFormat depthFormat = outputs.DepthAttachment.Value.Format;
MTLPixelFormat mtlDepthFormat = MTLFormats.VdToMTLPixelFormat(depthFormat, true);
mtlDesc.depthAttachmentPixelFormat = mtlDepthFormat;
if ((FormatHelpers.IsStencilFormat(depthFormat)))
{
HasStencil = true;
mtlDesc.stencilAttachmentPixelFormat = mtlDepthFormat;
}
}
for (uint i = 0; i < outputs.ColorAttachments.Length; i++)
{
BlendAttachmentDescription attachmentBlendDesc = blendStateDesc.AttachmentStates[i];
MTLRenderPipelineColorAttachmentDescriptor colorDesc = mtlDesc.colorAttachments[i];
colorDesc.pixelFormat = MTLFormats.VdToMTLPixelFormat(outputs.ColorAttachments[i].Format, false);
colorDesc.blendingEnabled = attachmentBlendDesc.BlendEnabled;
colorDesc.alphaBlendOperation = MTLFormats.VdToMTLBlendOp(attachmentBlendDesc.AlphaFunction);
colorDesc.sourceAlphaBlendFactor = MTLFormats.VdToMTLBlendFactor(attachmentBlendDesc.SourceAlphaFactor);
colorDesc.destinationAlphaBlendFactor = MTLFormats.VdToMTLBlendFactor(attachmentBlendDesc.DestinationAlphaFactor);
colorDesc.rgbBlendOperation = MTLFormats.VdToMTLBlendOp(attachmentBlendDesc.ColorFunction);
colorDesc.sourceRGBBlendFactor = MTLFormats.VdToMTLBlendFactor(attachmentBlendDesc.SourceColorFactor);
colorDesc.destinationRGBBlendFactor = MTLFormats.VdToMTLBlendFactor(attachmentBlendDesc.DestinationColorFactor);
}
RenderPipelineState = gd.Device.newRenderPipelineStateWithDescriptor(mtlDesc);
ObjectiveCRuntime.release(mtlDesc.NativePtr);
if (outputs.DepthAttachment != null)
{
MTLDepthStencilDescriptor depthDescriptor = MTLUtil.AllocInit <MTLDepthStencilDescriptor>(
nameof(MTLDepthStencilDescriptor));
depthDescriptor.depthCompareFunction = MTLFormats.VdToMTLCompareFunction(
description.DepthStencilState.DepthComparison);
depthDescriptor.depthWriteEnabled = description.DepthStencilState.DepthWriteEnabled;
bool stencilEnabled = description.DepthStencilState.StencilTestEnabled;
if (stencilEnabled)
{
StencilReference = description.DepthStencilState.StencilReference;
StencilBehaviorDescription vdFrontDesc = description.DepthStencilState.StencilFront;
MTLStencilDescriptor front = MTLUtil.AllocInit <MTLStencilDescriptor>(nameof(MTLStencilDescriptor));
front.readMask = stencilEnabled ? description.DepthStencilState.StencilReadMask : 0u;
front.writeMask = stencilEnabled ? description.DepthStencilState.StencilWriteMask : 0u;
front.depthFailureOperation = MTLFormats.VdToMTLStencilOperation(vdFrontDesc.DepthFail);
front.stencilFailureOperation = MTLFormats.VdToMTLStencilOperation(vdFrontDesc.Fail);
front.depthStencilPassOperation = MTLFormats.VdToMTLStencilOperation(vdFrontDesc.Pass);
front.stencilCompareFunction = MTLFormats.VdToMTLCompareFunction(vdFrontDesc.Comparison);
depthDescriptor.frontFaceStencil = front;
StencilBehaviorDescription vdBackDesc = description.DepthStencilState.StencilBack;
MTLStencilDescriptor back = MTLUtil.AllocInit <MTLStencilDescriptor>(nameof(MTLStencilDescriptor));
back.readMask = stencilEnabled ? description.DepthStencilState.StencilReadMask : 0u;
back.writeMask = stencilEnabled ? description.DepthStencilState.StencilWriteMask : 0u;
back.depthFailureOperation = MTLFormats.VdToMTLStencilOperation(vdBackDesc.DepthFail);
back.stencilFailureOperation = MTLFormats.VdToMTLStencilOperation(vdBackDesc.Fail);
back.depthStencilPassOperation = MTLFormats.VdToMTLStencilOperation(vdBackDesc.Pass);
back.stencilCompareFunction = MTLFormats.VdToMTLCompareFunction(vdBackDesc.Comparison);
depthDescriptor.backFaceStencil = back;
ObjectiveCRuntime.release(front.NativePtr);
ObjectiveCRuntime.release(back.NativePtr);
}
DepthStencilState = gd.Device.newDepthStencilStateWithDescriptor(depthDescriptor);
ObjectiveCRuntime.release(depthDescriptor.NativePtr);
}
DepthClipMode = description.DepthStencilState.DepthTestEnabled ? MTLDepthClipMode.Clip : MTLDepthClipMode.Clamp;
}
