{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Used to specify vertex information when calling 'GI.Cogl.Functions.polygon'

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

module GI.Cogl.Structs.TextureVertex
    ( 

-- * Exported types
    TextureVertex(..)                       ,
    newZeroTextureVertex                    ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveTextureVertexMethod              ,
#endif



 -- * Properties


-- ** color #attr:color#
-- | The color to use at this vertex. This is ignored if
--   use_color is 'P.False' when calling 'GI.Cogl.Functions.polygon'

    getTextureVertexColor                   ,
#if defined(ENABLE_OVERLOADING)
    textureVertex_color                     ,
#endif


-- ** tx #attr:tx#
-- | Texture x-coordinate

    getTextureVertexTx                      ,
    setTextureVertexTx                      ,
#if defined(ENABLE_OVERLOADING)
    textureVertex_tx                        ,
#endif


-- ** ty #attr:ty#
-- | Texture y-coordinate

    getTextureVertexTy                      ,
    setTextureVertexTy                      ,
#if defined(ENABLE_OVERLOADING)
    textureVertex_ty                        ,
#endif


-- ** x #attr:x#
-- | Model x-coordinate

    getTextureVertexX                       ,
    setTextureVertexX                       ,
#if defined(ENABLE_OVERLOADING)
    textureVertex_x                         ,
#endif


-- ** y #attr:y#
-- | Model y-coordinate

    getTextureVertexY                       ,
    setTextureVertexY                       ,
#if defined(ENABLE_OVERLOADING)
    textureVertex_y                         ,
#endif


-- ** z #attr:z#
-- | Model z-coordinate

    getTextureVertexZ                       ,
    setTextureVertexZ                       ,
#if defined(ENABLE_OVERLOADING)
    textureVertex_z                         ,
#endif




    ) 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.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

import {-# SOURCE #-} qualified GI.Cogl.Structs.Color as Cogl.Color

-- | Memory-managed wrapper type.
newtype TextureVertex = TextureVertex (SP.ManagedPtr TextureVertex)
    deriving (TextureVertex -> TextureVertex -> Bool
(TextureVertex -> TextureVertex -> Bool)
-> (TextureVertex -> TextureVertex -> Bool) -> Eq TextureVertex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextureVertex -> TextureVertex -> Bool
== :: TextureVertex -> TextureVertex -> Bool
$c/= :: TextureVertex -> TextureVertex -> Bool
/= :: TextureVertex -> TextureVertex -> Bool
Eq)

instance SP.ManagedPtrNewtype TextureVertex where
    toManagedPtr :: TextureVertex -> ManagedPtr TextureVertex
toManagedPtr (TextureVertex ManagedPtr TextureVertex
p) = ManagedPtr TextureVertex
p

instance BoxedPtr TextureVertex where
    boxedPtrCopy :: TextureVertex -> IO TextureVertex
boxedPtrCopy = \TextureVertex
p -> TextureVertex
-> (Ptr TextureVertex -> IO TextureVertex) -> IO TextureVertex
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TextureVertex
p (Int -> Ptr TextureVertex -> IO (Ptr TextureVertex)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
36 (Ptr TextureVertex -> IO (Ptr TextureVertex))
-> (Ptr TextureVertex -> IO TextureVertex)
-> Ptr TextureVertex
-> IO TextureVertex
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr TextureVertex -> TextureVertex)
-> Ptr TextureVertex -> IO TextureVertex
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr TextureVertex -> TextureVertex
TextureVertex)
    boxedPtrFree :: TextureVertex -> IO ()
boxedPtrFree = \TextureVertex
x -> TextureVertex -> (Ptr TextureVertex -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr TextureVertex
x Ptr TextureVertex -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr TextureVertex where
    boxedPtrCalloc :: IO (Ptr TextureVertex)
boxedPtrCalloc = Int -> IO (Ptr TextureVertex)
forall a. Int -> IO (Ptr a)
callocBytes Int
36


-- | Construct a `TextureVertex` struct initialized to zero.
newZeroTextureVertex :: MonadIO m => m TextureVertex
newZeroTextureVertex :: forall (m :: * -> *). MonadIO m => m TextureVertex
newZeroTextureVertex = IO TextureVertex -> m TextureVertex
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextureVertex -> m TextureVertex)
-> IO TextureVertex -> m TextureVertex
forall a b. (a -> b) -> a -> b
$ IO (Ptr TextureVertex)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr TextureVertex)
-> (Ptr TextureVertex -> IO TextureVertex) -> IO TextureVertex
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr TextureVertex -> TextureVertex)
-> Ptr TextureVertex -> IO TextureVertex
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr TextureVertex -> TextureVertex
TextureVertex

