public ImageCreateInfo ( StructureType sType = StructureType.ImageCreateInfo, void *pNext = default, ImageCreateFlags flags = default, ImageType imageType = default, Format format = default, Extent3D extent = default, uint mipLevels = default, uint arrayLayers = default, SampleCountFlags samples = default, ImageTiling tiling = default, ImageUsageFlags usage = default, SharingMode sharingMode = default, uint queueFamilyIndexCount = default, uint *pQueueFamilyIndices = default, ImageLayout initialLayout = default ) { SType = sType; PNext = pNext; Flags = flags; ImageType = imageType; Format = format; Extent = extent; MipLevels = mipLevels; ArrayLayers = arrayLayers; Samples = samples; Tiling = tiling; Usage = usage; SharingMode = sharingMode; QueueFamilyIndexCount = queueFamilyIndexCount; PQueueFamilyIndices = pQueueFamilyIndices; InitialLayout = initialLayout; }
public SurfaceCapabilities2EXT ( StructureType sType = StructureType.SurfaceCapabilities2Ext, void *pNext = default, uint minImageCount = default, uint maxImageCount = default, Extent2D currentExtent = default, Extent2D minImageExtent = default, Extent2D maxImageExtent = default, uint maxImageArrayLayers = default, SurfaceTransformFlagsKHR supportedTransforms = default, SurfaceTransformFlagsKHR currentTransform = default, CompositeAlphaFlagsKHR supportedCompositeAlpha = default, ImageUsageFlags supportedUsageFlags = default, SurfaceCounterFlagsEXT supportedSurfaceCounters = default ) { SType = sType; PNext = pNext; MinImageCount = minImageCount; MaxImageCount = maxImageCount; CurrentExtent = currentExtent; MinImageExtent = minImageExtent; MaxImageExtent = maxImageExtent; MaxImageArrayLayers = maxImageArrayLayers; SupportedTransforms = supportedTransforms; CurrentTransform = currentTransform; SupportedCompositeAlpha = supportedCompositeAlpha; SupportedUsageFlags = supportedUsageFlags; SupportedSurfaceCounters = supportedSurfaceCounters; }
public SurfaceCapabilitiesKHR ( uint minImageCount = default, uint maxImageCount = default, Extent2D currentExtent = default, Extent2D minImageExtent = default, Extent2D maxImageExtent = default, uint maxImageArrayLayers = default, SurfaceTransformFlagsKHR supportedTransforms = default, SurfaceTransformFlagsKHR currentTransform = default, CompositeAlphaFlagsKHR supportedCompositeAlpha = default, ImageUsageFlags supportedUsageFlags = default ) { MinImageCount = minImageCount; MaxImageCount = maxImageCount; CurrentExtent = currentExtent; MinImageExtent = minImageExtent; MaxImageExtent = maxImageExtent; MaxImageArrayLayers = maxImageArrayLayers; SupportedTransforms = supportedTransforms; CurrentTransform = currentTransform; SupportedCompositeAlpha = supportedCompositeAlpha; SupportedUsageFlags = supportedUsageFlags; }
public SharedPresentSurfaceCapabilitiesKHR ( StructureType sType = StructureType.SharedPresentSurfaceCapabilitiesKhr, void *pNext = default, ImageUsageFlags sharedPresentSupportedUsageFlags = default ) { SType = sType; PNext = pNext; SharedPresentSupportedUsageFlags = sharedPresentSupportedUsageFlags; }
public ImageViewUsageCreateInfo ( StructureType sType = StructureType.ImageViewUsageCreateInfo, void *pNext = default, ImageUsageFlags usage = default ) { SType = sType; PNext = pNext; Usage = usage; }
public ImageStencilUsageCreateInfo ( StructureType sType = StructureType.ImageStencilUsageCreateInfo, void *pNext = default, ImageUsageFlags stencilUsage = default ) { SType = sType; PNext = pNext; StencilUsage = stencilUsage; }
public static ImageWithMemory CreateSampledImageWithMemory( uint width, uint height, ImageUsageFlags imageUsageFlags, SampleCountFlags samples, Format format, ImageAspectFlags imageAspectFlags) { ImageWithMemory imageWithMemory = new ImageWithMemory { Image = VContext.Instance.device.CreateImage ( new ImageCreateInfo() { ImageType = ImageType.Image2D, Format = format, Extent = new Extent3D() { Width = width, Height = height, Depth = 1 }, MipLevels = 1, ArrayLayers = 1, Samples = samples, Tiling = ImageTiling.Optimal, Usage = imageUsageFlags, SharingMode = SharingMode.Exclusive, InitialLayout = ImageLayout.Undefined } ) }; MemoryRequirements textureMemoryRequirements = VContext.Instance.device.GetImageMemoryRequirements(imageWithMemory.Image); uint memoryTypeIndex = Util.GetMemoryTypeIndex(textureMemoryRequirements.MemoryTypeBits, MemoryPropertyFlags.DeviceLocal); imageWithMemory.Memory = VContext.Instance.device.AllocateMemory ( new MemoryAllocateInfo() { AllocationSize = textureMemoryRequirements.Size, MemoryTypeIndex = memoryTypeIndex } ); VContext.Instance.device.BindImageMemory(imageWithMemory.Image, imageWithMemory.Memory, 0); imageWithMemory.ImageView = VContext.Instance.CreateImageView(imageWithMemory.Image, format, imageAspectFlags); return(imageWithMemory); }
public PhysicalDeviceSparseImageFormatInfo2KHR ( StructureType sType = StructureType.PhysicalDeviceSparseImageFormatInfo2, void *pNext = default, Format format = default, ImageType type = default, SampleCountFlags samples = default, ImageUsageFlags usage = default, ImageTiling tiling = default ) { SType = sType; PNext = pNext; Format = format; Type = type; Samples = samples; Usage = usage; Tiling = tiling; }
public PhysicalDeviceImageFormatInfo2KHR ( StructureType sType = StructureType.PhysicalDeviceImageFormatInfo2, void *pNext = default, Format format = default, ImageType type = default, ImageTiling tiling = default, ImageUsageFlags usage = default, ImageCreateFlags flags = default ) { SType = sType; PNext = pNext; Format = format; Type = type; Tiling = tiling; Usage = usage; Flags = flags; }
public SwapchainCreateInfoKHR ( StructureType sType = StructureType.SwapchainCreateInfoKhr, void *pNext = default, SwapchainCreateFlagsKHR flags = default, SurfaceKHR surface = default, uint minImageCount = default, Format imageFormat = default, ColorSpaceKHR imageColorSpace = default, Extent2D imageExtent = default, uint imageArrayLayers = default, ImageUsageFlags imageUsage = default, SharingMode imageSharingMode = default, uint queueFamilyIndexCount = default, uint *pQueueFamilyIndices = default, SurfaceTransformFlagsKHR preTransform = default, CompositeAlphaFlagsKHR compositeAlpha = default, PresentModeKHR presentMode = default, Bool32 clipped = default, SwapchainKHR oldSwapchain = default ) { SType = sType; PNext = pNext; Flags = flags; Surface = surface; MinImageCount = minImageCount; ImageFormat = imageFormat; ImageColorSpace = imageColorSpace; ImageExtent = imageExtent; ImageArrayLayers = imageArrayLayers; ImageUsage = imageUsage; ImageSharingMode = imageSharingMode; QueueFamilyIndexCount = queueFamilyIndexCount; PQueueFamilyIndices = pQueueFamilyIndices; PreTransform = preTransform; CompositeAlpha = compositeAlpha; PresentMode = presentMode; Clipped = clipped; OldSwapchain = oldSwapchain; }
public _SwapchainCreateInfoKHR(SwapchainCreateInfoKHR info) { SType = info.type; Next = info.next; Flags = info.flags; Surface = info.surface; MinImageCount = info.minImageCount; ImageFormat = info.imageFormat; ImageColorSpace = info.imageColorSpace; ImageExtent = info.imageExtent; ImageArrayLayers = info.imageArrayLayers; ImageUsage = info.imageUsage; ImageSharingMode = info.imageSharingMode; QueueFamilyIndexCount = (UInt32)(info.queueFamilyIndices?.Count ?? 0); QueueFamilyIndices = info.queueFamilyIndices != null?Alloc.alloc(info.queueFamilyIndices) : IntPtr.Zero; PreTransform = info.preTransform; CompositeAlpha = info.compositeAlpha; PresentMode = info.presentMode; Clipped = info.clipped; OldSwapchain = info.oldSwapchain; }
public FramebufferAttachmentImageInfo ( StructureType sType = StructureType.FramebufferAttachmentImageInfo, void *pNext = default, ImageCreateFlags flags = default, ImageUsageFlags usage = default, uint width = default, uint height = default, uint layerCount = default, uint viewFormatCount = default, Format *pViewFormats = default ) { SType = sType; PNext = pNext; Flags = flags; Usage = usage; Width = width; Height = height; LayerCount = layerCount; ViewFormatCount = viewFormatCount; PViewFormats = pViewFormats; }
public static ImageWithMemory CreateImageWithMemory( Bitmap texture, bool forceLinear = false, ImageUsageFlags imageUsageFlags = ImageUsageFlags.Sampled, ImageLayout imageLayout = ImageLayout.ShaderReadOnlyOptimal) { ImageWithMemory imageWithMemory = new ImageWithMemory(); System.Drawing.Imaging.BitmapData data = texture.LockBits(new System.Drawing.Rectangle(0, 0, texture.Width, texture.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); int length = data.Stride * data.Height; DeviceSize imageSize = length; byte[] bytes = new byte[length]; System.Runtime.InteropServices.Marshal.Copy(data.Scan0, bytes, 0, length); texture.UnlockBits(data); BufferWithMemory stagingBuffer; fixed(byte *source = &bytes[0]) { stagingBuffer = VContext.Instance.CreateBuffer(BufferUsageFlags.TransferSrc, imageSize, source); } List <BufferImageCopy> bufferCopyRegions = new List <BufferImageCopy>(); DeviceSize offset = 0; for (uint i = 0; i < 1; i++) { BufferImageCopy bufferCopyRegion = new BufferImageCopy() { ImageSubresource = new ImageSubresourceLayers() { AspectMask = ImageAspectFlags.Color, MipLevel = i, BaseArrayLayer = 0, LayerCount = 1 }, ImageExtent = new Extent3D() { Width = (uint)texture.Width, Height = (uint)texture.Height, Depth = 1, }, BufferOffset = offset }; bufferCopyRegions.Add(bufferCopyRegion); offset += imageSize; } imageWithMemory.Image = VContext.Instance.device.CreateImage ( new ImageCreateInfo() { ImageType = ImageType.Image2D, Format = VContext.ColorFormat, Extent = new Extent3D() { Width = (uint)texture.Width, Height = (uint)texture.Height, Depth = 1 }, MipLevels = 1, ArrayLayers = 1, Samples = SampleCountFlags.Count1, Tiling = ImageTiling.Optimal, Usage = ImageUsageFlags.Sampled | ImageUsageFlags.TransferDst, SharingMode = SharingMode.Exclusive, InitialLayout = ImageLayout.Undefined } ); MemoryRequirements textureMemoryRequirements = VContext.Instance.device.GetImageMemoryRequirements(imageWithMemory.Image); uint memoryTypeIndex = Util.GetMemoryTypeIndex(textureMemoryRequirements.MemoryTypeBits, MemoryPropertyFlags.DeviceLocal); imageWithMemory.Memory = VContext.Instance.device.AllocateMemory ( new MemoryAllocateInfo() { AllocationSize = textureMemoryRequirements.Size, MemoryTypeIndex = memoryTypeIndex } ); VContext.Instance.device.BindImageMemory(imageWithMemory.Image, imageWithMemory.Memory, 0); CommandBuffer commandBuffer = _commandBuffer.Value; commandBuffer.Begin(new CommandBufferBeginInfo()); ImageSubresourceRange subresourceRange = new ImageSubresourceRange() { AspectMask = ImageAspectFlags.Color, BaseMipLevel = 0, LevelCount = 1, LayerCount = 1, }; ImageMemoryBarrier undefinedToTranserDstBarrier = new ImageMemoryBarrier() { OldLayout = ImageLayout.Undefined, NewLayout = ImageLayout.TransferDstOptimal, Image = imageWithMemory.Image, SubresourceRange = subresourceRange, SrcAccessMask = 0, DstAccessMask = AccessFlags.TransferWrite }; commandBuffer.CmdPipelineBarrier( PipelineStageFlags.AllCommands, PipelineStageFlags.AllCommands, 0, null, null, undefinedToTranserDstBarrier); // Copy mip levels from staging buffer commandBuffer.CmdCopyBufferToImage( stagingBuffer.Buffer, imageWithMemory.Image, ImageLayout.TransferDstOptimal, bufferCopyRegions.ToArray()); // Change texture image layout to shader read after all mip levels have been copied ImageMemoryBarrier transferDstToShaderReadBarrier = new ImageMemoryBarrier() { OldLayout = ImageLayout.TransferDstOptimal, NewLayout = ImageLayout.ShaderReadOnlyOptimal, Image = imageWithMemory.Image, SubresourceRange = subresourceRange, SrcAccessMask = AccessFlags.TransferWrite, DstAccessMask = AccessFlags.ShaderRead }; commandBuffer.CmdPipelineBarrier( PipelineStageFlags.AllCommands, PipelineStageFlags.AllCommands, 0, null, null, transferDstToShaderReadBarrier); commandBuffer.End(); // Create a fence to make sure that the copies have finished before continuing Fence copyFence = VContext.Instance.device.CreateFence(new FenceCreateInfo()); SubmitInfo submitInfo = new SubmitInfo() { CommandBuffers = new CommandBuffer[] { commandBuffer } }; VContext.Instance.deviceQueue.Submit(submitInfo, copyFence); VContext.Instance.device.WaitForFences(new Fence[] { copyFence }, true, ulong.MaxValue); commandBuffer.Reset(CommandBufferResetFlags.ReleaseResources); VContext.Instance.device.DestroyFence(copyFence); VContext.Instance.device.FreeMemory(stagingBuffer.Memory); VContext.Instance.device.DestroyBuffer(stagingBuffer.Buffer); imageWithMemory.ImageView = VContext.Instance.CreateImageView(imageWithMemory.Image, VContext.ColorFormat, ImageAspectFlags.Color); return(imageWithMemory); }
internal unsafe void GetSparseImageFormatProperties(Format format, ImageType type, SampleCountFlags samples, ImageUsageFlags usage, ImageTiling tiling, ref uint propertyCount, SparseImageFormatProperties* properties) { fixed (uint* __propertyCount__ = &propertyCount) { vkGetPhysicalDeviceSparseImageFormatProperties(this, format, type, samples, usage, tiling, __propertyCount__, properties); } }
private void CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties, bool isPreinitialized, out Image image, out DeviceMemory imageMemory, out DeviceSize memoryOffset, out DeviceSize memorySize) { image = this.device.CreateImage(ImageType.Image2d, format, new Extent3D(width, height, 1), 1, 1, SampleCountFlags.SampleCount1, imageTiling, usage, this.queueIndices.Indices.Count() == 1 ? SharingMode.Exclusive : SharingMode.Concurrent, this.queueIndices.Indices.ToArray(), isPreinitialized ? ImageLayout.Preinitialized : ImageLayout.Undefined); var memoryRequirements = image.GetMemoryRequirements(); memorySize = memoryRequirements.Size; imageMemory = this.device.AllocateMemory(memorySize, this.FindMemoryType(memoryRequirements.MemoryTypeBits, properties)); memoryOffset = 0; image.BindMemory(imageMemory, memoryOffset); }
public unsafe SparseImageFormatProperties[] GetSparseImageFormatProperties(Format format, ImageType type, SampleCountFlags samples, ImageUsageFlags usage, ImageTiling tiling) { uint count = 0; GetSparseImageFormatProperties(format, type, samples, usage, tiling, ref count, null); var result = new SparseImageFormatProperties[count]; if (count > 0) { fixed(SparseImageFormatProperties *resultPointer = &result[0]) GetSparseImageFormatProperties(format, type, samples, usage, tiling, ref count, resultPointer); } return(result); }
public unsafe void GetImageFormatProperties(Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, out ImageFormatProperties imageFormatProperties) { fixed (ImageFormatProperties* __imageFormatProperties__ = &imageFormatProperties) { vkGetPhysicalDeviceImageFormatProperties(this, format, type, tiling, usage, flags, __imageFormatProperties__).CheckError(); } }
internal static unsafe extern Result vkGetPhysicalDeviceImageFormatProperties(PhysicalDevice physicalDevice, Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties *ImageFormatProperties);
/// <param name="Surface">The swapchain's target surface</param> /// <param name="MinImageCount">Minimum number of presentation images the application needs</param> /// <param name="ImageFormat">Format of the presentation images</param> /// <param name="ImageColorSpace">Colorspace of the presentation images</param> /// <param name="ImageExtent">Dimensions of the presentation images</param> /// <param name="ImageArrayLayers">Determines the number of views for multiview/stereo presentation</param> /// <param name="ImageUsage">Bits indicating how the presentation images will be used</param> /// <param name="ImageSharingMode">Sharing mode used for the presentation images</param> /// <param name="QueueFamilyIndices">Array of queue family indices having access to the images in case of concurrent sharing mode</param> /// <param name="PreTransform">The transform, relative to the device's natural orientation, applied to the image content prior to presentation</param> /// <param name="CompositeAlpha">The alpha blending mode used when compositing this surface with other surfaces in the window system</param> /// <param name="PresentMode">Which presentation mode to use for presents on this swap chain</param> /// <param name="Clipped">Specifies whether presentable images may be affected by window clip regions</param> public SwapchainCreateInfoKHR(SurfaceKHR Surface, UInt32 MinImageCount, Format ImageFormat, ColorSpaceKHR ImageColorSpace, Extent2D ImageExtent, UInt32 ImageArrayLayers, ImageUsageFlags ImageUsage, SharingMode ImageSharingMode, UInt32[] QueueFamilyIndices, SurfaceTransformFlagsKHR PreTransform, CompositeAlphaFlagsKHR CompositeAlpha, PresentModeKHR PresentMode, Bool32 Clipped) : this() { this.Surface = Surface; this.MinImageCount = MinImageCount; this.ImageFormat = ImageFormat; this.ImageColorSpace = ImageColorSpace; this.ImageExtent = ImageExtent; this.ImageArrayLayers = ImageArrayLayers; this.ImageUsage = ImageUsage; this.ImageSharingMode = ImageSharingMode; this.QueueFamilyIndices = QueueFamilyIndices; this.PreTransform = PreTransform; this.CompositeAlpha = CompositeAlpha; this.PresentMode = PresentMode; this.Clipped = Clipped; }
public static extern unsafe void vkGetPhysicalDeviceSparseImageFormatProperties(IntPtr physicalDevice, Format format, ImageType type, SampleCountFlags samples, ImageUsageFlags usage, ImageTiling tiling, uint *pPropertyCount, SparseImageFormatProperties *pProperties);
public VulkanImage CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties) { this.CreateImage(width, height, format, imageTiling, usage, properties, out var image, out var memory); return(new VulkanImage(this, image, memory, format)); }
internal static unsafe extern Result vkGetPhysicalDeviceExternalImageFormatPropertiesNV(IntPtr physicalDevice, Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNv externalHandleType, ExternalImageFormatPropertiesNv *pExternalImageFormatProperties);
public static ImageWithMemory CreateImageWithMemory( uint width, uint height, ImageUsageFlags imageUsageFlags, ImageLayout imageLayout, AccessFlags accessMask, SampleCountFlags samples = SampleCountFlags.Count1) { ImageWithMemory imageWithMemory = new ImageWithMemory { Image = VContext.Instance.device.CreateImage ( new ImageCreateInfo() { ImageType = ImageType.Image2D, Format = VContext.ColorFormat, Extent = new Extent3D() { Width = width, Height = height, Depth = 1 }, MipLevels = 1, ArrayLayers = 1, Samples = samples, Tiling = ImageTiling.Optimal, Usage = imageUsageFlags, SharingMode = SharingMode.Exclusive, InitialLayout = ImageLayout.Undefined } ) }; MemoryRequirements textureMemoryRequirements = VContext.Instance.device.GetImageMemoryRequirements(imageWithMemory.Image); uint memoryTypeIndex = Util.GetMemoryTypeIndex(textureMemoryRequirements.MemoryTypeBits, MemoryPropertyFlags.DeviceLocal); imageWithMemory.Memory = VContext.Instance.device.AllocateMemory ( new MemoryAllocateInfo() { AllocationSize = textureMemoryRequirements.Size, MemoryTypeIndex = memoryTypeIndex } ); VContext.Instance.device.BindImageMemory(imageWithMemory.Image, imageWithMemory.Memory, 0); if (imageLayout != ImageLayout.Undefined) { CommandBuffer commandBuffer = _commandBuffer.Value; commandBuffer.Begin(new CommandBufferBeginInfo()); ImageSubresourceRange subresourceRange = new ImageSubresourceRange() { AspectMask = ImageAspectFlags.Color, BaseMipLevel = 0, LevelCount = 1, LayerCount = 1, }; ImageMemoryBarrier undefinedToTranserDstBarrier = new ImageMemoryBarrier() { OldLayout = ImageLayout.Undefined, NewLayout = imageLayout, Image = imageWithMemory.Image, SubresourceRange = subresourceRange, SrcAccessMask = 0, DstAccessMask = accessMask }; commandBuffer.CmdPipelineBarrier( PipelineStageFlags.AllCommands, PipelineStageFlags.AllCommands, 0, null, null, undefinedToTranserDstBarrier); commandBuffer.CmdPipelineBarrier( PipelineStageFlags.AllCommands, PipelineStageFlags.AllCommands, 0, null, null, undefinedToTranserDstBarrier); commandBuffer.End(); Fence fence = VContext.Instance.device.CreateFence(new FenceCreateInfo()); SubmitInfo submitInfo = new SubmitInfo() { CommandBuffers = new CommandBuffer[] { commandBuffer } }; VContext.Instance.deviceQueue.Submit(submitInfo, fence); VContext.Instance.device.WaitForFences(new Fence[] { fence }, true, ulong.MaxValue); commandBuffer.Reset(CommandBufferResetFlags.ReleaseResources); VContext.Instance.device.DestroyFence(fence); } imageWithMemory.ImageView = VContext.Instance.CreateImageView(imageWithMemory.Image, VContext.ColorFormat, ImageAspectFlags.Color); return(imageWithMemory); }
internal static unsafe extern void vkGetPhysicalDeviceSparseImageFormatProperties(PhysicalDevice physicalDevice, Format format, ImageType type, SampleCountFlags samples, ImageUsageFlags usage, ImageTiling tiling, out UInt32 *PropertyCount, SparseImageFormatProperties *Properties);
internal static unsafe extern void vkGetPhysicalDeviceSparseImageFormatProperties(PhysicalDevice physicalDevice, Format format, ImageType type, SampleCountFlags samples, ImageUsageFlags usage, ImageTiling tiling, uint* propertyCount, SparseImageFormatProperties* properties);
private void CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties, out Image image, out DeviceMemory imageMemory) { image = this.device.CreateImage(new ImageCreateInfo { ImageType = ImageType.Image2d, Extent = new Extent3D { Width = width, Height = height, Depth = 1 }, ArrayLayers = 1, MipLevels = 1, Format = format, Tiling = imageTiling, InitialLayout = ImageLayout.Preinitialized, Usage = usage, SharingMode = SharingMode.Exclusive, Samples = SampleCountFlags.SampleCount1, Flags = ImageCreateFlags.None }); var memoryRequirements = image.GetMemoryRequirements(); imageMemory = this.device.AllocateMemory(new MemoryAllocateInfo { AllocationSize = memoryRequirements.Size, MemoryTypeIndex = this.FindMemoryType(memoryRequirements.MemoryTypeBits, properties) }); image.BindMemory(imageMemory, 0); }
public VulkanImage CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties, bool isPreinitialized) { this.CreateImage(width, height, format, imageTiling, usage, properties, isPreinitialized, out var image, out var imageMemory, out DeviceSize offset, out DeviceSize size); return(new VulkanImage(this, image, imageMemory, offset, size, format)); }
public unsafe SparseImageFormatProperties[] GetSparseImageFormatProperties(Format format, ImageType type, SampleCountFlags samples, ImageUsageFlags usage, ImageTiling tiling) { uint count = 0; GetSparseImageFormatProperties(format, type, samples, usage, tiling, ref count, null); var result = new SparseImageFormatProperties[count]; if (count > 0) { fixed (SparseImageFormatProperties* resultPointer = &result[0]) GetSparseImageFormatProperties(format, type, samples, usage, tiling, ref count, resultPointer); } return result; }
internal static unsafe extern Result vkGetPhysicalDeviceImageFormatProperties(PhysicalDevice physicalDevice, Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* imageFormatProperties);
public static extern unsafe Result vkGetPhysicalDeviceImageFormatProperties(IntPtr physicalDevice, Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties *pImageFormatProperties);
/// <param name="Usage">Image usage flags</param> /// <param name="SharingMode">Cross-queue-family sharing mode</param> /// <param name="QueueFamilyIndices">Array of queue family indices to share across</param> /// <param name="InitialLayout">Initial image layout for all subresources</param> public ImageCreateInfo(ImageType ImageType, Format Format, Extent3D Extent, UInt32 MipLevels, UInt32 ArrayLayers, SampleCountFlags Samples, ImageTiling Tiling, ImageUsageFlags Usage, SharingMode SharingMode, UInt32[] QueueFamilyIndices, ImageLayout InitialLayout) : this() { this.ImageType = ImageType; this.Format = Format; this.Extent = Extent; this.MipLevels = MipLevels; this.ArrayLayers = ArrayLayers; this.Samples = Samples; this.Tiling = Tiling; this.Usage = Usage; this.SharingMode = SharingMode; this.QueueFamilyIndices = QueueFamilyIndices; this.InitialLayout = InitialLayout; }
/// <summary>To be documented.</summary> public static unsafe Result GetPhysicalDeviceExternalImageFormatProperties(this NVExternalMemoryCapabilities thisApi, [Count(Count = 0)] PhysicalDevice physicalDevice, [Count(Count = 0)] Format format, [Count(Count = 0)] ImageType type, [Count(Count = 0)] ImageTiling tiling, [Count(Count = 0)] ImageUsageFlags usage, [Count(Count = 0)] ImageCreateFlags flags, [Count(Count = 0)] ExternalMemoryHandleTypeFlagsNV externalHandleType, [Count(Count = 0), Flow(FlowDirection.Out)] Span <ExternalImageFormatPropertiesNV> pExternalImageFormatProperties) { // SpanOverloader return(thisApi.GetPhysicalDeviceExternalImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, externalHandleType, out pExternalImageFormatProperties.GetPinnableReference())); }
/// <summary> /// /// </summary> public SurfaceCapabilities(uint minImageCount, uint maxImageCount, Extent2D currentExtent, Extent2D minImageExtent, Extent2D maxImageExtent, uint maxImageArrayLayers, SurfaceTransformFlags supportedTransforms, SurfaceTransformFlags currentTransform, CompositeAlphaFlags supportedCompositeAlpha, ImageUsageFlags supportedUsageFlags) { this.MinImageCount = minImageCount; this.MaxImageCount = maxImageCount; this.CurrentExtent = currentExtent; this.MinImageExtent = minImageExtent; this.MaxImageExtent = maxImageExtent; this.MaxImageArrayLayers = maxImageArrayLayers; this.SupportedTransforms = supportedTransforms; this.CurrentTransform = currentTransform; this.SupportedCompositeAlpha = supportedCompositeAlpha; this.SupportedUsageFlags = supportedUsageFlags; }
public partial Result GetPhysicalDeviceExternalImageFormatProperties([Count(Count = 0)] PhysicalDevice physicalDevice, [Count(Count = 0)] Format format, [Count(Count = 0)] ImageType type, [Count(Count = 0)] ImageTiling tiling, [Count(Count = 0)] ImageUsageFlags usage, [Count(Count = 0)] ImageCreateFlags flags, [Count(Count = 0)] ExternalMemoryHandleTypeFlagsNV externalHandleType, [Count(Count = 0), Flow(FlowDirection.Out)] out ExternalImageFormatPropertiesNV pExternalImageFormatProperties);
public FrameBufferAttachment CreateAttachment(string AttachmentLookupID, Format myFormat, ImageType myType, ImageViewType view2D, ImageUsageFlags myImageFlag, ImageAspectFlags color, ImageTiling myTiles, SampleCountFlags mySampleCount, uint levelCount, uint layercount) { //TODO: Write exception class if (Initialized) { throw new Exception("Attempted to add attachment to initialized Framebuffer!"); } if (myAttachments.ContainsKey(AttachmentLookupID)) { throw new Exception("A framebuffer attachment with ID: " + AttachmentLookupID + " was added to frame buffer twice."); } ImageCreateInfo myInfo = new ImageCreateInfo() { ImageType = myType, MipLevels = 1, Format = myFormat, Extent = new Extent3D() { Width = myFramebufferInfo.Width, Height = myFramebufferInfo.Height, Depth = 1 }, ArrayLayers = layercount, Samples = mySampleCount, Tiling = myTiles, Usage = myImageFlag }; myImage = new Image(myInfo); var Return = this.CreateAttachment(AttachmentLookupID, myFormat, view2D, myImage, color, levelCount, layercount); myAttachments[AttachmentLookupID] = Return; myInfo.Dispose(false); return(Return); }