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);
}
