-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Cogl.Enums
    ( 

 -- * Enumerations


-- ** AttributeType #enum:AttributeType#

    AttributeType(..)                       ,


-- ** BitmapError #enum:BitmapError#

    BitmapError(..)                         ,


-- ** BlendStringError #enum:BlendStringError#

    BlendStringError(..)                    ,


-- ** DepthTestFunction #enum:DepthTestFunction#

    DepthTestFunction(..)                   ,


-- ** FilterReturn #enum:FilterReturn#

    FilterReturn(..)                        ,


-- ** FogMode #enum:FogMode#

    FogMode(..)                             ,


-- ** IndicesType #enum:IndicesType#

    IndicesType(..)                         ,


-- ** MaterialAlphaFunc #enum:MaterialAlphaFunc#

    MaterialAlphaFunc(..)                   ,


-- ** MaterialFilter #enum:MaterialFilter#

    MaterialFilter(..)                      ,


-- ** MaterialLayerType #enum:MaterialLayerType#

    MaterialLayerType(..)                   ,


-- ** MaterialWrapMode #enum:MaterialWrapMode#

    MaterialWrapMode(..)                    ,


-- ** PixelFormat #enum:PixelFormat#

    PixelFormat(..)                         ,


-- ** RendererError #enum:RendererError#

    RendererError(..)                       ,


-- ** ShaderType #enum:ShaderType#

    ShaderType(..)                          ,


-- ** StereoMode #enum:StereoMode#

    StereoMode(..)                          ,


-- ** SystemError #enum:SystemError#

    SystemError(..)                         ,


-- ** TextureComponents #enum:TextureComponents#

    TextureComponents(..)                   ,


-- ** TextureError #enum:TextureError#

    TextureError(..)                        ,


-- ** TextureType #enum:TextureType#

    TextureType(..)                         ,


-- ** VerticesMode #enum:VerticesMode#

    VerticesMode(..)                        ,


-- ** Winding #enum:Winding#

    Winding(..)                             ,


-- ** WinsysFeature #enum:WinsysFeature#

    WinsysFeature(..)                       ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- Enum WinsysFeature
-- | /No description available in the introspection data./
data WinsysFeature = 
      WinsysFeatureMultipleOnscreen
    -- ^ /No description available in the introspection data./
    | WinsysFeatureSwapThrottle
    -- ^ /No description available in the introspection data./
    | WinsysFeatureVblankCounter
    -- ^ /No description available in the introspection data./
    | WinsysFeatureVblankWait
    -- ^ /No description available in the introspection data./
    | WinsysFeatureTextureFromPixmap
    -- ^ /No description available in the introspection data./
    | WinsysFeatureSwapBuffersEvent
    -- ^ /No description available in the introspection data./
    | WinsysFeatureSwapRegion
    -- ^ /No description available in the introspection data./
    | WinsysFeatureSwapRegionThrottle
    -- ^ /No description available in the introspection data./
    | WinsysFeatureSwapRegionSynchronized
    -- ^ /No description available in the introspection data./
    | WinsysFeatureBufferAge
    -- ^ /No description available in the introspection data./
    | WinsysFeatureSyncAndCompleteEvent
    -- ^ /No description available in the introspection data./
    | WinsysFeatureNFeatures
    -- ^ /No description available in the introspection data./
    | AnotherWinsysFeature Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WinsysFeature -> ShowS
[WinsysFeature] -> ShowS
WinsysFeature -> String
(Int -> WinsysFeature -> ShowS)
-> (WinsysFeature -> String)
-> ([WinsysFeature] -> ShowS)
-> Show WinsysFeature
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WinsysFeature -> ShowS
showsPrec :: Int -> WinsysFeature -> ShowS
$cshow :: WinsysFeature -> String
show :: WinsysFeature -> String
$cshowList :: [WinsysFeature] -> ShowS
showList :: [WinsysFeature] -> ShowS
Show, WinsysFeature -> WinsysFeature -> Bool
(WinsysFeature -> WinsysFeature -> Bool)
-> (WinsysFeature -> WinsysFeature -> Bool) -> Eq WinsysFeature
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WinsysFeature -> WinsysFeature -> Bool
== :: WinsysFeature -> WinsysFeature -> Bool
$c/= :: WinsysFeature -> WinsysFeature -> Bool
/= :: WinsysFeature -> WinsysFeature -> Bool
Eq)

instance P.Enum WinsysFeature where
    fromEnum :: WinsysFeature -> Int
fromEnum WinsysFeature
WinsysFeatureMultipleOnscreen = Int
0
    fromEnum WinsysFeature
WinsysFeatureSwapThrottle = Int
1
    fromEnum WinsysFeature
WinsysFeatureVblankCounter = Int
2
    fromEnum WinsysFeature
WinsysFeatureVblankWait = Int
3
    fromEnum WinsysFeature
WinsysFeatureTextureFromPixmap = Int
4
    fromEnum WinsysFeature
WinsysFeatureSwapBuffersEvent = Int
5
    fromEnum WinsysFeature
WinsysFeatureSwapRegion = Int
6
    fromEnum WinsysFeature
WinsysFeatureSwapRegionThrottle = Int
7
    fromEnum WinsysFeature
WinsysFeatureSwapRegionSynchronized = Int
8
    fromEnum WinsysFeature
WinsysFeatureBufferAge = Int
9
    fromEnum WinsysFeature
WinsysFeatureSyncAndCompleteEvent = Int
10
    fromEnum WinsysFeature
WinsysFeatureNFeatures = Int
11
    fromEnum (AnotherWinsysFeature Int
k) = Int
k

    toEnum :: Int -> WinsysFeature
toEnum Int
0 = WinsysFeature
WinsysFeatureMultipleOnscreen
    toEnum Int
1 = WinsysFeature
WinsysFeatureSwapThrottle
    toEnum Int
2 = WinsysFeature
WinsysFeatureVblankCounter
    toEnum Int
3 = WinsysFeature
WinsysFeatureVblankWait
    toEnum Int
4 = WinsysFeature
WinsysFeatureTextureFromPixmap
    toEnum Int
5 = WinsysFeature
WinsysFeatureSwapBuffersEvent
    toEnum Int
6 = WinsysFeature
WinsysFeatureSwapRegion
    toEnum Int
7 = WinsysFeature
WinsysFeatureSwapRegionThrottle
    toEnum Int
8 = WinsysFeature
WinsysFeatureSwapRegionSynchronized
    toEnum Int
9 = WinsysFeature
WinsysFeatureBufferAge
    toEnum Int
10 = WinsysFeature
WinsysFeatureSyncAndCompleteEvent
    toEnum Int
11 = WinsysFeature
WinsysFeatureNFeatures
    toEnum Int
k = Int -> WinsysFeature
AnotherWinsysFeature Int
k

instance P.Ord WinsysFeature where
    compare :: WinsysFeature -> WinsysFeature -> Ordering
compare WinsysFeature
a WinsysFeature
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WinsysFeature -> Int
forall a. Enum a => a -> Int
P.fromEnum WinsysFeature
a) (WinsysFeature -> Int
forall a. Enum a => a -> Int
P.fromEnum WinsysFeature
b)

type instance O.ParentTypes WinsysFeature = '[]
instance O.HasParentTypes WinsysFeature

foreign import ccall "cogl_winsys_feature_get_type" c_cogl_winsys_feature_get_type :: 
    IO GType

instance B.Types.TypedObject WinsysFeature where
    glibType :: IO GType
glibType = IO GType
c_cogl_winsys_feature_get_type

instance B.Types.BoxedEnum WinsysFeature

-- Enum Winding
-- | Enum used to represent the two directions of rotation. This can be
-- used to set the front face for culling by calling
-- @/cogl_pipeline_set_front_face_winding()/@.
data Winding = 
      WindingClockwise
    -- ^ Vertices are in a clockwise order
    | WindingCounterClockwise
    -- ^ Vertices are in a counter-clockwise order
    | AnotherWinding Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Winding -> ShowS
[Winding] -> ShowS
Winding -> String
(Int -> Winding -> ShowS)
-> (Winding -> String) -> ([Winding] -> ShowS) -> Show Winding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Winding -> ShowS
showsPrec :: Int -> Winding -> ShowS
$cshow :: Winding -> String
show :: Winding -> String
$cshowList :: [Winding] -> ShowS
showList :: [Winding] -> ShowS
Show, Winding -> Winding -> Bool
(Winding -> Winding -> Bool)
-> (Winding -> Winding -> Bool) -> Eq Winding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Winding -> Winding -> Bool
== :: Winding -> Winding -> Bool
$c/= :: Winding -> Winding -> Bool
/= :: Winding -> Winding -> Bool
Eq)

instance P.Enum Winding where
    fromEnum :: Winding -> Int
fromEnum Winding
WindingClockwise = Int
0
    fromEnum Winding
WindingCounterClockwise = Int
1
    fromEnum (AnotherWinding Int
k) = Int
k

    toEnum :: Int -> Winding
toEnum Int
0 = Winding
WindingClockwise
    toEnum Int
1 = Winding
WindingCounterClockwise
    toEnum Int
k = Int -> Winding
AnotherWinding Int
k

instance P.Ord Winding where
    compare :: Winding -> Winding -> Ordering
compare Winding
a Winding
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Winding -> Int
forall a. Enum a => a -> Int
P.fromEnum Winding
a) (Winding -> Int
forall a. Enum a => a -> Int
P.fromEnum Winding
b)

type instance O.ParentTypes Winding = '[]
instance O.HasParentTypes Winding

foreign import ccall "cogl_winding_get_type" c_cogl_winding_get_type :: 
    IO GType

instance B.Types.TypedObject Winding where
    glibType :: IO GType
glibType = IO GType
c_cogl_winding_get_type

instance B.Types.BoxedEnum Winding

-- Enum VerticesMode
-- | Different ways of interpreting vertices when drawing.
-- 
-- /Since: 1.0/
data VerticesMode = 
      VerticesModePoints
    -- ^ FIXME, equivalent to
    -- \<constant>GL_POINTS\<\/constant>
    | VerticesModeLines
    -- ^ FIXME, equivalent to \<constant>GL_LINES\<\/constant>
    | VerticesModeLineLoop
    -- ^ FIXME, equivalent to
    -- \<constant>GL_LINE_LOOP\<\/constant>
    | VerticesModeLineStrip
    -- ^ FIXME, equivalent to
    -- \<constant>GL_LINE_STRIP\<\/constant>
    | VerticesModeTriangles
    -- ^ FIXME, equivalent to
    -- \<constant>GL_TRIANGLES\<\/constant>
    | VerticesModeTriangleStrip
    -- ^ FIXME, equivalent to
    -- \<constant>GL_TRIANGLE_STRIP\<\/constant>
    | VerticesModeTriangleFan
    -- ^ FIXME, equivalent to \<constant>GL_TRIANGLE_FAN\<\/constant>
    | AnotherVerticesMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VerticesMode -> ShowS
