private void createImageViews() { swapChainImageViews = new VkImageView[swapChainImages.Length]; for (int i = 0; i < swapChainImages.Length; i++) { VkImageViewCreateInfo createInfo = new VkImageViewCreateInfo(); createInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; createInfo.image = swapChainImages[i]; createInfo.viewType = VkImageViewType.VK_IMAGE_VIEW_TYPE_2D; createInfo.format = swapChainImageFormat; createInfo.components.r = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_IDENTITY; createInfo.components.g = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_IDENTITY; createInfo.components.b = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_IDENTITY; createInfo.components.a = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_IDENTITY; createInfo.subresourceRange.aspectMask = VkImageAspectFlagBits.VK_IMAGE_ASPECT_COLOR_BIT; createInfo.subresourceRange.baseMipLevel = 0; createInfo.subresourceRange.levelCount = 1; createInfo.subresourceRange.baseArrayLayer = 0; createInfo.subresourceRange.layerCount = 1; VkImageView imageView = null; VkResult result = Vulkan.vkCreateImageView(device, createInfo, default(VkAllocationCallbacks), out imageView); if (result != VkResult.VK_SUCCESS) { throw Program.Throw("failed to create image views!", result); } swapChainImageViews[i] = imageView; } }
public void CreateView(VkImageViewType type = VkImageViewType.ImageView2D, VkImageAspectFlags aspectFlags = VkImageAspectFlags.Color, uint layerCount = 1, uint baseMipLevel = 0, uint levelCount = 1, uint baseArrayLayer = 0, VkComponentSwizzle r = VkComponentSwizzle.R, VkComponentSwizzle g = VkComponentSwizzle.G, VkComponentSwizzle b = VkComponentSwizzle.B, VkComponentSwizzle a = VkComponentSwizzle.A) { VkImageView view = default(VkImageView); VkImageViewCreateInfo viewInfo = VkImageViewCreateInfo.New(); viewInfo.image = handle; viewInfo.viewType = type; viewInfo.format = Format; viewInfo.components.r = r; viewInfo.components.g = g; viewInfo.components.b = b; viewInfo.components.a = a; viewInfo.subresourceRange.aspectMask = aspectFlags; viewInfo.subresourceRange.baseMipLevel = baseMipLevel; viewInfo.subresourceRange.levelCount = levelCount; viewInfo.subresourceRange.baseArrayLayer = baseArrayLayer; viewInfo.subresourceRange.layerCount = layerCount; Utils.CheckResult(vkCreateImageView(Dev.VkDev, ref viewInfo, IntPtr.Zero, out view)); if (Descriptor.imageView.Handle != 0) { Dev.DestroyImageView(Descriptor.imageView); } Descriptor.imageView = view; }
protected virtual void SetupFrameBuffer() { var attachments = new VkImageView[2]; // Depth/Stencil attachment is the same for all frame buffers attachments[1] = DepthStencil.View; VkFramebufferCreateInfo frameBufferCreateInfo = new VkFramebufferCreateInfo(); frameBufferCreateInfo.sType = FramebufferCreateInfo; frameBufferCreateInfo.renderPass = renderPass; frameBufferCreateInfo.attachments = attachments; frameBufferCreateInfo.width = width; frameBufferCreateInfo.height = height; frameBufferCreateInfo.layers = 1; // Create frame buffers for every swap chain image frameBuffers = new VkFramebuffer[Swapchain.ImageCount]; for (uint i = 0; i < frameBuffers.Length; i++) { attachments[0] = Swapchain.Buffers[i].View; frameBufferCreateInfo.attachments = attachments; VkFramebuffer framebuffer; vkCreateFramebuffer(device, &frameBufferCreateInfo, null, &framebuffer); frameBuffers[i] = framebuffer; } }
private VkImageView[] CreateImageViews() { var imageViews = new VkImageView[SwapchainImages.Length]; for (int i = 0; i < SwapchainImages.Length; i++) { VkImageSubresourceRange range = new VkImageSubresourceRange { aspectMask = VkImageAspectFlags.Color, baseMipLevel = 0, levelCount = 1, baseArrayLayer = 0, layerCount = 1 }; VkImageViewCreateInfo createInfo = new VkImageViewCreateInfo { sType = VkStructureType.ImageViewCreateInfo, pNext = null, format = SwapchainFormat, viewType = VkImageViewType.Image2D, subresourceRange = range, image = SwapchainImages[i] }; VkImageView imageView; vkCreateImageView(Context.Device, &createInfo, null, out imageView); imageViews[i] = imageView; } return(imageViews); }
private VulkanImage(VulkanContext ctx, VkImage image, VkDeviceMemory memory, VkImageView view, VkFormat format) { Image = image; Memory = memory; View = view; Format = format; this.ctx = ctx; }
public FTexture(VkDevice device, VkPhysicalDevice physicalDevice, int cmdPoolID, VkQueue queue, string[] paths, VkFormat format, int width, int height, uint mipLevels = 1) { MipLevels = mipLevels; image = LoadTexture(device, physicalDevice, cmdPoolID, queue, paths, MipLevels); imageView = CreateColourImageArrayView(device, image, paths.Length, format, MipLevels); InitMips(device, queue, image, width, height, MipLevels, (uint)paths.Length, cmdPoolID); }
public static VkDescriptorImageInfo descriptorImageInfo(VkSampler sampler, VkImageView imageView, VkImageLayout imageLayout) { VkDescriptorImageInfo descriptorImageInfo = new VkDescriptorImageInfo(); descriptorImageInfo.sampler = sampler; descriptorImageInfo.imageView = imageView; descriptorImageInfo.imageLayout = imageLayout; return(descriptorImageInfo); }
private void DisposeVulkanSwapChainImageView(VkImageView vulkanSwapchainImageView) { _state.AssertDisposing(); if (vulkanSwapchainImageView != VK_NULL_HANDLE) { vkDestroyImageView(VulkanGraphicsDevice.VulkanDevice, vulkanSwapchainImageView, pAllocator: null); } }
public void SetFullHandles(VkImage image, VkImageView attachmentView, VkImageLayout layout, VkAccessFlags accessMask, VkFormat nativeFormat, VkImageAspectFlags aspect) { NativeImage = image; NativeColorAttachmentView = attachmentView; NativeLayout = layout; NativeAccessMask = accessMask; NativeFormat = nativeFormat; NativeImageAspect = aspect; }
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); }
/// <inheritdoc/> protected internal override void OnDestroyed() { if (ParentTexture != null || isNotOwningResources) { NativeImage = VkImage.Null; NativeMemory = VkDeviceMemory.Null; } if (!isNotOwningResources) { if (NativeMemory != VkDeviceMemory.Null) { GraphicsDevice.Collect(NativeMemory); NativeMemory = VkDeviceMemory.Null; SharedHandle = IntPtr.Zero; } if (NativeImage != VkImage.Null) { GraphicsDevice.Collect(NativeImage); NativeImage = VkImage.Null; } if (NativeBuffer != VkBuffer.Null) { GraphicsDevice.Collect(NativeBuffer); NativeBuffer = VkBuffer.Null; } if (NativeImageView != VkImageView.Null) { GraphicsDevice.Collect(NativeImageView); NativeImageView = VkImageView.Null; } if (NativeColorAttachmentView != VkImageView.Null) { GraphicsDevice.Collect(NativeColorAttachmentView); NativeColorAttachmentView = VkImageView.Null; } if (NativeDepthStencilView != VkImageView.Null) { GraphicsDevice.Collect(NativeDepthStencilView); NativeDepthStencilView = VkImageView.Null; } } base.OnDestroyed(); }
public static void SetDebugMarkerName(this VkImageView obj, Device dev, string name) { if (!dev.DebugMarkersEnabled) { return; } VkDebugMarkerObjectNameInfoEXT dmo = new VkDebugMarkerObjectNameInfoEXT(VkDebugReportObjectTypeEXT.ImageViewEXT, obj.Handle) { pObjectName = name.Pin() }; Utils.CheckResult(vkDebugMarkerSetObjectNameEXT(dev.VkDev, ref dmo)); name.Unpin(); }
public static void SetDebugMarkerName(this VkImageView obj, Device dev, string name) { if (!dev.debugUtilsEnabled) { return; } VkDebugUtilsObjectNameInfoEXT dmo = new VkDebugUtilsObjectNameInfoEXT(VkObjectType.ImageView, (ulong)obj.Handle) { pObjectName = name.Pin() }; Utils.CheckResult(vkSetDebugUtilsObjectNameEXT(dev.VkDev, ref dmo)); name.Unpin(); }
private void CreateDepthImageView() { VkImageViewCreateInfo createInfo = VkImageViewCreateInfo.New(); createInfo.image = depthImage; createInfo.viewType = VkImageViewType.Image2D; createInfo.format = VkFormat.D32Sfloat; createInfo.subresourceRange.aspectMask = VkImageAspectFlags.Depth; createInfo.subresourceRange.layerCount = 1; createInfo.subresourceRange.levelCount = 1; VkImageView view = VkImageView.Null; Assert(vkCreateImageView(device, &createInfo, null, &view)); this.depthImageView = view; }
void CreateImageView(VkImage image, VkFormat format, ref VkImageView imageView) { var info = new VkImageViewCreateInfo(); info.image = image; info.viewType = VkImageViewType._2D; info.format = format; info.subresourceRange.aspectMask = VkImageAspectFlags.ColorBit; info.subresourceRange.baseMipLevel = 0;; info.subresourceRange.levelCount = 1; info.subresourceRange.baseArrayLayer = 0; info.subresourceRange.layerCount = 1; imageView?.Dispose(); imageView = new VkImageView(device, info); }
public static VkImageView CreateColourImageArrayView(VkDevice device, VkImage image, int layers, VkFormat imageFormat, uint mipLevels) { VkImageViewCreateInfo createInfo = VkImageViewCreateInfo.New(); createInfo.image = image; createInfo.viewType = VkImageViewType.Image2DArray; createInfo.format = imageFormat; createInfo.subresourceRange.aspectMask = VkImageAspectFlags.Color; createInfo.subresourceRange.layerCount = (uint)layers; createInfo.subresourceRange.levelCount = mipLevels; VkImageView view = VkImageView.Null; Assert(vkCreateImageView(device, &createInfo, null, &view)); return(view); }
void CreateImageViews() { if (swapchainImageViews != null) { foreach (var iv in swapchainImageViews) { iv.Dispose(); } } swapchainImageViews = new List <VkImageView>(); foreach (var image in swapchainImages) { VkImageView temp = null; CreateImageView(image, swapchainImageFormat, ref temp); swapchainImageViews.Add(temp); } }
public unsafe ImageView( Image image, VkImageAspectFlags aspectMask ) { _device = image.Device; _image = image; var imageViewInfo = new VkImageViewCreateInfo { sType = VkStructureType.ImageViewCreateInfo, image = image.Handle, viewType = VkImageViewType.Image2D, format = image.Format, components = new VkComponentMapping { r = VkComponentSwizzle.Identity, g = VkComponentSwizzle.Identity, b = VkComponentSwizzle.Identity, a = VkComponentSwizzle.Identity }, subresourceRange = new VkImageSubresourceRange { aspectMask = aspectMask, baseMipLevel = 0, levelCount = image.MipLevel, baseArrayLayer = 0, layerCount = 1 } }; VkImageView imageView; if (VulkanNative.vkCreateImageView( _device.Handle, &imageViewInfo, null, &imageView ) != VkResult.Success) { throw new Exception("failed to create image view"); } _handle = imageView; }
internal void Initialize(int w, int h) { //create_buffer_image(0); create_image(w, h); // For depth-stencil formats, automatically fall back to a supported one if (IsDepthStencil) { image_view = get_depth_stencil_view(); } if (IsShaderResource) { create_buffer_image(); image_view = get_image_view(); } }
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 extern VkResult CreateImageView( VkDevice device, ref VkImageViewCreateInfo pCreateInfo, IntPtr pAllocator, out VkImageView pView );
public override VkResult CreateImageView(VkImageViewCreateInfo createInfo, out VkImageView imageView) { imageView = new DummyImageView(); return(VkResult.VK_SUCCESS); }
public override void DestroyImageView(VkImageView imageView) { throw new NotImplementedException(); }
public static VkResult vkCreateImageView(VkDevice device, VkImageViewCreateInfo createInfo, VkAllocationCallbacks pAllocator, out VkImageView imageView) { VkPreconditions.CheckNull(device, nameof(device)); return(GetDevice(device).CreateImageView(createInfo, out imageView)); }
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); }
public static extern void DestroyImageView( VkDevice device, VkImageView imageView, IntPtr pAllocator );
public static void vkDestroyImageView(VkDevice device, VkImageView imageView, VkAllocationCallbacks pAllocator) { VkPreconditions.CheckNull(device, nameof(device)); GetDevice(device).DestroyImageView(imageView); }
internal void SetNativeHandles(VkImage image, VkImageView attachmentView) { NativeImage = image; NativeColorAttachmentView = attachmentView; }
private void InitializeFromImpl(DataBox[] dataBoxes = null) { NativeFormat = VulkanConvertExtensions.ConvertPixelFormat(ViewFormat); HasStencil = IsStencilFormat(ViewFormat); NativeImageAspect = IsDepthStencil ? VkImageAspectFlags.Depth : VkImageAspectFlags.Color; if (HasStencil) { NativeImageAspect |= VkImageAspectFlags.Stencil; } // For depth-stencil formats, automatically fall back to a supported one if (IsDepthStencil && HasStencil) { NativeFormat = GetFallbackDepthStencilFormat(GraphicsDevice, NativeFormat); } if (Usage == GraphicsResourceUsage.Staging) { if (NativeImage != VkImage.Null) { throw new InvalidOperationException(); } if (isNotOwningResources) { throw new InvalidOperationException(); } NativeAccessMask = VkAccessFlags.HostRead | VkAccessFlags.HostWrite; NativePipelineStageMask = VkPipelineStageFlags.Host; if (ParentTexture != null) { // Create only a view NativeBuffer = ParentTexture.NativeBuffer; NativeMemory = ParentTexture.NativeMemory; } else { CreateBuffer(); if (dataBoxes != null && dataBoxes.Length > 0) { throw new InvalidOperationException(); } } } else { if (NativeImage != VkImage.Null) { throw new InvalidOperationException(); } NativeLayout = IsRenderTarget ? VkImageLayout.ColorAttachmentOptimal : IsDepthStencil ? VkImageLayout.DepthStencilAttachmentOptimal : IsShaderResource ? VkImageLayout.ShaderReadOnlyOptimal : VkImageLayout.General; if (NativeLayout == VkImageLayout.TransferDstOptimal) { NativeAccessMask = VkAccessFlags.TransferRead; } if (NativeLayout == VkImageLayout.ColorAttachmentOptimal) { NativeAccessMask = VkAccessFlags.ColorAttachmentWrite; } if (NativeLayout == VkImageLayout.DepthStencilAttachmentOptimal) { NativeAccessMask = VkAccessFlags.DepthStencilAttachmentWrite; } if (NativeLayout == VkImageLayout.ShaderReadOnlyOptimal) { NativeAccessMask = VkAccessFlags.ShaderRead | VkAccessFlags.InputAttachmentRead; } NativePipelineStageMask = IsRenderTarget ? VkPipelineStageFlags.ColorAttachmentOutput : IsDepthStencil ? VkPipelineStageFlags.ColorAttachmentOutput | VkPipelineStageFlags.EarlyFragmentTests | VkPipelineStageFlags.LateFragmentTests : IsShaderResource ? VkPipelineStageFlags.VertexInput | VkPipelineStageFlags.FragmentShader : VkPipelineStageFlags.None; if (ParentTexture != null) { // Create only a view NativeImage = ParentTexture.NativeImage; NativeMemory = ParentTexture.NativeMemory; } else { if (!isNotOwningResources) { CreateImage(); InitializeImage(dataBoxes); } } if (!isNotOwningResources) { NativeImageView = GetImageView(ViewType, ArraySlice, MipLevel); NativeColorAttachmentView = GetColorAttachmentView(ViewType, ArraySlice, MipLevel); NativeDepthStencilView = GetDepthStencilView(); } } }
public abstract void DestroyImageView(VkImageView imageView);