ipc/common/vulkan_types_mojom_traits.h

// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file is auto-generated from
// gpu/ipc/common/generate_vulkan_types.py
// It's formatted by clang-format using chromium coding style:
//    clang-format -i -style=chromium filename
// DO NOT EDIT!

#ifndef GPU_IPC_COMMON_VULKAN_TYPES_MOJOM_TRAITS_H_
#define GPU_IPC_COMMON_VULKAN_TYPES_MOJOM_TRAITS_H_

#include "base/containers/span.h"
#include "base/strings/string_piece.h"
#include "gpu/ipc/common/vulkan_types.h"
#include "gpu/ipc/common/vulkan_types.mojom-shared.h"

namespace mojo {

template <>
struct StructTraits<gpu::mojom::VkExtensionPropertiesDataView,
                    VkExtensionProperties> {
  static base::StringPiece extensionName(const VkExtensionProperties& input) {
    return input.extensionName;
  }

  static uint32_t specVersion(const VkExtensionProperties& input) {
    return input.specVersion;
  }

  static bool Read(gpu::mojom::VkExtensionPropertiesDataView data,
                   VkExtensionProperties* out);
};

template <>
struct StructTraits<gpu::mojom::VkLayerPropertiesDataView, VkLayerProperties> {
  static base::StringPiece layerName(const VkLayerProperties& input) {
    return input.layerName;
  }

  static uint32_t specVersion(const VkLayerProperties& input) {
    return input.specVersion;
  }

  static uint32_t implementationVersion(const VkLayerProperties& input) {
    return input.implementationVersion;
  }

  static base::StringPiece description(const VkLayerProperties& input) {
    return input.description;
  }

  static bool Read(gpu::mojom::VkLayerPropertiesDataView data,
                   VkLayerProperties* out);
};

template <>
struct StructTraits<gpu::mojom::VkPhysicalDevicePropertiesDataView,
                    VkPhysicalDeviceProperties> {
  static uint32_t apiVersion(const VkPhysicalDeviceProperties& input) {
    return input.apiVersion;
  }

  static uint32_t driverVersion(const VkPhysicalDeviceProperties& input) {
    return input.driverVersion;
  }

  static uint32_t vendorID(const VkPhysicalDeviceProperties& input) {
    return input.vendorID;
  }

  static uint32_t deviceID(const VkPhysicalDeviceProperties& input) {
    return input.deviceID;
  }

  static VkPhysicalDeviceType deviceType(
      const VkPhysicalDeviceProperties& input) {
    return input.deviceType;
  }

  static base::StringPiece deviceName(const VkPhysicalDeviceProperties& input) {
    return input.deviceName;
  }

  static base::span<const uint8_t> pipelineCacheUUID(
      const VkPhysicalDeviceProperties& input) {
    return base::make_span(input.pipelineCacheUUID);
  }

  static const VkPhysicalDeviceLimits& limits(
      const VkPhysicalDeviceProperties& input) {
    return input.limits;
  }

  static const VkPhysicalDeviceSparseProperties& sparseProperties(
      const VkPhysicalDeviceProperties& input) {
    return input.sparseProperties;
  }

  static bool Read(gpu::mojom::VkPhysicalDevicePropertiesDataView data,
                   VkPhysicalDeviceProperties* out);
};

template <>
struct EnumTraits<gpu::mojom::VkPhysicalDeviceType, VkPhysicalDeviceType> {
  static gpu::mojom::VkPhysicalDeviceType ToMojom(VkPhysicalDeviceType input) {
    switch (input) {
      case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_OTHER:
        return gpu::mojom::VkPhysicalDeviceType::OTHER;
      case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
        return gpu::mojom::VkPhysicalDeviceType::INTEGRATED_GPU;
      case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
        return gpu::mojom::VkPhysicalDeviceType::DISCRETE_GPU;
      case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
        return gpu::mojom::VkPhysicalDeviceType::VIRTUAL_GPU;
      case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_CPU:
        return gpu::mojom::VkPhysicalDeviceType::CPU;
      default:
        NOTREACHED();
        return gpu::mojom::VkPhysicalDeviceType::INVALID_VALUE;
    }
  }