instance tag ~ 'AttrSet => Constructible TextureVertex tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr TextureVertex -> TextureVertex)
-> [AttrOp TextureVertex tag] -> m TextureVertex
new ManagedPtr TextureVertex -> TextureVertex
_ [AttrOp TextureVertex tag]
attrs = do
        TextureVertex
o <- m TextureVertex
forall (m :: * -> *). MonadIO m => m TextureVertex
newZeroTextureVertex
        TextureVertex -> [AttrOp TextureVertex 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set TextureVertex
o [AttrOp TextureVertex tag]
[AttrOp TextureVertex 'AttrSet]
attrs
        TextureVertex -> m TextureVertex
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return TextureVertex
o


-- | Get the value of the “@x@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' textureVertex #x
-- @
getTextureVertexX :: MonadIO m => TextureVertex -> m Float
getTextureVertexX :: forall (m :: * -> *). MonadIO m => TextureVertex -> m Float
getTextureVertexX TextureVertex
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO Float) -> IO Float)
-> (Ptr TextureVertex -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@x@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' textureVertex [ #x 'Data.GI.Base.Attributes.:=' value ]
-- @
setTextureVertexX :: MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexX :: forall (m :: * -> *). MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexX TextureVertex
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO ()) -> IO ())
-> (Ptr TextureVertex -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data TextureVertexXFieldInfo
instance AttrInfo TextureVertexXFieldInfo where
    type AttrBaseTypeConstraint TextureVertexXFieldInfo = (~) TextureVertex
    type AttrAllowedOps TextureVertexXFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint TextureVertexXFieldInfo = (~) Float
    type AttrTransferTypeConstraint TextureVertexXFieldInfo = (~)Float
    type AttrTransferType TextureVertexXFieldInfo = Float
    type AttrGetType TextureVertexXFieldInfo = Float
    type AttrLabel TextureVertexXFieldInfo = "x"
    type AttrOrigin TextureVertexXFieldInfo = TextureVertex
    attrGet = getTextureVertexX
    attrSet = setTextureVertexX
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Cogl.Structs.TextureVertex.x"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-TextureVertex.html#g:attr:x"
        })

textureVertex_x :: AttrLabelProxy "x"
textureVertex_x = AttrLabelProxy

#endif


-- | Get the value of the “@y@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' textureVertex #y
-- @
getTextureVertexY :: MonadIO m => TextureVertex -> m Float
getTextureVertexY :: forall (m :: * -> *). MonadIO m => TextureVertex -> m Float
getTextureVertexY TextureVertex
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO Float) -> IO Float)
-> (Ptr TextureVertex -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@y@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' textureVertex [ #y 'Data.GI.Base.Attributes.:=' value ]
-- @
setTextureVertexY :: MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexY :: forall (m :: * -> *). MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexY TextureVertex
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO ()) -> IO ())
-> (Ptr TextureVertex -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data TextureVertexYFieldInfo
instance AttrInfo TextureVertexYFieldInfo where
    type AttrBaseTypeConstraint TextureVertexYFieldInfo = (~) TextureVertex
    type AttrAllowedOps TextureVertexYFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint TextureVertexYFieldInfo = (~) Float
    type AttrTransferTypeConstraint TextureVertexYFieldInfo = (~)Float
    type AttrTransferType TextureVertexYFieldInfo = Float
    type AttrGetType TextureVertexYFieldInfo = Float
    type AttrLabel TextureVertexYFieldInfo = "y"
    type AttrOrigin TextureVertexYFieldInfo = TextureVertex
    attrGet = getTextureVertexY
    attrSet = setTextureVertexY
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Cogl.Structs.TextureVertex.y"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-TextureVertex.html#g:attr:y"
        })