[VerticesMode] -> ShowS
VerticesMode -> String
(Int -> VerticesMode -> ShowS)
-> (VerticesMode -> String)
-> ([VerticesMode] -> ShowS)
-> Show VerticesMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VerticesMode -> ShowS
showsPrec :: Int -> VerticesMode -> ShowS
$cshow :: VerticesMode -> String
show :: VerticesMode -> String
$cshowList :: [VerticesMode] -> ShowS
showList :: [VerticesMode] -> ShowS
Show, VerticesMode -> VerticesMode -> Bool
(VerticesMode -> VerticesMode -> Bool)
-> (VerticesMode -> VerticesMode -> Bool) -> Eq VerticesMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VerticesMode -> VerticesMode -> Bool
== :: VerticesMode -> VerticesMode -> Bool
$c/= :: VerticesMode -> VerticesMode -> Bool
/= :: VerticesMode -> VerticesMode -> Bool
Eq)

instance P.Enum VerticesMode where
    fromEnum :: VerticesMode -> Int
fromEnum VerticesMode
VerticesModePoints = Int
0
    fromEnum VerticesMode
VerticesModeLines = Int
1
    fromEnum VerticesMode
VerticesModeLineLoop = Int
2
    fromEnum VerticesMode
VerticesModeLineStrip = Int
3
    fromEnum VerticesMode
VerticesModeTriangles = Int
4
    fromEnum VerticesMode
VerticesModeTriangleStrip = Int
5
    fromEnum VerticesMode
VerticesModeTriangleFan = Int
6
    fromEnum (AnotherVerticesMode Int
k) = Int
k

    toEnum :: Int -> VerticesMode
toEnum Int
0 = VerticesMode
VerticesModePoints
    toEnum Int
1 = VerticesMode
VerticesModeLines
    toEnum Int
2 = VerticesMode
VerticesModeLineLoop
    toEnum Int
3 = VerticesMode
VerticesModeLineStrip
    toEnum Int
4 = VerticesMode
VerticesModeTriangles
    toEnum Int
5 = VerticesMode
VerticesModeTriangleStrip
    toEnum Int
6 = VerticesMode
VerticesModeTriangleFan
    toEnum Int
k = Int -> VerticesMode
AnotherVerticesMode Int
k

instance P.Ord VerticesMode where
    compare :: VerticesMode -> VerticesMode -> Ordering
compare VerticesMode
a VerticesMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VerticesMode -> Int
forall a. Enum a => a -> Int
P.fromEnum VerticesMode
a) (VerticesMode -> Int
forall a. Enum a => a -> Int
P.fromEnum VerticesMode
b)

type instance O.ParentTypes VerticesMode = '[]
instance O.HasParentTypes VerticesMode

foreign import ccall "cogl_vertices_mode_get_type" c_cogl_vertices_mode_get_type :: 
    IO GType

instance B.Types.TypedObject VerticesMode where
    glibType :: IO GType
glibType = IO GType
c_cogl_vertices_mode_get_type

instance B.Types.BoxedEnum VerticesMode

-- Enum TextureType
-- | Constants representing the underlying hardware texture type of a
-- @/CoglTexture/@.
-- 
-- /Since: 1.10/
data TextureType = 
      TextureType2d
    -- ^ A @/CoglTexture2D/@
    | TextureType3d
    -- ^ A @/CoglTexture3D/@
    | TextureTypeRectangle
    -- ^ A @/CoglTextureRectangle/@
    | AnotherTextureType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextureType -> ShowS
[TextureType] -> ShowS
TextureType -> String
(Int -> TextureType -> ShowS)
-> (TextureType -> String)
-> ([TextureType] -> ShowS)
-> Show TextureType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextureType -> ShowS
showsPrec :: Int -> TextureType -> ShowS
$cshow :: TextureType -> String
show :: TextureType -> String
$cshowList :: [TextureType] -> ShowS
showList :: [TextureType] -> ShowS
Show, TextureType -> TextureType -> Bool
(TextureType -> TextureType -> Bool)
-> (TextureType -> TextureType -> Bool) -> Eq TextureType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextureType -> TextureType -> Bool
== :: TextureType -> TextureType -> Bool
$c/= :: TextureType -> TextureType -> Bool
/= :: TextureType -> TextureType -> Bool
Eq)

instance P.Enum TextureType where
    fromEnum :: TextureType -> Int
fromEnum TextureType
TextureType2d = Int
0
    fromEnum TextureType
TextureType3d = Int
1
    fromEnum TextureType
TextureTypeRectangle = Int
2
    fromEnum (AnotherTextureType Int
k) = Int
k

    toEnum :: Int -> TextureType
toEnum Int
0 = TextureType
TextureType2d
    toEnum Int
1 = TextureType
TextureType3d
    toEnum Int
2 = TextureType
TextureTypeRectangle
    toEnum Int
k = Int -> TextureType
AnotherTextureType Int
k

instance P.Ord TextureType where
    compare :: TextureType -> TextureType -> Ordering
compare TextureType
a TextureType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextureType -> Int
forall a. Enum a => a -> Int
P.fromEnum TextureType
a) (TextureType -> Int
forall a. Enum a => a -> Int
P.fromEnum TextureType
b)

type instance O.ParentTypes TextureType = '[]
instance O.HasParentTypes TextureType

foreign import ccall "cogl_texture_type_get_type" c_cogl_texture_type_get_type :: 
    IO GType

instance B.Types.TypedObject TextureType where
    glibType :: IO GType
glibType = IO GType
c_cogl_texture_type_get_type

instance B.Types.BoxedEnum TextureType

-- Enum TextureError
-- | Error codes that can be thrown when allocating textures.
-- 
-- /Since: 1.8/
data TextureError = 
      TextureErrorSize
    -- ^ Unsupported size
    | TextureErrorFormat
    -- ^ Unsupported format
    | TextureErrorBadParameter
    -- ^ /No description available in the introspection data./
    | TextureErrorType
    -- ^ A primitive texture type that is
    --   unsupported by the driver was used
    | AnotherTextureError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextureError -> ShowS
[TextureError] -> ShowS
TextureError -> String
(Int -> TextureError -> ShowS)
-> (TextureError -> String)
-> ([TextureError] -> ShowS)
-> Show TextureError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextureError -> ShowS
showsPrec :: Int -> TextureError -> ShowS
$cshow :: TextureError -> String
show :: TextureError -> String
$cshowList :: [TextureError] -> ShowS
showList :: [TextureError] -> ShowS
Show, TextureError -> TextureError -> Bool
(TextureError -> TextureError -> Bool)
-> (TextureError -> TextureError -> Bool) -> Eq TextureError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextureError -> TextureError -> Bool
== :: TextureError -> TextureError -> Bool
$c/= :: TextureError -> TextureError -> Bool
/= :: TextureError -> TextureError -> Bool
Eq)

instance P.Enum TextureError where
    fromEnum :: TextureError -> Int
fromEnum TextureError
TextureErrorSize = Int
0
    fromEnum TextureError
TextureErrorFormat = Int
1
    fromEnum TextureError
TextureErrorBadParameter = Int
2
    fromEnum TextureError
TextureErrorType = Int
3
    fromEnum (AnotherTextureError Int
k) = Int
k

    toEnum :: Int -> TextureError
toEnum Int
0 = TextureError
TextureErrorSize
    toEnum Int
1 = TextureError
TextureErrorFormat
    toEnum Int
2 = TextureError
TextureErrorBadParameter
    toEnum Int
3 = TextureError
TextureErrorType
    toEnum Int
k = Int -> TextureError
AnotherTextureError Int
k

instance P.Ord TextureError where
    compare :: TextureError -> TextureError -> Ordering
compare TextureError
a TextureError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextureError -> Int
forall a. Enum a => a -> Int
P.fromEnum TextureError
a) (TextureError -> Int
forall a. Enum a => a -> Int
P.fromEnum TextureError
b)

type instance O.ParentTypes TextureError = '[]
instance O.HasParentTypes TextureError

foreign import ccall "cogl_texture_error_get_type" c_cogl_texture_error_get_type :: 
    IO GType

instance B.Types.TypedObject TextureError where
    glibType :: IO GType
glibType = IO GType
c_cogl_texture_error_get_type

instance B.Types.BoxedEnum TextureError

-- Enum TextureComponents
-- | See 'GI.Cogl.Interfaces.Texture.textureSetComponents'.
-- 
-- /Since: 1.18/
data TextureComponents = 
      TextureComponentsA
    -- ^ Only the alpha component
    | TextureComponentsRg
    -- ^ Red and green components. Note that
    --   this can only be used if the @/COGL_FEATURE_ID_TEXTURE_RG/@ feature
    --   is advertised.
    | TextureComponentsRgb
    -- ^ Red, green and blue components
    | TextureComponentsRgba
    -- ^ Red, green, blue and alpha components
    | TextureComponentsDepth
    -- ^ Only a depth component
    | AnotherTextureComponents Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextureComponents -> ShowS
[TextureComponents] -> ShowS
TextureComponents -> String
(Int -> TextureComponents -> ShowS)
-> (TextureComponents -> String)
-> ([TextureComponents] -> ShowS)
-> Show TextureComponents
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextureComponents -> ShowS
showsPrec :: Int -> TextureComponents -> ShowS
$cshow :: TextureComponents -> String
show :: TextureComponents -> String
$cshowList :: [TextureComponents] -> ShowS
showList :: [TextureComponents] -> ShowS
Show, TextureComponents -> TextureComponents -> Bool
(TextureComponents -> TextureComponents -> Bool)
-> (TextureComponents -> TextureComponents -> Bool)
-> Eq TextureComponents
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextureComponents -> TextureComponents -> Bool
== :: TextureComponents -> TextureComponents -> Bool
$c/= :: TextureComponents -> TextureComponents -> Bool
/= :: TextureComponents -> TextureComponents -> Bool
Eq)

instance P.Enum TextureComponents where
    fromEnum :: TextureComponents -> Int
fromEnum TextureComponents
TextureComponentsA = Int
1
    fromEnum TextureComponents
TextureComponentsRg = Int
2
    fromEnum TextureComponents
TextureComponentsRgb = Int
3
    fromEnum TextureComponents