  static bool FromMojom(gpu::mojom::VkPhysicalDeviceType input,
                        VkPhysicalDeviceType* out) {
    switch (input) {
      case gpu::mojom::VkPhysicalDeviceType::OTHER:
        *out = VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_OTHER;
        return true;
      case gpu::mojom::VkPhysicalDeviceType::INTEGRATED_GPU:
        *out = VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
        return true;
      case gpu::mojom::VkPhysicalDeviceType::DISCRETE_GPU:
        *out = VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
        return true;
      case gpu::mojom::VkPhysicalDeviceType::VIRTUAL_GPU:
        *out = VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
        return true;
      case gpu::mojom::VkPhysicalDeviceType::CPU:
        *out = VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_CPU;
        return true;
      case gpu::mojom::VkPhysicalDeviceType::INVALID_VALUE:
        NOTREACHED();
        return false;
    }
    NOTREACHED();
    return false;
  }
};
template <>
struct StructTraits<gpu::mojom::VkPhysicalDeviceLimitsDataView,
                    VkPhysicalDeviceLimits> {
  static uint32_t maxImageDimension1D(const VkPhysicalDeviceLimits& input) {
    return input.maxImageDimension1D;
  }

  static uint32_t maxImageDimension2D(const VkPhysicalDeviceLimits& input) {
    return input.maxImageDimension2D;
  }

  static uint32_t maxImageDimension3D(const VkPhysicalDeviceLimits& input) {
    return input.maxImageDimension3D;
  }

  static uint32_t maxImageDimensionCube(const VkPhysicalDeviceLimits& input) {
    return input.maxImageDimensionCube;
  }

  static uint32_t maxImageArrayLayers(const VkPhysicalDeviceLimits& input) {
    return input.maxImageArrayLayers;
  }

  static uint32_t maxTexelBufferElements(const VkPhysicalDeviceLimits& input) {
    return input.maxTexelBufferElements;
  }

  static uint32_t maxUniformBufferRange(const VkPhysicalDeviceLimits& input) {
    return input.maxUniformBufferRange;
  }

  static uint32_t maxStorageBufferRange(const VkPhysicalDeviceLimits& input) {
    return input.maxStorageBufferRange;
  }

  static uint32_t maxPushConstantsSize(const VkPhysicalDeviceLimits& input) {
    return input.maxPushConstantsSize;
  }

  static uint32_t maxMemoryAllocationCount(
      const VkPhysicalDeviceLimits& input) {
    return input.maxMemoryAllocationCount;
  }

  static uint32_t maxSamplerAllocationCount(
      const VkPhysicalDeviceLimits& input) {
    return input.maxSamplerAllocationCount;
  }

  static bool bufferImageGranularity(const VkPhysicalDeviceLimits& input) {
    return input.bufferImageGranularity;
  }

  static bool sparseAddressSpaceSize(const VkPhysicalDeviceLimits& input) {
    return input.sparseAddressSpaceSize;
  }

  static uint32_t maxBoundDescriptorSets(const VkPhysicalDeviceLimits& input) {
    return input.maxBoundDescriptorSets;
  }

  static uint32_t maxPerStageDescriptorSamplers(
      const VkPhysicalDeviceLimits& input) {
    return input.maxPerStageDescriptorSamplers;
  }

  static uint32_t maxPerStageDescriptorUniformBuffers(
      const VkPhysicalDeviceLimits& input) {
    return input.maxPerStageDescriptorUniformBuffers;
  }

  static uint32_t maxPerStageDescriptorStorageBuffers(
      const VkPhysicalDeviceLimits& input) {
    return input.maxPerStageDescriptorStorageBuffers;
  }

  static uint32_t maxPerStageDescriptorSampledImages(
      const VkPhysicalDeviceLimits& input) {
    return input.maxPerStageDescriptorSampledImages;
  }

  static uint32_t maxPerStageDescriptorStorageImages(
      const VkPhysicalDeviceLimits& input) {
    return input.maxPerStageDescriptorStorageImages;
  }

  static uint32_t maxPerStageDescriptorInputAttachments(
      const VkPhysicalDeviceLimits& input) {
    return input.maxPerStageDescriptorInputAttachments;
  }

  static uint32_t maxPerStageResources(const VkPhysicalDeviceLimits& input) {
    return input.maxPerStageResources;
  }

  static uint32_t maxDescriptorSetSamplers(
      const VkPhysicalDeviceLimits& input) {
    return input.maxDescriptorSetSamplers;
  }

  static uint32_t maxDescriptorSetUniformBuffers(
      const VkPhysicalDeviceLimits& input) {
    return input.maxDescriptorSetUniformBuffers;
  }

  static uint32_t maxDescriptorSetUniformBuffersDynamic(
      const VkPhysicalDeviceLimits& input) {
    return input.maxDescriptorSetUniformBuffersDynamic;
  }

  static uint32_t maxDescriptorSetStorageBuffers(
      const VkPhysicalDeviceLimits& input) {
    return input.maxDescriptorSetStorageBuffers;
  }

  static uint32_t maxDescriptorSetStorageBuffersDynamic(
      const VkPhysicalDeviceLimits& input) {
    return input.maxDescriptorSetStorageBuffersDynamic;
  }

  static uint32_t maxDescriptorSetSampledImages(
      const VkPhysicalDeviceLimits& input) {
    return input.maxDescriptorSetSampledImages;
  }

  static uint32_t maxDescriptorSetStorageImages(
      const VkPhysicalDeviceLimits& input) {
    return input.maxDescriptorSetStorageImages;
  }

  static uint32_t maxDescriptorSetInputAttachments(
      const VkPhysicalDeviceLimits& input) {
    return input.maxDescriptorSetInputAttachments;
  }

  static uint32_t maxVertexInputAttributes(
      const VkPhysicalDeviceLimits& input) {
    return input.maxVertexInputAttributes;
  }

  static uint32_t maxVertexInputBindings(const VkPhysicalDeviceLimits& input) {
    return input.maxVertexInputBindings;
  }

  static uint32_t maxVertexInputAttributeOffset(
      const VkPhysicalDeviceLimits& input) {
    return input.maxVertexInputAttributeOffset;
  }

  static uint32_t maxVertexInputBindingStride(
      const VkPhysicalDeviceLimits& input) {
    return input.maxVertexInputBindingStride;
  }

  static uint32_t maxVertexOutputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxVertexOutputComponents;
  }