textureVertex_y :: AttrLabelProxy "y"
textureVertex_y = AttrLabelProxy

#endif


-- | Get the value of the “@z@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' textureVertex #z
-- @
getTextureVertexZ :: MonadIO m => TextureVertex -> m Float
getTextureVertexZ :: forall (m :: * -> *). MonadIO m => TextureVertex -> m Float
getTextureVertexZ TextureVertex
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO Float) -> IO Float)
-> (Ptr TextureVertex -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@z@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' textureVertex [ #z 'Data.GI.Base.Attributes.:=' value ]
-- @
setTextureVertexZ :: MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexZ :: forall (m :: * -> *). MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexZ TextureVertex
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO ()) -> IO ())
-> (Ptr TextureVertex -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data TextureVertexZFieldInfo
instance AttrInfo TextureVertexZFieldInfo where
    type AttrBaseTypeConstraint TextureVertexZFieldInfo = (~) TextureVertex
    type AttrAllowedOps TextureVertexZFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint TextureVertexZFieldInfo = (~) Float
    type AttrTransferTypeConstraint TextureVertexZFieldInfo = (~)Float
    type AttrTransferType TextureVertexZFieldInfo = Float
    type AttrGetType TextureVertexZFieldInfo = Float
    type AttrLabel TextureVertexZFieldInfo = "z"
    type AttrOrigin TextureVertexZFieldInfo = TextureVertex
    attrGet = getTextureVertexZ
    attrSet = setTextureVertexZ
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Cogl.Structs.TextureVertex.z"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-TextureVertex.html#g:attr:z"
        })

textureVertex_z :: AttrLabelProxy "z"
textureVertex_z = AttrLabelProxy

#endif


-- | Get the value of the “@tx@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' textureVertex #tx
-- @
getTextureVertexTx :: MonadIO m => TextureVertex -> m Float
getTextureVertexTx :: forall (m :: * -> *). MonadIO m => TextureVertex -> m Float
getTextureVertexTx TextureVertex
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO Float) -> IO Float)
-> (Ptr TextureVertex -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@tx@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' textureVertex [ #tx 'Data.GI.Base.Attributes.:=' value ]
-- @
setTextureVertexTx :: MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexTx :: forall (m :: * -> *). MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexTx TextureVertex
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO ()) -> IO ())
-> (Ptr TextureVertex -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data TextureVertexTxFieldInfo
instance AttrInfo TextureVertexTxFieldInfo where
    type AttrBaseTypeConstraint TextureVertexTxFieldInfo = (~) TextureVertex
    type AttrAllowedOps TextureVertexTxFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint TextureVertexTxFieldInfo = (~) Float
    type AttrTransferTypeConstraint TextureVertexTxFieldInfo = (~)Float
    type AttrTransferType TextureVertexTxFieldInfo = Float
    type AttrGetType TextureVertexTxFieldInfo = Float
    type AttrLabel TextureVertexTxFieldInfo = "tx"
    type AttrOrigin TextureVertexTxFieldInfo = TextureVertex
    attrGet = getTextureVertexTx
    attrSet = setTextureVertexTx
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Cogl.Structs.TextureVertex.tx"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-TextureVertex.html#g:attr:tx"
        })

textureVertex_tx :: AttrLabelProxy "tx"
textureVertex_tx = AttrLabelProxy

#endif