TextureComponentsRgba = Int
4
    fromEnum TextureComponents
TextureComponentsDepth = Int
5
    fromEnum (AnotherTextureComponents Int
k) = Int
k

    toEnum :: Int -> TextureComponents
toEnum Int
1 = TextureComponents
TextureComponentsA
    toEnum Int
2 = TextureComponents
TextureComponentsRg
    toEnum Int
3 = TextureComponents
TextureComponentsRgb
    toEnum Int
4 = TextureComponents
TextureComponentsRgba
    toEnum Int
5 = TextureComponents
TextureComponentsDepth
    toEnum Int
k = Int -> TextureComponents
AnotherTextureComponents Int
k

instance P.Ord TextureComponents where
    compare :: TextureComponents -> TextureComponents -> Ordering
compare TextureComponents
a TextureComponents
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextureComponents -> Int
forall a. Enum a => a -> Int
P.fromEnum TextureComponents
a) (TextureComponents -> Int
forall a. Enum a => a -> Int
P.fromEnum TextureComponents
b)

type instance O.ParentTypes TextureComponents = '[]
instance O.HasParentTypes TextureComponents

foreign import ccall "cogl_texture_components_get_type" c_cogl_texture_components_get_type :: 
    IO GType

instance B.Types.TypedObject TextureComponents where
    glibType :: IO GType
glibType = IO GType
c_cogl_texture_components_get_type

instance B.Types.BoxedEnum TextureComponents

-- Enum SystemError
-- | Error enumeration for Cogl
-- 
-- The /@cOGLSYSTEMERRORUNSUPPORTED@/ error can be thrown for a
-- variety of reasons. For example:
-- 
-- \<itemizedlist>
--  \<listitem>\<para>You\'ve tried to use a feature that is not
--   advertised by @/cogl_has_feature()/@. This could happen if you create
--   a 2d texture with a non-power-of-two size when
--   @/COGL_FEATURE_ID_TEXTURE_NPOT/@ is not advertised.\<\/para>\<\/listitem>
--  \<listitem>\<para>The GPU can not handle the configuration you have
--   requested. An example might be if you try to use too many texture
--   layers in a single @/CoglPipeline/@\<\/para>\<\/listitem>
--  \<listitem>\<para>The driver does not support some
--   configuration.\<\/para>\<\/listiem>
-- \<\/itemizedlist>
-- 
-- Currently this is only used by Cogl API marked as experimental so
-- this enum should also be considered experimental.
-- 
-- /Since: 1.4/
data SystemError = 
      SystemErrorCoglSystemErrorUnsupported
    -- ^ You tried to use a feature or
    --    configuration not currently available.
    | SystemErrorCoglSystemErrorNoMemory
    -- ^ You tried to allocate a resource
    --    such as a texture and there wasn\'t enough memory.
    | AnotherSystemError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SystemError -> ShowS
[SystemError] -> ShowS
SystemError -> String
(Int -> SystemError -> ShowS)
-> (SystemError -> String)
-> ([SystemError] -> ShowS)
-> Show SystemError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SystemError -> ShowS
showsPrec :: Int -> SystemError -> ShowS
$cshow :: SystemError -> String
show :: SystemError -> String
$cshowList :: [SystemError] -> ShowS
showList :: [SystemError] -> ShowS
Show, SystemError -> SystemError -> Bool
(SystemError -> SystemError -> Bool)
-> (SystemError -> SystemError -> Bool) -> Eq SystemError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SystemError -> SystemError -> Bool
== :: SystemError -> SystemError -> Bool
$c/= :: SystemError -> SystemError -> Bool
/= :: SystemError -> SystemError -> Bool
Eq)

instance P.Enum SystemError where
    fromEnum :: SystemError -> Int
fromEnum SystemError
SystemErrorCoglSystemErrorUnsupported = Int
0
    fromEnum SystemError
SystemErrorCoglSystemErrorNoMemory = Int
1
    fromEnum (AnotherSystemError Int
k) = Int
k

    toEnum :: Int -> SystemError
toEnum Int
0 = SystemError
SystemErrorCoglSystemErrorUnsupported
    toEnum Int
1 = SystemError
SystemErrorCoglSystemErrorNoMemory
    toEnum Int
k = Int -> SystemError
AnotherSystemError Int
k

instance P.Ord SystemError where
    compare :: SystemError -> SystemError -> Ordering
compare SystemError
a SystemError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SystemError -> Int
forall a. Enum a => a -> Int
P.fromEnum SystemError
a) (SystemError -> Int
forall a. Enum a => a -> Int
P.fromEnum SystemError
b)

type instance O.ParentTypes SystemError = '[]
instance O.HasParentTypes SystemError

foreign import ccall "cogl_system_error_get_type" c_cogl_system_error_get_type :: 
    IO GType

instance B.Types.TypedObject SystemError where
    glibType :: IO GType
glibType = IO GType
c_cogl_system_error_get_type

instance B.Types.BoxedEnum SystemError

-- Enum StereoMode
-- | Represents how draw should affect the two buffers
-- of a stereo framebuffer. See @/cogl_framebuffer_set_stereo_mode()/@.
data StereoMode = 
      StereoModeBoth
    -- ^ draw to both stereo buffers
    | StereoModeLeft
    -- ^ draw only to the left stereo buffer
    | StereoModeRight
    -- ^ draw only to the left stereo buffer
    | AnotherStereoMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StereoMode -> ShowS
[StereoMode] -> ShowS
StereoMode -> String
(Int -> StereoMode -> ShowS)
-> (StereoMode -> String)
-> ([StereoMode] -> ShowS)
-> Show StereoMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StereoMode -> ShowS
showsPrec :: Int -> StereoMode -> ShowS
$cshow :: StereoMode -> String
show :: StereoMode -> String
$cshowList :: [StereoMode] -> ShowS
showList :: [StereoMode] -> ShowS
Show, StereoMode -> StereoMode -> Bool
(StereoMode -> StereoMode -> Bool)
-> (StereoMode -> StereoMode -> Bool) -> Eq StereoMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StereoMode -> StereoMode -> Bool
== :: StereoMode -> StereoMode -> Bool
$c/= :: StereoMode -> StereoMode -> Bool
/= :: StereoMode -> StereoMode -> Bool
Eq)

instance P.Enum StereoMode where
    fromEnum :: StereoMode -> Int
fromEnum StereoMode
StereoModeBoth = Int
0
    fromEnum StereoMode
StereoModeLeft = Int
1
    fromEnum StereoMode
StereoModeRight = Int
2
    fromEnum (AnotherStereoMode Int
k) = Int
k

    toEnum :: Int -> StereoMode
toEnum Int
0 = StereoMode
StereoModeBoth
    toEnum Int
1 = StereoMode
StereoModeLeft
    toEnum Int
2 = StereoMode
StereoModeRight
    toEnum Int
k = Int -> StereoMode
AnotherStereoMode Int
k

instance P.Ord StereoMode where
    compare :: StereoMode -> StereoMode -> Ordering
compare StereoMode
a StereoMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StereoMode -> Int
forall a. Enum a => a -> Int
P.fromEnum StereoMode
a) (StereoMode -> Int
forall a. Enum a => a -> Int
P.fromEnum StereoMode
b)

type instance O.ParentTypes StereoMode = '[]
instance O.HasParentTypes StereoMode

foreign import ccall "cogl_stereo_mode_get_type" c_cogl_stereo_mode_get_type :: 
    IO GType

instance B.Types.TypedObject StereoMode where
    glibType :: IO GType
glibType = IO GType
c_cogl_stereo_mode_get_type

instance B.Types.BoxedEnum StereoMode

-- Enum ShaderType
-- | Types of shaders
-- 
-- /Since: 1.0/
data ShaderType = 
      ShaderTypeVertex
    -- ^ A program for proccessing vertices
    | ShaderTypeFragment
    -- ^ A program for processing fragments
    | AnotherShaderType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ShaderType -> ShowS
[ShaderType] -> ShowS
ShaderType -> String
(Int -> ShaderType -> ShowS)
-> (ShaderType -> String)
-> ([ShaderType] -> ShowS)
-> Show ShaderType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShaderType -> ShowS
showsPrec :: Int -> ShaderType -> ShowS
$cshow :: ShaderType -> String
show :: ShaderType -> String
$cshowList :: [ShaderType] -> ShowS
showList :: [ShaderType] -> ShowS
Show, ShaderType -> ShaderType -> Bool
(ShaderType -> ShaderType -> Bool)
-> (ShaderType -> ShaderType -> Bool) -> Eq ShaderType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShaderType -> ShaderType -> Bool
== :: ShaderType -> ShaderType -> Bool
$c/= :: ShaderType -> ShaderType -> Bool
/= :: ShaderType -> ShaderType -> Bool
Eq)

instance P.Enum ShaderType where
    fromEnum :: ShaderType -> Int
fromEnum ShaderType
ShaderTypeVertex = Int
0
    fromEnum ShaderType
ShaderTypeFragment = Int
1
    fromEnum (AnotherShaderType Int
k) = Int
k

    toEnum :: Int -> ShaderType
toEnum Int
0 = ShaderType
ShaderTypeVertex
    toEnum Int
1 = ShaderType
ShaderTypeFragment
    toEnum Int
k = Int -> ShaderType
AnotherShaderType Int
k

instance P.Ord ShaderType where
    compare :: ShaderType -> ShaderType -> Ordering
compare ShaderType
a ShaderType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ShaderType -> Int
forall a. Enum a => a -> Int
P.fromEnum ShaderType
a) (ShaderType -> Int
forall a. Enum a => a -> Int
P.fromEnum ShaderType
b)

type instance O.ParentTypes ShaderType = '[]
instance O.HasParentTypes ShaderType

foreign import ccall "cogl_shader_type_get_type" c_cogl_shader_type_get_type :: 
    IO GType

instance B.Types.TypedObject ShaderType where
    glibType :: IO GType
glibType = IO GType
c_cogl_shader_type_get_type

instance B.Types.BoxedEnum ShaderType

-- Enum RendererError
-- | /No description available in the introspection data./
data RendererError = 
      RendererErrorXlibDisplayOpen
    -- ^ /No description available in the introspection data./
    | RendererErrorBadConstraint
    -- ^ /No description available in the introspection data./
    | AnotherRendererError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RendererError -> ShowS
