{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}

-- | "SDL.Video.Renderer" provides a high-level interface to SDL's accelerated 2D rendering library.

module SDL.Video.Renderer
  ( Renderer

    -- * 'Renderer' Configuration
    -- | These configuration options can be used with 'SDL.Video.createRenderer' to create 'Renderer's.
  , RendererConfig(..)
  , defaultRenderer
  , RendererType(..)

  -- * Drawing Primitives
  , clear
  , copy
  , copyEx
  , drawLine
  , drawLines
  , drawPoint
  , drawPoints
  , drawRect
  , drawRects
  , fillRect
  , fillRects
  , present

  -- * 'Renderer' State
  -- | SDL exposes a stateful interface to 'Renderer's - the above primitives drawing routines will change their
  -- output depending on the value of these state variables.
  , rendererDrawBlendMode
  , rendererDrawColor
  , rendererRenderTarget
  , rendererClipRect
  , rendererLogicalSize
  , rendererScale
  , rendererViewport
  , renderTargetSupported

  -- * 'Surface's
  , Surface(..)
  , updateWindowSurface
  , surfaceBlit
  , surfaceBlitScaled
  , surfaceFillRect
  , surfaceFillRects

  -- ** Creating and Destroying 'Surface's
  , convertSurface
  , createRGBSurface
  , createRGBSurfaceFrom
  , freeSurface
  , getWindowSurface
  , loadBMP

  -- ** 'Surface' state
  , surfaceColorKey
  , surfaceBlendMode
  , surfaceDimensions
  , surfaceFormat
  , surfacePixels

  -- ** Accessing 'Surface' Data
  , lockSurface
  , unlockSurface

  -- * 'Palette's and pixel formats
  , Palette
  , paletteNColors
  , paletteColors
  , paletteColor
  , PixelFormat(..)
  , SurfacePixelFormat
  , formatPalette
  , setPaletteColors
  , pixelFormatToMasks
  , masksToPixelFormat

  -- * Textures
  , Texture

  -- ** Creating, Using and Destroying 'Texture's
  , createTexture
  , TextureAccess(..)
  , createTextureFromSurface
  , updateTexture
  , destroyTexture
  , glBindTexture
  , glUnbindTexture

  -- ** 'Texture' State
  , textureAlphaMod
  , textureBlendMode
  , BlendMode(..)
  , textureColorMod

  -- ** Accessing 'Texture' Data
  , lockTexture
  , unlockTexture
  , queryTexture
  , TextureInfo(..)

  , Rectangle(..)

  -- * Available 'Renderer's
  -- | These functions allow you to query the current system for available 'Renderer's that can be created
  -- with 'SDL.Video.createRenderer'.
  , getRendererInfo
  , RendererInfo(..)
  , getRenderDriverInfo
  ) where

import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Exception (catch, throw, SomeException, uninterruptibleMask_)
import Data.Bits
import Data.Data (Data)
import Data.Foldable
import Data.StateVar
import Data.Text (Text)
import Data.Typeable
import Data.Word
import Foreign.C.String
import Foreign.C.Types
import Foreign.ForeignPtr
import Foreign.Marshal.Alloc
import Foreign.Marshal.Utils
import Foreign.Ptr
import Foreign.Storable
import GHC.Generics (Generic)
import Prelude hiding (foldr)
import SDL.Vect
import SDL.Internal.Exception
import SDL.Internal.Numbered
import SDL.Internal.Types
import qualified Data.ByteString as BS
import qualified Data.ByteString.Internal as BSI
import qualified Data.Text.Encoding as Text
import qualified Data.Vector.Storable as SV
import qualified Data.Vector.Storable.Mutable as MSV
import qualified SDL.Raw as Raw

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative
import Data.Traversable
#endif

-- | Perform a fast surface copy to a destination surface.
--
-- See @<https://wiki.libsdl.org/SDL_BlitSurface SDL_BlitSurface>@ for C documentation.
surfaceBlit :: MonadIO m
            => Surface -- ^ The 'Surface' to be copied from
            -> Maybe (Rectangle CInt) -- ^ The rectangle to be copied, or 'Nothing' to copy the entire surface
            -> Surface -- ^ The 'Surface' that is the blit target
            -> Maybe (Point V2 CInt) -- ^ The position to blit to
            -> m (Maybe (Rectangle CInt))
surfaceBlit :: Surface
-> Maybe (Rectangle CInt)
-> Surface
-> Maybe (Point V2 CInt)
-> m (Maybe (Rectangle CInt))
surfaceBlit (Surface src :: Ptr Surface
src _) srcRect :: Maybe (Rectangle CInt)
srcRect (Surface dst :: Ptr Surface
dst _) dstLoc :: Maybe (Point V2 CInt)
dstLoc = IO (Maybe (Rectangle CInt)) -> m (Maybe (Rectangle CInt))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Rectangle CInt)) -> m (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt)) -> m (Maybe (Rectangle CInt))
forall a b. (a -> b) -> a -> b
$
  (Rectangle CInt
 -> (Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
 -> IO (Maybe (Rectangle CInt)))
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt
-> (Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
srcRect ((Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
 -> IO (Maybe (Rectangle CInt)))
-> (Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b. (a -> b) -> a -> b
$ \srcPtr :: Ptr (Rectangle CInt)
srcPtr ->
  (Rectangle CInt
 -> (Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
 -> IO (Maybe (Rectangle CInt)))
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt
-> (Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ((Point V2 CInt -> Rectangle CInt)
-> Maybe (Point V2 CInt) -> Maybe (Rectangle CInt)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Point V2 CInt -> V2 CInt -> Rectangle CInt)
-> V2 CInt -> Point V2 CInt -> Rectangle CInt
forall a b c. (a -> b -> c) -> b -> a -> c
flip Point V2 CInt -> V2 CInt -> Rectangle CInt
forall a. Point V2 a -> V2 a -> Rectangle a
Rectangle 0) Maybe (Point V2 CInt)
dstLoc) ((Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
 -> IO (Maybe (Rectangle CInt)))
-> (Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b. (a -> b) -> a -> b
$ \dstPtr :: Ptr (Rectangle CInt)
dstPtr -> do
      CInt
_ <- Text -> Text -> IO CInt -> IO CInt
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m a
throwIfNeg "SDL.Video.blitSurface" "SDL_BlitSurface" (IO CInt -> IO CInt) -> IO CInt -> IO CInt
forall a b. (a -> b) -> a -> b
$
           Ptr Surface -> Ptr Rect -> Ptr Surface -> Ptr Rect -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> Ptr Rect -> Ptr Surface -> Ptr Rect -> m CInt
Raw.blitSurface Ptr Surface
src (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
srcPtr) Ptr Surface
dst (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
dstPtr)
      IO (Maybe (Rectangle CInt))
-> (Point V2 CInt -> IO (Maybe (Rectangle CInt)))
-> Maybe (Point V2 CInt)
-> IO (Maybe (Rectangle CInt))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe (Rectangle CInt) -> IO (Maybe (Rectangle CInt))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Rectangle CInt)
forall a. Maybe a
Nothing) (\_ -> Rectangle CInt -> Maybe (Rectangle CInt)
forall a. a -> Maybe a
Just (Rectangle CInt -> Maybe (Rectangle CInt))
-> IO (Rectangle CInt) -> IO (Maybe (Rectangle CInt))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr (Rectangle CInt) -> IO (Rectangle CInt)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Rectangle CInt)
dstPtr) Maybe (Point V2 CInt)
dstLoc

-- | Create a texture for a rendering context.
--
-- See @<https://wiki.libsdl.org/SDL_CreateTexture SDL_CreateTexture>@ for C documentation.
createTexture :: (Functor m,MonadIO m)
              => Renderer -- ^ The rendering context.
              -> PixelFormat
              -> TextureAccess
              -> V2 CInt -- ^ The size of the texture.
              -> m Texture
createTexture :: Renderer -> PixelFormat -> TextureAccess -> V2 CInt -> m Texture
createTexture (Renderer r :: Renderer
r) fmt :: PixelFormat
fmt access :: TextureAccess
access (V2 w :: CInt
w h :: CInt
h) =
  (Renderer -> Texture) -> m Renderer -> m Texture
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Renderer -> Texture
Texture (m Renderer -> m Texture) -> m Renderer -> m Texture
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> m Renderer -> m Renderer
forall (m :: * -> *) a.
MonadIO m =>
Text -> Text -> m (Ptr a) -> m (Ptr a)
throwIfNull "SDL.Video.Renderer.createTexture" "SDL_CreateTexture" (m Renderer -> m Renderer) -> m Renderer -> m Renderer
forall a b. (a -> b) -> a -> b
$
  Renderer -> Word32 -> CInt -> CInt -> CInt -> m Renderer
forall (m :: * -> *).
MonadIO m =>
Renderer -> Word32 -> CInt -> CInt -> CInt -> m Renderer
Raw.createTexture Renderer
r (PixelFormat -> Word32
forall a b. ToNumber a b => a -> b
toNumber PixelFormat
fmt) (TextureAccess -> CInt
forall a b. ToNumber a b => a -> b
toNumber TextureAccess
access) CInt
w CInt
h

-- | Create a texture from an existing surface.
--
-- See @<https://wiki.libsdl.org/SDL_CreateTextureFromSurface SDL_CreateTextureFromSurface>@ for C documentation.
createTextureFromSurface :: (Functor m,MonadIO m)
                         => Renderer -- ^ The rendering context
                         -> Surface -- ^ The surface containing pixel data used to fill the texture
                         -> m Texture
createTextureFromSurface :: Renderer -> Surface -> m Texture
createTextureFromSurface (Renderer r :: Renderer
r) (Surface s :: Ptr Surface
s _) =
  (Renderer -> Texture) -> m Renderer -> m Texture
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Renderer -> Texture
Texture (m Renderer -> m Texture) -> m Renderer -> m Texture
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> m Renderer -> m Renderer
forall (m :: * -> *) a.
MonadIO m =>
Text -> Text -> m (Ptr a) -> m (Ptr a)
throwIfNull "SDL.Video.createTextureFromSurface" "SDL_CreateTextureFromSurface" (m Renderer -> m Renderer) -> m Renderer -> m Renderer
forall a b. (a -> b) -> a -> b
$
  Renderer -> Ptr Surface -> m Renderer
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr Surface -> m Renderer
Raw.createTextureFromSurface Renderer
r Ptr Surface
s

-- | Bind an OpenGL\/ES\/ES2 texture to the current context for use with when rendering OpenGL primitives directly.
--
-- See @<https://wiki.libsdl.org/SDL_GL_BindTexture SDL_GL_BindTexture>@ for C documentation.
glBindTexture :: (Functor m,MonadIO m)
              => Texture -- ^ The texture to bind to the current OpenGL\/ES\/ES2 context
              -> m ()
glBindTexture :: Texture -> m ()
glBindTexture (Texture t :: Renderer
t) =
  Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.glBindTexture" "SDL_GL_BindTexture" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
  Renderer -> Ptr CFloat -> Ptr CFloat -> m CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr CFloat -> Ptr CFloat -> m CInt
Raw.glBindTexture Renderer
t Ptr CFloat
forall a. Ptr a
nullPtr Ptr CFloat
forall a. Ptr a
nullPtr

-- | Unbind an OpenGL\/ES\/ES2 texture from the current context.
--
-- See @<https://wiki.libsdl.org/SDL_GL_UnbindTexture SDL_GL_UnbindTexture>@ for C documentation.
glUnbindTexture :: (Functor m,MonadIO m)
                => Texture -- ^ The texture to unbind from the current OpenGL\/ES\/ES2 context
                -> m ()
glUnbindTexture :: Texture -> m ()
glUnbindTexture (Texture t :: Renderer
t) =
  Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.glUnindTexture" "SDL_GL_UnbindTexture" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
  Renderer -> m CInt
forall (m :: * -> *). MonadIO m => Renderer -> m CInt
Raw.glUnbindTexture Renderer
t

-- | Updates texture rectangle with new pixel data.
--
-- See @<https://wiki.libsdl.org/SDL_UpdateTexture SDL_UpdateTexture>@ for C documentation.
updateTexture :: (Functor m, MonadIO m)
              => Texture -- ^ The 'Texture' to be updated
              -> Maybe (Rectangle CInt) -- ^ The area to update, Nothing for entire texture
              -> BS.ByteString -- ^ The raw pixel data
              -> CInt -- ^ The number of bytes in a row of pixel data, including padding between lines
              -> m Texture
updateTexture :: Texture
-> Maybe (Rectangle CInt) -> ByteString -> CInt -> m Texture
updateTexture tex :: Texture
tex@(Texture t :: Renderer
t) rect :: Maybe (Rectangle CInt)
rect pixels :: ByteString
pixels pitch :: CInt
pitch = do
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.updateTexture" "SDL_UpdateTexture" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
    (Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
rect ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \rectPtr :: Ptr (Rectangle CInt)
rectPtr ->
      let (pixelForeign :: ForeignPtr Word8
pixelForeign, _, _) = ByteString -> (ForeignPtr Word8, Int, Int)
BSI.toForeignPtr ByteString
pixels
      in ForeignPtr Word8 -> (Ptr Word8 -> IO CInt) -> IO CInt
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Word8
pixelForeign ((Ptr Word8 -> IO CInt) -> IO CInt)
-> (Ptr Word8 -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \pixelsPtr :: Ptr Word8
pixelsPtr ->
        Renderer -> Ptr Rect -> Renderer -> CInt -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr Rect -> Renderer -> CInt -> m CInt
Raw.updateTexture Renderer
t (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
rectPtr) (Ptr Word8 -> Renderer
forall a b. Ptr a -> Ptr b
castPtr Ptr Word8
pixelsPtr) CInt
pitch
  Texture -> m Texture
forall (m :: * -> *) a. Monad m => a -> m a
return Texture
tex

-- | Destroy the specified texture.
--
-- See @<https://wiki.libsdl.org/SDL_DestroyTexture SDL_DestroyTexture>@ for the C documentation.
destroyTexture :: MonadIO m => Texture -> m ()
destroyTexture :: Texture -> m ()
destroyTexture (Texture t :: Renderer
t) = Renderer -> m ()
forall (m :: * -> *). MonadIO m => Renderer -> m ()
Raw.destroyTexture Renderer
t

-- | Lock a portion of the texture for *write-only* pixel access.
--
-- See @<https://wiki.libsdl.org/SDL_LockTexture SDL_LockTexture>@ for C documentation.
lockTexture :: MonadIO m
            => Texture -- ^ The 'Texture' to lock for access, which must have been created with 'TextureAccessStreaming'
            -> Maybe (Rectangle CInt) -- ^ The area to lock for access; 'Nothing' to lock the entire texture
            -> m (Ptr (),CInt) -- ^ A pointer to the locked pixels, appropriately offset by the locked area, and the pitch of the locked pixels (the pitch is the length of one row in bytes).
lockTexture :: Texture -> Maybe (Rectangle CInt) -> m (Renderer, CInt)
lockTexture (Texture t :: Renderer
t) rect :: Maybe (Rectangle CInt)
rect = IO (Renderer, CInt) -> m (Renderer, CInt)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Renderer, CInt) -> m (Renderer, CInt))
-> IO (Renderer, CInt) -> m (Renderer, CInt)
forall a b. (a -> b) -> a -> b
$
  (Ptr Renderer -> IO (Renderer, CInt)) -> IO (Renderer, CInt)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Renderer -> IO (Renderer, CInt)) -> IO (Renderer, CInt))
-> (Ptr Renderer -> IO (Renderer, CInt)) -> IO (Renderer, CInt)
forall a b. (a -> b) -> a -> b
$ \pixelsPtr :: Ptr Renderer
pixelsPtr ->
  (Ptr CInt -> IO (Renderer, CInt)) -> IO (Renderer, CInt)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CInt -> IO (Renderer, CInt)) -> IO (Renderer, CInt))
-> (Ptr CInt -> IO (Renderer, CInt)) -> IO (Renderer, CInt)
forall a b. (a -> b) -> a -> b
$ \pitchPtr :: Ptr CInt
pitchPtr ->
  (Rectangle CInt
 -> (Ptr (Rectangle CInt) -> IO (Renderer, CInt))
 -> IO (Renderer, CInt))
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO (Renderer, CInt))
-> IO (Renderer, CInt)
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt
-> (Ptr (Rectangle CInt) -> IO (Renderer, CInt))
-> IO (Renderer, CInt)
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
rect ((Ptr (Rectangle CInt) -> IO (Renderer, CInt))
 -> IO (Renderer, CInt))
-> (Ptr (Rectangle CInt) -> IO (Renderer, CInt))
-> IO (Renderer, CInt)
forall a b. (a -> b) -> a -> b
$ \rectPtr :: Ptr (Rectangle CInt)
rectPtr -> do
    Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "lockTexture" "SDL_LockTexture" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
      Renderer -> Ptr Rect -> Ptr Renderer -> Ptr CInt -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr Rect -> Ptr Renderer -> Ptr CInt -> m CInt
Raw.lockTexture Renderer
t (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
rectPtr) Ptr Renderer
pixelsPtr Ptr CInt
pitchPtr
    Renderer
pixels <- Ptr Renderer -> IO Renderer
forall a. Storable a => Ptr a -> IO a
peek Ptr Renderer
pixelsPtr
    CInt
pitch <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
pitchPtr
    (Renderer, CInt) -> IO (Renderer, CInt)
forall (m :: * -> *) a. Monad m => a -> m a
return (Renderer
pixels, CInt
pitch)

-- | Unlock a texture, uploading the changes to video memory, if needed.
--
-- /Warning/: See <https://bugzilla.libsdl.org/show_bug.cgi?id=1586 Bug No. 1586> before using this function!
--
-- See @<https://wiki.libsdl.org/SDL_UnlockTexture SDL_UnlockTexture>@ for C documentation.
unlockTexture :: MonadIO m => Texture -> m ()
unlockTexture :: Texture -> m ()
unlockTexture (Texture t :: Renderer
t) = Renderer -> m ()
forall (m :: * -> *). MonadIO m => Renderer -> m ()
Raw.unlockTexture Renderer
t

-- | Set up a surface for directly accessing the pixels.
--
-- See @<https://wiki.libsdl.org/SDL_LockSurface SDL_LockSurface>@ for C documentation.
lockSurface :: MonadIO m => Surface -> m ()
lockSurface :: Surface -> m ()
lockSurface (Surface s :: Ptr Surface
s _) =
  Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "lockSurface" "SDL_LockSurface" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
    Ptr Surface -> m CInt
forall (m :: * -> *). MonadIO m => Ptr Surface -> m CInt
Raw.lockSurface Ptr Surface
s

-- | Release a surface after directly accessing the pixels.
--
-- See @<https://wiki.libsdl.org/SDL_UnlockSurface SDL_UnlockSurface>@ for C documentation.
unlockSurface :: MonadIO m => Surface -> m ()
unlockSurface :: Surface -> m ()
unlockSurface (Surface s :: Ptr Surface
s _) = Ptr Surface -> m ()
forall (m :: * -> *). MonadIO m => Ptr Surface -> m ()
Raw.unlockSurface Ptr Surface
s

-- | Information to the GPU about how you will use a texture.
data TextureAccess
  = TextureAccessStatic
    -- ^ Changes rarely, cannot be locked
  | TextureAccessStreaming
    -- ^ changes frequently, can be locked
  | TextureAccessTarget
    -- ^ Can be used as a render target
  deriving (TextureAccess
TextureAccess -> TextureAccess -> Bounded TextureAccess
forall a. a -> a -> Bounded a
maxBound :: TextureAccess
$cmaxBound :: TextureAccess
minBound :: TextureAccess
$cminBound :: TextureAccess
Bounded, Typeable TextureAccess
DataType
Constr
Typeable TextureAccess =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TextureAccess -> c TextureAccess)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TextureAccess)
-> (TextureAccess -> Constr)
-> (TextureAccess -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TextureAccess))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TextureAccess))
-> ((forall b. Data b => b -> b) -> TextureAccess -> TextureAccess)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TextureAccess -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TextureAccess -> r)
-> (forall u. (forall d. Data d => d -> u) -> TextureAccess -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TextureAccess -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess)
-> Data TextureAccess
TextureAccess -> DataType
TextureAccess -> Constr
(forall b. Data b => b -> b) -> TextureAccess -> TextureAccess
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TextureAccess -> c TextureAccess
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TextureAccess
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TextureAccess -> u
forall u. (forall d. Data d => d -> u) -> TextureAccess -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TextureAccess -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TextureAccess -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TextureAccess
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TextureAccess -> c TextureAccess
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TextureAccess)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TextureAccess)
$cTextureAccessTarget :: Constr
$cTextureAccessStreaming :: Constr
$cTextureAccessStatic :: Constr
$tTextureAccess :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess
gmapMp :: (forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess
gmapM :: (forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TextureAccess -> m TextureAccess
gmapQi :: Int -> (forall d. Data d => d -> u) -> TextureAccess -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TextureAccess -> u
gmapQ :: (forall d. Data d => d -> u) -> TextureAccess -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TextureAccess -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TextureAccess -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TextureAccess -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TextureAccess -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TextureAccess -> r
gmapT :: (forall b. Data b => b -> b) -> TextureAccess -> TextureAccess
$cgmapT :: (forall b. Data b => b -> b) -> TextureAccess -> TextureAccess
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TextureAccess)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TextureAccess)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TextureAccess)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TextureAccess)
dataTypeOf :: TextureAccess -> DataType
$cdataTypeOf :: TextureAccess -> DataType
toConstr :: TextureAccess -> Constr
$ctoConstr :: TextureAccess -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TextureAccess
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TextureAccess
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TextureAccess -> c TextureAccess
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TextureAccess -> c TextureAccess
$cp1Data :: Typeable TextureAccess
Data, Int -> TextureAccess
TextureAccess -> Int
TextureAccess -> [TextureAccess]
TextureAccess -> TextureAccess
TextureAccess -> TextureAccess -> [TextureAccess]
TextureAccess -> TextureAccess -> TextureAccess -> [TextureAccess]
(TextureAccess -> TextureAccess)
-> (TextureAccess -> TextureAccess)
-> (Int -> TextureAccess)
-> (TextureAccess -> Int)
-> (TextureAccess -> [TextureAccess])
-> (TextureAccess -> TextureAccess -> [TextureAccess])
-> (TextureAccess -> TextureAccess -> [TextureAccess])
-> (TextureAccess
    -> TextureAccess -> TextureAccess -> [TextureAccess])
