{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
module SDL.Mixer
(
withAudio,
Audio (..),
Format (..),
Output (..),
defaultAudio,
ChunkSize,
queryAudio,
openAudio,
closeAudio,
Loadable (..),
Chunk (..),
chunkDecoders,
Music (..),
musicDecoders,
Channel,
pattern AllChannels,
setChannels,
getChannels,
play,
playForever,
Times,
pattern Once,
pattern Forever,
playOn,
Milliseconds,
Limit,
pattern NoLimit,
playLimit,
fadeIn,
fadeInOn,
fadeInLimit,
reserveChannels,
Group,
pattern DefaultGroup,
group,
groupSpan,
groupCount,
getAvailable,
getOldest,
getNewest,
pause,
resume,
halt,
haltAfter,
haltGroup,
Volume,
HasVolume (..),
playing,
playingCount,
paused,
pausedCount,
playedLast,
Fading,
fading,
fadeOut,
fadeOutGroup,
whenChannelFinished,
playMusic,
Position,
fadeInMusic,
fadeInMusicAt,
fadeInMusicAtMOD,
pauseMusic,
haltMusic,
resumeMusic,
rewindMusic,
setMusicPosition,
setMusicPositionMOD,
setMusicVolume,
getMusicVolume,
playingMusic,
pausedMusic,
fadingMusic,
MusicType (..),
musicType,
playingMusicType,
fadeOutMusic,
whenMusicFinished,
Effect,
EffectFinished,
pattern PostProcessing,
effect,
effectPan,
effectDistance,
effectPosition,
effectReverseStereo,
initialize,
InitFlag (..),
quit,
version,
)
where
import Control.Exception (throwIO)
import Control.Exception.Lifted (finally)
import Control.Monad (forM, void, when, (<=<), (>=>))
import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Monad.Trans.Control (MonadBaseControl)
import Data.Bits ((.&.), (.|.))
import Data.ByteString as BS (ByteString, readFile)
import Data.ByteString.Unsafe (unsafeUseAsCStringLen)
import Data.Default.Class (Default (def))
import Data.IORef (IORef, newIORef, readIORef, writeIORef)
import Data.Int (Int16)
import Data.Vector.Storable.Mutable (IOVector, unsafeFromForeignPtr0)
import Data.Word (Word8)
import Foreign.C.String (peekCString)
import Foreign.C.Types (CInt)
import Foreign.ForeignPtr (castForeignPtr, newForeignPtr_)
import Foreign.Marshal.Alloc (alloca)
import Foreign.Ptr (FunPtr, Ptr, castPtr, freeHaskellFunPtr, nullFunPtr, nullPtr)
import Foreign.Storable (Storable (peek))
import SDL (SDLException (SDLCallFailed))
import SDL.Internal.Exception
( getError,
throwIf0,
throwIfNeg,
throwIfNeg_,
throwIfNull,
throwIf_,
)
import qualified SDL.Raw
import SDL.Raw.Filesystem (rwFromConstMem)
import qualified SDL.Raw.Mixer
import System.IO.Unsafe (unsafePerformIO)
initialize :: (Foldable f, MonadIO m) => f InitFlag -> m ()
initialize :: forall (f :: * -> *) (m :: * -> *).
(Foldable f, MonadIO m) =>
f InitFlag -> m ()
initialize f InitFlag
flags = do
let raw :: CInt
raw = (CInt -> InitFlag -> CInt) -> CInt -> f InitFlag -> CInt
forall b a. (b -> a -> b) -> b -> f a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\CInt
a InitFlag
b -> CInt
a CInt -> CInt -> CInt
forall a. Bits a => a -> a -> a
.|. InitFlag -> CInt
initToCInt InitFlag
b) CInt
0 f InitFlag
flags
(CInt -> Bool) -> Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
MonadIO m =>
(a -> Bool) -> Text -> Text -> m a -> m ()
throwIf_ ((CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
raw) (CInt -> Bool) -> (CInt -> CInt) -> CInt -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CInt -> CInt -> CInt
forall a. Bits a => a -> a -> a
.&. CInt
raw)) Text
"SDL.Mixer.initialize" Text
"Mix_Init" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.init CInt
raw
data InitFlag
= InitFLAC
| InitMOD
| InitMP3
| InitOGG
deriving stock (InitFlag -> InitFlag -> Bool
(InitFlag -> InitFlag -> Bool)
-> (InitFlag -> InitFlag -> Bool) -> Eq InitFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InitFlag -> InitFlag -> Bool
== :: InitFlag -> InitFlag -> Bool
$c/= :: InitFlag -> InitFlag -> Bool
/= :: InitFlag -> InitFlag -> Bool
Eq, Eq InitFlag
Eq InitFlag
-> (InitFlag -> InitFlag -> Ordering)
-> (InitFlag -> InitFlag -> Bool)
-> (InitFlag -> InitFlag -> Bool)
-> (InitFlag -> InitFlag -> Bool)
-> (InitFlag -> InitFlag -> Bool)
-> (InitFlag -> InitFlag -> InitFlag)
-> (InitFlag -> InitFlag -> InitFlag)
-> Ord InitFlag
InitFlag -> InitFlag -> Bool
InitFlag -> InitFlag -> Ordering
InitFlag -> InitFlag -> InitFlag
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
$ccompare :: InitFlag -> InitFlag -> Ordering
compare :: InitFlag -> InitFlag -> Ordering
$c< :: InitFlag -> InitFlag -> Bool
< :: InitFlag -> InitFlag -> Bool
$c<= :: InitFlag -> InitFlag -> Bool
<= :: InitFlag -> InitFlag -> Bool
$c> :: InitFlag -> InitFlag -> Bool
> :: InitFlag -> InitFlag -> Bool
$c>= :: InitFlag -> InitFlag -> Bool
>= :: InitFlag -> InitFlag -> Bool
$cmax :: InitFlag -> InitFlag -> InitFlag
max :: InitFlag -> InitFlag -> InitFlag
$cmin :: InitFlag -> InitFlag -> InitFlag
min :: InitFlag -> InitFlag -> InitFlag
Ord, InitFlag
InitFlag -> InitFlag -> Bounded InitFlag
forall a. a -> a -> Bounded a
$cminBound :: InitFlag
minBound :: InitFlag
$cmaxBound :: InitFlag
maxBound :: InitFlag
Bounded, ReadPrec [InitFlag]
ReadPrec InitFlag
Volume -> ReadS InitFlag
ReadS [InitFlag]
(Volume -> ReadS InitFlag)
-> ReadS [InitFlag]
-> ReadPrec InitFlag
-> ReadPrec [InitFlag]
-> Read InitFlag
forall a.
(Volume -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Volume -> ReadS InitFlag
readsPrec :: Volume -> ReadS InitFlag
$creadList :: ReadS [InitFlag]
readList :: ReadS [InitFlag]
$creadPrec :: ReadPrec InitFlag
readPrec :: ReadPrec InitFlag
$creadListPrec :: ReadPrec [InitFlag]
readListPrec :: ReadPrec [InitFlag]
Read, Volume -> InitFlag -> ShowS
[InitFlag] -> ShowS
InitFlag -> String
(Volume -> InitFlag -> ShowS)
-> (InitFlag -> String) -> ([InitFlag] -> ShowS) -> Show InitFlag
forall a.
(Volume -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Volume -> InitFlag -> ShowS
showsPrec :: Volume -> InitFlag -> ShowS
$cshow :: InitFlag -> String
show :: InitFlag -> String
$cshowList :: [InitFlag] -> ShowS
showList :: [InitFlag] -> ShowS
Show)
initToCInt :: InitFlag -> CInt
initToCInt :: InitFlag -> CInt
initToCInt = \case
InitFlag
InitFLAC -> CInt
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.INIT_FLAC
InitFlag
InitMOD -> CInt
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.INIT_MOD
InitFlag
InitMP3 -> CInt
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.INIT_MP3
InitFlag
InitOGG -> CInt
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.INIT_OGG
quit :: MonadIO m => m ()
quit :: forall (m :: * -> *). MonadIO m => m ()
quit = m ()
forall (m :: * -> *). MonadIO m => m ()
SDL.Raw.Mixer.quit
version :: (Integral a, MonadIO m) => m (a, a, a)
version :: forall a (m :: * -> *). (Integral a, MonadIO m) => m (a, a, a)
version = IO (a, a, a) -> m (a, a, a)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (a, a, a) -> m (a, a, a)) -> IO (a, a, a) -> m (a, a, a)
forall a b. (a -> b) -> a -> b
$ do
SDL.Raw.Version Word8
major Word8
minor Word8
patch <- Ptr Version -> IO Version
forall a. Storable a => Ptr a -> IO a
peek (Ptr Version -> IO Version) -> IO (Ptr Version) -> IO Version
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO (Ptr Version)
forall (m :: * -> *). MonadIO m => m (Ptr Version)
SDL.Raw.Mixer.getVersion
(a, a, a) -> IO (a, a, a)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
major, Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
minor, Word8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
patch)
withAudio ::
(MonadBaseControl IO m, MonadIO m) => Audio -> ChunkSize -> m a -> m a
withAudio :: forall (m :: * -> *) a.
(MonadBaseControl IO m, MonadIO m) =>
Audio -> Volume -> m a -> m a
withAudio Audio
conf Volume
csize m a
act = do
Audio -> Volume -> m ()
forall (m :: * -> *). MonadIO m => Audio -> Volume -> m ()
openAudio Audio
conf Volume
csize
m a -> m () -> m a
forall (m :: * -> *) a b.
MonadBaseControl IO m =>
m a -> m b -> m a
finally m a
act m ()
forall (m :: * -> *). MonadIO m => m ()
closeAudio
openAudio :: MonadIO m => Audio -> ChunkSize -> m ()
openAudio :: forall (m :: * -> *). MonadIO m => Audio -> Volume -> m ()
openAudio Audio {Volume
Output
Format
audioFrequency :: Volume
audioFormat :: Format
audioOutput :: Output
audioFrequency :: Audio -> Volume
audioFormat :: Audio -> Format
audioOutput :: Audio -> Output
..} Volume
chunkSize =
Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ Text
"SDL.Mixer.openAudio" Text
"Mix_OpenAudio" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
CInt -> Format -> CInt -> CInt -> m CInt
forall {m :: * -> *}.
MonadIO m =>
CInt -> Format -> CInt -> CInt -> m CInt
SDL.Raw.Mixer.openAudio
(Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
audioFrequency)
(Format -> Format
formatToWord Format
audioFormat)
(Output -> CInt
outputToCInt Output
audioOutput)
(Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
chunkSize)
data Audio = Audio
{
Audio -> Volume
audioFrequency :: Int,
Audio -> Format
audioFormat :: Format,
Audio -> Output
audioOutput :: Output
}
deriving stock (Audio -> Audio -> Bool
(Audio -> Audio -> Bool) -> (Audio -> Audio -> Bool) -> Eq Audio
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Audio -> Audio -> Bool
== :: Audio -> Audio -> Bool
$c/= :: Audio -> Audio -> Bool
/= :: Audio -> Audio -> Bool
Eq, ReadPrec [Audio]
ReadPrec Audio
Volume -> ReadS Audio
ReadS [Audio]
(Volume -> ReadS Audio)
-> ReadS [Audio]
-> ReadPrec Audio
-> ReadPrec [Audio]
-> Read Audio
forall a.
(Volume -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Volume -> ReadS Audio
readsPrec :: Volume -> ReadS Audio
$creadList :: ReadS [Audio]
readList :: ReadS [Audio]
$creadPrec :: ReadPrec Audio
readPrec :: ReadPrec Audio
$creadListPrec :: ReadPrec [Audio]
readListPrec :: ReadPrec [Audio]
Read, Volume -> Audio -> ShowS
[Audio] -> ShowS
Audio -> String
(Volume -> Audio -> ShowS)
-> (Audio -> String) -> ([Audio] -> ShowS) -> Show Audio
forall a.
(Volume -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Volume -> Audio -> ShowS
showsPrec :: Volume -> Audio -> ShowS
$cshow :: Audio -> String
show :: Audio -> String
$cshowList :: [Audio] -> ShowS
showList :: [Audio] -> ShowS
Show)
instance Default Audio where
def :: Audio
def =
Audio
{ audioFrequency :: Volume
audioFrequency = Volume
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.DEFAULT_FREQUENCY,
audioFormat :: Format
audioFormat = Format -> Format
wordToFormat Format
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.DEFAULT_FORMAT,
audioOutput :: Output
audioOutput = CInt -> Output
cIntToOutput CInt
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.DEFAULT_CHANNELS
}
defaultAudio :: Audio
defaultAudio :: Audio
defaultAudio = Audio
forall a. Default a => a
def
type ChunkSize = Int
data Format
=
FormatU8
|
FormatS8
|
FormatU16_LSB
|
FormatS16_LSB
|
FormatU16_MSB
|
FormatS16_MSB
|
FormatU16_Sys
|
FormatS16_Sys
deriving stock (Format -> Format -> Bool
(Format -> Format -> Bool)
-> (Format -> Format -> Bool) -> Eq Format
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Format -> Format -> Bool
== :: Format -> Format -> Bool
$c/= :: Format -> Format -> Bool
/= :: Format -> Format -> Bool
Eq, Eq Format
Eq Format
-> (Format -> Format -> Ordering)
-> (Format -> Format -> Bool)
-> (Format -> Format -> Bool)
-> (Format -> Format -> Bool)
-> (Format -> Format -> Bool)
-> (Format -> Format -> Format)
-> (Format -> Format -> Format)
-> Ord Format
Format -> Format -> Bool
Format -> Format -> Ordering
Format -> Format -> Format
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
$ccompare :: Format -> Format -> Ordering
compare :: Format -> Format -> Ordering
$c< :: Format -> Format -> Bool
< :: Format -> Format -> Bool
$c<= :: Format -> Format -> Bool
<= :: Format -> Format -> Bool
$c> :: Format -> Format -> Bool
> :: Format -> Format -> Bool
$c>= :: Format -> Format -> Bool
>= :: Format -> Format -> Bool
$cmax :: Format -> Format -> Format
max :: Format -> Format -> Format
$cmin :: Format -> Format -> Format
min :: Format -> Format -> Format
Ord, Format
Format -> Format -> Bounded Format
forall a. a -> a -> Bounded a
$cminBound :: Format
minBound :: Format
$cmaxBound :: Format
maxBound :: Format
Bounded, ReadPrec [Format]
ReadPrec Format
Volume -> ReadS Format
ReadS [Format]
(Volume -> ReadS Format)
-> ReadS [Format]
-> ReadPrec Format
-> ReadPrec [Format]
-> Read Format
forall a.
(Volume -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Volume -> ReadS Format
readsPrec :: Volume -> ReadS Format
$creadList :: ReadS [Format]
readList :: ReadS [Format]
$creadPrec :: ReadPrec Format
readPrec :: ReadPrec Format
$creadListPrec :: ReadPrec [Format]
readListPrec :: ReadPrec [Format]
Read, Volume -> Format -> ShowS
[Format] -> ShowS
Format -> String
(Volume -> Format -> ShowS)
-> (Format -> String) -> ([Format] -> ShowS) -> Show Format
forall a.
(Volume -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Volume -> Format -> ShowS
showsPrec :: Volume -> Format -> ShowS
$cshow :: Format -> String
show :: Format -> String
$cshowList :: [Format] -> ShowS
showList :: [Format] -> ShowS
Show)
formatToWord :: Format -> SDL.Raw.Mixer.Format
formatToWord :: Format -> Format
formatToWord = \case
Format
FormatU8 -> Format
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.AUDIO_U8
Format
FormatS8 -> Format
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.AUDIO_S8
Format
FormatU16_LSB -> Format
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.AUDIO_U16LSB
Format
FormatS16_LSB -> Format
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.AUDIO_S16LSB
Format
FormatU16_MSB -> Format
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.AUDIO_U16MSB
Format
FormatS16_MSB -> Format
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.AUDIO_S16MSB
Format
FormatU16_Sys -> Format
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.AUDIO_U16SYS
Format
FormatS16_Sys -> Format
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.AUDIO_S16SYS
wordToFormat :: SDL.Raw.Mixer.Format -> Format
wordToFormat :: Format -> Format
wordToFormat = \case
Format
SDL.Raw.Mixer.AUDIO_U8 -> Format
FormatU8
Format
SDL.Raw.Mixer.AUDIO_S8 -> Format
FormatS8
Format
SDL.Raw.Mixer.AUDIO_U16LSB -> Format
FormatU16_LSB
Format
SDL.Raw.Mixer.AUDIO_S16LSB -> Format
FormatS16_LSB
Format
SDL.Raw.Mixer.AUDIO_U16MSB -> Format
FormatU16_MSB
Format
SDL.Raw.Mixer.AUDIO_S16MSB -> Format
FormatS16_MSB
Format
SDL.Raw.Mixer.AUDIO_U16SYS -> Format
FormatU16_Sys
Format
SDL.Raw.Mixer.AUDIO_S16SYS -> Format
FormatS16_Sys
Format
_ -> String -> Format
forall a. HasCallStack => String -> a
error String
"SDL.Mixer.wordToFormat: unknown Format."
data Output = Mono | Stereo
deriving stock (Output -> Output -> Bool
(Output -> Output -> Bool)
-> (Output -> Output -> Bool) -> Eq Output
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Output -> Output -> Bool
== :: Output -> Output -> Bool
$c/= :: Output -> Output -> Bool
/= :: Output -> Output -> Bool
Eq, Eq Output
Eq Output
-> (Output -> Output -> Ordering)
-> (Output -> Output -> Bool)
-> (Output -> Output -> Bool)
-> (Output -> Output -> Bool)
-> (Output -> Output -> Bool)
-> (Output -> Output -> Output)
-> (Output -> Output -> Output)
-> Ord Output
Output -> Output -> Bool
Output -> Output -> Ordering
Output -> Output -> Output
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
$ccompare :: Output -> Output -> Ordering
compare :: Output -> Output -> Ordering
$c< :: Output -> Output -> Bool
< :: Output -> Output -> Bool
$c<= :: Output -> Output -> Bool
<= :: Output -> Output -> Bool
$c> :: Output -> Output -> Bool
> :: Output -> Output -> Bool
$c>= :: Output -> Output -> Bool
>= :: Output -> Output -> Bool
$cmax :: Output -> Output -> Output
max :: Output -> Output -> Output
$cmin :: Output -> Output -> Output
min :: Output -> Output -> Output
Ord, Output
Output -> Output -> Bounded Output
forall a. a -> a -> Bounded a
$cminBound :: Output
minBound :: Output
$cmaxBound :: Output
maxBound :: Output
Bounded, ReadPrec [Output]
ReadPrec Output
Volume -> ReadS Output
ReadS [Output]
(Volume -> ReadS Output)
-> ReadS [Output]
-> ReadPrec Output
-> ReadPrec [Output]
-> Read Output
forall a.
(Volume -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Volume -> ReadS Output
readsPrec :: Volume -> ReadS Output
$creadList :: ReadS [Output]
readList :: ReadS [Output]
$creadPrec :: ReadPrec Output
readPrec :: ReadPrec Output
$creadListPrec :: ReadPrec [Output]
readListPrec :: ReadPrec [Output]
Read, Volume -> Output -> ShowS
[Output] -> ShowS
Output -> String
(Volume -> Output -> ShowS)
-> (Output -> String) -> ([Output] -> ShowS) -> Show Output
forall a.
(Volume -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Volume -> Output -> ShowS
showsPrec :: Volume -> Output -> ShowS
$cshow :: Output -> String
show :: Output -> String
$cshowList :: [Output] -> ShowS
showList :: [Output] -> ShowS
Show)
outputToCInt :: Output -> CInt
outputToCInt :: Output -> CInt
outputToCInt = \case
Output
Mono -> CInt
1
Output
Stereo -> CInt
2
cIntToOutput :: CInt -> Output
cIntToOutput :: CInt -> Output
cIntToOutput = \case
CInt
1 -> Output
Mono
CInt
2 -> Output
Stereo
CInt
_ -> String -> Output
forall a. HasCallStack => String -> a
error String
"SDL.Mixer.cIntToOutput: unknown number of channels."
queryAudio :: MonadIO m => m Audio
queryAudio :: forall (m :: * -> *). MonadIO m => m Audio
queryAudio =
IO Audio -> m Audio
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
(IO Audio -> m Audio)
-> ((Ptr CInt -> IO Audio) -> IO Audio)
-> (Ptr CInt -> IO Audio)
-> m Audio
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Ptr CInt -> IO Audio) -> IO Audio
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca
((Ptr CInt -> IO Audio) -> m Audio)
-> (Ptr CInt -> IO Audio) -> m Audio
forall a b. (a -> b) -> a -> b
$ \Ptr CInt
freq ->
(Ptr Format -> IO Audio) -> IO Audio
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr Format -> IO Audio) -> IO Audio)
-> (Ptr Format -> IO Audio) -> IO Audio
forall a b. (a -> b) -> a -> b
$ \Ptr Format
form ->
(Ptr CInt -> IO Audio) -> IO Audio
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CInt -> IO Audio) -> IO Audio)
-> (Ptr CInt -> IO Audio) -> IO Audio
forall a b. (a -> b) -> a -> b
$ \Ptr CInt
chan -> do
IO CInt -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO CInt -> IO ()) -> (IO CInt -> IO CInt) -> IO CInt -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> IO CInt -> IO CInt
forall a (m :: * -> *).
(Eq a, MonadIO m, Num a) =>
Text -> Text -> m a -> m a
throwIf0 Text
"SDL.Mixer.queryAudio" Text
"Mix_QuerySpec" (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$
Ptr CInt -> Ptr Format -> Ptr CInt -> IO CInt
forall {m :: * -> *}.
MonadIO m =>
Ptr CInt -> Ptr Format -> Ptr CInt -> m CInt
SDL.Raw.Mixer.querySpec Ptr CInt
freq Ptr Format
form Ptr CInt
chan
Volume -> Format -> Output -> Audio
Audio
(Volume -> Format -> Output -> Audio)
-> IO Volume -> IO (Format -> Output -> Audio)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Volume) -> IO CInt -> IO Volume
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
freq)
IO (Format -> Output -> Audio) -> IO Format -> IO (Output -> Audio)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Format -> Format
wordToFormat (Format -> Format) -> IO Format -> IO Format
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Format -> IO Format
forall a. Storable a => Ptr a -> IO a
peek Ptr Format
form)
IO (Output -> Audio) -> IO Output -> IO Audio
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (CInt -> Output
cIntToOutput (CInt -> Output) -> IO CInt -> IO Output
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
chan)
closeAudio :: MonadIO m => m ()
closeAudio :: forall (m :: * -> *). MonadIO m => m ()
closeAudio = m ()
forall (m :: * -> *). MonadIO m => m ()
SDL.Raw.Mixer.closeAudio
class Loadable a where
decode :: MonadIO m => ByteString -> m a
load :: MonadIO m => FilePath -> m a
load = ByteString -> m a
forall a (m :: * -> *).
(Loadable a, MonadIO m) =>
ByteString -> m a
forall (m :: * -> *). MonadIO m => ByteString -> m a
decode (ByteString -> m a) -> (String -> m ByteString) -> String -> m a
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString)
-> (String -> IO ByteString) -> String -> m ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO ByteString
BS.readFile)
free :: MonadIO m => a -> m ()
type Volume = Int
volumeToCInt :: Volume -> CInt
volumeToCInt :: Volume -> CInt
volumeToCInt = Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Volume -> CInt) -> (Volume -> Volume) -> Volume -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Volume -> Volume -> Volume
forall a. Ord a => a -> a -> a
max Volume
0 (Volume -> Volume) -> (Volume -> Volume) -> Volume -> Volume
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Volume -> Volume -> Volume
forall a. Ord a => a -> a -> a
min Volume
128
class HasVolume a where
getVolume :: MonadIO m => a -> m Volume
setVolume :: MonadIO m => Volume -> a -> m ()
chunkDecoders :: MonadIO m => m [String]
chunkDecoders :: forall (m :: * -> *). MonadIO m => m [String]
chunkDecoders =
IO [String] -> m [String]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [String] -> m [String]) -> IO [String] -> m [String]
forall a b. (a -> b) -> a -> b
$ do
CInt
num <- IO CInt
forall (m :: * -> *). MonadIO m => m CInt
SDL.Raw.Mixer.getNumChunkDecoders
[CInt] -> (CInt -> IO String) -> IO [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [CInt
0 .. CInt
num CInt -> CInt -> CInt
forall a. Num a => a -> a -> a
- CInt
1] ((CInt -> IO String) -> IO [String])
-> (CInt -> IO String) -> IO [String]
forall a b. (a -> b) -> a -> b
$ CInt -> IO CString
forall {m :: * -> *}. MonadIO m => CInt -> m CString
SDL.Raw.Mixer.getChunkDecoder (CInt -> IO CString) -> (CString -> IO String) -> CInt -> IO String
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CString -> IO String
peekCString
newtype Chunk = Chunk (Ptr SDL.Raw.Mixer.Chunk)
deriving stock (Chunk -> Chunk -> Bool
(Chunk -> Chunk -> Bool) -> (Chunk -> Chunk -> Bool) -> Eq Chunk
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Chunk -> Chunk -> Bool
== :: Chunk -> Chunk -> Bool
$c/= :: Chunk -> Chunk -> Bool
/= :: Chunk -> Chunk -> Bool
Eq, Volume -> Chunk -> ShowS
[Chunk] -> ShowS
Chunk -> String
(Volume -> Chunk -> ShowS)
-> (Chunk -> String) -> ([Chunk] -> ShowS) -> Show Chunk
forall a.
(Volume -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Volume -> Chunk -> ShowS
showsPrec :: Volume -> Chunk -> ShowS
$cshow :: Chunk -> String
show :: Chunk -> String
$cshowList :: [Chunk] -> ShowS
showList :: [Chunk] -> ShowS
Show)
instance Loadable Chunk where
decode :: forall (m :: * -> *). MonadIO m => ByteString -> m Chunk
decode ByteString
bytes = IO Chunk -> m Chunk
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Chunk -> m Chunk) -> IO Chunk -> m Chunk
forall a b. (a -> b) -> a -> b
$ do
ByteString -> (CStringLen -> IO Chunk) -> IO Chunk
forall a. ByteString -> (CStringLen -> IO a) -> IO a
unsafeUseAsCStringLen ByteString
bytes ((CStringLen -> IO Chunk) -> IO Chunk)
-> (CStringLen -> IO Chunk) -> IO Chunk
forall a b. (a -> b) -> a -> b
$ \(CString
cstr, Volume
len) -> do
Ptr RWops
rw <- Ptr () -> CInt -> IO (Ptr RWops)
forall (m :: * -> *). MonadIO m => Ptr () -> CInt -> m (Ptr RWops)
rwFromConstMem (CString -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr CString
cstr) (Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
len)
(Ptr Chunk -> Chunk) -> IO (Ptr Chunk) -> IO Chunk
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Chunk -> Chunk
Chunk
(IO (Ptr Chunk) -> IO Chunk)
-> (IO (Ptr Chunk) -> IO (Ptr Chunk)) -> IO (Ptr Chunk) -> IO Chunk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> IO (Ptr Chunk) -> IO (Ptr Chunk)
forall (m :: * -> *) a.
MonadIO m =>
Text -> Text -> m (Ptr a) -> m (Ptr a)
throwIfNull Text
"SDL.Mixer.decode<Chunk>" Text
"Mix_LoadWAV_RW"
(IO (Ptr Chunk) -> IO Chunk) -> IO (Ptr Chunk) -> IO Chunk
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> CInt -> IO (Ptr Chunk)
forall {m :: * -> *}.
MonadIO m =>
Ptr RWops -> CInt -> m (Ptr Chunk)
SDL.Raw.Mixer.loadWAV_RW Ptr RWops
rw CInt
0
free :: forall (m :: * -> *). MonadIO m => Chunk -> m ()
free (Chunk Ptr Chunk
p) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr Chunk -> IO ()
forall {m :: * -> *}. MonadIO m => Ptr Chunk -> m ()
SDL.Raw.Mixer.freeChunk Ptr Chunk
p
instance HasVolume Chunk where
getVolume :: forall (m :: * -> *). MonadIO m => Chunk -> m Volume
getVolume (Chunk Ptr Chunk
p) = CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Volume) -> m CInt -> m Volume
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Chunk -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => Ptr Chunk -> CInt -> m CInt
SDL.Raw.Mixer.volumeChunk Ptr Chunk
p (-CInt
1)
setVolume :: forall (m :: * -> *). MonadIO m => Volume -> Chunk -> m ()
setVolume Volume
v (Chunk Ptr Chunk
p) = m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> (CInt -> m CInt) -> CInt -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr Chunk -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => Ptr Chunk -> CInt -> m CInt
SDL.Raw.Mixer.volumeChunk Ptr Chunk
p (CInt -> m ()) -> CInt -> m ()
forall a b. (a -> b) -> a -> b
$ Volume -> CInt
volumeToCInt Volume
v
newtype Channel = Channel CInt
deriving stock (Channel -> Channel -> Bool
(Channel -> Channel -> Bool)
-> (Channel -> Channel -> Bool) -> Eq Channel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Channel -> Channel -> Bool
== :: Channel -> Channel -> Bool
$c/= :: Channel -> Channel -> Bool
/= :: Channel -> Channel -> Bool
Eq, Eq Channel
Eq Channel
-> (Channel -> Channel -> Ordering)
-> (Channel -> Channel -> Bool)
-> (Channel -> Channel -> Bool)
-> (Channel -> Channel -> Bool)
-> (Channel -> Channel -> Bool)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> Ord Channel
Channel -> Channel -> Bool
Channel -> Channel -> Ordering
Channel -> Channel -> Channel
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
$ccompare :: Channel -> Channel -> Ordering
compare :: Channel -> Channel -> Ordering
$c< :: Channel -> Channel -> Bool
< :: Channel -> Channel -> Bool
$c<= :: Channel -> Channel -> Bool
<= :: Channel -> Channel -> Bool
$c> :: Channel -> Channel -> Bool
> :: Channel -> Channel -> Bool
$c>= :: Channel -> Channel -> Bool
>= :: Channel -> Channel -> Bool
$cmax :: Channel -> Channel -> Channel
max :: Channel -> Channel -> Channel
$cmin :: Channel -> Channel -> Channel
min :: Channel -> Channel -> Channel
Ord)
deriving newtype (Volume -> Channel
Channel -> Volume
Channel -> [Channel]
Channel -> Channel
Channel -> Channel -> [Channel]
Channel -> Channel -> Channel -> [Channel]
(Channel -> Channel)
-> (Channel -> Channel)
-> (Volume -> Channel)
-> (Channel -> Volume)
-> (Channel -> [Channel])
-> (Channel -> Channel -> [Channel])
-> (Channel -> Channel -> [Channel])
-> (Channel -> Channel -> Channel -> [Channel])
-> Enum Channel
forall a.
(a -> a)
-> (a -> a)
-> (Volume -> a)
-> (a -> Volume)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Channel -> Channel
succ :: Channel -> Channel
$cpred :: Channel -> Channel
pred :: Channel -> Channel
$ctoEnum :: Volume -> Channel
toEnum :: Volume -> Channel
$cfromEnum :: Channel -> Volume
fromEnum :: Channel -> Volume
$cenumFrom :: Channel -> [Channel]
enumFrom :: Channel -> [Channel]
$cenumFromThen :: Channel -> Channel -> [Channel]
enumFromThen :: Channel -> Channel -> [Channel]
$cenumFromTo :: Channel -> Channel -> [Channel]
enumFromTo :: Channel -> Channel -> [Channel]
$cenumFromThenTo :: Channel -> Channel -> Channel -> [Channel]
enumFromThenTo :: Channel -> Channel -> Channel -> [Channel]
Enum, Enum Channel
Real Channel
Real Channel
-> Enum Channel
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> (Channel, Channel))
-> (Channel -> Channel -> (Channel, Channel))
-> (Channel -> Integer)
-> Integral Channel
Channel -> Integer
Channel -> Channel -> (Channel, Channel)
Channel -> Channel -> Channel
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Channel -> Channel -> Channel
quot :: Channel -> Channel -> Channel
$crem :: Channel -> Channel -> Channel
rem :: Channel -> Channel -> Channel
$cdiv :: Channel -> Channel -> Channel
div :: Channel -> Channel -> Channel
$cmod :: Channel -> Channel -> Channel
mod :: Channel -> Channel -> Channel
$cquotRem :: Channel -> Channel -> (Channel, Channel)
quotRem :: Channel -> Channel -> (Channel, Channel)
$cdivMod :: Channel -> Channel -> (Channel, Channel)
divMod :: Channel -> Channel -> (Channel, Channel)
$ctoInteger :: Channel -> Integer
toInteger :: Channel -> Integer
Integral, Num Channel
Ord Channel
Num Channel -> Ord Channel -> (Channel -> Rational) -> Real Channel
Channel -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
$ctoRational :: Channel -> Rational
toRational :: Channel -> Rational
Real, Integer -> Channel
Channel -> Channel
Channel -> Channel -> Channel
(Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel -> Channel)
-> (Channel -> Channel)
-> (Channel -> Channel)
-> (Channel -> Channel)
-> (Integer -> Channel)
-> Num Channel
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Channel -> Channel -> Channel
+ :: Channel -> Channel -> Channel
$c- :: Channel -> Channel -> Channel
- :: Channel -> Channel -> Channel
$c* :: Channel -> Channel -> Channel
* :: Channel -> Channel -> Channel
$cnegate :: Channel -> Channel
negate :: Channel -> Channel
$cabs :: Channel -> Channel
abs :: Channel -> Channel
$csignum :: Channel -> Channel
signum :: Channel -> Channel
$cfromInteger :: Integer -> Channel
fromInteger :: Integer -> Channel
Num)
instance Show Channel where
show :: Channel -> String
show = \case
Channel
AllChannels -> String
"AllChannels"
Channel CInt
c -> String
"Channel " String -> ShowS
forall a. [a] -> [a] -> [a]
++ CInt -> String
forall a. Show a => a -> String
show CInt
c
clipChan :: CInt -> CInt
clipChan :: CInt -> CInt
clipChan = CInt -> CInt -> CInt
forall a. Ord a => a -> a -> a
max CInt
forall {a}. (Eq a, Num a) => a
SDL.Raw.Mixer.CHANNEL_POST
setChannels :: MonadIO m => Int -> m ()
setChannels :: forall (m :: * -> *). MonadIO m => Volume -> m ()
setChannels = m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> (Volume -> m CInt) -> Volume -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.allocateChannels (CInt -> m CInt) -> (Volume -> CInt) -> Volume -> m CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Volume -> CInt) -> (Volume -> Volume) -> Volume -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Volume -> Volume -> Volume
forall a. Ord a => a -> a -> a
max Volume
0
getChannels :: MonadIO m => m Int
getChannels :: forall (m :: * -> *). MonadIO m => m Volume
getChannels = CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Volume) -> m CInt -> m Volume
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.allocateChannels (-CInt
1)
reserveChannels :: MonadIO m => Int -> m Int
reserveChannels :: forall (m :: * -> *). MonadIO m => Volume -> m Volume
reserveChannels =
(CInt -> Volume) -> m CInt -> m Volume
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (m CInt -> m Volume) -> (Volume -> m CInt) -> Volume -> m Volume
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.reserveChannels (CInt -> m CInt) -> (Volume -> CInt) -> Volume -> m CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral
playedLast :: MonadIO m => Channel -> m (Maybe Chunk)
playedLast :: forall (m :: * -> *). MonadIO m => Channel -> m (Maybe Chunk)
playedLast (Channel CInt
c) = do
Ptr Chunk
p <- CInt -> m (Ptr Chunk)
forall {m :: * -> *}. MonadIO m => CInt -> m (Ptr Chunk)
SDL.Raw.Mixer.getChunk (CInt -> m (Ptr Chunk)) -> CInt -> m (Ptr Chunk)
forall a b. (a -> b) -> a -> b
$ CInt -> CInt
clipChan CInt
c
Maybe Chunk -> m (Maybe Chunk)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Chunk -> m (Maybe Chunk)) -> Maybe Chunk -> m (Maybe Chunk)
forall a b. (a -> b) -> a -> b
$ if Ptr Chunk
p Ptr Chunk -> Ptr Chunk -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Chunk
forall a. Ptr a
nullPtr then Maybe Chunk
forall a. Maybe a
Nothing else Chunk -> Maybe Chunk
forall a. a -> Maybe a
Just (Ptr Chunk -> Chunk
Chunk Ptr Chunk
p)
pattern AllChannels :: Channel
pattern $mAllChannels :: forall {r}. Channel -> ((# #) -> r) -> ((# #) -> r) -> r
$bAllChannels :: Channel
AllChannels = -1
instance HasVolume Channel where
setVolume :: forall (m :: * -> *). MonadIO m => Volume -> Channel -> m ()
setVolume Volume
v (Channel CInt
c) =
m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> (CInt -> m CInt) -> CInt -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> CInt -> m CInt
SDL.Raw.Mixer.volume (CInt -> CInt
clipChan CInt
c) (CInt -> m ()) -> CInt -> m ()
forall a b. (a -> b) -> a -> b
$ Volume -> CInt
volumeToCInt Volume
v
getVolume :: forall (m :: * -> *). MonadIO m => Channel -> m Volume
getVolume (Channel CInt
c) =
CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Volume) -> m CInt -> m Volume
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> CInt -> m CInt
SDL.Raw.Mixer.volume (CInt -> CInt
clipChan CInt
c) (-CInt
1)
play :: MonadIO m => Chunk -> m ()
play :: forall (m :: * -> *). MonadIO m => Chunk -> m ()
play = m Channel -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m Channel -> m ()) -> (Chunk -> m Channel) -> Chunk -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Channel -> Times -> Chunk -> m Channel
forall (m :: * -> *).
MonadIO m =>
Channel -> Times -> Chunk -> m Channel
playOn (-Channel
1) Times
Once
playForever :: MonadIO m => Chunk -> m ()
playForever :: forall (m :: * -> *). MonadIO m => Chunk -> m ()
playForever = m Channel -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m Channel -> m ()) -> (Chunk -> m Channel) -> Chunk -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Channel -> Times -> Chunk -> m Channel
forall (m :: * -> *).
MonadIO m =>
Channel -> Times -> Chunk -> m Channel
playOn (-Channel
1) Times
Forever
newtype Times = Times CInt
deriving stock (Times -> Times -> Bool
(Times -> Times -> Bool) -> (Times -> Times -> Bool) -> Eq Times
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Times -> Times -> Bool
== :: Times -> Times -> Bool
$c/= :: Times -> Times -> Bool
/= :: Times -> Times -> Bool
Eq, Eq Times
Eq Times
-> (Times -> Times -> Ordering)
-> (Times -> Times -> Bool)
-> (Times -> Times -> Bool)
-> (Times -> Times -> Bool)
-> (Times -> Times -> Bool)
-> (Times -> Times -> Times)
-> (Times -> Times -> Times)
-> Ord Times
Times -> Times -> Bool
Times -> Times -> Ordering
Times -> Times -> Times
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
$ccompare :: Times -> Times -> Ordering
compare :: Times -> Times -> Ordering
$c< :: Times -> Times -> Bool
< :: Times -> Times -> Bool
$c<= :: Times -> Times -> Bool
<= :: Times -> Times -> Bool
$c> :: Times -> Times -> Bool
> :: Times -> Times -> Bool
$c>= :: Times -> Times -> Bool
>= :: Times -> Times -> Bool
$cmax :: Times -> Times -> Times
max :: Times -> Times -> Times
$cmin :: Times -> Times -> Times
min :: Times -> Times -> Times
Ord)
deriving newtype (Volume -> Times
Times -> Volume
Times -> [Times]
Times -> Times
Times -> Times -> [Times]
Times -> Times -> Times -> [Times]
(Times -> Times)
-> (Times -> Times)
-> (Volume -> Times)
-> (Times -> Volume)
-> (Times -> [Times])
-> (Times -> Times -> [Times])
-> (Times -> Times -> [Times])
-> (Times -> Times -> Times -> [Times])
-> Enum Times
forall a.
(a -> a)
-> (a -> a)
-> (Volume -> a)
-> (a -> Volume)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Times -> Times
succ :: Times -> Times
$cpred :: Times -> Times
pred :: Times -> Times
$ctoEnum :: Volume -> Times
toEnum :: Volume -> Times
$cfromEnum :: Times -> Volume
fromEnum :: Times -> Volume
$cenumFrom :: Times -> [Times]
enumFrom :: Times -> [Times]
$cenumFromThen :: Times -> Times -> [Times]
enumFromThen :: Times -> Times -> [Times]
$cenumFromTo :: Times -> Times -> [Times]
enumFromTo :: Times -> Times -> [Times]
$cenumFromThenTo :: Times -> Times -> Times -> [Times]
enumFromThenTo :: Times -> Times -> Times -> [Times]
Enum, Enum Times
Real Times
Real Times
-> Enum Times
-> (Times -> Times -> Times)
-> (Times -> Times -> Times)
-> (Times -> Times -> Times)
-> (Times -> Times -> Times)
-> (Times -> Times -> (Times, Times))
-> (Times -> Times -> (Times, Times))
-> (Times -> Integer)
-> Integral Times
Times -> Integer
Times -> Times -> (Times, Times)
Times -> Times -> Times
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Times -> Times -> Times
quot :: Times -> Times -> Times
$crem :: Times -> Times -> Times
rem :: Times -> Times -> Times
$cdiv :: Times -> Times -> Times
div :: Times -> Times -> Times
$cmod :: Times -> Times -> Times
mod :: Times -> Times -> Times
$cquotRem :: Times -> Times -> (Times, Times)
quotRem :: Times -> Times -> (Times, Times)
$cdivMod :: Times -> Times -> (Times, Times)
divMod :: Times -> Times -> (Times, Times)
$ctoInteger :: Times -> Integer
toInteger :: Times -> Integer
Integral, Num Times
Ord Times
Num Times -> Ord Times -> (Times -> Rational) -> Real Times
Times -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
$ctoRational :: Times -> Rational
toRational :: Times -> Rational
Real, Integer -> Times
Times -> Times
Times -> Times -> Times
(Times -> Times -> Times)
-> (Times -> Times -> Times)
-> (Times -> Times -> Times)
-> (Times -> Times)
-> (Times -> Times)
-> (Times -> Times)
-> (Integer -> Times)
-> Num Times
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Times -> Times -> Times
+ :: Times -> Times -> Times
$c- :: Times -> Times -> Times
- :: Times -> Times -> Times
$c* :: Times -> Times -> Times
* :: Times -> Times -> Times
$cnegate :: Times -> Times
negate :: Times -> Times
$cabs :: Times -> Times
abs :: Times -> Times
$csignum :: Times -> Times
signum :: Times -> Times
$cfromInteger :: Integer -> Times
fromInteger :: Integer -> Times
Num)
pattern Once :: Times
pattern $mOnce :: forall {r}. Times -> ((# #) -> r) -> ((# #) -> r) -> r
$bOnce :: Times
Once = 1
pattern Forever :: Times
pattern $mForever :: forall {r}. Times -> ((# #) -> r) -> ((# #) -> r) -> r
$bForever :: Times
Forever = 0
playOn :: MonadIO m => Channel -> Times -> Chunk -> m Channel
playOn :: forall (m :: * -> *).
MonadIO m =>
Channel -> Times -> Chunk -> m Channel
playOn = Volume -> Channel -> Times -> Chunk -> m Channel
forall (m :: * -> *).
MonadIO m =>
Volume -> Channel -> Times -> Chunk -> m Channel
playLimit Volume
NoLimit
type Milliseconds = Int
type Limit = Milliseconds
pattern NoLimit :: Limit
pattern $mNoLimit :: forall {r}. Volume -> ((# #) -> r) -> ((# #) -> r) -> r
$bNoLimit :: Volume
NoLimit = -1
playLimit :: MonadIO m => Limit -> Channel -> Times -> Chunk -> m Channel
playLimit :: forall (m :: * -> *).
MonadIO m =>
Volume -> Channel -> Times -> Chunk -> m Channel
playLimit Volume
l (Channel CInt
c) (Times CInt
t) (Chunk Ptr Chunk
p) =
Text -> Text -> m Channel -> m Channel
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m a
throwIfNeg
Text
"SDL.Mixer.playLimit"
Text
"Mix_PlayChannelTimed"
( CInt -> Channel
forall a b. (Integral a, Num b) => a -> b
fromIntegral
(CInt -> Channel) -> m CInt -> m Channel
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> Ptr Chunk -> CInt -> CInt -> m CInt
forall {m :: * -> *}.
MonadIO m =>
CInt -> Ptr Chunk -> CInt -> CInt -> m CInt
SDL.Raw.Mixer.playChannelTimed
(CInt -> CInt
clipChan CInt
c)
Ptr Chunk
p
(CInt -> CInt -> CInt
forall a. Ord a => a -> a -> a
max (-CInt
1) (CInt -> CInt) -> CInt -> CInt
forall a b. (a -> b) -> a -> b
$ CInt
t CInt -> CInt -> CInt
forall a. Num a => a -> a -> a
- CInt
1)
(Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
l)
)
fadeIn :: MonadIO m => Milliseconds -> Chunk -> m ()
fadeIn :: forall (m :: * -> *). MonadIO m => Volume -> Chunk -> m ()
fadeIn Volume
ms = m Channel -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m Channel -> m ()) -> (Chunk -> m Channel) -> Chunk -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Channel -> Times -> Volume -> Chunk -> m Channel
forall (m :: * -> *).
MonadIO m =>
Channel -> Times -> Volume -> Chunk -> m Channel
fadeInOn Channel
AllChannels Times
Once Volume
ms
fadeInOn :: MonadIO m => Channel -> Times -> Milliseconds -> Chunk -> m Channel
fadeInOn :: forall (m :: * -> *).
MonadIO m =>
Channel -> Times -> Volume -> Chunk -> m Channel
fadeInOn = Volume -> Channel -> Times -> Volume -> Chunk -> m Channel
forall (m :: * -> *).
MonadIO m =>
Volume -> Channel -> Times -> Volume -> Chunk -> m Channel
fadeInLimit Volume
NoLimit
fadeInLimit ::
MonadIO m =>
Limit ->
Channel ->
Times ->
Milliseconds ->
Chunk ->
m Channel
fadeInLimit :: forall (m :: * -> *).
MonadIO m =>
Volume -> Channel -> Times -> Volume -> Chunk -> m Channel
fadeInLimit Volume
l (Channel CInt
c) (Times CInt
t) Volume
ms (Chunk Ptr Chunk
p) =
Text -> Text -> m Channel -> m Channel
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m a
throwIfNeg Text
"SDL.Mixer.fadeInLimit" Text
"Mix_FadeInChannelTimed" (m Channel -> m Channel) -> m Channel -> m Channel
forall a b. (a -> b) -> a -> b
$
CInt -> Channel
forall a b. (Integral a, Num b) => a -> b
fromIntegral
(CInt -> Channel) -> m CInt -> m Channel
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> Ptr Chunk -> CInt -> CInt -> CInt -> m CInt
forall {m :: * -> *}.
MonadIO m =>
CInt -> Ptr Chunk -> CInt -> CInt -> CInt -> m CInt
SDL.Raw.Mixer.fadeInChannelTimed
(CInt -> CInt
clipChan CInt
c)
Ptr Chunk
p
(CInt -> CInt -> CInt
forall a. Ord a => a -> a -> a
max (-CInt
1) (CInt -> CInt) -> CInt -> CInt
forall a b. (a -> b) -> a -> b
$ CInt
t CInt -> CInt -> CInt
forall a. Num a => a -> a -> a
- CInt
1)
(Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
ms)
(Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
l)
fadeOut :: MonadIO m => Milliseconds -> Channel -> m ()
fadeOut :: forall (m :: * -> *). MonadIO m => Volume -> Channel -> m ()
fadeOut Volume
ms (Channel CInt
c) =
m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$ CInt -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> CInt -> m CInt
SDL.Raw.Mixer.fadeOutChannel (CInt -> CInt
clipChan CInt
c) (CInt -> m CInt) -> CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
ms
fadeOutGroup :: MonadIO m => Milliseconds -> Group -> m ()
fadeOutGroup :: forall (m :: * -> *). MonadIO m => Volume -> Group -> m ()
fadeOutGroup Volume
ms = \case
Group
DefaultGroup -> Volume -> Channel -> m ()
forall (m :: * -> *). MonadIO m => Volume -> Channel -> m ()
fadeOut Volume
ms Channel
AllChannels
Group CInt
g -> m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$ CInt -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> CInt -> m CInt
SDL.Raw.Mixer.fadeOutGroup CInt
g (CInt -> m CInt) -> CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
ms
pause :: MonadIO m => Channel -> m ()
pause :: forall (m :: * -> *). MonadIO m => Channel -> m ()
pause (Channel CInt
c) = CInt -> m ()
forall {m :: * -> *}. MonadIO m => CInt -> m ()
SDL.Raw.Mixer.pause (CInt -> m ()) -> CInt -> m ()
forall a b. (a -> b) -> a -> b
$ CInt -> CInt
clipChan CInt
c
resume :: MonadIO m => Channel -> m ()
resume :: forall (m :: * -> *). MonadIO m => Channel -> m ()
resume (Channel CInt
c) = CInt -> m ()
forall {m :: * -> *}. MonadIO m => CInt -> m ()
SDL.Raw.Mixer.resume (CInt -> m ()) -> CInt -> m ()
forall a b. (a -> b) -> a -> b
$ CInt -> CInt
clipChan CInt
c
halt :: MonadIO m => Channel -> m ()
halt :: forall (m :: * -> *). MonadIO m => Channel -> m ()
halt (Channel CInt
c) = m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$ CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.haltChannel (CInt -> m CInt) -> CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ CInt -> CInt
clipChan CInt
c
haltAfter :: MonadIO m => Milliseconds -> Channel -> m ()
haltAfter :: forall (m :: * -> *). MonadIO m => Volume -> Channel -> m ()
haltAfter Volume
ms (Channel CInt
c) =
m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> (CInt -> m CInt) -> CInt -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> CInt -> m CInt
SDL.Raw.Mixer.expireChannel (CInt -> CInt
clipChan CInt
c) (CInt -> m ()) -> CInt -> m ()
forall a b. (a -> b) -> a -> b
$ Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
ms
haltGroup :: MonadIO m => Group -> m ()
haltGroup :: forall (m :: * -> *). MonadIO m => Group -> m ()
haltGroup = \case
Group
DefaultGroup -> Channel -> m ()
forall (m :: * -> *). MonadIO m => Channel -> m ()
halt Channel
AllChannels
Group CInt
g -> m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$ CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.haltGroup (CInt -> m CInt) -> CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ CInt -> CInt -> CInt
forall a. Ord a => a -> a -> a
max CInt
0 CInt
g
{-# NOINLINE channelFinishedFunPtr #-}
channelFinishedFunPtr :: IORef (FunPtr (SDL.Raw.Mixer.Channel -> IO ()))
channelFinishedFunPtr :: IORef (FunPtr (CInt -> IO ()))
channelFinishedFunPtr = IO (IORef (FunPtr (CInt -> IO ())))
-> IORef (FunPtr (CInt -> IO ()))
forall a. IO a -> a
unsafePerformIO (IO (IORef (FunPtr (CInt -> IO ())))
-> IORef (FunPtr (CInt -> IO ())))
-> IO (IORef (FunPtr (CInt -> IO ())))
-> IORef (FunPtr (CInt -> IO ()))
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> IO (IORef (FunPtr (CInt -> IO ())))
forall a. a -> IO (IORef a)
newIORef FunPtr (CInt -> IO ())
forall a. FunPtr a
nullFunPtr
whenChannelFinished :: MonadIO m => (Channel -> IO ()) -> m ()
whenChannelFinished :: forall (m :: * -> *). MonadIO m => (Channel -> IO ()) -> m ()
whenChannelFinished Channel -> IO ()
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let callback' :: CInt -> IO ()
callback' = Channel -> IO ()
callback (Channel -> IO ()) -> (CInt -> Channel) -> CInt -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Channel
Channel
FunPtr (CInt -> IO ())
callbackRaw <- (CInt -> IO ()) -> IO (FunPtr (CInt -> IO ()))
SDL.Raw.Mixer.wrapChannelCallback CInt -> IO ()
callback'
FunPtr (CInt -> IO ()) -> IO ()
forall {m :: * -> *}. MonadIO m => FunPtr (CInt -> IO ()) -> m ()
SDL.Raw.Mixer.channelFinished FunPtr (CInt -> IO ())
callbackRaw
FunPtr (CInt -> IO ())
lastFunPtr <- IORef (FunPtr (CInt -> IO ())) -> IO (FunPtr (CInt -> IO ()))
forall a. IORef a -> IO a
readIORef IORef (FunPtr (CInt -> IO ()))
channelFinishedFunPtr
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (FunPtr (CInt -> IO ())
lastFunPtr FunPtr (CInt -> IO ()) -> FunPtr (CInt -> IO ()) -> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr (CInt -> IO ())
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> IO ()
forall a. FunPtr a -> IO ()
freeHaskellFunPtr FunPtr (CInt -> IO ())
lastFunPtr
IORef (FunPtr (CInt -> IO ())) -> FunPtr (CInt -> IO ()) -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef (FunPtr (CInt -> IO ()))
channelFinishedFunPtr FunPtr (CInt -> IO ())
callbackRaw
playing :: MonadIO m => Channel -> m Bool
playing :: forall (m :: * -> *). MonadIO m => Channel -> m Bool
playing (Channel CInt
c) = (CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
> CInt
0) (CInt -> Bool) -> m CInt -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.playing (CInt -> CInt
clipChan CInt
c)
playingCount :: MonadIO m => m Int
playingCount :: forall (m :: * -> *). MonadIO m => m Volume
playingCount = CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Volume) -> m CInt -> m Volume
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.playing (-CInt
1)
paused :: MonadIO m => Channel -> m Bool
paused :: forall (m :: * -> *). MonadIO m => Channel -> m Bool
paused (Channel CInt
c) = (CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
> CInt
0) (CInt -> Bool) -> m CInt -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.paused (CInt -> CInt
clipChan CInt
c)
pausedCount :: MonadIO m => m Int
pausedCount :: forall (m :: * -> *). MonadIO m => m Volume
pausedCount = CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Volume) -> m CInt -> m Volume
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.paused (-CInt
1)
data Fading = NoFading | FadingIn | FadingOut
deriving stock (Fading -> Fading -> Bool
(Fading -> Fading -> Bool)
-> (Fading -> Fading -> Bool) -> Eq Fading
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Fading -> Fading -> Bool
== :: Fading -> Fading -> Bool
$c/= :: Fading -> Fading -> Bool
/= :: Fading -> Fading -> Bool
Eq, Eq Fading
Eq Fading
-> (Fading -> Fading -> Ordering)
-> (Fading -> Fading -> Bool)
-> (Fading -> Fading -> Bool)
-> (Fading -> Fading -> Bool)
-> (Fading -> Fading -> Bool)
-> (Fading -> Fading -> Fading)
-> (Fading -> Fading -> Fading)
-> Ord Fading
Fading -> Fading -> Bool
Fading -> Fading -> Ordering
Fading -> Fading -> Fading
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
$ccompare :: Fading -> Fading -> Ordering
compare :: Fading -> Fading -> Ordering
$c< :: Fading -> Fading -> Bool
< :: Fading -> Fading -> Bool
$c<= :: Fading -> Fading -> Bool
<= :: Fading -> Fading -> Bool
$c> :: Fading -> Fading -> Bool
> :: Fading -> Fading -> Bool
$c>= :: Fading -> Fading -> Bool
>= :: Fading -> Fading -> Bool
$cmax :: Fading -> Fading -> Fading
max :: Fading -> Fading -> Fading
$cmin :: Fading -> Fading -> Fading
min :: Fading -> Fading -> Fading
Ord, Volume -> Fading -> ShowS
[Fading] -> ShowS
Fading -> String
(Volume -> Fading -> ShowS)
-> (Fading -> String) -> ([Fading] -> ShowS) -> Show Fading
forall a.
(Volume -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Volume -> Fading -> ShowS
showsPrec :: Volume -> Fading -> ShowS
$cshow :: Fading -> String
show :: Fading -> String
$cshowList :: [Fading] -> ShowS
showList :: [Fading] -> ShowS
Show, ReadPrec [Fading]
ReadPrec Fading
Volume -> ReadS Fading
ReadS [Fading]
(Volume -> ReadS Fading)
-> ReadS [Fading]
-> ReadPrec Fading
-> ReadPrec [Fading]
-> Read Fading
forall a.
(Volume -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Volume -> ReadS Fading
readsPrec :: Volume -> ReadS Fading
$creadList :: ReadS [Fading]
readList :: ReadS [Fading]
$creadPrec :: ReadPrec Fading
readPrec :: ReadPrec Fading
$creadListPrec :: ReadPrec [Fading]
readListPrec :: ReadPrec [Fading]
Read)
wordToFading :: SDL.Raw.Mixer.Fading -> Fading
wordToFading :: MusicType -> Fading
wordToFading = \case
MusicType
SDL.Raw.Mixer.NO_FADING -> Fading
NoFading
MusicType
SDL.Raw.Mixer.FADING_IN -> Fading
FadingIn
MusicType
SDL.Raw.Mixer.FADING_OUT -> Fading
FadingOut
MusicType
_ -> String -> Fading
forall a. HasCallStack => String -> a
error String
"SDL.Mixer.wordToFading: unknown Fading value."
fading :: MonadIO m => Channel -> m Fading
fading :: forall (m :: * -> *). MonadIO m => Channel -> m Fading
fading (Channel CInt
c) =
MusicType -> Fading
wordToFading (MusicType -> Fading) -> m MusicType -> m Fading
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> m MusicType
forall {m :: * -> *}. MonadIO m => CInt -> m MusicType
SDL.Raw.Mixer.fadingChannel (CInt -> CInt
clipChan CInt
c)
newtype Group = Group CInt
deriving stock (Group -> Group -> Bool
(Group -> Group -> Bool) -> (Group -> Group -> Bool) -> Eq Group
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Group -> Group -> Bool
== :: Group -> Group -> Bool
$c/= :: Group -> Group -> Bool
/= :: Group -> Group -> Bool
Eq, Eq Group
Eq Group
-> (Group -> Group -> Ordering)
-> (Group -> Group -> Bool)
-> (Group -> Group -> Bool)
-> (Group -> Group -> Bool)
-> (Group -> Group -> Bool)
-> (Group -> Group -> Group)
-> (Group -> Group -> Group)
-> Ord Group
Group -> Group -> Bool
Group -> Group -> Ordering
Group -> Group -> Group
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
$ccompare :: Group -> Group -> Ordering
compare :: Group -> Group -> Ordering
$c< :: Group -> Group -> Bool
< :: Group -> Group -> Bool
$c<= :: Group -> Group -> Bool
<= :: Group -> Group -> Bool
$c> :: Group -> Group -> Bool
> :: Group -> Group -> Bool
$c>= :: Group -> Group -> Bool
>= :: Group -> Group -> Bool
$cmax :: Group -> Group -> Group
max :: Group -> Group -> Group
$cmin :: Group -> Group -> Group
min :: Group -> Group -> Group
Ord)
deriving newtype (Volume -> Group
Group -> Volume
Group -> [Group]
Group -> Group
Group -> Group -> [Group]
Group -> Group -> Group -> [Group]
(Group -> Group)
-> (Group -> Group)
-> (Volume -> Group)
-> (Group -> Volume)
-> (Group -> [Group])
-> (Group -> Group -> [Group])
-> (Group -> Group -> [Group])
-> (Group -> Group -> Group -> [Group])
-> Enum Group
forall a.
(a -> a)
-> (a -> a)
-> (Volume -> a)
-> (a -> Volume)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Group -> Group
succ :: Group -> Group
$cpred :: Group -> Group
pred :: Group -> Group
$ctoEnum :: Volume -> Group
toEnum :: Volume -> Group
$cfromEnum :: Group -> Volume
fromEnum :: Group -> Volume
$cenumFrom :: Group -> [Group]
enumFrom :: Group -> [Group]
$cenumFromThen :: Group -> Group -> [Group]
enumFromThen :: Group -> Group -> [Group]
$cenumFromTo :: Group -> Group -> [Group]
enumFromTo :: Group -> Group -> [Group]
$cenumFromThenTo :: Group -> Group -> Group -> [Group]
enumFromThenTo :: Group -> Group -> Group -> [Group]
Enum, Enum Group
Real Group
Real Group
-> Enum Group
-> (Group -> Group -> Group)
-> (Group -> Group -> Group)
-> (Group -> Group -> Group)
-> (Group -> Group -> Group)
-> (Group -> Group -> (Group, Group))
-> (Group -> Group -> (Group, Group))
-> (Group -> Integer)
-> Integral Group
Group -> Integer
Group -> Group -> (Group, Group)
Group -> Group -> Group
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Group -> Group -> Group
quot :: Group -> Group -> Group
$crem :: Group -> Group -> Group
rem :: Group -> Group -> Group
$cdiv :: Group -> Group -> Group
div :: Group -> Group -> Group
$cmod :: Group -> Group -> Group
mod :: Group -> Group -> Group
$cquotRem :: Group -> Group -> (Group, Group)
quotRem :: Group -> Group -> (Group, Group)
$cdivMod :: Group -> Group -> (Group, Group)
divMod :: Group -> Group -> (Group, Group)
$ctoInteger :: Group -> Integer
toInteger :: Group -> Integer
Integral, Num Group
Ord Group
Num Group -> Ord Group -> (Group -> Rational) -> Real Group
Group -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
$ctoRational :: Group -> Rational
toRational :: Group -> Rational
Real, Integer -> Group
Group -> Group
Group -> Group -> Group
(Group -> Group -> Group)
-> (Group -> Group -> Group)
-> (Group -> Group -> Group)
-> (Group -> Group)
-> (Group -> Group)
-> (Group -> Group)
-> (Integer -> Group)
-> Num Group
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Group -> Group -> Group
+ :: Group -> Group -> Group
$c- :: Group -> Group -> Group
- :: Group -> Group -> Group
$c* :: Group -> Group -> Group
* :: Group -> Group -> Group
$cnegate :: Group -> Group
negate :: Group -> Group
$cabs :: Group -> Group
abs :: Group -> Group
$csignum :: Group -> Group
signum :: Group -> Group
$cfromInteger :: Integer -> Group
fromInteger :: Integer -> Group
Num)
pattern DefaultGroup :: Group
pattern $mDefaultGroup :: forall {r}. Group -> ((# #) -> r) -> ((# #) -> r) -> r
$bDefaultGroup :: Group
DefaultGroup = -1
group :: MonadIO m => Group -> Channel -> m Bool
group :: forall (m :: * -> *). MonadIO m => Group -> Channel -> m Bool
group wrapped :: Group
wrapped@(Group CInt
g) Channel
channel =
case Channel
channel of
Channel
AllChannels -> do
Volume
total <- m Volume
forall (m :: * -> *). MonadIO m => m Volume
getChannels
if Volume
total Volume -> Volume -> Bool
forall a. Ord a => a -> a -> Bool
> Volume
0
then (Volume -> Volume -> Bool
forall a. Ord a => a -> a -> Bool
> Volume
0) (Volume -> Bool) -> m Volume -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Group -> Channel -> Channel -> m Volume
forall (m :: * -> *).
MonadIO m =>
Group -> Channel -> Channel -> m Volume
groupSpan Group
wrapped Channel
0 (CInt -> Channel
Channel (CInt -> Channel) -> CInt -> Channel
forall a b. (a -> b) -> a -> b
$ Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Volume -> CInt) -> Volume -> CInt
forall a b. (a -> b) -> a -> b
$ Volume
total Volume -> Volume -> Volume
forall a. Num a => a -> a -> a
- Volume
1)
else Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
Channel CInt
c ->
if CInt
c CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
>= CInt
0
then (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
== CInt
1) (CInt -> Bool) -> m CInt -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> CInt -> m CInt
SDL.Raw.Mixer.groupChannel CInt
c CInt
g
else Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
groupSpan :: MonadIO m => Group -> Channel -> Channel -> m Int
groupSpan :: forall (m :: * -> *).
MonadIO m =>
Group -> Channel -> Channel -> m Volume
groupSpan wrap :: Group
wrap@(Group CInt
g) from :: Channel
from@(Channel CInt
c1) to :: Channel
to@(Channel CInt
c2)
| CInt
c1 CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
< CInt
0 Bool -> Bool -> Bool
|| CInt
c2 CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
< CInt
0 = Volume -> m Volume
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Volume
0
| CInt
c1 CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
> CInt
c2 = Group -> Channel -> Channel -> m Volume
forall (m :: * -> *).
MonadIO m =>
Group -> Channel -> Channel -> m Volume
groupSpan Group
wrap Channel
to Channel
from
| Bool
otherwise = CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Volume) -> m CInt -> m Volume
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> CInt -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> CInt -> CInt -> m CInt
SDL.Raw.Mixer.groupChannels CInt
c1 CInt
c2 CInt
g
groupCount :: MonadIO m => Group -> m Int
groupCount :: forall (m :: * -> *). MonadIO m => Group -> m Volume
groupCount (Group CInt
g) = CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Volume) -> m CInt -> m Volume
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.groupCount CInt
g
getAvailable :: MonadIO m => Group -> m (Maybe Channel)
getAvailable :: forall (m :: * -> *). MonadIO m => Group -> m (Maybe Channel)
getAvailable (Group CInt
g) = do
CInt
found <- CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.groupAvailable CInt
g
Maybe Channel -> m (Maybe Channel)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Channel -> m (Maybe Channel))
-> Maybe Channel -> m (Maybe Channel)
forall a b. (a -> b) -> a -> b
$ if CInt
found CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
>= CInt
0 then Channel -> Maybe Channel
forall a. a -> Maybe a
Just (Channel -> Maybe Channel) -> Channel -> Maybe Channel
forall a b. (a -> b) -> a -> b
$ CInt -> Channel
forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
found else Maybe Channel
forall a. Maybe a
Nothing
getOldest :: MonadIO m => Group -> m (Maybe Channel)
getOldest :: forall (m :: * -> *). MonadIO m => Group -> m (Maybe Channel)
getOldest (Group CInt
g) = do
CInt
found <- CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.groupOldest CInt
g
Maybe Channel -> m (Maybe Channel)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Channel -> m (Maybe Channel))
-> Maybe Channel -> m (Maybe Channel)
forall a b. (a -> b) -> a -> b
$ if CInt
found CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
>= CInt
0 then Channel -> Maybe Channel
forall a. a -> Maybe a
Just (Channel -> Maybe Channel) -> Channel -> Maybe Channel
forall a b. (a -> b) -> a -> b
$ CInt -> Channel
forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
found else Maybe Channel
forall a. Maybe a
Nothing
getNewest :: MonadIO m => Group -> m (Maybe Channel)
getNewest :: forall (m :: * -> *). MonadIO m => Group -> m (Maybe Channel)
getNewest (Group CInt
g) = do
CInt
found <- CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.groupNewer CInt
g
Maybe Channel -> m (Maybe Channel)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Channel -> m (Maybe Channel))
-> Maybe Channel -> m (Maybe Channel)
forall a b. (a -> b) -> a -> b
$ if CInt
found CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
>= CInt
0 then Channel -> Maybe Channel
forall a. a -> Maybe a
Just (Channel -> Maybe Channel) -> Channel -> Maybe Channel
forall a b. (a -> b) -> a -> b
$ CInt -> Channel
forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
found else Maybe Channel
forall a. Maybe a
Nothing
musicDecoders :: MonadIO m => m [String]
musicDecoders :: forall (m :: * -> *). MonadIO m => m [String]
musicDecoders =
IO [String] -> m [String]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [String] -> m [String]) -> IO [String] -> m [String]
forall a b. (a -> b) -> a -> b
$ do
CInt
num <- IO CInt
forall (m :: * -> *). MonadIO m => m CInt
SDL.Raw.Mixer.getNumMusicDecoders
[CInt] -> (CInt -> IO String) -> IO [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [CInt
0 .. CInt
num CInt -> CInt -> CInt
forall a. Num a => a -> a -> a
- CInt
1] ((CInt -> IO String) -> IO [String])
-> (CInt -> IO String) -> IO [String]
forall a b. (a -> b) -> a -> b
$ CInt -> IO CString
forall {m :: * -> *}. MonadIO m => CInt -> m CString
SDL.Raw.Mixer.getMusicDecoder (CInt -> IO CString) -> (CString -> IO String) -> CInt -> IO String
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CString -> IO String
peekCString
newtype Music = Music (Ptr SDL.Raw.Mixer.Music)
deriving stock (Music -> Music -> Bool
(Music -> Music -> Bool) -> (Music -> Music -> Bool) -> Eq Music
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Music -> Music -> Bool
== :: Music -> Music -> Bool
$c/= :: Music -> Music -> Bool
/= :: Music -> Music -> Bool
Eq, Volume -> Music -> ShowS
[Music] -> ShowS
Music -> String
(Volume -> Music -> ShowS)
-> (Music -> String) -> ([Music] -> ShowS) -> Show Music
forall a.
(Volume -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Volume -> Music -> ShowS
showsPrec :: Volume -> Music -> ShowS
$cshow :: Music -> String
show :: Music -> String
$cshowList :: [Music] -> ShowS
showList :: [Music] -> ShowS
Show)
instance Loadable Music where
decode :: forall (m :: * -> *). MonadIO m => ByteString -> m Music
decode ByteString
bytes = IO Music -> m Music
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Music -> m Music) -> IO Music -> m Music
forall a b. (a -> b) -> a -> b
$ do
ByteString -> (CStringLen -> IO Music) -> IO Music
forall a. ByteString -> (CStringLen -> IO a) -> IO a
unsafeUseAsCStringLen ByteString
bytes ((CStringLen -> IO Music) -> IO Music)
-> (CStringLen -> IO Music) -> IO Music
forall a b. (a -> b) -> a -> b
$ \(CString
cstr, Volume
len) -> do
Ptr RWops
rw <- Ptr () -> CInt -> IO (Ptr RWops)
forall (m :: * -> *). MonadIO m => Ptr () -> CInt -> m (Ptr RWops)
rwFromConstMem (CString -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr CString
cstr) (Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
len)
(Ptr Music -> Music) -> IO (Ptr Music) -> IO Music
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Ptr Music -> Music
Music
(IO (Ptr Music) -> IO Music)
-> (IO (Ptr Music) -> IO (Ptr Music)) -> IO (Ptr Music) -> IO Music
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> IO (Ptr Music) -> IO (Ptr Music)
forall (m :: * -> *) a.
MonadIO m =>
Text -> Text -> m (Ptr a) -> m (Ptr a)
throwIfNull Text
"SDL.Mixer.decode<Music>" Text
"Mix_LoadMUS_RW"
(IO (Ptr Music) -> IO Music) -> IO (Ptr Music) -> IO Music
forall a b. (a -> b) -> a -> b
$ Ptr RWops -> CInt -> IO (Ptr Music)
forall {m :: * -> *}.
MonadIO m =>
Ptr RWops -> CInt -> m (Ptr Music)
SDL.Raw.Mixer.loadMUS_RW Ptr RWops
rw CInt
0
free :: forall (m :: * -> *). MonadIO m => Music -> m ()
free (Music Ptr Music
p) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Ptr Music -> IO ()
forall {m :: * -> *}. MonadIO m => Ptr Music -> m ()
SDL.Raw.Mixer.freeMusic Ptr Music
p
playMusic :: MonadIO m => Times -> Music -> m ()
playMusic :: forall (m :: * -> *). MonadIO m => Times -> Music -> m ()
playMusic Times
times (Music Ptr Music
p) =
Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ Text
"SDL.Mixer.playMusic" Text
"Mix_PlayMusic" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
Ptr Music -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => Ptr Music -> CInt -> m CInt
SDL.Raw.Mixer.playMusic Ptr Music
p (CInt -> m CInt) -> CInt -> m CInt
forall a b. (a -> b) -> a -> b
$
case Times
times of
Times
Forever -> (-CInt
1)
Times CInt
t -> CInt -> CInt -> CInt
forall a. Ord a => a -> a -> a
max CInt
1 CInt
t
pauseMusic :: MonadIO m => m ()
pauseMusic :: forall (m :: * -> *). MonadIO m => m ()
pauseMusic = m ()
forall (m :: * -> *). MonadIO m => m ()
SDL.Raw.Mixer.pauseMusic
haltMusic :: MonadIO m => m ()
haltMusic :: forall (m :: * -> *). MonadIO m => m ()
haltMusic = m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void m CInt
forall (m :: * -> *). MonadIO m => m CInt
SDL.Raw.Mixer.haltMusic
resumeMusic :: MonadIO m => m ()
resumeMusic :: forall (m :: * -> *). MonadIO m => m ()
resumeMusic = m ()
forall (m :: * -> *). MonadIO m => m ()
SDL.Raw.Mixer.resumeMusic
playingMusic :: MonadIO m => m Bool
playingMusic :: forall (m :: * -> *). MonadIO m => m Bool
playingMusic = (CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
> CInt
0) (CInt -> Bool) -> m CInt -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m CInt
forall (m :: * -> *). MonadIO m => m CInt
SDL.Raw.Mixer.playingMusic
pausedMusic :: MonadIO m => m Bool
pausedMusic :: forall (m :: * -> *). MonadIO m => m Bool
pausedMusic = (CInt -> CInt -> Bool
forall a. Ord a => a -> a -> Bool
> CInt
0) (CInt -> Bool) -> m CInt -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m CInt
forall (m :: * -> *). MonadIO m => m CInt
SDL.Raw.Mixer.pausedMusic
rewindMusic :: MonadIO m => m ()
rewindMusic :: forall (m :: * -> *). MonadIO m => m ()
rewindMusic = m ()
forall (m :: * -> *). MonadIO m => m ()
SDL.Raw.Mixer.rewindMusic
fadeInMusic :: MonadIO m => Milliseconds -> Times -> Music -> m ()
fadeInMusic :: forall (m :: * -> *). MonadIO m => Volume -> Times -> Music -> m ()
fadeInMusic Volume
ms Times
times (Music Ptr Music
p) =
Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ Text
"SDL.Mixer.fadeInMusic" Text
"Mix_FadeInMusic" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
Ptr Music -> CInt -> CInt -> m CInt
forall {m :: * -> *}.
MonadIO m =>
Ptr Music -> CInt -> CInt -> m CInt
SDL.Raw.Mixer.fadeInMusic Ptr Music
p CInt
t' (Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
ms)
where
t' :: CInt
t' = case Times
times of
Times
Forever -> (-CInt
1)
Times CInt
t -> CInt -> CInt -> CInt
forall a. Ord a => a -> a -> a
max CInt
1 CInt
t
fadeOutMusic :: MonadIO m => Milliseconds -> m Bool
fadeOutMusic :: forall (m :: * -> *). MonadIO m => Volume -> m Bool
fadeOutMusic = (CInt -> Bool) -> m CInt -> m Bool
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
== CInt
1) (m CInt -> m Bool) -> (Volume -> m CInt) -> Volume -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.fadeOutMusic (CInt -> m CInt) -> (Volume -> CInt) -> Volume -> m CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral
type Position = Milliseconds
setMusicPosition :: MonadIO m => Position -> m ()
setMusicPosition :: forall (m :: * -> *). MonadIO m => Volume -> m ()
setMusicPosition Volume
at = do
m ()
forall (m :: * -> *). MonadIO m => m ()
rewindMusic
Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ Text
"SDL.Mixer.setMusicPosition" Text
"Mix_SetMusicPosition" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
CDouble -> m CInt
forall {m :: * -> *}. MonadIO m => CDouble -> m CInt
SDL.Raw.Mixer.setMusicPosition (CDouble -> m CInt) -> CDouble -> m CInt
forall a b. (a -> b) -> a -> b
$ Volume -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Volume
at CDouble -> CDouble -> CDouble
forall a. Fractional a => a -> a -> a
/ CDouble
1000.0
setMusicPositionMOD :: MonadIO m => Int -> m ()
setMusicPositionMOD :: forall (m :: * -> *). MonadIO m => Volume -> m ()
setMusicPositionMOD Volume
n = do
Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ Text
"SDL.Mixer.setMusicPositionMOD" Text
"Mix_SetMusicPosition" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
CDouble -> m CInt
forall {m :: * -> *}. MonadIO m => CDouble -> m CInt
SDL.Raw.Mixer.setMusicPosition (CDouble -> m CInt) -> CDouble -> m CInt
forall a b. (a -> b) -> a -> b
$ Volume -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Volume
n
fadeInMusicAt :: MonadIO m => Position -> Milliseconds -> Times -> Music -> m ()
fadeInMusicAt :: forall (m :: * -> *).
MonadIO m =>
Volume -> Volume -> Times -> Music -> m ()
fadeInMusicAt Volume
at Volume
ms Times
times (Music Ptr Music
p) =
Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ Text
"SDL.Mixer.fadeInMusicAt" Text
"Mix_FadeInMusicPos" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
Ptr Music -> CInt -> CInt -> CDouble -> m CInt
forall {m :: * -> *}.
MonadIO m =>
Ptr Music -> CInt -> CInt -> CDouble -> m CInt
SDL.Raw.Mixer.fadeInMusicPos
Ptr Music
p
CInt
t'
(Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
ms)
(Volume -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Volume
at CDouble -> CDouble -> CDouble
forall a. Fractional a => a -> a -> a
/ CDouble
1000.0)
where
t' :: CInt
t' = case Times
times of
Times
Forever -> (-CInt
1)
Times CInt
t -> CInt -> CInt -> CInt
forall a. Ord a => a -> a -> a
max CInt
1 CInt
t
fadeInMusicAtMOD :: MonadIO m => Int -> Milliseconds -> Times -> Music -> m ()
fadeInMusicAtMOD :: forall (m :: * -> *).
MonadIO m =>
Volume -> Volume -> Times -> Music -> m ()
fadeInMusicAtMOD Volume
at Volume
ms Times
times (Music Ptr Music
p) =
Text -> Text -> m CInt -> m ()
forall (m :: * -> *) a.
(MonadIO m, Num a, Ord a) =>
Text -> Text -> m a -> m ()
throwIfNeg_ Text
"SDL.Mixer.fadeInMusicAtMOD" Text
"Mix_FadeInMusicPos" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
Ptr Music -> CInt -> CInt -> CDouble -> m CInt
forall {m :: * -> *}.
MonadIO m =>
Ptr Music -> CInt -> CInt -> CDouble -> m CInt
SDL.Raw.Mixer.fadeInMusicPos
Ptr Music
p
CInt
t'
(Volume -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Volume
ms)
(Volume -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Volume
at)
where
t' :: CInt
t' = case Times
times of
Times
Forever -> (-CInt
1)
Times CInt
t -> CInt -> CInt -> CInt
forall a. Ord a => a -> a -> a
max CInt
1 CInt
t
fadingMusic :: MonadIO m => m Fading
fadingMusic :: forall (m :: * -> *). MonadIO m => m Fading
fadingMusic = MusicType -> Fading
wordToFading (MusicType -> Fading) -> m MusicType -> m Fading
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m MusicType
forall (m :: * -> *). MonadIO m => m MusicType
SDL.Raw.Mixer.fadingMusic
getMusicVolume :: MonadIO m => m Volume
getMusicVolume :: forall (m :: * -> *). MonadIO m => m Volume
getMusicVolume = CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Volume) -> m CInt -> m Volume
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.volumeMusic (-CInt
1)
setMusicVolume :: MonadIO m => Volume -> m ()
setMusicVolume :: forall (m :: * -> *). MonadIO m => Volume -> m ()
setMusicVolume Volume
v = m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> (CInt -> m CInt) -> CInt -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> m CInt
SDL.Raw.Mixer.volumeMusic (CInt -> m ()) -> CInt -> m ()
forall a b. (a -> b) -> a -> b
$ Volume -> CInt
volumeToCInt Volume
v
data MusicType
= CMD
| WAV
| MOD
| MID
| OGG
| MP3
| FLAC
deriving stock (MusicType -> MusicType -> Bool
(MusicType -> MusicType -> Bool)
-> (MusicType -> MusicType -> Bool) -> Eq MusicType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MusicType -> MusicType -> Bool
== :: MusicType -> MusicType -> Bool
$c/= :: MusicType -> MusicType -> Bool
/= :: MusicType -> MusicType -> Bool
Eq, Volume -> MusicType -> ShowS
[MusicType] -> ShowS
MusicType -> String
(Volume -> MusicType -> ShowS)
-> (MusicType -> String)
-> ([MusicType] -> ShowS)
-> Show MusicType
forall a.
(Volume -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Volume -> MusicType -> ShowS
showsPrec :: Volume -> MusicType -> ShowS
$cshow :: MusicType -> String
show :: MusicType -> String
$cshowList :: [MusicType] -> ShowS
showList :: [MusicType] -> ShowS
Show, ReadPrec [MusicType]
ReadPrec MusicType
Volume -> ReadS MusicType
ReadS [MusicType]
(Volume -> ReadS MusicType)
-> ReadS [MusicType]
-> ReadPrec MusicType
-> ReadPrec [MusicType]
-> Read MusicType
forall a.
(Volume -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Volume -> ReadS MusicType
readsPrec :: Volume -> ReadS MusicType
$creadList :: ReadS [MusicType]
readList :: ReadS [MusicType]
$creadPrec :: ReadPrec MusicType
readPrec :: ReadPrec MusicType
$creadListPrec :: ReadPrec [MusicType]
readListPrec :: ReadPrec [MusicType]
Read, Eq MusicType
Eq MusicType
-> (MusicType -> MusicType -> Ordering)
-> (MusicType -> MusicType -> Bool)
-> (MusicType -> MusicType -> Bool)
-> (MusicType -> MusicType -> Bool)
-> (MusicType -> MusicType -> Bool)
-> (MusicType -> MusicType -> MusicType)
-> (MusicType -> MusicType -> MusicType)
-> Ord MusicType
MusicType -> MusicType -> Bool
MusicType -> MusicType -> Ordering
MusicType -> MusicType -> MusicType
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
$ccompare :: MusicType -> MusicType -> Ordering
compare :: MusicType -> MusicType -> Ordering
$c< :: MusicType -> MusicType -> Bool
< :: MusicType -> MusicType -> Bool
$c<= :: MusicType -> MusicType -> Bool
<= :: MusicType -> MusicType -> Bool
$c> :: MusicType -> MusicType -> Bool
> :: MusicType -> MusicType -> Bool
$c>= :: MusicType -> MusicType -> Bool
>= :: MusicType -> MusicType -> Bool
$cmax :: MusicType -> MusicType -> MusicType
max :: MusicType -> MusicType -> MusicType
$cmin :: MusicType -> MusicType -> MusicType
min :: MusicType -> MusicType -> MusicType
Ord, MusicType
MusicType -> MusicType -> Bounded MusicType
forall a. a -> a -> Bounded a
$cminBound :: MusicType
minBound :: MusicType
$cmaxBound :: MusicType
maxBound :: MusicType
Bounded)
wordToMusicType :: SDL.Raw.Mixer.MusicType -> Maybe MusicType
wordToMusicType :: MusicType -> Maybe MusicType
wordToMusicType = \case
MusicType
SDL.Raw.Mixer.MUS_NONE -> Maybe MusicType
forall a. Maybe a
Nothing
MusicType
SDL.Raw.Mixer.MUS_CMD -> MusicType -> Maybe MusicType
forall a. a -> Maybe a
Just MusicType
CMD
MusicType
SDL.Raw.Mixer.MUS_WAV -> MusicType -> Maybe MusicType
forall a. a -> Maybe a
Just MusicType
WAV
MusicType
SDL.Raw.Mixer.MUS_MOD -> MusicType -> Maybe MusicType
forall a. a -> Maybe a
Just MusicType
MOD
MusicType
SDL.Raw.Mixer.MUS_MID -> MusicType -> Maybe MusicType
forall a. a -> Maybe a
Just MusicType
MID
MusicType
SDL.Raw.Mixer.MUS_OGG -> MusicType -> Maybe MusicType
forall a. a -> Maybe a
Just MusicType
OGG
MusicType
SDL.Raw.Mixer.MUS_MP3 -> MusicType -> Maybe MusicType
forall a. a -> Maybe a
Just MusicType
MP3
MusicType
SDL.Raw.Mixer.MUS_FLAC -> MusicType -> Maybe MusicType
forall a. a -> Maybe a
Just MusicType
FLAC
MusicType
_ -> Maybe MusicType
forall a. Maybe a
Nothing
musicType :: Music -> Maybe MusicType
musicType :: Music -> Maybe MusicType
musicType (Music Ptr Music
p) =
MusicType -> Maybe MusicType
wordToMusicType (MusicType -> Maybe MusicType) -> MusicType -> Maybe MusicType
forall a b. (a -> b) -> a -> b
$ IO MusicType -> MusicType
forall a. IO a -> a
unsafePerformIO (Ptr Music -> IO MusicType
forall {m :: * -> *}. MonadIO m => Ptr Music -> m MusicType
SDL.Raw.Mixer.getMusicType Ptr Music
p)
playingMusicType :: MonadIO m => m (Maybe MusicType)
playingMusicType :: forall (m :: * -> *). MonadIO m => m (Maybe MusicType)
playingMusicType = MusicType -> Maybe MusicType
wordToMusicType (MusicType -> Maybe MusicType)
-> m MusicType -> m (Maybe MusicType)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Music -> m MusicType
forall {m :: * -> *}. MonadIO m => Ptr Music -> m MusicType
SDL.Raw.Mixer.getMusicType Ptr Music
forall a. Ptr a
nullPtr
{-# NOINLINE musicFinishedFunPtr #-}
musicFinishedFunPtr :: IORef (FunPtr (IO ()))
musicFinishedFunPtr :: IORef (FunPtr (IO ()))
musicFinishedFunPtr = IO (IORef (FunPtr (IO ()))) -> IORef (FunPtr (IO ()))
forall a. IO a -> a
unsafePerformIO (IO (IORef (FunPtr (IO ()))) -> IORef (FunPtr (IO ())))
-> IO (IORef (FunPtr (IO ()))) -> IORef (FunPtr (IO ()))
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO (IORef (FunPtr (IO ())))
forall a. a -> IO (IORef a)
newIORef FunPtr (IO ())
forall a. FunPtr a
nullFunPtr
whenMusicFinished :: MonadIO m => IO () -> m ()
whenMusicFinished :: forall (m :: * -> *). MonadIO m => IO () -> m ()
whenMusicFinished IO ()
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
FunPtr (IO ())
callbackRaw <- IO () -> IO (FunPtr (IO ()))
SDL.Raw.Mixer.wrapMusicCallback IO ()
callback
FunPtr (IO ()) -> IO ()
forall {m :: * -> *}. MonadIO m => FunPtr (IO ()) -> m ()
SDL.Raw.Mixer.hookMusicFinished FunPtr (IO ())
callbackRaw
FunPtr (IO ())
lastFunPtr <- IORef (FunPtr (IO ())) -> IO (FunPtr (IO ()))
forall a. IORef a -> IO a
readIORef IORef (FunPtr (IO ()))
musicFinishedFunPtr
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (FunPtr (IO ())
lastFunPtr FunPtr (IO ()) -> FunPtr (IO ()) -> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr (IO ())
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
forall a. FunPtr a -> IO ()
freeHaskellFunPtr FunPtr (IO ())
lastFunPtr
IORef (FunPtr (IO ())) -> FunPtr (IO ()) -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef (FunPtr (IO ()))
musicFinishedFunPtr FunPtr (IO ())
callbackRaw
type Effect = Channel -> IOVector Word8 -> IO ()
type EffectFinished = Channel -> IO ()
pattern PostProcessing :: Channel
pattern $mPostProcessing :: forall {r}. Channel -> ((# #) -> r) -> ((# #) -> r) -> r
$bPostProcessing :: Channel
PostProcessing = SDL.Raw.Mixer.CHANNEL_POST
effect :: MonadIO m => Channel -> EffectFinished -> Effect -> m (m ())
effect :: forall (m :: * -> *).
MonadIO m =>
Channel -> (Channel -> IO ()) -> Effect -> m (m ())
effect (Channel CInt
channel) Channel -> IO ()
fin Effect
ef = do
FunPtr Effect
ef' <- IO (FunPtr Effect) -> m (FunPtr Effect)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (FunPtr Effect) -> m (FunPtr Effect))
-> IO (FunPtr Effect) -> m (FunPtr Effect)
forall a b. (a -> b) -> a -> b
$
Effect -> IO (FunPtr Effect)
SDL.Raw.Mixer.wrapEffect (Effect -> IO (FunPtr Effect)) -> Effect -> IO (FunPtr Effect)
forall a b. (a -> b) -> a -> b
$ \CInt
c Ptr ()
p CInt
len Ptr ()
_ -> do
ForeignPtr Word8
fp <- ForeignPtr () -> ForeignPtr Word8
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr (ForeignPtr () -> ForeignPtr Word8)
-> IO (ForeignPtr ()) -> IO (ForeignPtr Word8)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr () -> IO (ForeignPtr ())
forall a. Ptr a -> IO (ForeignPtr a)
newForeignPtr_ Ptr ()
p
Effect
ef (CInt -> Channel
Channel CInt
c) (IOVector Word8 -> IO ())
-> (Volume -> IOVector Word8) -> Volume -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr Word8 -> Volume -> IOVector Word8
forall a s. ForeignPtr a -> Volume -> MVector s a
unsafeFromForeignPtr0 ForeignPtr Word8
fp (Volume -> IO ()) -> Volume -> IO ()
forall a b. (a -> b) -> a -> b
$ CInt -> Volume
forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
len
FunPtr EffectFinished
fin' <- IO (FunPtr EffectFinished) -> m (FunPtr EffectFinished)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (FunPtr EffectFinished) -> m (FunPtr EffectFinished))
-> IO (FunPtr EffectFinished) -> m (FunPtr EffectFinished)
forall a b. (a -> b) -> a -> b
$
EffectFinished -> IO (FunPtr EffectFinished)
SDL.Raw.Mixer.wrapEffectFinished (EffectFinished -> IO (FunPtr EffectFinished))
-> EffectFinished -> IO (FunPtr EffectFinished)
forall a b. (a -> b) -> a -> b
$ \CInt
c Ptr ()
_ ->
Channel -> IO ()
fin (Channel -> IO ()) -> Channel -> IO ()
forall a b. (a -> b) -> a -> b
$ CInt -> Channel
Channel CInt
c
CInt
result <- CInt -> FunPtr Effect -> FunPtr EffectFinished -> Ptr () -> m CInt
forall {m :: * -> *}.
MonadIO m =>
CInt -> FunPtr Effect -> FunPtr EffectFinished -> Ptr () -> m CInt
SDL.Raw.Mixer.registerEffect CInt
channel FunPtr Effect
ef' FunPtr EffectFinished
fin' Ptr ()
forall a. Ptr a
nullPtr
if CInt
result CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
== CInt
0
then do
IO (m ()) -> m (m ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (m ()) -> m (m ())) -> IO (m ()) -> m (m ())
forall a b. (a -> b) -> a -> b
$ do
FunPtr Effect -> IO ()
forall a. FunPtr a -> IO ()
freeHaskellFunPtr FunPtr Effect
ef' IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> FunPtr EffectFinished -> IO ()
forall a. FunPtr a -> IO ()
freeHaskellFunPtr FunPtr EffectFinished
fin'
Text
err <- IO Text
forall (m :: * -> *). MonadIO m => m Text
getError
SDLException -> IO (m ())
forall e a. Exception e => e -> IO a
throwIO (SDLException -> IO (m ())) -> SDLException -> IO (m ())
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> SDLException
SDLCallFailed Text
"SDL.Raw.Mixer.addEffect" Text
"Mix_RegisterEffect" Text
err
else m () -> m (m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (m () -> m (m ())) -> (IO () -> m ()) -> IO () -> m (m ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m (m ())) -> IO () -> m (m ())
forall a b. (a -> b) -> a -> b
$ do
CInt
removed <- CInt -> FunPtr Effect -> IO CInt
forall {m :: * -> *}. MonadIO m => CInt -> FunPtr Effect -> m CInt
SDL.Raw.Mixer.unregisterEffect CInt
channel FunPtr Effect
ef'
FunPtr Effect -> IO ()
forall a. FunPtr a -> IO ()
freeHaskellFunPtr FunPtr Effect
ef' IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> FunPtr EffectFinished -> IO ()
forall a. FunPtr a -> IO ()
freeHaskellFunPtr FunPtr EffectFinished
fin'
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CInt
removed CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
== CInt
0) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
Text
err <- IO Text
forall (m :: * -> *). MonadIO m => m Text
getError
SDLException -> IO ()
forall e a. Exception e => e -> IO a
throwIO (SDLException -> IO ()) -> SDLException -> IO ()
forall a b. (a -> b) -> a -> b
$
Text -> Text -> Text -> SDLException
SDLCallFailed Text
"SDL.Raw.Mixer.removeEffect" Text
"Mix_UnregisterEffect" Text
err
effectPan :: MonadIO m => Channel -> Volume -> Volume -> m (m ())
effectPan :: forall (m :: * -> *).
MonadIO m =>
Channel -> Volume -> Volume -> m (m ())
effectPan channel :: Channel
channel@(Channel CInt
c) Volume
lVol Volume
rVol = do
m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> (m CInt -> m CInt) -> m CInt -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> m CInt -> m CInt
forall a (m :: * -> *).
(Eq a, MonadIO m, Num a) =>
Text -> Text -> m a -> m a
throwIf0 Text
"SDL.Raw.Mixer.effectPan" Text
"Mix_SetPanning" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
CInt -> Word8 -> Word8 -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> Word8 -> Word8 -> m CInt
SDL.Raw.Mixer.setPanning CInt
c (Volume -> Word8
wordVol Volume
lVol) (Volume -> Word8
wordVol Volume
rVol)
m () -> m (m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (m () -> m (m ())) -> (m (m ()) -> m ()) -> m (m ()) -> m (m ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (m ()) -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m (m ()) -> m (m ())) -> m (m ()) -> m (m ())
forall a b. (a -> b) -> a -> b
$ Channel -> Volume -> Volume -> m (m ())
forall (m :: * -> *).
MonadIO m =>
Channel -> Volume -> Volume -> m (m ())
effectPan Channel
channel Volume
128 Volume
128
wordVol :: Volume -> Word8
wordVol :: Volume -> Word8
wordVol = CInt -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Word8) -> (Volume -> CInt) -> Volume -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> CInt -> CInt
forall a. Ord a => a -> a -> a
min CInt
255 (CInt -> CInt) -> (Volume -> CInt) -> Volume -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CInt -> CInt -> CInt
forall a. Num a => a -> a -> a
* CInt
2) (CInt -> CInt) -> (Volume -> CInt) -> Volume -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Volume -> CInt
volumeToCInt
effectDistance :: MonadIO m => Channel -> Word8 -> m (m ())
effectDistance :: forall (m :: * -> *). MonadIO m => Channel -> Word8 -> m (m ())
effectDistance channel :: Channel
channel@(Channel CInt
c) Word8
dist = do
m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> (m CInt -> m CInt) -> m CInt -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> m CInt -> m CInt
forall a (m :: * -> *).
(Eq a, MonadIO m, Num a) =>
Text -> Text -> m a -> m a
throwIf0 Text
"SDL.Raw.Mixer.effectDistance" Text
"Mix_SetDistance" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
CInt -> Word8 -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> Word8 -> m CInt
SDL.Raw.Mixer.setDistance CInt
c Word8
dist
m () -> m (m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (m () -> m (m ())) -> (m (m ()) -> m ()) -> m (m ()) -> m (m ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (m ()) -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m (m ()) -> m (m ())) -> m (m ()) -> m (m ())
forall a b. (a -> b) -> a -> b
$ Channel -> Word8 -> m (m ())
forall (m :: * -> *). MonadIO m => Channel -> Word8 -> m (m ())
effectDistance Channel
channel Word8
0
effectPosition :: MonadIO m => Channel -> Int16 -> Word8 -> m (m ())
effectPosition :: forall (m :: * -> *).
MonadIO m =>
Channel -> Int16 -> Word8 -> m (m ())
effectPosition channel :: Channel
channel@(Channel CInt
c) Int16
angle Word8
dist = do
m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> (m CInt -> m CInt) -> m CInt -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> m CInt -> m CInt
forall a (m :: * -> *).
(Eq a, MonadIO m, Num a) =>
Text -> Text -> m a -> m a
throwIf0 Text
"SDL.Raw.Mixer.effectPosition" Text
"Mix_SetPosition" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
CInt -> Int16 -> Word8 -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> Int16 -> Word8 -> m CInt
SDL.Raw.Mixer.setPosition CInt
c Int16
angle Word8
dist
m () -> m (m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (m () -> m (m ())) -> (m (m ()) -> m ()) -> m (m ()) -> m (m ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (m ()) -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m (m ()) -> m (m ())) -> m (m ()) -> m (m ())
forall a b. (a -> b) -> a -> b
$ Channel -> Int16 -> Word8 -> m (m ())
forall (m :: * -> *).
MonadIO m =>
Channel -> Int16 -> Word8 -> m (m ())
effectPosition Channel
channel Int16
0 Word8
0
effectReverseStereo :: MonadIO m => Channel -> Bool -> m (m ())
effectReverseStereo :: forall (m :: * -> *). MonadIO m => Channel -> Bool -> m (m ())
effectReverseStereo channel :: Channel
channel@(Channel CInt
c) Bool
rev = do
m CInt -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m CInt -> m ()) -> (m CInt -> m CInt) -> m CInt -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> m CInt -> m CInt
forall a (m :: * -> *).
(Eq a, MonadIO m, Num a) =>
Text -> Text -> m a -> m a
throwIf0 Text
"SDL.Raw.Mixer.effectReverseStereo" Text
"Mix_SetReverseStereo" (m CInt -> m ()) -> m CInt -> m ()
forall a b. (a -> b) -> a -> b
$
CInt -> CInt -> m CInt
forall {m :: * -> *}. MonadIO m => CInt -> CInt -> m CInt
SDL.Raw.Mixer.setReverseStereo CInt
c (if Bool
rev then CInt
1 else CInt
0)
m () -> m (m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (m () -> m (m ())) -> (m (m ()) -> m ()) -> m (m ()) -> m (m ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (m ()) -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m (m ()) -> m (m ())) -> m (m ()) -> m (m ())
forall a b. (a -> b) -> a -> b
$ Channel -> Bool -> m (m ())
forall (m :: * -> *). MonadIO m => Channel -> Bool -> m (m ())
effectReverseStereo Channel
channel Bool
False