[RendererError] -> ShowS
RendererError -> String
(Int -> RendererError -> ShowS)
-> (RendererError -> String)
-> ([RendererError] -> ShowS)
-> Show RendererError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RendererError -> ShowS
showsPrec :: Int -> RendererError -> ShowS
$cshow :: RendererError -> String
show :: RendererError -> String
$cshowList :: [RendererError] -> ShowS
showList :: [RendererError] -> ShowS
Show, RendererError -> RendererError -> Bool
(RendererError -> RendererError -> Bool)
-> (RendererError -> RendererError -> Bool) -> Eq RendererError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RendererError -> RendererError -> Bool
== :: RendererError -> RendererError -> Bool
$c/= :: RendererError -> RendererError -> Bool
/= :: RendererError -> RendererError -> Bool
Eq)

instance P.Enum RendererError where
    fromEnum :: RendererError -> Int
fromEnum RendererError
RendererErrorXlibDisplayOpen = Int
0
    fromEnum RendererError
RendererErrorBadConstraint = Int
1
    fromEnum (AnotherRendererError Int
k) = Int
k

    toEnum :: Int -> RendererError
toEnum Int
0 = RendererError
RendererErrorXlibDisplayOpen
    toEnum Int
1 = RendererError
RendererErrorBadConstraint
    toEnum Int
k = Int -> RendererError
AnotherRendererError Int
k

instance P.Ord RendererError where
    compare :: RendererError -> RendererError -> Ordering
compare RendererError
a RendererError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RendererError -> Int
forall a. Enum a => a -> Int
P.fromEnum RendererError
a) (RendererError -> Int
forall a. Enum a => a -> Int
P.fromEnum RendererError
b)

type instance O.ParentTypes RendererError = '[]
instance O.HasParentTypes RendererError

foreign import ccall "cogl_renderer_error_get_type" c_cogl_renderer_error_get_type :: 
    IO GType

instance B.Types.TypedObject RendererError where
    glibType :: IO GType
glibType = IO GType
c_cogl_renderer_error_get_type

instance B.Types.BoxedEnum RendererError

-- Enum PixelFormat
-- | Pixel formats used by Cogl. For the formats with a byte per
-- component, the order of the components specify the order in
-- increasing memory addresses. So for example
-- 'GI.Cogl.Enums.PixelFormatRgb888' would have the red component in the
-- lowest address, green in the next address and blue after that
-- regardless of the endianness of the system.
-- 
-- For the formats with non byte aligned components the component
-- order specifies the order within a 16-bit or 32-bit number from
-- most significant bit to least significant. So for
-- 'GI.Cogl.Enums.PixelFormatRgb565', the red component would be in bits
-- 11-15, the green component would be in 6-11 and the blue component
-- would be in 1-5. Therefore the order in memory depends on the
-- endianness of the system.
-- 
-- When uploading a texture 'GI.Cogl.Enums.PixelFormatAny' can be used as the
-- internal format. Cogl will try to pick the best format to use
-- internally and convert the texture data if necessary.
-- 
-- /Since: 0.8/
data PixelFormat = 
      PixelFormatAny
    -- ^ Any format
    | PixelFormatA8
    -- ^ 8 bits alpha mask
    | PixelFormatRgb565
    -- ^ RGB, 16 bits
    | PixelFormatRgba4444
    -- ^ RGBA, 16 bits
    | PixelFormatRgba5551
    -- ^ RGBA, 16 bits
    | PixelFormatYuv
    -- ^ Not currently supported
    | PixelFormatG8
    -- ^ Single luminance component
    | PixelFormatRg88
    -- ^ RG, 16 bits. Note that red-green textures
    --   are only available if @/COGL_FEATURE_ID_TEXTURE_RG/@ is advertised.
    --   See 'GI.Cogl.Interfaces.Texture.textureSetComponents' for details.
    | PixelFormatRgb888
    -- ^ RGB, 24 bits
    | PixelFormatBgr888
    -- ^ BGR, 24 bits
    | PixelFormatRgba8888
    -- ^ RGBA, 32 bits
    | PixelFormatBgra8888
    -- ^ BGRA, 32 bits
    | PixelFormatArgb8888
    -- ^ ARGB, 32 bits
    | PixelFormatAbgr8888
    -- ^ ABGR, 32 bits
    | PixelFormatRgba1010102
    -- ^ RGBA, 32 bits, 10 bpc
    | PixelFormatBgra1010102
    -- ^ BGRA, 32 bits, 10 bpc
    | PixelFormatArgb2101010
    -- ^ ARGB, 32 bits, 10 bpc
    | PixelFormatAbgr2101010
    -- ^ ABGR, 32 bits, 10 bpc
    | PixelFormatRgba8888Pre
    -- ^ Premultiplied RGBA, 32 bits
    | PixelFormatBgra8888Pre
    -- ^ Premultiplied BGRA, 32 bits
    | PixelFormatArgb8888Pre
    -- ^ Premultiplied ARGB, 32 bits
    | PixelFormatAbgr8888Pre
    -- ^ Premultiplied ABGR, 32 bits
    | PixelFormatRgba4444Pre
    -- ^ Premultiplied RGBA, 16 bits
    | PixelFormatRgba5551Pre
    -- ^ Premultiplied RGBA, 16 bits
    | PixelFormatRgba1010102Pre
    -- ^ Premultiplied RGBA, 32 bits, 10 bpc
    | PixelFormatBgra1010102Pre
    -- ^ Premultiplied BGRA, 32 bits, 10 bpc
    | PixelFormatArgb2101010Pre
    -- ^ Premultiplied ARGB, 32 bits, 10 bpc
    | PixelFormatAbgr2101010Pre
    -- ^ Premultiplied ABGR, 32 bits, 10 bpc
    | PixelFormatDepth16
    -- ^ /No description available in the introspection data./
    | PixelFormatDepth32
    -- ^ /No description available in the introspection data./
    | PixelFormatDepth24Stencil8
    -- ^ /No description available in the introspection data./
    | AnotherPixelFormat Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PixelFormat -> ShowS
[PixelFormat] -> ShowS
PixelFormat -> String
(Int -> PixelFormat -> ShowS)
-> (PixelFormat -> String)
-> ([PixelFormat] -> ShowS)
-> Show PixelFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PixelFormat -> ShowS
showsPrec :: Int -> PixelFormat -> ShowS
$cshow :: PixelFormat -> String
show :: PixelFormat -> String
$cshowList :: [PixelFormat] -> ShowS
showList :: [PixelFormat] -> ShowS
Show, PixelFormat -> PixelFormat -> Bool
(PixelFormat -> PixelFormat -> Bool)
-> (PixelFormat -> PixelFormat -> Bool) -> Eq PixelFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PixelFormat -> PixelFormat -> Bool
== :: PixelFormat -> PixelFormat -> Bool
$c/= :: PixelFormat -> PixelFormat -> Bool
/= :: PixelFormat -> PixelFormat -> Bool
Eq)

instance P.Enum PixelFormat where
    fromEnum :: PixelFormat -> Int
fromEnum PixelFormat
PixelFormatAny = Int
0
    fromEnum PixelFormat
PixelFormatA8 = Int
17
    fromEnum PixelFormat
PixelFormatRgb565 = Int
4
    fromEnum PixelFormat
PixelFormatRgba4444 = Int
21
    fromEnum PixelFormat
PixelFormatRgba5551 = Int
22
    fromEnum PixelFormat
PixelFormatYuv = Int
7
    fromEnum PixelFormat
PixelFormatG8 = Int
8
    fromEnum PixelFormat
PixelFormatRg88 = Int
9
    fromEnum PixelFormat
PixelFormatRgb888 = Int
2
    fromEnum PixelFormat
PixelFormatBgr888 = Int
34
    fromEnum PixelFormat
PixelFormatRgba8888 = Int
19
    fromEnum PixelFormat
PixelFormatBgra8888 = Int
51
    fromEnum PixelFormat
PixelFormatArgb8888 = Int
83
    fromEnum PixelFormat
PixelFormatAbgr8888 = Int
115
    fromEnum PixelFormat
PixelFormatRgba1010102 = Int
29
    fromEnum PixelFormat
PixelFormatBgra1010102 = Int
61
    fromEnum PixelFormat
PixelFormatArgb2101010 = Int
93
    fromEnum PixelFormat
PixelFormatAbgr2101010 = Int
125
    fromEnum PixelFormat
PixelFormatRgba8888Pre = Int
147
    fromEnum PixelFormat
PixelFormatBgra8888Pre = Int
179
    fromEnum PixelFormat
PixelFormatArgb8888Pre = Int
211
    fromEnum PixelFormat
PixelFormatAbgr8888Pre = Int
243
    fromEnum PixelFormat
PixelFormatRgba4444Pre = Int
149
    fromEnum PixelFormat
PixelFormatRgba5551Pre = Int
150
    fromEnum PixelFormat
PixelFormatRgba1010102Pre = Int
157
    fromEnum PixelFormat
PixelFormatBgra1010102Pre = Int
189
    fromEnum PixelFormat
PixelFormatArgb2101010Pre = Int
221
    fromEnum PixelFormat
PixelFormatAbgr2101010Pre = Int
253
    fromEnum PixelFormat
PixelFormatDepth16 = Int
265
    fromEnum PixelFormat
PixelFormatDepth32 = Int
259
    fromEnum PixelFormat
PixelFormatDepth24Stencil8 = Int
771
    fromEnum (AnotherPixelFormat Int
k) = Int
k

    toEnum :: Int -> PixelFormat
toEnum Int
0 = PixelFormat
PixelFormatAny
    toEnum Int
17 = PixelFormat
PixelFormatA8
    toEnum Int
4 = PixelFormat
PixelFormatRgb565
    toEnum Int
21 = PixelFormat
PixelFormatRgba4444
    toEnum Int
22 = PixelFormat
PixelFormatRgba5551
    toEnum Int
7 = PixelFormat
PixelFormatYuv
    toEnum Int
8 = PixelFormat
PixelFormatG8
    toEnum Int
9 = PixelFormat
PixelFormatRg88
    toEnum Int
2 = PixelFormat
PixelFormatRgb888
    toEnum Int
34 = PixelFormat
PixelFormatBgr888
    toEnum Int
19 = PixelFormat
PixelFormatRgba8888
    toEnum Int
51 = PixelFormat
PixelFormatBgra8888
    toEnum Int
83 = PixelFormat
PixelFormatArgb8888
    toEnum Int
115 = PixelFormat
PixelFormatAbgr8888
    toEnum Int
29 = PixelFormat
PixelFormatRgba1010102
    toEnum Int
61 = PixelFormat
PixelFormatBgra1010102
    toEnum Int
93 = PixelFormat
PixelFormatArgb2101010
    toEnum Int
125 = PixelFormat
PixelFormatAbgr2101010
    toEnum Int
147 = PixelFormat
PixelFormatRgba8888Pre
    toEnum Int
179 = PixelFormat
PixelFormatBgra8888Pre
    toEnum Int
211 = PixelFormat
PixelFormatArgb8888Pre
    toEnum Int
243 = PixelFormat
PixelFormatAbgr8888Pre
    toEnum Int
149 = PixelFormat
PixelFormatRgba4444Pre
    toEnum Int
150 = PixelFormat
PixelFormatRgba5551Pre
    toEnum Int
157 = PixelFormat
PixelFormatRgba1010102Pre
    toEnum Int
189 = PixelFormat
PixelFormatBgra1010102Pre
    toEnum Int
221 = PixelFormat
PixelFormatArgb2101010Pre
    toEnum Int
253 = PixelFormat
PixelFormatAbgr2101010Pre
    toEnum Int
265 = PixelFormat
PixelFormatDepth16
    toEnum Int
259 = PixelFormat
PixelFormatDepth32
    toEnum Int
771 = PixelFormat
PixelFormatDepth24Stencil8
    toEnum Int
k = Int -> PixelFormat
AnotherPixelFormat Int
k

instance P.Ord PixelFormat where
    compare :: PixelFormat -> PixelFormat -> Ordering
compare PixelFormat
a PixelFormat
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PixelFormat -> Int
forall a. Enum a => a -> Int
P.fromEnum PixelFormat
a) (PixelFormat -> Int
forall a. Enum a => a -> Int
P.fromEnum PixelFormat
b)

type instance O.ParentTypes PixelFormat = '[]
instance O.HasParentTypes PixelFormat

foreign import ccall "cogl_pixel_format_get_type" c_cogl_pixel_format_get_type :: 
    IO GType

instance B.Types.TypedObject PixelFormat where
    glibType :: IO GType
glibType = IO GType
c_cogl_pixel_format_get_type

instance B.Types.BoxedEnum PixelFormat

-- Enum MaterialWrapMode
-- | The wrap mode specifies what happens when texture coordinates
-- outside the range 0→1 are used. Note that if the filter mode is
-- anything but 'GI.Cogl.Enums.MaterialFilterNearest' then texels outside the
-- range 0→1 might be used even when the coordinate is exactly 0 or 1
-- because OpenGL will try to sample neighbouring pixels. For example
-- if you are trying to render the full texture then you may get
-- artifacts around the edges when the pixels from the other side are
-- merged in if the wrap mode is set to repeat.
-- 
-- /Since: 1.4/
data MaterialWrapMode = 
      MaterialWrapModeRepeat
    -- ^ The texture will be repeated. This
    --   is useful for example to draw a tiled background.
    | MaterialWrapModeClampToEdge
    -- ^ The coordinates outside the
    --   range 0→1 will sample copies of the edge pixels of the
    --   texture. This is useful to avoid artifacts if only one copy of
    --   the texture is being rendered.
    | MaterialWrapModeAutomatic
    -- ^ Cogl will try to automatically
    --   decide which of the above two to use. For 'GI.Cogl.Functions.rectangle', it
    --   will use repeat mode if any of the texture coordinates are
    --   outside the range 0→1, otherwise it will use clamp to edge. For
    --   'GI.Cogl.Functions.polygon' it will always use repeat mode. For
    --   'GI.Cogl.Functions.vertexBufferDraw' it will use repeat mode except for
    --   layers that have point sprite coordinate generation enabled. This
    --   is the default value.
    | AnotherMaterialWrapMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MaterialWrapMode -> ShowS
[MaterialWrapMode] -> ShowS
MaterialWrapMode -> String
(Int -> MaterialWrapMode -> ShowS)
-> (MaterialWrapMode -> String)
-> ([MaterialWrapMode] -> ShowS)
-> Show MaterialWrapMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaterialWrapMode -> ShowS
showsPrec :: Int -> MaterialWrapMode -> ShowS
$cshow :: MaterialWrapMode -> String
show :: MaterialWrapMode -> String
$cshowList :: [MaterialWrapMode] -> ShowS
showList :: [MaterialWrapMode] -> ShowS
Show, MaterialWrapMode -> MaterialWrapMode -> Bool
(MaterialWrapMode -> MaterialWrapMode -> Bool)
-> (MaterialWrapMode -> MaterialWrapMode -> Bool)
-> Eq MaterialWrapMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaterialWrapMode -> MaterialWrapMode -> Bool
== :: MaterialWrapMode -> MaterialWrapMode -> Bool
$c/= :: MaterialWrapMode -> MaterialWrapMode -> Bool
/= :: MaterialWrapMode -> MaterialWrapMode -> Bool
Eq)

instance P.Enum MaterialWrapMode where
    fromEnum :: MaterialWrapMode -> Int
fromEnum MaterialWrapMode
MaterialWrapModeRepeat = Int
10497
    fromEnum MaterialWrapMode
MaterialWrapModeClampToEdge = Int
33071
    fromEnum MaterialWrapMode
MaterialWrapModeAutomatic = Int
519
    fromEnum (AnotherMaterialWrapMode Int
k) = Int
k

    toEnum :: Int -> MaterialWrapMode
toEnum Int
10497 = MaterialWrapMode
MaterialWrapModeRepeat
    toEnum Int
33071 = MaterialWrapMode
MaterialWrapModeClampToEdge
    toEnum Int
519 = MaterialWrapMode
MaterialWrapModeAutomatic
    toEnum Int
k = Int -> MaterialWrapMode
AnotherMaterialWrapMode Int
k

instance P.Ord MaterialWrapMode where
    compare :: MaterialWrapMode -> MaterialWrapMode -> Ordering
compare MaterialWrapMode
a MaterialWrapMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MaterialWrapMode -> Int
forall a. Enum a => a -> Int
P.fromEnum MaterialWrapMode
a) (MaterialWrapMode -> Int
forall a. Enum a => a -> Int
P.fromEnum MaterialWrapMode
b)

type instance O.ParentTypes MaterialWrapMode = '[]
instance O.HasParentTypes MaterialWrapMode

foreign import ccall "cogl_material_wrap_mode_get_type" c_cogl_material_wrap_mode_get_type :: 
    IO GType

instance B.Types.TypedObject MaterialWrapMode where
    glibType :: IO GType
glibType = IO GType
c_cogl_material_wrap_mode_get_type

instance B.Types.BoxedEnum MaterialWrapMode

-- Enum MaterialLayerType
-- | Available types of layers for a t'GI.Cogl.Structs.Material.Material'. This enumeration
-- might be expanded in later versions.
-- 
-- /Since: 1.0/
data MaterialLayerType = 
      MaterialLayerTypeTexture
    -- ^ The layer represents a
    --   \<link linkend=\"cogl-Textures\">texture\<\/link>
    | AnotherMaterialLayerType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MaterialLayerType -> ShowS
[MaterialLayerType] -> ShowS
MaterialLayerType -> String
(Int -> MaterialLayerType -> ShowS)
-> (MaterialLayerType -> String)
-> ([MaterialLayerType] -> ShowS)
-> Show MaterialLayerType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaterialLayerType -> ShowS
showsPrec :: Int -> MaterialLayerType -> ShowS
$cshow :: MaterialLayerType -> String
show :: MaterialLayerType -> String
$cshowList :: [MaterialLayerType] -> ShowS
showList :: [MaterialLayerType] -> ShowS
Show, MaterialLayerType -> MaterialLayerType -> Bool
(MaterialLayerType -> MaterialLayerType -> Bool)
-> (MaterialLayerType -> MaterialLayerType -> Bool)
-> Eq MaterialLayerType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaterialLayerType -> MaterialLayerType -> Bool
== :: MaterialLayerType -> MaterialLayerType -> Bool
$c/= :: MaterialLayerType -> MaterialLayerType -> Bool
/= :: MaterialLayerType -> MaterialLayerType -> Bool
Eq)

instance P.Enum MaterialLayerType where
    fromEnum :: MaterialLayerType -> Int
fromEnum MaterialLayerType
MaterialLayerTypeTexture = Int
0
    fromEnum (AnotherMaterialLayerType Int
k) = Int
k

    toEnum :: Int -> MaterialLayerType
toEnum Int
0 = MaterialLayerType
MaterialLayerTypeTexture
    toEnum Int
k = Int -> MaterialLayerType
AnotherMaterialLayerType Int
k

instance P.Ord MaterialLayerType where
    compare :: MaterialLayerType -> MaterialLayerType -> Ordering
compare MaterialLayerType
a MaterialLayerType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MaterialLayerType -> Int
forall a. Enum a => a -> Int
P.fromEnum MaterialLayerType
a) (MaterialLayerType -> Int
forall a. Enum a => a -> Int
P.fromEnum MaterialLayerType
b)

type instance O.ParentTypes MaterialLayerType = '[]
instance O.HasParentTypes MaterialLayerType

foreign import ccall "cogl_material_layer_type_get_type" c_cogl_material_layer_type_get_type :: 
    IO GType

instance B.Types.TypedObject MaterialLayerType where
    glibType :: IO GType
glibType = IO GType
c_cogl_material_layer_type_get_type

instance B.Types.BoxedEnum MaterialLayerType

-- Enum MaterialFilter
-- | Texture filtering is used whenever the current pixel maps either to more
-- than one texture element (texel) or less than one. These filter enums
-- correspond to different strategies used to come up with a pixel color, by
-- possibly referring to multiple neighbouring texels and taking a weighted
-- average or simply using the nearest texel.
data MaterialFilter = 
      MaterialFilterNearest
    -- ^ Measuring in manhatten distance from the,
    --   current pixel center, use the nearest texture texel
    | MaterialFilterLinear
    -- ^ Use the weighted average of the 4 texels
    --   nearest the current pixel center
    | MaterialFilterNearestMipmapNearest
    -- ^ Select the mimap level whose
    --   texel size most closely matches the current pixel, and use the
    --   'GI.Cogl.Enums.MaterialFilterNearest' criterion
    | MaterialFilterLinearMipmapNearest
    -- ^ Select the mimap level whose
    --   texel size most closely matches the current pixel, and use the
    --   'GI.Cogl.Enums.MaterialFilterLinear' criterion
    | MaterialFilterNearestMipmapLinear
    -- ^ Select the two mimap levels
    --   whose texel size most closely matches the current pixel, use
    --   the 'GI.Cogl.Enums.MaterialFilterNearest' criterion on each one and take
    --   their weighted average
    | MaterialFilterLinearMipmapLinear
    -- ^ Select the two mimap levels
    --   whose texel size most closely matches the current pixel, use
    --   the 'GI.Cogl.Enums.MaterialFilterLinear' criterion on each one and take
    --   their weighted average
    | AnotherMaterialFilter Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MaterialFilter -> ShowS
[MaterialFilter] -> ShowS
MaterialFilter -> String
(Int -> MaterialFilter -> ShowS)
-> (MaterialFilter -> String)
-> ([MaterialFilter] -> ShowS)
-> Show MaterialFilter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaterialFilter -> ShowS
showsPrec :: Int -> MaterialFilter -> ShowS
$cshow :: MaterialFilter -> String
show :: MaterialFilter -> String
$cshowList :: [MaterialFilter] -> ShowS
showList :: [MaterialFilter] -> ShowS
Show, MaterialFilter -> MaterialFilter -> Bool
(MaterialFilter -> MaterialFilter -> Bool)
-> (MaterialFilter -> MaterialFilter -> Bool) -> Eq MaterialFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaterialFilter -> MaterialFilter -> Bool
== :: MaterialFilter -> MaterialFilter -> Bool
$c/= :: MaterialFilter -> MaterialFilter -> Bool
/= :: MaterialFilter -> MaterialFilter -> Bool
Eq)

instance P.Enum MaterialFilter where
    fromEnum :: MaterialFilter -> Int
fromEnum MaterialFilter
MaterialFilterNearest = Int
9728
    fromEnum MaterialFilter
MaterialFilterLinear = Int
9729
    fromEnum MaterialFilter
MaterialFilterNearestMipmapNearest = Int
9984
    fromEnum MaterialFilter
MaterialFilterLinearMipmapNearest = Int
9985
    fromEnum MaterialFilter
MaterialFilterNearestMipmapLinear = Int
9986
    fromEnum MaterialFilter
MaterialFilterLinearMipmapLinear = Int
9987
    fromEnum (AnotherMaterialFilter Int
k) = Int
k

    toEnum :: Int -> MaterialFilter
toEnum Int
9728 = MaterialFilter
MaterialFilterNearest
    toEnum Int
9729 = MaterialFilter
MaterialFilterLinear
    toEnum Int
9984 = MaterialFilter
MaterialFilterNearestMipmapNearest
    toEnum Int
9985 = MaterialFilter
MaterialFilterLinearMipmapNearest
    toEnum Int
9986 = MaterialFilter
MaterialFilterNearestMipmapLinear
    toEnum Int
9987 = MaterialFilter
MaterialFilterLinearMipmapLinear
    toEnum Int
k = Int -> MaterialFilter
AnotherMaterialFilter Int
k

instance P.Ord MaterialFilter where
    compare :: MaterialFilter -> MaterialFilter -> Ordering
compare MaterialFilter
a MaterialFilter
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MaterialFilter -> Int
forall a. Enum a => a -> Int
P.fromEnum MaterialFilter
a) (MaterialFilter -> Int
forall a. Enum a => a -> Int
P.fromEnum MaterialFilter
b)

type instance O.ParentTypes MaterialFilter = '[]
instance O.HasParentTypes MaterialFilter

foreign import ccall "cogl_material_filter_get_type" c_cogl_material_filter_get_type :: 
    IO GType

instance B.Types.TypedObject MaterialFilter where
    glibType :: IO GType
glibType = IO GType
c_cogl_material_filter_get_type

instance B.Types.BoxedEnum MaterialFilter

-- Enum MaterialAlphaFunc
-- | Alpha testing happens before blending primitives with the framebuffer and
-- gives an opportunity to discard fragments based on a comparison with the
-- incoming alpha value and a reference alpha value. The t'GI.Cogl.Enums.MaterialAlphaFunc'
-- determines how the comparison is done.
data MaterialAlphaFunc = 
      MaterialAlphaFuncNever
    -- ^ Never let the fragment through.
    | MaterialAlphaFuncLess
    -- ^ Let the fragment through if the incoming
    --   alpha value is less than the reference alpha value
    | MaterialAlphaFuncEqual
    -- ^ Let the fragment through if the incoming
    --   alpha value equals the reference alpha value
    | MaterialAlphaFuncLequal
    -- ^ Let the fragment through if the incoming
    --   alpha value is less than or equal to the reference alpha value
    | MaterialAlphaFuncGreater
    -- ^ Let the fragment through if the incoming
    --   alpha value is greater than the reference alpha value
    | MaterialAlphaFuncNotequal
    -- ^ Let the fragment through if the incoming
    --   alpha value does not equal the reference alpha value
    | MaterialAlphaFuncGequal
    -- ^ Let the fragment through if the incoming
    --   alpha value is greater than or equal to the reference alpha value.
    | MaterialAlphaFuncAlways
    -- ^ Always let the fragment through.
    | AnotherMaterialAlphaFunc Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MaterialAlphaFunc -> ShowS
[MaterialAlphaFunc] -> ShowS
MaterialAlphaFunc -> String
(Int -> MaterialAlphaFunc -> ShowS)
-> (MaterialAlphaFunc -> String)
-> ([MaterialAlphaFunc] -> ShowS)
-> Show MaterialAlphaFunc
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaterialAlphaFunc -> ShowS
showsPrec :: Int -> MaterialAlphaFunc -> ShowS
$cshow :: MaterialAlphaFunc -> String
show :: MaterialAlphaFunc -> String
$cshowList :: [MaterialAlphaFunc] -> ShowS
showList :: [MaterialAlphaFunc] -> ShowS
Show, MaterialAlphaFunc -> MaterialAlphaFunc -> Bool
(MaterialAlphaFunc -> MaterialAlphaFunc -> Bool)
-> (MaterialAlphaFunc -> MaterialAlphaFunc -> Bool)
-> Eq MaterialAlphaFunc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaterialAlphaFunc -> MaterialAlphaFunc -> Bool
== :: MaterialAlphaFunc -> MaterialAlphaFunc -> Bool
$c/= :: MaterialAlphaFunc -> MaterialAlphaFunc -> Bool
/= :: MaterialAlphaFunc -> MaterialAlphaFunc -> Bool
Eq)

instance P.Enum MaterialAlphaFunc where
    fromEnum :: MaterialAlphaFunc -> Int
fromEnum MaterialAlphaFunc
MaterialAlphaFuncNever = Int
512
    fromEnum MaterialAlphaFunc
MaterialAlphaFuncLess = Int
513
    fromEnum MaterialAlphaFunc
MaterialAlphaFuncEqual = Int
514
    fromEnum MaterialAlphaFunc
MaterialAlphaFuncLequal = Int
515
    fromEnum MaterialAlphaFunc
MaterialAlphaFuncGreater = Int
516
    fromEnum MaterialAlphaFunc
MaterialAlphaFuncNotequal = Int
517
    fromEnum MaterialAlphaFunc
MaterialAlphaFuncGequal = Int
518
    fromEnum MaterialAlphaFunc
MaterialAlphaFuncAlways = Int
519
    fromEnum (AnotherMaterialAlphaFunc Int
k) = Int
k

    toEnum :: Int -> MaterialAlphaFunc
toEnum Int
512 = MaterialAlphaFunc
MaterialAlphaFuncNever
    toEnum Int
513 = MaterialAlphaFunc
MaterialAlphaFuncLess
    toEnum Int
514 = MaterialAlphaFunc
MaterialAlphaFuncEqual
    toEnum Int
515 = MaterialAlphaFunc
MaterialAlphaFuncLequal
    toEnum Int
516 = MaterialAlphaFunc
MaterialAlphaFuncGreater
    toEnum Int
517 = MaterialAlphaFunc
MaterialAlphaFuncNotequal
    toEnum Int
518 = MaterialAlphaFunc
MaterialAlphaFuncGequal
    toEnum Int
519 = MaterialAlphaFunc
MaterialAlphaFuncAlways
    toEnum Int
k = Int -> MaterialAlphaFunc
AnotherMaterialAlphaFunc Int
k

instance P.Ord MaterialAlphaFunc where
    compare :: MaterialAlphaFunc -> MaterialAlphaFunc -> Ordering
compare MaterialAlphaFunc
a MaterialAlphaFunc
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MaterialAlphaFunc -> Int
forall a. Enum a => a -> Int
P.fromEnum MaterialAlphaFunc
a) (MaterialAlphaFunc -> Int
forall a. Enum a => a -> Int
P.fromEnum MaterialAlphaFunc
b)

type instance O.ParentTypes MaterialAlphaFunc = '[]
instance O.HasParentTypes MaterialAlphaFunc

foreign import ccall "cogl_material_alpha_func_get_type" c_cogl_material_alpha_func_get_type :: 
    IO GType

instance B.Types.TypedObject MaterialAlphaFunc where
    glibType :: IO GType
glibType = IO GType
c_cogl_material_alpha_func_get_type

instance B.Types.BoxedEnum MaterialAlphaFunc

-- Enum IndicesType
-- | You should aim to use the smallest data type that gives you enough
-- range, since it reduces the size of your index array and can help
-- reduce the demand on memory bandwidth.
-- 
-- Note that 'GI.Cogl.Enums.IndicesTypeInt' is only supported if the
-- @/COGL_FEATURE_ID_UNSIGNED_INT_INDICES/@ feature is available. This
-- should always be available on OpenGL but on OpenGL ES it will only
-- be available if the GL_OES_element_index_uint extension is
-- advertized.
data IndicesType = 
      IndicesTypeByte
    -- ^ Your indices are unsigned bytes
    | IndicesTypeShort
    -- ^ Your indices are unsigned shorts
    | IndicesTypeInt
    -- ^ Your indices are unsigned ints
    | AnotherIndicesType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IndicesType -> ShowS
[IndicesType] -> ShowS
IndicesType -> String
(Int -> IndicesType -> ShowS)
-> (IndicesType -> String)
-> ([IndicesType] -> ShowS)
-> Show IndicesType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IndicesType -> ShowS
showsPrec :: Int -> IndicesType -> ShowS
$cshow :: IndicesType -> String
show :: IndicesType -> String
$cshowList :: [IndicesType] -> ShowS
showList :: [IndicesType] -> ShowS
Show, IndicesType -> IndicesType -> Bool
(IndicesType -> IndicesType -> Bool)
-> (IndicesType -> IndicesType -> Bool) -> Eq IndicesType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndicesType -> IndicesType -> Bool
== :: IndicesType -> IndicesType -> Bool
$c/= :: IndicesType -> IndicesType -> Bool
/= :: IndicesType -> IndicesType -> Bool
Eq)

instance P.Enum IndicesType where
    fromEnum :: IndicesType -> Int
fromEnum IndicesType
IndicesTypeByte = Int
0
    fromEnum IndicesType
IndicesTypeShort = Int
1
    fromEnum IndicesType
IndicesTypeInt = Int
2
    fromEnum (AnotherIndicesType Int
k) = Int
k

    toEnum :: Int -> IndicesType
toEnum Int
0 = IndicesType
IndicesTypeByte
    toEnum Int
1 = IndicesType
IndicesTypeShort
    toEnum Int
2 = IndicesType
IndicesTypeInt
    toEnum Int
k = Int -> IndicesType
AnotherIndicesType Int
k

instance P.Ord IndicesType where
    compare :: IndicesType -> IndicesType -> Ordering
compare IndicesType
a IndicesType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IndicesType -> Int
forall a. Enum a => a -> Int
P.fromEnum IndicesType
a) (IndicesType -> Int
forall a. Enum a => a -> Int
P.fromEnum IndicesType
b)

type instance O.ParentTypes IndicesType = '[]
instance O.HasParentTypes IndicesType

foreign import ccall "cogl_indices_type_get_type" c_cogl_indices_type_get_type :: 
    IO GType

instance B.Types.TypedObject IndicesType where
    glibType :: IO GType
glibType = IO GType
c_cogl_indices_type_get_type

instance B.Types.BoxedEnum IndicesType

-- Enum FogMode
-- | The fog mode determines the equation used to calculate the fogging blend
-- factor while fogging is enabled. The simplest 'GI.Cogl.Enums.FogModeLinear' mode
-- determines f as:
-- 
-- >
-- >  f = end - eye_distance / end - start
-- 
-- 
-- Where eye_distance is the distance of the current fragment in eye
-- coordinates from the origin.
-- 
-- /Since: 1.0/
data FogMode = 
      FogModeLinear
    -- ^ Calculates the fog blend factor as:
    -- >
    -- >  f = end - eye_distance / end - start
    | FogModeExponential
    -- ^ Calculates the fog blend factor as:
    -- >
    -- >  f = e ^ -(density * eye_distance)
    | FogModeExponentialSquared
    -- ^ Calculates the fog blend factor as:
    -- >
    -- >  f = e ^ -(density * eye_distance)^2
    | AnotherFogMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FogMode -> ShowS
[FogMode] -> ShowS
FogMode -> String
(Int -> FogMode -> ShowS)
-> (FogMode -> String) -> ([FogMode] -> ShowS) -> Show FogMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FogMode -> ShowS
showsPrec :: Int -> FogMode -> ShowS
$cshow :: FogMode -> String
show :: FogMode -> String
$cshowList :: [FogMode] -> ShowS
showList :: [FogMode] -> ShowS
Show, FogMode -> FogMode -> Bool
(FogMode -> FogMode -> Bool)
-> (FogMode -> FogMode -> Bool) -> Eq FogMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FogMode -> FogMode -> Bool
== :: FogMode -> FogMode -> Bool
$c/= :: FogMode -> FogMode -> Bool
/= :: FogMode -> FogMode -> Bool
Eq)

instance P.Enum FogMode where
    fromEnum :: FogMode -> Int
fromEnum FogMode
FogModeLinear = Int
0
    fromEnum FogMode
FogModeExponential = Int
1
    fromEnum FogMode
FogModeExponentialSquared = Int
2
    fromEnum (AnotherFogMode Int
k) = Int
k

    toEnum :: Int -> FogMode
toEnum Int
0 = FogMode
FogModeLinear
    toEnum Int
1 = FogMode
FogModeExponential
    toEnum Int
2 = FogMode
FogModeExponentialSquared
    toEnum Int
k = Int -> FogMode
AnotherFogMode Int
k

instance P.Ord FogMode where
    compare :: FogMode -> FogMode -> Ordering
compare FogMode
a FogMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FogMode -> Int
forall a. Enum a => a -> Int
P.fromEnum FogMode
a) (FogMode -> Int
forall a. Enum a => a -> Int
P.fromEnum FogMode
b)

type instance O.ParentTypes FogMode = '[]
instance O.HasParentTypes FogMode

foreign import ccall "cogl_fog_mode_get_type" c_cogl_fog_mode_get_type :: 
    IO GType

instance B.Types.TypedObject FogMode where
    glibType :: IO GType
glibType = IO GType
c_cogl_fog_mode_get_type

instance B.Types.BoxedEnum FogMode

-- Enum FilterReturn
-- | Return values for the @/CoglXlibFilterFunc/@ and @/CoglWin32FilterFunc/@ functions.
data FilterReturn = 
      FilterReturnContinue
    -- ^ The event was not handled, continues the
    --                        processing
    | FilterReturnRemove
    -- ^ Remove the event, stops the processing
    | AnotherFilterReturn Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FilterReturn -> ShowS
[FilterReturn] -> ShowS
FilterReturn -> String
(Int -> FilterReturn -> ShowS)
-> (FilterReturn -> String)
-> ([FilterReturn] -> ShowS)
-> Show FilterReturn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FilterReturn -> ShowS
showsPrec :: Int -> FilterReturn -> ShowS
$cshow :: FilterReturn -> String
show :: FilterReturn -> String
$cshowList :: [FilterReturn] -> ShowS
showList :: [FilterReturn] -> ShowS
Show, FilterReturn -> FilterReturn -> Bool
(FilterReturn -> FilterReturn -> Bool)
-> (FilterReturn -> FilterReturn -> Bool) -> Eq FilterReturn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FilterReturn -> FilterReturn -> Bool
== :: FilterReturn -> FilterReturn -> Bool
$c/= :: FilterReturn -> FilterReturn -> Bool
/= :: FilterReturn -> FilterReturn -> Bool
Eq)

instance P.Enum FilterReturn where
    fromEnum :: FilterReturn -> Int
fromEnum FilterReturn
FilterReturnContinue = Int
0
    fromEnum FilterReturn
FilterReturnRemove = Int
1
    fromEnum (AnotherFilterReturn Int
k) = Int
k

    toEnum :: Int -> FilterReturn
toEnum Int
0 = FilterReturn
FilterReturnContinue
    toEnum Int
1 = FilterReturn
FilterReturnRemove
    toEnum Int
k = Int -> FilterReturn
AnotherFilterReturn Int
k

instance P.Ord FilterReturn where
    compare :: FilterReturn -> FilterReturn -> Ordering
compare FilterReturn
a FilterReturn
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FilterReturn -> Int
forall a. Enum a => a -> Int
P.fromEnum FilterReturn
a) (FilterReturn -> Int
forall a. Enum a => a -> Int
P.fromEnum FilterReturn
b)

type instance O.ParentTypes FilterReturn = '[]
instance O.HasParentTypes FilterReturn

foreign import ccall "cogl_filter_return_get_type" c_cogl_filter_return_get_type :: 
    IO GType

instance B.Types.TypedObject FilterReturn where
    glibType :: IO GType
glibType = IO GType
c_cogl_filter_return_get_type

instance B.Types.BoxedEnum FilterReturn

-- Enum DepthTestFunction
-- | When using depth testing one of these functions is used to compare
-- the depth of an incoming fragment against the depth value currently
-- stored in the depth buffer. The function is changed using
-- @/cogl_depth_state_set_test_function()/@.
-- 
-- The test is only done when depth testing is explicitly enabled. (See
-- @/cogl_depth_state_set_test_enabled()/@)
data DepthTestFunction = 
      DepthTestFunctionNever
    -- ^ Never passes.
    | DepthTestFunctionLess
    -- ^ Passes if the fragment\'s depth
    -- value is less than the value currently in the depth buffer.
    | DepthTestFunctionEqual
    -- ^ Passes if the fragment\'s depth
    -- value is equal to the value currently in the depth buffer.
    | DepthTestFunctionLequal
    -- ^ Passes if the fragment\'s depth
    -- value is less or equal to the value currently in the depth buffer.
    | DepthTestFunctionGreater
    -- ^ Passes if the fragment\'s depth
    -- value is greater than the value currently in the depth buffer.
    | DepthTestFunctionNotequal
    -- ^ Passes if the fragment\'s depth
    -- value is not equal to the value currently in the depth buffer.
    | DepthTestFunctionGequal
    -- ^ Passes if the fragment\'s depth
    -- value greater than or equal to the value currently in the depth buffer.
    | DepthTestFunctionAlways
    -- ^ Always passes.
    | AnotherDepthTestFunction Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DepthTestFunction -> ShowS
[DepthTestFunction] -> ShowS
DepthTestFunction -> String
(Int -> DepthTestFunction -> ShowS)
-> (DepthTestFunction -> String)
-> ([DepthTestFunction] -> ShowS)
-> Show DepthTestFunction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DepthTestFunction -> ShowS
showsPrec :: Int -> DepthTestFunction -> ShowS
$cshow :: DepthTestFunction -> String
show :: DepthTestFunction -> String
$cshowList :: [DepthTestFunction] -> ShowS
showList :: [DepthTestFunction] -> ShowS
Show, DepthTestFunction -> DepthTestFunction -> Bool
(DepthTestFunction -> DepthTestFunction -> Bool)
-> (DepthTestFunction -> DepthTestFunction -> Bool)
-> Eq DepthTestFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DepthTestFunction -> DepthTestFunction -> Bool
== :: DepthTestFunction -> DepthTestFunction -> Bool
$c/= :: DepthTestFunction -> DepthTestFunction -> Bool
/= :: DepthTestFunction -> DepthTestFunction -> Bool
Eq)

instance P.Enum DepthTestFunction where
    fromEnum :: DepthTestFunction -> Int
fromEnum DepthTestFunction
DepthTestFunctionNever = Int
512
    fromEnum DepthTestFunction
DepthTestFunctionLess = Int
513
    fromEnum DepthTestFunction
DepthTestFunctionEqual = Int
514
    fromEnum DepthTestFunction
DepthTestFunctionLequal = Int
515
    fromEnum DepthTestFunction
DepthTestFunctionGreater = Int
516
    fromEnum DepthTestFunction
DepthTestFunctionNotequal = Int
517
    fromEnum DepthTestFunction
DepthTestFunctionGequal = Int
518
    fromEnum DepthTestFunction
DepthTestFunctionAlways = Int
519
    fromEnum (AnotherDepthTestFunction Int
k) = Int
k

    toEnum :: Int -> DepthTestFunction
toEnum Int
512 = DepthTestFunction
DepthTestFunctionNever
    toEnum Int
513 = DepthTestFunction
DepthTestFunctionLess
    toEnum Int
514 = DepthTestFunction
DepthTestFunctionEqual
    toEnum Int
515 = DepthTestFunction
DepthTestFunctionLequal
    toEnum Int