-> Enum TextureAccess
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: TextureAccess -> TextureAccess -> TextureAccess -> [TextureAccess]
$cenumFromThenTo :: TextureAccess -> TextureAccess -> TextureAccess -> [TextureAccess]
enumFromTo :: TextureAccess -> TextureAccess -> [TextureAccess]
$cenumFromTo :: TextureAccess -> TextureAccess -> [TextureAccess]
enumFromThen :: TextureAccess -> TextureAccess -> [TextureAccess]
$cenumFromThen :: TextureAccess -> TextureAccess -> [TextureAccess]
enumFrom :: TextureAccess -> [TextureAccess]
$cenumFrom :: TextureAccess -> [TextureAccess]
fromEnum :: TextureAccess -> Int
$cfromEnum :: TextureAccess -> Int
toEnum :: Int -> TextureAccess
$ctoEnum :: Int -> TextureAccess
pred :: TextureAccess -> TextureAccess
$cpred :: TextureAccess -> TextureAccess
succ :: TextureAccess -> TextureAccess
$csucc :: TextureAccess -> TextureAccess
Enum, TextureAccess -> TextureAccess -> Bool
(TextureAccess -> TextureAccess -> Bool)
-> (TextureAccess -> TextureAccess -> Bool) -> Eq TextureAccess
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextureAccess -> TextureAccess -> Bool
$c/= :: TextureAccess -> TextureAccess -> Bool
== :: TextureAccess -> TextureAccess -> Bool
$c== :: TextureAccess -> TextureAccess -> Bool
Eq, (forall x. TextureAccess -> Rep TextureAccess x)
-> (forall x. Rep TextureAccess x -> TextureAccess)
-> Generic TextureAccess
forall x. Rep TextureAccess x -> TextureAccess
forall x. TextureAccess -> Rep TextureAccess x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TextureAccess x -> TextureAccess
$cfrom :: forall x. TextureAccess -> Rep TextureAccess x
Generic, Eq TextureAccess
Eq TextureAccess =>
(TextureAccess -> TextureAccess -> Ordering)
-> (TextureAccess -> TextureAccess -> Bool)
-> (TextureAccess -> TextureAccess -> Bool)
-> (TextureAccess -> TextureAccess -> Bool)
-> (TextureAccess -> TextureAccess -> Bool)
-> (TextureAccess -> TextureAccess -> TextureAccess)
-> (TextureAccess -> TextureAccess -> TextureAccess)
-> Ord TextureAccess
TextureAccess -> TextureAccess -> Bool
TextureAccess -> TextureAccess -> Ordering
TextureAccess -> TextureAccess -> TextureAccess
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TextureAccess -> TextureAccess -> TextureAccess
$cmin :: TextureAccess -> TextureAccess -> TextureAccess
max :: TextureAccess -> TextureAccess -> TextureAccess
$cmax :: TextureAccess -> TextureAccess -> TextureAccess
>= :: TextureAccess -> TextureAccess -> Bool
$c>= :: TextureAccess -> TextureAccess -> Bool
> :: TextureAccess -> TextureAccess -> Bool
$c> :: TextureAccess -> TextureAccess -> Bool
<= :: TextureAccess -> TextureAccess -> Bool
$c<= :: TextureAccess -> TextureAccess -> Bool
< :: TextureAccess -> TextureAccess -> Bool
$c< :: TextureAccess -> TextureAccess -> Bool
compare :: TextureAccess -> TextureAccess -> Ordering
$ccompare :: TextureAccess -> TextureAccess -> Ordering
$cp1Ord :: Eq TextureAccess
Ord, ReadPrec [TextureAccess]
ReadPrec TextureAccess
Int -> ReadS TextureAccess
ReadS [TextureAccess]
(Int -> ReadS TextureAccess)
-> ReadS [TextureAccess]
-> ReadPrec TextureAccess
-> ReadPrec [TextureAccess]
-> Read TextureAccess
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TextureAccess]
$creadListPrec :: ReadPrec [TextureAccess]
readPrec :: ReadPrec TextureAccess
$creadPrec :: ReadPrec TextureAccess
readList :: ReadS [TextureAccess]
$creadList :: ReadS [TextureAccess]
readsPrec :: Int -> ReadS TextureAccess
$creadsPrec :: Int -> ReadS TextureAccess
Read, Int -> TextureAccess -> ShowS
[TextureAccess] -> ShowS
TextureAccess -> String
(Int -> TextureAccess -> ShowS)
-> (TextureAccess -> String)
-> ([TextureAccess] -> ShowS)
-> Show TextureAccess
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextureAccess] -> ShowS
$cshowList :: [TextureAccess] -> ShowS
show :: TextureAccess -> String
$cshow :: TextureAccess -> String
showsPrec :: Int -> TextureAccess -> ShowS
$cshowsPrec :: Int -> TextureAccess -> ShowS
Show, Typeable)

instance FromNumber TextureAccess CInt where
  fromNumber :: CInt -> TextureAccess
fromNumber n' :: CInt
n' = case CInt
n' of
    Raw.SDL_TEXTUREACCESS_STATIC -> TextureAccess
TextureAccessStatic
    Raw.SDL_TEXTUREACCESS_STREAMING -> TextureAccess
TextureAccessStreaming
    Raw.SDL_TEXTUREACCESS_TARGET -> TextureAccess
TextureAccessTarget
    _ -> String -> TextureAccess
forall a. HasCallStack => String -> a
error "Unknown value"

instance ToNumber TextureAccess CInt where
  toNumber :: TextureAccess -> CInt
toNumber t :: TextureAccess
t = case TextureAccess
t of
    TextureAccessStatic -> CInt
forall a. (Eq a, Num a) => a
Raw.SDL_TEXTUREACCESS_STATIC
    TextureAccessStreaming -> CInt
forall a. (Eq a, Num a) => a
Raw.SDL_TEXTUREACCESS_STREAMING
    TextureAccessTarget -> CInt
forall a. (Eq a, Num a) => a
Raw.SDL_TEXTUREACCESS_TARGET

data TextureInfo = TextureInfo
  { TextureInfo -> PixelFormat
texturePixelFormat :: PixelFormat
    -- ^ Raw format of the texture; the actual format may differ, but pixel transfers will use this format
  , TextureInfo -> TextureAccess
textureAccess      :: TextureAccess
    -- ^ The access available to the texture
  , TextureInfo -> CInt
textureWidth       :: CInt
    -- ^ The width of the texture
  , TextureInfo -> CInt
textureHeight      :: CInt
    -- ^ The height of the texture
  } deriving (TextureInfo -> TextureInfo -> Bool
(TextureInfo -> TextureInfo -> Bool)
-> (TextureInfo -> TextureInfo -> Bool) -> Eq TextureInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextureInfo -> TextureInfo -> Bool
$c/= :: TextureInfo -> TextureInfo -> Bool
== :: TextureInfo -> TextureInfo -> Bool
$c== :: TextureInfo -> TextureInfo -> Bool
Eq, (forall x. TextureInfo -> Rep TextureInfo x)
-> (forall x. Rep TextureInfo x -> TextureInfo)
-> Generic TextureInfo
forall x. Rep TextureInfo x -> TextureInfo
forall x. TextureInfo -> Rep TextureInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TextureInfo x -> TextureInfo
$cfrom :: forall x. TextureInfo -> Rep TextureInfo x
Generic, Eq TextureInfo
Eq TextureInfo =>
(TextureInfo -> TextureInfo -> Ordering)
-> (TextureInfo -> TextureInfo -> Bool)
-> (TextureInfo -> TextureInfo -> Bool)
-> (TextureInfo -> TextureInfo -> Bool)
-> (TextureInfo -> TextureInfo -> Bool)
-> (TextureInfo -> TextureInfo -> TextureInfo)
-> (TextureInfo -> TextureInfo -> TextureInfo)
-> Ord TextureInfo
TextureInfo -> TextureInfo -> Bool
TextureInfo -> TextureInfo -> Ordering
TextureInfo -> TextureInfo -> TextureInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TextureInfo -> TextureInfo -> TextureInfo
$cmin :: TextureInfo -> TextureInfo -> TextureInfo
max :: TextureInfo -> TextureInfo -> TextureInfo
$cmax :: TextureInfo -> TextureInfo -> TextureInfo
>= :: TextureInfo -> TextureInfo -> Bool
$c>= :: TextureInfo -> TextureInfo -> Bool
> :: TextureInfo -> TextureInfo -> Bool
$c> :: TextureInfo -> TextureInfo -> Bool
<= :: TextureInfo -> TextureInfo -> Bool
$c<= :: TextureInfo -> TextureInfo -> Bool
< :: TextureInfo -> TextureInfo -> Bool
$c< :: TextureInfo -> TextureInfo -> Bool
compare :: TextureInfo -> TextureInfo -> Ordering
$ccompare :: TextureInfo -> TextureInfo -> Ordering
$cp1Ord :: Eq TextureInfo
Ord, ReadPrec [TextureInfo]
ReadPrec TextureInfo
Int -> ReadS TextureInfo
ReadS [TextureInfo]
(Int -> ReadS TextureInfo)
-> ReadS [TextureInfo]
-> ReadPrec TextureInfo
-> ReadPrec [TextureInfo]
-> Read TextureInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TextureInfo]
$creadListPrec :: ReadPrec [TextureInfo]
readPrec :: ReadPrec TextureInfo
$creadPrec :: ReadPrec TextureInfo
readList :: ReadS [TextureInfo]
$creadList :: ReadS [TextureInfo]
readsPrec :: Int -> ReadS TextureInfo
$creadsPrec :: Int -> ReadS TextureInfo
Read, Int -> TextureInfo -> ShowS
[TextureInfo] -> ShowS
TextureInfo -> String
(Int -> TextureInfo -> ShowS)
-> (TextureInfo -> String)
-> ([TextureInfo] -> ShowS)
-> Show TextureInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextureInfo] -> ShowS
$cshowList :: [TextureInfo] -> ShowS
show :: TextureInfo -> String
$cshow :: TextureInfo -> String
showsPrec :: Int -> TextureInfo -> ShowS
$cshowsPrec :: Int -> TextureInfo -> ShowS
Show, Typeable)

-- | Query the attributes of a texture.
--
-- See @<https://wiki.libsdl.org/SDL_QueryTexture SDL_QueryTexture>@ for C documentation.
queryTexture :: MonadIO m => Texture -> m TextureInfo
queryTexture :: Texture -> m TextureInfo
queryTexture (Texture tex :: Renderer
tex) = IO TextureInfo -> m TextureInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextureInfo -> m TextureInfo)
-> IO TextureInfo -> m TextureInfo
forall a b. (a -> b) -> a -> b
$
  (Ptr Word32 -> IO TextureInfo) -> IO TextureInfo
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO TextureInfo) -> IO TextureInfo)
-> (Ptr Word32 -> IO TextureInfo) -> IO TextureInfo
forall a b. (a -> b) -> a -> b
$ \pfPtr :: Ptr Word32
pfPtr ->
  (Ptr CInt -> IO TextureInfo) -> IO TextureInfo
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CInt -> IO TextureInfo) -> IO TextureInfo)
-> (Ptr CInt -> IO TextureInfo) -> IO TextureInfo
forall a b. (a -> b) -> a -> b
$ \acPtr :: Ptr CInt
acPtr ->
  (Ptr CInt -> IO TextureInfo) -> IO TextureInfo
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CInt -> IO TextureInfo) -> IO TextureInfo)
-> (Ptr CInt -> IO TextureInfo) -> IO TextureInfo
forall a b. (a -> b) -> a -> b
$ \wPtr :: Ptr CInt
wPtr ->
  (Ptr CInt -> IO TextureInfo) -> IO TextureInfo
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CInt -> IO TextureInfo) -> IO TextureInfo)
-> (Ptr CInt -> IO TextureInfo) -> IO TextureInfo
forall a b. (a -> b) -> a -> b
$ \hPtr :: Ptr CInt
hPtr -> do
    Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.queryTexture" "SDL_QueryTexture" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
      Renderer
-> Ptr Word32 -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer
-> Ptr Word32 -> Ptr CInt -> Ptr CInt -> Ptr CInt -> m CInt
Raw.queryTexture Renderer
tex Ptr Word32
pfPtr Ptr CInt
acPtr Ptr CInt
wPtr Ptr CInt
hPtr
    PixelFormat -> TextureAccess -> CInt -> CInt -> TextureInfo
TextureInfo (PixelFormat -> TextureAccess -> CInt -> CInt -> TextureInfo)
-> IO PixelFormat
-> IO (TextureAccess -> CInt -> CInt -> TextureInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
      (Word32 -> PixelFormat) -> IO Word32 -> IO PixelFormat
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word32 -> PixelFormat
forall a b. FromNumber a b => b -> a
fromNumber (Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
pfPtr) IO (TextureAccess -> CInt -> CInt -> TextureInfo)
-> IO TextureAccess -> IO (CInt -> CInt -> TextureInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
      (CInt -> TextureAccess) -> IO CInt -> IO TextureAccess
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CInt -> TextureAccess
forall a b. FromNumber a b => b -> a
fromNumber (Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
acPtr) IO (CInt -> CInt -> TextureInfo)
-> IO CInt -> IO (CInt -> TextureInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
      Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
wPtr IO (CInt -> TextureInfo) -> IO CInt -> IO TextureInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
      Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
hPtr

-- | Allocate a new RGB surface.
--
-- See @<https://wiki.libsdl.org/SDL_CreateRGBSurface SDL_CreateRGBSurface>@ for C documentation.
createRGBSurface :: (Functor m, MonadIO m)
                 => V2 CInt -- ^ The size of the surface
                 -> PixelFormat -- ^ The bit depth, red, green, blue and alpha mask for the pixels
                 -> m Surface
createRGBSurface :: V2 CInt -> PixelFormat -> m Surface
createRGBSurface (V2 w :: CInt
w h :: CInt
h) pf :: PixelFormat
pf =
  (Ptr Surface -> Surface) -> m (Ptr Surface) -> m Surface
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Surface -> Surface
unmanagedSurface (m (Ptr Surface) -> m Surface) -> m (Ptr Surface) -> m Surface
forall a b. (a -> b) -> a -> b
$
    Text -> Text -> m (Ptr Surface) -> m (Ptr Surface)
forall (m :: * -> *) a.
MonadIO m =>
Text -> Text -> m (Ptr a) -> m (Ptr a)
throwIfNull "SDL.Video.createRGBSurface" "SDL_CreateRGBSurface" (m (Ptr Surface) -> m (Ptr Surface))
-> m (Ptr Surface) -> m (Ptr Surface)
forall a b. (a -> b) -> a -> b
$ do
      (bpp :: CInt
bpp, V4 r :: Word32
r g :: Word32
g b :: Word32
b a :: Word32
a) <- PixelFormat -> m (CInt, V4 Word32)
forall (m :: * -> *).
MonadIO m =>
PixelFormat -> m (CInt, V4 Word32)
pixelFormatToMasks PixelFormat
pf
      Word32
-> CInt
-> CInt
-> CInt
-> Word32
-> Word32
-> Word32
-> Word32
-> m (Ptr Surface)
forall (m :: * -> *).
MonadIO m =>
Word32
-> CInt
-> CInt
-> CInt
-> Word32
-> Word32
-> Word32
-> Word32
-> m (Ptr Surface)
Raw.createRGBSurface 0 CInt
w CInt
h CInt
bpp Word32
r Word32
g Word32
b Word32
a

-- | Allocate a new RGB surface with existing pixel data.
--
-- See @<https://wiki.libsdl.org/SDL_CreateRGBSurfaceFrom SDL_CreateRGBSurfaceFrom>@ for C documentation.
createRGBSurfaceFrom :: (Functor m, MonadIO m)
                     => MSV.IOVector Word8 -- ^ The existing pixel data
                     -> V2 CInt -- ^ The size of the surface
                     -> CInt -- ^ The pitch - the length of a row of pixels in bytes
                     -> PixelFormat -- ^ The bit depth, red, green, blue and alpha mask for the pixels
                     -> m Surface
createRGBSurfaceFrom :: IOVector Word8 -> V2 CInt -> CInt -> PixelFormat -> m Surface
createRGBSurfaceFrom pixels :: IOVector Word8
pixels (V2 w :: CInt
w h :: CInt
h) p :: CInt
p pf :: PixelFormat
pf = IO Surface -> m Surface
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Surface -> m Surface) -> IO Surface -> m Surface
forall a b. (a -> b) -> a -> b
$
  (Ptr Surface -> Surface) -> IO (Ptr Surface) -> IO Surface
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (IOVector Word8 -> Ptr Surface -> Surface
managedSurface IOVector Word8
pixels) (IO (Ptr Surface) -> IO Surface) -> IO (Ptr Surface) -> IO Surface
forall a b. (a -> b) -> a -> b
$
    Text -> Text -> IO (Ptr Surface) -> IO (Ptr Surface)
forall (m :: * -> *) a.
MonadIO m =>
Text -> Text -> m (Ptr a) -> m (Ptr a)
throwIfNull "SDL.Video.createRGBSurfaceFrom" "SDL_CreateRGBSurfaceFrom" (IO (Ptr Surface) -> IO (Ptr Surface))
-> IO (Ptr Surface) -> IO (Ptr Surface)
forall a b. (a -> b) -> a -> b
$ do
      (bpp :: CInt
bpp, V4 r :: Word32
r g :: Word32
g b :: Word32
b a :: Word32
a) <- PixelFormat -> IO (CInt, V4 Word32)
forall (m :: * -> *).
MonadIO m =>
PixelFormat -> m (CInt, V4 Word32)
pixelFormatToMasks PixelFormat
pf
      IOVector Word8
-> (Ptr Word8 -> IO (Ptr Surface)) -> IO (Ptr Surface)
forall a b. Storable a => IOVector a -> (Ptr a -> IO b) -> IO b
MSV.unsafeWith IOVector Word8
pixels ((Ptr Word8 -> IO (Ptr Surface)) -> IO (Ptr Surface))
-> (Ptr Word8 -> IO (Ptr Surface)) -> IO (Ptr Surface)
forall a b. (a -> b) -> a -> b
$ \pixelPtr :: Ptr Word8
pixelPtr ->
        Renderer
-> CInt
-> CInt
-> CInt
-> CInt
-> Word32
-> Word32
-> Word32
-> Word32
-> IO (Ptr Surface)
forall (m :: * -> *).
MonadIO m =>
Renderer
-> CInt
-> CInt
-> CInt
-> CInt
-> Word32
-> Word32
-> Word32
-> Word32
-> m (Ptr Surface)
Raw.createRGBSurfaceFrom (Ptr Word8 -> Renderer
forall a b. Ptr a -> Ptr b
castPtr Ptr Word8
pixelPtr) CInt
w CInt
h CInt
bpp CInt
p Word32
r Word32
g Word32
b Word32
a

-- | Perform a fast fill of a rectangle with a specific color.
--
-- If there is a clip rectangle set on the destination (set via 'clipRect'), then this function will fill based on the intersection of the clip rectangle and the given 'Rectangle'.
--
-- See @<https://wiki.libsdl.org/SDL_FillRect SDL_FillRect>@ for C documentation.
surfaceFillRect :: MonadIO m
                => Surface -- ^ The 'Surface' that is the drawing target.
                -> Maybe (Rectangle CInt) -- ^ The rectangle to fill, or 'Nothing' to fill the entire surface.
                -> V4 Word8 -- ^ The color to fill with. If the color value contains an alpha component then the destination is simply filled with that alpha information, no blending takes place. This colour will be implictly mapped to the closest approximation that matches the surface's pixel format.
                -> m ()
surfaceFillRect :: Surface -> Maybe (Rectangle CInt) -> V4 Word8 -> m ()
surfaceFillRect (Surface s :: Ptr Surface
s _) rect :: Maybe (Rectangle CInt)
rect (V4 r :: Word8
r g :: Word8
g b :: Word8
b a :: Word8
a) = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.fillRect" "SDL_FillRect" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  (Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
rect ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \rectPtr :: Ptr (Rectangle CInt)
rectPtr -> do
    Ptr PixelFormat
format <- Surface -> Ptr PixelFormat
Raw.surfaceFormat (Surface -> Ptr PixelFormat) -> IO Surface -> IO (Ptr PixelFormat)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Surface -> IO Surface
forall a. Storable a => Ptr a -> IO a
peek Ptr Surface
s
    Ptr PixelFormat -> Word8 -> Word8 -> Word8 -> Word8 -> IO Word32
forall (m :: * -> *).
MonadIO m =>
Ptr PixelFormat -> Word8 -> Word8 -> Word8 -> Word8 -> m Word32
Raw.mapRGBA Ptr PixelFormat
format Word8
r Word8
g Word8
b Word8
a IO Word32 -> (Word32 -> IO CInt) -> IO CInt
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ptr Surface -> Ptr Rect -> Word32 -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> Ptr Rect -> Word32 -> m CInt
Raw.fillRect Ptr Surface
s (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
rectPtr)

-- | Perform a fast fill of a set of rectangles with a specific color.
--
-- If there is a clip rectangle set on any of the destinations (set via 'clipRect'), then this function will fill based on the intersection of the clip rectangle and the given 'Rectangle's.
--
-- See @<https://wiki.libsdl.org/SDL_FillRect SDL_FillRects>@ for C documentation.
surfaceFillRects :: MonadIO m
                 => Surface -- ^ The 'Surface' that is the drawing target.
                 -> SV.Vector (Rectangle CInt) -- ^ A 'SV.Vector' of 'Rectangle's to be filled.
                 -> V4 Word8 -- ^ The color to fill with. If the color value contains an alpha component then the destination is simply filled with that alpha information, no blending takes place. This colour will be implictly mapped to the closest approximation that matches the surface's pixel format.
                 -> m ()
surfaceFillRects :: Surface -> Vector (Rectangle CInt) -> V4 Word8 -> m ()
surfaceFillRects (Surface s :: Ptr Surface
s _) rects :: Vector (Rectangle CInt)
rects (V4 r :: Word8
r g :: Word8
g b :: Word8
b a :: Word8
a) = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.fillRects" "SDL_FillRects" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
    Vector (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
SV.unsafeWith Vector (Rectangle CInt)
rects ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \rp :: Ptr (Rectangle CInt)
rp -> do
      Ptr PixelFormat
format <- Surface -> Ptr PixelFormat
Raw.surfaceFormat (Surface -> Ptr PixelFormat) -> IO Surface -> IO (Ptr PixelFormat)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Surface -> IO Surface
forall a. Storable a => Ptr a -> IO a
peek Ptr Surface
s
      Ptr Surface -> Ptr Rect -> CInt -> Word32 -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> Ptr Rect -> CInt -> Word32 -> m CInt
Raw.fillRects Ptr Surface
s
                    (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
rp)
                    (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Vector (Rectangle CInt) -> Int
forall a. Storable a => Vector a -> Int
SV.length Vector (Rectangle CInt)
rects))
                    (Word32 -> IO CInt) -> IO Word32 -> IO CInt
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr PixelFormat -> Word8 -> Word8 -> Word8 -> Word8 -> IO Word32
forall (m :: * -> *).
MonadIO m =>
Ptr PixelFormat -> Word8 -> Word8 -> Word8 -> Word8 -> m Word32
Raw.mapRGBA Ptr PixelFormat
format Word8
r Word8
g Word8
b Word8
a

-- | Free an RGB surface.
--
-- If the surface was created using 'createRGBSurfaceFrom' then the pixel data is not freed.
--
-- See @<https://wiki.libsdl.org/SDL_FreeSurface SDL_FreeSurface>@ for the C documentation.
freeSurface :: MonadIO m => Surface -> m ()
freeSurface :: Surface -> m ()
freeSurface (Surface s :: Ptr Surface
s _) = Ptr Surface -> m ()
forall (m :: * -> *). MonadIO m => Ptr Surface -> m ()
Raw.freeSurface Ptr Surface
s

-- | Load a surface from a BMP file.
--
-- See @<https://wiki.libsdl.org/SDL_LoadBMP SDL_LoadBMP>@ for C documentation.
loadBMP :: MonadIO m => FilePath -> m Surface
loadBMP :: String -> m Surface
loadBMP filePath :: String
filePath = IO Surface -> m Surface
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Surface -> m Surface) -> IO Surface -> m Surface
forall a b. (a -> b) -> a -> b
$
  (Ptr Surface -> Surface) -> IO (Ptr Surface) -> IO Surface
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Surface -> Surface
unmanagedSurface (IO (Ptr Surface) -> IO Surface) -> IO (Ptr Surface) -> IO Surface
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO (Ptr Surface) -> IO (Ptr Surface)
forall (m :: * -> *) a.
MonadIO m =>
Text -> Text -> m (Ptr a) -> m (Ptr a)
throwIfNull "SDL.Video.loadBMP" "SDL_LoadBMP" (IO (Ptr Surface) -> IO (Ptr Surface))
-> IO (Ptr Surface) -> IO (Ptr Surface)
forall a b. (a -> b) -> a -> b
$
  String -> (CString -> IO (Ptr Surface)) -> IO (Ptr Surface)
forall a. String -> (CString -> IO a) -> IO a
withCString String
filePath ((CString -> IO (Ptr Surface)) -> IO (Ptr Surface))
-> (CString -> IO (Ptr Surface)) -> IO (Ptr Surface)
forall a b. (a -> b) -> a -> b
$ CString -> IO (Ptr Surface)
forall (m :: * -> *). MonadIO m => CString -> m (Ptr Surface)
Raw.loadBMP

newtype SurfacePixelFormat = SurfacePixelFormat (Ptr Raw.PixelFormat)
  deriving (SurfacePixelFormat -> SurfacePixelFormat -> Bool
(SurfacePixelFormat -> SurfacePixelFormat -> Bool)
-> (SurfacePixelFormat -> SurfacePixelFormat -> Bool)
-> Eq SurfacePixelFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SurfacePixelFormat -> SurfacePixelFormat -> Bool
$c/= :: SurfacePixelFormat -> SurfacePixelFormat -> Bool
== :: SurfacePixelFormat -> SurfacePixelFormat -> Bool
$c== :: SurfacePixelFormat -> SurfacePixelFormat -> Bool
Eq, Typeable)

-- It's possible we could use unsafePerformIO here, but I'm not
-- sure. surface->{w,h} are immutable, but do we need to guarantee that pointers
-- aren't reused by *different* surfaces.
-- | Retrive the width and height of a 'Surface'.
surfaceDimensions :: MonadIO m => Surface -> m (V2 CInt)
surfaceDimensions :: Surface -> m (V2 CInt)
surfaceDimensions (Surface s :: Ptr Surface
s _) = IO (V2 CInt) -> m (V2 CInt)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (V2 CInt) -> m (V2 CInt)) -> IO (V2 CInt) -> m (V2 CInt)
forall a b. (a -> b) -> a -> b
$ (CInt -> CInt -> V2 CInt
forall a. a -> a -> V2 a
V2 (CInt -> CInt -> V2 CInt)
-> (Surface -> CInt) -> Surface -> CInt -> V2 CInt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Surface -> CInt
Raw.surfaceW (Surface -> CInt -> V2 CInt)
-> (Surface -> CInt) -> Surface -> V2 CInt
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Surface -> CInt
Raw.surfaceH) (Surface -> V2 CInt) -> IO Surface -> IO (V2 CInt)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Surface -> IO Surface
forall a. Storable a => Ptr a -> IO a
peek Ptr Surface
s