-- | Get the value of the “@ty@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' textureVertex #ty
-- @
getTextureVertexTy :: MonadIO m => TextureVertex -> m Float
getTextureVertexTy :: forall (m :: * -> *). MonadIO m => TextureVertex -> m Float
getTextureVertexTy TextureVertex
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO Float) -> IO Float)
-> (Ptr TextureVertex -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@ty@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' textureVertex [ #ty 'Data.GI.Base.Attributes.:=' value ]
-- @
setTextureVertexTy :: MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexTy :: forall (m :: * -> *). MonadIO m => TextureVertex -> Float -> m ()
setTextureVertexTy TextureVertex
s Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO ()) -> IO ())
-> (Ptr TextureVertex -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data TextureVertexTyFieldInfo
instance AttrInfo TextureVertexTyFieldInfo where
    type AttrBaseTypeConstraint TextureVertexTyFieldInfo = (~) TextureVertex
    type AttrAllowedOps TextureVertexTyFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint TextureVertexTyFieldInfo = (~) Float
    type AttrTransferTypeConstraint TextureVertexTyFieldInfo = (~)Float
    type AttrTransferType TextureVertexTyFieldInfo = Float
    type AttrGetType TextureVertexTyFieldInfo = Float
    type AttrLabel TextureVertexTyFieldInfo = "ty"
    type AttrOrigin TextureVertexTyFieldInfo = TextureVertex
    attrGet = getTextureVertexTy
    attrSet = setTextureVertexTy
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Cogl.Structs.TextureVertex.ty"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-TextureVertex.html#g:attr:ty"
        })

textureVertex_ty :: AttrLabelProxy "ty"
textureVertex_ty = AttrLabelProxy

#endif


-- | Get the value of the “@color@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' textureVertex #color
-- @
getTextureVertexColor :: MonadIO m => TextureVertex -> m Cogl.Color.Color
getTextureVertexColor :: forall (m :: * -> *). MonadIO m => TextureVertex -> m Color
getTextureVertexColor TextureVertex
s = IO Color -> m Color
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ TextureVertex -> (Ptr TextureVertex -> IO Color) -> IO Color
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TextureVertex
s ((Ptr TextureVertex -> IO Color) -> IO Color)
-> (Ptr TextureVertex -> IO Color) -> IO Color
forall a b. (a -> b) -> a -> b
$ \Ptr TextureVertex
ptr -> do
    let val :: Ptr Color
val = Ptr TextureVertex
ptr Ptr TextureVertex -> Int -> Ptr Color
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: (Ptr Cogl.Color.Color)
    Color
val' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Color -> Color
Cogl.Color.Color) Ptr Color
val
    Color -> IO Color
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Color
val'

#if defined(ENABLE_OVERLOADING)
data TextureVertexColorFieldInfo
instance AttrInfo TextureVertexColorFieldInfo where
    type AttrBaseTypeConstraint TextureVertexColorFieldInfo = (~) TextureVertex
    type AttrAllowedOps TextureVertexColorFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint TextureVertexColorFieldInfo = (~) (Ptr Cogl.Color.Color)
    type AttrTransferTypeConstraint TextureVertexColorFieldInfo = (~)(Ptr Cogl.Color.Color)
    type AttrTransferType TextureVertexColorFieldInfo = (Ptr Cogl.Color.Color)
    type AttrGetType TextureVertexColorFieldInfo = Cogl.Color.Color
    type AttrLabel TextureVertexColorFieldInfo = "color"
    type AttrOrigin TextureVertexColorFieldInfo = TextureVertex
    attrGet = getTextureVertexColor
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Cogl.Structs.TextureVertex.color"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-TextureVertex.html#g:attr:color"
        })

textureVertex_color :: AttrLabelProxy "color"
textureVertex_color = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TextureVertex
type instance O.AttributeList TextureVertex = TextureVertexAttributeList
type TextureVertexAttributeList = ('[ '("x", TextureVertexXFieldInfo), '("y", TextureVertexYFieldInfo), '("z", TextureVertexZFieldInfo), '("tx", TextureVertexTxFieldInfo), '("ty", TextureVertexTyFieldInfo), '("color", TextureVertexColorFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveTextureVertexMethod (t :: Symbol) (o :: *) :: * where
    ResolveTextureVertexMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTextureVertexMethod t TextureVertex, O.OverloadedMethod info TextureVertex p) => OL.IsLabel t (TextureVertex -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTextureVertexMethod t TextureVertex, O.OverloadedMethod info TextureVertex p, R.HasField t TextureVertex p) => R.HasField t TextureVertex p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveTextureVertexMethod t TextureVertex, O.OverloadedMethodInfo info TextureVertex) => OL.IsLabel t (O.MethodProxy info TextureVertex) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif