}
template <typename Visitor>
-inline bool Iterate(Visitor* visitor, VkJsonAllProperties* properties) {
- return
- visitor->Visit("properties", &properties->properties) &&
- visitor->Visit("features", &properties->features) &&
- visitor->Visit("memory", &properties->memory) &&
- visitor->Visit("queues", &properties->queues) &&
- visitor->Visit("extensions", &properties->extensions) &&
- visitor->Visit("layers", &properties->layers) &&
- visitor->Visit("formats", &properties->formats);
+inline bool Iterate(Visitor* visitor, VkJsonDevice* device) {
+ return visitor->Visit("properties", &device->properties) &&
+ visitor->Visit("features", &device->features) &&
+ visitor->Visit("memory", &device->memory) &&
+ visitor->Visit("queues", &device->queues) &&
+ visitor->Visit("extensions", &device->extensions) &&
+ visitor->Visit("layers", &device->layers) &&
+ visitor->Visit("formats", &device->formats);
}
} // anonymous namespace
-std::string VkJsonAllPropertiesToJson(
- const VkJsonAllProperties& properties) {
- return VkTypeToJson(properties);
+std::string VkJsonDeviceToJson(const VkJsonDevice& device) {
+ return VkTypeToJson(device);
}
-bool VkJsonAllPropertiesFromJson(
- const std::string& json, VkJsonAllProperties* properties,
- std::string* errors) {
- return VkTypeFromJson(json, properties, errors);
+bool VkJsonDeviceFromJson(const std::string& json,
+ VkJsonDevice* device,
+ std::string* errors) {
+ return VkTypeFromJson(json, device, errors);
};
std::string VkJsonImageFormatPropertiesToJson(
#undef max
#endif
-struct VkJsonAllProperties {
- VkJsonAllProperties() {
+struct VkJsonDevice {
+ VkJsonDevice() {
memset(&properties, 0, sizeof(VkPhysicalDeviceProperties));
memset(&features, 0, sizeof(VkPhysicalDeviceFeatures));
memset(&memory, 0, sizeof(VkPhysicalDeviceMemoryProperties));
std::map<VkFormat, VkFormatProperties> formats;
};
-VkJsonAllProperties VkJsonGetAllProperties(VkPhysicalDevice physicalDevice);
-
-std::string VkJsonAllPropertiesToJson(
- const VkJsonAllProperties& properties);
-bool VkJsonAllPropertiesFromJson(
- const std::string& json, VkJsonAllProperties* properties,
- std::string* errors);
+VkJsonDevice VkJsonGetDevice(VkPhysicalDevice device);
+std::string VkJsonDeviceToJson(const VkJsonDevice& device);
+bool VkJsonDeviceFromJson(const std::string& json,
+ VkJsonDevice* device,
+ std::string* errors);
std::string VkJsonImageFormatPropertiesToJson(
const VkImageFormatProperties& properties);
VkImageFormatProperties* properties,
std::string* errors);
+// Backward-compatibility aliases
+typedef VkJsonDevice VkJsonAllProperties;
+inline VkJsonAllProperties VkJsonGetAllProperties(
+ VkPhysicalDevice physicalDevice) {
+ return VkJsonGetDevice(physicalDevice);
+}
+inline std::string VkJsonAllPropertiesToJson(
+ const VkJsonAllProperties& properties) {
+ return VkJsonDeviceToJson(properties);
+}
+inline bool VkJsonAllPropertiesFromJson(const std::string& json,
+ VkJsonAllProperties* properties,
+ std::string* errors) {
+ return VkJsonDeviceFromJson(json, properties, errors);
+}
+
#endif // VKJSON_H_
#include <utility>
-VkJsonAllProperties VkJsonGetAllProperties(VkPhysicalDevice physical_device) {
- VkJsonAllProperties properties;
- vkGetPhysicalDeviceProperties(physical_device, &properties.properties);
- vkGetPhysicalDeviceFeatures(physical_device, &properties.features);
- vkGetPhysicalDeviceMemoryProperties(physical_device, &properties.memory);
+VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) {
+ VkJsonDevice device;
+ vkGetPhysicalDeviceProperties(physical_device, &device.properties);
+ vkGetPhysicalDeviceFeatures(physical_device, &device.features);
+ vkGetPhysicalDeviceMemoryProperties(physical_device, &device.memory);
uint32_t queue_family_count = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count,
nullptr);
if (queue_family_count > 0) {
- properties.queues.resize(queue_family_count);
+ device.queues.resize(queue_family_count);
vkGetPhysicalDeviceQueueFamilyProperties(
- physical_device, &queue_family_count, properties.queues.data());
+ physical_device, &queue_family_count, device.queues.data());
}
// Only device extensions.
vkEnumerateDeviceExtensionProperties(physical_device, nullptr,
&extension_count, nullptr);
if (extension_count > 0) {
- properties.extensions.resize(extension_count);
- vkEnumerateDeviceExtensionProperties(physical_device, nullptr,
- &extension_count,
- properties.extensions.data());
+ device.extensions.resize(extension_count);
+ vkEnumerateDeviceExtensionProperties(
+ physical_device, nullptr, &extension_count, device.extensions.data());
}
uint32_t layer_count = 0;
vkEnumerateDeviceLayerProperties(physical_device, &layer_count, nullptr);
if (layer_count > 0) {
- properties.layers.resize(layer_count);
+ device.layers.resize(layer_count);
vkEnumerateDeviceLayerProperties(physical_device, &layer_count,
- properties.layers.data());
+ device.layers.data());
}
VkFormatProperties format_properties = {};
if (format_properties.linearTilingFeatures ||
format_properties.optimalTilingFeatures ||
format_properties.bufferFeatures) {
- properties.formats.insert(std::make_pair(format, format_properties));
+ device.formats.insert(std::make_pair(format, format_properties));
}
}
- return properties;
+ return device;
}
return true;
}
-bool DumpProperties(const VkJsonAllProperties& props, const Options& options) {
- std::string device_name(props.properties.deviceName);
+bool DumpProperties(const VkJsonDevice& device, const Options& options) {
+ std::string device_name(device.properties.deviceName);
std::string output_file = options.output_file;
if (output_file.empty())
output_file = device_name + ".json";
}
}
- std::string json = VkJsonAllPropertiesToJson(props) + '\n';
+ std::string json = VkJsonDeviceToJson(device) + '\n';
fwrite(json.data(), 1, json.size(), file);
if (output_file != "-") {
<< std::endl;
return 1;
}
- auto props = VkJsonGetAllProperties(physical_devices[options.device_index]);
- if (!DumpProperties(props, options))
+ auto device = VkJsonGetDevice(physical_devices[options.device_index]);
+ if (!DumpProperties(device, options))
return 1;
return 0;
}
bool found = false;
for (auto physical_device : physical_devices) {
- auto props = VkJsonGetAllProperties(physical_device);
+ auto device = VkJsonGetDevice(physical_device);
if (!options.device_name.empty() &&
- options.device_name != props.properties.deviceName)
+ options.device_name != device.properties.deviceName)
continue;
- if (!DumpProperties(props, options))
+ if (!DumpProperties(device, options))
return 1;
found = true;
}
bool result = false;
const char name[] = "Test device";
- VkJsonAllProperties device_props;
- memcpy(device_props.properties.deviceName, name, sizeof(name));
- device_props.properties.limits.maxImageDimension1D = 3;
- device_props.properties.limits.maxSamplerLodBias = 3.5f;
- device_props.properties.limits.bufferImageGranularity = 0x1ffffffffull;
- device_props.properties.limits.maxViewportDimensions[0] = 1;
- device_props.properties.limits.maxViewportDimensions[1] = 2;
+ VkJsonDevice device;
+ memcpy(device.properties.deviceName, name, sizeof(name));
+ device.properties.limits.maxImageDimension1D = 3;
+ device.properties.limits.maxSamplerLodBias = 3.5f;
+ device.properties.limits.bufferImageGranularity = 0x1ffffffffull;
+ device.properties.limits.maxViewportDimensions[0] = 1;
+ device.properties.limits.maxViewportDimensions[1] = 2;
VkFormatProperties format_props = {
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT};
- device_props.formats.insert(
- std::make_pair(VK_FORMAT_R8_UNORM, format_props));
- device_props.formats.insert(
- std::make_pair(VK_FORMAT_R8G8_UNORM, format_props));
- std::string json = VkJsonAllPropertiesToJson(device_props);
+ device.formats.insert(std::make_pair(VK_FORMAT_R8_UNORM, format_props));
+ device.formats.insert(std::make_pair(VK_FORMAT_R8G8_UNORM, format_props));
+ std::string json = VkJsonDeviceToJson(device);
std::cout << json << std::endl;
- VkJsonAllProperties device_props2;
- result = VkJsonAllPropertiesFromJson(json, &device_props2, &errors);
+ VkJsonDevice device2;
+ result = VkJsonDeviceFromJson(json, &device2, &errors);
EXPECT(result);
if (!result)
std::cout << "Error: " << errors << std::endl;
- EXPECT(!memcmp(&device_props.properties,
- &device_props2.properties,
- sizeof(device_props.properties)));
- for (auto& kv : device_props.formats) {
- auto it = device_props2.formats.find(kv.first);
- EXPECT(it != device_props2.formats.end());
+ EXPECT(!memcmp(&device.properties, &device2.properties,
+ sizeof(device.properties)));
+ for (auto& kv : device.formats) {
+ auto it = device2.formats.find(kv.first);
+ EXPECT(it != device2.formats.end());
EXPECT(!memcmp(&kv.second, &it->second, sizeof(kv.second)));
}