  static uint32_t maxTessellationGenerationLevel(
      const VkPhysicalDeviceLimits& input) {
    return input.maxTessellationGenerationLevel;
  }

  static uint32_t maxTessellationPatchSize(
      const VkPhysicalDeviceLimits& input) {
    return input.maxTessellationPatchSize;
  }

  static uint32_t maxTessellationControlPerVertexInputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxTessellationControlPerVertexInputComponents;
  }

  static uint32_t maxTessellationControlPerVertexOutputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxTessellationControlPerVertexOutputComponents;
  }

  static uint32_t maxTessellationControlPerPatchOutputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxTessellationControlPerPatchOutputComponents;
  }

  static uint32_t maxTessellationControlTotalOutputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxTessellationControlTotalOutputComponents;
  }

  static uint32_t maxTessellationEvaluationInputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxTessellationEvaluationInputComponents;
  }

  static uint32_t maxTessellationEvaluationOutputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxTessellationEvaluationOutputComponents;
  }

  static uint32_t maxGeometryShaderInvocations(
      const VkPhysicalDeviceLimits& input) {
    return input.maxGeometryShaderInvocations;
  }

  static uint32_t maxGeometryInputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxGeometryInputComponents;
  }

  static uint32_t maxGeometryOutputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxGeometryOutputComponents;
  }

  static uint32_t maxGeometryOutputVertices(
      const VkPhysicalDeviceLimits& input) {
    return input.maxGeometryOutputVertices;
  }

  static uint32_t maxGeometryTotalOutputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxGeometryTotalOutputComponents;
  }

  static uint32_t maxFragmentInputComponents(
      const VkPhysicalDeviceLimits& input) {
    return input.maxFragmentInputComponents;
  }

  static uint32_t maxFragmentOutputAttachments(
      const VkPhysicalDeviceLimits& input) {
    return input.maxFragmentOutputAttachments;
  }

  static uint32_t maxFragmentDualSrcAttachments(
      const VkPhysicalDeviceLimits& input) {
    return input.maxFragmentDualSrcAttachments;
  }

  static uint32_t maxFragmentCombinedOutputResources(
      const VkPhysicalDeviceLimits& input) {
    return input.maxFragmentCombinedOutputResources;
  }

  static uint32_t maxComputeSharedMemorySize(
      const VkPhysicalDeviceLimits& input) {
    return input.maxComputeSharedMemorySize;
  }

  static base::span<const uint32_t> maxComputeWorkGroupCount(
      const VkPhysicalDeviceLimits& input) {
    return base::make_span(input.maxComputeWorkGroupCount);
  }

  static uint32_t maxComputeWorkGroupInvocations(
      const VkPhysicalDeviceLimits& input) {
    return input.maxComputeWorkGroupInvocations;
  }

  static base::span<const uint32_t> maxComputeWorkGroupSize(
      const VkPhysicalDeviceLimits& input) {
    return base::make_span(input.maxComputeWorkGroupSize);
  }

  static uint32_t subPixelPrecisionBits(const VkPhysicalDeviceLimits& input) {
    return input.subPixelPrecisionBits;
  }

  static uint32_t subTexelPrecisionBits(const VkPhysicalDeviceLimits& input) {
    return input.subTexelPrecisionBits;
  }

  static uint32_t mipmapPrecisionBits(const VkPhysicalDeviceLimits& input) {
    return input.mipmapPrecisionBits;
  }

  static uint32_t maxDrawIndexedIndexValue(
      const VkPhysicalDeviceLimits& input) {
    return input.maxDrawIndexedIndexValue;
  }

  static uint32_t maxDrawIndirectCount(const VkPhysicalDeviceLimits& input) {
    return input.maxDrawIndirectCount;
  }

  static float maxSamplerLodBias(const VkPhysicalDeviceLimits& input) {
    return input.maxSamplerLodBias;
  }

  static float maxSamplerAnisotropy(const VkPhysicalDeviceLimits& input) {
    return input.maxSamplerAnisotropy;
  }

  static uint32_t maxViewports(const VkPhysicalDeviceLimits& input) {
    return input.maxViewports;
  }

  static base::span<const uint32_t> maxViewportDimensions(
      const VkPhysicalDeviceLimits& input) {
    return base::make_span(input.maxViewportDimensions);
  }

  static base::span<const float> viewportBoundsRange(
      const VkPhysicalDeviceLimits& input) {
    return base::make_span(input.viewportBoundsRange);
  }

  static uint32_t viewportSubPixelBits(const VkPhysicalDeviceLimits& input) {
    return input.viewportSubPixelBits;
  }

  static size_t minMemoryMapAlignment(const VkPhysicalDeviceLimits& input) {
    return input.minMemoryMapAlignment;
  }

  static bool minTexelBufferOffsetAlignment(
      const VkPhysicalDeviceLimits& input) {
    return input.minTexelBufferOffsetAlignment;
  }

  static bool minUniformBufferOffsetAlignment(
      const VkPhysicalDeviceLimits& input) {
    return input.minUniformBufferOffsetAlignment;
  }

  static bool minStorageBufferOffsetAlignment(
      const VkPhysicalDeviceLimits& input) {
    return input.minStorageBufferOffsetAlignment;
  }

  static int32_t minTexelOffset(const VkPhysicalDeviceLimits& input) {
    return input.minTexelOffset;
  }

  static uint32_t maxTexelOffset(const VkPhysicalDeviceLimits& input) {
    return input.maxTexelOffset;
  }

  static int32_t minTexelGatherOffset(const VkPhysicalDeviceLimits& input) {
    return input.minTexelGatherOffset;
  }

  static uint32_t maxTexelGatherOffset(const VkPhysicalDeviceLimits& input) {
    return input.maxTexelGatherOffset;
  }

  static float minInterpolationOffset(const VkPhysicalDeviceLimits& input) {
    return input.minInterpolationOffset;
  }

  static float maxInterpolationOffset(const VkPhysicalDeviceLimits& input) {
    return input.maxInterpolationOffset;
  }

  static uint32_t subPixelInterpolationOffsetBits(
      const VkPhysicalDeviceLimits& input) {
    return input.subPixelInterpolationOffsetBits;
  }

  static uint32_t maxFramebufferWidth(const VkPhysicalDeviceLimits& input) {
    return input.maxFramebufferWidth;
  }

  static uint32_t maxFramebufferHeight(const VkPhysicalDeviceLimits& input) {
    return input.maxFramebufferHeight;
  }

  static uint32_t maxFramebufferLayers(const VkPhysicalDeviceLimits& input) {
    return input.maxFramebufferLayers;
  }

  static VkSampleCountFlags framebufferColorSampleCounts(
      const VkPhysicalDeviceLimits& input) {
    return input.framebufferColorSampleCounts;
  }

  static VkSampleCountFlags framebufferDepthSampleCounts(
      const VkPhysicalDeviceLimits& input) {
    return input.framebufferDepthSampleCounts;
  }

  static VkSampleCountFlags framebufferStencilSampleCounts(
      const VkPhysicalDeviceLimits& input) {
    return input.framebufferStencilSampleCounts;
  }

  static VkSampleCountFlags framebufferNoAttachmentsSampleCounts(
      const VkPhysicalDeviceLimits& input) {
    return input.framebufferNoAttachmentsSampleCounts;
  }

  static uint32_t maxColorAttachments(const VkPhysicalDeviceLimits& input) {
    return input.maxColorAttachments;
  }

  static VkSampleCountFlags sampledImageColorSampleCounts(
      const VkPhysicalDeviceLimits& input) {
    return input.sampledImageColorSampleCounts;
  }

  static VkSampleCountFlags sampledImageIntegerSampleCounts(
      const VkPhysicalDeviceLimits& input) {
    return input.sampledImageIntegerSampleCounts;
  }

  static VkSampleCountFlags sampledImageDepthSampleCounts(
      const VkPhysicalDeviceLimits& input) {
    return input.sampledImageDepthSampleCounts;
  }

  static VkSampleCountFlags sampledImageStencilSampleCounts(
      const VkPhysicalDeviceLimits& input) {
    return input.sampledImageStencilSampleCounts;
  }

  static VkSampleCountFlags storageImageSampleCounts(
      const VkPhysicalDeviceLimits& input) {
    return input.storageImageSampleCounts;
  }

  static uint32_t maxSampleMaskWords(const VkPhysicalDeviceLimits& input) {
    return input.maxSampleMaskWords;
  }

  static bool timestampComputeAndGraphics(const VkPhysicalDeviceLimits& input) {
    return input.timestampComputeAndGraphics;
  }

  static float timestampPeriod(const VkPhysicalDeviceLimits& input) {
    return input.timestampPeriod;
  }

  static uint32_t maxClipDistances(const VkPhysicalDeviceLimits& input) {
    return input.maxClipDistances;
  }

  static uint32_t maxCullDistances(const VkPhysicalDeviceLimits& input) {
    return input.maxCullDistances;
  }

  static uint32_t maxCombinedClipAndCullDistances(
      const VkPhysicalDeviceLimits& input) {
    return input.maxCombinedClipAndCullDistances;
  }

  static uint32_t discreteQueuePriorities(const VkPhysicalDeviceLimits& input) {
    return input.discreteQueuePriorities;
  }

  static base::span<const float> pointSizeRange(
      const VkPhysicalDeviceLimits& input) {
    return base::make_span(input.pointSizeRange);
  }

  static base::span<const float> lineWidthRange(
      const VkPhysicalDeviceLimits& input) {
    return base::make_span(input.lineWidthRange);
  }

  static float pointSizeGranularity(const VkPhysicalDeviceLimits& input) {
    return input.pointSizeGranularity;
  }

  static float lineWidthGranularity(const VkPhysicalDeviceLimits& input) {
    return input.lineWidthGranularity;
  }

  static bool strictLines(const VkPhysicalDeviceLimits& input) {
    return input.strictLines;
  }

  static bool standardSampleLocations(const VkPhysicalDeviceLimits& input) {
    return input.standardSampleLocations;
  }

  static bool optimalBufferCopyOffsetAlignment(
      const VkPhysicalDeviceLimits& input) {
    return input.optimalBufferCopyOffsetAlignment;
  }

  static bool optimalBufferCopyRowPitchAlignment(
      const VkPhysicalDeviceLimits& input) {
    return input.optimalBufferCopyRowPitchAlignment;
  }

  static bool nonCoherentAtomSize(const VkPhysicalDeviceLimits& input) {
    return input.nonCoherentAtomSize;
  }

  static bool Read(gpu::mojom::VkPhysicalDeviceLimitsDataView data,
                   VkPhysicalDeviceLimits* out);
};