-- | Obtain the pointer to the underlying pixels in a surface. You should bracket
-- this call with 'lockSurface' and 'unlockSurface', respectively.
surfacePixels :: MonadIO m => Surface -> m (Ptr ())
surfacePixels :: Surface -> m Renderer
surfacePixels (Surface s :: Ptr Surface
s _) = IO Renderer -> m Renderer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Renderer -> m Renderer) -> IO Renderer -> m Renderer
forall a b. (a -> b) -> a -> b
$ Surface -> Renderer
Raw.surfacePixels (Surface -> Renderer) -> IO Surface -> IO Renderer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Surface -> IO Surface
forall a. Storable a => Ptr a -> IO a
peek Ptr Surface
s

-- It's possible we could use unsafePerformIO here, but I'm not
-- sure. surface->format is immutable, but do we need to guarantee that pointers
-- aren't reused by *different* surfaces?
-- | Inspect the pixel format under a surface.
surfaceFormat :: MonadIO m => Surface -> m SurfacePixelFormat
surfaceFormat :: Surface -> m SurfacePixelFormat
surfaceFormat (Surface s :: Ptr Surface
s _) = IO SurfacePixelFormat -> m SurfacePixelFormat
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SurfacePixelFormat -> m SurfacePixelFormat)
-> IO SurfacePixelFormat -> m SurfacePixelFormat
forall a b. (a -> b) -> a -> b
$ Ptr PixelFormat -> SurfacePixelFormat
SurfacePixelFormat (Ptr PixelFormat -> SurfacePixelFormat)
-> (Surface -> Ptr PixelFormat) -> Surface -> SurfacePixelFormat
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Surface -> Ptr PixelFormat
Raw.surfaceFormat (Surface -> SurfacePixelFormat)
-> IO Surface -> IO SurfacePixelFormat
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Surface -> IO Surface
forall a. Storable a => Ptr a -> IO a
peek Ptr Surface
s

newtype Palette = Palette (Ptr Raw.Palette)
  deriving (Palette -> Palette -> Bool
(Palette -> Palette -> Bool)
-> (Palette -> Palette -> Bool) -> Eq Palette
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Palette -> Palette -> Bool
$c/= :: Palette -> Palette -> Bool
== :: Palette -> Palette -> Bool
$c== :: Palette -> Palette -> Bool
Eq, Typeable)

formatPalette :: MonadIO m => SurfacePixelFormat -> m (Maybe Palette)
formatPalette :: SurfacePixelFormat -> m (Maybe Palette)
formatPalette (SurfacePixelFormat f :: Ptr PixelFormat
f) = IO (Maybe Palette) -> m (Maybe Palette)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Palette) -> m (Maybe Palette))
-> IO (Maybe Palette) -> m (Maybe Palette)
forall a b. (a -> b) -> a -> b
$ Ptr Palette -> Maybe Palette
wrap (Ptr Palette -> Maybe Palette)
-> (PixelFormat -> Ptr Palette) -> PixelFormat -> Maybe Palette
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PixelFormat -> Ptr Palette
Raw.pixelFormatPalette (PixelFormat -> Maybe Palette)
-> IO PixelFormat -> IO (Maybe Palette)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr PixelFormat -> IO PixelFormat
forall a. Storable a => Ptr a -> IO a
peek Ptr PixelFormat
f
  where wrap :: Ptr Palette -> Maybe Palette
wrap p :: Ptr Palette
p
          | Ptr Palette
p Ptr Palette -> Ptr Palette -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Palette
forall a. Ptr a
nullPtr = Maybe Palette
forall a. Maybe a
Nothing
          | Bool
otherwise = Palette -> Maybe Palette
forall a. a -> Maybe a
Just (Ptr Palette -> Palette
Palette Ptr Palette
p)

paletteNColors :: MonadIO m => Palette -> m CInt
paletteNColors :: Palette -> m CInt
paletteNColors (Palette p :: Ptr Palette
p) = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Palette -> CInt
Raw.paletteNColors (Palette -> CInt) -> IO Palette -> IO CInt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Palette -> IO Palette
forall a. Storable a => Ptr a -> IO a
peek Ptr Palette
p

paletteColors :: MonadIO m => Palette -> m (Maybe (SV.Vector (V4 Word8)))
paletteColors :: Palette -> m (Maybe (Vector (V4 Word8)))
paletteColors q :: Palette
q@(Palette p :: Ptr Palette
p) = do
  Int
n <- IO Int -> m Int
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> m Int) -> IO Int -> m Int
forall a b. (a -> b) -> a -> b
$ CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Palette -> IO CInt
forall (m :: * -> *). MonadIO m => Palette -> m CInt
paletteNColors Palette
q
  let wrap :: Ptr a -> Maybe (Ptr a)
wrap p' :: Ptr a
p' | Ptr a
p' Ptr a -> Ptr a -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr a
forall a. Ptr a
nullPtr = Maybe (Ptr a)
forall a. Maybe a
Nothing
              | Bool
otherwise     = Ptr a -> Maybe (Ptr a)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr a
p'
  Maybe (Ptr (V4 Word8))
mv <- IO (Maybe (Ptr (V4 Word8))) -> m (Maybe (Ptr (V4 Word8)))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Ptr (V4 Word8))) -> m (Maybe (Ptr (V4 Word8))))
-> IO (Maybe (Ptr (V4 Word8))) -> m (Maybe (Ptr (V4 Word8)))
forall a b. (a -> b) -> a -> b
$ Ptr (V4 Word8) -> Maybe (Ptr (V4 Word8))
forall a. Ptr a -> Maybe (Ptr a)
wrap (Ptr (V4 Word8) -> Maybe (Ptr (V4 Word8)))
-> (Palette -> Ptr (V4 Word8)) -> Palette -> Maybe (Ptr (V4 Word8))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr Color -> Ptr (V4 Word8)
forall a b. Ptr a -> Ptr b
castPtr (Ptr Color -> Ptr (V4 Word8))
-> (Palette -> Ptr Color) -> Palette -> Ptr (V4 Word8)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Palette -> Ptr Color
Raw.paletteColors (Palette -> Maybe (Ptr (V4 Word8)))
-> IO Palette -> IO (Maybe (Ptr (V4 Word8)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Palette -> IO Palette
forall a. Storable a => Ptr a -> IO a
peek Ptr Palette
p
  Maybe (ForeignPtr (V4 Word8))
mColor <- IO (Maybe (ForeignPtr (V4 Word8)))
-> m (Maybe (ForeignPtr (V4 Word8)))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (ForeignPtr (V4 Word8)))
 -> m (Maybe (ForeignPtr (V4 Word8))))
-> IO (Maybe (ForeignPtr (V4 Word8)))
-> m (Maybe (ForeignPtr (V4 Word8)))
forall a b. (a -> b) -> a -> b
$ (Ptr (V4 Word8) -> IO (ForeignPtr (V4 Word8)))
-> Maybe (Ptr (V4 Word8)) -> IO (Maybe (ForeignPtr (V4 Word8)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Ptr (V4 Word8) -> IO (ForeignPtr (V4 Word8))
forall a. Ptr a -> IO (ForeignPtr a)
newForeignPtr_ Maybe (Ptr (V4 Word8))
mv
  Maybe (Vector (V4 Word8)) -> m (Maybe (Vector (V4 Word8)))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Vector (V4 Word8)) -> m (Maybe (Vector (V4 Word8))))
-> Maybe (Vector (V4 Word8)) -> m (Maybe (Vector (V4 Word8)))
forall a b. (a -> b) -> a -> b
$ (ForeignPtr (V4 Word8) -> Int -> Vector (V4 Word8))
-> Int -> ForeignPtr (V4 Word8) -> Vector (V4 Word8)
forall a b c. (a -> b -> c) -> b -> a -> c
flip ForeignPtr (V4 Word8) -> Int -> Vector (V4 Word8)
forall a. Storable a => ForeignPtr a -> Int -> Vector a
SV.unsafeFromForeignPtr0 Int
n (ForeignPtr (V4 Word8) -> Vector (V4 Word8))
-> Maybe (ForeignPtr (V4 Word8)) -> Maybe (Vector (V4 Word8))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (ForeignPtr (V4 Word8))
mColor

paletteColor :: MonadIO m => Palette -> CInt -> m (Maybe (V4 Word8))
paletteColor :: Palette -> CInt -> m (Maybe (V4 Word8))
paletteColor q :: Palette
q@(Palette p :: Ptr Palette
p) i :: CInt
i = do
    Palette
rp <- IO Palette -> m Palette
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Palette -> m Palette) -> IO Palette -> m Palette
forall a b. (a -> b) -> a -> b
$ Ptr Palette -> IO Palette
forall a. Storable a => Ptr a -> IO a
peek Ptr Palette
p
    CInt
m <- Palette -> m CInt
forall (m :: * -> *). MonadIO m => Palette -> m CInt
paletteNColors Palette
q
    if CInt
m CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
> CInt
i Bool -> Bool -> Bool
&& CInt
i CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
>= 0 then
      IO (Maybe (V4 Word8)) -> m (Maybe (V4 Word8))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (V4 Word8)) -> m (Maybe (V4 Word8)))
-> IO (Maybe (V4 Word8)) -> m (Maybe (V4 Word8))
forall a b. (a -> b) -> a -> b
$ (V4 Word8 -> Maybe (V4 Word8))
-> IO (V4 Word8) -> IO (Maybe (V4 Word8))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap V4 Word8 -> Maybe (V4 Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return (IO (V4 Word8) -> IO (Maybe (V4 Word8)))
-> (Palette -> IO (V4 Word8)) -> Palette -> IO (Maybe (V4 Word8))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Ptr (V4 Word8) -> Int -> IO (V4 Word8))
-> Int -> Ptr (V4 Word8) -> IO (V4 Word8)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Ptr (V4 Word8) -> Int -> IO (V4 Word8)
forall a. Storable a => Ptr a -> Int -> IO a
peekElemOff (CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
i) (Ptr (V4 Word8) -> IO (V4 Word8))
-> (Palette -> Ptr (V4 Word8)) -> Palette -> IO (V4 Word8)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr Color -> Ptr (V4 Word8)
forall a b. Ptr a -> Ptr b
castPtr (Ptr Color -> Ptr (V4 Word8))
-> (Palette -> Ptr Color) -> Palette -> Ptr (V4 Word8)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Palette -> Ptr Color
Raw.paletteColors (Palette -> IO (Maybe (V4 Word8)))
-> Palette -> IO (Maybe (V4 Word8))
forall a b. (a -> b) -> a -> b
$ Palette
rp
    else
      Maybe (V4 Word8) -> m (Maybe (V4 Word8))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (V4 Word8)
forall a. Maybe a
Nothing

-- | Set a range of colors in a palette.
--
-- See @<https://wiki.libsdl.org/SDL_SetPaletteColors SDL_SetPaletteColors>@ for C documentation.
setPaletteColors :: MonadIO m
                 => Palette -- ^ The 'Palette' to modify
                 -> (SV.Vector (V4 Word8)) -- ^ A 'SV.Vector' of colours to copy into the palette
                 -> CInt -- ^ The index of the first palette entry to modify
                 -> m ()
setPaletteColors :: Palette -> Vector (V4 Word8) -> CInt -> m ()
setPaletteColors (Palette p :: Ptr Palette
p) colors :: Vector (V4 Word8)
colors first :: CInt
first = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.setPaletteColors" "SDL_SetPaletteColors" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  Vector (V4 Word8) -> (Ptr (V4 Word8) -> IO CInt) -> IO CInt
forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
SV.unsafeWith Vector (V4 Word8)
colors ((Ptr (V4 Word8) -> IO CInt) -> IO CInt)
-> (Ptr (V4 Word8) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \cp :: Ptr (V4 Word8)
cp ->
    Ptr Palette -> Ptr Color -> CInt -> CInt -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Palette -> Ptr Color -> CInt -> CInt -> m CInt
Raw.setPaletteColors Ptr Palette
p (Ptr (V4 Word8) -> Ptr Color
forall a b. Ptr a -> Ptr b
castPtr Ptr (V4 Word8)
cp) CInt
first CInt
n
  where
    n :: CInt
n = Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> Int -> CInt
forall a b. (a -> b) -> a -> b
$ Vector (V4 Word8) -> Int
forall a. Storable a => Vector a -> Int
SV.length Vector (V4 Word8)
colors

-- | Get the SDL surface associated with the window.
--
-- See @<https://wiki.libsdl.org/SDL_GetWindowSurface SDL_GetWindowSurface>@ for C documentation.
getWindowSurface :: (Functor m, MonadIO m) => Window -> m Surface
getWindowSurface :: Window -> m Surface
getWindowSurface (Window w :: Renderer
w) =
  (Ptr Surface -> Surface) -> m (Ptr Surface) -> m Surface
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Surface -> Surface
unmanagedSurface (m (Ptr Surface) -> m Surface) -> m (Ptr Surface) -> m Surface
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> m (Ptr Surface) -> m (Ptr Surface)
forall (m :: * -> *) a.
MonadIO m =>
Text -> Text -> m (Ptr a) -> m (Ptr a)
throwIfNull "SDL.Video.getWindowSurface" "SDL_GetWindowSurface" (m (Ptr Surface) -> m (Ptr Surface))
-> m (Ptr Surface) -> m (Ptr Surface)
forall a b. (a -> b) -> a -> b
$
  Renderer -> m (Ptr Surface)
forall (m :: * -> *). MonadIO m => Renderer -> m (Ptr Surface)
Raw.getWindowSurface Renderer
w

-- | Get or set the blend mode used for drawing operations (fill and line).
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_SetRenderDrawBlendMode SDL_SetRenderDrawBlendMode>@ and @<https://wiki.libsdl.org/SDL_GetRenderDrawBlendMode SDL_GetRenderDrawBlendMode>@ for C documentation.
rendererDrawBlendMode :: Renderer -> StateVar BlendMode
rendererDrawBlendMode :: Renderer -> StateVar BlendMode
rendererDrawBlendMode (Renderer r :: Renderer
r) = IO BlendMode -> (BlendMode -> IO ()) -> StateVar BlendMode
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO BlendMode
getRenderDrawBlendMode BlendMode -> IO ()
forall (m :: * -> *) a. (MonadIO m, ToNumber a Word32) => a -> m ()
setRenderDrawBlendMode
  where
  getRenderDrawBlendMode :: IO BlendMode
getRenderDrawBlendMode = IO BlendMode -> IO BlendMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BlendMode -> IO BlendMode) -> IO BlendMode -> IO BlendMode
forall a b. (a -> b) -> a -> b
$
    (Ptr Word32 -> IO BlendMode) -> IO BlendMode
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO BlendMode) -> IO BlendMode)
-> (Ptr Word32 -> IO BlendMode) -> IO BlendMode
forall a b. (a -> b) -> a -> b
$ \bmPtr :: Ptr Word32
bmPtr -> do
      Text -> Text -> IO Int -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.getRenderDrawBlendMode" "SDL_GetRenderDrawBlendMode" (IO Int -> IO ()) -> IO Int -> IO ()
forall a b. (a -> b) -> a -> b
$
        Renderer -> Ptr Word32 -> IO Int
forall (m :: * -> *). MonadIO m => Renderer -> Ptr Word32 -> m Int
Raw.getRenderDrawBlendMode Renderer
r Ptr Word32
bmPtr
      Word32 -> BlendMode
forall a b. FromNumber a b => b -> a
fromNumber (Word32 -> BlendMode) -> IO Word32 -> IO BlendMode
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
bmPtr

  setRenderDrawBlendMode :: a -> m ()
setRenderDrawBlendMode bm :: a
bm =
    Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.setRenderDrawBlendMode" "SDL_SetRenderDrawBlendMode" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
    Renderer -> Word32 -> m CInt
forall (m :: * -> *). MonadIO m => Renderer -> Word32 -> m CInt
Raw.setRenderDrawBlendMode Renderer
r (a -> Word32
forall a b. ToNumber a b => a -> b
toNumber a
bm)

-- | Get or set the color used for drawing operations (rect, line and clear).
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_SetRenderDrawColor SDL_SetRenderDrawColor>@ and @<https://wiki.libsdl.org/SDL_GetRenderDrawColor SDL_GetRenderDrawColor>@ for C documentation.
rendererDrawColor :: Renderer -> StateVar (V4 Word8)
rendererDrawColor :: Renderer -> StateVar (V4 Word8)
rendererDrawColor (Renderer re :: Renderer
re) = IO (V4 Word8) -> (V4 Word8 -> IO ()) -> StateVar (V4 Word8)
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (V4 Word8)
getRenderDrawColor V4 Word8 -> IO ()
forall (m :: * -> *). MonadIO m => V4 Word8 -> m ()
setRenderDrawColor
  where
  getRenderDrawColor :: IO (V4 Word8)
getRenderDrawColor = IO (V4 Word8) -> IO (V4 Word8)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (V4 Word8) -> IO (V4 Word8)) -> IO (V4 Word8) -> IO (V4 Word8)
forall a b. (a -> b) -> a -> b
$
    (Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8))
-> (Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8)
forall a b. (a -> b) -> a -> b
$ \r :: Ptr Word8
r ->
    (Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8))
-> (Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8)
forall a b. (a -> b) -> a -> b
$ \g :: Ptr Word8
g ->
    (Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8))
-> (Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8)
forall a b. (a -> b) -> a -> b
$ \b :: Ptr Word8
b ->
    (Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8))
-> (Ptr Word8 -> IO (V4 Word8)) -> IO (V4 Word8)
forall a b. (a -> b) -> a -> b
$ \a :: Ptr Word8
a -> do
      Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.getRenderDrawColor" "SDL_GetRenderDrawColor" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
        Renderer
-> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer
-> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> m CInt
Raw.getRenderDrawColor Renderer
re Ptr Word8
r Ptr Word8
g Ptr Word8
b Ptr Word8
a
      Word8 -> Word8 -> Word8 -> Word8 -> V4 Word8
forall a. a -> a -> a -> a -> V4 a
V4 (Word8 -> Word8 -> Word8 -> Word8 -> V4 Word8)
-> IO Word8 -> IO (Word8 -> Word8 -> Word8 -> V4 Word8)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
r IO (Word8 -> Word8 -> Word8 -> V4 Word8)
-> IO Word8 -> IO (Word8 -> Word8 -> V4 Word8)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
g IO (Word8 -> Word8 -> V4 Word8)
-> IO Word8 -> IO (Word8 -> V4 Word8)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
b IO (Word8 -> V4 Word8) -> IO Word8 -> IO (V4 Word8)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
a

  setRenderDrawColor :: V4 Word8 -> m ()
setRenderDrawColor (V4 r :: Word8
r g :: Word8
g b :: Word8
b a :: Word8
a) =
    Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.setRenderDrawColor" "SDL_SetRenderDrawColor" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
    Renderer -> Word8 -> Word8 -> Word8 -> Word8 -> m CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Word8 -> Word8 -> Word8 -> Word8 -> m CInt
Raw.setRenderDrawColor Renderer
re Word8
r Word8
g Word8
b Word8
a

-- | Copy the window surface to the screen.
--
-- This is the function you use to reflect any changes to the surface on the screen.
--
-- See @<https://wiki.libsdl.org/SDL_UpdateWindowSurface SDL_UpdateWindowSurface>@ for C documentation.
updateWindowSurface :: (Functor m, MonadIO m) => Window -> m ()
updateWindowSurface :: Window -> m ()
updateWindowSurface (Window w :: Renderer
w) =
  Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.updateWindowSurface" "SDL_UpdateWindowSurface" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
    Renderer -> m CInt
forall (m :: * -> *). MonadIO m => Renderer -> m CInt
Raw.updateWindowSurface Renderer
w

-- | Blend modes used in 'copy' and drawing operations.
data BlendMode
  = BlendNone
    -- ^ No blending
  | BlendAlphaBlend
    -- ^ Alpha blending.
    --
    -- @
    -- dstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA))
    -- dstA = srcA + (dstA * (1-srcA))
    -- @
  | BlendAdditive
    -- ^ Additive blending
    --
    -- @
    -- dstRGB = (srcRGB * srcA) + dstRGB
    -- dstA = dstA
    -- @
  | BlendMod
    -- ^ Color modulate
    --
    -- @
    -- dstRGB = srcRGB * dstRGB
    -- dstA = dstA
    --
  deriving (BlendMode
BlendMode -> BlendMode -> Bounded BlendMode
forall a. a -> a -> Bounded a
maxBound :: BlendMode
$cmaxBound :: BlendMode
minBound :: BlendMode
$cminBound :: BlendMode
Bounded, Typeable BlendMode
DataType
Constr
Typeable BlendMode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BlendMode -> c BlendMode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BlendMode)
-> (BlendMode -> Constr)
-> (BlendMode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BlendMode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlendMode))
-> ((forall b. Data b => b -> b) -> BlendMode -> BlendMode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BlendMode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BlendMode -> r)
-> (forall u. (forall d. Data d => d -> u) -> BlendMode -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BlendMode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BlendMode -> m BlendMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlendMode -> m BlendMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlendMode -> m BlendMode)
-> Data BlendMode
BlendMode -> DataType
BlendMode -> Constr
(forall b. Data b => b -> b) -> BlendMode -> BlendMode
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlendMode -> c BlendMode
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlendMode
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BlendMode -> u
forall u. (forall d. Data d => d -> u) -> BlendMode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlendMode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlendMode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlendMode -> m BlendMode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlendMode -> m BlendMode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlendMode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlendMode -> c BlendMode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlendMode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlendMode)
$cBlendMod :: Constr
$cBlendAdditive :: Constr
$cBlendAlphaBlend :: Constr
$cBlendNone :: Constr
$tBlendMode :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BlendMode -> m BlendMode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlendMode -> m BlendMode
gmapMp :: (forall d. Data d => d -> m d) -> BlendMode -> m BlendMode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlendMode -> m BlendMode
gmapM :: (forall d. Data d => d -> m d) -> BlendMode -> m BlendMode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlendMode -> m BlendMode
gmapQi :: Int -> (forall d. Data d => d -> u) -> BlendMode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BlendMode -> u
gmapQ :: (forall d. Data d => d -> u) -> BlendMode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BlendMode -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlendMode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlendMode -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlendMode -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlendMode -> r
gmapT :: (forall b. Data b => b -> b) -> BlendMode -> BlendMode
$cgmapT :: (forall b. Data b => b -> b) -> BlendMode -> BlendMode
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlendMode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlendMode)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BlendMode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlendMode)
dataTypeOf :: BlendMode -> DataType
$cdataTypeOf :: BlendMode -> DataType
toConstr :: BlendMode -> Constr
$ctoConstr :: BlendMode -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlendMode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlendMode
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlendMode -> c BlendMode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlendMode -> c BlendMode
$cp1Data :: Typeable BlendMode
Data, Int -> BlendMode
BlendMode -> Int
BlendMode -> [BlendMode]
BlendMode -> BlendMode
BlendMode -> BlendMode -> [BlendMode]
BlendMode -> BlendMode -> BlendMode -> [BlendMode]
(BlendMode -> BlendMode)
-> (BlendMode -> BlendMode)
-> (Int -> BlendMode)
-> (BlendMode -> Int)
-> (BlendMode -> [BlendMode])
-> (BlendMode -> BlendMode -> [BlendMode])
-> (BlendMode -> BlendMode -> [BlendMode])
-> (BlendMode -> BlendMode -> BlendMode -> [BlendMode])
-> Enum BlendMode
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: BlendMode -> BlendMode -> BlendMode -> [BlendMode]
$cenumFromThenTo :: BlendMode -> BlendMode -> BlendMode -> [BlendMode]
enumFromTo :: BlendMode -> BlendMode -> [BlendMode]
$cenumFromTo :: BlendMode -> BlendMode -> [BlendMode]
enumFromThen :: BlendMode -> BlendMode -> [BlendMode]
$cenumFromThen :: BlendMode -> BlendMode -> [BlendMode]
enumFrom :: BlendMode -> [BlendMode]
$cenumFrom :: BlendMode -> [BlendMode]
fromEnum :: BlendMode -> Int
$cfromEnum :: BlendMode -> Int
toEnum :: Int -> BlendMode
$ctoEnum :: Int -> BlendMode
pred :: BlendMode -> BlendMode
$cpred :: BlendMode -> BlendMode
succ :: BlendMode -> BlendMode
$csucc :: BlendMode -> BlendMode
Enum, BlendMode -> BlendMode -> Bool
(BlendMode -> BlendMode -> Bool)
-> (BlendMode -> BlendMode -> Bool) -> Eq BlendMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BlendMode -> BlendMode -> Bool
$c/= :: BlendMode -> BlendMode -> Bool
== :: BlendMode -> BlendMode -> Bool
$c== :: BlendMode -> BlendMode -> Bool
Eq, (forall x. BlendMode -> Rep BlendMode x)
-> (forall x. Rep BlendMode x -> BlendMode) -> Generic BlendMode
forall x. Rep BlendMode x -> BlendMode
forall x. BlendMode -> Rep BlendMode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BlendMode x -> BlendMode
$cfrom :: forall x. BlendMode -> Rep BlendMode x
Generic, Eq BlendMode
Eq BlendMode =>
(BlendMode -> BlendMode -> Ordering)
-> (BlendMode -> BlendMode -> Bool)
-> (BlendMode -> BlendMode -> Bool)
-> (BlendMode -> BlendMode -> Bool)
-> (BlendMode -> BlendMode -> Bool)
-> (BlendMode -> BlendMode -> BlendMode)
-> (BlendMode -> BlendMode -> BlendMode)
-> Ord BlendMode
BlendMode -> BlendMode -> Bool
BlendMode -> BlendMode -> Ordering
BlendMode -> BlendMode -> BlendMode
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BlendMode -> BlendMode -> BlendMode
$cmin :: BlendMode -> BlendMode -> BlendMode
max :: BlendMode -> BlendMode -> BlendMode
$cmax :: BlendMode -> BlendMode -> BlendMode
>= :: BlendMode -> BlendMode -> Bool
$c>= :: BlendMode -> BlendMode -> Bool
> :: BlendMode -> BlendMode -> Bool
$c> :: BlendMode -> BlendMode -> Bool
<= :: BlendMode -> BlendMode -> Bool
$c<= :: BlendMode -> BlendMode -> Bool
< :: BlendMode -> BlendMode -> Bool
$c< :: BlendMode -> BlendMode -> Bool
compare :: BlendMode -> BlendMode -> Ordering
$ccompare :: BlendMode -> BlendMode -> Ordering
$cp1Ord :: Eq BlendMode
Ord, ReadPrec [BlendMode]
ReadPrec BlendMode
Int -> ReadS BlendMode
ReadS [BlendMode]
(Int -> ReadS BlendMode)
-> ReadS [BlendMode]
-> ReadPrec BlendMode
-> ReadPrec [BlendMode]
-> Read BlendMode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BlendMode]
$creadListPrec :: ReadPrec [BlendMode]
readPrec :: ReadPrec BlendMode
$creadPrec :: ReadPrec BlendMode
readList :: ReadS [BlendMode]
$creadList :: ReadS [BlendMode]
readsPrec :: Int -> ReadS BlendMode
$creadsPrec :: Int -> ReadS BlendMode
Read, Int -> BlendMode -> ShowS
[BlendMode] -> ShowS
BlendMode -> String
(Int -> BlendMode -> ShowS)
-> (BlendMode -> String)
-> ([BlendMode] -> ShowS)
-> Show BlendMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BlendMode] -> ShowS
$cshowList :: [BlendMode] -> ShowS
show :: BlendMode -> String
$cshow :: BlendMode -> String
showsPrec :: Int -> BlendMode -> ShowS
$cshowsPrec :: Int -> BlendMode -> ShowS
Show, Typeable)

instance FromNumber BlendMode Word32 where
  fromNumber :: Word32 -> BlendMode
fromNumber n :: Word32
n = case Word32
n of
    Raw.SDL_BLENDMODE_ADD -> BlendMode
BlendAdditive
    Raw.SDL_BLENDMODE_BLEND -> BlendMode
BlendAlphaBlend
    Raw.SDL_BLENDMODE_NONE -> BlendMode
BlendNone
    Raw.SDL_BLENDMODE_MOD -> BlendMode
BlendMod
    _ -> String -> BlendMode
forall a. HasCallStack => String -> a
error (String -> BlendMode) -> String -> BlendMode
forall a b. (a -> b) -> a -> b
$ "fromNumber<BlendMode>: unknown blend mode: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word32 -> String
forall a. Show a => a -> String
show Word32
n

instance ToNumber BlendMode Word32 where
  toNumber :: BlendMode -> Word32
toNumber BlendNone = Word32
Raw.SDL_BLENDMODE_NONE
  toNumber BlendAlphaBlend = Word32
Raw.SDL_BLENDMODE_BLEND
  toNumber BlendAdditive = Word32
Raw.SDL_BLENDMODE_ADD
  toNumber BlendMod = Word32
Raw.SDL_BLENDMODE_MOD

data Rectangle a = Rectangle (Point V2 a) (V2 a)
  deriving (Rectangle a -> Rectangle a -> Bool
(Rectangle a -> Rectangle a -> Bool)
-> (Rectangle a -> Rectangle a -> Bool) -> Eq (Rectangle a)
forall a. Eq a => Rectangle a -> Rectangle a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Rectangle a -> Rectangle a -> Bool
$c/= :: forall a. Eq a => Rectangle a -> Rectangle a -> Bool
== :: Rectangle a -> Rectangle a -> Bool
$c== :: forall a. Eq a => Rectangle a -> Rectangle a -> Bool
Eq, a -> Rectangle b -> Rectangle a
(a -> b) -> Rectangle a -> Rectangle b
(forall a b. (a -> b) -> Rectangle a -> Rectangle b)
-> (forall a b. a -> Rectangle b -> Rectangle a)
-> Functor Rectangle
forall a b. a -> Rectangle b -> Rectangle a
forall a b. (a -> b) -> Rectangle a -> Rectangle b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Rectangle b -> Rectangle a
$c<$ :: forall a b. a -> Rectangle b -> Rectangle a
fmap :: (a -> b) -> Rectangle a -> Rectangle b
$cfmap :: forall a b. (a -> b) -> Rectangle a -> Rectangle b
Functor, (forall x. Rectangle a -> Rep (Rectangle a) x)
-> (forall x. Rep (Rectangle a) x -> Rectangle a)
-> Generic (Rectangle a)
forall x. Rep (Rectangle a) x -> Rectangle a
forall x. Rectangle a -> Rep (Rectangle a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Rectangle a) x -> Rectangle a
forall a x. Rectangle a -> Rep (Rectangle a) x
$cto :: forall a x. Rep (Rectangle a) x -> Rectangle a
$cfrom :: forall a x. Rectangle a -> Rep (Rectangle a) x
Generic, Eq (Rectangle a)
Eq (Rectangle a) =>
(Rectangle a -> Rectangle a -> Ordering)
-> (Rectangle a -> Rectangle a -> Bool)
-> (Rectangle a -> Rectangle a -> Bool)
-> (Rectangle a -> Rectangle a -> Bool)
-> (Rectangle a -> Rectangle a -> Bool)
-> (Rectangle a -> Rectangle a -> Rectangle a)
-> (Rectangle a -> Rectangle a -> Rectangle a)
-> Ord (Rectangle a)
Rectangle a -> Rectangle a -> Bool
Rectangle a -> Rectangle a -> Ordering
Rectangle a -> Rectangle a -> Rectangle a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Rectangle a)
forall a. Ord a => Rectangle a -> Rectangle a -> Bool
forall a. Ord a => Rectangle a -> Rectangle a -> Ordering
forall a. Ord a => Rectangle a -> Rectangle a -> Rectangle a
min :: Rectangle a -> Rectangle a -> Rectangle a
$cmin :: forall a. Ord a => Rectangle a -> Rectangle a -> Rectangle a
max :: Rectangle a -> Rectangle a -> Rectangle a
$cmax :: forall a. Ord a => Rectangle a -> Rectangle a -> Rectangle a
>= :: Rectangle a -> Rectangle a -> Bool
$c>= :: forall a. Ord a => Rectangle a -> Rectangle a -> Bool
> :: Rectangle a -> Rectangle a -> Bool
$c> :: forall a. Ord a => Rectangle a -> Rectangle a -> Bool
<= :: Rectangle a -> Rectangle a -> Bool
$c<= :: forall a. Ord a => Rectangle a -> Rectangle a -> Bool
< :: Rectangle a -> Rectangle a -> Bool
$c< :: forall a. Ord a => Rectangle a -> Rectangle a -> Bool
compare :: Rectangle a -> Rectangle a -> Ordering
$ccompare :: forall a. Ord a => Rectangle a -> Rectangle a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Rectangle a)
Ord, ReadPrec [Rectangle a]
ReadPrec (Rectangle a)
Int -> ReadS (Rectangle a)
ReadS [Rectangle a]
(Int -> ReadS (Rectangle a))
-> ReadS [Rectangle a]
-> ReadPrec (Rectangle a)
-> ReadPrec [Rectangle a]
-> Read (Rectangle a)
forall a. Read a => ReadPrec [Rectangle a]
forall a. Read a => ReadPrec (Rectangle a)
forall a. Read a => Int -> ReadS (Rectangle a)
forall a. Read a => ReadS [Rectangle a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Rectangle a]
$creadListPrec :: forall a. Read a => ReadPrec [Rectangle a]
readPrec :: ReadPrec (Rectangle a)
$creadPrec :: forall a. Read a => ReadPrec (Rectangle a)
readList :: ReadS [Rectangle a]
$creadList :: forall a. Read a => ReadS [Rectangle a]
readsPrec :: Int -> ReadS (Rectangle a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Rectangle a)
Read, Int -> Rectangle a -> ShowS
[Rectangle a] -> ShowS
Rectangle a -> String
(Int -> Rectangle a -> ShowS)
-> (Rectangle a -> String)
-> ([Rectangle a] -> ShowS)
-> Show (Rectangle a)
forall a. Show a => Int -> Rectangle a -> ShowS
forall a. Show a => [Rectangle a] -> ShowS
forall a. Show a => Rectangle a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Rectangle a] -> ShowS
$cshowList :: forall a. Show a => [Rectangle a] -> ShowS
show :: Rectangle a -> String
$cshow :: forall a. Show a => Rectangle a -> String
showsPrec :: Int -> Rectangle a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Rectangle a -> ShowS
Show, Typeable)

instance Storable a => Storable (Rectangle a) where
  sizeOf :: Rectangle a -> Int
sizeOf ~(Rectangle o :: Point V2 a
o s :: V2 a
s) = Point V2 a -> Int
forall a. Storable a => a -> Int
sizeOf Point V2 a
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ V2 a -> Int
forall a. Storable a => a -> Int
sizeOf V2 a
s
  alignment :: Rectangle a -> Int
alignment _ = 0
  peek :: Ptr (Rectangle a) -> IO (Rectangle a)
peek ptr :: Ptr (Rectangle a)
ptr = do
    Point V2 a
o <- Ptr (Point V2 a) -> IO (Point V2 a)
forall a. Storable a => Ptr a -> IO a
peek (Ptr (Rectangle a) -> Ptr (Point V2 a)
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle a)
ptr)
    V2 a
s <- Ptr (V2 a) -> IO (V2 a)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Any -> Ptr (V2 a)
forall a b. Ptr a -> Ptr b
castPtr (Ptr (Rectangle a)
ptr Ptr (Rectangle a) -> Int -> Ptr Any
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Point V2 a -> Int
forall a. Storable a => a -> Int
sizeOf Point V2 a
o))
    Rectangle a -> IO (Rectangle a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Point V2 a -> V2 a -> Rectangle a
forall a. Point V2 a -> V2 a -> Rectangle a
Rectangle Point V2 a
o V2 a
s)
  poke :: Ptr (Rectangle a) -> Rectangle a -> IO ()
poke ptr :: Ptr (Rectangle a)
ptr (Rectangle o :: Point V2 a
o s :: V2 a
s) = do
    Ptr (Point V2 a) -> Point V2 a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr (Rectangle a) -> Ptr (Point V2 a)
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle a)
ptr) Point V2 a
o
    Ptr (V2 a) -> V2 a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Any -> Ptr (V2 a)
forall a b. Ptr a -> Ptr b
castPtr (Ptr (Rectangle a)
ptr Ptr (Rectangle a) -> Int -> Ptr Any
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Point V2 a -> Int
forall a. Storable a => a -> Int
sizeOf Point V2 a
o)) V2 a
s

data Surface = Surface (Ptr Raw.Surface) (Maybe (MSV.IOVector Word8))
  deriving (Typeable)

unmanagedSurface :: Ptr Raw.Surface -> Surface
unmanagedSurface :: Ptr Surface -> Surface
unmanagedSurface s :: Ptr Surface
s = Ptr Surface -> Maybe (IOVector Word8) -> Surface
Surface Ptr Surface
s Maybe (IOVector Word8)
forall a. Maybe a
Nothing

managedSurface :: MSV.IOVector Word8 -> Ptr Raw.Surface -> Surface
managedSurface :: IOVector Word8 -> Ptr Surface -> Surface
managedSurface p :: IOVector Word8
p s :: Ptr Surface
s = Ptr Surface -> Maybe (IOVector Word8) -> Surface
Surface Ptr Surface
s (IOVector Word8 -> Maybe (IOVector Word8)
forall a. a -> Maybe a
Just IOVector Word8
p)

newtype Texture = Texture Raw.Texture
  deriving (Texture -> Texture -> Bool
(Texture -> Texture -> Bool)
-> (Texture -> Texture -> Bool) -> Eq Texture
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Texture -> Texture -> Bool
$c/= :: Texture -> Texture -> Bool
== :: Texture -> Texture -> Bool
$c== :: Texture -> Texture -> Bool
Eq, Typeable)

-- | Draw a rectangle outline on the current rendering target.
--
-- See @<https://wiki.libsdl.org/SDL_RenderDrawRect SDL_RenderDrawRect>@ for C documentation.
drawRect :: MonadIO m
         => Renderer
         -> Maybe (Rectangle CInt) -- ^ The rectangle outline to draw. 'Nothing' for the entire rendering context.
         -> m ()
drawRect :: Renderer -> Maybe (Rectangle CInt) -> m ()
drawRect (Renderer r :: Renderer
r) rect :: Maybe (Rectangle CInt)
rect = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.drawRect" "SDL_RenderDrawRect" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  (Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
rect (Renderer -> Ptr Rect -> IO CInt
forall (m :: * -> *). MonadIO m => Renderer -> Ptr Rect -> m CInt
Raw.renderDrawRect Renderer
r (Ptr Rect -> IO CInt)
-> (Ptr (Rectangle CInt) -> Ptr Rect)
-> Ptr (Rectangle CInt)
-> IO CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr)

-- | Draw some number of rectangles on the current rendering target.
--
-- See @<https://wiki.libsdl.org/SDL_RenderDrawRects SDL_RenderDrawRects>@ for C documentation.
drawRects :: MonadIO m => Renderer -> SV.Vector (Rectangle CInt) -> m ()
drawRects :: Renderer -> Vector (Rectangle CInt) -> m ()
drawRects (Renderer r :: Renderer
r) rects :: Vector (Rectangle CInt)
rects = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.drawRects" "SDL_RenderDrawRects" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  Vector (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
SV.unsafeWith Vector (Rectangle CInt)
rects ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \rp :: Ptr (Rectangle CInt)
rp ->
    Renderer -> Ptr Rect -> CInt -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr Rect -> CInt -> m CInt
Raw.renderDrawRects Renderer
r
                        (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
rp)
                        (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Vector (Rectangle CInt) -> Int
forall a. Storable a => Vector a -> Int
SV.length Vector (Rectangle CInt)
rects))

-- | Fill a rectangle on the current rendering target with the drawing color.
--
-- See @<https://wiki.libsdl.org/SDL_RenderFillRect SDL_RenderFillRect>@ for C documentation.
fillRect ::
     MonadIO m
  => Renderer
  -> Maybe (Rectangle CInt) -- ^ The rectangle to fill.
  -> m ()
fillRect :: Renderer -> Maybe (Rectangle CInt) -> m ()
fillRect (Renderer r :: Renderer
r) rect :: Maybe (Rectangle CInt)
rect =
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.fillRect" "SDL_RenderFillRect" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  case Maybe (Rectangle CInt)
rect of
    Nothing -> Renderer -> Ptr Rect -> IO CInt
forall (m :: * -> *). MonadIO m => Renderer -> Ptr Rect -> m CInt
Raw.renderFillRect Renderer
r Ptr Rect
forall a. Ptr a
nullPtr
    Just (Rectangle (P (V2 x :: CInt
x y :: CInt
y)) (V2 w :: CInt
w h :: CInt
h)) -> Renderer -> CInt -> CInt -> CInt -> CInt -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> CInt -> CInt -> CInt -> CInt -> m CInt
Raw.renderFillRectEx Renderer
r CInt
x CInt
y CInt
w CInt
h
{-# INLINE fillRect #-}

-- | Fill some number of rectangles on the current rendering target with the drawing color.
--
-- See @<https://wiki.libsdl.org/SDL_RenderFillRects SDL_RenderFillRects>@ for C documentation.
fillRects :: MonadIO m => Renderer -> SV.Vector (Rectangle CInt) -> m ()
fillRects :: Renderer -> Vector (Rectangle CInt) -> m ()
fillRects (Renderer r :: Renderer
r) rects :: Vector (Rectangle CInt)
rects = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.fillRects" "SDL_RenderFillRects" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
    Vector (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
SV.unsafeWith Vector (Rectangle CInt)
rects ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \rp :: Ptr (Rectangle CInt)
rp ->
      Renderer -> Ptr Rect -> CInt -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr Rect -> CInt -> m CInt
Raw.renderFillRects Renderer
r
                          (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
rp)
                          (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Vector (Rectangle CInt) -> Int
forall a. Storable a => Vector a -> Int
SV.length Vector (Rectangle CInt)
rects))

-- | Clear the current rendering target with the drawing color.
--
-- See @<https://wiki.libsdl.org/SDL_RenderClear SDL_RenderClear>@ for C documentation.
clear :: (Functor m, MonadIO m) => Renderer -> m ()
clear :: Renderer -> m ()
clear (Renderer r :: Renderer
r) =
  Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.clear" "SDL_RenderClear" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
  Renderer -> m CInt
forall (m :: * -> *). MonadIO m => Renderer -> m CInt
Raw.renderClear Renderer
r
{-# INLINE clear #-}

-- | Get or set the drawing scale for rendering on the current target.
--
-- The drawing coordinates are scaled by the x\/y scaling factors before they are used by the renderer. This allows resolution independent drawing with a single coordinate system.
--
-- If this results in scaling or subpixel drawing by the rendering backend, it will be handled using the appropriate quality hints. For best results use integer scaling factors.
--
-- See @<https://wiki.libsdl.org/SDL_RenderSetScale SDL_RenderSetScale>@ and @<https://wiki.libsdl.org/SDL_RenderGetScale SDL_RenderGetScale>@ for C documentation.
rendererScale :: Renderer -> StateVar (V2 CFloat)
rendererScale :: Renderer -> StateVar (V2 CFloat)
rendererScale (Renderer r :: Renderer
r) = IO (V2 CFloat) -> (V2 CFloat -> IO ()) -> StateVar (V2 CFloat)
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (V2 CFloat)
renderGetScale V2 CFloat -> IO ()
forall (m :: * -> *). MonadIO m => V2 CFloat -> m ()
renderSetScale
  where
  renderSetScale :: V2 CFloat -> m ()
renderSetScale (V2 x :: CFloat
x y :: CFloat
y) =
    Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.renderSetScale" "SDL_RenderSetScale" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
    Renderer -> CFloat -> CFloat -> m CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> CFloat -> CFloat -> m CInt
Raw.renderSetScale Renderer
r CFloat
x CFloat
y

  renderGetScale :: IO (V2 CFloat)
renderGetScale = IO (V2 CFloat) -> IO (V2 CFloat)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (V2 CFloat) -> IO (V2 CFloat))
-> IO (V2 CFloat) -> IO (V2 CFloat)
forall a b. (a -> b) -> a -> b
$
    (Ptr CFloat -> IO (V2 CFloat)) -> IO (V2 CFloat)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CFloat -> IO (V2 CFloat)) -> IO (V2 CFloat))
-> (Ptr CFloat -> IO (V2 CFloat)) -> IO (V2 CFloat)
forall a b. (a -> b) -> a -> b
$ \w :: Ptr CFloat
w ->
    (Ptr CFloat -> IO (V2 CFloat)) -> IO (V2 CFloat)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CFloat -> IO (V2 CFloat)) -> IO (V2 CFloat))
-> (Ptr CFloat -> IO (V2 CFloat)) -> IO (V2 CFloat)
forall a b. (a -> b) -> a -> b
$ \h :: Ptr CFloat
h -> do
      Renderer -> Ptr CFloat -> Ptr CFloat -> IO ()
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr CFloat -> Ptr CFloat -> m ()
Raw.renderGetScale Renderer
r Ptr CFloat
w Ptr CFloat
h
      CFloat -> CFloat -> V2 CFloat
forall a. a -> a -> V2 a
V2 (CFloat -> CFloat -> V2 CFloat)
-> IO CFloat -> IO (CFloat -> V2 CFloat)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
w IO (CFloat -> V2 CFloat) -> IO CFloat -> IO (V2 CFloat)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
h

-- | Get or set the clip rectangle for rendering on the specified target.
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_RenderSetClipRect SDL_RenderSetClipRect>@ and @<https://wiki.libsdl.org/SDL_RenderGetClipRect SDL_RenderGetClipRect>@ for C documentation.
rendererClipRect :: Renderer -> StateVar (Maybe (Rectangle CInt))
rendererClipRect :: Renderer -> StateVar (Maybe (Rectangle CInt))
rendererClipRect (Renderer r :: Renderer
r) = IO (Maybe (Rectangle CInt))
-> (Maybe (Rectangle CInt) -> IO ())
-> StateVar (Maybe (Rectangle CInt))
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (Maybe (Rectangle CInt))
renderGetClipRect Maybe (Rectangle CInt) -> IO ()
forall (m :: * -> *) a. (MonadIO m, Storable a) => Maybe a -> m ()
renderSetClipRect
  where
  renderGetClipRect :: IO (Maybe (Rectangle CInt))
renderGetClipRect = IO (Maybe (Rectangle CInt)) -> IO (Maybe (Rectangle CInt))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Rectangle CInt)) -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt)) -> IO (Maybe (Rectangle CInt))
forall a b. (a -> b) -> a -> b
$
    (Ptr Rect -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Rect -> IO (Maybe (Rectangle CInt)))
 -> IO (Maybe (Rectangle CInt)))
-> (Ptr Rect -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b. (a -> b) -> a -> b
$ \rPtr :: Ptr Rect
rPtr -> do
      Renderer -> Ptr Rect -> IO ()
forall (m :: * -> *). MonadIO m => Renderer -> Ptr Rect -> m ()
Raw.renderGetClipRect Renderer
r Ptr Rect
rPtr
      (Ptr (Rectangle CInt) -> IO (Rectangle CInt))
-> Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt))
forall a b. (Ptr a -> IO b) -> Ptr a -> IO (Maybe b)
maybePeek Ptr (Rectangle CInt) -> IO (Rectangle CInt)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Rect -> Ptr (Rectangle CInt)
forall a b. Ptr a -> Ptr b
castPtr Ptr Rect
rPtr)
  renderSetClipRect :: Maybe a -> m ()
renderSetClipRect rect :: Maybe a
rect =
    IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
    Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.renderSetClipRect" "SDL_RenderSetClipRect" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
    (a -> (Ptr a -> IO CInt) -> IO CInt)
-> Maybe a -> (Ptr a -> IO CInt) -> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith a -> (Ptr a -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe a
rect ((Ptr a -> IO CInt) -> IO CInt) -> (Ptr a -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Renderer -> Ptr Rect -> IO CInt
forall (m :: * -> *). MonadIO m => Renderer -> Ptr Rect -> m CInt
Raw.renderSetClipRect Renderer
r (Ptr Rect -> IO CInt) -> (Ptr a -> Ptr Rect) -> Ptr a -> IO CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr a -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr

-- | Get or set the drawing area for rendering on the current target.
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_RenderSetViewport SDL_RenderSetViewport>@ and @<https://wiki.libsdl.org/SDL_RenderGetViewport SDL_RenderGetViewport>@ for C documentation.
rendererViewport :: Renderer -> StateVar (Maybe (Rectangle CInt))
rendererViewport :: Renderer -> StateVar (Maybe (Rectangle CInt))
rendererViewport (Renderer r :: Renderer
r) = IO (Maybe (Rectangle CInt))
-> (Maybe (Rectangle CInt) -> IO ())
-> StateVar (Maybe (Rectangle CInt))
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (Maybe (Rectangle CInt))
renderGetViewport Maybe (Rectangle CInt) -> IO ()
forall (m :: * -> *) a. (MonadIO m, Storable a) => Maybe a -> m ()
renderSetViewport
  where
  renderGetViewport :: IO (Maybe (Rectangle CInt))
renderGetViewport = IO (Maybe (Rectangle CInt)) -> IO (Maybe (Rectangle CInt))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Rectangle CInt)) -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt)) -> IO (Maybe (Rectangle CInt))
forall a b. (a -> b) -> a -> b
$
    (Ptr Rect -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Rect -> IO (Maybe (Rectangle CInt)))
 -> IO (Maybe (Rectangle CInt)))
-> (Ptr Rect -> IO (Maybe (Rectangle CInt)))
-> IO (Maybe (Rectangle CInt))
forall a b. (a -> b) -> a -> b
$ \rect :: Ptr Rect
rect -> do
      Renderer -> Ptr Rect -> IO ()
forall (m :: * -> *). MonadIO m => Renderer -> Ptr Rect -> m ()
Raw.renderGetViewport Renderer
r Ptr Rect
rect
      (Ptr (Rectangle CInt) -> IO (Rectangle CInt))
-> Ptr (Rectangle CInt) -> IO (Maybe (Rectangle CInt))
forall a b. (Ptr a -> IO b) -> Ptr a -> IO (Maybe b)
maybePeek Ptr (Rectangle CInt) -> IO (Rectangle CInt)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Rect -> Ptr (Rectangle CInt)
forall a b. Ptr a -> Ptr b
castPtr Ptr Rect
rect)

  renderSetViewport :: Maybe a -> m ()
renderSetViewport rect :: Maybe a
rect =
    IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
    Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.renderSetViewport" "SDL_RenderSetViewport" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
    (a -> (Ptr a -> IO CInt) -> IO CInt)
