VK_QCOM_image_processing.hs

{-# language CPP #-}
-- | = Name
--
-- VK_QCOM_image_processing - device extension
--
-- = VK_QCOM_image_processing
--
-- [__Name String__]
--     @VK_QCOM_image_processing@
--
-- [__Extension Type__]
--     Device extension
--
-- [__Registered Extension Number__]
--     441
--
-- [__Revision__]
--     1
--
-- [__Ratification Status__]
--     Not ratified
--
-- [__Extension and Version Dependencies__]
--     <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_format_feature_flags2 VK_KHR_format_feature_flags2>
--     or
--     <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#versions-1.3 Vulkan Version 1.3>
--
-- [__API Interactions__]
--
--     -   Interacts with VK_VERSION_1_3
--
--     -   Interacts with VK_KHR_format_feature_flags2
--
-- [__SPIR-V Dependencies__]
--
--     -   <https://htmlpreview.github.io/?https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/QCOM/SPV_QCOM_image_processing.html SPV_QCOM_image_processing>
--
-- [__Contact__]
--
--     -   Matthew Netsch
--         <https://github.com/KhronosGroup/Vulkan-Docs/issues/new?body=[VK_QCOM_image_processing] @mnetsch%0A*Here describe the issue or question you have about the VK_QCOM_image_processing extension* >
--
-- [__Extension Proposal__]
--     <https://github.com/KhronosGroup/Vulkan-Docs/tree/main/proposals/VK_QCOM_image_processing.adoc VK_QCOM_image_processing>
--
-- == Other Extension Metadata
--
-- [__Last Modified Date__]
--     2022-07-08
--
-- [__Interactions and External Dependencies__]
--
--     -   This extension provides API support for
--         <https://github.com/KhronosGroup/GLSL/blob/main/extensions/qcom/GLSL_QCOM_image_processing.txt GL_QCOM_image_processing>
--
-- [__Contributors__]
--
--     -   Jeff Leger, Qualcomm Technologies, Inc.
--
--     -   Ruihao Zhang, Qualcomm Technologies, Inc.
--
-- == Description
--
-- GPUs are commonly used to process images for various applications from
-- 3D graphics to UI and from composition to compute applications. Simple
-- scaling and filtering can be done with bilinear filtering, which comes
-- for free during texture sampling. However, as screen sizes get larger
-- and more use cases rely on GPU such as camera and video post-processing
-- needs, there is increasing demand for GPU to support higher order
-- filtering and other advanced image processing.
--
-- This extension introduces a new set of SPIR-V built-in functions for
-- image processing. It exposes the following new imaging operations
--
-- -   The @OpImageSampleWeightedQCOM@ instruction takes 3 operands:
--     /sampled image/, /weight image/, and texture coordinates. The
--     instruction computes a weighted average of an MxN region of texels
--     in the /sampled image/, using a set of MxN weights in the /weight
--     image/.
--
-- -   The @OpImageBoxFilterQCOM@ instruction takes 3 operands: /sampled
--     image/, /box size/, and texture coordinates. Note that /box size/
--     specifies a floating-point width and height in texels. The
--     instruction computes a weighted average of all texels in the
--     /sampled image/ that are covered (either partially or fully) by a
--     box with the specified size and centered at the specified texture
--     coordinates.
--
-- -   The @OpImageBlockMatchSADQCOM@ and @OpImageBlockMatchSSDQCOM@
--     instructions each takes 5 operands: /target image/, /target
--     coordinates/, /reference image/, /reference coordinates/, and /block
--     size/. Each instruction computes an error metric, that describes
--     whether a block of texels in the /target image/ matches a
--     corresponding block of texels in the /reference image/. The error
--     metric is computed per-component. @OpImageBlockMatchSADQCOM@
--     computes \"Sum Of Absolute Difference\" and
--     @OpImageBlockMatchSSDQCOM@ computes \"Sum of Squared Difference\".
--
-- Each of the image processing instructions operate only on 2D images. The
-- instructions do not-support sampling of mipmap, multi-plane,
-- multi-layer, multi-sampled, or depth\/stencil images. The instructions
-- can be used in any shader stage.
--
-- Implementations of this extension should support these operations
-- natively at the HW instruction level, offering potential performance
-- gains as well as ease of development.
--
-- == New Structures
--
-- -   Extending 'Vulkan.Core10.ImageView.ImageViewCreateInfo':
--
--     -   'ImageViewSampleWeightCreateInfoQCOM'
--
-- -   Extending
--     'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.PhysicalDeviceFeatures2',
--     'Vulkan.Core10.Device.DeviceCreateInfo':
--
--     -   'PhysicalDeviceImageProcessingFeaturesQCOM'
--
-- -   Extending
--     'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.PhysicalDeviceProperties2':
--
--     -   'PhysicalDeviceImageProcessingPropertiesQCOM'
--
-- == New Enum Constants
--
-- -   'QCOM_IMAGE_PROCESSING_EXTENSION_NAME'
--
-- -   'QCOM_IMAGE_PROCESSING_SPEC_VERSION'
--
-- -   Extending 'Vulkan.Core10.Enums.DescriptorType.DescriptorType':
--
--     -   'Vulkan.Core10.Enums.DescriptorType.DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM'
--
--     -   'Vulkan.Core10.Enums.DescriptorType.DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM'
--
-- -   Extending
--     'Vulkan.Core10.Enums.ImageUsageFlagBits.ImageUsageFlagBits':
--
--     -   'Vulkan.Core10.Enums.ImageUsageFlagBits.IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM'
--
--     -   'Vulkan.Core10.Enums.ImageUsageFlagBits.IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM'
--
-- -   Extending
--     'Vulkan.Core10.Enums.SamplerCreateFlagBits.SamplerCreateFlagBits':
--
--     -   'Vulkan.Core10.Enums.SamplerCreateFlagBits.SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM'
--
-- -   Extending 'Vulkan.Core10.Enums.StructureType.StructureType':
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM'
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM'
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM'
--
-- If
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_format_feature_flags2 VK_KHR_format_feature_flags2>
-- or
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#versions-1.3 Vulkan Version 1.3>
-- is supported:
--
-- -   Extending
--     'Vulkan.Core13.Enums.FormatFeatureFlags2.FormatFeatureFlagBits2':
--
--     -   'Vulkan.Core13.Enums.FormatFeatureFlags2.FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM'
--
--     -   'Vulkan.Core13.Enums.FormatFeatureFlags2.FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM'
--
--     -   'Vulkan.Core13.Enums.FormatFeatureFlags2.FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM'
--
--     -   'Vulkan.Core13.Enums.FormatFeatureFlags2.FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM'
--
-- == Version History
--
-- -   Revision 1, 2022-07-08 (Jeff Leger)
--
-- == See Also
--
-- No cross-references are available
--
-- == Document Notes
--
-- For more information, see the
-- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VK_QCOM_image_processing Vulkan Specification>
--
-- This page is a generated document. Fixes and changes should be made to
-- the generator scripts, not directly.
module Vulkan.Extensions.VK_QCOM_image_processing  ( ImageViewSampleWeightCreateInfoQCOM(..)
                                                   , PhysicalDeviceImageProcessingFeaturesQCOM(..)
                                                   , PhysicalDeviceImageProcessingPropertiesQCOM(..)
                                                   , QCOM_IMAGE_PROCESSING_SPEC_VERSION
                                                   , pattern QCOM_IMAGE_PROCESSING_SPEC_VERSION
                                                   , QCOM_IMAGE_PROCESSING_EXTENSION_NAME
                                                   , pattern QCOM_IMAGE_PROCESSING_EXTENSION_NAME
                                                   ) where

import Foreign.Marshal.Alloc (allocaBytes)
import Foreign.Ptr (nullPtr)
import Foreign.Ptr (plusPtr)
import Vulkan.CStruct (FromCStruct)
import Vulkan.CStruct (FromCStruct(..))
import Vulkan.CStruct (ToCStruct)
import Vulkan.CStruct (ToCStruct(..))
import Vulkan.Zero (Zero(..))
import Data.String (IsString)
import Data.Typeable (Typeable)
import Foreign.Storable (Storable)
import Foreign.Storable (Storable(peek))
import Foreign.Storable (Storable(poke))
import qualified Foreign.Storable (Storable(..))
import GHC.Generics (Generic)
import Foreign.Ptr (Ptr)
import Data.Word (Word32)
import Data.Kind (Type)
import Vulkan.Core10.FundamentalTypes (bool32ToBool)
import Vulkan.Core10.FundamentalTypes (boolToBool32)
import Vulkan.Core10.FundamentalTypes (Bool32)
import Vulkan.Core10.FundamentalTypes (Extent2D)
import Vulkan.Core10.FundamentalTypes (Offset2D)
import Vulkan.Core10.Enums.StructureType (StructureType)
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM))
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM))
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM))
-- | VkImageViewSampleWeightCreateInfoQCOM - Structure describing weight
-- sampling parameters for image view
--
-- = Description
--
-- The @filterCenter@ specifies the origin or center of the filter kernel,
-- as described in
-- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#textures-weightimage-filteroperation Weight Sampling Operation>.
-- The @numPhases@ describes the number of sub-pixel filter phases as
-- described in
-- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#textures-weightimage-filterphases Weight Sampling Phases>.
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_QCOM_image_processing VK_QCOM_image_processing>,
-- 'Vulkan.Core10.FundamentalTypes.Extent2D',
-- 'Vulkan.Core10.FundamentalTypes.Offset2D',
-- 'Vulkan.Core10.Enums.StructureType.StructureType'
data ImageViewSampleWeightCreateInfoQCOM = ImageViewSampleWeightCreateInfoQCOM
  { -- | @filterCenter@ is a 'Vulkan.Core10.FundamentalTypes.Offset2D' describing
    -- the location of the weight filter origin.
    filterCenter :: Offset2D
  , -- | @filterSize@ is a 'Vulkan.Core10.FundamentalTypes.Extent2D' specifying
    -- weight filter dimensions.
    filterSize :: Extent2D
  , -- | @numPhases@ is number of sub-pixel filter phases.
    --
    -- #VUID-VkImageViewSampleWeightCreateInfoQCOM-numPhases-06962# @numPhases@
    -- /must/ be a power of two squared value (i.e., 1, 4, 16, 64, 256, etc.)
    --
    -- #VUID-VkImageViewSampleWeightCreateInfoQCOM-numPhases-06963# @numPhases@
    -- /must/ be less than or equal to
    -- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#limits-weightfilter-phases ::maxWeightFilterPhases>
    numPhases :: Word32
  }
  deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (ImageViewSampleWeightCreateInfoQCOM)