template <>
struct StructTraits<gpu::mojom::VkPhysicalDeviceSparsePropertiesDataView,
                    VkPhysicalDeviceSparseProperties> {
  static bool residencyStandard2DBlockShape(
      const VkPhysicalDeviceSparseProperties& input) {
    return input.residencyStandard2DBlockShape;
  }

  static bool residencyStandard2DMultisampleBlockShape(
      const VkPhysicalDeviceSparseProperties& input) {
    return input.residencyStandard2DMultisampleBlockShape;
  }

  static bool residencyStandard3DBlockShape(
      const VkPhysicalDeviceSparseProperties& input) {
    return input.residencyStandard3DBlockShape;
  }

  static bool residencyAlignedMipSize(
      const VkPhysicalDeviceSparseProperties& input) {
    return input.residencyAlignedMipSize;
  }

  static bool residencyNonResidentStrict(
      const VkPhysicalDeviceSparseProperties& input) {
    return input.residencyNonResidentStrict;
  }

  static bool Read(gpu::mojom::VkPhysicalDeviceSparsePropertiesDataView data,
                   VkPhysicalDeviceSparseProperties* out);
};

template <>
struct StructTraits<gpu::mojom::VkPhysicalDeviceFeaturesDataView,
                    VkPhysicalDeviceFeatures> {
  static bool robustBufferAccess(const VkPhysicalDeviceFeatures& input) {
    return input.robustBufferAccess;
  }

  static bool fullDrawIndexUint32(const VkPhysicalDeviceFeatures& input) {
    return input.fullDrawIndexUint32;
  }

  static bool imageCubeArray(const VkPhysicalDeviceFeatures& input) {
    return input.imageCubeArray;
  }

  static bool independentBlend(const VkPhysicalDeviceFeatures& input) {
    return input.independentBlend;
  }

  static bool geometryShader(const VkPhysicalDeviceFeatures& input) {
    return input.geometryShader;
  }

  static bool tessellationShader(const VkPhysicalDeviceFeatures& input) {
    return input.tessellationShader;
  }

  static bool sampleRateShading(const VkPhysicalDeviceFeatures& input) {
    return input.sampleRateShading;
  }

  static bool dualSrcBlend(const VkPhysicalDeviceFeatures& input) {
    return input.dualSrcBlend;
  }

  static bool logicOp(const VkPhysicalDeviceFeatures& input) {
    return input.logicOp;
  }

  static bool multiDrawIndirect(const VkPhysicalDeviceFeatures& input) {
    return input.multiDrawIndirect;
  }

  static bool drawIndirectFirstInstance(const VkPhysicalDeviceFeatures& input) {
    return input.drawIndirectFirstInstance;
  }

  static bool depthClamp(const VkPhysicalDeviceFeatures& input) {
    return input.depthClamp;
  }

  static bool depthBiasClamp(const VkPhysicalDeviceFeatures& input) {
    return input.depthBiasClamp;
  }

  static bool fillModeNonSolid(const VkPhysicalDeviceFeatures& input) {
    return input.fillModeNonSolid;
  }

  static bool depthBounds(const VkPhysicalDeviceFeatures& input) {
    return input.depthBounds;
  }

  static bool wideLines(const VkPhysicalDeviceFeatures& input) {
    return input.wideLines;
  }

  static bool largePoints(const VkPhysicalDeviceFeatures& input) {
    return input.largePoints;
  }

  static bool alphaToOne(const VkPhysicalDeviceFeatures& input) {
    return input.alphaToOne;
  }

  static bool multiViewport(const VkPhysicalDeviceFeatures& input) {
    return input.multiViewport;
  }

  static bool samplerAnisotropy(const VkPhysicalDeviceFeatures& input) {
    return input.samplerAnisotropy;
  }

  static bool textureCompressionETC2(const VkPhysicalDeviceFeatures& input) {
    return input.textureCompressionETC2;
  }

  static bool textureCompressionASTC_LDR(
      const VkPhysicalDeviceFeatures& input) {
    return input.textureCompressionASTC_LDR;
  }

  static bool textureCompressionBC(const VkPhysicalDeviceFeatures& input) {
    return input.textureCompressionBC;
  }

  static bool occlusionQueryPrecise(const VkPhysicalDeviceFeatures& input) {
    return input.occlusionQueryPrecise;
  }

  static bool pipelineStatisticsQuery(const VkPhysicalDeviceFeatures& input) {
    return input.pipelineStatisticsQuery;
  }

  static bool vertexPipelineStoresAndAtomics(
      const VkPhysicalDeviceFeatures& input) {
    return input.vertexPipelineStoresAndAtomics;
  }

  static bool fragmentStoresAndAtomics(const VkPhysicalDeviceFeatures& input) {
    return input.fragmentStoresAndAtomics;
  }

  static bool shaderTessellationAndGeometryPointSize(
      const VkPhysicalDeviceFeatures& input) {
    return input.shaderTessellationAndGeometryPointSize;
  }

  static bool shaderImageGatherExtended(const VkPhysicalDeviceFeatures& input) {
    return input.shaderImageGatherExtended;
  }

  static bool shaderStorageImageExtendedFormats(
      const VkPhysicalDeviceFeatures& input) {
    return input.shaderStorageImageExtendedFormats;
  }

  static bool shaderStorageImageMultisample(
      const VkPhysicalDeviceFeatures& input) {
    return input.shaderStorageImageMultisample;
  }

  static bool shaderStorageImageReadWithoutFormat(
      const VkPhysicalDeviceFeatures& input) {
    return input.shaderStorageImageReadWithoutFormat;
  }

  static bool shaderStorageImageWriteWithoutFormat(
      const VkPhysicalDeviceFeatures& input) {
    return input.shaderStorageImageWriteWithoutFormat;
  }

  static bool shaderUniformBufferArrayDynamicIndexing(
      const VkPhysicalDeviceFeatures& input) {
    return input.shaderUniformBufferArrayDynamicIndexing;
  }

  static bool shaderSampledImageArrayDynamicIndexing(
      const VkPhysicalDeviceFeatures& input) {
    return input.shaderSampledImageArrayDynamicIndexing;
  }

  static bool shaderStorageBufferArrayDynamicIndexing(
      const VkPhysicalDeviceFeatures& input) {
    return input.shaderStorageBufferArrayDynamicIndexing;
  }

  static bool shaderStorageImageArrayDynamicIndexing(
      const VkPhysicalDeviceFeatures& input) {
    return input.shaderStorageImageArrayDynamicIndexing;
  }

  static bool shaderClipDistance(const VkPhysicalDeviceFeatures& input) {
    return input.shaderClipDistance;
  }

  static bool shaderCullDistance(const VkPhysicalDeviceFeatures& input) {
    return input.shaderCullDistance;
  }

  static bool shaderFloat64(const VkPhysicalDeviceFeatures& input) {
    return input.shaderFloat64;
  }

  static bool shaderInt64(const VkPhysicalDeviceFeatures& input) {
    return input.shaderInt64;
  }

  static bool shaderInt16(const VkPhysicalDeviceFeatures& input) {
    return input.shaderInt16;
  }

  static bool shaderResourceResidency(const VkPhysicalDeviceFeatures& input) {
    return input.shaderResourceResidency;
  }

  static bool shaderResourceMinLod(const VkPhysicalDeviceFeatures& input) {
    return input.shaderResourceMinLod;
  }

  static bool sparseBinding(const VkPhysicalDeviceFeatures& input) {
    return input.sparseBinding;
  }

  static bool sparseResidencyBuffer(const VkPhysicalDeviceFeatures& input) {
    return input.sparseResidencyBuffer;
  }

  static bool sparseResidencyImage2D(const VkPhysicalDeviceFeatures& input) {
    return input.sparseResidencyImage2D;
  }

  static bool sparseResidencyImage3D(const VkPhysicalDeviceFeatures& input) {
    return input.sparseResidencyImage3D;
  }

  static bool sparseResidency2Samples(const VkPhysicalDeviceFeatures& input) {
    return input.sparseResidency2Samples;
  }

  static bool sparseResidency4Samples(const VkPhysicalDeviceFeatures& input) {
    return input.sparseResidency4Samples;
  }

  static bool sparseResidency8Samples(const VkPhysicalDeviceFeatures& input) {
    return input.sparseResidency8Samples;
  }

  static bool sparseResidency16Samples(const VkPhysicalDeviceFeatures& input) {
    return input.sparseResidency16Samples;
  }

  static bool sparseResidencyAliased(const VkPhysicalDeviceFeatures& input) {
    return input.sparseResidencyAliased;
  }

  static bool variableMultisampleRate(const VkPhysicalDeviceFeatures& input) {
    return input.variableMultisampleRate;
  }

  static bool inheritedQueries(const VkPhysicalDeviceFeatures& input) {
    return input.inheritedQueries;
  }

  static bool Read(gpu::mojom::VkPhysicalDeviceFeaturesDataView data,
                   VkPhysicalDeviceFeatures* out);
};

