packages feed

al 0.1.1.3 → 0.1.2

raw patch · 13 files changed

+284/−72 lines, 13 filesdep +mtl

Dependencies added: mtl

Files

CHANGELOG.md view
@@ -1,3 +1,7 @@+## 0.1.2++- Everything runs in `(MonadIO m) => m a` instead of `IO a` now on.+ ## 0.1.1.3  - Relaxed upper bounds on c2hs to enable the use of c2hs-0.24.*.
al.cabal view
@@ -1,5 +1,5 @@ name:                al
-version:             0.1.1.3
+version:             0.1.2
 synopsis:            OpenAL 1.1 raw API.
 description:         OpenAL is a minimalistic sound API that aims to provide
                      bare features for /spacialized audio/. The API looks like
@@ -8,12 +8,12 @@                      Up to now, no OpenAL extension is supported. You're highly
                      invited to contribute ;).
 
-                     EAX is not supported yet eiher. It'll be embedded in
+                     EAX is not supported yet either. It'll be embedded in
                      future releases, soon.
 
                      IMPORTANT: In order to build and install "al", you'll
                      need to pass the path of the /include/ and /libs/ directory
-                     of your OpenAL installation.
+                     of your OpenAL installation if you get errors.
 
                      Then use this to install:
 
@@ -88,6 +88,7 @@                      , ForeignFunctionInterface
 
   build-depends:       base >= 4.7 && < 4.8
+                     , mtl >= 2.1 && < 2.2
 
   hs-source-dirs:      src
