public FramebufferBuilder(RenderPass pass, VkExtent2D size, Func <TAttachment, uint> map, uint layers = 1) { _pass = pass; _size = size; _attachmentMap = map; _layers = layers; }
internal void SetNewSwapchain( VkSwapchainKHR deviceSwapchain, uint width, uint height, VkSurfaceFormatKHR surfaceFormat, VkExtent2D swapchainExtent) { _desiredWidth = width; _desiredHeight = height; // Get the images uint scImageCount = 0; VkResult result = vkGetSwapchainImagesKHR(_gd.Device, deviceSwapchain, ref scImageCount, null); CheckResult(result); if (_scImages == null) { _scImages = new VkImage[(int)scImageCount]; } result = vkGetSwapchainImagesKHR(_gd.Device, deviceSwapchain, ref scImageCount, out _scImages[0]); CheckResult(result); _scImageFormat = surfaceFormat.format; _scExtent = swapchainExtent; CreateDepthTexture(); CreateFramebuffers(); _outputDescription = OutputDescription.CreateFromFramebuffer(this); }
public Framebuffer(RenderPass pass, VkExtent2D size, uint layers, IEnumerable <ImageView> views) { Size = size; Device = pass.Device; var imageArray = views.Select(x => { x.AssertValid(); return(x.Handle); }).ToArray(); unsafe { fixed(VkImageView *view = imageArray) { var info = new VkFramebufferCreateInfo() { SType = VkStructureType.FramebufferCreateInfo, Flags = 0, PNext = IntPtr.Zero, RenderPass = pass.Handle, Width = size.Width, Height = size.Height, Layers = layers, AttachmentCount = (uint)imageArray.Length, PAttachments = view }; Handle = Device.Handle.CreateFramebuffer(&info, Instance.AllocationCallbacks); } } }
internal SwapchainKHRBuilder(SurfaceKHR surf, Device dev, VkExtent2D size) { _surf = surf; _dev = dev; _extent = size; _shareMode = VkSharingMode.Exclusive; _preferredTransform = 0; _requiredTransform = VkSurfaceTransformFlagBitsKHR.InheritBitKhr; }
public SoftwareFormSurface(SoftwareInstance instance, VkWin32SurfaceCreateInfoKHR createInfo) { this.m_Formats = new List <VkSurfaceFormatKHR>() { VkSurfaceFormatKHR.Create(VkFormat.VK_FORMAT_B8G8R8A8_UNORM, VkColorSpaceKHR.VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) }; this.m_PresentModes = new List <VkPresentModeKHR>() { VkPresentModeKHR.VK_PRESENT_MODE_IMMEDIATE_KHR }; this.m_instance = instance; this.m_createInfo = createInfo; foreach (Form form in Application.OpenForms) { if (form.Handle == createInfo.hwnd) { m_Form = form; } } if (m_Form == null) { throw new ArgumentException(string.Format("Form not found for the handle informed on the field {0}.{1}", nameof(VkWin32SurfaceCreateInfoKHR), nameof(VkWin32SurfaceCreateInfoKHR.hwnd))); } var m_OriginalExtents = VkExtent2D.Create(GetWidth(), GetHeight()); m_CurrentSurfaceExtents = m_OriginalExtents; this.m_Capabilities = new VkSurfaceCapabilitiesKHR(); this.m_Capabilities.currentExtent = m_OriginalExtents; this.m_Capabilities.maxImageExtent = m_OriginalExtents; this.m_Capabilities.minImageExtent = m_OriginalExtents; this.m_Capabilities.minImageCount = 1; this.m_Capabilities.maxImageCount = 8; this.m_Capabilities.maxImageArrayLayers = 1; this.m_Capabilities.supportedTransforms = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; this.m_Capabilities.currentTransform = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; this.m_Capabilities.supportedCompositeAlpha = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; this.m_Capabilities.supportedUsageFlags = VkImageUsageFlags.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; this.m_SurfacePresentMode = FormSurfacePresentMode.DibBitmapBitBlt; InternalResize(); m_Form.Resize += Form_Resize; }
public VkResult PresentImage(int imageIndex) { // TODO: SoftwareSwapchain.PresentImage() VkExtent2D imageExtent = new VkExtent2D( m_Images[imageIndex].m_imageExtent.width, m_Images[imageIndex].m_imageExtent.height); return(((BaseSoftwareSurface)m_createInfo.surface).PresentImage(m_Images[imageIndex], imageExtent)); }
void CreateSwapchain() { var support = GetSwapchainSupport(physicalDevice); var cap = support.cap; var surfaceFormat = ChooseSwapSurfaceFormat(support.formats); var mode = ChooseSwapPresentMode(support.modes); var extent = ChooseSwapExtent(ref cap); int imageCount = cap.minImageCount + 1; if (cap.maxImageCount > 0 && imageCount > cap.maxImageCount) { imageCount = cap.maxImageCount; } var oldSwapchain = swapchain; var info = new VkSwapchainCreateInfo(); info.surface = surface; info.oldSwapchain = oldSwapchain; info.minImageCount = imageCount; info.imageFormat = surfaceFormat.format; info.imageColorSpace = surfaceFormat.colorSpace; info.imageExtent = extent; info.imageArrayLayers = 1; info.imageUsage = VkImageUsageFlags.ColorAttachmentBit; var queueFamilyIndices = new List <int> { graphicsIndex, presentIndex }; if (graphicsIndex != presentIndex) { info.imageSharingMode = VkSharingMode.Concurrent; info.queueFamilyIndices = queueFamilyIndices; } else { info.imageSharingMode = VkSharingMode.Exclusive; } info.preTransform = cap.currentTransform; info.compositeAlpha = VkCompositeAlphaFlagsKHR.OpaqueBitKhr; info.presentMode = mode; info.clipped = true; swapchain = new VkSwapchain(device, info); oldSwapchain?.Dispose(); swapchainImages = new List <VkImage>(swapchain.Images); swapchainImageFormat = surfaceFormat.format; swapchainExtent = extent; }
public Framebuffer(Device dev, VkFramebufferCreateInfo info) { Device = dev; Size = new VkExtent2D() { Width = info.Width, Height = info.Height }; unsafe { Handle = dev.Handle.CreateFramebuffer(&info, Instance.AllocationCallbacks); } }
VkExtent2D ChooseSwapExtent(VkSurfaceCapabilitiesKHR capabilities) { if (capabilities.currentExtent.width != uint.MaxValue) { return(capabilities.currentExtent); } else { VkExtent2D actualExtent = new VkExtent2D(WIDTH, HEIGHT); actualExtent.width = Math.Max(capabilities.minImageExtent.width, Math.Min(capabilities.maxImageExtent.width, actualExtent.width)); actualExtent.height = Math.Max(capabilities.minImageExtent.height, Math.Min(capabilities.maxImageExtent.height, actualExtent.height)); return(actualExtent); } }
public VkResult PresentImage(SoftwareImage image, VkExtent2D imageExtent) { var form = m_Form; if (form == null || form.IsDisposed) { return(VkResult.VK_ERROR_DEVICE_LOST); } VkResult result; if ((imageExtent.width != m_CurrentSurfaceExtents.width) || (imageExtent.height != m_CurrentSurfaceExtents.height)) { InternalDrawUnscaled(image, form); return(VkResult.VK_SUBOPTIMAL_KHR); } /* * if ((imageExtent.width < m_CurrentExtents.width) || (imageExtent.height < m_CurrentExtents.height)) * { * return VkResult.VK_ERROR_OUT_OF_DATE_KHR; * } */ if (form.InvokeRequired) { result = (VkResult)form.Invoke((Func <VkResult>)(() => { return(InternalPresent(image, form)); })); } else { result = InternalPresent(image, form); } if ((imageExtent.width != m_CurrentSurfaceExtents.width) || (imageExtent.height != m_CurrentSurfaceExtents.height)) { if (result == VkResult.VK_SUCCESS) { result = VkResult.VK_SUBOPTIMAL_KHR; } } return(result); }
VkExtent2D ChooseSwapExtent(ref VkSurfaceCapabilitiesKHR cap) { if (cap.currentExtent.width != -1) { return(cap.currentExtent); } else { var extent = new VkExtent2D(); extent.width = width; extent.height = height; extent.width = Math.Max(cap.minImageExtent.width, Math.Min(cap.maxImageExtent.width, extent.width)); extent.height = Math.Max(cap.minImageExtent.height, Math.Min(cap.maxImageExtent.height, extent.height)); return(extent); } }
private VkExtent2D ChooseSwapExtent(VkSurfaceCapabilitiesKHR capabilities) { if (capabilities.currentExtent.width > 0) { return(capabilities.currentExtent); } else { VkExtent2D actualExtent = Window.Extent; actualExtent = new VkExtent2D( Math.Max(capabilities.minImageExtent.width, Math.Min(capabilities.maxImageExtent.width, actualExtent.width)), Math.Max(capabilities.minImageExtent.height, Math.Min(capabilities.maxImageExtent.height, actualExtent.height)) ); return(actualExtent); } }
private VkExtent2D chooseSwapExtent(VkSurfaceCapabilitiesKHR capabilities) { if (capabilities.currentExtent.width != Int32.MaxValue) { return(capabilities.currentExtent); } else { int width, height; GLFW.glfwGetWindowSize(window, out width, out height); VkExtent2D actualExtent = VkExtent2D.Create(width, height); actualExtent.width = Math.Max(capabilities.minImageExtent.width, Math.Min(capabilities.maxImageExtent.width, actualExtent.width)); actualExtent.height = Math.Max(capabilities.minImageExtent.height, Math.Min(capabilities.maxImageExtent.height, actualExtent.height)); return(actualExtent); } }
private VkPipelineViewportStateCreateInfo CreateViewportState() { VkExtent2D currentExtent = vkctrl.GetCurrentExtent(); var viewport = new VkViewport() { width = currentExtent.width, height = currentExtent.height, x = 0, y = 0, minDepth = 0.0f, maxDepth = 1.0f, }; var scissor = new VkRect2D() { extent = currentExtent }; var viewportState = new VkPipelineViewportStateCreateInfo(); viewportState.viewports = new[] { viewport }; viewportState.scissors = new[] { scissor }; return(viewportState); }
private void CreateSwapChain() { var swapChainSupport = QuerySwapChainSupport(physicalDevice, surface); var surfaceFormat = ChooseSwapSurfaceFormat(swapChainSupport.Formats); var presentMode = ChooseSwapPresentMode(swapChainSupport.PresentModes); var extent = ChooseSwapExtent(swapChainSupport.Capabilities); var minImages = swapChainSupport.Capabilities.MinImageCount; var maxImages = swapChainSupport.Capabilities.MaxImageCount > 0 ? swapChainSupport.Capabilities.MaxImageCount : int.MaxValue; var imageCount = Math.Max(minImages, Math.Min(maxImages, 2)); var indices = FindQueueFamilies(physicalDevice, surface).Value; var separateQueues = indices.GraphicsFamily != indices.PresentFamily; var createInfo = new VkSwapchainCreateInfoKHR { Surface = surface, MinImageCount = imageCount, ImageFormat = surfaceFormat.Format, ImageColorSpace = surfaceFormat.ColorSpace, ImageExtent = extent, ImageArrayLayers = 1, ImageUsage = VkImageUsageFlags.ColorAttachment, ImageSharingMode = separateQueues ? VkSharingMode.Concurrent : VkSharingMode.Exclusive, QueueFamilyIndices = separateQueues ? new[] { indices.GraphicsFamily, indices.PresentFamily } : null, PreTransform = swapChainSupport.Capabilities.CurrentTransform, CompositeAlpha = VkCompositeAlphaFlagsKHR.Opaque, PresentMode = presentMode, Clipped = true, OldSwapchain = null }; swapChain = device.CreateSwapchainKHR(createInfo, null).Object; swapChainImages = swapChain.GetImagesKHR().Object; swapchainImageFormat = surfaceFormat.Format; swapChainExtent = extent; }
public unsafe Swapchain(Device device, NativeWindow window) { _device = device; _window = window; //get present queue _presentQueueFamily = GetQueueFamilyWithPresentationSupport( device, window ); //get surface capabilities _surfaceCapabilities = GetSurfaceCapabilities( device, window ); //get surface format support _supportedSurfaceFormats = GetSupportedSurfaceFormats( device, window ); //get present mode support _supportedPresentModes = GetSupportedPresentModes( device, window ); //choose best surface format #region Surface Format if ( _supportedSurfaceFormats.Count == 1 && _supportedSurfaceFormats[0].format == VkFormat.Undefined ) { _surfaceFormat = new VkSurfaceFormatKHR { colorSpace = VkColorSpaceKHR.SrgbNonlinearKHR, format = VkFormat.R8g8b8Unorm }; } else { bool choosenFormat = false; foreach (var format in _supportedSurfaceFormats) { if ( format.format == VkFormat.R8g8b8Unorm && format.colorSpace == VkColorSpaceKHR.SrgbNonlinearKHR ) { _surfaceFormat = format; choosenFormat = true; break; } } if (choosenFormat == false) { _surfaceFormat = _supportedSurfaceFormats[0]; } } #endregion #region Surface Present Mode _surfacePresentMode = VkPresentModeKHR.FifoKHR; foreach (var presentMode in _supportedPresentModes) { if (presentMode == VkPresentModeKHR.MailboxKHR) { _surfacePresentMode = presentMode; break; } else if (presentMode == VkPresentModeKHR.ImmediateKHR) { _surfacePresentMode = presentMode; } } #endregion #region Surface Extent if (_surfaceCapabilities.currentExtent.width != uint.MaxValue) { _surfaceExtent = _surfaceCapabilities.currentExtent; } else { _surfaceExtent = new VkExtent2D { width = Math.Clamp( Convert.ToUInt32(window.Width), _surfaceCapabilities.minImageExtent.width, _surfaceCapabilities.maxImageExtent.width ), height = Math.Clamp( Convert.ToUInt32(window.Height), _surfaceCapabilities.minImageExtent.height, _surfaceCapabilities.maxImageExtent.height ) }; } #endregion #region Images Count var imagesCount = _surfaceCapabilities.minImageCount + 1; if (_surfaceCapabilities.maxImageCount > 0) { if (imagesCount > _surfaceCapabilities.maxImageCount) { imagesCount = Math.Min(_surfaceCapabilities.maxImageCount, 2); } } #endregion var queueFamilyIndices = new NativeList <uint>(); foreach (var queueFamily in device.QueueFamilies) { queueFamilyIndices.Add(queueFamily.Index); } var swapchainInfo = new VkSwapchainCreateInfoKHR { sType = VkStructureType.SwapchainCreateInfoKHR, compositeAlpha = VkCompositeAlphaFlagsKHR.OpaqueKHR, minImageCount = imagesCount, imageFormat = _surfaceFormat.format, imageColorSpace = _surfaceFormat.colorSpace, imageExtent = _surfaceExtent, imageArrayLayers = 1, imageUsage = ( VkImageUsageFlags.ColorAttachment | VkImageUsageFlags.TransferDst ), imageSharingMode = VkSharingMode.Concurrent, preTransform = _surfaceCapabilities.currentTransform, presentMode = _surfacePresentMode, surface = window.Surface, clipped = true, queueFamilyIndexCount = queueFamilyIndices.Count, pQueueFamilyIndices = (uint *)queueFamilyIndices.Data.ToPointer() }; VkSwapchainKHR swapchain; if (VulkanNative.vkCreateSwapchainKHR( device.Handle, &swapchainInfo, null, &swapchain ) != VkResult.Success) { throw new Exception("failed to create swapchain"); } _handle = swapchain; SetupSwapchainImages(); }
public unsafe Window(string title, int width, int height, WindowFlags flags = WindowFlags.None) { Title = title; bool fullscreen = false; GLFWmonitor *monitor = null; if ((flags & WindowFlags.Fullscreen) != WindowFlags.None) { monitor = glfwGetPrimaryMonitor(); fullscreen = true; } if ((flags & WindowFlags.FullscreenDesktop) != WindowFlags.None) { monitor = glfwGetPrimaryMonitor(); //auto mode = glfwGetVideoMode(monitor); // //glfwWindowHint(GLFW_RED_BITS, mode->redBits); //glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits); //glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits); //glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate); glfwWindowHint(WindowHintBool.Decorated, false); fullscreen = true; } if (!fullscreen) { if ((flags & WindowFlags.Borderless) != WindowFlags.None) { glfwWindowHint(WindowHintBool.Decorated, false); } else { glfwWindowHint(WindowHintBool.Decorated, true); } if ((flags & WindowFlags.Resizable) != WindowFlags.None) { glfwWindowHint(WindowHintBool.Resizable, true); } if ((flags & WindowFlags.Hidden) != WindowFlags.None) { glfwWindowHint(WindowHintBool.Visible, false); } if ((flags & WindowFlags.Minimized) != WindowFlags.None) { glfwWindowHint(WindowHintBool.Iconified, true); } if ((flags & WindowFlags.Maximized) != WindowFlags.None) { glfwWindowHint(WindowHintBool.Maximized, true); } } _window = glfwCreateWindow(width, height, title, monitor, null); //Handle = hwnd; glfwGetWindowSize(_window, out width, out height); Extent = new VkExtent2D(width, height); }
public static extern void GetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, out VkExtent2D pGranularity );
public SwapchainKHR(SurfaceKHR surface, Device device, uint minImageCount, uint layerCount, VkImageUsageFlag usageFlag, VkFormat imageFormat, VkColorSpaceKHR colorSpace, VkExtent2D dimensions, VkCompositeAlphaFlagBitsKHR compositeAlpha, VkPresentModeKHR presentMode, bool clipped = true, VkSurfaceTransformFlagBitsKHR transform = VkSurfaceTransformFlagBitsKHR.IdentityBitKhr, VkSharingMode sharing = VkSharingMode.Exclusive, uint[] sharedQueueFamily = null, SwapchainKHR oldSwapchain = null) { SurfaceKHR = surface; Device = device; { var surfSupported = false; foreach (var family in Device.Queues.Select(x => x.FamilyIndex).Distinct()) { if (PhysicalDevice.Handle.GetPhysicalDeviceSurfaceSupportKHR(family, SurfaceKHR.Handle)) { surfSupported = true; break; } } if (!surfSupported) { throw new NotSupportedException($"No queues on device support the surface"); } } _sharingQueueInfo = sharedQueueFamily; unsafe { if (sharing == VkSharingMode.Concurrent) { Debug.Assert(sharedQueueFamily != null); } var hasPinnedSharedQueue = sharedQueueFamily != null && sharedQueueFamily.Length > 0; var pinnedSharedQueueFamily = hasPinnedSharedQueue ? GCHandle.Alloc(sharedQueueFamily, GCHandleType.Pinned) : default(GCHandle); try { var info = new VkSwapchainCreateInfoKHR() { SType = VkStructureType.SwapchainCreateInfoKhr, PNext = IntPtr.Zero, Flags = 0, // reserved VkSwapchainCreateFlagBitsKHR Surface = surface.Handle, MinImageCount = minImageCount, ImageFormat = imageFormat, ImageColorSpace = colorSpace, ImageExtent = dimensions, ImageArrayLayers = layerCount, ImageUsage = usageFlag, ImageSharingMode = sharing, QueueFamilyIndexCount = (uint)(sharedQueueFamily?.Length ?? 0), PQueueFamilyIndices = hasPinnedSharedQueue ? (uint *)Marshal.UnsafeAddrOfPinnedArrayElement(sharedQueueFamily, 0).ToPointer() : (uint *)0, PreTransform = transform, CompositeAlpha = compositeAlpha, PresentMode = presentMode, Clipped = clipped, OldSwapchain = oldSwapchain?.Handle ?? VkSwapchainKHR.Null }; _info = info; Handle = Device.Handle.CreateSwapchainKHR(&info, Instance.AllocationCallbacks); if (oldSwapchain != null) { foreach (var img in oldSwapchain._swapchainImages) { img.Dispose(); } oldSwapchain.Dispose(); } } finally { if (hasPinnedSharedQueue) { pinnedSharedQueueFamily.Free(); } } } var images = Device.Handle.GetSwapchainImagesKHR(Handle); _swapchainImages.Clear(); _swapchainImages.Capacity = images.Length; foreach (var img in images) { _swapchainImages.Add(new SwapchainImage(this, img)); } }
void CreateSwapchain() { var support = GetSwapchainSupport(physicalDevice); var cap = support.cap.Value; var surfaceFormat = ChooseSwapSurfaceFormat(support.formats); var mode = ChooseSwapPresentMode(support.modes); var extent = ChooseSwapExtent(ref cap); uint imageCount = cap.minImageCount + 1; if (cap.maxImageCount > 0 && imageCount > cap.maxImageCount) { imageCount = cap.maxImageCount; } var info = new VkSwapchainCreateInfoKHR(); info.sType = CSGL.Vulkan.VkStructureType.SwapchainCreateInfoKhr; info.surface = surface; info.minImageCount = imageCount; info.imageFormat = surfaceFormat.format; info.imageColorSpace = surfaceFormat.colorSpace; info.imageExtent = extent; info.imageArrayLayers = 1; info.imageUsage = CSGL.Vulkan.VkImageUsageFlags.ColorAttachmentBit; var queueFamilyIndices = new NativeArray <uint>(2); queueFamilyIndices[0] = graphicsIndex; queueFamilyIndices[1] = presentIndex; if (graphicsIndex != presentIndex) { info.imageSharingMode = CSGL.Vulkan.VkSharingMode.Concurrent; info.queueFamilyIndexCount = 2; info.pQueueFamilyIndices = queueFamilyIndices.Address; } else { info.imageSharingMode = CSGL.Vulkan.VkSharingMode.Exclusive; } info.preTransform = cap.currentTransform; info.compositeAlpha = CSGL.Vulkan.VkCompositeAlphaFlagsKHR.OpaqueBitKhr; info.presentMode = mode; info.clipped = 1; var oldSwapchain = swapchain; info.oldSwapchain = oldSwapchain; VkSwapchainKHR newSwapchain; var result = createSwapchain(device, ref info, alloc, out newSwapchain); if (swapchain != VkSwapchainKHR.Null) { destroySwapchain(device, swapchain, alloc); } swapchain = newSwapchain; getSwapchainImages(device, swapchain, ref imageCount, IntPtr.Zero); var swapchainImagesNative = new NativeArray <VkImage>(imageCount); getSwapchainImages(device, swapchain, ref imageCount, swapchainImagesNative.Address); swapchainImages = new List <VkImage>(swapchainImagesNative.Count); for (int i = 0; i < imageCount; i++) { swapchainImages.Add(swapchainImagesNative[i]); } swapchainImageFormat = surfaceFormat.format; swapchainExtent = extent; support.cap.Dispose(); queueFamilyIndices.Dispose(); }
//private readonly WindowStyles _windowFullscreenStyle = WindowStyles.WS_CLIPSIBLINGS | WindowStyles.WS_GROUP | WindowStyles.WS_TABSTOP; public unsafe Window(string title, int width, int height, WindowFlags flags = WindowFlags.None) { Title = title; int x = CW_USEDEFAULT; int y = CW_USEDEFAULT; bool resizable = (flags & WindowFlags.Resizable) != WindowFlags.None; _windowWindowedStyle = WindowStyles.WS_CAPTION | WindowStyles.WS_SYSMENU | WindowStyles.WS_MINIMIZEBOX | WindowStyles.WS_CLIPSIBLINGS | WindowStyles.WS_BORDER | WindowStyles.WS_DLGFRAME | WindowStyles.WS_THICKFRAME | WindowStyles.WS_GROUP | WindowStyles.WS_TABSTOP; if (resizable) { _windowWindowedStyle |= WindowStyles.WS_SIZEBOX | WindowStyles.WS_MAXIMIZEBOX; } _windowStyle = _windowWindowedStyle; RawRect windowRect = new RawRect(0, 0, width, height); // Adjust according to window styles AdjustWindowRectEx(ref windowRect, _windowStyle, false, WindowExStyles.WS_EX_OVERLAPPEDWINDOW); int windowWidth = windowRect.Right - windowRect.Left; int windowHeight = windowRect.Bottom - windowRect.Top; bool centerWindow = true; if (centerWindow) { if (windowWidth > 0 && windowHeight > 0) { int screenWidth = GetSystemMetrics(SystemMetrics.SM_CXSCREEN); int screenHeight = GetSystemMetrics(SystemMetrics.SM_CYSCREEN); // Place the window in the middle of the screen.WS_EX_APPWINDOW x = (screenWidth - windowWidth) / 2; y = (screenHeight - windowHeight) / 2; } } IntPtr hwnd; fixed(char *lpWndClassName = WndClassName) { fixed(char *lpWindowName = Title) { hwnd = CreateWindowExW( (uint)WindowExStyles.WS_EX_OVERLAPPEDWINDOW, (ushort *)lpWndClassName, (ushort *)lpWindowName, (uint)_windowStyle, x, y, windowWidth, windowHeight, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, null); } } if (hwnd == IntPtr.Zero) { return; } ShowWindow(hwnd, ShowWindowCommand.Normal); Handle = hwnd; GetClientRect(hwnd, out windowRect); Extent = new VkExtent2D(windowRect.Right - windowRect.Left, windowRect.Bottom - windowRect.Top); }
/// <summary> /// Initializes a new instance of the <see cref="VkRect2D"/> structure. /// </summary> /// <param name="width">The width component of the extent.</param> /// <param name="height">The height component of the extent.</param> public VkRect2D(int width, int height) { offset = default; extent = new VkExtent2D(width, height); }
/// <summary> /// Initializes a new instance of the <see cref="VkRect2D"/> structure. /// </summary> /// <param name="x">The X component of the offset.</param> /// <param name="y">The Y component of the offset.</param> /// <param name="width">The width component of the extent.</param> /// <param name="height">The height component of the extent.</param> public VkRect2D(int x, int y, int width, int height) { offset = new VkOffset2D(x, y); extent = new VkExtent2D(width, height); }
/// <summary> /// Initializes a new instance of the <see cref="VkRect2D"/> structure. /// </summary> /// <param name="extent">The extent component of the rectangle.</param> public VkRect2D(VkExtent2D extent) { offset = default; this.extent = extent; }
/// <summary> /// Initializes a new instance of the <see cref="VkRect2D"/> structure. /// </summary> /// <param name="offset">The offset component of the rectangle.</param> /// <param name="extent">The extent component of the rectangle.</param> public VkRect2D(VkOffset2D offset, VkExtent2D extent) { this.offset = offset; this.extent = extent; }
private void OnDraw(VkCommandBuffer commandBuffer, VkFramebuffer framebuffer, VkExtent2D size) { float g = _green + 0.001f; if (g > 1.0f) { g = 0.0f; } _green = g; VkClearValue clearValue = new VkClearValue(1.0f, _green, 0.0f, 1.0f); // Begin the render pass. VkRenderPassBeginInfo renderPassBeginInfo = new VkRenderPassBeginInfo { sType = VkStructureType.RenderPassBeginInfo, renderPass = _graphicsDevice !.Swapchain.RenderPass, framebuffer = framebuffer, renderArea = new VkRect2D(size), clearValueCount = 1, pClearValues = &clearValue }; vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VkSubpassContents.Inline); vkCmdEndRenderPass(commandBuffer); } }
public FramebufferBuilder <uint> FramebufferBuilder(VkExtent2D size, uint layers = 1) { return(new FramebufferBuilder <uint>(this, size, (x) => x, layers)); }
private void CreateSwapChain() { // Create SwapChain SwapChainSupportDetails swapChainSupport = this.QuerySwapChainSupport(this.physicalDevice); VkSurfaceFormatKHR surfaceFormat = this.ChooseSwapSurfaceFormat(swapChainSupport.formats); VkPresentModeKHR presentMode = this.ChooseSwapPresentMode(swapChainSupport.presentModes); VkExtent2D extent = this.ChooseSwapExtent(swapChainSupport.capabilities); uint imageCount = swapChainSupport.capabilities.minImageCount + 1; if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) { imageCount = swapChainSupport.capabilities.maxImageCount; } VkSwapchainCreateInfoKHR createInfo = new VkSwapchainCreateInfoKHR(); createInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; createInfo.surface = surface; createInfo.minImageCount = imageCount; createInfo.imageFormat = surfaceFormat.format; createInfo.imageColorSpace = surfaceFormat.colorSpace; createInfo.imageExtent = extent; createInfo.imageArrayLayers = 1; createInfo.imageUsage = VkImageUsageFlags.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; QueueFamilyIndices indices = this.FindQueueFamilies(this.physicalDevice); uint *queueFamilyIndices = stackalloc uint[] { indices.graphicsFamily.Value, indices.presentFamily.Value }; if (indices.graphicsFamily != indices.presentFamily) { createInfo.imageSharingMode = VkSharingMode.VK_SHARING_MODE_CONCURRENT; createInfo.queueFamilyIndexCount = 2; createInfo.pQueueFamilyIndices = queueFamilyIndices; } else { createInfo.imageSharingMode = VkSharingMode.VK_SHARING_MODE_EXCLUSIVE; createInfo.queueFamilyIndexCount = 0; //Optional createInfo.pQueueFamilyIndices = null; //Optional } createInfo.preTransform = swapChainSupport.capabilities.currentTransform; createInfo.compositeAlpha = VkCompositeAlphaFlagsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; createInfo.presentMode = presentMode; createInfo.clipped = true; createInfo.oldSwapchain = 0; fixed(VkSwapchainKHR *swapChainPtr = &swapChain) { Helpers.CheckErrors(VulkanNative.vkCreateSwapchainKHR(device, &createInfo, null, swapChainPtr)); } // SwapChain Images VulkanNative.vkGetSwapchainImagesKHR(device, swapChain, &imageCount, null); this.swapChainImages = new VkImage[imageCount]; fixed(VkImage *swapChainImagesPtr = &this.swapChainImages[0]) { VulkanNative.vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImagesPtr); } this.swapChainImageFormat = surfaceFormat.format; this.swapChainExtent = extent; }
private void CreateSwapChain() { var swapChainSupport = new SwapChainSupportDetails(vkPhysicalDevice, vkSurface); VkSurfaceFormatKHR surfaceFormat = ChooseSwapSurfaceFormat(swapChainSupport.formats); VkPresentModeKHR presentMode = ChooseSwapPresentMode(swapChainSupport.presentModes); VkExtent2D extent = ChooseSwapExtent(swapChainSupport.capabilities); uint imageCount = swapChainSupport.capabilities.minImageCount + 1; if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) { imageCount = Math.Min(imageCount, swapChainSupport.capabilities.maxImageCount); } var createInfo = new VkSwapchainCreateInfoKHR() { sType = VkStructureType.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, surface = vkSurface, minImageCount = imageCount, imageFormat = surfaceFormat.format, imageColorSpace = surfaceFormat.colorSpace, imageExtent = extent, imageArrayLayers = 1, imageUsage = VkImageUsageFlagBits.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, preTransform = swapChainSupport.capabilities.currentTransform, compositeAlpha = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, presentMode = presentMode, clipped = true, }; var indices = new QueueFamilyIndices(vkPhysicalDevice, vkSurface); uint *QueueFamilyIndicesPtr = stackalloc uint[] { (uint)indices.GraphicsFamily, (uint)indices.PresentFamily, }; if (indices.GraphicsFamily != indices.PresentFamily) { createInfo.imageSharingMode = VkSharingMode.VK_SHARING_MODE_CONCURRENT; createInfo.pQueueFamilyIndices = QueueFamilyIndicesPtr; } else { createInfo.imageSharingMode = VkSharingMode.VK_SHARING_MODE_EXCLUSIVE; } VkSwapchainKHR newSwapChain; var result = VulkanNative.vkCreateSwapchainKHR(vkDevice, &createInfo, null, &newSwapChain); vkSwapChain = newSwapChain; Helpers.CheckErrors(result); VulkanNative.vkGetSwapchainImagesKHR(vkDevice, vkSwapChain, &imageCount, null); VkImage *images = stackalloc VkImage[(int)imageCount]; result = VulkanNative.vkGetSwapchainImagesKHR(vkDevice, vkSwapChain, &imageCount, images); Helpers.CheckErrors(result); vkSwapChainImages = new VkImage[imageCount]; for (int i = 0; i < imageCount; i++) { vkSwapChainImages[i] = images[i]; } vkSwapChainImageFormat = surfaceFormat.format; vkSwapChainExtent = extent; }
private void createSwapChain() { SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice); VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats); VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes); VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities); int imageCount = swapChainSupport.capabilities.minImageCount + 1; if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) { imageCount = swapChainSupport.capabilities.maxImageCount; } VkSwapchainCreateInfoKHR createInfo = new VkSwapchainCreateInfoKHR(); createInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; createInfo.surface = surface; createInfo.minImageCount = imageCount; createInfo.imageFormat = surfaceFormat.format; createInfo.imageColorSpace = surfaceFormat.colorSpace; createInfo.imageExtent = extent; createInfo.imageArrayLayers = 1; createInfo.imageUsage = VkImageUsageFlags.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; QueueFamilyIndices indices = findQueueFamilies(physicalDevice); var queueFamilyIndices = new List <int>() { indices.graphicsFamily, indices.presentFamily }; if (indices.graphicsFamily != indices.presentFamily) { createInfo.imageSharingMode = VkSharingMode.VK_SHARING_MODE_CONCURRENT; createInfo.queueFamilyIndexCount = queueFamilyIndices.Count; createInfo.pQueueFamilyIndices = queueFamilyIndices.ToArray(); } else { createInfo.imageSharingMode = VkSharingMode.VK_SHARING_MODE_EXCLUSIVE; } createInfo.preTransform = (VkSurfaceTransformFlagBitsKHR)swapChainSupport.capabilities.currentTransform; createInfo.compositeAlpha = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; createInfo.presentMode = presentMode; createInfo.clipped = VkBool32.VK_TRUE; createInfo.oldSwapchain = null; VkResult result = Vulkan.vkCreateSwapchainKHR(device, createInfo, null, out swapChain); if (result != VkResult.VK_SUCCESS) { throw Program.Throw("failed to create swap chain!", result); } swapChainImages = new VkImage[imageCount]; Vulkan.vkGetSwapchainImagesKHR(device, swapChain, ref imageCount, swapChainImages); swapChainImageFormat = surfaceFormat.format; swapChainExtent = extent; }