#endif
deriving instance Show ImageViewSampleWeightCreateInfoQCOM

instance ToCStruct ImageViewSampleWeightCreateInfoQCOM where
  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
  pokeCStruct p ImageViewSampleWeightCreateInfoQCOM{..} f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr Offset2D)) (filterCenter)
    poke ((p `plusPtr` 24 :: Ptr Extent2D)) (filterSize)
    poke ((p `plusPtr` 32 :: Ptr Word32)) (numPhases)
    f
  cStructSize = 40
  cStructAlignment = 8
  pokeZeroCStruct p f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr Offset2D)) (zero)
    poke ((p `plusPtr` 24 :: Ptr Extent2D)) (zero)
    poke ((p `plusPtr` 32 :: Ptr Word32)) (zero)
    f

instance FromCStruct ImageViewSampleWeightCreateInfoQCOM where
  peekCStruct p = do
    filterCenter <- peekCStruct @Offset2D ((p `plusPtr` 16 :: Ptr Offset2D))
    filterSize <- peekCStruct @Extent2D ((p `plusPtr` 24 :: Ptr Extent2D))
    numPhases <- peek @Word32 ((p `plusPtr` 32 :: Ptr Word32))
    pure $ ImageViewSampleWeightCreateInfoQCOM
             filterCenter filterSize numPhases

instance Storable ImageViewSampleWeightCreateInfoQCOM where
  sizeOf ~_ = 40
  alignment ~_ = 8
  peek = peekCStruct
  poke ptr poked = pokeCStruct ptr poked (pure ())

instance Zero ImageViewSampleWeightCreateInfoQCOM where
  zero = ImageViewSampleWeightCreateInfoQCOM
           zero
           zero
           zero


-- | VkPhysicalDeviceImageProcessingFeaturesQCOM - Structure describing image
-- processing features that can be supported by an implementation
--
-- = Members
--
-- This structure describes the following features:
--
-- = Description
--
-- If the 'PhysicalDeviceImageProcessingFeaturesQCOM' structure is included
-- in the @pNext@ chain of the
-- 'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.PhysicalDeviceFeatures2'
-- structure passed to
-- 'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.getPhysicalDeviceFeatures2',
-- it is filled in to indicate whether each corresponding feature is
-- supported. 'PhysicalDeviceImageProcessingFeaturesQCOM' /can/ also be
-- used in the @pNext@ chain of 'Vulkan.Core10.Device.DeviceCreateInfo' to
-- selectively enable these features.
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_QCOM_image_processing VK_QCOM_image_processing>,
-- 'Vulkan.Core10.FundamentalTypes.Bool32',
-- 'Vulkan.Core10.Enums.StructureType.StructureType'
data PhysicalDeviceImageProcessingFeaturesQCOM = PhysicalDeviceImageProcessingFeaturesQCOM
  { -- | #features-textureSampleWeighted# @textureSampleWeighted@ indicates that
    -- the implementation supports shader modules that declare the
    -- @TextureSampleWeightedQCOM@ capability.
    textureSampleWeighted :: Bool
  , -- | #features-textureBoxFilter# @textureBoxFilter@ indicates that the
    -- implementation supports shader modules that declare the
    -- @TextureBoxFilterQCOM@ capability.
    textureBoxFilter :: Bool
  , -- | #features-textureBlockMatch# @textureBlockMatch@ indicates that the
    -- implementation supports shader modules that declare the
    -- @TextureBlockMatchQCOM@ capability.
    textureBlockMatch :: Bool
  }
  deriving (Typeable, Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (PhysicalDeviceImageProcessingFeaturesQCOM)
#endif
deriving instance Show PhysicalDeviceImageProcessingFeaturesQCOM

instance ToCStruct PhysicalDeviceImageProcessingFeaturesQCOM where
  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
  pokeCStruct p PhysicalDeviceImageProcessingFeaturesQCOM{..} f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr Bool32)) (boolToBool32 (textureSampleWeighted))
    poke ((p `plusPtr` 20 :: Ptr Bool32)) (boolToBool32 (textureBoxFilter))
    poke ((p `plusPtr` 24 :: Ptr Bool32)) (boolToBool32 (textureBlockMatch))
    f
  cStructSize = 32
  cStructAlignment = 8
  pokeZeroCStruct p f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr Bool32)) (boolToBool32 (zero))
    poke ((p `plusPtr` 20 :: Ptr Bool32)) (boolToBool32 (zero))
    poke ((p `plusPtr` 24 :: Ptr Bool32)) (boolToBool32 (zero))
    f

instance FromCStruct PhysicalDeviceImageProcessingFeaturesQCOM where
  peekCStruct p = do
    textureSampleWeighted <- peek @Bool32 ((p `plusPtr` 16 :: Ptr Bool32))
    textureBoxFilter <- peek @Bool32 ((p `plusPtr` 20 :: Ptr Bool32))
    textureBlockMatch <- peek @Bool32 ((p `plusPtr` 24 :: Ptr Bool32))
    pure $ PhysicalDeviceImageProcessingFeaturesQCOM
             (bool32ToBool textureSampleWeighted)
             (bool32ToBool textureBoxFilter)
             (bool32ToBool textureBlockMatch)

instance Storable PhysicalDeviceImageProcessingFeaturesQCOM where
  sizeOf ~_ = 32
  alignment ~_ = 8
  peek = peekCStruct
  poke ptr poked = pokeCStruct ptr poked (pure ())

instance Zero PhysicalDeviceImageProcessingFeaturesQCOM where
  zero = PhysicalDeviceImageProcessingFeaturesQCOM
           zero
           zero
           zero


-- | VkPhysicalDeviceImageProcessingPropertiesQCOM - Structure containing
-- image processing properties
--
-- = Description
--
-- If the 'PhysicalDeviceImageProcessingPropertiesQCOM' structure is
-- included in the @pNext@ chain of the
-- 'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.PhysicalDeviceProperties2'
-- structure passed to
-- 'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.getPhysicalDeviceProperties2',
-- it is filled in with each corresponding implementation-dependent
-- property.
--
-- These are properties of the image processing information of a physical
-- device.
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_QCOM_image_processing VK_QCOM_image_processing>,
-- 'Vulkan.Core10.FundamentalTypes.Extent2D',
-- 'Vulkan.Core10.Enums.StructureType.StructureType'
data PhysicalDeviceImageProcessingPropertiesQCOM = PhysicalDeviceImageProcessingPropertiesQCOM
  { -- | #limits-weightfilter-phases# @maxWeightFilterPhases@ is the maximum
    -- value that /can/ be specified for
    -- 'ImageViewSampleWeightCreateInfoQCOM'::@numPhases@ in
    -- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#textures-weightimage-filterphases weight image sampling>
    -- operations.
    maxWeightFilterPhases :: Word32
  , -- | #limits-weightfilter-maxdimension# @maxWeightFilterDimension@ is a
    -- 'Vulkan.Core10.FundamentalTypes.Extent2D' describing the largest
    -- dimensions (@width@ and @height@) that /can/ be specified for
    -- 'ImageViewSampleWeightCreateInfoQCOM'::@filterSize@.
    maxWeightFilterDimension :: Extent2D
  , -- | #limits-blockmatch-maxblocksize# @maxBlockMatchRegion@ is a
    -- 'Vulkan.Core10.FundamentalTypes.Extent2D' describing the largest
    -- dimensions (@width@ and @height@) that /can/ be specified for
    -- @blockSize@ in
    -- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#textures-blockmatch block matching>
    -- operations.
    maxBlockMatchRegion :: Extent2D
  , -- | #limits-boxfilter-maxblocksize# @maxBoxFilterBlockSize@ is a
    -- 'Vulkan.Core10.FundamentalTypes.Extent2D' describing the maximum
    -- dimensions (@width@ and @height@) that /can/ be specified for
    -- @blocksize@ in
    -- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#textures-boxfilter box filter sampling>
    -- operations.
    maxBoxFilterBlockSize :: Extent2D
  }
  deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (PhysicalDeviceImageProcessingPropertiesQCOM)
#endif
deriving instance Show PhysicalDeviceImageProcessingPropertiesQCOM

instance ToCStruct PhysicalDeviceImageProcessingPropertiesQCOM where
  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
  pokeCStruct p PhysicalDeviceImageProcessingPropertiesQCOM{..} f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    poke ((p `plusPtr` 16 :: Ptr Word32)) (maxWeightFilterPhases)
    poke ((p `plusPtr` 20 :: Ptr Extent2D)) (maxWeightFilterDimension)
    poke ((p `plusPtr` 28 :: Ptr Extent2D)) (maxBlockMatchRegion)
    poke ((p `plusPtr` 36 :: Ptr Extent2D)) (maxBoxFilterBlockSize)
    f
  cStructSize = 48
  cStructAlignment = 8
  pokeZeroCStruct p f = do
    poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM)
    poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
    f

instance FromCStruct PhysicalDeviceImageProcessingPropertiesQCOM where
  peekCStruct p = do
    maxWeightFilterPhases <- peek @Word32 ((p `plusPtr` 16 :: Ptr Word32))
    maxWeightFilterDimension <- peekCStruct @Extent2D ((p `plusPtr` 20 :: Ptr Extent2D))
    maxBlockMatchRegion <- peekCStruct @Extent2D ((p `plusPtr` 28 :: Ptr Extent2D))
    maxBoxFilterBlockSize <- peekCStruct @Extent2D ((p `plusPtr` 36 :: Ptr Extent2D))
    pure $ PhysicalDeviceImageProcessingPropertiesQCOM
             maxWeightFilterPhases
             maxWeightFilterDimension
             maxBlockMatchRegion
             maxBoxFilterBlockSize

instance Storable PhysicalDeviceImageProcessingPropertiesQCOM where
  sizeOf ~_ = 48
  alignment ~_ = 8
  peek = peekCStruct
  poke ptr poked = pokeCStruct ptr poked (pure ())

instance Zero PhysicalDeviceImageProcessingPropertiesQCOM where
  zero = PhysicalDeviceImageProcessingPropertiesQCOM
           zero
           zero
           zero
           zero


type QCOM_IMAGE_PROCESSING_SPEC_VERSION = 1

-- No documentation found for TopLevel "VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION"
pattern QCOM_IMAGE_PROCESSING_SPEC_VERSION :: forall a . Integral a => a
pattern QCOM_IMAGE_PROCESSING_SPEC_VERSION = 1


type QCOM_IMAGE_PROCESSING_EXTENSION_NAME = "VK_QCOM_image_processing"

-- No documentation found for TopLevel "VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME"
pattern QCOM_IMAGE_PROCESSING_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
pattern QCOM_IMAGE_PROCESSING_EXTENSION_NAME = "VK_QCOM_image_processing"