protected SwapchainData CreateSwapchain(PhysicalDevice physicalDevice, SurfaceKHR surface, uint windowWidth, uint windowHeight)
{
var data = new SwapchainData();
var surfaceFormats = physicalDevice.GetSurfaceFormatsKHR(surface);
var surfaceFormat = surfaceFormats[0].Format;
var surfaceCapabilities = physicalDevice.GetSurfaceCapabilitiesKHR(surface);
var desiredImageCount = Math.Min(surfaceCapabilities.MinImageCount + 1, surfaceCapabilities.MaxImageCount);
SurfaceTransformFlagsKHR preTransform;
if ((surfaceCapabilities.SupportedTransforms & SurfaceTransformFlagsKHR.Identity) != 0)
{
preTransform = SurfaceTransformFlagsKHR.Identity;
}
else
{
preTransform = surfaceCapabilities.CurrentTransform;
}
var presentModes = physicalDevice.GetSurfacePresentModesKHR(surface);
var swapChainPresentMode = PresentModeKHR.Fifo;
if (presentModes.Contains(PresentModeKHR.Mailbox))
{
swapChainPresentMode = PresentModeKHR.Mailbox;
}
else if (presentModes.Contains(PresentModeKHR.Immediate))
{
swapChainPresentMode = PresentModeKHR.Immediate;
}
var imageExtent = new Extent2D(windowWidth, windowHeight);
var swapchainCreateInfo = new SwapchainCreateInfoKHR
{
Surface = surface,
MinImageCount = desiredImageCount,
ImageFormat = surfaceFormat,
ImageExtent = imageExtent,
ImageArrayLayers = 1,
ImageUsage = ImageUsageFlags.ColorAttachment,
ImageSharingMode = SharingMode.Exclusive,
//ImageColorSpace = ColorSpaceKHR.SrgbNonlinear,
QueueFamilyIndices = null,
PreTransform = preTransform,
CompositeAlpha = CompositeAlphaFlagsKHR.Opaque,
PresentMode = swapChainPresentMode,
Clipped = true,
};
data.Swapchain = device.CreateSwapchainKHR(swapchainCreateInfo);
data.ImageFormat = surfaceFormat;
return(data);
}
public static bool CheckSwapchainCreateInfo(PhysicalDevice physicalDevice, SwapchainCreateInfoKhr createInfo, bool fixExtend)
{
SurfaceKhr surface = createInfo.Surface;
foreach (uint index in createInfo.QueueFamilyIndices)
{
if (!physicalDevice.GetSurfaceSupportKHR(index, surface))
{
return(false);
}
}
bool supportImageFormat = false;
foreach (SurfaceFormatKhr suportedFormat in physicalDevice.GetSurfaceFormatsKHR(surface))
{
if (suportedFormat.Format == createInfo.ImageFormat &&
suportedFormat.ColorSpace == createInfo.ImageColorSpace)
{
supportImageFormat = true;
break;
}
}
if (!supportImageFormat)
{
return(false);
}
SurfaceCapabilitiesKhr capabilities = physicalDevice.GetSurfaceCapabilitiesKHR(surface);
if (fixExtend)
{
var extend = createInfo.ImageExtent;
extend.Width = Clamp(extend.Width, capabilities.MinImageExtent.Width, capabilities.MaxImageExtent.Width);
extend.Height = Clamp(extend.Height, capabilities.MinImageExtent.Height, capabilities.MaxImageExtent.Height);
createInfo.ImageExtent = extend;
}
if (createInfo.PreTransform == SurfaceTransformFlagsKhr.Inherit)
{
createInfo.PreTransform = capabilities.CurrentTransform;
}
// TODO: Fix up CompositeAlpha if Inherit is set
if (capabilities.MinImageCount <= createInfo.MinImageCount &&
capabilities.MaxImageCount >= createInfo.MinImageCount &&
capabilities.MaxImageArrayLayers <= createInfo.ImageArrayLayers &&
((capabilities.SupportedTransforms & createInfo.PreTransform) == createInfo.PreTransform) &&
((capabilities.SupportedCompositeAlpha & createInfo.CompositeAlpha) == createInfo.CompositeAlpha) &&
((capabilities.SupportedUsageFlags & createInfo.ImageUsage) == createInfo.ImageUsage) &&
createInfo.ImageExtent.Width >= capabilities.MinImageExtent.Width &&
createInfo.ImageExtent.Width <= capabilities.MaxImageExtent.Width &&
createInfo.ImageExtent.Height >= capabilities.MinImageExtent.Height &&
createInfo.ImageExtent.Height <= capabilities.MaxImageExtent.Height)
{
return(true);
}
return(false);
}
private void InitializeVulkan(PhysicalDevice physDev, SurfaceKhr surface)
{
var queueFamilyProperties = physDev.GetQueueFamilyProperties();
uint queueFamilyUsedIndex;
for (queueFamilyUsedIndex = 0; queueFamilyUsedIndex < queueFamilyProperties.Length; ++queueFamilyUsedIndex)
{
if (!physDev.GetSurfaceSupportKHR(queueFamilyUsedIndex, surface))
{
continue;
}
if (queueFamilyProperties[queueFamilyUsedIndex].QueueFlags.HasFlag(QueueFlags.Graphics))
{
break;
}
}
var queueInfo = new DeviceQueueCreateInfo
{
QueuePriorities = new[] { 1.0f },
QueueFamilyIndex = queueFamilyUsedIndex
};
var deviceInfo = new DeviceCreateInfo
{
EnabledExtensionNames = new[]
{
"VK_KHR_swapchain",
},
QueueCreateInfos = new[] { queueInfo }
};
_device = physDev.CreateDevice(deviceInfo);
_queue = _device.GetQueue(0, 0);
_surfaceCapabilities = physDev.GetSurfaceCapabilitiesKHR(surface);
var surfaceFormat = SelectSurfaceFormat(physDev, surface);
_swapchainKhr = CreateSwapchainKhr(surface, surfaceFormat);
_images = _device.GetSwapchainImagesKHR(_swapchainKhr);
_renderPass = CreateRenderPass(surfaceFormat);
_framebuffers = CreateFramebuffers(_images, surfaceFormat);
var fenceInfo = new FenceCreateInfo();
_fence = _device.CreateFence(fenceInfo);
var semaphoreInfo = new SemaphoreCreateInfo();
_semaphore = _device.CreateSemaphore(semaphoreInfo);
_commandBuffers = CreateCommandBuffers(_images, _framebuffers, _renderPass, _surfaceCapabilities);
}
public virtual void Initialize(PhysicalDevice physicalDevice, SurfaceKhr surface)
{
var queueFamilyProperties = physicalDevice.GetQueueFamilyProperties();
uint queueFamilyUsedIndex;
for (queueFamilyUsedIndex = 0; queueFamilyUsedIndex < queueFamilyProperties.Length; ++queueFamilyUsedIndex)
{
if (!physicalDevice.GetSurfaceSupportKHR(queueFamilyUsedIndex, surface))
{
continue;
}
if (queueFamilyProperties [queueFamilyUsedIndex].QueueFlags.HasFlag(QueueFlags.Graphics))
{
break;
}
}
var queueInfo = new DeviceQueueCreateInfo {
QueuePriorities = new float [] { 1.0f }, QueueFamilyIndex = queueFamilyUsedIndex
};
var deviceInfo = new DeviceCreateInfo {
EnabledExtensionNames = new string [] { "VK_KHR_swapchain" },
QueueCreateInfos = new DeviceQueueCreateInfo [] { queueInfo }
};
device = physicalDevice.CreateDevice(deviceInfo);
queue = device.GetQueue(0, 0);
surfaceCapabilities = physicalDevice.GetSurfaceCapabilitiesKHR(surface);
var surfaceFormat = SelectFormat(physicalDevice, surface);
swapchain = CreateSwapchain(surface, surfaceFormat);
images = device.GetSwapchainImagesKHR(swapchain);
renderPass = CreateRenderPass(surfaceFormat);
framebuffers = CreateFramebuffers(images, surfaceFormat);
var fenceInfo = new FenceCreateInfo();
fence = device.CreateFence(fenceInfo);
var semaphoreInfo = new SemaphoreCreateInfo();
semaphore = device.CreateSemaphore(semaphoreInfo);
initialized = true;
}
public SwapChainSupportDetails(PhysicalDevice device, SurfaceKhr surface)
{
capabilities = device.GetSurfaceCapabilitiesKHR(surface);
formats = device.GetSurfaceFormatsKHR(surface);
presentModes = device.GetSurfacePresentModesKHR(surface);
}
static void CreateSwapchain()
{
// surface format
var surfaceFormats = physicalDevice.GetSurfaceFormatsKHR(surface);
if (surfaceFormats.Count == 1 && surfaceFormats[0].Format == Format.Undefined)
{
backBufferFormat = Format.B8g8r8a8Unorm;
Console.WriteLine($"using default backBufferFormat {backBufferFormat}");
}
else
{
backBufferFormat = surfaceFormats[0].Format;
Console.WriteLine($"backBufferFormat {backBufferFormat}");
}
var surfaceCapabilities = physicalDevice.GetSurfaceCapabilitiesKHR(surface);
// Buffer count
var desiredImageCount = surfaceCapabilities.MinImageCount + 1;
if (surfaceCapabilities.MaxImageCount > 0 && desiredImageCount > surfaceCapabilities.MaxImageCount)
{
desiredImageCount = surfaceCapabilities.MaxImageCount;
}
// Transform
SurfaceTransformFlagsKhr preTransform;
if ((surfaceCapabilities.SupportedTransforms & SurfaceTransformFlagsKhr.Identity) != 0)
{
preTransform = SurfaceTransformFlagsKhr.Identity;
}
else
{
preTransform = surfaceCapabilities.CurrentTransform;
}
// Present mode
var presentModes = physicalDevice.GetSurfacePresentModesKHR(surface);
var swapChainPresentMode = PresentModeKhr.Fifo;
if (presentModes.Contains(PresentModeKhr.Mailbox))
{
swapChainPresentMode = PresentModeKhr.Mailbox;
}
else if (presentModes.Contains(PresentModeKhr.Immediate))
{
swapChainPresentMode = PresentModeKhr.Immediate;
}
Console.WriteLine($"swapChainPresentMode {swapChainPresentMode}");
// Create swapchain
/*var swapchainCreateInfo = new SwapchainCreateInfoKhr
* {
* Surface = surface,
* ImageSharingMode = SharingMode.Exclusive,
* ImageExtent = new Extent2D { Width = 800, Height = 600 },
* ImageArrayLayers = 1,
* ImageFormat = backBufferFormat,
* ImageColorSpace = ColorSpaceKhr.SrgbNonlinear,
* ImageUsage = (uint)ImageUsageFlags.ColorAttachment,
* PresentMode = swapChainPresentMode,
* CompositeAlpha = CompositeAlphaFlagsKhr.Opaque,
* MinImageCount = desiredImageCount,
* PreTransform = preTransform,
* Clipped = true,
* };
* swapchain = device.CreateSwapchainKHR(swapchainCreateInfo, null);
* Console.WriteLine("[ OK ] Swapchain");
*
* backBuffers = device.GetSwapchainImagesKHR(swapchain);*/
}
private (SurfaceCapabilitiesKhr surfaceCapablities, SurfaceFormatKhr[] formats, PresentModeKhr[] presentModes) QuerySwapchainSupport(PhysicalDevice device)
{
return(device.GetSurfaceCapabilitiesKHR(data.surface), device.GetSurfaceFormatsKHR(data.surface), device.GetSurfacePresentModesKHR(data.surface));
}
public void Create(CommandBuffer commandBuffer) {
var surfaceCapabilities = PhysicalDevice.GetSurfaceCapabilitiesKHR(Surface);
Extent2D swapChainExtend = new Extent2D {
Width = surfaceCapabilities.CurrentExtent.Width,
Height = surfaceCapabilities.CurrentExtent.Height
};
var presentModes = PhysicalDevice.GetSurfacePresentModesKHR(Surface);
PresentModeKhr presentMode = GetBestPresentMode(presentModes);
var desiredImages = surfaceCapabilities.MinImageCount + 1;
if (surfaceCapabilities.MaxImageCount > 0 && desiredImages > surfaceCapabilities.MaxImageCount) {
desiredImages = surfaceCapabilities.MaxImageCount;
}
var preTransform = surfaceCapabilities.CurrentTransform;
if (surfaceCapabilities.SupportedTransforms.HasFlag(SurfaceTransformFlagsKhr.Identity)) {
preTransform = SurfaceTransformFlagsKhr.Identity;
}
var oldSwapChain = Swapchain;
var swapChainCreateInfo = new SwapchainCreateInfoKhr {
Surface = Surface,
MinImageCount = desiredImages,
ImageFormat = ColorFormat,
ImageColorSpace = ColorSpace,
ImageExtent = swapChainExtend,
ImageUsage = ImageUsageFlags.ColorAttachment,
PreTransform = preTransform,
ImageArrayLayers = 1,
ImageSharingMode = SharingMode.Exclusive,
QueueFamilyIndexCount = 0,
QueueFamilyIndices = null,
PresentMode = presentMode,
Clipped = true,
// Alpha on the window surface should be opaque:
// If it was not we could create transparent regions of our window which
// would require support from the Window compositor. You can totally do
// that if you wanted though ;)
CompositeAlpha = CompositeAlphaFlagsKhr.Opaque
};
Swapchain = Device.CreateSwapchainKHR(swapChainCreateInfo);
if (oldSwapChain != null) {
Device.DestroySwapchainKHR(oldSwapChain);
}
Images = Device.GetSwapchainImagesKHR(Swapchain).ToList();
// Create the image views for the swap chain. They will all be single
// layer, 2D images, with no mipmaps.
// Check the VkImageViewCreateInfo structure to see other views you
// can potentially create.
for (var i = 0; i < Images.Count; i++) {
var buffer = new SwapChainBuffer();
var colorAttachmentView = new ImageViewCreateInfo {
Format = ColorFormat,
Components = new ComponentMapping {
R = ComponentSwizzle.R,
G = ComponentSwizzle.G,
B = ComponentSwizzle.B,
A = ComponentSwizzle.A
},
SubresourceRange = new ImageSubresourceRange {
AspectMask = ImageAspectFlags.Color,
BaseMipLevel = 0,
LevelCount = 1,
BaseArrayLayer = 0,
LayerCount = 1
},
ViewType = ImageViewType.View2D
};
buffer.Image = Images[i];
SetImageLayout(commandBuffer, buffer.Image, ImageAspectFlags.Color, ImageLayout.Undefined, ImageLayout.PresentSrcKhr);
buffer.View = Device.CreateImageView(colorAttachmentView);
Buffers.Add(buffer);
}
}
public SurfaceCapabilitiesKhr GetSurfaceCapabilities(MySurface surface)
{
return(_physicalDevice.GetSurfaceCapabilitiesKHR(surface.Handle));
}