template <>
struct StructTraits<gpu::mojom::VkQueueFamilyPropertiesDataView,
                    VkQueueFamilyProperties> {
  static VkQueueFlags queueFlags(const VkQueueFamilyProperties& input) {
    return input.queueFlags;
  }

  static uint32_t queueCount(const VkQueueFamilyProperties& input) {
    return input.queueCount;
  }

  static uint32_t timestampValidBits(const VkQueueFamilyProperties& input) {
    return input.timestampValidBits;
  }

  static const VkExtent3D& minImageTransferGranularity(
      const VkQueueFamilyProperties& input) {
    return input.minImageTransferGranularity;
  }

  static bool Read(gpu::mojom::VkQueueFamilyPropertiesDataView data,
                   VkQueueFamilyProperties* out);
};

template <>
struct StructTraits<gpu::mojom::VkExtent3DDataView, VkExtent3D> {
  static uint32_t width(const VkExtent3D& input) { return input.width; }

  static uint32_t height(const VkExtent3D& input) { return input.height; }

  static uint32_t depth(const VkExtent3D& input) { return input.depth; }

  static bool Read(gpu::mojom::VkExtent3DDataView data, VkExtent3D* out);
};

}  // namespace mojo

#endif  // GPU_IPC_COMMON_VULKAN_TYPES_MOJOM_TRAITS_H_