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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef GPU_IPC_COMMON_VULKAN_INFO_MOJOM_TRAITS_H_
#define GPU_IPC_COMMON_VULKAN_INFO_MOJOM_TRAITS_H_
#include <string_view>
#include "gpu/config/vulkan_info.h"
#include "gpu/ipc/common/vulkan_info.mojom-shared.h"
#include "gpu/ipc/common/vulkan_types_mojom_traits.h"
namespace mojo {
template <>
struct StructTraits<gpu::mojom::VulkanPhysicalDeviceInfoDataView,
gpu::VulkanPhysicalDeviceInfo> {
static const VkPhysicalDeviceProperties& properties(
const gpu::VulkanPhysicalDeviceInfo& input) {
return input.properties;
}
static const std::vector<VkExtensionProperties>& extensions(
const gpu::VulkanPhysicalDeviceInfo& input) {
return input.extensions;
}
static const VkPhysicalDeviceFeatures& features(
const gpu::VulkanPhysicalDeviceInfo& input) {
return input.features;
}
static bool feature_sampler_ycbcr_conversion(
const gpu::VulkanPhysicalDeviceInfo& input) {
return input.feature_sampler_ycbcr_conversion;
}
static bool feature_protected_memory(
const gpu::VulkanPhysicalDeviceInfo& input) {
return input.feature_protected_memory;
}
static const std::vector<VkQueueFamilyProperties>& queue_families(
const gpu::VulkanPhysicalDeviceInfo& input) {
return input.queue_families;
}
static bool Read(gpu::mojom::VulkanPhysicalDeviceInfoDataView data,
gpu::VulkanPhysicalDeviceInfo* out) {
if (!data.ReadProperties(&out->properties))
return false;
if (!data.ReadExtensions(&out->extensions))
return false;
if (!data.ReadFeatures(&out->features))
return false;
out->feature_sampler_ycbcr_conversion =
data.feature_sampler_ycbcr_conversion();
out->feature_protected_memory = data.feature_protected_memory();
if (!data.ReadQueueFamilies(&out->queue_families))
return false;
return true;
}
};
template <>
struct StructTraits<gpu::mojom::VulkanInfoDataView, gpu::VulkanInfo> {
static uint32_t api_version(const gpu::VulkanInfo& input) {
return input.api_version;
}
static uint32_t used_api_version(const gpu::VulkanInfo& input) {
return input.used_api_version;
}
static const std::vector<VkExtensionProperties>& instance_extensions(
const gpu::VulkanInfo& input) {
return input.instance_extensions;
}
static std::vector<std::string_view> enabled_instance_extensions(
const gpu::VulkanInfo& input) {
std::vector<std::string_view> extensions;
extensions.reserve(input.enabled_instance_extensions.size());
for (const char* extension : input.enabled_instance_extensions)
extensions.emplace_back(extension);
return extensions;
}
static const std::vector<VkLayerProperties>& instance_layers(
const gpu::VulkanInfo& input) {
return input.instance_layers;
}
static const std::vector<gpu::VulkanPhysicalDeviceInfo>& physical_devices(
const gpu::VulkanInfo& input) {
return input.physical_devices;
}
static bool Read(gpu::mojom::VulkanInfoDataView data, gpu::VulkanInfo* out) {
out->api_version = data.api_version();
out->used_api_version = data.used_api_version();
if (!data.ReadInstanceExtensions(&out->instance_extensions))
return false;
std::vector<std::string_view> extensions;
if (!data.ReadEnabledInstanceExtensions(&extensions))
return false;
out->SetEnabledInstanceExtensions(extensions);
return data.ReadInstanceLayers(&out->instance_layers) &&
data.ReadPhysicalDevices(&out->physical_devices);
}
};
} // namespace mojo
#endif // GPU_IPC_COMMON_VULKAN_INFO_MOJOM_TRAITS_H_
|
