Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Namespaces | Classes | Functions
skwindow Namespace Reference

Namespaces

namespace  internal
 

Classes

struct  DisplayParams
 
struct  IOSWindowInfo
 
struct  MacWindowInfo
 
class  WindowContext
 
struct  XlibWindowInfo
 

Functions

std::unique_ptr< WindowContext > MakeGraphiteVulkanForAndroid (ANativeWindow *window, const DisplayParams &params)
 
std::unique_ptr< WindowContext > MakeVulkanForAndroid (ANativeWindow *window, const DisplayParams &params)
 
static CGFloat GetBackingScaleFactor (NSView *view)
 
std::unique_ptr< WindowContext > MakeGraphiteVulkanForXlib (const XlibWindowInfo &info, const DisplayParams &displayParams)
 
std::unique_ptr< WindowContext > MakeRasterForXlib (const XlibWindowInfo &info, const DisplayParams &params)
 
std::unique_ptr< WindowContext > MakeVulkanForXlib (const XlibWindowInfo &info, const DisplayParams &displayParams)
 
std::unique_ptr< WindowContext > MakeGraphiteVulkanForWin (HWND hwnd, const DisplayParams &params)
 
std::unique_ptr< WindowContext > MakeRasterForWin (HWND wnd, const DisplayParams &params)
 
std::unique_ptr< WindowContext > MakeVulkanForWin (HWND hwnd, const DisplayParams &params)
 

Function Documentation

◆ GetBackingScaleFactor()

static CGFloat skwindow::GetBackingScaleFactor ( NSView *  view)
inlinestatic

Definition at line 22 of file WindowContextFactory_mac.h.

22 {
23 #ifdef SK_BUILD_FOR_IOS
24 UIScreen* screen = view.window.screen ?: [UIScreen mainScreen];
25 return screen.nativeScale;
26 #else
27 NSScreen* screen = view.window.screen ?: [NSScreen mainScreen];
28 return screen.backingScaleFactor;
29 #endif
30}

◆ MakeGraphiteVulkanForAndroid()

std::unique_ptr< WindowContext > skwindow::MakeGraphiteVulkanForAndroid ( ANativeWindow *  window,
const DisplayParams &  params 
)

Definition at line 16 of file GraphiteVulkanWindowContext_android.cpp.

17 {
18 PFN_vkGetInstanceProcAddr instProc;
19 if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc)) {
20 return nullptr;
21 }
22
23 auto createVkSurface = [window, instProc] (VkInstance instance) -> VkSurfaceKHR {
24 PFN_vkCreateAndroidSurfaceKHR createAndroidSurfaceKHR =
25 (PFN_vkCreateAndroidSurfaceKHR) instProc(instance, "vkCreateAndroidSurfaceKHR");
26
27 if (!window) {
28 return VK_NULL_HANDLE;
29 }
30 VkSurfaceKHR surface;
31
32 VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo;
33 memset(&surfaceCreateInfo, 0, sizeof(VkAndroidSurfaceCreateInfoKHR));
34 surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
35 surfaceCreateInfo.pNext = nullptr;
36 surfaceCreateInfo.flags = 0;
37 surfaceCreateInfo.window = window;
38
39 VkResult res = createAndroidSurfaceKHR(instance, &surfaceCreateInfo,
40 nullptr, &surface);
41 return (VK_SUCCESS == res) ? surface : VK_NULL_HANDLE;
42 };
43
44 auto canPresent = [](VkInstance, VkPhysicalDevice, uint32_t) { return true; };
45
46 std::unique_ptr<WindowContext> ctx(
47 new internal::GraphiteVulkanWindowContext(params,
48 createVkSurface,
49 canPresent,
50 instProc));
51 if (!ctx->isValid()) {
52 return nullptr;
53 }
54
55 return ctx;
56}
params
const EmbeddedViewParams * params
Definition embedder_external_view_embedder.cc:138
window
GLFWwindow * window
Definition main.cc:45
instance
VkInstance instance
Definition main.cc:48
surface
VkSurfaceKHR surface
Definition main.cc:49
VkAndroidSurfaceCreateInfoKHR::window
struct ANativeWindow * window
Definition vulkan_android.h:32
VkAndroidSurfaceCreateInfoKHR::flags
VkAndroidSurfaceCreateFlagsKHR flags
Definition vulkan_android.h:31
PFN_vkCreateAndroidSurfaceKHR
VkResult(VKAPI_PTR * PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition vulkan_android.h:35
VkResult
VkResult
Definition vulkan_core.h:140
VK_SUCCESS
@ VK_SUCCESS
Definition vulkan_core.h:141
VK_NULL_HANDLE
#define VK_NULL_HANDLE
Definition vulkan_core.h:46
PFN_vkGetInstanceProcAddr
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
Definition vulkan_core.h:3989
VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR
@ VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR
Definition vulkan_core.h:432

◆ MakeGraphiteVulkanForWin()

std::unique_ptr< WindowContext > skwindow::MakeGraphiteVulkanForWin ( HWND  hwnd,
const DisplayParams &  params 
)

Definition at line 19 of file GraphiteVulkanWindowContext_win.cpp.

19 {
20 PFN_vkGetInstanceProcAddr instProc;
21 if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc)) {
22 return nullptr;
23 }
24
25 auto createVkSurface = [hwnd, instProc] (VkInstance instance) -> VkSurfaceKHR {
26 static PFN_vkCreateWin32SurfaceKHR createWin32SurfaceKHR = nullptr;
27 if (!createWin32SurfaceKHR) {
28 createWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR)
29 instProc(instance, "vkCreateWin32SurfaceKHR");
30 }
31 HINSTANCE hinstance = GetModuleHandle(0);
32 VkSurfaceKHR surface;
33
34 VkWin32SurfaceCreateInfoKHR surfaceCreateInfo;
35 memset(&surfaceCreateInfo, 0, sizeof(VkWin32SurfaceCreateInfoKHR));
36 surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
37 surfaceCreateInfo.pNext = nullptr;
38 surfaceCreateInfo.flags = 0;
39 surfaceCreateInfo.hinstance = hinstance;
40 surfaceCreateInfo.hwnd = hwnd;
41
42 VkResult res = createWin32SurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
43 if (VK_SUCCESS != res) {
44 return VK_NULL_HANDLE;
45 }
46
47 return surface;
48 };
49
50 auto canPresent = [instProc] (VkInstance instance, VkPhysicalDevice physDev,
51 uint32_t queueFamilyIndex) {
52 static PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR
53 getPhysicalDeviceWin32PresentationSupportKHR = nullptr;
54 if (!getPhysicalDeviceWin32PresentationSupportKHR) {
55 getPhysicalDeviceWin32PresentationSupportKHR =
56 (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)
57 instProc(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
58 }
59
60 VkBool32 check = getPhysicalDeviceWin32PresentationSupportKHR(physDev, queueFamilyIndex);
61 return (VK_FALSE != check);
62 };
63
64 std::unique_ptr<WindowContext> ctx(
65 new internal::GraphiteVulkanWindowContext(params, createVkSurface,
66 canPresent, instProc));
67 if (!ctx->isValid()) {
68 return nullptr;
69 }
70 return ctx;
71}
check
#define check(reporter, ref, unref, make, kill)
Definition RefCntTest.cpp:85
VkWin32SurfaceCreateInfoKHR::flags
VkWin32SurfaceCreateFlagsKHR flags
Definition vulkan_win32.h:30
VK_FALSE
#define VK_FALSE
Definition vulkan_core.h:125
VkBool32
uint32_t VkBool32
Definition vulkan_core.h:94
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
@ VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
Definition vulkan_core.h:433
PFN_vkCreateWin32SurfaceKHR
VkResult(VKAPI_PTR * PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition vulkan_win32.h:35
PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
Definition vulkan_win32.h:36

◆ MakeGraphiteVulkanForXlib()

std::unique_ptr< WindowContext > skwindow::MakeGraphiteVulkanForXlib ( const XlibWindowInfo &  info,
const DisplayParams &  displayParams 
)

Definition at line 18 of file GraphiteVulkanWindowContext_unix.cpp.

19 {
20 PFN_vkGetInstanceProcAddr instProc;
21 if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc)) {
22 SkDebugf("Could not load vulkan library\n");
23 return nullptr;
24 }
25
26 auto createVkSurface = [&info, instProc](VkInstance instance) -> VkSurfaceKHR {
27 static PFN_vkCreateXcbSurfaceKHR createXcbSurfaceKHR = nullptr;
28 if (!createXcbSurfaceKHR) {
29 createXcbSurfaceKHR =
30 (PFN_vkCreateXcbSurfaceKHR) instProc(instance, "vkCreateXcbSurfaceKHR");
31 }
32
33 VkSurfaceKHR surface;
34
35 VkXcbSurfaceCreateInfoKHR surfaceCreateInfo;
36 memset(&surfaceCreateInfo, 0, sizeof(VkXcbSurfaceCreateInfoKHR));
37 surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
38 surfaceCreateInfo.pNext = nullptr;
39 surfaceCreateInfo.flags = 0;
40 surfaceCreateInfo.connection = XGetXCBConnection(info.fDisplay);
41 surfaceCreateInfo.window = info.fWindow;
42
43 VkResult res = createXcbSurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
44 if (res != VK_SUCCESS) {
45 return VK_NULL_HANDLE;
46 }
47
48 return surface;
49 };
50
51 auto canPresent = [&info, instProc](VkInstance instance, VkPhysicalDevice physDev,
52 uint32_t queueFamilyIndex) {
53 static PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
54 getPhysicalDeviceXcbPresentationSupportKHR = nullptr;
55 if (!getPhysicalDeviceXcbPresentationSupportKHR) {
56 getPhysicalDeviceXcbPresentationSupportKHR =
57 (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)
58 instProc(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
59 }
60
61 Display* display = info.fDisplay;
62 VisualID visualID = XVisualIDFromVisual(DefaultVisual(info.fDisplay,
63 DefaultScreen(info.fDisplay)));
64 VkBool32 check = getPhysicalDeviceXcbPresentationSupportKHR(physDev,
65 queueFamilyIndex,
66 XGetXCBConnection(display),
67 visualID);
68 return (check != VK_FALSE);
69 };
70 std::unique_ptr<WindowContext> ctx(
71 new internal::GraphiteVulkanWindowContext(displayParams,
72 createVkSurface,
73 canPresent,
74 instProc));
75 if (!ctx->isValid()) {
76 return nullptr;
77 }
78 return ctx;
79}
info
static void info(const char *fmt,...) SK_PRINTF_LIKE(1
Definition DM.cpp:213
SkDebugf
void SK_SPI SkDebugf(const char format[],...) SK_PRINTF_LIKE(1
VkXcbSurfaceCreateInfoKHR::sType
VkStructureType sType
Definition vulkan_xcb.h:28
VkXcbSurfaceCreateInfoKHR::flags
VkXcbSurfaceCreateFlagsKHR flags
Definition vulkan_xcb.h:30
VkXcbSurfaceCreateInfoKHR::connection
xcb_connection_t * connection
Definition vulkan_xcb.h:31
VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR
@ VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR
Definition vulkan_core.h:430
PFN_vkCreateXcbSurfaceKHR
VkResult(VKAPI_PTR * PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition vulkan_xcb.h:35
PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id)
Definition vulkan_xcb.h:36

◆ MakeRasterForWin()

std::unique_ptr< WindowContext > skwindow::MakeRasterForWin ( HWND  wnd,
const DisplayParams &  params 
)
protected

Definition at line 87 of file RasterWindowContext_win.cpp.

87 {
88 std::unique_ptr<WindowContext> ctx(new RasterWindowContext_win(wnd, params));
89 if (!ctx->isValid()) {
90 ctx = nullptr;
91 }
92 return ctx;
93}

◆ MakeRasterForXlib()

std::unique_ptr< WindowContext > skwindow::MakeRasterForXlib ( const XlibWindowInfo &  info,
const DisplayParams &  params 
)
protected

Definition at line 90 of file RasterWindowContext_unix.cpp.

91 {
92 std::unique_ptr<WindowContext> ctx(new RasterWindowContext_xlib(
93 info.fDisplay, info.fWindow, info.fWidth, info.fHeight, params));
94 if (!ctx->isValid()) {
95 ctx = nullptr;
96 }
97 return ctx;
98}

◆ MakeVulkanForAndroid()

std::unique_ptr< WindowContext > skwindow::MakeVulkanForAndroid ( ANativeWindow *  window,
const DisplayParams &  params 
)

Definition at line 16 of file VulkanWindowContext_android.cpp.

17 {
18 PFN_vkGetInstanceProcAddr instProc;
19 if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc)) {
20 return nullptr;
21 }
22
23 auto createVkSurface = [window, instProc] (VkInstance instance) -> VkSurfaceKHR {
24 PFN_vkCreateAndroidSurfaceKHR createAndroidSurfaceKHR =
25 (PFN_vkCreateAndroidSurfaceKHR) instProc(instance, "vkCreateAndroidSurfaceKHR");
26
27 if (!window) {
28 return VK_NULL_HANDLE;
29 }
30 VkSurfaceKHR surface;
31
32 VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo;
33 memset(&surfaceCreateInfo, 0, sizeof(VkAndroidSurfaceCreateInfoKHR));
34 surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
35 surfaceCreateInfo.pNext = nullptr;
36 surfaceCreateInfo.flags = 0;
37 surfaceCreateInfo.window = window;
38
39 VkResult res = createAndroidSurfaceKHR(instance, &surfaceCreateInfo,
40 nullptr, &surface);
41 return (VK_SUCCESS == res) ? surface : VK_NULL_HANDLE;
42 };
43
44 auto canPresent = [](VkInstance, VkPhysicalDevice, uint32_t) { return true; };
45
46 std::unique_ptr<WindowContext> ctx(
47 new internal::VulkanWindowContext(params, createVkSurface, canPresent, instProc));
48 if (!ctx->isValid()) {
49 return nullptr;
50 }
51 return ctx;
52}

◆ MakeVulkanForWin()

std::unique_ptr< WindowContext > skwindow::MakeVulkanForWin ( HWND  hwnd,
const DisplayParams &  params 
)

Definition at line 22 of file VulkanWindowContext_win.cpp.

22 {
23 PFN_vkGetInstanceProcAddr instProc;
24 if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc)) {
25 return nullptr;
26 }
27
28 auto createVkSurface = [hwnd, instProc] (VkInstance instance) -> VkSurfaceKHR {
29 static PFN_vkCreateWin32SurfaceKHR createWin32SurfaceKHR = nullptr;
30 if (!createWin32SurfaceKHR) {
31 createWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR)
32 instProc(instance, "vkCreateWin32SurfaceKHR");
33 }
34 HINSTANCE hinstance = GetModuleHandle(0);
35 VkSurfaceKHR surface;
36
37 VkWin32SurfaceCreateInfoKHR surfaceCreateInfo;
38 memset(&surfaceCreateInfo, 0, sizeof(VkWin32SurfaceCreateInfoKHR));
39 surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
40 surfaceCreateInfo.pNext = nullptr;
41 surfaceCreateInfo.flags = 0;
42 surfaceCreateInfo.hinstance = hinstance;
43 surfaceCreateInfo.hwnd = hwnd;
44
45 VkResult res = createWin32SurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
46 if (VK_SUCCESS != res) {
47 return VK_NULL_HANDLE;
48 }
49
50 return surface;
51 };
52
53 auto canPresent = [instProc] (VkInstance instance, VkPhysicalDevice physDev,
54 uint32_t queueFamilyIndex) {
55 static PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR
56 getPhysicalDeviceWin32PresentationSupportKHR = nullptr;
57 if (!getPhysicalDeviceWin32PresentationSupportKHR) {
58 getPhysicalDeviceWin32PresentationSupportKHR =
59 (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)
60 instProc(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
61 }
62
63 VkBool32 check = getPhysicalDeviceWin32PresentationSupportKHR(physDev, queueFamilyIndex);
64 return (VK_FALSE != check);
65 };
66
67 std::unique_ptr<WindowContext> ctx(
68 new internal::VulkanWindowContext(params, createVkSurface, canPresent, instProc));
69 if (!ctx->isValid()) {
70 return nullptr;
71 }
72 return ctx;
73}