src/Sound/AL/Buffer.chs view
@@ -8,17 +8,42 @@ -- Portability : portable ---------------------------------------------------------------------------- -module Sound.AL.Buffer where+module Sound.AL.Buffer (+    alGenBuffers+  , alDeleteBuffers+  , alIsBuffer+  , alBufferData+  , alGetBufferf+  , alGetBufferi+  ) where +import Control.Monad.Trans ( MonadIO(..) ) import Foreign.C.Types import Foreign.Ptr ( Ptr ) import Sound.AL.Types  #include <al.h> -foreign import CALLCV "alGenBuffers" alGenBuffers :: ALsizei -> Ptr ALuint -> IO ()-foreign import CALLCV "alDeleteBuffers" alDeleteBuffers :: ALsizei -> Ptr ALuint -> IO ()-foreign import CALLCV "alIsBuffer" alIsBuffer :: ALuint -> IO ALboolean-foreign import CALLCV "alBufferData" alBufferData :: ALuint -> ALenum -> Ptr a -> ALsizei -> ALsizei -> IO ()-foreign import CALLCV "alGetBufferf" alGetBufferf :: ALuint -> ALenum -> Ptr ALfloat -> IO ()-foreign import CALLCV "alGetBufferi" alGetBufferi :: ALuint -> ALenum -> Ptr ALint -> IO ()+foreign import CALLCV "alGenBuffers" alGenBuffers_ :: ALsizei -> Ptr ALuint -> IO ()+alGenBuffers :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()+alGenBuffers a b = liftIO $ alGenBuffers_ a b++foreign import CALLCV "alDeleteBuffers" alDeleteBuffers_ :: ALsizei -> Ptr ALuint -> IO ()+alDeleteBuffers :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()+alDeleteBuffers a b = liftIO $ alDeleteBuffers_ a b++foreign import CALLCV "alIsBuffer" alIsBuffer_ :: ALuint -> IO ALboolean+alIsBuffer :: (MonadIO m) => ALuint -> m ALboolean+alIsBuffer = liftIO . alIsBuffer_++foreign import CALLCV "alBufferData" alBufferData_ :: ALuint -> ALenum -> Ptr a -> ALsizei -> ALsizei -> IO ()+alBufferData :: (MonadIO m) => ALuint -> ALenum -> Ptr a -> ALsizei -> ALsizei -> m ()+alBufferData a b c d e = liftIO $ alBufferData_ a b c d e++foreign import CALLCV "alGetBufferf" alGetBufferf_ :: ALuint -> ALenum -> Ptr ALfloat -> IO ()+alGetBufferf :: (MonadIO m) => ALuint -> ALenum -> Ptr ALfloat -> m ()+alGetBufferf a b c = liftIO $ alGetBufferf_ a b c++foreign import CALLCV "alGetBufferi" alGetBufferi_ :: ALuint -> ALenum -> Ptr ALint -> IO ()+alGetBufferi :: (MonadIO m) => ALuint -> ALenum -> Ptr ALint -> m ()+alGetBufferi a b c = liftIO $ alGetBufferi_ a b c
src/Sound/AL/Errors.chs view
@@ -10,9 +10,12 @@  module Sound.AL.Errors where +import Control.Monad.Trans ( MonadIO(..) ) import Foreign.C.Types import Sound.AL.Types  #include <al.h> -foreign import CALLCV "alGetError" alGetError :: IO ALenum+foreign import CALLCV "alGetError" alGetError_ :: IO ALenum+alGetError :: (MonadIO m) => m ALenum+alGetError = liftIO alGetError_
src/Sound/AL/Extensions.chs view
@@ -10,12 +10,21 @@  module Sound.AL.Extensions where +import Control.Monad.Trans ( MonadIO(..) )  import Foreign.C.Types import Foreign.Ptr ( Ptr ) import Sound.AL.Types  #include <al.h> -foreign import CALLCV "alIsExtensionPresent" alIsExtensionPresent :: Ptr ALubyte -> IO ALboolean-foreign import CALLCV "alGetProcAddress" alGetProcAddress :: Ptr ALubyte -> IO (Ptr ALvoid)-foreign import CALLCV "alGetEnumValue" alGetEnumValue :: Ptr ALubyte -> IO ALenum+foreign import CALLCV "alIsExtensionPresent" alIsExtensionPresent_ :: Ptr ALubyte -> IO ALboolean+alIsExtensionPresent :: (MonadIO m) => Ptr ALubyte -> m ALboolean+alIsExtensionPresent = liftIO . alIsExtensionPresent++foreign import CALLCV "alGetProcAddress" alGetProcAddress_ :: Ptr ALubyte -> IO (Ptr ALvoid)+alGetProcAddress :: (MonadIO m) => Ptr ALubyte -> m (Ptr ALvoid)+alGetProcAddress = liftIO . alGetProcAddress_++foreign import CALLCV "alGetEnumValue" alGetEnumValue_ :: Ptr ALubyte -> IO ALenum+alGetEnumValue :: (MonadIO m) => Ptr ALubyte -> m ALenum+alGetEnumValue = liftIO . alGetEnumValue
src/Sound/AL/Listener.chs view
@@ -10,17 +10,41 @@  module Sound.AL.Listener where +import Control.Monad.Trans ( MonadIO(..) ) import Foreign.C.Types import Foreign.Ptr ( Ptr ) import Sound.AL.Types  #include <al.h> -foreign import CALLCV "alListenerf" alListenerf :: ALenum -> ALfloat -> IO ()-foreign import CALLCV "alListener3f" alListener3f :: ALenum -> ALfloat -> ALfloat -> ALfloat -> IO ()-foreign import CALLCV "alListenerfv" alListenerfv :: ALenum -> Ptr ALfloat -> IO ()-foreign import CALLCV "alListeneri" alListeneri :: ALenum -> ALint -> IO ()-foreign import CALLCV "alGetListenerf" alGetListenerf :: ALenum -> Ptr ALfloat -> IO ()-foreign import CALLCV "alGetListener3f" alGetListener3f :: ALenum -> Ptr ALfloat -> Ptr ALfloat -> Ptr ALfloat -> IO ()-foreign import CALLCV "alGetListenerfv" alGetListenerfv :: ALenum -> Ptr ALfloat -> IO ()-foreign import CALLCV "alGetListeneri" alGetListeneri :: ALenum -> Ptr ALint -> IO ()+foreign import CALLCV "alListenerf" alListenerf_ :: ALenum -> ALfloat -> IO ()+alListenerf :: (MonadIO m) => ALenum -> ALfloat -> m ()+alListenerf a b = liftIO $ alListenerf_ a b++foreign import CALLCV "alListener3f" alListener3f_ :: ALenum -> ALfloat -> ALfloat -> ALfloat -> IO ()+alListener3f :: (MonadIO m) => ALenum -> ALfloat -> ALfloat -> ALfloat -> m ()+alListener3f a b c d = liftIO $ alListener3f_ a b c d++foreign import CALLCV "alListenerfv" alListenerfv_ :: ALenum -> Ptr ALfloat -> IO ()+alListenerfv :: (MonadIO m) => ALenum -> Ptr ALfloat -> m ()+alListenerfv a b = liftIO $ alListenerfv_ a b++foreign import CALLCV "alListeneri" alListeneri_ :: ALenum -> ALint -> IO ()+alListeneri :: (MonadIO m) => ALenum -> ALint -> m ()+alListeneri a b = liftIO $ alListeneri_ a b++foreign import CALLCV "alGetListenerf" alGetListenerf_ :: ALenum -> Ptr ALfloat -> IO ()+alGetListenerf :: (MonadIO m) => ALenum -> Ptr ALfloat -> m ()+alGetListenerf a b = liftIO $ alGetListenerf_ a b++foreign import CALLCV "alGetListener3f" alGetListener3f_ :: ALenum -> Ptr ALfloat -> Ptr ALfloat -> Ptr ALfloat -> IO ()+alGetListener3f :: (MonadIO m) => ALenum -> Ptr ALfloat -> Ptr ALfloat -> Ptr ALfloat -> m ()+alGetListener3f a b c d = liftIO $ alGetListener3f_ a b c d++foreign import CALLCV "alGetListenerfv" alGetListenerfv_ :: ALenum -> Ptr ALfloat -> IO ()+alGetListenerfv :: (MonadIO m) => ALenum -> Ptr ALfloat -> m ()+alGetListenerfv a b = liftIO $ alGetListenerfv_ a b++foreign import CALLCV "alGetListeneri" alGetListeneri_ :: ALenum -> Ptr ALint -> IO ()+alGetListeneri :: (MonadIO m) => ALenum -> Ptr ALint -> m ()+alGetListeneri a b = liftIO $ alGetListeneri_ a b
src/Sound/AL/Source.chs view
@@ -10,29 +10,89 @@  module Sound.AL.Source where +import Control.Monad.Trans ( MonadIO(..) ) import Foreign.C.Types import Foreign.Ptr ( Ptr ) import Sound.AL.Types  #include <al.h> -foreign import CALLCV "alGenSources" alGenSources :: ALsizei -> Ptr ALuint -> IO ()-foreign import CALLCV "alDeleteSources" alDeleteSources :: ALsizei -> Ptr ALuint -> IO ()-foreign import CALLCV "alIsSource" alIsSource :: ALuint -> IO ALboolean-foreign import CALLCV "alSourcef" alSourcef :: ALuint -> ALenum -> ALfloat -> IO ()-foreign import CALLCV "alSourcefv" alSourcefv :: ALuint -> ALenum -> Ptr ALfloat -> IO ()-foreign import CALLCV "alSource3f" alSource3f :: ALuint -> ALenum -> ALfloat -> ALfloat -> ALfloat -> IO ()-foreign import CALLCV "alSourcei" alSourcei :: ALuint -> ALenum -> ALint -> IO ()-foreign import CALLCV "alGetSourcef" alGetSourcef :: ALuint -> ALenum -> Ptr ALfloat -> IO ()-foreign import CALLCV "alGetSourcefv" alGetSourcefv :: ALuint -> ALenum -> Ptr ALfloat -> IO ()-foreign import CALLCV "alGetSourcei" alGetSourcei :: ALuint -> ALenum -> Ptr ALint -> IO ()-foreign import CALLCV "alSourcePlay" alSourcePlay :: ALuint -> IO ()-foreign import CALLCV "alSourcePlayv" alSourcePlayv :: ALsizei -> Ptr ALuint -> IO ()-foreign import CALLCV "alSourcePause" alSourcePause :: ALuint -> IO ()-foreign import CALLCV "alSourcePausev" alSourcePausev :: ALsizei -> Ptr ALuint -> IO ()-foreign import CALLCV "alSourceStop" alSourceStop :: ALuint -> IO ()-foreign import CALLCV "alSourceStopv" alSourceStopv :: ALsizei -> Ptr ALuint -> IO ()-foreign import CALLCV "alSourceRewind" alSourceRewind :: ALuint -> IO ()-foreign import CALLCV "alSourceRewindv" alSourceRewindv :: ALsizei -> Ptr ALuint -> IO ()-foreign import CALLCV "alSourceQueueBuffers" alSourceQueueBuffers :: ALuint -> ALsizei -> Ptr ALuint -> IO ()-foreign import CALLCV "alSourceUnqueueBuffers" alSourceUnqueueBuffers :: ALuint -> ALsizei -> Ptr ALuint -> IO ()+foreign import CALLCV "alGenSources" alGenSources_ :: ALsizei -> Ptr ALuint -> IO ()+alGenSources :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()+alGenSources a b = liftIO $ alGenSources_ a b++foreign import CALLCV "alDeleteSources" alDeleteSources_ :: ALsizei -> Ptr ALuint -> IO ()+alDeleteSources :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()+alDeleteSources a b = liftIO $ alDeleteSources_ a b++foreign import CALLCV "alIsSource" alIsSource_ :: ALuint -> IO ALboolean+alIsSource :: (MonadIO m) => ALuint -> m ALboolean+alIsSource = liftIO . alIsSource_++foreign import CALLCV "alSourcef" alSourcef_ :: ALuint -> ALenum -> ALfloat -> IO ()+alSourcef :: (MonadIO m) => ALuint -> ALenum -> ALfloat -> m ()+alSourcef a b c = liftIO $ alSourcef_ a b c++foreign import CALLCV "alSourcefv" alSourcefv_ :: ALuint -> ALenum -> Ptr ALfloat -> IO ()+alSourcefv :: (MonadIO m) => ALuint -> ALenum -> Ptr ALfloat -> m ()+alSourcefv a b c = liftIO $ alSourcefv_ a b c++foreign import CALLCV "alSource3f" alSource3f_ :: ALuint -> ALenum -> ALfloat -> ALfloat -> ALfloat -> IO ()+alSource3f :: (MonadIO m) => ALuint -> ALenum -> ALfloat -> ALfloat -> ALfloat -> m ()+alSource3f a b c d e = liftIO $ alSource3f_ a b c d e++foreign import CALLCV "alSourcei" alSourcei_ :: ALuint -> ALenum -> ALint -> IO ()+alSourcei :: (MonadIO m) => ALuint -> ALenum -> ALint -> m ()+alSourcei a b c = liftIO $ alSourcei_ a b c++foreign import CALLCV "alGetSourcef" alGetSourcef_ :: ALuint -> ALenum -> Ptr ALfloat -> IO ()+alGetSourcef :: (MonadIO m) => ALuint -> ALenum -> Ptr ALfloat -> m ()+alGetSourcef a b c = liftIO $ alGetSourcef_ a b c++foreign import CALLCV "alGetSourcefv" alGetSourcefv_ :: ALuint -> ALenum -> Ptr ALfloat -> IO ()+alGetSourcefv :: (MonadIO m) => ALuint -> ALenum -> Ptr ALfloat -> m ()+alGetSourcefv a b c = liftIO $ alGetSourcefv_ a b c++foreign import CALLCV "alGetSourcei" alGetSourcei_ :: ALuint -> ALenum -> Ptr ALint -> IO ()+alGetSourcei :: (MonadIO m) => ALuint -> ALenum -> Ptr ALint -> m ()+alGetSourcei a b c = liftIO $ alGetSourcei_ a b c++foreign import CALLCV "alSourcePlay" alSourcePlay_ :: ALuint -> IO ()+alSourcePlay :: (MonadIO m) => ALuint -> m ()+alSourcePlay = liftIO . alSourcePlay_++foreign import CALLCV "alSourcePlayv" alSourcePlayv_ :: ALsizei -> Ptr ALuint -> IO ()+alSourcePlayv :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()+alSourcePlayv a b = liftIO $ alSourcePlayv_ a b++foreign import CALLCV "alSourcePause" alSourcePause_ :: ALuint -> IO ()+alSourcePause :: (MonadIO m) => ALuint -> m ()+alSourcePause = liftIO . alSourcePause_++foreign import CALLCV "alSourcePausev" alSourcePausev_ :: ALsizei -> Ptr ALuint -> IO ()+alSourcePausev :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()+alSourcePausev a b = liftIO $ alSourcePausev_ a b++foreign import CALLCV "alSourceStop" alSourceStop_ :: ALuint -> IO ()+alSourceStop :: (MonadIO m) => ALuint -> m ()+alSourceStop = liftIO . alSourceStop_++foreign import CALLCV "alSourceStopv" alSourceStopv_ :: ALsizei -> Ptr ALuint -> IO ()+alSourceStopv :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()+alSourceStopv a b = liftIO $ alSourceStopv_ a b++foreign import CALLCV "alSourceRewind" alSourceRewind_ :: ALuint -> IO ()+alSourceRewind :: (MonadIO m) => ALuint -> m ()+alSourceRewind = liftIO . alSourceRewind_++foreign import CALLCV "alSourceRewindv" alSourceRewindv_ :: ALsizei -> Ptr ALuint -> IO ()+alSourceRewindv :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()+alSourceRewindv a b = liftIO $ alSourceRewindv_ a b++foreign import CALLCV "alSourceQueueBuffers" alSourceQueueBuffers_ :: ALuint -> ALsizei -> Ptr ALuint -> IO ()+alSourceQueueBuffers :: (MonadIO m) => ALuint -> ALsizei -> Ptr ALuint -> m ()+alSourceQueueBuffers a b c = liftIO $ alSourceQueueBuffers_ a b c++foreign import CALLCV "alSourceUnqueueBuffers" alSourceUnqueueBuffers_ :: ALuint -> ALsizei -> Ptr ALuint -> IO ()+alSourceUnqueueBuffers :: (MonadIO m) => ALuint -> ALsizei -> Ptr ALuint -> m ()+alSourceUnqueueBuffers a b c = liftIO $ alSourceUnqueueBuffers a b c
src/Sound/AL/State.chs view
@@ -10,24 +10,69 @@  module Sound.AL.State where +import Control.Monad.Trans ( MonadIO(..) )  import Foreign.C.Types import Foreign.Ptr ( Ptr ) import Sound.AL.Types  #include <al.h> -foreign import CALLCV "alEnable" alEnable :: ALenum -> IO ()-foreign import CALLCV "alDisable" alDisable :: ALenum -> IO ()-foreign import CALLCV "alIsEnabled" alIsEnabled :: ALenum -> IO ALboolean-foreign import CALLCV "alGetBoolean" alGetBoolean :: ALenum -> IO ALboolean-foreign import CALLCV "alGetDouble" alGetDouble :: ALenum -> IO ALdouble-foreign import CALLCV "alGetFloat" alGetFloat :: ALenum -> IO ALfloat-foreign import CALLCV "alGetInteger" alGetInteger :: ALenum -> IO ALint-foreign import CALLCV "alGetBooleanv" alGetBooleanv :: ALenum -> Ptr ALboolean -> IO ()-foreign import CALLCV "alGetDoublev" alGetDoublev :: ALenum -> Ptr ALdouble -> IO ()-foreign import CALLCV "alGetFloatv" alGetFloatv :: ALenum -> Ptr ALfloat -> IO ()-foreign import CALLCV "alGetIntegerv" alGetIntegerv :: ALenum -> Ptr ALint -> IO ()-foreign import CALLCV "alGetString" alGetString :: ALenum -> Ptr ALubyte-foreign import CALLCV "alDistanceModel" alDistanceModel :: ALenum -> IO ()-foreign import CALLCV "alDopplerFactor" alDopplerFactor :: ALfloat -> IO ()-foreign import CALLCV "alDopplerVelocity" alDopplerVelocity :: ALfloat -> IO ()+foreign import CALLCV "alEnable" alEnable_ :: ALenum -> IO ()+alEnable :: (MonadIO m) => ALenum -> m ()+alEnable = liftIO . alEnable_++foreign import CALLCV "alDisable" alDisable_ :: ALenum -> IO ()+alDisable :: (MonadIO m) => ALenum -> m ()+alDisable = liftIO . alDisable_++foreign import CALLCV "alIsEnabled" alIsEnabled_ :: ALenum -> IO ALboolean+alIsEnabled :: (MonadIO m) => ALenum -> m ALboolean+alIsEnabled = liftIO . alIsEnabled_++foreign import CALLCV "alGetBoolean" alGetBoolean_ :: ALenum -> IO ALboolean+alGetBoolean :: (MonadIO m) => ALenum -> m ALboolean+alGetBoolean = liftIO . alGetBoolean_++foreign import CALLCV "alGetDouble" alGetDouble_ :: ALenum -> IO ALdouble+alGetDouble :: (MonadIO m) => ALenum -> m ALdouble+alGetDouble = liftIO . alGetDouble_++foreign import CALLCV "alGetFloat" alGetFloat_ :: ALenum -> IO ALfloat+alGetFloat :: (MonadIO m) => ALenum -> m ALfloat+alGetFloat = liftIO . alGetFloat_++foreign import CALLCV "alGetInteger" alGetInteger_ :: ALenum -> IO ALint+alGetInteger :: (MonadIO m) => ALenum -> m ALint+alGetInteger = liftIO . alGetInteger_++foreign import CALLCV "alGetBooleanv" alGetBooleanv_ :: ALenum -> Ptr ALboolean -> IO ()+alGetBooleanv :: (MonadIO m) => ALenum -> Ptr ALboolean -> m ()+alGetBooleanv a b = liftIO $ alGetBooleanv_ a b++foreign import CALLCV "alGetDoublev" alGetDoublev_ :: ALenum -> Ptr ALdouble -> IO ()+alGetDoublev :: (MonadIO m) => ALenum -> Ptr ALdouble -> m ()+alGetDoublev a b = liftIO $ alGetDoublev_ a b++foreign import CALLCV "alGetFloatv" alGetFloatv_ :: ALenum -> Ptr ALfloat -> IO ()+alGetFloatv :: (MonadIO m) => ALenum -> Ptr ALfloat -> m ()+alGetFloatv a b = liftIO $ alGetFloatv_ a b++foreign import CALLCV "alGetIntegerv" alGetIntegerv_ :: ALenum -> Ptr ALint -> IO ()+alGetIntegerv :: (MonadIO m) => ALenum -> Ptr ALint -> m ()+alGetIntegerv a b = liftIO $ alGetIntegerv_ a b++foreign import CALLCV "alGetString" alGetString_ :: ALenum -> IO (Ptr ALubyte)+alGetString :: (MonadIO m) => ALenum -> m (Ptr ALubyte)+alGetString = liftIO . alGetString_++foreign import CALLCV "alDistanceModel" alDistanceModel_ :: ALenum -> IO ()+alDistanceModel :: (MonadIO m) => ALenum -> m ()+alDistanceModel = liftIO . alDistanceModel_++foreign import CALLCV "alDopplerFactor" alDopplerFactor_ :: ALfloat -> IO ()+alDopplerFactor :: (MonadIO m) => ALfloat -> m ()+alDopplerFactor = liftIO . alDopplerFactor_++foreign import CALLCV "alDopplerVelocity" alDopplerVelocity_ :: ALfloat -> IO ()+alDopplerVelocity :: (MonadIO m) => ALfloat -> m ()+alDopplerVelocity = liftIO . alDopplerVelocity_
src/Sound/ALC/Context.chs view
@@ -10,14 +10,32 @@  module Sound.ALC.Context where +import Control.Monad.Trans ( MonadIO(..) ) import Foreign.C.Types import Foreign.Ptr ( Ptr ) import Sound.AL.Types import Sound.ALC.Types -foreign import CALLCV "alcCreateContext" alcCreateContext :: Ptr ALCdevice -> Ptr ALint -> IO (Ptr ALvoid)-foreign import CALLCV "alcMakeContextCurrent" alcMakeContextCurrent :: Ptr ALvoid -> IO ALCenum-foreign import CALLCV "alcProcessContext" alcProcessContext :: Ptr ALvoid -> IO ()-foreign import CALLCV "alcSuspendContext" alcSuspendContext :: Ptr ALvoid -> IO ()-foreign import CALLCV "alcDestroyContext" alcDestroyContext :: Ptr ALvoid -> IO ALCenum-foreign import CALLCV "alcGetCurrentContext" alcGetCurrentContext :: IO (Ptr ALvoid)+foreign import CALLCV "alcCreateContext" alcCreateContext_ :: Ptr ALCdevice -> Ptr ALint -> IO (Ptr ALvoid)+alcCreateContext :: (MonadIO m) => Ptr ALCdevice -> Ptr ALint -> m (Ptr ALvoid)+alcCreateContext a b = liftIO $ alcCreateContext_ a b++foreign import CALLCV "alcMakeContextCurrent" alcMakeContextCurrent_ :: Ptr ALvoid -> IO ALCenum+alcMakeContextCurrent :: (MonadIO m) => Ptr ALvoid -> m ALCenum+alcMakeContextCurrent = liftIO . alcMakeContextCurrent_++foreign import CALLCV "alcProcessContext" alcProcessContext_ :: Ptr ALvoid -> IO ()+alcProcessContext :: (MonadIO m) => Ptr ALvoid -> m ()+alcProcessContext = liftIO . alcProcessContext_++foreign import CALLCV "alcSuspendContext" alcSuspendContext_ :: Ptr ALvoid -> IO ()+alcSuspendContext :: (MonadIO m) => Ptr ALvoid -> m ()+alcSuspendContext = liftIO . alcSuspendContext_++foreign import CALLCV "alcDestroyContext" alcDestroyContext_ :: Ptr ALvoid -> IO ALCenum+alcDestroyContext :: (MonadIO m) => Ptr ALvoid -> m ALCenum+alcDestroyContext = liftIO . alcDestroyContext_++foreign import CALLCV "alcGetCurrentContext" alcGetCurrentContext_ :: IO (Ptr ALvoid)+alcGetCurrentContext :: (MonadIO m) => m (Ptr ALvoid)+alcGetCurrentContext = liftIO alcGetCurrentContext_
src/Sound/ALC/Device.chs view
@@ -10,10 +10,15 @@  module Sound.ALC.Device where -import Foreign.C.Types+import Control.Monad.Trans ( MonadIO(..) ) import Foreign.Ptr ( Ptr ) import Sound.AL.Types import Sound.ALC.Types -foreign import CALLCV alcOpenDevice :: Ptr ALubyte -> IO (Ptr ALCdevice)-foreign import CALLCV alcCloseDevice :: Ptr ALCdevice -> IO ()+foreign import CALLCV "alcOpenDevice" alcOpenDevice_ :: Ptr ALubyte -> IO (Ptr ALCdevice)+alcOpenDevice :: (MonadIO m) => Ptr ALubyte -> m (Ptr ALCdevice)+alcOpenDevice = liftIO . alcOpenDevice_++foreign import CALLCV "alcCloseDevice" alcCloseDevice_ :: Ptr ALCdevice -> IO ()+alcCloseDevice  :: (MonadIO m) => Ptr ALCdevice -> m ()+alcCloseDevice = liftIO . alcCloseDevice_
src/Sound/ALC/Errors.chs view
@@ -10,7 +10,10 @@  module Sound.ALC.Errors where +import Control.Monad.Trans ( MonadIO(..) ) import Foreign.C.Types import Sound.ALC.Types -foreign import CALLCV "alcGetError" alcGetError :: IO ALCenum+foreign import CALLCV "alcGetError" alcGetError_ :: IO ALCenum+alcGetError :: (MonadIO m) => m ALCenum+alcGetError = liftIO alcGetError_
src/Sound/ALC/Extensions.chs view
@@ -10,11 +10,20 @@  module Sound.ALC.Extensions where +import Control.Monad.Trans ( MonadIO(..) ) import Foreign.C.Types import Foreign.Ptr ( Ptr ) import Sound.AL.Types import Sound.ALC.Types -foreign import CALLCV "alcIsExtensionPresent" alcIsExtensionPresent :: Ptr ALCdevice -> Ptr ALubyte -> IO ALboolean-foreign import CALLCV "alcGetProcAddress" alcGetProcAddress :: Ptr ALCdevice -> Ptr ALubyte -> IO (Ptr ALvoid)-foreign import CALLCV "alcGetEnumValue" alcGetEnumValue :: Ptr ALCdevice -> Ptr ALubyte -> IO ALenum+foreign import CALLCV "alcIsExtensionPresent" alcIsExtensionPresent_ :: Ptr ALCdevice -> Ptr ALubyte -> IO ALboolean+alcIsExtensionPresent :: (MonadIO m) => Ptr ALCdevice -> Ptr ALubyte -> m ALboolean+alcIsExtensionPresent a b = liftIO $ alcIsExtensionPresent_ a b++foreign import CALLCV "alcGetProcAddress" alcGetProcAddress_ :: Ptr ALCdevice -> Ptr ALubyte -> IO (Ptr ALvoid)+alcGetProcAddress :: (MonadIO m) => Ptr ALCdevice -> Ptr ALubyte -> m (Ptr ALvoid)+alcGetProcAddress a b = liftIO $ alcGetProcAddress_ a b++foreign import CALLCV "alcGetEnumValue" alcGetEnumValue_ :: Ptr ALCdevice -> Ptr ALubyte -> IO ALenum+alcGetEnumValue :: (MonadIO m) => Ptr ALCdevice -> Ptr ALubyte -> m ALenum+alcGetEnumValue a b = liftIO $ alcGetEnumValue_ a b
src/Sound/ALC/State.chs view
@@ -10,10 +10,16 @@  module Sound.ALC.State where +import Control.Monad.Trans ( MonadIO(..) )  import Foreign.C.Types import Foreign.Ptr ( Ptr ) import Sound.AL.Types import Sound.ALC.Types -foreign import CALLCV "alcGetString" alcGetString :: Ptr ALCdevice -> ALenum -> IO (Ptr ALubyte)-foreign import CALLCV "alcGetIntegerv" alcGetIntegerv :: Ptr ALCdevice -> ALenum -> ALsizei -> Ptr ALint -> IO ()+foreign import CALLCV "alcGetString" alcGetString_ :: Ptr ALCdevice -> ALenum -> IO (Ptr ALubyte)+alcGetString :: (MonadIO m) => Ptr ALCdevice -> ALenum -> m (Ptr ALubyte)+alcGetString a b = liftIO $ alcGetString_ a b++foreign import CALLCV "alcGetIntegerv" alcGetIntegerv_ :: Ptr ALCdevice -> ALenum -> ALsizei -> Ptr ALint -> IO ()+alcGetIntegerv :: (MonadIO m) => Ptr ALCdevice -> ALenum -> ALsizei -> Ptr ALint -> m ()+alcGetIntegerv a b c d = liftIO $ alcGetIntegerv_ a b c d