-> Maybe a -> (Ptr a -> IO CInt) -> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith a -> (Ptr a -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe a
rect ((Ptr a -> IO CInt) -> IO CInt) -> (Ptr a -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Renderer -> Ptr Rect -> IO CInt
forall (m :: * -> *). MonadIO m => Renderer -> Ptr Rect -> m CInt
Raw.renderSetViewport Renderer
r (Ptr Rect -> IO CInt) -> (Ptr a -> Ptr Rect) -> Ptr a -> IO CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr a -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr

-- | Update the screen with any rendering performed since the previous call.
--
-- SDL\'s rendering functions operate on a backbuffer; that is, calling a rendering function such as 'drawLine' does not directly put a line on the screen, but rather updates the backbuffer. As such, you compose your entire scene and present the composed backbuffer to the screen as a complete picture.
--
-- Therefore, when using SDL's rendering API, one does all drawing intended for the frame, and then calls this function once per frame to present the final drawing to the user.
--
-- The backbuffer should be considered invalidated after each present; do not assume that previous contents will exist between frames. You are strongly encouraged to call 'clear' to initialize the backbuffer before starting each new frame's drawing, even if you plan to overwrite every pixel.
--
-- See @<https://wiki.libsdl.org/SDL_RenderPresent SDL_RenderPresent>@ for C documentation.
present :: MonadIO m => Renderer -> m ()
present :: Renderer -> m ()
present (Renderer r :: Renderer
r) = Renderer -> m ()
forall (m :: * -> *). MonadIO m => Renderer -> m ()
Raw.renderPresent Renderer
r

-- | Copy a portion of the texture to the current rendering target.
--
-- See @<https://wiki.libsdl.org/SDL_RenderCopy SDL_RenderCopy>@ for C documentation.
copy :: MonadIO m
     => Renderer -- ^ The rendering context
     -> Texture -- ^ The source texture
     -> Maybe (Rectangle CInt) -- ^ The source rectangle to copy, or 'Nothing' for the whole texture
     -> Maybe (Rectangle CInt) -- ^ The destination rectangle to copy to, or 'Nothing' for the whole rendering target. The texture will be stretched to fill the given rectangle.
     -> m ()
copy :: Renderer
-> Texture
-> Maybe (Rectangle CInt)
-> Maybe (Rectangle CInt)
-> m ()
copy (Renderer r :: Renderer
r) (Texture t :: Renderer
t) srcRect :: Maybe (Rectangle CInt)
srcRect dstRect :: Maybe (Rectangle CInt)
dstRect =
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.copy" "SDL_RenderCopy" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  (Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
srcRect ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \src :: Ptr (Rectangle CInt)
src ->
  (Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
dstRect ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \dst :: Ptr (Rectangle CInt)
dst ->
  Renderer -> Renderer -> Ptr Rect -> Ptr Rect -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Renderer -> Ptr Rect -> Ptr Rect -> m CInt
Raw.renderCopy Renderer
r Renderer
t (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
src) (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
dst)

-- | Copy a portion of the texture to the current rendering target, optionally rotating it by angle around the given center and also flipping it top-bottom and/or left-right.
--
-- See @<https://wiki.libsdl.org/SDL_RenderCopyEx SDL_RenderCopyEx>@ for C documentation.
copyEx :: MonadIO m
       => Renderer -- ^ The rendering context
       -> Texture -- ^ The source texture
       -> Maybe (Rectangle CInt) -- ^ The source rectangle to copy, or 'Nothing' for the whole texture
       -> Maybe (Rectangle CInt) -- ^ The destination rectangle to copy to, or 'Nothing' for the whole rendering target. The texture will be stretched to fill the given rectangle.
       -> CDouble -- ^ The angle of rotation in degrees. The rotation will be performed clockwise.
       -> Maybe (Point V2 CInt) -- ^ The point indicating the center of the rotation, or 'Nothing' to rotate around the center of the destination rectangle
       -> V2 Bool -- ^ Whether to flip the texture on the X and/or Y axis
       -> m ()
copyEx :: Renderer
-> Texture
-> Maybe (Rectangle CInt)
-> Maybe (Rectangle CInt)
-> CDouble
-> Maybe (Point V2 CInt)
-> V2 Bool
-> m ()
copyEx (Renderer r :: Renderer
r) (Texture t :: Renderer
t) srcRect :: Maybe (Rectangle CInt)
srcRect dstRect :: Maybe (Rectangle CInt)
dstRect theta :: CDouble
theta center :: Maybe (Point V2 CInt)
center flips :: V2 Bool
flips =
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.copyEx" "SDL_RenderCopyEx" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  (Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
srcRect ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \src :: Ptr (Rectangle CInt)
src ->
  (Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
dstRect ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \dst :: Ptr (Rectangle CInt)
dst ->
  (Point V2 CInt -> (Ptr (Point V2 CInt) -> IO CInt) -> IO CInt)
-> Maybe (Point V2 CInt)
-> (Ptr (Point V2 CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Point V2 CInt -> (Ptr (Point V2 CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Point V2 CInt)
center ((Ptr (Point V2 CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Point V2 CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \c :: Ptr (Point V2 CInt)
c ->
  Renderer
-> Renderer
-> Ptr Rect
-> Ptr Rect
-> CDouble
-> Ptr Point
-> Word32
-> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer
-> Renderer
-> Ptr Rect
-> Ptr Rect
-> CDouble
-> Ptr Point
-> Word32
-> m CInt
Raw.renderCopyEx Renderer
r Renderer
t (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
src) (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
dst) CDouble
theta (Ptr (Point V2 CInt) -> Ptr Point
forall a b. Ptr a -> Ptr b
castPtr Ptr (Point V2 CInt)
c)
                   (case V2 Bool
flips of
                      V2 x :: Bool
x y :: Bool
y -> (if Bool
x then Word32
Raw.SDL_FLIP_HORIZONTAL else 0) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|.
                               (if Bool
y then Word32
Raw.SDL_FLIP_VERTICAL else 0))

-- | Draw a line on the current rendering target.
--
-- See @<https://wiki.libsdl.org/SDL_RenderDrawLine SDL_RenderDrawLine>@ for C documentation.
drawLine :: (Functor m,MonadIO m)
         => Renderer
         -> Point V2 CInt -- ^ The start point of the line
         -> Point V2 CInt -- ^ The end point of the line
         -> m ()
drawLine :: Renderer -> Point V2 CInt -> Point V2 CInt -> m ()
drawLine (Renderer r :: Renderer
r) (P (V2 x :: CInt
x y :: CInt
y)) (P (V2 x' :: CInt
x' y' :: CInt
y')) =
  Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.drawLine" "SDL_RenderDrawLine" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
  Renderer -> CInt -> CInt -> CInt -> CInt -> m CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> CInt -> CInt -> CInt -> CInt -> m CInt
Raw.renderDrawLine Renderer
r CInt
x CInt
y CInt
x' CInt
y'

-- | Draw a series of connected lines on the current rendering target.
--
-- See @<https://wiki.libsdl.org/SDL_RenderDrawLines SDL_RenderDrawLines>@ for C documentation.
drawLines :: MonadIO m
          => Renderer
          -> SV.Vector (Point V2 CInt) -- ^ A 'SV.Vector' of points along the line. SDL will draw lines between these points.
          -> m ()
drawLines :: Renderer -> Vector (Point V2 CInt) -> m ()
drawLines (Renderer r :: Renderer
r) points :: Vector (Point V2 CInt)
points =
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.drawLines" "SDL_RenderDrawLines" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  Vector (Point V2 CInt)
-> (Ptr (Point V2 CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
SV.unsafeWith Vector (Point V2 CInt)
points ((Ptr (Point V2 CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Point V2 CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \cp :: Ptr (Point V2 CInt)
cp ->
    Renderer -> Ptr Point -> CInt -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr Point -> CInt -> m CInt
Raw.renderDrawLines Renderer
r
                        (Ptr (Point V2 CInt) -> Ptr Point
forall a b. Ptr a -> Ptr b
castPtr Ptr (Point V2 CInt)
cp)
                        (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Vector (Point V2 CInt) -> Int
forall a. Storable a => Vector a -> Int
SV.length Vector (Point V2 CInt)
points))

-- | Draw a point on the current rendering target.
--
-- See @<https://wiki.libsdl.org/SDL_RenderDrawPoint SDL_RenderDrawPoint>@ for C documentation.
drawPoint :: (Functor m, MonadIO m) => Renderer -> Point V2 CInt -> m ()
drawPoint :: Renderer -> Point V2 CInt -> m ()
drawPoint (Renderer r :: Renderer
r) (P (V2 x :: CInt
x y :: CInt
y)) =
  Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.drawPoint" "SDL_RenderDrawPoint" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
  Renderer -> CInt -> CInt -> m CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> CInt -> CInt -> m CInt
Raw.renderDrawPoint Renderer
r CInt
x CInt
y

-- | Draw multiple points on the current rendering target.
--
-- See @<https://wiki.libsdl.org/SDL_RenderDrawPoints SDL_RenderDrawPoints>@ for C documentation.
drawPoints :: MonadIO m => Renderer -> SV.Vector (Point V2 CInt) -> m ()
drawPoints :: Renderer -> Vector (Point V2 CInt) -> m ()
drawPoints (Renderer r :: Renderer
r) points :: Vector (Point V2 CInt)
points =
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.drawPoints" "SDL_RenderDrawPoints" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  Vector (Point V2 CInt)
-> (Ptr (Point V2 CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
SV.unsafeWith Vector (Point V2 CInt)
points ((Ptr (Point V2 CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Point V2 CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \cp :: Ptr (Point V2 CInt)
cp ->
    Renderer -> Ptr Point -> CInt -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr Point -> CInt -> m CInt
Raw.renderDrawPoints Renderer
r
                         (Ptr (Point V2 CInt) -> Ptr Point
forall a b. Ptr a -> Ptr b
castPtr Ptr (Point V2 CInt)
cp)
                         (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Vector (Point V2 CInt) -> Int
forall a. Storable a => Vector a -> Int
SV.length Vector (Point V2 CInt)
points))

-- | Copy an existing surface into a new one that is optimized for blitting to a surface of a specified pixel format.
--
-- This function is used to optimize images for faster repeat blitting. This is accomplished by converting the original and storing the result as a new surface. The new, optimized surface can then be used as the source for future blits, making them faster.
--
-- See @<https://wiki.libsdl.org/SDL_ConvertSurface SDL_ConvertSurface>@ for C documentation.
convertSurface :: (Functor m,MonadIO m)
               => Surface -- ^ The 'Surface' to convert
               -> SurfacePixelFormat -- ^ The pixel format that the new surface is optimized for
               -> m Surface
convertSurface :: Surface -> SurfacePixelFormat -> m Surface
convertSurface (Surface s :: Ptr Surface
s _) (SurfacePixelFormat fmt :: Ptr PixelFormat
fmt) =
  (Ptr Surface -> Surface) -> m (Ptr Surface) -> m Surface
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Surface -> Surface
unmanagedSurface (m (Ptr Surface) -> m Surface) -> m (Ptr Surface) -> m Surface
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> m (Ptr Surface) -> m (Ptr Surface)
forall (m :: * -> *) a.
MonadIO m =>
Text -> Text -> m (Ptr a) -> m (Ptr a)
throwIfNull "SDL.Video.Renderer.convertSurface" "SDL_ConvertSurface" (m (Ptr Surface) -> m (Ptr Surface))
-> m (Ptr Surface) -> m (Ptr Surface)
forall a b. (a -> b) -> a -> b
$
  Ptr Surface -> Ptr PixelFormat -> Word32 -> m (Ptr Surface)
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> Ptr PixelFormat -> Word32 -> m (Ptr Surface)
Raw.convertSurface Ptr Surface
s Ptr PixelFormat
fmt 0

-- | Perform a scaled surface copy to a destination surface.
--
-- See @<https://wiki.libsdl.org/SDL_BlitScaled SDL_BlitScaled>@ for C documentation.
surfaceBlitScaled :: MonadIO m
                  => Surface -- ^ The 'Surface' to be copied from
                  -> Maybe (Rectangle CInt) -- ^ The rectangle to be copied, or 'Nothing' to copy the entire surface
                  -> Surface -- ^ The 'Surface' that is the blit target
                  -> Maybe (Rectangle CInt) -- ^ The rectangle that is copied into, or 'Nothing' to copy into the entire surface
                  -> m ()
surfaceBlitScaled :: Surface
-> Maybe (Rectangle CInt)
-> Surface
-> Maybe (Rectangle CInt)
-> m ()
surfaceBlitScaled (Surface src :: Ptr Surface
src _) srcRect :: Maybe (Rectangle CInt)
srcRect (Surface dst :: Ptr Surface
dst _) dstRect :: Maybe (Rectangle CInt)
dstRect =
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.blitSurface" "SDL_BlitSurface" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
  (Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
srcRect ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \srcPtr :: Ptr (Rectangle CInt)
srcPtr ->
  (Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> Maybe (Rectangle CInt)
-> (Ptr (Rectangle CInt) -> IO CInt)
-> IO CInt
forall a b c.
(a -> (Ptr b -> IO c) -> IO c)
-> Maybe a -> (Ptr b -> IO c) -> IO c
maybeWith Rectangle CInt -> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with Maybe (Rectangle CInt)
dstRect ((Ptr (Rectangle CInt) -> IO CInt) -> IO CInt)
-> (Ptr (Rectangle CInt) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \dstPtr :: Ptr (Rectangle CInt)
dstPtr ->
  Ptr Surface -> Ptr Rect -> Ptr Surface -> Ptr Rect -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> Ptr Rect -> Ptr Surface -> Ptr Rect -> m CInt
Raw.blitScaled Ptr Surface
src (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
srcPtr) Ptr Surface
dst (Ptr (Rectangle CInt) -> Ptr Rect
forall a b. Ptr a -> Ptr b
castPtr Ptr (Rectangle CInt)
dstPtr)

-- | Get or set the color key (transparent pixel color) for a surface.
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_SetColorKey SDL_SetColorKey>@ and @<https://wiki.libsdl.org/SDL_GetColorKey SDL_GetColorKey>@ for C documentation.
surfaceColorKey :: Surface -> StateVar (Maybe (V4 Word8))
surfaceColorKey :: Surface -> StateVar (Maybe (V4 Word8))
surfaceColorKey (Surface s :: Ptr Surface
s _) = IO (Maybe (V4 Word8))
-> (Maybe (V4 Word8) -> IO ()) -> StateVar (Maybe (V4 Word8))
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (Maybe (V4 Word8))
getColorKey Maybe (V4 Word8) -> IO ()
forall (m :: * -> *). MonadIO m => Maybe (V4 Word8) -> m ()
setColorKey
  where
  getColorKey :: IO (Maybe (V4 Word8))
getColorKey =
    IO (Maybe (V4 Word8)) -> IO (Maybe (V4 Word8))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (V4 Word8)) -> IO (Maybe (V4 Word8)))
-> IO (Maybe (V4 Word8)) -> IO (Maybe (V4 Word8))
forall a b. (a -> b) -> a -> b
$
    (Ptr Word32 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8)))
-> (Ptr Word32 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. (a -> b) -> a -> b
$ \keyPtr :: Ptr Word32
keyPtr -> do
      CInt
ret <- Ptr Surface -> Ptr Word32 -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> Ptr Word32 -> m CInt
Raw.getColorKey Ptr Surface
s Ptr Word32
keyPtr
      if CInt
ret CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
== -1
        then Maybe (V4 Word8) -> IO (Maybe (V4 Word8))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (V4 Word8)
forall a. Maybe a
Nothing
        else do Ptr PixelFormat
format <- IO (Ptr PixelFormat) -> IO (Ptr PixelFormat)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Surface -> Ptr PixelFormat
Raw.surfaceFormat (Surface -> Ptr PixelFormat) -> IO Surface -> IO (Ptr PixelFormat)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Surface -> IO Surface
forall a. Storable a => Ptr a -> IO a
peek Ptr Surface
s)
                Word32
mapped <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
keyPtr
                (Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8)))
-> (Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. (a -> b) -> a -> b
$ \r :: Ptr Word8
r ->
                  (Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8)))
-> (Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. (a -> b) -> a -> b
$ \g :: Ptr Word8
g ->
                  (Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8)))
-> (Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. (a -> b) -> a -> b
$ \b :: Ptr Word8
b ->
                  (Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8)))
-> (Ptr Word8 -> IO (Maybe (V4 Word8))) -> IO (Maybe (V4 Word8))
forall a b. (a -> b) -> a -> b
$ \a :: Ptr Word8
a ->
                    do Word32
-> Ptr PixelFormat
-> Ptr Word8
-> Ptr Word8
-> Ptr Word8
-> Ptr Word8
-> IO ()
forall (m :: * -> *).
MonadIO m =>
Word32
-> Ptr PixelFormat
-> Ptr Word8
-> Ptr Word8
-> Ptr Word8
-> Ptr Word8
-> m ()
Raw.getRGBA Word32
mapped Ptr PixelFormat
format Ptr Word8
r Ptr Word8
g Ptr Word8
b Ptr Word8
a
                       V4 Word8 -> Maybe (V4 Word8)
forall a. a -> Maybe a
Just (V4 Word8 -> Maybe (V4 Word8))
-> IO (V4 Word8) -> IO (Maybe (V4 Word8))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word8 -> Word8 -> Word8 -> Word8 -> V4 Word8
forall a. a -> a -> a -> a -> V4 a
V4 (Word8 -> Word8 -> Word8 -> Word8 -> V4 Word8)
-> IO Word8 -> IO (Word8 -> Word8 -> Word8 -> V4 Word8)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
r IO (Word8 -> Word8 -> Word8 -> V4 Word8)
-> IO Word8 -> IO (Word8 -> Word8 -> V4 Word8)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
g IO (Word8 -> Word8 -> V4 Word8)
-> IO Word8 -> IO (Word8 -> V4 Word8)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
b IO (Word8 -> V4 Word8) -> IO Word8 -> IO (V4 Word8)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
a)
  setColorKey :: Maybe (V4 Word8) -> m ()
setColorKey key :: Maybe (V4 Word8)
key =
    IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
    Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.setColorKey" "SDL_SetColorKey" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
    case Maybe (V4 Word8)
key of
      Nothing ->
        (Ptr Word32 -> IO CInt) -> IO CInt
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO CInt) -> IO CInt)
-> (Ptr Word32 -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \keyPtr :: Ptr Word32
keyPtr -> do
          -- TODO Error checking?
          CInt
ret <- Ptr Surface -> Ptr Word32 -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> Ptr Word32 -> m CInt
Raw.getColorKey Ptr Surface
s Ptr Word32
keyPtr
          if CInt
ret CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
== -1
            -- if ret == -1 then there is no key enabled, so we have nothing to
            -- do.
            then CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return 0
            else do Word32
key' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
keyPtr
                    Ptr Surface -> CInt -> Word32 -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> CInt -> Word32 -> m CInt
Raw.setColorKey Ptr Surface
s 0 Word32
key'

      Just (V4 r :: Word8
r g :: Word8
g b :: Word8
b a :: Word8
a) -> do
        Ptr PixelFormat
format <- IO (Ptr PixelFormat) -> IO (Ptr PixelFormat)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Surface -> Ptr PixelFormat
Raw.surfaceFormat (Surface -> Ptr PixelFormat) -> IO Surface -> IO (Ptr PixelFormat)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Surface -> IO Surface
forall a. Storable a => Ptr a -> IO a
peek Ptr Surface
s)
        Ptr PixelFormat -> Word8 -> Word8 -> Word8 -> Word8 -> IO Word32
forall (m :: * -> *).
MonadIO m =>
Ptr PixelFormat -> Word8 -> Word8 -> Word8 -> Word8 -> m Word32
Raw.mapRGBA Ptr PixelFormat
format Word8
r Word8
g Word8
b Word8
a IO Word32 -> (Word32 -> IO CInt) -> IO CInt
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ptr Surface -> CInt -> Word32 -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> CInt -> Word32 -> m CInt
Raw.setColorKey Ptr Surface
s 1

-- | Get or set the additional color value multiplied into render copy operations.
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_SetTextureColorMod SDL_SetTextureColorMod>@ and @<https://wiki.libsdl.org/SDL_GetTextureColorMod SDL_GetTextureColorMod>@ for C documentation.
textureColorMod :: Texture -> StateVar (V3 Word8)
textureColorMod :: Texture -> StateVar (V3 Word8)
textureColorMod (Texture t :: Renderer
t) = IO (V3 Word8) -> (V3 Word8 -> IO ()) -> StateVar (V3 Word8)
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (V3 Word8)
getTextureColorMod V3 Word8 -> IO ()
forall (m :: * -> *). MonadIO m => V3 Word8 -> m ()
setTextureColorMod
  where
  getTextureColorMod :: IO (V3 Word8)
getTextureColorMod = IO (V3 Word8) -> IO (V3 Word8)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (V3 Word8) -> IO (V3 Word8)) -> IO (V3 Word8) -> IO (V3 Word8)
forall a b. (a -> b) -> a -> b
$
    (Ptr Word8 -> IO (V3 Word8)) -> IO (V3 Word8)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (V3 Word8)) -> IO (V3 Word8))
-> (Ptr Word8 -> IO (V3 Word8)) -> IO (V3 Word8)
forall a b. (a -> b) -> a -> b
$ \r :: Ptr Word8
r ->
    (Ptr Word8 -> IO (V3 Word8)) -> IO (V3 Word8)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (V3 Word8)) -> IO (V3 Word8))
-> (Ptr Word8 -> IO (V3 Word8)) -> IO (V3 Word8)
forall a b. (a -> b) -> a -> b
$ \g :: Ptr Word8
g ->
    (Ptr Word8 -> IO (V3 Word8)) -> IO (V3 Word8)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO (V3 Word8)) -> IO (V3 Word8))
-> (Ptr Word8 -> IO (V3 Word8)) -> IO (V3 Word8)
forall a b. (a -> b) -> a -> b
$ \b :: Ptr Word8
b -> do
      Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.getTextureColorMod" "SDL_GetTextureColorMod" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
        Renderer -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> m CInt
Raw.getTextureColorMod Renderer
t Ptr Word8
r Ptr Word8
g Ptr Word8
b
      Word8 -> Word8 -> Word8 -> V3 Word8
forall a. a -> a -> a -> V3 a
V3 (Word8 -> Word8 -> Word8 -> V3 Word8)
-> IO Word8 -> IO (Word8 -> Word8 -> V3 Word8)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
r IO (Word8 -> Word8 -> V3 Word8)
-> IO Word8 -> IO (Word8 -> V3 Word8)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
g IO (Word8 -> V3 Word8) -> IO Word8 -> IO (V3 Word8)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
b

  setTextureColorMod :: V3 Word8 -> m ()
setTextureColorMod (V3 r :: Word8
r g :: Word8
g b :: Word8
b) =
    Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.setTextureColorMod" "SDL_SetTextureColorMod" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
    Renderer -> Word8 -> Word8 -> Word8 -> m CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Word8 -> Word8 -> Word8 -> m CInt
Raw.setTextureColorMod Renderer
t Word8
r Word8
g Word8
b

data PixelFormat
  = Unknown
  | Index1LSB
  | Index1MSB
  | Index4LSB
  | Index4MSB
  | Index8
  | RGB332
  | RGB444
  | RGB555
  | BGR555
  | ARGB4444
  | RGBA4444
  | ABGR4444
  | BGRA4444
  | ARGB1555
  | RGBA5551
  | ABGR1555
  | BGRA5551
  | RGB565
  | BGR565
  | RGB24
  | BGR24
  | RGB888
  | RGBX8888
  | BGR888
  | BGRX8888
  | ARGB8888
  | RGBA8888
  | ABGR8888
  | BGRA8888
  | ARGB2101010
  | YV12
  | IYUV
  | YUY2
  | UYVY
  | YVYU
  deriving (PixelFormat
PixelFormat -> PixelFormat -> Bounded PixelFormat
forall a. a -> a -> Bounded a
maxBound :: PixelFormat
$cmaxBound :: PixelFormat
minBound :: PixelFormat
$cminBound :: PixelFormat
Bounded, Typeable PixelFormat
DataType
Constr
Typeable PixelFormat =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PixelFormat -> c PixelFormat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PixelFormat)
-> (PixelFormat -> Constr)
-> (PixelFormat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PixelFormat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PixelFormat))
-> ((forall b. Data b => b -> b) -> PixelFormat -> PixelFormat)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PixelFormat -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PixelFormat -> r)
-> (forall u. (forall d. Data d => d -> u) -> PixelFormat -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PixelFormat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat)
-> Data PixelFormat
PixelFormat -> DataType
PixelFormat -> Constr
(forall b. Data b => b -> b) -> PixelFormat -> PixelFormat
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PixelFormat -> c PixelFormat
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PixelFormat
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PixelFormat -> u
forall u. (forall d. Data d => d -> u) -> PixelFormat -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PixelFormat -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PixelFormat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PixelFormat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PixelFormat -> c PixelFormat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PixelFormat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PixelFormat)
$cYVYU :: Constr
$cUYVY :: Constr
$cYUY2 :: Constr
$cIYUV :: Constr
$cYV12 :: Constr
$cARGB2101010 :: Constr
$cBGRA8888 :: Constr
$cABGR8888 :: Constr
$cRGBA8888 :: Constr
$cARGB8888 :: Constr
$cBGRX8888 :: Constr
$cBGR888 :: Constr
$cRGBX8888 :: Constr
$cRGB888 :: Constr
$cBGR24 :: Constr
$cRGB24 :: Constr
$cBGR565 :: Constr
$cRGB565 :: Constr
$cBGRA5551 :: Constr
$cABGR1555 :: Constr
$cRGBA5551 :: Constr
$cARGB1555 :: Constr
$cBGRA4444 :: Constr
$cABGR4444 :: Constr
$cRGBA4444 :: Constr
$cARGB4444 :: Constr
$cBGR555 :: Constr
$cRGB555 :: Constr
$cRGB444 :: Constr
$cRGB332 :: Constr
$cIndex8 :: Constr
$cIndex4MSB :: Constr
$cIndex4LSB :: Constr
$cIndex1MSB :: Constr
$cIndex1LSB :: Constr
$cUnknown :: Constr
$tPixelFormat :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat
gmapMp :: (forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat
gmapM :: (forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PixelFormat -> m PixelFormat
gmapQi :: Int -> (forall d. Data d => d -> u) -> PixelFormat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PixelFormat -> u
gmapQ :: (forall d. Data d => d -> u) -> PixelFormat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PixelFormat -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PixelFormat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PixelFormat -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PixelFormat -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PixelFormat -> r
gmapT :: (forall b. Data b => b -> b) -> PixelFormat -> PixelFormat
$cgmapT :: (forall b. Data b => b -> b) -> PixelFormat -> PixelFormat
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PixelFormat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PixelFormat)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PixelFormat)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PixelFormat)
dataTypeOf :: PixelFormat -> DataType
$cdataTypeOf :: PixelFormat -> DataType
toConstr :: PixelFormat -> Constr
$ctoConstr :: PixelFormat -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PixelFormat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PixelFormat
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PixelFormat -> c PixelFormat
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PixelFormat -> c PixelFormat
$cp1Data :: Typeable PixelFormat
Data, Int -> PixelFormat
PixelFormat -> Int
PixelFormat -> [PixelFormat]
PixelFormat -> PixelFormat
PixelFormat -> PixelFormat -> [PixelFormat]
PixelFormat -> PixelFormat -> PixelFormat -> [PixelFormat]
(PixelFormat -> PixelFormat)
-> (PixelFormat -> PixelFormat)
-> (Int -> PixelFormat)
-> (PixelFormat -> Int)
-> (PixelFormat -> [PixelFormat])
-> (PixelFormat -> PixelFormat -> [PixelFormat])
-> (PixelFormat -> PixelFormat -> [PixelFormat])
-> (PixelFormat -> PixelFormat -> PixelFormat -> [PixelFormat])
-> Enum PixelFormat
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: PixelFormat -> PixelFormat -> PixelFormat -> [PixelFormat]
$cenumFromThenTo :: PixelFormat -> PixelFormat -> PixelFormat -> [PixelFormat]
enumFromTo :: PixelFormat -> PixelFormat -> [PixelFormat]
$cenumFromTo :: PixelFormat -> PixelFormat -> [PixelFormat]
enumFromThen :: PixelFormat -> PixelFormat -> [PixelFormat]
$cenumFromThen :: PixelFormat -> PixelFormat -> [PixelFormat]
enumFrom :: PixelFormat -> [PixelFormat]
$cenumFrom :: PixelFormat -> [PixelFormat]
fromEnum :: PixelFormat -> Int
$cfromEnum :: PixelFormat -> Int
toEnum :: Int -> PixelFormat
$ctoEnum :: Int -> PixelFormat
pred :: PixelFormat -> PixelFormat
$cpred :: PixelFormat -> PixelFormat
succ :: PixelFormat -> PixelFormat
$csucc :: PixelFormat -> PixelFormat
Enum, PixelFormat -> PixelFormat -> Bool
(PixelFormat -> PixelFormat -> Bool)
-> (PixelFormat -> PixelFormat -> Bool) -> Eq PixelFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PixelFormat -> PixelFormat -> Bool
$c/= :: PixelFormat -> PixelFormat -> Bool
== :: PixelFormat -> PixelFormat -> Bool
$c== :: PixelFormat -> PixelFormat -> Bool
Eq, (forall x. PixelFormat -> Rep PixelFormat x)
-> (forall x. Rep PixelFormat x -> PixelFormat)
-> Generic PixelFormat
forall x. Rep PixelFormat x -> PixelFormat
forall x. PixelFormat -> Rep PixelFormat x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PixelFormat x -> PixelFormat
$cfrom :: forall x. PixelFormat -> Rep PixelFormat x
Generic, Eq PixelFormat
Eq PixelFormat =>
(PixelFormat -> PixelFormat -> Ordering)
-> (PixelFormat -> PixelFormat -> Bool)
-> (PixelFormat -> PixelFormat -> Bool)
-> (PixelFormat -> PixelFormat -> Bool)
-> (PixelFormat -> PixelFormat -> Bool)
-> (PixelFormat -> PixelFormat -> PixelFormat)
-> (PixelFormat -> PixelFormat -> PixelFormat)
-> Ord PixelFormat
PixelFormat -> PixelFormat -> Bool
PixelFormat -> PixelFormat -> Ordering
PixelFormat -> PixelFormat -> PixelFormat
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PixelFormat -> PixelFormat -> PixelFormat
$cmin :: PixelFormat -> PixelFormat -> PixelFormat
max :: PixelFormat -> PixelFormat -> PixelFormat
$cmax :: PixelFormat -> PixelFormat -> PixelFormat
>= :: PixelFormat -> PixelFormat -> Bool
$c>= :: PixelFormat -> PixelFormat -> Bool
> :: PixelFormat -> PixelFormat -> Bool
$c> :: PixelFormat -> PixelFormat -> Bool
<= :: PixelFormat -> PixelFormat -> Bool
$c<= :: PixelFormat -> PixelFormat -> Bool
< :: PixelFormat -> PixelFormat -> Bool
$c< :: PixelFormat -> PixelFormat -> Bool
compare :: PixelFormat -> PixelFormat -> Ordering
$ccompare :: PixelFormat -> PixelFormat -> Ordering
$cp1Ord :: Eq PixelFormat
Ord, ReadPrec [PixelFormat]
ReadPrec PixelFormat
Int -> ReadS PixelFormat
ReadS [PixelFormat]
(Int -> ReadS PixelFormat)
-> ReadS [PixelFormat]
-> ReadPrec PixelFormat
-> ReadPrec [PixelFormat]
-> Read PixelFormat
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PixelFormat]
$creadListPrec :: ReadPrec [PixelFormat]
readPrec :: ReadPrec PixelFormat
$creadPrec :: ReadPrec PixelFormat
readList :: ReadS [PixelFormat]
$creadList :: ReadS [PixelFormat]
readsPrec :: Int -> ReadS PixelFormat
$creadsPrec :: Int -> ReadS PixelFormat
Read, 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
showList :: [PixelFormat] -> ShowS
$cshowList :: [PixelFormat] -> ShowS
show :: PixelFormat -> String
$cshow :: PixelFormat -> String
showsPrec :: Int -> PixelFormat -> ShowS
$cshowsPrec :: Int -> PixelFormat -> ShowS
Show, Typeable)

instance FromNumber PixelFormat Word32 where
  fromNumber :: Word32 -> PixelFormat
fromNumber n' :: Word32
n' = case Word32
n' of
    Raw.SDL_PIXELFORMAT_UNKNOWN -> PixelFormat
Unknown
    Raw.SDL_PIXELFORMAT_INDEX1LSB -> PixelFormat
Index1LSB
    Raw.SDL_PIXELFORMAT_INDEX1MSB -> PixelFormat
Index1MSB
    Raw.SDL_PIXELFORMAT_INDEX4LSB -> PixelFormat
Index4LSB
    Raw.SDL_PIXELFORMAT_INDEX4MSB -> PixelFormat
Index4MSB
    Raw.SDL_PIXELFORMAT_INDEX8 -> PixelFormat
Index8
    Raw.SDL_PIXELFORMAT_RGB332 -> PixelFormat
RGB332
    Raw.SDL_PIXELFORMAT_RGB444 -> PixelFormat
RGB444
    Raw.SDL_PIXELFORMAT_RGB555 -> PixelFormat
RGB555
    Raw.SDL_PIXELFORMAT_BGR555 -> PixelFormat
BGR555
    Raw.SDL_PIXELFORMAT_ARGB4444 -> PixelFormat
ARGB4444
    Raw.SDL_PIXELFORMAT_RGBA4444 -> PixelFormat
RGBA4444
    Raw.SDL_PIXELFORMAT_ABGR4444 -> PixelFormat
ABGR4444
    Raw.SDL_PIXELFORMAT_BGRA4444 -> PixelFormat
BGRA4444
    Raw.SDL_PIXELFORMAT_ARGB1555 -> PixelFormat
ARGB1555
    Raw.SDL_PIXELFORMAT_RGBA5551 -> PixelFormat
RGBA5551
    Raw.SDL_PIXELFORMAT_ABGR1555 -> PixelFormat
ABGR1555
    Raw.SDL_PIXELFORMAT_BGRA5551 -> PixelFormat
BGRA5551
    Raw.SDL_PIXELFORMAT_RGB565 -> PixelFormat
RGB565
    Raw.SDL_PIXELFORMAT_BGR565 -> PixelFormat
BGR565
    Raw.SDL_PIXELFORMAT_RGB24 -> PixelFormat
RGB24
    Raw.SDL_PIXELFORMAT_BGR24 -> PixelFormat
BGR24
    Raw.SDL_PIXELFORMAT_RGB888 -> PixelFormat
RGB888
    Raw.SDL_PIXELFORMAT_RGBX8888 -> PixelFormat
RGBX8888
    Raw.SDL_PIXELFORMAT_BGR888 -> PixelFormat
BGR888
    Raw.SDL_PIXELFORMAT_BGRX8888 -> PixelFormat
BGRX8888
    Raw.SDL_PIXELFORMAT_ARGB8888 -> PixelFormat
ARGB8888
    Raw.SDL_PIXELFORMAT_RGBA8888 -> PixelFormat
RGBA8888
    Raw.SDL_PIXELFORMAT_ABGR8888 -> PixelFormat
ABGR8888
    Raw.SDL_PIXELFORMAT_BGRA8888 -> PixelFormat
BGRA8888
    Raw.SDL_PIXELFORMAT_ARGB2101010 -> PixelFormat
ARGB2101010
    Raw.SDL_PIXELFORMAT_YV12 -> PixelFormat
YV12
    Raw.SDL_PIXELFORMAT_IYUV -> PixelFormat
IYUV
    Raw.SDL_PIXELFORMAT_YUY2 -> PixelFormat
YUY2
    Raw.SDL_PIXELFORMAT_UYVY -> PixelFormat
UYVY
    Raw.SDL_PIXELFORMAT_YVYU -> PixelFormat
YVYU
    _ -> String -> PixelFormat
forall a. HasCallStack => String -> a
error "fromNumber: not numbered"

instance ToNumber PixelFormat Word32 where
  toNumber :: PixelFormat -> Word32
