sharkk/gpu public

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

package gpu_core

import "core:log"
import vk "vendor:vulkan"
import bk "../backend"

// Create a Vulkan surface from a backend-neutral surface descriptor.
create_surface :: proc(desc: bk.Surface_Desc, instance: vk.Instance) -> (surface: vk.SurfaceKHR, ok: bool) {
	switch desc.kind {
	case .X11:
		return create_xlib_surface(instance, desc.x11)
	case .Wayland:
		return create_wayland_surface(instance, desc.wayland)
	case .Win32:
		return create_win32_surface(instance, desc.win32)
	case .None:
	}

	log.error("gpu/core: unsupported surface descriptor for Vulkan surface")
	return 0, false
}

@(private)
create_xlib_surface :: proc(instance: vk.Instance, handle: bk.X11_Surface_Handle) -> (vk.SurfaceKHR, bool) {
	when ODIN_OS == .Linux {
		info := vk.XlibSurfaceCreateInfoKHR{
			sType  = .XLIB_SURFACE_CREATE_INFO_KHR,
			dpy    = auto_cast handle.display,
			window = auto_cast handle.window,
		}
		surface: vk.SurfaceKHR
		result := vk.CreateXlibSurfaceKHR(instance, &info, nil, &surface)
		if result != .SUCCESS {
			log.errorf("gpu/core: vkCreateXlibSurfaceKHR failed: %v", result)
			return 0, false
		}
		return surface, true
	} else {
		return 0, false
	}
}

@(private)
create_wayland_surface :: proc(instance: vk.Instance, handle: bk.Wayland_Surface_Handle) -> (vk.SurfaceKHR, bool) {
	when ODIN_OS == .Linux {
		info := vk.WaylandSurfaceCreateInfoKHR{
			sType   = .WAYLAND_SURFACE_CREATE_INFO_KHR,
			display = auto_cast handle.display,
			surface = auto_cast handle.surface,
		}
		surface: vk.SurfaceKHR
		result := vk.CreateWaylandSurfaceKHR(instance, &info, nil, &surface)
		if result != .SUCCESS {
			log.errorf("gpu/core: vkCreateWaylandSurfaceKHR failed: %v", result)
			return 0, false
		}
		return surface, true
	} else {
		return 0, false
	}
}

@(private)
create_win32_surface :: proc(instance: vk.Instance, handle: bk.Win32_Surface_Handle) -> (vk.SurfaceKHR, bool) {
	when ODIN_OS == .Windows {
		info := vk.Win32SurfaceCreateInfoKHR{
			sType     = .WIN32_SURFACE_CREATE_INFO_KHR,
			hinstance = auto_cast handle.hinstance,
			hwnd      = auto_cast handle.hwnd,
		}
		surface: vk.SurfaceKHR
		result := vk.CreateWin32SurfaceKHR(instance, &info, nil, &surface)
		if result != .SUCCESS {
			log.errorf("gpu/core: vkCreateWin32SurfaceKHR failed: %v", result)
			return 0, false
		}
		return surface, true
	} else {
		return 0, false
	}
}