public override void Activate()
{
if (state != ActivableState.Activated)
{
List <VkSubpassDescription> spDescs = new List <VkSubpassDescription> ();
foreach (SubPass sp in subpasses)
{
spDescs.Add(sp.SubpassDescription);
}
VkRenderPassCreateInfo renderPassInfo = VkRenderPassCreateInfo.New();
renderPassInfo.attachmentCount = (uint)attachments.Count;
renderPassInfo.pAttachments = attachments.Pin();
renderPassInfo.subpassCount = (uint)spDescs.Count;
renderPassInfo.pSubpasses = spDescs.Pin();
renderPassInfo.dependencyCount = (uint)dependencies.Count;
renderPassInfo.pDependencies = dependencies.Pin();
handle = Dev.CreateRenderPass(renderPassInfo);
foreach (SubPass sp in subpasses)
{
sp.UnpinLists();
}
attachments.Unpin();
spDescs.Unpin();
dependencies.Unpin();
}
base.Activate();
}
internal void CreateRenderPass()
{
VkFormat ColorFormat = NativeDevice.NativeSwapChain.VkColorFormat;
VkAttachmentDescription colorAttachment = new VkAttachmentDescription()
{
format = ColorFormat,
samples = VkSampleCountFlags.Count1,
loadOp = VkAttachmentLoadOp.Clear,
storeOp = VkAttachmentStoreOp.Store,
stencilLoadOp = VkAttachmentLoadOp.DontCare,
stencilStoreOp = VkAttachmentStoreOp.DontCare,
initialLayout = VkImageLayout.Undefined,
finalLayout = VkImageLayout.PresentSrcKHR,
};
VkAttachmentReference colorAttachmentRef = new VkAttachmentReference()
{
attachment = 0,
layout = VkImageLayout.ColorAttachmentOptimal,
};
VkSubpassDescription subpass = new VkSubpassDescription()
{
pipelineBindPoint = VkPipelineBindPoint.Graphics,
colorAttachmentCount = 1,
pColorAttachments = &colorAttachmentRef,
};
VkSubpassDependency dependency = new VkSubpassDependency()
{
srcSubpass = SubpassExternal,
dstSubpass = 0,
srcStageMask = VkPipelineStageFlags.ColorAttachmentOutput,
srcAccessMask = 0,
dstStageMask = VkPipelineStageFlags.ColorAttachmentOutput,
dstAccessMask = VkAccessFlags.ColorAttachmentRead | VkAccessFlags.ColorAttachmentWrite,
};
VkRenderPassCreateInfo renderPassCI = new VkRenderPassCreateInfo()
{
sType = VkStructureType.RenderPassCreateInfo,
attachmentCount = 1,
pAttachments = &colorAttachment,
subpassCount = 1,
pSubpasses = &subpass,
dependencyCount = 1,
pDependencies = &dependency,
};
vkCreateRenderPass(NativeDevice.Device, ref renderPassCI, null, out var RenderPass);
NativeRenderPass = RenderPass;
}
public static VkResult vkCreateFramebuffer(
VkDevice device,
VkRenderPass renderPass,
ReadOnlySpan <VkImageView> attachments,
uint width,
uint height,
uint layers,
out VkFramebuffer framebuffer)
{
fixed(VkImageView *attachmentsPtr = attachments)
{
VkFramebufferCreateInfo createInfo = new VkFramebufferCreateInfo
{
sType = VkStructureType.FramebufferCreateInfo,
renderPass = renderPass,
attachmentCount = (uint)attachments.Length,
pAttachments = attachmentsPtr,
width = width,
height = height,
layers = layers
};
return(vkCreateFramebuffer(device, &createInfo, null, out framebuffer));
}
}
private void CreateRenderPass()
{
var colorAttachment = new VkAttachmentDescription()
{
format = vkSwapChainImageFormat,
samples = VkSampleCountFlagBits.VK_SAMPLE_COUNT_1_BIT,
loadOp = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_CLEAR,
storeOp = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_STORE,
stencilLoadOp = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_DONT_CARE,
stencilStoreOp = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_DONT_CARE,
initialLayout = VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED,
finalLayout = VkImageLayout.VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
};
var colorAttachmentRef = new VkAttachmentReference()
{
attachment = 0,
layout = VkImageLayout.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
};
var subpass = new VkSubpassDescription()
{
pipelineBindPoint = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_GRAPHICS,
colorAttachmentCount = 1,
pColorAttachments = &colorAttachmentRef,
};
var dependency = new VkSubpassDependency()
{
srcSubpass = VK_SUBPASS_EXTERNAL,
srcStageMask = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
srcAccessMask = 0,
dstSubpass = 0,
dstStageMask = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
dstAccessMask = VkAccessFlagBits.VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
};
var renderPassInfo = new VkRenderPassCreateInfo()
{
sType = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
attachmentCount = 1,
pAttachments = &colorAttachment,
subpassCount = 1,
pSubpasses = &subpass,
dependencyCount = 1,
pDependencies = &dependency,
};
VkRenderPass newRenderPass;
var result = VulkanNative.vkCreateRenderPass(vkDevice, &renderPassInfo, null, &newRenderPass);
vkRenderPass = newRenderPass;
Helpers.CheckErrors(result);
}
private void BeginCurrentRenderPass()
{
Debug.Assert(_activeRenderPass == VkRenderPass.Null);
VkRenderPassBeginInfo renderPassBI = VkRenderPassBeginInfo.New();
renderPassBI.framebuffer = _currentFramebuffer.CurrentFramebuffer;
renderPassBI.renderPass = _currentFramebuffer.RenderPass;
renderPassBI.renderArea = new VkRect2D(_currentFramebuffer.Width, _currentFramebuffer.Height);
vkCmdBeginRenderPass(_cb, ref renderPassBI, VkSubpassContents.Inline);
_activeRenderPass = _currentFramebuffer.RenderPass;
}
public static VkGraphicsPipelineCreateInfo pipelineCreateInfo(
VkPipelineLayout layout,
VkRenderPass renderPass,
VkPipelineCreateFlags flags = 0)
{
VkGraphicsPipelineCreateInfo pipelineCreateInfo = VkGraphicsPipelineCreateInfo.New();
pipelineCreateInfo.layout = layout;
pipelineCreateInfo.renderPass = renderPass;
pipelineCreateInfo.flags = flags;
pipelineCreateInfo.basePipelineIndex = -1;
pipelineCreateInfo.basePipelineHandle = new VkPipeline();
return(pipelineCreateInfo);
}
void CreateRenderPass()
{
var colorAttachment = new VkAttachmentDescription();
colorAttachment.format = swapchainImageFormat;
colorAttachment.samples = VkSampleCountFlags._1_Bit;
colorAttachment.loadOp = VkAttachmentLoadOp.Clear;
colorAttachment.storeOp = VkAttachmentStoreOp.Store;
colorAttachment.stencilLoadOp = VkAttachmentLoadOp.DontCare;
colorAttachment.stencilStoreOp = VkAttachmentStoreOp.DontCare;
colorAttachment.initialLayout = VkImageLayout.Undefined;
colorAttachment.finalLayout = VkImageLayout.PresentSrcKhr;
var colorAttachmentRef = new VkAttachmentReference();
colorAttachmentRef.attachment = 0;
colorAttachmentRef.layout = VkImageLayout.ColorAttachmentOptimal;
var subpass = new VkSubpassDescription();
subpass.pipelineBindPoint = VkPipelineBindPoint.Graphics;
subpass.colorAttachments = new List <VkAttachmentReference> {
colorAttachmentRef
};
var dependency = new VkSubpassDependency();
dependency.srcSubpass = -1; //VK_SUBPASS_EXTERNAL
dependency.dstSubpass = 0;
dependency.srcStageMask = VkPipelineStageFlags.BottomOfPipeBit;
dependency.srcAccessMask = VkAccessFlags.MemoryReadBit;
dependency.dstStageMask = VkPipelineStageFlags.ColorAttachmentOutputBit;
dependency.dstAccessMask = VkAccessFlags.ColorAttachmentReadBit
| VkAccessFlags.ColorAttachmentWriteBit;
var info = new VkRenderPassCreateInfo();
info.attachments = new List <VkAttachmentDescription> {
colorAttachment
};
info.subpasses = new List <VkSubpassDescription> {
subpass
};
info.dependencies = new List <VkSubpassDependency> {
dependency
};
renderPass?.Dispose();
renderPass = new VkRenderPass(device, info);
}
private VkPipeline CreateGraphicsPipeline(VkDevice device, VkRenderPass renderPass)
{
VkPipeline pipeline = null;
var createInfo = new VkGraphicsPipelineCreateInfo()
{
inputAssemblyState = m_inputAssemblyState,
vertexInputState = m_vertexInputState,
pRasterizationState = m_rasterizationState,
pDepthStencilState = m_depthStencilState,
pColorBlendState = m_colorBlendState,
pMultisampleState = m_multisampleState,
pStages = m_shaderStages,
viewportState = m_viewportState,
layout = m_pipelineLayout,
renderPass = renderPass
};
VulkanAPI.vkCreateGraphicsPipelines(device, null, 1, ref createInfo, out pipeline);
return(pipeline);
}
private void EndCurrentRenderPass()
{
Debug.Assert(_activeRenderPass != VkRenderPass.Null);
vkCmdEndRenderPass(_cb);
_activeRenderPass = VkRenderPass.Null;
// Place a barrier between RenderPasses, so that color / depth outputs
// can be read in subsequent passes.
vkCmdPipelineBarrier(
_cb,
VkPipelineStageFlags.BottomOfPipe,
VkPipelineStageFlags.TopOfPipe,
VkDependencyFlags.None,
0,
null,
0,
null,
0,
null);
}
protected override void InitializeFrame()
{
_depthStencilBuffer = ToDispose(VulkanImage.DepthStencil(Context, Host.Width, Host.Height));
var renderPass = CreateRenderPass();
_renderPass = renderPass;
ToDispose(new ActionDisposable(() =>
{
vkDestroyRenderPass(Context.Device, renderPass, null);
}));
var imageViews = CreateImageViews();
_imageViews = imageViews;
ToDispose(new ActionDisposable(() =>
{
foreach (var imageView in imageViews)
{
vkDestroyImageView(Context.Device, imageView, null);
}
}));
var frameBuffers = CreateFramebuffers();
_framebuffers = frameBuffers;
ToDispose(new ActionDisposable(() =>
{
foreach (var frameBuffer in frameBuffers)
{
vkDestroyFramebuffer(Context.Device, frameBuffer, null);
}
}));
var pipeline = CreateGraphicsPipeline();
_pipeline = pipeline;
ToDispose(new ActionDisposable(() =>
{
vkDestroyPipeline(Context.Device, pipeline, null);
}));
SetViewProjection();
}
static VkFramebuffer CreateFramebuffer(VkDevice device, VkRenderPass pass, VkImageView imageView, VkImageView depthImageView)
{
VkImageView[] imageViews = new VkImageView[] {
imageView,
depthImageView
};
VkFramebufferCreateInfo createInfo = VkFramebufferCreateInfo.New();
createInfo.renderPass = pass;
createInfo.attachmentCount = (uint)imageViews.Length;
fixed(VkImageView *ptr = imageViews)
createInfo.pAttachments = ptr;
createInfo.width = (uint)width;
createInfo.height = (uint)height;
createInfo.layers = 1;
VkFramebuffer framebuffer = VkFramebuffer.Null;
Assert(vkCreateFramebuffer(device, &createInfo, null, &framebuffer));
return(framebuffer);
}
public static VkResult vkCreateRenderPass(VkDevice device, VkRenderPassCreateInfo renderPassInfo, VkAllocationCallbacks pAllocator, out VkRenderPass renderPass)
{
VkPreconditions.CheckNull(device, nameof(device));
return(GetDevice(device).CreateRenderPass(renderPassInfo, out renderPass));
}
public Framebuffer(VkDevice Device, int Width, int Height)
{
_Device = Device;
_Width = Width;
_Height = Height;
_FrameBufferColor = _Device.CreateImage(VkImageCreateFlag.NONE,
VkFormat.VK_FORMAT_B8G8R8A8_SRGB,
Width, Height,
1, 1,
VkSampleCountFlag.VK_SAMPLE_COUNT_1,
VkImageTiling.VK_IMAGE_TILING_OPTIMAL,
VkImageUsageFlag.VK_IMAGE_USAGE_COLOR_ATTACHMENT,
VkSharingMode.VK_SHARING_MODE_EXCLUSIVE,
null,
VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED);
_ImageSize = _FrameBufferColor.MemoryRequirements.size;
// We will back this image with Device Accessible Memomy so we can map it an copy
// the content from the Host.
// To do so we need to find the right memory type first.
VkMemoryType deviceMemory = new VkMemoryType();
foreach (VkMemoryType memoryType in _FrameBufferColor.MemoryRequirements.memoryTypes)
{
// Pick the first memory type that can be mapped into host memory
if ((memoryType.propertyFlags & VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_DEVICE_LOCAL) != 0)
{
deviceMemory = memoryType;
break;
}
}
VkDeviceMemory FrameBufferMemory = _Device.AllocateMemory(_FrameBufferColor.MemoryRequirements.size, deviceMemory);
_FrameBufferColor.BindMemory(FrameBufferMemory, 0);
// Allocate the host visible memory to transfer the framebuffer
_TransferBuffer = _Device.CreateBuffer(0, _FrameBufferColor.MemoryRequirements.size, VkBufferUsageFlag.VK_BUFFER_USAGE_TRANSFER_DST, VkSharingMode.VK_SHARING_MODE_EXCLUSIVE, new VkQueueFamilyProperties[] { _Device.Queues[0].Family });
// We will use a host visible buffer so we can map it an copy
// the content from the Host.
// To do so we need to find the right memory type first.
VkMemoryType hostMemory = new VkMemoryType();
foreach (VkMemoryType memoryType in _TransferBuffer.MemoryRequirements.memoryTypes)
{
// Pick the first memory type that can be mapped into host memory
if ((memoryType.propertyFlags & VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_HOST_VISIBLE) != 0)
{
hostMemory = memoryType;
break;
}
}
VkDeviceMemory TransferBufferMemory = _Device.AllocateMemory(_ImageSize, hostMemory);
_TransferBuffer.BindMemory(TransferBufferMemory, 0);
_TransferBufferPtr = TransferBufferMemory.Map(0, _ImageSize, VkMemoryMapFlag.NONE);
VkImageView imageView = _FrameBufferColor.CreateImageView(VkImageViewType.VK_IMAGE_VIEW_TYPE_2D, new VkImageSubresourceRange()
{
aspectMask = VkImageAspectFlag.VK_IMAGE_ASPECT_COLOR_BIT, baseArrayLayer = 0, baseMipLevel = 0, layerCount = 1, levelCount = 1
});
VkAttachmentDescription colorAttachment = new VkAttachmentDescription();
colorAttachment.format = _FrameBufferColor.Format;
colorAttachment.samples = VkSampleCountFlag.VK_SAMPLE_COUNT_1;
colorAttachment.loadOp = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.stencilLoadOp = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_DONT_CARE;
colorAttachment.stencilStoreOp = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_DONT_CARE;
colorAttachment.initialLayout = VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED;
colorAttachment.finalLayout = VkImageLayout.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkAttachmentReference colorAttachmentReference = new VkAttachmentReference();
colorAttachmentReference.attachment = 0;
colorAttachmentReference.layout = VkImageLayout.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass = new VkSubpassDescription();
subpass.pipelineBindPoint = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachments = new VkAttachmentReference[] { colorAttachmentReference };
subpass.depthStencilAttachment = null;
subpass.inputAttachments = null;
subpass.preserveAttachments = null;
subpass.resolveAttachments = null;
VkSubpassDependency dependency = new VkSubpassDependency();
dependency.srcSubpass = VkSubpassDependency.VK_SUBPASS_EXTERNAL;
dependency.dstSubpass = 0;
dependency.srcStageMask = VkPipelineStageFlag.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT;
dependency.srcAccessMask = 0;
dependency.dstStageMask = VkPipelineStageFlag.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT;
dependency.dstAccessMask = VkAccessFlag.VK_ACCESS_COLOR_ATTACHMENT_READ | VkAccessFlag.VK_ACCESS_COLOR_ATTACHMENT_WRITE;
_RenderPass = _Device.CreateRenderPass(new VkAttachmentDescription[] { colorAttachment },
new VkSubpassDescription[] { subpass },
new VkSubpassDependency[] { dependency });
_Framebuffer = _Device.CreateFramebuffer(_RenderPass, new VkImageView[] { imageView }, (uint)Width, (uint)Height, 1);
}
private void EndCurrentRenderPass()
{
Debug.Assert(_activeRenderPass != VkRenderPass.Null);
vkCmdEndRenderPass(_cb);
_activeRenderPass = VkRenderPass.Null;
}
public static void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks pAllocator)
{
VkPreconditions.CheckNull(device, nameof(device));
GetDevice(device).DestroyRenderPass(renderPass);
}
public static extern void DestroyRenderPass(
VkDevice device,
VkRenderPass renderPass,
IntPtr pAllocator
);
public static extern void GetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
out VkExtent2D pGranularity
);
public static VkResult vkCreateFramebuffer(
VkDevice device,
VkRenderPass renderPass,
ReadOnlySpan <VkImageView> attachments,
in Size extent,
public static extern VkResult CreateRenderPass(
VkDevice device,
ref VkRenderPassCreateInfo pCreateInfo,
IntPtr pAllocator,
out VkRenderPass pRenderPass
);
public RenderPass(Device dev, VkRenderPass handle)
{
Device = dev;
Handle = handle;
}
VkPipeline CreatePipeline(VkDevice device, VkSurfaceCapabilitiesKHR surfaceCapabilities,
VkRenderPass renderPass, VkPipelineLayout pipelineLayout)
{
//VkShaderModule vertexShaderModule = device.CreateShaderModule(LoadResource(@"Shaders\shader.vert.spv"));
VkShaderModule vsModule;
{
var info = new VkShaderModuleCreateInfo {
sType = VkStructureType.ShaderModuleCreateInfo
};
byte[] bytes = LoadResource(@"Shaders\shader.vert.spv");
info.code = bytes;
//vkAPI.vkCreateShaderModule(device, bytes);
vkAPI.vkCreateShaderModule(device, &info, null, &vsModule).Check();
info.Free();
}
//VkShaderModule fragmentShaderModule = device.CreateShaderModule(LoadResource(@"Shaders\shader.frag.spv"));
VkShaderModule fsModule;
{
var info = new VkShaderModuleCreateInfo {
sType = VkStructureType.ShaderModuleCreateInfo
};
byte[] bytes = LoadResource(@"Shaders\shader.frag.spv");
info.code = bytes;
//vkAPI.vkCreateShaderModule(device, bytes);
vkAPI.vkCreateShaderModule(device, &info, null, &fsModule).Check();
info.Free();
}
var shaderStages = new VkPipelineShaderStageCreateInfo[2];
{
shaderStages[0].sType = VkStructureType.PipelineShaderStageCreateInfo;
shaderStages[0].stage = VkShaderStageFlagBits.Vertex;
shaderStages[0].module = vsModule;
//"main".Set(ref shaderStages[0].pName);
shaderStages[0].pName = "main";
shaderStages[1].sType = VkStructureType.PipelineShaderStageCreateInfo;
shaderStages[1].stage = VkShaderStageFlagBits.Fragment;
shaderStages[1].module = fsModule;
//"main".Set(ref shaderStages[1].pName);
shaderStages[1].pName = "main";
}
var viewport = new VkPipelineViewportStateCreateInfo {
sType = VkStructureType.PipelineViewportStateCreateInfo
};
viewport.viewports = new VkViewport(surfaceCapabilities.currentExtent, 0.0f, 1.0f);
viewport.scissors = new VkRect2D(surfaceCapabilities.currentExtent);
var multisample = new VkPipelineMultisampleStateCreateInfo {
sType = VkStructureType.PipelineMultisampleStateCreateInfo
};
multisample.rasterizationSamples = VkSampleCountFlagBits._1;
var colorBlend = new VkPipelineColorBlendStateCreateInfo {
sType = VkStructureType.PipelineColorBlendStateCreateInfo
};
colorBlend.logicOp = VkLogicOp.Copy;
var blend = new VkPipelineColorBlendAttachmentState(
colorWriteMask: VkColorComponentFlagBits.R | VkColorComponentFlagBits.G
| VkColorComponentFlagBits.B | VkColorComponentFlagBits.A,
blendEnable: false);
colorBlend.attachments = blend;
var rasterization = new VkPipelineRasterizationStateCreateInfo {
sType = VkStructureType.PipelineRasterizationStateCreateInfo
};
rasterization.polygonMode = VkPolygonMode.Fill;
rasterization.cullMode = VkCullModeFlagBits.None;
rasterization.frontFace = VkFrontFace.Clockwise;
rasterization.lineWidth = 1.0f;
var inputAssem = new VkPipelineInputAssemblyStateCreateInfo {
sType = VkStructureType.PipelineInputAssemblyStateCreateInfo
};
inputAssem.topology = VkPrimitiveTopology.TriangleList;
var input = new VkPipelineVertexInputStateCreateInfo {
sType = VkStructureType.PipelineVertexInputStateCreateInfo
};
// static readonly float[] Vertices = { .. }
input.vertexBindingDescriptions = new VkVertexInputBindingDescription(
binding: 0,
stride: 2 * sizeof(float),
inputRate: VkVertexInputRate.Vertex);
// layout(location = 0) in vec2 inPos;
input.vertexAttributeDescriptions = new VkVertexInputAttributeDescription(
location: 0,
binding: 0,
format: VkFormat.R32g32Sfloat,
offset: 0);
//VkPipelineCache cache = device.CreatePipelineCache(ref cacheInfo);
VkPipelineCache cache;
{
var info = VkPipelineCacheCreateInfo.Alloc();
vkAPI.vkCreatePipelineCache(device, info, null, &cache).Check();
Marshal.FreeHGlobal((IntPtr)info);
}
//var infos = new VkGraphicsPipelineCreateInfo[] { pipelineCreateInfo };
//return device.CreateGraphicsPipelines(ref cache, infos);
VkPipeline pipeline;
{
var info = new VkGraphicsPipelineCreateInfo {
sType = VkStructureType.GraphicsPipelineCreateInfo
};
info.layout = pipelineLayout;
info.pViewportState = &viewport;
info.stages = shaderStages;
info.pMultisampleState = &multisample;
info.pColorBlendState = &colorBlend;
info.pRasterizationState = &rasterization;
info.pInputAssemblyState = &inputAssem;
info.pVertexInputState = &input;
info.renderPass = renderPass;
vkAPI.vkCreateGraphicsPipelines(device, cache, 1, &info, null, &pipeline).Check();
info.Free();
}
shaderStages[0].Free();
shaderStages[1].Free();
viewport.Free();
colorBlend.Free();
input.Free();
return(pipeline);
}
public void Init(IntPtr hwnd, IntPtr processHandle)
{
if (this.isInitialized)
{
return;
}
this.instance = InitInstance();
InitDebugCallback(this.instance);
this.surface = InitSurface(this.instance, hwnd, processHandle);
this.vkPhysicalDevice = InitPhysicalDevice(this.instance);
VkSurfaceFormatKHR surfaceFormat = SelectFormat(this.vkPhysicalDevice, this.surface);
this.device = CreateDevice(this.vkPhysicalDevice, this.surface);
this.vkQueue = this.device.GetQueue(0, 0);
VkSurfaceCapabilitiesKHR surfaceCapabilities;
//this.vkPhysicalDevice.GetSurfaceCapabilitiesKhr(this.vkSurface, out surfaceCapabilities);
vkAPI.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(this.vkPhysicalDevice, this.surface, &surfaceCapabilities).Check();
this.swapchain = CreateSwapchain(this.device, this.surface, surfaceFormat, surfaceCapabilities);
this.vkImages = this.device.GetSwapchainImages(this.swapchain);
this.renderPass = CreateRenderPass(this.device, surfaceFormat);
this.framebuffers = CreateFramebuffers(this.device, this.vkImages, surfaceFormat, this.renderPass, surfaceCapabilities);
this.vkFence = this.device.CreateFence();
this.vkSemaphore = this.device.CreateSemaphore();
// buffers for vertex data.
VkBuffer vertexBuffer = CreateBuffer(this.vkPhysicalDevice, this.device, Vertices, VkBufferUsageFlagBits.VertexBuffer, typeof(float));
VkBuffer indexBuffer = CreateBuffer(this.vkPhysicalDevice, this.device, Indexes, VkBufferUsageFlagBits.IndexBuffer, typeof(short));
var uniformBufferData = new AreaUniformBuffer(1, 1);
this.originalWidth = 1; this.width = this.originalWidth;
this.originalHeight = 1; this.height = this.originalHeight;
this.uniformBuffer = CreateBuffer(this.vkPhysicalDevice, this.device, uniformBufferData, VkBufferUsageFlagBits.UniformBuffer, typeof(AreaUniformBuffer));
this.descriptorSetLayout = CreateDescriptorSetLayout(this.device);
this.vkPipelineLayout = CreatePipelineLayout(this.device, this.descriptorSetLayout);
VkPipeline pipeline = CreatePipeline(this.device, surfaceCapabilities, this.renderPass, this.vkPipelineLayout);
this.descriptorSet = CreateDescriptorSet(this.device, this.descriptorSetLayout);
UpdateDescriptorSets(this.device, this.uniformBuffer, this.descriptorSet);
this.commandBuffers = CreateCommandBuffers(
this.device, this.renderPass, surfaceCapabilities,
this.vkImages, this.framebuffers, pipeline,
vertexBuffer, indexBuffer, (uint)Indexes.Length,
this.vkPipelineLayout, this.descriptorSet);
this.isInitialized = true;
}
public abstract VkResult CreateRenderPass(VkRenderPassCreateInfo renderPassInfo, out VkRenderPass renderPass);
public RenderPass(GraphicsDevice device)
{
vkRenderPass = default;
this.device = device;
}
private void BeginCurrentRenderPass()
{
Debug.Assert(_activeRenderPass == VkRenderPass.Null);
Debug.Assert(_currentFramebuffer != null);
_currentFramebufferEverActive = true;
uint attachmentCount = _currentFramebuffer.AttachmentCount;
bool haveAnyAttachments = _currentFramebuffer.ColorTargets.Count > 0 || _currentFramebuffer.DepthTarget != null;
bool haveAllClearValues = _depthClearValue.HasValue || _currentFramebuffer.DepthTarget == null;
bool haveAnyClearValues = _depthClearValue.HasValue;
for (int i = 0; i < _currentFramebuffer.ColorTargets.Count; i++)
{
if (!_validColorClearValues[i])
{
haveAllClearValues = false;
haveAnyClearValues = true;
}
else
{
haveAnyClearValues = true;
}
}
VkRenderPassBeginInfo renderPassBI = VkRenderPassBeginInfo.New();
renderPassBI.renderArea = new VkRect2D(_currentFramebuffer.RenderableWidth, _currentFramebuffer.RenderableHeight);
renderPassBI.framebuffer = _currentFramebuffer.CurrentFramebuffer;
if (!haveAnyAttachments || !haveAllClearValues)
{
renderPassBI.renderPass = _newFramebuffer
? _currentFramebuffer.RenderPassNoClear_Init
: _currentFramebuffer.RenderPassNoClear_Load;
vkCmdBeginRenderPass(_cb, ref renderPassBI, VkSubpassContents.Inline);
_activeRenderPass = renderPassBI.renderPass;
if (haveAnyClearValues)
{
if (_depthClearValue.HasValue)
{
ClearDepthStencil(_depthClearValue.Value.depthStencil.depth, (byte)_depthClearValue.Value.depthStencil.stencil);
_depthClearValue = null;
}
for (uint i = 0; i < _currentFramebuffer.ColorTargets.Count; i++)
{
if (_validColorClearValues[i])
{
_validColorClearValues[i] = false;
VkClearValue vkClearValue = _clearValues[i];
RgbaFloat clearColor = new RgbaFloat(
vkClearValue.color.float32_0,
vkClearValue.color.float32_1,
vkClearValue.color.float32_2,
vkClearValue.color.float32_3);
ClearColorTarget(i, clearColor);
}
}
}
}
else
{
// We have clear values for every attachment.
renderPassBI.renderPass = _currentFramebuffer.RenderPassClear;
fixed(VkClearValue *clearValuesPtr = &_clearValues[0])
{
renderPassBI.clearValueCount = attachmentCount;
renderPassBI.pClearValues = clearValuesPtr;
if (_depthClearValue.HasValue)
{
_clearValues[_currentFramebuffer.ColorTargets.Count] = _depthClearValue.Value;
_depthClearValue = null;
}
vkCmdBeginRenderPass(_cb, ref renderPassBI, VkSubpassContents.Inline);
_activeRenderPass = _currentFramebuffer.RenderPassClear;
Util.ClearArray(_validColorClearValues);
}
}
_newFramebuffer = false;
}
public override void DestroyRenderPass(VkRenderPass renderPass)
{
throw new NotImplementedException();
}
VkCommandBuffer[] CreateCommandBuffers(
VkDevice device, VkRenderPass renderPass, VkSurfaceCapabilitiesKHR surfaceCapabilities,
VkImage[] images, VkFramebuffer[] framebuffers, VkPipeline pipeline,
VkBuffer vertexBuffer, VkBuffer indexBuffer, uint indexLength,
VkPipelineLayout pipelineLayout, VkDescriptorSet descriptorSet)
{
VkCommandBuffer[] buffers;
{
VkCommandPool pool;
{
var info = new VkCommandPoolCreateInfo {
sType = VkStructureType.CommandPoolCreateInfo
};
info.flags = VkCommandPoolCreateFlagBits.ResetCommandBuffer;
//var commandPool = device.CreateCommandPool(ref poolInfo);
vkCreateCommandPool(device, &info, null, &pool).Check();
}
{
var info = new VkCommandBufferAllocateInfo {
sType = VkStructureType.CommandBufferAllocateInfo
};
info.level = VkCommandBufferLevel.Primary;
info.commandPool = pool;
info.commandBufferCount = (uint)images.Length;
//buffers = device.AllocateCommandBuffers(ref info);
buffers = new VkCommandBuffer[info.commandBufferCount];
fixed(VkCommandBuffer *pointer = buffers)
{
vkAPI.vkAllocateCommandBuffers(device, &info, pointer).Check();
}
}
}
var cmdBeginInfo = new VkCommandBufferBeginInfo {
sType = VkStructureType.CommandBufferBeginInfo
};
var clearValue = new VkClearValue {
color = new VkClearColorValue(0.9f, 0.87f, 0.75f, 1.0f)
};
var begin = new VkRenderPassBeginInfo {
sType = VkStructureType.RenderPassBeginInfo
};
begin.renderPass = renderPass;
begin.clearValues = clearValue;
begin.renderArea = new VkRect2D {
extent = surfaceCapabilities.currentExtent
};
for (int i = 0; i < images.Length; i++)
{
VkCommandBuffer cmds = buffers[i];
//cmds.Begin(ref cmdBeginInfo);
vkAPI.vkBeginCommandBuffer(cmds, &cmdBeginInfo).Check();
begin.framebuffer = framebuffers[i];
vkAPI.vkCmdBeginRenderPass(cmds, &begin, VkSubpassContents.Inline);
vkAPI.vkCmdBindDescriptorSets(cmds, VkPipelineBindPoint.Graphics, pipelineLayout,
0, 1, &descriptorSet,
0, null);
vkAPI.vkCmdBindPipeline(cmds, VkPipelineBindPoint.Graphics, pipeline);
VkDeviceSize offset = 0;
vkAPI.vkCmdBindVertexBuffers(cmds, 0, 1, &vertexBuffer, &offset);
vkAPI.vkCmdBindIndexBuffer(cmds, indexBuffer, offset, VkIndexType.Uint16);
vkAPI.vkCmdDrawIndexed(cmds, indexLength, 1, 0, 0, 0);
vkAPI.vkCmdEndRenderPass(cmds);
vkAPI.vkEndCommandBuffer(cmds).Check();
}
begin.Free();
return(buffers);
}
public override VkResult CreateRenderPass(VkRenderPassCreateInfo renderPassInfo, out VkRenderPass renderPass)
{
throw new NotImplementedException();
}
protected VkFramebuffer[] CreateFramebuffers(VkDevice device, VkImage[] images,
VkSurfaceFormatKHR surfaceFormat, VkRenderPass renderPass,
VkSurfaceCapabilitiesKHR surfaceCapabilities)
{
var displayViews = new VkImageView[images.Length];
var viewInfo = new VkImageViewCreateInfo {
sType = VkStructureType.ImageViewCreateInfo
};
viewInfo.viewType = VkImageViewType._2d;
viewInfo.format = surfaceFormat.format;
viewInfo.components = new VkComponentMapping {
r = VkComponentSwizzle.R,
g = VkComponentSwizzle.G,
b = VkComponentSwizzle.B,
a = VkComponentSwizzle.A
};
viewInfo.subresourceRange = new VkImageSubresourceRange {
aspectMask = VkImageAspectFlagBits.Color,
levelCount = 1,
layerCount = 1
};
for (int i = 0; i < images.Length; i++)
{
viewInfo.image = images[i];
//displayViews[i] = device.CreateImageView(ref info);
VkImageView view;
vkAPI.vkCreateImageView(device, &viewInfo, null, &view).Check();
displayViews[i] = view;
}
var framebuffers = new VkFramebuffer[images.Length];
var fbInfo = new VkFramebufferCreateInfo {
sType = VkStructureType.FramebufferCreateInfo
};
fbInfo.layers = 1;
fbInfo.renderPass = renderPass;
fbInfo.width = surfaceCapabilities.currentExtent.width;
fbInfo.height = surfaceCapabilities.currentExtent.height;
for (int i = 0; i < images.Length; i++)
{
fbInfo.attachments = displayViews[i];
//framebuffers[i] = device.CreateFramebuffer(ref info);
VkFramebuffer framebuffer;
vkAPI.vkCreateFramebuffer(device, &fbInfo, null, &framebuffer).Check();
framebuffers[i] = framebuffer;
}
fbInfo.Free();
return(framebuffers);
}
private void BeginCurrentRenderPass()
{
Debug.Assert(_activeRenderPass == VkRenderPass.Null);
Debug.Assert(_currentFramebuffer != null);
_currentFramebufferEverActive = true;
uint attachmentCount = _currentFramebuffer.AttachmentCount;
bool haveAnyAttachments = _framebuffer.ColorTargets.Count > 0 || _framebuffer.DepthTarget != null;
bool haveAllClearValues = _depthClearValue.HasValue || _framebuffer.DepthTarget == null;
bool haveAnyClearValues = _depthClearValue.HasValue;
for (int i = 0; i < _currentFramebuffer.ColorTargets.Count; i++)
{
if (!_validColorClearValues[i])
{
haveAllClearValues = false;
haveAnyClearValues = true;
}
else
{
haveAnyClearValues = true;
}
}
VkRenderPassBeginInfo renderPassBI = VkRenderPassBeginInfo.New();
renderPassBI.renderArea = new VkRect2D(_currentFramebuffer.RenderableWidth, _currentFramebuffer.RenderableHeight);
renderPassBI.framebuffer = _currentFramebuffer.CurrentFramebuffer;
if (!haveAnyAttachments || !haveAllClearValues)
{
renderPassBI.renderPass = _currentFramebuffer.RenderPassNoClear;
vkCmdBeginRenderPass(_cb, ref renderPassBI, VkSubpassContents.Inline);
_activeRenderPass = _currentFramebuffer.RenderPassNoClear;
if (haveAnyClearValues)
{
if (_depthClearValue.HasValue)
{
ClearDepthStencil(_depthClearValue.Value.depthStencil.depth, (byte)_depthClearValue.Value.depthStencil.stencil);
_depthClearValue = null;
}
for (uint i = 0; i < _currentFramebuffer.ColorTargets.Count; i++)
{
if (_validColorClearValues[i])
{
_validColorClearValues[i] = false;
VkClearValue vkClearValue = _clearValues[i];
RgbaFloat clearColor = new RgbaFloat(
vkClearValue.color.float32_0,
vkClearValue.color.float32_1,
vkClearValue.color.float32_2,
vkClearValue.color.float32_3);
ClearColorTarget(i, clearColor);
}
}
}
}
else
{
// We have clear values for every attachment.
renderPassBI.renderPass = _currentFramebuffer.RenderPassClear;
fixed(VkClearValue *clearValuesPtr = &_clearValues[0])
{
renderPassBI.clearValueCount = attachmentCount;
renderPassBI.pClearValues = clearValuesPtr;
if (_depthClearValue.HasValue)
{
_clearValues[_currentFramebuffer.ColorTargets.Count] = _depthClearValue.Value;
}
vkCmdBeginRenderPass(_cb, ref renderPassBI, VkSubpassContents.Inline);
_activeRenderPass = _currentFramebuffer.RenderPassClear;
Util.ClearArray(_validColorClearValues);
}
}
// Set new image layouts
foreach (FramebufferAttachment colorTarget in _currentFramebuffer.ColorTargets)
{
VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(colorTarget.Target);
VkImageLayout layout = (vkTex.Usage & TextureUsage.Sampled) != 0
? VkImageLayout.ShaderReadOnlyOptimal
: VkImageLayout.ColorAttachmentOptimal;
vkTex.SetImageLayout(colorTarget.ArrayLayer, layout);
}
if (_currentFramebuffer.DepthTarget != null)
{
VkTexture vkDepthTex = Util.AssertSubtype <Texture, VkTexture>(_currentFramebuffer.DepthTarget.Value.Target);
VkImageLayout layout = (vkDepthTex.Usage & TextureUsage.Sampled) != 0
? VkImageLayout.ShaderReadOnlyOptimal
: VkImageLayout.DepthStencilAttachmentOptimal;
vkDepthTex.SetImageLayout(_currentFramebuffer.DepthTarget.Value.ArrayLayer, layout);
}
}