toNumber pf :: PixelFormat
pf = case PixelFormat
pf of
    Unknown -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_UNKNOWN
    Index1LSB -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_INDEX1LSB
    Index1MSB -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_INDEX1MSB
    Index4LSB -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_INDEX4LSB
    Index4MSB -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_INDEX4MSB
    Index8 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_INDEX8
    RGB332 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGB332
    RGB444 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGB444
    RGB555 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGB555
    BGR555 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_BGR555
    ARGB4444 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_ARGB4444
    RGBA4444 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGBA4444
    ABGR4444 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_ABGR4444
    BGRA4444 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_BGRA4444
    ARGB1555 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_ARGB1555
    RGBA5551 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGBA5551
    ABGR1555 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_ABGR1555
    BGRA5551 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_BGRA5551
    RGB565 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGB565
    BGR565 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_BGR565
    RGB24 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGB24
    BGR24 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_BGR24
    RGB888 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGB888
    RGBX8888 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGBX8888
    BGR888 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_BGR888
    BGRX8888 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_BGRX8888
    ARGB8888 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_ARGB8888
    RGBA8888 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_RGBA8888
    ABGR8888 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_ABGR8888
    BGRA8888 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_BGRA8888
    ARGB2101010 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_ARGB2101010
    YV12 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_YV12
    IYUV -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_IYUV
    YUY2 -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_YUY2
    UYVY -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_UYVY
    YVYU -> Word32
forall a. (Eq a, Num a) => a
Raw.SDL_PIXELFORMAT_YVYU

-- | Renderer acceleration mode
data RendererType
  = UnacceleratedRenderer
    -- ^ The renderer does not use hardware acceleration
  | AcceleratedRenderer
    -- ^ The renderer uses hardware acceleration and refresh rate is ignored
  | AcceleratedVSyncRenderer
    -- ^ The renderer uses hardware acceleration and present is synchronized with the refresh rate
  | SoftwareRenderer
    -- ^ The renderer is a software fallback
  deriving (RendererType
RendererType -> RendererType -> Bounded RendererType
forall a. a -> a -> Bounded a
maxBound :: RendererType
$cmaxBound :: RendererType
minBound :: RendererType
$cminBound :: RendererType
Bounded, Typeable RendererType
DataType
Constr
Typeable RendererType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RendererType -> c RendererType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RendererType)
-> (RendererType -> Constr)
-> (RendererType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RendererType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RendererType))
-> ((forall b. Data b => b -> b) -> RendererType -> RendererType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RendererType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RendererType -> r)
-> (forall u. (forall d. Data d => d -> u) -> RendererType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RendererType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RendererType -> m RendererType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RendererType -> m RendererType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RendererType -> m RendererType)
-> Data RendererType
RendererType -> DataType
RendererType -> Constr
(forall b. Data b => b -> b) -> RendererType -> RendererType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RendererType -> c RendererType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RendererType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RendererType -> u
forall u. (forall d. Data d => d -> u) -> RendererType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RendererType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RendererType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RendererType -> m RendererType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RendererType -> m RendererType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RendererType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RendererType -> c RendererType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RendererType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RendererType)
$cSoftwareRenderer :: Constr
$cAcceleratedVSyncRenderer :: Constr
$cAcceleratedRenderer :: Constr
$cUnacceleratedRenderer :: Constr
$tRendererType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RendererType -> m RendererType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RendererType -> m RendererType
gmapMp :: (forall d. Data d => d -> m d) -> RendererType -> m RendererType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RendererType -> m RendererType
gmapM :: (forall d. Data d => d -> m d) -> RendererType -> m RendererType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RendererType -> m RendererType
gmapQi :: Int -> (forall d. Data d => d -> u) -> RendererType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RendererType -> u
gmapQ :: (forall d. Data d => d -> u) -> RendererType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RendererType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RendererType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RendererType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RendererType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RendererType -> r
gmapT :: (forall b. Data b => b -> b) -> RendererType -> RendererType
$cgmapT :: (forall b. Data b => b -> b) -> RendererType -> RendererType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RendererType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RendererType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RendererType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RendererType)
dataTypeOf :: RendererType -> DataType
$cdataTypeOf :: RendererType -> DataType
toConstr :: RendererType -> Constr
$ctoConstr :: RendererType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RendererType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RendererType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RendererType -> c RendererType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RendererType -> c RendererType
$cp1Data :: Typeable RendererType
Data, Int -> RendererType
RendererType -> Int
RendererType -> [RendererType]
RendererType -> RendererType
RendererType -> RendererType -> [RendererType]
RendererType -> RendererType -> RendererType -> [RendererType]
(RendererType -> RendererType)
-> (RendererType -> RendererType)
-> (Int -> RendererType)
-> (RendererType -> Int)
-> (RendererType -> [RendererType])
-> (RendererType -> RendererType -> [RendererType])
-> (RendererType -> RendererType -> [RendererType])
-> (RendererType -> RendererType -> RendererType -> [RendererType])
-> Enum RendererType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: RendererType -> RendererType -> RendererType -> [RendererType]
$cenumFromThenTo :: RendererType -> RendererType -> RendererType -> [RendererType]
enumFromTo :: RendererType -> RendererType -> [RendererType]
$cenumFromTo :: RendererType -> RendererType -> [RendererType]
enumFromThen :: RendererType -> RendererType -> [RendererType]
$cenumFromThen :: RendererType -> RendererType -> [RendererType]
enumFrom :: RendererType -> [RendererType]
$cenumFrom :: RendererType -> [RendererType]
fromEnum :: RendererType -> Int
$cfromEnum :: RendererType -> Int
toEnum :: Int -> RendererType
$ctoEnum :: Int -> RendererType
pred :: RendererType -> RendererType
$cpred :: RendererType -> RendererType
succ :: RendererType -> RendererType
$csucc :: RendererType -> RendererType
Enum, RendererType -> RendererType -> Bool
(RendererType -> RendererType -> Bool)
-> (RendererType -> RendererType -> Bool) -> Eq RendererType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RendererType -> RendererType -> Bool
$c/= :: RendererType -> RendererType -> Bool
== :: RendererType -> RendererType -> Bool
$c== :: RendererType -> RendererType -> Bool
Eq, (forall x. RendererType -> Rep RendererType x)
-> (forall x. Rep RendererType x -> RendererType)
-> Generic RendererType
forall x. Rep RendererType x -> RendererType
forall x. RendererType -> Rep RendererType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RendererType x -> RendererType
$cfrom :: forall x. RendererType -> Rep RendererType x
Generic, Eq RendererType
Eq RendererType =>
(RendererType -> RendererType -> Ordering)
-> (RendererType -> RendererType -> Bool)
-> (RendererType -> RendererType -> Bool)
-> (RendererType -> RendererType -> Bool)
-> (RendererType -> RendererType -> Bool)
-> (RendererType -> RendererType -> RendererType)
-> (RendererType -> RendererType -> RendererType)
-> Ord RendererType
RendererType -> RendererType -> Bool
RendererType -> RendererType -> Ordering
RendererType -> RendererType -> RendererType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RendererType -> RendererType -> RendererType
$cmin :: RendererType -> RendererType -> RendererType
max :: RendererType -> RendererType -> RendererType
$cmax :: RendererType -> RendererType -> RendererType
>= :: RendererType -> RendererType -> Bool
$c>= :: RendererType -> RendererType -> Bool
> :: RendererType -> RendererType -> Bool
$c> :: RendererType -> RendererType -> Bool
<= :: RendererType -> RendererType -> Bool
$c<= :: RendererType -> RendererType -> Bool
< :: RendererType -> RendererType -> Bool
$c< :: RendererType -> RendererType -> Bool
compare :: RendererType -> RendererType -> Ordering
$ccompare :: RendererType -> RendererType -> Ordering
$cp1Ord :: Eq RendererType
Ord, ReadPrec [RendererType]
ReadPrec RendererType
Int -> ReadS RendererType
ReadS [RendererType]
(Int -> ReadS RendererType)
-> ReadS [RendererType]
-> ReadPrec RendererType
-> ReadPrec [RendererType]
-> Read RendererType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RendererType]
$creadListPrec :: ReadPrec [RendererType]
readPrec :: ReadPrec RendererType
$creadPrec :: ReadPrec RendererType
readList :: ReadS [RendererType]
$creadList :: ReadS [RendererType]
readsPrec :: Int -> ReadS RendererType
$creadsPrec :: Int -> ReadS RendererType
Read, Int -> RendererType -> ShowS
[RendererType] -> ShowS
RendererType -> String
(Int -> RendererType -> ShowS)
-> (RendererType -> String)
-> ([RendererType] -> ShowS)
-> Show RendererType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RendererType] -> ShowS
$cshowList :: [RendererType] -> ShowS
show :: RendererType -> String
$cshow :: RendererType -> String
showsPrec :: Int -> RendererType -> ShowS
$cshowsPrec :: Int -> RendererType -> ShowS
Show, Typeable)

-- | The configuration data used when creating windows.
data RendererConfig = RendererConfig
  { RendererConfig -> RendererType
rendererType  :: RendererType
    -- ^ The renderer's acceleration mode
  , RendererConfig -> Bool
rendererTargetTexture :: Bool
    -- ^ The renderer supports rendering to texture
  } deriving (Typeable RendererConfig
DataType
Constr
Typeable RendererConfig =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RendererConfig -> c RendererConfig)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RendererConfig)
-> (RendererConfig -> Constr)
-> (RendererConfig -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RendererConfig))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RendererConfig))
-> ((forall b. Data b => b -> b)
    -> RendererConfig -> RendererConfig)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RendererConfig -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RendererConfig -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> RendererConfig -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RendererConfig -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RendererConfig -> m RendererConfig)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RendererConfig -> m RendererConfig)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RendererConfig -> m RendererConfig)
-> Data RendererConfig
RendererConfig -> DataType
RendererConfig -> Constr
(forall b. Data b => b -> b) -> RendererConfig -> RendererConfig
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RendererConfig -> c RendererConfig
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RendererConfig
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> RendererConfig -> u
forall u. (forall d. Data d => d -> u) -> RendererConfig -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RendererConfig -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RendererConfig -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RendererConfig -> m RendererConfig
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RendererConfig -> m RendererConfig
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RendererConfig
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RendererConfig -> c RendererConfig
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RendererConfig)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RendererConfig)
$cRendererConfig :: Constr
$tRendererConfig :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> RendererConfig -> m RendererConfig
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RendererConfig -> m RendererConfig
gmapMp :: (forall d. Data d => d -> m d)
-> RendererConfig -> m RendererConfig
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RendererConfig -> m RendererConfig
gmapM :: (forall d. Data d => d -> m d)
-> RendererConfig -> m RendererConfig
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RendererConfig -> m RendererConfig
gmapQi :: Int -> (forall d. Data d => d -> u) -> RendererConfig -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RendererConfig -> u
gmapQ :: (forall d. Data d => d -> u) -> RendererConfig -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RendererConfig -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RendererConfig -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RendererConfig -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RendererConfig -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RendererConfig -> r
gmapT :: (forall b. Data b => b -> b) -> RendererConfig -> RendererConfig
$cgmapT :: (forall b. Data b => b -> b) -> RendererConfig -> RendererConfig
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RendererConfig)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RendererConfig)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RendererConfig)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RendererConfig)
dataTypeOf :: RendererConfig -> DataType
$cdataTypeOf :: RendererConfig -> DataType
toConstr :: RendererConfig -> Constr
$ctoConstr :: RendererConfig -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RendererConfig
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RendererConfig
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RendererConfig -> c RendererConfig
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RendererConfig -> c RendererConfig
$cp1Data :: Typeable RendererConfig
Data, RendererConfig -> RendererConfig -> Bool
(RendererConfig -> RendererConfig -> Bool)
-> (RendererConfig -> RendererConfig -> Bool) -> Eq RendererConfig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RendererConfig -> RendererConfig -> Bool
$c/= :: RendererConfig -> RendererConfig -> Bool
== :: RendererConfig -> RendererConfig -> Bool
$c== :: RendererConfig -> RendererConfig -> Bool
Eq, (forall x. RendererConfig -> Rep RendererConfig x)
-> (forall x. Rep RendererConfig x -> RendererConfig)
-> Generic RendererConfig
forall x. Rep RendererConfig x -> RendererConfig
forall x. RendererConfig -> Rep RendererConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RendererConfig x -> RendererConfig
$cfrom :: forall x. RendererConfig -> Rep RendererConfig x
Generic, Eq RendererConfig
Eq RendererConfig =>
(RendererConfig -> RendererConfig -> Ordering)
-> (RendererConfig -> RendererConfig -> Bool)
-> (RendererConfig -> RendererConfig -> Bool)
-> (RendererConfig -> RendererConfig -> Bool)
-> (RendererConfig -> RendererConfig -> Bool)
-> (RendererConfig -> RendererConfig -> RendererConfig)
-> (RendererConfig -> RendererConfig -> RendererConfig)
-> Ord RendererConfig
RendererConfig -> RendererConfig -> Bool
RendererConfig -> RendererConfig -> Ordering
RendererConfig -> RendererConfig -> RendererConfig
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RendererConfig -> RendererConfig -> RendererConfig
$cmin :: RendererConfig -> RendererConfig -> RendererConfig
max :: RendererConfig -> RendererConfig -> RendererConfig
$cmax :: RendererConfig -> RendererConfig -> RendererConfig
>= :: RendererConfig -> RendererConfig -> Bool
$c>= :: RendererConfig -> RendererConfig -> Bool
> :: RendererConfig -> RendererConfig -> Bool
$c> :: RendererConfig -> RendererConfig -> Bool
<= :: RendererConfig -> RendererConfig -> Bool
$c<= :: RendererConfig -> RendererConfig -> Bool
< :: RendererConfig -> RendererConfig -> Bool
$c< :: RendererConfig -> RendererConfig -> Bool
compare :: RendererConfig -> RendererConfig -> Ordering
$ccompare :: RendererConfig -> RendererConfig -> Ordering
$cp1Ord :: Eq RendererConfig
Ord, ReadPrec [RendererConfig]
ReadPrec RendererConfig
Int -> ReadS RendererConfig
ReadS [RendererConfig]
(Int -> ReadS RendererConfig)
-> ReadS [RendererConfig]
-> ReadPrec RendererConfig
-> ReadPrec [RendererConfig]
-> Read RendererConfig
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RendererConfig]
$creadListPrec :: ReadPrec [RendererConfig]
readPrec :: ReadPrec RendererConfig
$creadPrec :: ReadPrec RendererConfig
readList :: ReadS [RendererConfig]
$creadList :: ReadS [RendererConfig]
readsPrec :: Int -> ReadS RendererConfig
$creadsPrec :: Int -> ReadS RendererConfig
Read, Int -> RendererConfig -> ShowS
[RendererConfig] -> ShowS
RendererConfig -> String
(Int -> RendererConfig -> ShowS)
-> (RendererConfig -> String)
-> ([RendererConfig] -> ShowS)
-> Show RendererConfig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RendererConfig] -> ShowS
$cshowList :: [RendererConfig] -> ShowS
show :: RendererConfig -> String
$cshow :: RendererConfig -> String
showsPrec :: Int -> RendererConfig -> ShowS
$cshowsPrec :: Int -> RendererConfig -> ShowS
Show, Typeable)

instance FromNumber RendererConfig Word32 where
  fromNumber :: Word32 -> RendererConfig
fromNumber n :: Word32
n = RendererConfig :: RendererType -> Bool -> RendererConfig
RendererConfig
    { rendererType :: RendererType
rendererType          = Bool -> Bool -> Bool -> RendererType
rendererType'
                                (Word32
n Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32
forall a. (Eq a, Num a) => a
Raw.SDL_RENDERER_SOFTWARE Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= 0)
                                (Word32
n Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32
forall a. (Eq a, Num a) => a
Raw.SDL_RENDERER_ACCELERATED Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= 0)
                                (Word32
n Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32
forall a. (Eq a, Num a) => a
Raw.SDL_RENDERER_PRESENTVSYNC Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= 0)
    , rendererTargetTexture :: Bool
rendererTargetTexture = Word32
n Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32
forall a. (Eq a, Num a) => a
Raw.SDL_RENDERER_TARGETTEXTURE Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= 0
    }
    where
      rendererType' :: Bool -> Bool -> Bool -> RendererType
rendererType' s :: Bool
s a :: Bool
a v :: Bool
v | Bool
s         = RendererType
SoftwareRenderer
                          | Bool
a Bool -> Bool -> Bool
&& Bool
v    = RendererType
AcceleratedVSyncRenderer
                          | Bool
a         = RendererType
AcceleratedRenderer
                          | Bool
otherwise = RendererType
UnacceleratedRenderer

instance ToNumber RendererConfig Word32 where
  toNumber :: RendererConfig -> Word32
toNumber config :: RendererConfig
config = (Word32 -> Word32 -> Word32) -> Word32 -> [Word32] -> Word32
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
(.|.) 0
    [ if Bool
isSoftware then Word32
forall a. (Eq a, Num a) => a
Raw.SDL_RENDERER_SOFTWARE else 0
    , if Bool -> Bool
not Bool
isSoftware then Word32
forall a. (Eq a, Num a) => a
Raw.SDL_RENDERER_ACCELERATED else 0
    , if RendererConfig -> RendererType
rendererType RendererConfig
config RendererType -> RendererType -> Bool
forall a. Eq a => a -> a -> Bool
== RendererType
AcceleratedVSyncRenderer then Word32
forall a. (Eq a, Num a) => a
Raw.SDL_RENDERER_PRESENTVSYNC  else 0
    , if RendererConfig -> Bool
rendererTargetTexture RendererConfig
config then Word32
forall a. (Eq a, Num a) => a
Raw.SDL_RENDERER_TARGETTEXTURE else 0
    ]
    where
      isSoftware :: Bool
isSoftware = RendererConfig -> RendererType
rendererType RendererConfig
config RendererType -> RendererType -> Bool
forall a. Eq a => a -> a -> Bool
== RendererType
SoftwareRenderer

-- | Default options for 'RendererConfig'.
--
-- @
-- 'defaultRenderer' = 'RendererConfig'
--   { 'rendererType'          = 'AcceleratedRenderer'
--   , 'rendererTargetTexture' = False
--   }
-- @
defaultRenderer :: RendererConfig
defaultRenderer :: RendererConfig
defaultRenderer = RendererConfig :: RendererType -> Bool -> RendererConfig
RendererConfig
  { rendererType :: RendererType
rendererType          = RendererType
AcceleratedRenderer
  , rendererTargetTexture :: Bool
rendererTargetTexture = Bool
False
  }

-- | Information about an instantiated 'Renderer'.
data RendererInfo = RendererInfo
  { RendererInfo -> Text
rendererInfoName              :: Text
    -- ^ The name of the renderer
  , RendererInfo -> RendererConfig
rendererInfoFlags             :: RendererConfig
    -- ^ Supported renderer features
  , RendererInfo -> Word32
rendererInfoNumTextureFormats :: Word32
    -- ^ The number of available texture formats
  , RendererInfo -> [PixelFormat]
rendererInfoTextureFormats    :: [PixelFormat]
    -- ^ The available texture formats
  , RendererInfo -> CInt
rendererInfoMaxTextureWidth   :: CInt
    -- ^ The maximum texture width
  , RendererInfo -> CInt
rendererInfoMaxTextureHeight  :: CInt
    -- ^ The maximum texture height
  } deriving (RendererInfo -> RendererInfo -> Bool
(RendererInfo -> RendererInfo -> Bool)
-> (RendererInfo -> RendererInfo -> Bool) -> Eq RendererInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RendererInfo -> RendererInfo -> Bool
$c/= :: RendererInfo -> RendererInfo -> Bool
== :: RendererInfo -> RendererInfo -> Bool
$c== :: RendererInfo -> RendererInfo -> Bool
Eq, (forall x. RendererInfo -> Rep RendererInfo x)
-> (forall x. Rep RendererInfo x -> RendererInfo)
-> Generic RendererInfo
forall x. Rep RendererInfo x -> RendererInfo
forall x. RendererInfo -> Rep RendererInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RendererInfo x -> RendererInfo
$cfrom :: forall x. RendererInfo -> Rep RendererInfo x
Generic, Eq RendererInfo
Eq RendererInfo =>
(RendererInfo -> RendererInfo -> Ordering)
-> (RendererInfo -> RendererInfo -> Bool)
-> (RendererInfo -> RendererInfo -> Bool)
-> (RendererInfo -> RendererInfo -> Bool)
-> (RendererInfo -> RendererInfo -> Bool)
-> (RendererInfo -> RendererInfo -> RendererInfo)
-> (RendererInfo -> RendererInfo -> RendererInfo)
-> Ord RendererInfo
RendererInfo -> RendererInfo -> Bool
RendererInfo -> RendererInfo -> Ordering
RendererInfo -> RendererInfo -> RendererInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RendererInfo -> RendererInfo -> RendererInfo
$cmin :: RendererInfo -> RendererInfo -> RendererInfo
max :: RendererInfo -> RendererInfo -> RendererInfo
$cmax :: RendererInfo -> RendererInfo -> RendererInfo
>= :: RendererInfo -> RendererInfo -> Bool
$c>= :: RendererInfo -> RendererInfo -> Bool
> :: RendererInfo -> RendererInfo -> Bool
$c> :: RendererInfo -> RendererInfo -> Bool
<= :: RendererInfo -> RendererInfo -> Bool
$c<= :: RendererInfo -> RendererInfo -> Bool
< :: RendererInfo -> RendererInfo -> Bool
$c< :: RendererInfo -> RendererInfo -> Bool
compare :: RendererInfo -> RendererInfo -> Ordering
$ccompare :: RendererInfo -> RendererInfo -> Ordering
$cp1Ord :: Eq RendererInfo
Ord, ReadPrec [RendererInfo]
ReadPrec RendererInfo
Int -> ReadS RendererInfo
ReadS [RendererInfo]
(Int -> ReadS RendererInfo)
-> ReadS [RendererInfo]
-> ReadPrec RendererInfo
-> ReadPrec [RendererInfo]
-> Read RendererInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RendererInfo]
$creadListPrec :: ReadPrec [RendererInfo]
readPrec :: ReadPrec RendererInfo
$creadPrec :: ReadPrec RendererInfo
readList :: ReadS [RendererInfo]
$creadList :: ReadS [RendererInfo]
readsPrec :: Int -> ReadS RendererInfo
$creadsPrec :: Int -> ReadS RendererInfo
Read, Int -> RendererInfo -> ShowS
[RendererInfo] -> ShowS
RendererInfo -> String
(Int -> RendererInfo -> ShowS)
-> (RendererInfo -> String)
-> ([RendererInfo] -> ShowS)
-> Show RendererInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RendererInfo] -> ShowS
$cshowList :: [RendererInfo] -> ShowS
show :: RendererInfo -> String
$cshow :: RendererInfo -> String
showsPrec :: Int -> RendererInfo -> ShowS
$cshowsPrec :: Int -> RendererInfo -> ShowS
Show, Typeable)

fromRawRendererInfo :: MonadIO m => Raw.RendererInfo -> m RendererInfo
fromRawRendererInfo :: RendererInfo -> m RendererInfo
fromRawRendererInfo (Raw.RendererInfo name :: CString
name flgs :: Word32
flgs ntf :: Word32
ntf tfs :: [Word32]
tfs mtw :: CInt
mtw mth :: CInt
mth) = IO RendererInfo -> m RendererInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RendererInfo -> m RendererInfo)
-> IO RendererInfo -> m RendererInfo
forall a b. (a -> b) -> a -> b
$ do
    Text
name' <- ByteString -> Text
Text.decodeUtf8 (ByteString -> Text) -> IO ByteString -> IO Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CString -> IO ByteString
BS.packCString CString
name
    RendererInfo -> IO RendererInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (RendererInfo -> IO RendererInfo)
-> RendererInfo -> IO RendererInfo
forall a b. (a -> b) -> a -> b
$ Text
-> RendererConfig
-> Word32
-> [PixelFormat]
-> CInt
-> CInt
-> RendererInfo
RendererInfo Text
name' (Word32 -> RendererConfig
forall a b. FromNumber a b => b -> a
fromNumber Word32
flgs) Word32
ntf ((Word32 -> PixelFormat) -> [Word32] -> [PixelFormat]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word32 -> PixelFormat
forall a b. FromNumber a b => b -> a
fromNumber [Word32]
tfs) CInt
mtw CInt
mth

-- | Get information about a rendering context.
--
-- See @<https://wiki.libsdl.org/SDL_GetRendererInfo SDL_GetRendererInfo>@ for C documentation.
getRendererInfo :: MonadIO m => Renderer -> m RendererInfo
getRendererInfo :: Renderer -> m RendererInfo
getRendererInfo (Renderer renderer :: Renderer
renderer) = IO RendererInfo -> m RendererInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RendererInfo -> m RendererInfo)
-> IO RendererInfo -> m RendererInfo
forall a b. (a -> b) -> a -> b
$
  (Ptr RendererInfo -> IO RendererInfo) -> IO RendererInfo
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr RendererInfo -> IO RendererInfo) -> IO RendererInfo)
-> (Ptr RendererInfo -> IO RendererInfo) -> IO RendererInfo
forall a b. (a -> b) -> a -> b
$ \rptr :: Ptr RendererInfo
rptr -> do
    Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "getRendererInfo" "SDL_GetRendererInfo" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
      Renderer -> Ptr RendererInfo -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr RendererInfo -> m CInt
Raw.getRendererInfo Renderer
renderer Ptr RendererInfo
rptr
    Ptr RendererInfo -> IO RendererInfo
forall a. Storable a => Ptr a -> IO a
peek Ptr RendererInfo
rptr IO RendererInfo
-> (RendererInfo -> IO RendererInfo) -> IO RendererInfo
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= RendererInfo -> IO RendererInfo
forall (m :: * -> *). MonadIO m => RendererInfo -> m RendererInfo
fromRawRendererInfo

-- | Enumerate all known render drivers on the system, and determine their supported features.
--
-- See @<https://wiki.libsdl.org/SDL_GetRenderDriverInfo SDL_GetRenderDriverInfo>@ for C documentation.
getRenderDriverInfo :: MonadIO m => m [RendererInfo]
getRenderDriverInfo :: m [RendererInfo]
getRenderDriverInfo = IO [RendererInfo] -> m [RendererInfo]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [RendererInfo] -> m [RendererInfo])
-> IO [RendererInfo] -> m [RendererInfo]
forall a b. (a -> b) -> a -> b
$ do
  CInt
count <- IO CInt
forall (m :: * -> *). MonadIO m => m CInt
Raw.getNumRenderDrivers
  (CInt -> IO RendererInfo) -> [CInt] -> IO [RendererInfo]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse CInt -> IO RendererInfo
go [0..CInt
countCInt -> CInt -> CInt
forall a. Num a => a -> a -> a
-1]
  where
    go :: CInt -> IO RendererInfo
go idx :: CInt
idx = (Ptr RendererInfo -> IO RendererInfo) -> IO RendererInfo
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr RendererInfo -> IO RendererInfo) -> IO RendererInfo)
-> (Ptr RendererInfo -> IO RendererInfo) -> IO RendererInfo
forall a b. (a -> b) -> a -> b
$ \rptr :: Ptr RendererInfo
rptr -> do
               Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "getRenderDriverInfo" "SDL_GetRenderDriverInfo" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
                 CInt -> Ptr RendererInfo -> IO CInt
forall (m :: * -> *).
MonadIO m =>
CInt -> Ptr RendererInfo -> m CInt
Raw.getRenderDriverInfo CInt
idx Ptr RendererInfo
rptr
               Ptr RendererInfo -> IO RendererInfo
forall a. Storable a => Ptr a -> IO a
peek Ptr RendererInfo
rptr IO RendererInfo
-> (RendererInfo -> IO RendererInfo) -> IO RendererInfo
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= RendererInfo -> IO RendererInfo
forall (m :: * -> *). MonadIO m => RendererInfo -> m RendererInfo
fromRawRendererInfo

-- | Get or set the additional alpha value multiplied into render copy operations.
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_SetTextureAlphaMod SDL_SetTextureAlphaMod>@ and @<https://wiki.libsdl.org/SDL_GetTextureAlphaMod SDL_GetTextureAlphaMod>@ for C documentation.
textureAlphaMod :: Texture -> StateVar Word8
textureAlphaMod :: Texture -> StateVar Word8
textureAlphaMod (Texture t :: Renderer
t) = IO Word8 -> (Word8 -> IO ()) -> StateVar Word8
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO Word8
getTextureAlphaMod Word8 -> IO ()
forall (m :: * -> *). MonadIO m => Word8 -> m ()
setTextureAlphaMod
  where
  getTextureAlphaMod :: IO Word8
getTextureAlphaMod = IO Word8 -> IO Word8
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> IO Word8) -> IO Word8 -> IO Word8
forall a b. (a -> b) -> a -> b
$
    (Ptr Word8 -> IO Word8) -> IO Word8
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word8 -> IO Word8) -> IO Word8)
-> (Ptr Word8 -> IO Word8) -> IO Word8
forall a b. (a -> b) -> a -> b
$ \x :: Ptr Word8
x -> do
      Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.getTextureAlphaMod" "SDL_GetTextureAlphaMod" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
        Renderer -> Ptr Word8 -> IO CInt
forall (m :: * -> *). MonadIO m => Renderer -> Ptr Word8 -> m CInt
Raw.getTextureAlphaMod Renderer
t Ptr Word8
x
      Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
x

  setTextureAlphaMod :: Word8 -> m ()
setTextureAlphaMod alpha :: Word8
alpha =
    Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.setTextureAlphaMod" "SDL_SetTextureAlphaMod" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
      Renderer -> Word8 -> m CInt
forall (m :: * -> *). MonadIO m => Renderer -> Word8 -> m CInt
Raw.setTextureAlphaMod Renderer
t Word8
alpha

-- | Get or set the blend mode used for texture copy operations.
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_SetTextureBlendMode SDL_SetTextureBlendMode>@ and @<https://wiki.libsdl.org/SDL_GetTextureBlendMode SDL_GetTextureBlendMode>@ for C documentation.
textureBlendMode :: Texture -> StateVar BlendMode
textureBlendMode :: Texture -> StateVar BlendMode
textureBlendMode (Texture t :: Renderer
t) = IO BlendMode -> (BlendMode -> IO ()) -> StateVar BlendMode
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO BlendMode
getTextureBlendMode BlendMode -> IO ()
forall (m :: * -> *) a. (MonadIO m, ToNumber a Word32) => a -> m ()
setTextureBlendMode
  where
  getTextureBlendMode :: IO BlendMode
getTextureBlendMode = IO BlendMode -> IO BlendMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BlendMode -> IO BlendMode) -> IO BlendMode -> IO BlendMode
forall a b. (a -> b) -> a -> b
$
    (Ptr Word32 -> IO BlendMode) -> IO BlendMode
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO BlendMode) -> IO BlendMode)
-> (Ptr Word32 -> IO BlendMode) -> IO BlendMode
forall a b. (a -> b) -> a -> b
$ \x :: Ptr Word32
x -> do
      Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.getTextureBlendMode" "SDL_GetTextureBlendMode" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
        Renderer -> Ptr Word32 -> IO CInt
forall (m :: * -> *). MonadIO m => Renderer -> Ptr Word32 -> m CInt
Raw.getTextureBlendMode Renderer
t Ptr Word32
x
      Word32 -> BlendMode
forall a b. FromNumber a b => b -> a
fromNumber (Word32 -> BlendMode) -> IO Word32 -> IO BlendMode
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
x

  setTextureBlendMode :: a -> m ()
setTextureBlendMode bm :: a
bm =
    Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.setTextureBlendMode" "SDL_SetTextureBlendMode" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
    Renderer -> Word32 -> m CInt
forall (m :: * -> *). MonadIO m => Renderer -> Word32 -> m CInt
Raw.setTextureBlendMode Renderer
t (a -> Word32
forall a b. ToNumber a b => a -> b
toNumber a
bm)

-- | Get or set the blend mode used for blit operations.
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_SetSurfaceBlendMode SDL_SetSurfaceBlendMode>@ and @<https://wiki.libsdl.org/SDL_GetSurfaceBlendMode SDL_GetSurfaceBlendMode>@ for C documentation.
surfaceBlendMode :: Surface -> StateVar BlendMode
surfaceBlendMode :: Surface -> StateVar BlendMode
surfaceBlendMode (Surface s :: Ptr Surface
s _) = IO BlendMode -> (BlendMode -> IO ()) -> StateVar BlendMode
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO BlendMode
getSurfaceBlendMode BlendMode -> IO ()
forall (m :: * -> *) a. (MonadIO m, ToNumber a Word32) => a -> m ()
setSurfaceBlendMode
  where
  getSurfaceBlendMode :: IO BlendMode
getSurfaceBlendMode = IO BlendMode -> IO BlendMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BlendMode -> IO BlendMode) -> IO BlendMode -> IO BlendMode
forall a b. (a -> b) -> a -> b
$
    (Ptr Word32 -> IO BlendMode) -> IO BlendMode
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO BlendMode) -> IO BlendMode)
-> (Ptr Word32 -> IO BlendMode) -> IO BlendMode
forall a b. (a -> b) -> a -> b
$ \x :: Ptr Word32
x -> do
      Text -> Text -> IO CInt -> IO ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.getSurfaceBlendMode" "SDL_GetSurfaceBlendMode" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
        Ptr Surface -> Ptr Word32 -> IO CInt
forall (m :: * -> *).
MonadIO m =>
Ptr Surface -> Ptr Word32 -> m CInt
Raw.getSurfaceBlendMode Ptr Surface
s Ptr Word32
x
      Word32 -> BlendMode
forall a b. FromNumber a b => b -> a
fromNumber (Word32 -> BlendMode) -> IO Word32 -> IO BlendMode
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
x

  setSurfaceBlendMode :: a -> m ()
setSurfaceBlendMode bm :: a
bm =
    Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.setSurfaceBlendMode" "SDL_SetSurfaceBlendMode" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
    Ptr Surface -> Word32 -> m CInt
forall (m :: * -> *). MonadIO m => Ptr Surface -> Word32 -> m CInt
Raw.setSurfaceBlendMode Ptr Surface
s (a -> Word32
forall a b. ToNumber a b => a -> b
toNumber a
bm)

-- | Get or set the current render target. 'Nothing' corresponds to the default render target.
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_SetRenderTarget SDL_SetRenderTarget>@ and @<https://wiki.libsdl.org/SDL_GetRenderTarget SDL_GetRenderTarget>@ for C documentation.
rendererRenderTarget :: Renderer -> StateVar (Maybe Texture)
rendererRenderTarget :: Renderer -> StateVar (Maybe Texture)
rendererRenderTarget (Renderer r :: Renderer
r) = IO (Maybe Texture)
-> (Maybe Texture -> IO ()) -> StateVar (Maybe Texture)
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (Maybe Texture)
getRenderTarget Maybe Texture -> IO ()
forall (m :: * -> *). MonadIO m => Maybe Texture -> m ()
setRenderTarget
  where
  getRenderTarget :: IO (Maybe Texture)
getRenderTarget = do
    Renderer
t <- Renderer -> IO Renderer
forall (m :: * -> *). MonadIO m => Renderer -> m Renderer
Raw.getRenderTarget Renderer
r
    Maybe Texture -> IO (Maybe Texture)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Texture -> IO (Maybe Texture))
-> Maybe Texture -> IO (Maybe Texture)
forall a b. (a -> b) -> a -> b
$
      if Renderer
t Renderer -> Renderer -> Bool
forall a. Eq a => a -> a -> Bool
== Renderer
forall a. Ptr a
nullPtr
        then Maybe Texture
forall a. Maybe a
Nothing
        else Texture -> Maybe Texture
forall a. a -> Maybe a
Just (Renderer -> Texture
Texture Renderer
t)

  setRenderTarget :: Maybe Texture -> m ()
setRenderTarget texture :: Maybe Texture
texture =
    Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.Renderer.setRenderTarget" "SDL_SetRenderTarget" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
    case Maybe Texture
texture of
      Nothing -> Renderer -> Renderer -> m CInt
forall (m :: * -> *). MonadIO m => Renderer -> Renderer -> m CInt
Raw.setRenderTarget Renderer
r Renderer
forall a. Ptr a
nullPtr
      Just (Texture t :: Renderer
t) -> Renderer -> Renderer -> m CInt
forall (m :: * -> *). MonadIO m => Renderer -> Renderer -> m CInt
Raw.setRenderTarget Renderer
r Renderer
t

-- | Get or set the device independent resolution for rendering.
--
-- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
--
-- See @<https://wiki.libsdl.org/SDL_RenderSetLogicalSize SDL_RenderSetLogicalSize>@ and @<https://wiki.libsdl.org/SDL_RenderGetLogicalSize SDL_RenderGetLogicalSize>@ for C documentation.
rendererLogicalSize :: Renderer -> StateVar (Maybe (V2 CInt))
rendererLogicalSize :: Renderer -> StateVar (Maybe (V2 CInt))
rendererLogicalSize (Renderer r :: Renderer
r) = IO (Maybe (V2 CInt))
-> (Maybe (V2 CInt) -> IO ()) -> StateVar (Maybe (V2 CInt))
forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar IO (Maybe (V2 CInt))
renderGetLogicalSize Maybe (V2 CInt) -> IO ()
forall (m :: * -> *). MonadIO m => Maybe (V2 CInt) -> m ()
renderSetLogicalSize
  where
  renderGetLogicalSize :: IO (Maybe (V2 CInt))
renderGetLogicalSize = IO (Maybe (V2 CInt)) -> IO (Maybe (V2 CInt))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (V2 CInt)) -> IO (Maybe (V2 CInt)))
-> IO (Maybe (V2 CInt)) -> IO (Maybe (V2 CInt))
forall a b. (a -> b) -> a -> b
$
    (Ptr CInt -> IO (Maybe (V2 CInt))) -> IO (Maybe (V2 CInt))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CInt -> IO (Maybe (V2 CInt))) -> IO (Maybe (V2 CInt)))
-> (Ptr CInt -> IO (Maybe (V2 CInt))) -> IO (Maybe (V2 CInt))
forall a b. (a -> b) -> a -> b
$ \w :: Ptr CInt
w -> do
    (Ptr CInt -> IO (Maybe (V2 CInt))) -> IO (Maybe (V2 CInt))
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CInt -> IO (Maybe (V2 CInt))) -> IO (Maybe (V2 CInt)))
-> (Ptr CInt -> IO (Maybe (V2 CInt))) -> IO (Maybe (V2 CInt))
forall a b. (a -> b) -> a -> b
$ \h :: Ptr CInt
h -> do
      Renderer -> Ptr CInt -> Ptr CInt -> IO ()
forall (m :: * -> *).
MonadIO m =>
Renderer -> Ptr CInt -> Ptr CInt -> m ()
Raw.renderGetLogicalSize Renderer
r Ptr CInt
w Ptr CInt
h
      V2 CInt
v <- CInt -> CInt -> V2 CInt
forall a. a -> a -> V2 a
V2 (CInt -> CInt -> V2 CInt) -> IO CInt -> IO (CInt -> V2 CInt)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
w IO (CInt -> V2 CInt) -> IO CInt -> IO (V2 CInt)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
h
      Maybe (V2 CInt) -> IO (Maybe (V2 CInt))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (V2 CInt) -> IO (Maybe (V2 CInt)))
-> Maybe (V2 CInt) -> IO (Maybe (V2 CInt))
forall a b. (a -> b) -> a -> b
$ if V2 CInt
v V2 CInt -> V2 CInt -> Bool
forall a. Eq a => a -> a -> Bool
== 0 then Maybe (V2 CInt)
forall a. Maybe a
Nothing else V2 CInt -> Maybe (V2 CInt)
forall a. a -> Maybe a
Just V2 CInt
v

  renderSetLogicalSize :: Maybe (V2 CInt) -> m ()
renderSetLogicalSize v :: Maybe (V2 CInt)
v =
    Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ "SDL.Video.renderSetLogicalSize" "SDL_RenderSetLogicalSize" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$ do
      let (x :: CInt
x,y :: CInt
y) = case Maybe (V2 CInt)
v of Just (V2 vx vy) -> (CInt
vx, CInt
vy)
                            Nothing -> (0,0)
      Renderer -> CInt -> CInt -> m CInt
forall (m :: * -> *).
MonadIO m =>
Renderer -> CInt -> CInt -> m CInt
Raw.renderSetLogicalSize Renderer
r CInt
x CInt
y

-- | Determine whether a window supports the use of render targets.
--
-- See @<https://wiki.libsdl.org/SDL_RenderTargetSupported SDL_RenderTargetSupported>@ for C documentation.
renderTargetSupported :: (MonadIO m) => Renderer -> m Bool
renderTargetSupported :: Renderer -> m Bool
renderTargetSupported (Renderer r :: Renderer
r) = Renderer -> m Bool
forall (m :: * -> *). MonadIO m => Renderer -> m Bool
Raw.renderTargetSupported Renderer
r

-- | Convert the given the enumerated pixel format to a bpp value and RGBA masks.
--
-- See @<https://wiki.libsdl.org/SDL_PixelFormatEnumToMasks SDL_PixelFormatEnumToMasks>@ for C documentation.
pixelFormatToMasks :: (MonadIO m) => PixelFormat -> m (CInt, V4 Word32)
pixelFormatToMasks :: PixelFormat -> m (CInt, V4 Word32)
pixelFormatToMasks pf :: PixelFormat
pf = IO (CInt, V4 Word32) -> m (CInt, V4 Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (CInt, V4 Word32) -> m (CInt, V4 Word32))
-> IO (CInt, V4 Word32) -> m (CInt, V4 Word32)
forall a b. (a -> b) -> a -> b
$
  (Ptr CInt -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CInt -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32))
-> (Ptr CInt -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. (a -> b) -> a -> b
$ \bpp :: Ptr CInt
bpp ->
  (Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32))
-> (Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. (a -> b) -> a -> b
$ \r :: Ptr Word32
r ->
  (Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32))
-> (Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. (a -> b) -> a -> b
$ \g :: Ptr Word32
g ->
  (Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32))
-> (Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. (a -> b) -> a -> b
$ \b :: Ptr Word32
b ->
  (Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32))
-> (Ptr Word32 -> IO (CInt, V4 Word32)) -> IO (CInt, V4 Word32)
forall a b. (a -> b) -> a -> b
$ \a :: Ptr Word32
a -> do
    (Bool -> Bool) -> Text -> Text -> IO Bool -> IO ()
forall (m :: * -> *) a.
MonadIO m =>
(a -> Bool) -> Text -> Text -> m a -> m ()
throwIf_ Bool -> Bool
not "SDL.Video.pixelFormatEnumToMasks" "SDL_PixelFormatEnumToMasks" (IO Bool -> IO ()) -> IO Bool -> IO ()
forall a b. (a -> b) -> a -> b
$
      Word32
-> Ptr CInt
-> Ptr Word32
-> Ptr Word32
-> Ptr Word32
-> Ptr Word32
-> IO Bool
forall (m :: * -> *).
MonadIO m =>
Word32
-> Ptr CInt
-> Ptr Word32
-> Ptr Word32
-> Ptr Word32
-> Ptr Word32
-> m Bool
Raw.pixelFormatEnumToMasks (PixelFormat -> Word32
forall a b. ToNumber a b => a -> b
toNumber PixelFormat
pf) Ptr CInt
bpp Ptr Word32
r Ptr Word32
g Ptr Word32
b Ptr Word32
a
    CInt -> Word32 -> Word32 -> Word32 -> Word32 -> (CInt, V4 Word32)
forall a a. a -> a -> a -> a -> a -> (a, V4 a)
wrap (CInt -> Word32 -> Word32 -> Word32 -> Word32 -> (CInt, V4 Word32))
-> IO CInt
-> IO (Word32 -> Word32 -> Word32 -> Word32 -> (CInt, V4 Word32))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
bpp IO (Word32 -> Word32 -> Word32 -> Word32 -> (CInt, V4 Word32))
-> IO Word32
-> IO (Word32 -> Word32 -> Word32 -> (CInt, V4 Word32))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
r IO (Word32 -> Word32 -> Word32 -> (CInt, V4 Word32))
-> IO Word32 -> IO (Word32 -> Word32 -> (CInt, V4 Word32))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
g IO (Word32 -> Word32 -> (CInt, V4 Word32))
-> IO Word32 -> IO (Word32 -> (CInt, V4 Word32))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
b IO (Word32 -> (CInt, V4 Word32))
-> IO Word32 -> IO (CInt, V4 Word32)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
a
    where
      wrap :: a -> a -> a -> a -> a -> (a, V4 a)
wrap bpp :: a
bpp r :: a
r g :: a
g b :: a
b a :: a
a = (a
bpp, a -> a -> a -> a -> V4 a
forall a. a -> a -> a -> a -> V4 a
V4 a
r a
g a
b a
a)

-- | Convert a bpp value and RGBA masks to an enumerated pixel format.
--
-- See @<https://wiki.libsdl.org/SDL_MasksToPixelFormatEnum SDL_MasksToPixelFormatEnum>@ for C documentation.
masksToPixelFormat :: (MonadIO m) => CInt -> V4 Word32 -> m PixelFormat
masksToPixelFormat :: CInt -> V4 Word32 -> m PixelFormat
masksToPixelFormat bpp :: CInt
bpp (V4 r :: Word32
r g :: Word32
g b :: Word32
b a :: Word32
a) = IO PixelFormat -> m PixelFormat
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PixelFormat -> m PixelFormat)
-> IO PixelFormat -> m PixelFormat
forall a b. (a -> b) -> a -> b
$
  Word32 -> PixelFormat
forall a b. FromNumber a b => b -> a
fromNumber (Word32 -> PixelFormat) -> IO Word32 -> IO PixelFormat
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> Word32 -> Word32 -> Word32 -> Word32 -> IO Word32
forall (m :: * -> *).
MonadIO m =>
CInt -> Word32 -> Word32 -> Word32 -> Word32 -> m Word32
Raw.masksToPixelFormatEnum CInt
bpp Word32
r Word32
g Word32
b Word32
a