◆ MakeVulkanForXlib()

std::unique_ptr< WindowContext > skwindow::MakeVulkanForXlib ( const XlibWindowInfo &  info,
const DisplayParams &  displayParams 
)

Definition at line 19 of file VulkanWindowContext_unix.cpp.

20 {
21 PFN_vkGetInstanceProcAddr instProc;
22 if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc)) {
23 SkDebugf("Could not load vulkan library\n");
24 return nullptr;
25 }
26
27 auto createVkSurface = [&info, instProc](VkInstance instance) -> VkSurfaceKHR {
28 static PFN_vkCreateXcbSurfaceKHR createXcbSurfaceKHR = nullptr;
29 if (!createXcbSurfaceKHR) {
30 createXcbSurfaceKHR =
31 (PFN_vkCreateXcbSurfaceKHR) instProc(instance, "vkCreateXcbSurfaceKHR");
32 }
33
34 VkSurfaceKHR surface;
35
36 VkXcbSurfaceCreateInfoKHR surfaceCreateInfo;
37 memset(&surfaceCreateInfo, 0, sizeof(VkXcbSurfaceCreateInfoKHR));
38 surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
39 surfaceCreateInfo.pNext = nullptr;
40 surfaceCreateInfo.flags = 0;
41 surfaceCreateInfo.connection = XGetXCBConnection(info.fDisplay);
42 surfaceCreateInfo.window = info.fWindow;
43
44 VkResult res = createXcbSurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
45 if (VK_SUCCESS != res) {
46 return VK_NULL_HANDLE;
47 }
48
49 return surface;
50 };
51
52 auto canPresent = [&info, instProc](VkInstance instance, VkPhysicalDevice physDev,
53 uint32_t queueFamilyIndex) {
54 static PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
55 getPhysicalDeviceXcbPresentationSupportKHR = nullptr;
56 if (!getPhysicalDeviceXcbPresentationSupportKHR) {
57 getPhysicalDeviceXcbPresentationSupportKHR =
58 (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)
59 instProc(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
60 }
61
62 Display* display = info.fDisplay;
63 VisualID visualID = XVisualIDFromVisual(DefaultVisual(info.fDisplay,
64 DefaultScreen(info.fDisplay)));
65 VkBool32 check = getPhysicalDeviceXcbPresentationSupportKHR(physDev,
66 queueFamilyIndex,
67 XGetXCBConnection(display),
68 visualID);
69 return (VK_FALSE != check);
70 };
71 std::unique_ptr<WindowContext> ctx(
72 new internal::VulkanWindowContext(displayParams,
73 createVkSurface,
74 canPresent,
75 instProc));
76 if (!ctx->isValid()) {
77 return nullptr;
78 }
79 return ctx;
80}
Generated on Fri Apr 26 2024 06:22:32 for Flutter Engine by doxygen 1.9.8