516 = DepthTestFunction
DepthTestFunctionGreater
    toEnum Int
517 = DepthTestFunction
DepthTestFunctionNotequal
    toEnum Int
518 = DepthTestFunction
DepthTestFunctionGequal
    toEnum Int
519 = DepthTestFunction
DepthTestFunctionAlways
    toEnum Int
k = Int -> DepthTestFunction
AnotherDepthTestFunction Int
k

instance P.Ord DepthTestFunction where
    compare :: DepthTestFunction -> DepthTestFunction -> Ordering
compare DepthTestFunction
a DepthTestFunction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DepthTestFunction -> Int
forall a. Enum a => a -> Int
P.fromEnum DepthTestFunction
a) (DepthTestFunction -> Int
forall a. Enum a => a -> Int
P.fromEnum DepthTestFunction
b)

type instance O.ParentTypes DepthTestFunction = '[]
instance O.HasParentTypes DepthTestFunction

foreign import ccall "cogl_depth_test_function_get_type" c_cogl_depth_test_function_get_type :: 
    IO GType

instance B.Types.TypedObject DepthTestFunction where
    glibType :: IO GType
glibType = IO GType
c_cogl_depth_test_function_get_type

instance B.Types.BoxedEnum DepthTestFunction

-- Enum BlendStringError
-- | Error enumeration for the blend strings parser
-- 
-- /Since: 1.0/
data BlendStringError = 
      BlendStringErrorParseError
    -- ^ Generic parse error
    | BlendStringErrorArgumentParseError
    -- ^ Argument parse error
    | BlendStringErrorInvalidError
    -- ^ Internal parser error
    | BlendStringErrorGpuUnsupportedError
    -- ^ Blend string not
    --   supported by the GPU
    | AnotherBlendStringError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BlendStringError -> ShowS
[BlendStringError] -> ShowS
BlendStringError -> String
(Int -> BlendStringError -> ShowS)
-> (BlendStringError -> String)
-> ([BlendStringError] -> ShowS)
-> Show BlendStringError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BlendStringError -> ShowS
showsPrec :: Int -> BlendStringError -> ShowS
$cshow :: BlendStringError -> String
show :: BlendStringError -> String
$cshowList :: [BlendStringError] -> ShowS
showList :: [BlendStringError] -> ShowS
Show, BlendStringError -> BlendStringError -> Bool
(BlendStringError -> BlendStringError -> Bool)
-> (BlendStringError -> BlendStringError -> Bool)
-> Eq BlendStringError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlendStringError -> BlendStringError -> Bool
== :: BlendStringError -> BlendStringError -> Bool
$c/= :: BlendStringError -> BlendStringError -> Bool
/= :: BlendStringError -> BlendStringError -> Bool
Eq)

instance P.Enum BlendStringError where
    fromEnum :: BlendStringError -> Int
fromEnum BlendStringError
BlendStringErrorParseError = Int
0
    fromEnum BlendStringError
BlendStringErrorArgumentParseError = Int
1
    fromEnum BlendStringError
BlendStringErrorInvalidError = Int
2
    fromEnum BlendStringError
BlendStringErrorGpuUnsupportedError = Int
3
    fromEnum (AnotherBlendStringError Int
k) = Int
k

    toEnum :: Int -> BlendStringError
toEnum Int
0 = BlendStringError
BlendStringErrorParseError
    toEnum Int
1 = BlendStringError
BlendStringErrorArgumentParseError
    toEnum Int
2 = BlendStringError
BlendStringErrorInvalidError
    toEnum Int
3 = BlendStringError
BlendStringErrorGpuUnsupportedError
    toEnum Int
k = Int -> BlendStringError
AnotherBlendStringError Int
k

instance P.Ord BlendStringError where
    compare :: BlendStringError -> BlendStringError -> Ordering
compare BlendStringError
a BlendStringError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BlendStringError -> Int
forall a. Enum a => a -> Int
P.fromEnum BlendStringError
a) (BlendStringError -> Int
forall a. Enum a => a -> Int
P.fromEnum BlendStringError
b)

type instance O.ParentTypes BlendStringError = '[]
instance O.HasParentTypes BlendStringError

foreign import ccall "cogl_blend_string_error_get_type" c_cogl_blend_string_error_get_type :: 
    IO GType

instance B.Types.TypedObject BlendStringError where
    glibType :: IO GType
glibType = IO GType
c_cogl_blend_string_error_get_type

instance B.Types.BoxedEnum BlendStringError

-- Enum BitmapError
-- | Error codes that can be thrown when performing bitmap
-- operations. Note that @/gdk_pixbuf_new_from_file()/@ can also throw
-- errors directly from the underlying image loading library. For
-- example, if GdkPixbuf is used then errors @/GdkPixbufError/@s
-- will be used directly.
-- 
-- /Since: 1.4/
data BitmapError = 
      BitmapErrorFailed
    -- ^ Generic failure code, something went
    --   wrong.
    | BitmapErrorUnknownType
    -- ^ Unknown image type.
    | BitmapErrorCorruptImage
    -- ^ An image file was broken somehow.
    | AnotherBitmapError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BitmapError -> ShowS
[BitmapError] -> ShowS
BitmapError -> String
(Int -> BitmapError -> ShowS)
-> (BitmapError -> String)
-> ([BitmapError] -> ShowS)
-> Show BitmapError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BitmapError -> ShowS
showsPrec :: Int -> BitmapError -> ShowS
$cshow :: BitmapError -> String
show :: BitmapError -> String
$cshowList :: [BitmapError] -> ShowS
showList :: [BitmapError] -> ShowS
Show, BitmapError -> BitmapError -> Bool
(BitmapError -> BitmapError -> Bool)
-> (BitmapError -> BitmapError -> Bool) -> Eq BitmapError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BitmapError -> BitmapError -> Bool
== :: BitmapError -> BitmapError -> Bool
$c/= :: BitmapError -> BitmapError -> Bool
/= :: BitmapError -> BitmapError -> Bool
Eq)

instance P.Enum BitmapError where
    fromEnum :: BitmapError -> Int
fromEnum BitmapError
BitmapErrorFailed = Int
0
    fromEnum BitmapError
BitmapErrorUnknownType = Int
1
    fromEnum BitmapError
BitmapErrorCorruptImage = Int
2
    fromEnum (AnotherBitmapError Int
k) = Int
k

    toEnum :: Int -> BitmapError
toEnum Int
0 = BitmapError
BitmapErrorFailed
    toEnum Int
1 = BitmapError
BitmapErrorUnknownType
    toEnum Int
2 = BitmapError
BitmapErrorCorruptImage
    toEnum Int
k = Int -> BitmapError
AnotherBitmapError Int
k

instance P.Ord BitmapError where
    compare :: BitmapError -> BitmapError -> Ordering
compare BitmapError
a BitmapError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BitmapError -> Int
forall a. Enum a => a -> Int
P.fromEnum BitmapError
a) (BitmapError -> Int
forall a. Enum a => a -> Int
P.fromEnum BitmapError
b)

type instance O.ParentTypes BitmapError = '[]
instance O.HasParentTypes BitmapError

foreign import ccall "cogl_bitmap_error_get_type" c_cogl_bitmap_error_get_type :: 
    IO GType

instance B.Types.TypedObject BitmapError where
    glibType :: IO GType
glibType = IO GType
c_cogl_bitmap_error_get_type

instance B.Types.BoxedEnum BitmapError

-- Enum AttributeType
-- | Data types for the components of a vertex attribute.
-- 
-- /Since: 1.0/
data AttributeType = 
      AttributeTypeByte
    -- ^ Data is the same size of a byte
    | AttributeTypeUnsignedByte
    -- ^ Data is the same size of an
    --   unsigned byte
    | AttributeTypeShort
    -- ^ Data is the same size of a short integer
    | AttributeTypeUnsignedShort
    -- ^ Data is the same size of
    --   an unsigned short integer
    | AttributeTypeFloat
    -- ^ Data is the same size of a float
    | AnotherAttributeType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AttributeType -> ShowS
[AttributeType] -> ShowS
AttributeType -> String
(Int -> AttributeType -> ShowS)
-> (AttributeType -> String)
-> ([AttributeType] -> ShowS)
-> Show AttributeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AttributeType -> ShowS
showsPrec :: Int -> AttributeType -> ShowS
$cshow :: AttributeType -> String
show :: AttributeType -> String
$cshowList :: [AttributeType] -> ShowS
showList :: [AttributeType] -> ShowS
Show, AttributeType -> AttributeType -> Bool
(AttributeType -> AttributeType -> Bool)
-> (AttributeType -> AttributeType -> Bool) -> Eq AttributeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AttributeType -> AttributeType -> Bool
== :: AttributeType -> AttributeType -> Bool
$c/= :: AttributeType -> AttributeType -> Bool
/= :: AttributeType -> AttributeType -> Bool
Eq)

instance P.Enum AttributeType where
    fromEnum :: AttributeType -> Int
fromEnum AttributeType
AttributeTypeByte = Int
5120
    fromEnum AttributeType
AttributeTypeUnsignedByte = Int
5121
    fromEnum AttributeType
AttributeTypeShort = Int
5122
    fromEnum AttributeType
AttributeTypeUnsignedShort = Int
5123
    fromEnum AttributeType
AttributeTypeFloat = Int
5126
    fromEnum (AnotherAttributeType Int
k) = Int
k

    toEnum :: Int -> AttributeType
toEnum Int
5120 = AttributeType
AttributeTypeByte
    toEnum Int
5121 = AttributeType
AttributeTypeUnsignedByte
    toEnum Int
5122 = AttributeType
AttributeTypeShort
    toEnum Int
5123 = AttributeType
AttributeTypeUnsignedShort
    toEnum Int
5126 = AttributeType
AttributeTypeFloat
    toEnum Int
k = Int -> AttributeType
AnotherAttributeType Int
k

instance P.Ord AttributeType where
    compare :: AttributeType -> AttributeType -> Ordering
compare AttributeType
a AttributeType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AttributeType -> Int
forall a. Enum a => a -> Int
P.fromEnum AttributeType
a) (AttributeType -> Int
forall a. Enum a => a -> Int
P.fromEnum AttributeType
b)

type instance O.ParentTypes AttributeType = '[]
instance O.HasParentTypes AttributeType

foreign import ccall "cogl_attribute_type_get_type" c_cogl_attribute_type_get_type :: 
    IO GType

instance B.Types.TypedObject AttributeType where
    glibType :: IO GType
glibType = IO GType
c_cogl_attribute_type_get_type

instance B.Types.BoxedEnum AttributeType