packages feed

HGamer3D-CAudio-Binding (empty) → 0.1.5

raw patch · 29 files changed

+3242/−0 lines, 29 filesdep +HGamer3D-Datadep +basedep +haskell98setup-changed

Dependencies added: HGamer3D-Data, base, haskell98

Files

+ C2HS.hs view
@@ -0,0 +1,238 @@+--  C->Haskell Compiler: Marshalling library
+--
+--  Copyright (c) [1999...2005] Manuel M T Chakravarty
+--
+--  Redistribution and use in source and binary forms, with or without
+--  modification, are permitted provided that the following conditions are met:
+-- 
+--  1. Redistributions of source code must retain the above copyright notice,
+--     this list of conditions and the following disclaimer. 
+--  2. Redistributions in binary form must reproduce the above copyright
+--     notice, this list of conditions and the following disclaimer in the
+--     documentation and/or other materials provided with the distribution. 
+--  3. The name of the author may not be used to endorse or promote products
+--     derived from this software without specific prior written permission. 
+--
+--  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+--  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+--  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
+--  NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+--  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+--  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+--  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+--  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+--  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+--  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--
+--- Description ---------------------------------------------------------------
+--
+--  Language: Haskell 98
+--
+--  This module provides the marshaling routines for Haskell files produced by 
+--  C->Haskell for binding to C library interfaces.  It exports all of the
+--  low-level FFI (language-independent plus the C-specific parts) together
+--  with the C->HS-specific higher-level marshalling routines.
+--
+
+module C2HS (
+
+  -- * Re-export the language-independent component of the FFI 
+  module Foreign,
+
+  -- * Re-export the C language component of the FFI
+  module Foreign.C,
+
+  -- * Composite marshalling functions
+  withCStringLenIntConv, peekCStringLenIntConv, withIntConv, withFloatConv,
+  peekIntConv, peekFloatConv, withBool, peekBool, withEnum, peekEnum,
+
+  -- * Conditional results using 'Maybe'
+  nothingIf, nothingIfNull,
+
+  -- * Bit masks
+  combineBitMasks, containsBitMask, extractBitMasks,
+
+  -- * Conversion between C and Haskell types
+  cIntConv, cFloatConv, cToBool, cFromBool, cToEnum, cFromEnum
+) where 
+
+
+import Foreign
+import Foreign.C
+
+import Monad (liftM)
+
+
+-- Composite marshalling functions
+-- -------------------------------
+
+-- Strings with explicit length
+--
+withCStringLenIntConv :: Num n => String -> ((CString, n) -> IO a) -> IO a
+withCStringLenIntConv s f    = withCStringLen s $ \(p, n) -> f (p, fromIntegral n)
+
+peekCStringLenIntConv :: Integral n => (CString, n) -> IO String
+peekCStringLenIntConv (s, n) = peekCStringLen (s, fromIntegral n)
+
+-- Marshalling of numerals
+--
+
+withIntConv   :: (Storable b, Integral a, Integral b) 
+              => a -> (Ptr b -> IO c) -> IO c
+withIntConv    = with . fromIntegral
+
+withFloatConv :: (Storable b, RealFloat a, RealFloat b) 
+              => a -> (Ptr b -> IO c) -> IO c
+withFloatConv  = with . realToFrac
+
+peekIntConv   :: (Storable a, Integral a, Integral b) 
+              => Ptr a -> IO b
+peekIntConv    = liftM fromIntegral . peek
+
+peekFloatConv :: (Storable a, RealFloat a, RealFloat b) 
+              => Ptr a -> IO b
+peekFloatConv  = liftM realToFrac . peek
+
+
+-- Everything else below is deprecated.
+-- These functions are not used by code generated by c2hs.
+
+{-# DEPRECATED withBool        "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED peekBool        "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED withEnum        "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED peekEnum        "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED nothingIf       "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED nothingIfNull   "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED combineBitMasks "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED containsBitMask "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED extractBitMasks "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED cIntConv        "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED cFloatConv      "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED cFromBool       "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED cToBool         "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED cToEnum         "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+{-# DEPRECATED cFromEnum       "The C2HS module will soon stop providing unnecessary\nutility functions. Please use standard FFI library functions instead." #-}
+
+
+-- Passing Booleans by reference
+--
+
+withBool :: (Integral a, Storable a) => Bool -> (Ptr a -> IO b) -> IO b
+withBool  = with . fromBool
+
+peekBool :: (Integral a, Storable a) => Ptr a -> IO Bool
+peekBool  = liftM toBool . peek
+
+
+-- Passing enums by reference
+--
+
+withEnum :: (Enum a, Integral b, Storable b) => a -> (Ptr b -> IO c) -> IO c
+withEnum  = with . cFromEnum
+
+peekEnum :: (Enum a, Integral b, Storable b) => Ptr b -> IO a
+peekEnum  = liftM cToEnum . peek
+
+
+-- Storing of 'Maybe' values
+-- -------------------------
+
+--TODO: kill off this orphan instance!
+
+instance Storable a => Storable (Maybe a) where
+  sizeOf    _ = sizeOf    (undefined :: Ptr ())
+  alignment _ = alignment (undefined :: Ptr ())
+
+  peek p = do
+             ptr <- peek (castPtr p)
+             if ptr == nullPtr
+               then return Nothing
+               else liftM Just $ peek ptr
+
+  poke p v = do
+               ptr <- case v of
+                        Nothing -> return nullPtr
+                        Just v' -> new v'
+               poke (castPtr p) ptr
+
+
+-- Conditional results using 'Maybe'
+-- ---------------------------------
+
+-- Wrap the result into a 'Maybe' type.
+--
+-- * the predicate determines when the result is considered to be non-existing,
+--   ie, it is represented by `Nothing'
+--
+-- * the second argument allows to map a result wrapped into `Just' to some
+--   other domain
+--
+nothingIf       :: (a -> Bool) -> (a -> b) -> a -> Maybe b
+nothingIf p f x  = if p x then Nothing else Just $ f x
+
+-- |Instance for special casing null pointers.
+--
+nothingIfNull :: (Ptr a -> b) -> Ptr a -> Maybe b
+nothingIfNull  = nothingIf (== nullPtr)
+
+
+-- Support for bit masks
+-- ---------------------
+
+-- Given a list of enumeration values that represent bit masks, combine these
+-- masks using bitwise disjunction.
+--
+combineBitMasks :: (Enum a, Bits b) => [a] -> b
+combineBitMasks = foldl (.|.) 0 . map (fromIntegral . fromEnum)
+
+-- Tests whether the given bit mask is contained in the given bit pattern
+-- (i.e., all bits set in the mask are also set in the pattern).
+--
+containsBitMask :: (Bits a, Enum b) => a -> b -> Bool
+bits `containsBitMask` bm = let bm' = fromIntegral . fromEnum $ bm
+                            in
+                            bm' .&. bits == bm'
+
+-- |Given a bit pattern, yield all bit masks that it contains.
+--
+-- * This does *not* attempt to compute a minimal set of bit masks that when
+--   combined yield the bit pattern, instead all contained bit masks are
+--   produced.
+--
+extractBitMasks :: (Bits a, Enum b, Bounded b) => a -> [b]
+extractBitMasks bits = 
+  [bm | bm <- [minBound..maxBound], bits `containsBitMask` bm]
+
+
+-- Conversion routines
+-- -------------------
+
+-- |Integral conversion
+--
+cIntConv :: (Integral a, Integral b) => a -> b
+cIntConv  = fromIntegral
+
+-- |Floating conversion
+--
+cFloatConv :: (RealFloat a, RealFloat b) => a -> b
+cFloatConv  = realToFrac
+
+-- |Obtain C value from Haskell 'Bool'.
+--
+cFromBool :: Num a => Bool -> a
+cFromBool  = fromBool
+
+-- |Obtain Haskell 'Bool' from C value.
+--
+cToBool :: Num a => a -> Bool
+cToBool  = toBool
+
+-- |Convert a C enumeration to Haskell.
+--
+cToEnum :: (Integral i, Enum e) => i -> e
+cToEnum  = toEnum . fromIntegral
+
+-- |Convert a Haskell enumeration to C.
+--
+cFromEnum :: (Enum e, Integral i) => e -> i
+cFromEnum  = fromIntegral . fromEnum
+ HGamer3D-CAudio-Binding.cabal view
@@ -0,0 +1,41 @@+Name:                HGamer3D-CAudio-Binding
+Version:             0.1.5
+Synopsis:            Library to enable 3D game development for Haskell - cAudio Bindings
+Description:         
+	Library, to enable 3D game development for Haskell,
+	based on bindings to 3D Graphics, Audio and GUI libraries.
+	THIS MODULE: cAudio Bindings
+    List of features and modules: 
+	  Data Module (Basic Data Types),
+      OGRE Binding (3D Graphics Engine), 
+      OIS Binding (Input System),
+      cAudio Binding (Audio),
+      CEGUI Binding (GUI System),
+      APIs (Haskell style APIs, different ways, to approach API)
+    Platform: Windows only
+	License: Apache License, Version 2.0
+	Install: see http://www.althainz.de/HGamer3D/Download-and-Installation.html
+	
+License:             OtherLicense
+License-file:        LICENSE
+Author:              Peter Althainz
+Maintainer:          althainz@googlemail.com
+Build-Type:          Simple
+Cabal-Version:       >=1.2
+Homepage:            http://www.althainz.de/HGamer3D.html
+Category:            Game
+Extra-source-files:  Setup.hs include/EnumAudioFormats.h,include/EnumDeviceType.h,include/TypeHG3DClass.h,include/TypeVector3.h,include/ClassPtr.h,include/Utils.h,include/CAudioDllDefines.h,include/ClassILogger.h,include/ClassIAudioDeviceList.h,include/ClassIAudioSource.h,include/ClassIAudioManager.h,include/ClassIListener.h,include/ClassIAudioCapture.h
+
+Library
+  Build-Depends:     base >= 3 && < 5, HGamer3D-Data == 0.1.5
+
+  Exposed-modules:   HGamer3D.Bindings.CAudio.EnumAudioFormats,HGamer3D.Bindings.CAudio.EnumDeviceType,HGamer3D.Bindings.CAudio.TypeHG3DClass,HGamer3D.Bindings.CAudio.TypeVector3,HGamer3D.Bindings.CAudio.ClassPtr,HGamer3D.Bindings.CAudio.Utils,HGamer3D.Bindings.CAudio.ClassILogger,HGamer3D.Bindings.CAudio.ClassIAudioDeviceList,HGamer3D.Bindings.CAudio.ClassIAudioSource,HGamer3D.Bindings.CAudio.ClassIAudioManager,HGamer3D.Bindings.CAudio.ClassIListener,HGamer3D.Bindings.CAudio.ClassIAudioCapture
+  Other-modules:     C2HS 
+
+  ghc-options:       
+  cc-options:        -Wno-attributes 
+  hs-source-dirs:    .
+  Include-dirs:      include
+  Build-tools:       
+  build-depends:     haskell98
+  extra-libraries:   HGamer3DCAudio015
+ HGamer3D/Bindings/CAudio/ClassIAudioCapture.hs view
@@ -0,0 +1,282 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- ClassIAudioCapture.chs
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "Dep-cAudio/cAudio/include\IAudioCapture.h"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.ClassIAudioCapture where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+import HGamer3D.Data.HG3DClass
+import HGamer3D.Data.Vector2
+import HGamer3D.Data.Vector3
+import HGamer3D.Data.Vector4
+import HGamer3D.Data.Quaternion
+import HGamer3D.Data.Colour
+import HGamer3D.Data.Angle
+import HGamer3D.Bindings.CAudio.TypeHG3DClass
+{-# LINE 52 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+import HGamer3D.Bindings.CAudio.ClassPtr
+{-# LINE 53 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+import HGamer3D.Bindings.CAudio.Utils
+{-# LINE 54 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+import HGamer3D.Bindings.CAudio.EnumAudioFormats
+{-# LINE 55 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+
+
+cIAcInitialize :: HG3DClass -> String -> Int -> EnumAudioFormats -> Int -> IO (Bool)
+cIAcInitialize a1 a2 a3 a4 a5 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  let {a3' = fromIntegral a3} in 
+  let {a4' = cIntFromEnum a4} in 
+  let {a5' = fromIntegral a5} in 
+  alloca $ \a6' -> 
+  cIAcInitialize'_ a1' a2' a3' a4' a5' a6' >>= \res ->
+  peekBoolUtil  a6'>>= \a6'' -> 
+  return (a6'')
+{-# LINE 65 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcIsReady :: HG3DClass -> IO (Bool)
+cIAcIsReady a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAcIsReady'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 69 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcUpdateCaptureBuffer :: HG3DClass -> Bool -> IO ()
+cIAcUpdateCaptureBuffer a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  cIAcUpdateCaptureBuffer'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 73 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcShutdown :: HG3DClass -> IO ()
+cIAcShutdown a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAcShutdown'_ a1' >>= \res ->
+  return ()
+{-# LINE 76 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcIsUpdateThreadRunning :: HG3DClass -> IO (Bool)
+cIAcIsUpdateThreadRunning a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAcIsUpdateThreadRunning'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 80 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcGetDeviceName :: HG3DClass -> IO (String)
+cIAcGetDeviceName a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloc64k $ \a2' -> 
+  cIAcGetDeviceName'_ a1' a2' >>= \res ->
+  peekCString  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 84 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcGetFrequency :: HG3DClass -> IO (Int)
+cIAcGetFrequency a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAcGetFrequency'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 88 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcGetFormat :: HG3DClass -> IO (EnumAudioFormats)
+cIAcGetFormat a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAcGetFormat'_ a1' a2' >>= \res ->
+  peekEnumUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 92 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcGetInternalBufferSize :: HG3DClass -> IO (Int)
+cIAcGetInternalBufferSize a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAcGetInternalBufferSize'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 96 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcGetSampleSize :: HG3DClass -> IO (Int)
+cIAcGetSampleSize a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAcGetSampleSize'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 100 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcSetDevice :: HG3DClass -> String -> IO (Bool)
+cIAcSetDevice a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  cIAcSetDevice'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 105 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcSetFrequency :: HG3DClass -> Int -> IO (Bool)
+cIAcSetFrequency a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  alloca $ \a3' -> 
+  cIAcSetFrequency'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 110 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcSetFormat :: HG3DClass -> EnumAudioFormats -> IO (Bool)
+cIAcSetFormat a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = cIntFromEnum a2} in 
+  alloca $ \a3' -> 
+  cIAcSetFormat'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 115 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcSetInternalBufferSize :: HG3DClass -> Int -> IO (Bool)
+cIAcSetInternalBufferSize a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  alloca $ \a3' -> 
+  cIAcSetInternalBufferSize'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 120 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcBeginCapture :: HG3DClass -> IO (Bool)
+cIAcBeginCapture a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAcBeginCapture'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 124 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcStopCapture :: HG3DClass -> IO ()
+cIAcStopCapture a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAcStopCapture'_ a1' >>= \res ->
+  return ()
+{-# LINE 127 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcGetCurrentCapturedAudioSize :: HG3DClass -> IO (Int)
+cIAcGetCurrentCapturedAudioSize a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAcGetCurrentCapturedAudioSize'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 131 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+cIAcUnRegisterAllEventHandlers :: HG3DClass -> IO ()
+cIAcUnRegisterAllEventHandlers a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAcUnRegisterAllEventHandlers'_ a1' >>= \res ->
+  return ()
+{-# LINE 134 "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs" #-}
+;
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_initialize_c"
+  cIAcInitialize'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (CUInt -> (CInt -> (CUInt -> ((Ptr CInt) -> (IO ())))))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_isReady_c"
+  cIAcIsReady'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_updateCaptureBuffer_c"
+  cIAcUpdateCaptureBuffer'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_shutdown_c"
+  cIAcShutdown'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_isUpdateThreadRunning_c"
+  cIAcIsUpdateThreadRunning'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_getDeviceName_c"
+  cIAcGetDeviceName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_getFrequency_c"
+  cIAcGetFrequency'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_getFormat_c"
+  cIAcGetFormat'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_getInternalBufferSize_c"
+  cIAcGetInternalBufferSize'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_getSampleSize_c"
+  cIAcGetSampleSize'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_setDevice_c"
+  cIAcSetDevice'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_setFrequency_c"
+  cIAcSetFrequency'_ :: ((HG3DClassPtr) -> (CUInt -> ((Ptr CInt) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_setFormat_c"
+  cIAcSetFormat'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_setInternalBufferSize_c"
+  cIAcSetInternalBufferSize'_ :: ((HG3DClassPtr) -> (CUInt -> ((Ptr CInt) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_beginCapture_c"
+  cIAcBeginCapture'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_stopCapture_c"
+  cIAcStopCapture'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_getCurrentCapturedAudioSize_c"
+  cIAcGetCurrentCapturedAudioSize'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioCapture.chs.h cIAc_unRegisterAllEventHandlers_c"
+  cIAcUnRegisterAllEventHandlers'_ :: ((HG3DClassPtr) -> (IO ()))
+ HGamer3D/Bindings/CAudio/ClassIAudioDeviceList.hs view
@@ -0,0 +1,125 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- ClassIAudioDeviceList.chs
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "Dep-cAudio/cAudio/include\IAudioDeviceList.h"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.ClassIAudioDeviceList where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+import HGamer3D.Data.HG3DClass
+import HGamer3D.Data.Vector2
+import HGamer3D.Data.Vector3
+import HGamer3D.Data.Vector4
+import HGamer3D.Data.Quaternion
+import HGamer3D.Data.Colour
+import HGamer3D.Data.Angle
+import HGamer3D.Bindings.CAudio.TypeHG3DClass
+{-# LINE 52 "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs" #-}
+import HGamer3D.Bindings.CAudio.ClassPtr
+{-# LINE 53 "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs" #-}
+import HGamer3D.Bindings.CAudio.Utils
+{-# LINE 54 "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs" #-}
+
+
+cIAdlGetDeviceCount :: HG3DClass -> IO (Int)
+cIAdlGetDeviceCount a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAdlGetDeviceCount'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 60 "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs" #-}
+;
+cIAdlGetDeviceName :: HG3DClass -> Int -> IO (String)
+cIAdlGetDeviceName a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  alloc64k $ \a3' -> 
+  cIAdlGetDeviceName'_ a1' a2' a3' >>= \res ->
+  peekCString  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 65 "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs" #-}
+;
+cIAdlGetDeviceDescription :: HG3DClass -> Int -> IO (String)
+cIAdlGetDeviceDescription a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  alloc64k $ \a3' -> 
+  cIAdlGetDeviceDescription'_ a1' a2' a3' >>= \res ->
+  peekCString  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 70 "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs" #-}
+;
+cIAdlGetDefaultDeviceName :: HG3DClass -> IO (String)
+cIAdlGetDefaultDeviceName a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloc64k $ \a2' -> 
+  cIAdlGetDefaultDeviceName'_ a1' a2' >>= \res ->
+  peekCString  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 74 "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs" #-}
+;
+cIAdlIsSupported :: HG3DClass -> IO (Bool)
+cIAdlIsSupported a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAdlIsSupported'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 78 "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs" #-}
+;
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs.h cIAdl_getDeviceCount_c"
+  cIAdlGetDeviceCount'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs.h cIAdl_getDeviceName_c"
+  cIAdlGetDeviceName'_ :: ((HG3DClassPtr) -> (CUInt -> ((Ptr CChar) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs.h cIAdl_getDeviceDescription_c"
+  cIAdlGetDeviceDescription'_ :: ((HG3DClassPtr) -> (CUInt -> ((Ptr CChar) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs.h cIAdl_getDefaultDeviceName_c"
+  cIAdlGetDefaultDeviceName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioDeviceList.chs.h cIAdl_isSupported_c"
+  cIAdlIsSupported'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+ HGamer3D/Bindings/CAudio/ClassIAudioManager.hs view
@@ -0,0 +1,350 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- ClassIAudioManager.chs
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "Dep-cAudio/cAudio/include\IAudioManager.h"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.ClassIAudioManager where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+import HGamer3D.Data.HG3DClass
+import HGamer3D.Data.Vector2
+import HGamer3D.Data.Vector3
+import HGamer3D.Data.Vector4
+import HGamer3D.Data.Quaternion
+import HGamer3D.Data.Colour
+import HGamer3D.Data.Angle
+import HGamer3D.Bindings.CAudio.TypeHG3DClass
+{-# LINE 52 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+import HGamer3D.Bindings.CAudio.ClassPtr
+{-# LINE 53 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+import HGamer3D.Bindings.CAudio.Utils
+{-# LINE 54 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+import HGamer3D.Bindings.CAudio.TypeVector3
+{-# LINE 55 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+import HGamer3D.Bindings.CAudio.EnumAudioFormats
+{-# LINE 56 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+
+
+cIAmInitialize :: HG3DClass -> String -> Int -> Int -> IO (Bool)
+cIAmInitialize a1 a2 a3 a4 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  let {a3' = fromIntegral a3} in 
+  let {a4' = fromIntegral a4} in 
+  alloca $ \a5' -> 
+  cIAmInitialize'_ a1' a2' a3' a4' a5' >>= \res ->
+  peekBoolUtil  a5'>>= \a5'' -> 
+  return (a5'')
+{-# LINE 65 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmShutDown :: HG3DClass -> IO ()
+cIAmShutDown a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAmShutDown'_ a1' >>= \res ->
+  return ()
+{-# LINE 68 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmUpdate :: HG3DClass -> IO ()
+cIAmUpdate a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAmUpdate'_ a1' >>= \res ->
+  return ()
+{-# LINE 71 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmIsUpdateThreadRunning :: HG3DClass -> IO (Bool)
+cIAmIsUpdateThreadRunning a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAmIsUpdateThreadRunning'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 75 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmGetSoundByName :: HG3DClass -> String -> IO (HG3DClass)
+cIAmGetSoundByName a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  cIAmGetSoundByName'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 80 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmReleaseAllSources :: HG3DClass -> IO ()
+cIAmReleaseAllSources a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAmReleaseAllSources'_ a1' >>= \res ->
+  return ()
+{-# LINE 83 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmRelease :: HG3DClass -> HG3DClass -> IO ()
+cIAmRelease a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  cIAmRelease'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 87 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmPlay2D :: HG3DClass -> String -> Bool -> Bool -> IO (HG3DClass)
+cIAmPlay2D a1 a2 a3 a4 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  let {a3' = fromBool a3} in 
+  let {a4' = fromBool a4} in 
+  alloca $ \a5' -> 
+  cIAmPlay2D'_ a1' a2' a3' a4' a5' >>= \res ->
+  peek  a5'>>= \a5'' -> 
+  return (a5'')
+{-# LINE 94 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmPlay3D :: HG3DClass -> String -> Vector3 -> Bool -> Bool -> IO (HG3DClass)
+cIAmPlay3D a1 a2 a3 a4 a5 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withVector3 a3 $ \a3' -> 
+  let {a4' = fromBool a4} in 
+  let {a5' = fromBool a5} in 
+  alloca $ \a6' -> 
+  cIAmPlay3D'_ a1' a2' a3' a4' a5' a6' >>= \res ->
+  peek  a6'>>= \a6'' -> 
+  return (a6'')
+{-# LINE 102 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmSetMasterVolume :: HG3DClass -> Float -> IO ()
+cIAmSetMasterVolume a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAmSetMasterVolume'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 106 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmGetMasterVolume :: HG3DClass -> IO (Float)
+cIAmGetMasterVolume a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAmGetMasterVolume'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 110 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmStopAllSounds :: HG3DClass -> IO ()
+cIAmStopAllSounds a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAmStopAllSounds'_ a1' >>= \res ->
+  return ()
+{-# LINE 113 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmCreate :: HG3DClass -> String -> String -> Bool -> IO (HG3DClass)
+cIAmCreate a1 a2 a3 a4 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withCString a3 $ \a3' -> 
+  let {a4' = fromBool a4} in 
+  alloca $ \a5' -> 
+  cIAmCreate'_ a1' a2' a3' a4' a5' >>= \res ->
+  peek  a5'>>= \a5'' -> 
+  return (a5'')
+{-# LINE 120 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmCreateFromMemory :: HG3DClass -> String -> String -> Int -> String -> IO (HG3DClass)
+cIAmCreateFromMemory a1 a2 a3 a4 a5 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withCString a3 $ \a3' -> 
+  let {a4' = fromIntegral a4} in 
+  withCString a5 $ \a5' -> 
+  alloca $ \a6' -> 
+  cIAmCreateFromMemory'_ a1' a2' a3' a4' a5' a6' >>= \res ->
+  peek  a6'>>= \a6'' -> 
+  return (a6'')
+{-# LINE 128 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmCreateFromRaw :: HG3DClass -> String -> String -> Int -> Int -> EnumAudioFormats -> IO (HG3DClass)
+cIAmCreateFromRaw a1 a2 a3 a4 a5 a6 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withCString a3 $ \a3' -> 
+  let {a4' = fromIntegral a4} in 
+  let {a5' = fromIntegral a5} in 
+  let {a6' = cIntFromEnum a6} in 
+  alloca $ \a7' -> 
+  cIAmCreateFromRaw'_ a1' a2' a3' a4' a5' a6' a7' >>= \res ->
+  peek  a7'>>= \a7'' -> 
+  return (a7'')
+{-# LINE 137 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmUnRegisterAudioDecoder :: HG3DClass -> String -> IO ()
+cIAmUnRegisterAudioDecoder a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  cIAmUnRegisterAudioDecoder'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 141 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmIsAudioDecoderRegistered :: HG3DClass -> String -> IO (Bool)
+cIAmIsAudioDecoderRegistered a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  cIAmIsAudioDecoderRegistered'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 146 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmUnRegisterAllAudioDecoders :: HG3DClass -> IO ()
+cIAmUnRegisterAllAudioDecoders a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAmUnRegisterAllAudioDecoders'_ a1' >>= \res ->
+  return ()
+{-# LINE 149 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmUnRegisterDataSource :: HG3DClass -> String -> IO ()
+cIAmUnRegisterDataSource a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  cIAmUnRegisterDataSource'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 153 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmIsDataSourceRegistered :: HG3DClass -> String -> IO (Bool)
+cIAmIsDataSourceRegistered a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  cIAmIsDataSourceRegistered'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 158 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmUnRegisterAllDataSources :: HG3DClass -> IO ()
+cIAmUnRegisterAllDataSources a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAmUnRegisterAllDataSources'_ a1' >>= \res ->
+  return ()
+{-# LINE 161 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmUnRegisterAllEventHandlers :: HG3DClass -> IO ()
+cIAmUnRegisterAllEventHandlers a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAmUnRegisterAllEventHandlers'_ a1' >>= \res ->
+  return ()
+{-# LINE 164 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+cIAmGetListener :: HG3DClass -> IO (HG3DClass)
+cIAmGetListener a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAmGetListener'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 168 "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs" #-}
+;
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_initialize_c"
+  cIAmInitialize'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (CInt -> (CInt -> ((Ptr CInt) -> (IO ()))))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_shutDown_c"
+  cIAmShutDown'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_update_c"
+  cIAmUpdate'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_isUpdateThreadRunning_c"
+  cIAmIsUpdateThreadRunning'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_getSoundByName_c"
+  cIAmGetSoundByName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_releaseAllSources_c"
+  cIAmReleaseAllSources'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_release_c"
+  cIAmRelease'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_play2D_c"
+  cIAmPlay2D'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (CInt -> (CInt -> ((HG3DClassPtr) -> (IO ()))))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_play3D_c"
+  cIAmPlay3D'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Vector3Ptr) -> (CInt -> (CInt -> ((HG3DClassPtr) -> (IO ())))))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_setMasterVolume_c"
+  cIAmSetMasterVolume'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_getMasterVolume_c"
+  cIAmGetMasterVolume'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_stopAllSounds_c"
+  cIAmStopAllSounds'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_create_c"
+  cIAmCreate'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (CInt -> ((HG3DClassPtr) -> (IO ()))))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_createFromMemory_c"
+  cIAmCreateFromMemory'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (CInt -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ())))))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_createFromRaw_c"
+  cIAmCreateFromRaw'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (CInt -> (CUInt -> (CInt -> ((HG3DClassPtr) -> (IO ()))))))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_unRegisterAudioDecoder_c"
+  cIAmUnRegisterAudioDecoder'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_isAudioDecoderRegistered_c"
+  cIAmIsAudioDecoderRegistered'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_unRegisterAllAudioDecoders_c"
+  cIAmUnRegisterAllAudioDecoders'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_unRegisterDataSource_c"
+  cIAmUnRegisterDataSource'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_isDataSourceRegistered_c"
+  cIAmIsDataSourceRegistered'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_unRegisterAllDataSources_c"
+  cIAmUnRegisterAllDataSources'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_unRegisterAllEventHandlers_c"
+  cIAmUnRegisterAllEventHandlers'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioManager.chs.h cIAm_getListener_c"
+  cIAmGetListener'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))
+ HGamer3D/Bindings/CAudio/ClassIAudioSource.hs view
@@ -0,0 +1,683 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- ClassIAudioSource.chs
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "Dep-cAudio/cAudio/include\IAudioSource.h"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.ClassIAudioSource where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+import HGamer3D.Data.HG3DClass
+import HGamer3D.Data.Vector2
+import HGamer3D.Data.Vector3
+import HGamer3D.Data.Vector4
+import HGamer3D.Data.Quaternion
+import HGamer3D.Data.Colour
+import HGamer3D.Data.Angle
+import HGamer3D.Bindings.CAudio.TypeHG3DClass
+{-# LINE 52 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+import HGamer3D.Bindings.CAudio.ClassPtr
+{-# LINE 53 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+import HGamer3D.Bindings.CAudio.Utils
+{-# LINE 54 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+import HGamer3D.Bindings.CAudio.TypeVector3
+{-# LINE 55 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+
+
+cIAsPlay :: HG3DClass -> IO (Bool)
+cIAsPlay a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsPlay'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 61 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsPlay2d :: HG3DClass -> Bool -> IO (Bool)
+cIAsPlay2d a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  alloca $ \a3' -> 
+  cIAsPlay2d'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 66 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsPlay3d :: HG3DClass -> Vector3 -> Float -> Bool -> IO (Bool)
+cIAsPlay3d a1 a2 a3 a4 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  let {a3' = realToFrac a3} in 
+  let {a4' = fromBool a4} in 
+  alloca $ \a5' -> 
+  cIAsPlay3d'_ a1' a2' a3' a4' a5' >>= \res ->
+  peekBoolUtil  a5'>>= \a5'' -> 
+  return (a5'')
+{-# LINE 73 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsPause :: HG3DClass -> IO ()
+cIAsPause a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAsPause'_ a1' >>= \res ->
+  return ()
+{-# LINE 76 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsStop :: HG3DClass -> IO ()
+cIAsStop a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAsStop'_ a1' >>= \res ->
+  return ()
+{-# LINE 79 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsLoop :: HG3DClass -> Bool -> IO ()
+cIAsLoop a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  cIAsLoop'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 83 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSeek :: HG3DClass -> Float -> Bool -> IO (Bool)
+cIAsSeek a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  let {a3' = fromBool a3} in 
+  alloca $ \a4' -> 
+  cIAsSeek'_ a1' a2' a3' a4' >>= \res ->
+  peekBoolUtil  a4'>>= \a4'' -> 
+  return (a4'')
+{-# LINE 89 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetTotalAudioTime :: HG3DClass -> IO (Float)
+cIAsGetTotalAudioTime a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetTotalAudioTime'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 93 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetTotalAudioSize :: HG3DClass -> IO (Int)
+cIAsGetTotalAudioSize a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetTotalAudioSize'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 97 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetCompressedAudioSize :: HG3DClass -> IO (Int)
+cIAsGetCompressedAudioSize a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetCompressedAudioSize'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 101 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetCurrentAudioTime :: HG3DClass -> IO (Float)
+cIAsGetCurrentAudioTime a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetCurrentAudioTime'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 105 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetCurrentAudioPosition :: HG3DClass -> IO (Int)
+cIAsGetCurrentAudioPosition a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetCurrentAudioPosition'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 109 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetCurrentCompressedAudioPosition :: HG3DClass -> IO (Int)
+cIAsGetCurrentCompressedAudioPosition a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetCurrentCompressedAudioPosition'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 113 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsUpdate :: HG3DClass -> IO (Bool)
+cIAsUpdate a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsUpdate'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 117 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsIsValid :: HG3DClass -> IO (Bool)
+cIAsIsValid a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsIsValid'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 121 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsIsPlaying :: HG3DClass -> IO (Bool)
+cIAsIsPlaying a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsIsPlaying'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 125 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsIsPaused :: HG3DClass -> IO (Bool)
+cIAsIsPaused a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsIsPaused'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 129 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsIsStopped :: HG3DClass -> IO (Bool)
+cIAsIsStopped a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsIsStopped'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 133 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsIsLooping :: HG3DClass -> IO (Bool)
+cIAsIsLooping a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsIsLooping'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 137 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetPosition :: HG3DClass -> Vector3 -> IO ()
+cIAsSetPosition a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cIAsSetPosition'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 141 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetVelocity :: HG3DClass -> Vector3 -> IO ()
+cIAsSetVelocity a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cIAsSetVelocity'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 145 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetDirection :: HG3DClass -> Vector3 -> IO ()
+cIAsSetDirection a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cIAsSetDirection'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 149 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetRolloffFactor :: HG3DClass -> Float -> IO ()
+cIAsSetRolloffFactor a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetRolloffFactor'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 153 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetStrength :: HG3DClass -> Float -> IO ()
+cIAsSetStrength a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetStrength'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 157 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetMinDistance :: HG3DClass -> Float -> IO ()
+cIAsSetMinDistance a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetMinDistance'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 161 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetMaxDistance :: HG3DClass -> Float -> IO ()
+cIAsSetMaxDistance a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetMaxDistance'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 165 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetPitch :: HG3DClass -> Float -> IO ()
+cIAsSetPitch a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetPitch'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 169 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetVolume :: HG3DClass -> Float -> IO ()
+cIAsSetVolume a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetVolume'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 173 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetMinVolume :: HG3DClass -> Float -> IO ()
+cIAsSetMinVolume a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetMinVolume'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 177 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetMaxVolume :: HG3DClass -> Float -> IO ()
+cIAsSetMaxVolume a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetMaxVolume'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 181 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetInnerConeAngle :: HG3DClass -> Float -> IO ()
+cIAsSetInnerConeAngle a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetInnerConeAngle'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 185 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetOuterConeAngle :: HG3DClass -> Float -> IO ()
+cIAsSetOuterConeAngle a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetOuterConeAngle'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 189 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetOuterConeVolume :: HG3DClass -> Float -> IO ()
+cIAsSetOuterConeVolume a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetOuterConeVolume'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 193 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetDopplerStrength :: HG3DClass -> Float -> IO ()
+cIAsSetDopplerStrength a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cIAsSetDopplerStrength'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 197 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsSetDopplerVelocity :: HG3DClass -> Vector3 -> IO ()
+cIAsSetDopplerVelocity a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cIAsSetDopplerVelocity'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 201 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsMove :: HG3DClass -> Vector3 -> IO ()
+cIAsMove a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cIAsMove'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 205 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetPosition :: HG3DClass -> IO (Vector3)
+cIAsGetPosition a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetPosition'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 209 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetVelocity :: HG3DClass -> IO (Vector3)
+cIAsGetVelocity a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetVelocity'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 213 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetDirection :: HG3DClass -> IO (Vector3)
+cIAsGetDirection a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetDirection'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 217 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetRolloffFactor :: HG3DClass -> IO (Float)
+cIAsGetRolloffFactor a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetRolloffFactor'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 221 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetStrength :: HG3DClass -> IO (Float)
+cIAsGetStrength a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetStrength'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 225 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetMinDistance :: HG3DClass -> IO (Float)
+cIAsGetMinDistance a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetMinDistance'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 229 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetMaxDistance :: HG3DClass -> IO (Float)
+cIAsGetMaxDistance a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetMaxDistance'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 233 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetPitch :: HG3DClass -> IO (Float)
+cIAsGetPitch a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetPitch'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 237 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetVolume :: HG3DClass -> IO (Float)
+cIAsGetVolume a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetVolume'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 241 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetMinVolume :: HG3DClass -> IO (Float)
+cIAsGetMinVolume a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetMinVolume'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 245 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetMaxVolume :: HG3DClass -> IO (Float)
+cIAsGetMaxVolume a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetMaxVolume'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 249 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetInnerConeAngle :: HG3DClass -> IO (Float)
+cIAsGetInnerConeAngle a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetInnerConeAngle'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 253 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetOuterConeAngle :: HG3DClass -> IO (Float)
+cIAsGetOuterConeAngle a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetOuterConeAngle'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 257 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetOuterConeVolume :: HG3DClass -> IO (Float)
+cIAsGetOuterConeVolume a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetOuterConeVolume'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 261 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetDopplerStrength :: HG3DClass -> IO (Float)
+cIAsGetDopplerStrength a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetDopplerStrength'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 265 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsGetDopplerVelocity :: HG3DClass -> IO (Vector3)
+cIAsGetDopplerVelocity a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cIAsGetDopplerVelocity'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 269 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+cIAsUnRegisterAllEventHandlers :: HG3DClass -> IO ()
+cIAsUnRegisterAllEventHandlers a1 =
+  withHG3DClass a1 $ \a1' -> 
+  cIAsUnRegisterAllEventHandlers'_ a1' >>= \res ->
+  return ()
+{-# LINE 272 "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs" #-}
+;
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_play_c"
+  cIAsPlay'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_play2d_c"
+  cIAsPlay2d'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_play3d_c"
+  cIAsPlay3d'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (CFloat -> (CInt -> ((Ptr CInt) -> (IO ()))))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_pause_c"
+  cIAsPause'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_stop_c"
+  cIAsStop'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_loop_c"
+  cIAsLoop'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_seek_c"
+  cIAsSeek'_ :: ((HG3DClassPtr) -> (CFloat -> (CInt -> ((Ptr CInt) -> (IO ())))))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getTotalAudioTime_c"
+  cIAsGetTotalAudioTime'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getTotalAudioSize_c"
+  cIAsGetTotalAudioSize'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getCompressedAudioSize_c"
+  cIAsGetCompressedAudioSize'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getCurrentAudioTime_c"
+  cIAsGetCurrentAudioTime'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getCurrentAudioPosition_c"
+  cIAsGetCurrentAudioPosition'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getCurrentCompressedAudioPosition_c"
+  cIAsGetCurrentCompressedAudioPosition'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_update_c"
+  cIAsUpdate'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_isValid_c"
+  cIAsIsValid'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_isPlaying_c"
+  cIAsIsPlaying'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_isPaused_c"
+  cIAsIsPaused'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_isStopped_c"
+  cIAsIsStopped'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_isLooping_c"
+  cIAsIsLooping'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setPosition_c"
+  cIAsSetPosition'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setVelocity_c"
+  cIAsSetVelocity'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setDirection_c"
+  cIAsSetDirection'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setRolloffFactor_c"
+  cIAsSetRolloffFactor'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setStrength_c"
+  cIAsSetStrength'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setMinDistance_c"
+  cIAsSetMinDistance'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setMaxDistance_c"
+  cIAsSetMaxDistance'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setPitch_c"
+  cIAsSetPitch'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setVolume_c"
+  cIAsSetVolume'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setMinVolume_c"
+  cIAsSetMinVolume'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setMaxVolume_c"
+  cIAsSetMaxVolume'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setInnerConeAngle_c"
+  cIAsSetInnerConeAngle'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setOuterConeAngle_c"
+  cIAsSetOuterConeAngle'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setOuterConeVolume_c"
+  cIAsSetOuterConeVolume'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setDopplerStrength_c"
+  cIAsSetDopplerStrength'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_setDopplerVelocity_c"
+  cIAsSetDopplerVelocity'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_move_c"
+  cIAsMove'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getPosition_c"
+  cIAsGetPosition'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getVelocity_c"
+  cIAsGetVelocity'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getDirection_c"
+  cIAsGetDirection'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getRolloffFactor_c"
+  cIAsGetRolloffFactor'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getStrength_c"
+  cIAsGetStrength'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getMinDistance_c"
+  cIAsGetMinDistance'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getMaxDistance_c"
+  cIAsGetMaxDistance'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getPitch_c"
+  cIAsGetPitch'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getVolume_c"
+  cIAsGetVolume'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getMinVolume_c"
+  cIAsGetMinVolume'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getMaxVolume_c"
+  cIAsGetMaxVolume'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getInnerConeAngle_c"
+  cIAsGetInnerConeAngle'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getOuterConeAngle_c"
+  cIAsGetOuterConeAngle'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getOuterConeVolume_c"
+  cIAsGetOuterConeVolume'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getDopplerStrength_c"
+  cIAsGetDopplerStrength'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_getDopplerVelocity_c"
+  cIAsGetDopplerVelocity'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIAudioSource.chs.h cIAs_unRegisterAllEventHandlers_c"
+  cIAsUnRegisterAllEventHandlers'_ :: ((HG3DClassPtr) -> (IO ()))
+ HGamer3D/Bindings/CAudio/ClassIListener.hs view
@@ -0,0 +1,191 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- ClassIListener.chs
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "Dep-cAudio/cAudio/include\IListener.h"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.ClassIListener where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+import HGamer3D.Data.HG3DClass
+import HGamer3D.Data.Vector2
+import HGamer3D.Data.Vector3
+import HGamer3D.Data.Vector4
+import HGamer3D.Data.Quaternion
+import HGamer3D.Data.Colour
+import HGamer3D.Data.Angle
+import HGamer3D.Bindings.CAudio.TypeHG3DClass
+{-# LINE 52 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+import HGamer3D.Bindings.CAudio.ClassPtr
+{-# LINE 53 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+import HGamer3D.Bindings.CAudio.Utils
+{-# LINE 54 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+import HGamer3D.Bindings.CAudio.TypeVector3
+{-# LINE 55 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+
+
+cILSetPosition :: HG3DClass -> Vector3 -> IO ()
+cILSetPosition a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cILSetPosition'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 61 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILSetDirection :: HG3DClass -> Vector3 -> IO ()
+cILSetDirection a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cILSetDirection'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 65 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILSetUpVector :: HG3DClass -> Vector3 -> IO ()
+cILSetUpVector a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cILSetUpVector'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 69 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILSetVelocity :: HG3DClass -> Vector3 -> IO ()
+cILSetVelocity a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cILSetVelocity'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 73 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILSetMasterVolume :: HG3DClass -> Float -> IO ()
+cILSetMasterVolume a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  cILSetMasterVolume'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 77 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILMove :: HG3DClass -> Vector3 -> IO ()
+cILMove a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withVector3 a2 $ \a2' -> 
+  cILMove'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 81 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILGetPosition :: HG3DClass -> IO (Vector3)
+cILGetPosition a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cILGetPosition'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 85 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILGetDirection :: HG3DClass -> IO (Vector3)
+cILGetDirection a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cILGetDirection'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 89 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILGetUpVector :: HG3DClass -> IO (Vector3)
+cILGetUpVector a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cILGetUpVector'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 93 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILGetVelocity :: HG3DClass -> IO (Vector3)
+cILGetVelocity a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cILGetVelocity'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 97 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+cILGetMasterVolume :: HG3DClass -> IO (Float)
+cILGetMasterVolume a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  cILGetMasterVolume'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 101 "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs" #-}
+;
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_setPosition_c"
+  cILSetPosition'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_setDirection_c"
+  cILSetDirection'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_setUpVector_c"
+  cILSetUpVector'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_setVelocity_c"
+  cILSetVelocity'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_setMasterVolume_c"
+  cILSetMasterVolume'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_move_c"
+  cILMove'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_getPosition_c"
+  cILGetPosition'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_getDirection_c"
+  cILGetDirection'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_getUpVector_c"
+  cILGetUpVector'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_getVelocity_c"
+  cILGetVelocity'_ :: ((HG3DClassPtr) -> ((Vector3Ptr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassIListener.chs.h cIL_getMasterVolume_c"
+  cILGetMasterVolume'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))
+ HGamer3D/Bindings/CAudio/ClassILogger.hs view
@@ -0,0 +1,87 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\ClassILogger.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- ClassILogger.chs
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "Dep-cAudio/cAudio/include\ILogger.h"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.ClassILogger where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+import HGamer3D.Data.HG3DClass
+import HGamer3D.Data.Vector2
+import HGamer3D.Data.Vector3
+import HGamer3D.Data.Vector4
+import HGamer3D.Data.Quaternion
+import HGamer3D.Data.Colour
+import HGamer3D.Data.Angle
+import HGamer3D.Bindings.CAudio.TypeHG3DClass
+{-# LINE 52 "HGamer3D\\Bindings\\CAudio\\ClassILogger.chs" #-}
+import HGamer3D.Bindings.CAudio.ClassPtr
+{-# LINE 53 "HGamer3D\\Bindings\\CAudio\\ClassILogger.chs" #-}
+import HGamer3D.Bindings.CAudio.Utils
+{-# LINE 54 "HGamer3D\\Bindings\\CAudio\\ClassILogger.chs" #-}
+
+
+cIAlUnRegisterLogReceiver :: HG3DClass -> String -> IO ()
+cIAlUnRegisterLogReceiver a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  cIAlUnRegisterLogReceiver'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 60 "HGamer3D\\Bindings\\CAudio\\ClassILogger.chs" #-}
+;
+cIAlIsLogReceiverRegistered :: HG3DClass -> String -> IO (Bool)
+cIAlIsLogReceiverRegistered a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  cIAlIsLogReceiverRegistered'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 65 "HGamer3D\\Bindings\\CAudio\\ClassILogger.chs" #-}
+;
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassILogger.chs.h cIAl_unRegisterLogReceiver_c"
+  cIAlUnRegisterLogReceiver'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\ClassILogger.chs.h cIAl_isLogReceiverRegistered_c"
+  cIAlIsLogReceiverRegistered'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))
+ HGamer3D/Bindings/CAudio/ClassPtr.hs view
@@ -0,0 +1,54 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\ClassPtr.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+--
+-- Copyright 2011 Dr. Peter Althainz
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+
+-- ClassPtr.chs
+
+module HGamer3D.Bindings.CAudio.ClassPtr where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+
+{- class ClassILogger -}
+type ClassILogger = Ptr (())
+{-# LINE 35 "HGamer3D\\Bindings\\CAudio\\ClassPtr.chs" #-}
+{- class ClassIAudioDeviceList -}
+type ClassIAudioDeviceList = Ptr (())
+{-# LINE 37 "HGamer3D\\Bindings\\CAudio\\ClassPtr.chs" #-}
+{- class ClassIAudioSource -}
+type ClassIAudioSource = Ptr (())
+{-# LINE 39 "HGamer3D\\Bindings\\CAudio\\ClassPtr.chs" #-}
+{- class ClassIAudioManager -}
+type ClassIAudioManager = Ptr (())
+{-# LINE 41 "HGamer3D\\Bindings\\CAudio\\ClassPtr.chs" #-}
+{- class ClassIListener -}
+type ClassIListener = Ptr (())
+{-# LINE 43 "HGamer3D\\Bindings\\CAudio\\ClassPtr.chs" #-}
+{- class ClassIAudioCapture -}
+type ClassIAudioCapture = Ptr (())
+{-# LINE 45 "HGamer3D\\Bindings\\CAudio\\ClassPtr.chs" #-}
+ HGamer3D/Bindings/CAudio/EnumAudioFormats.hs view
@@ -0,0 +1,57 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\EnumAudioFormats.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- EnumAudioFormats.h
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "Dep-cAudio/cAudio/include\EAudioFormats.h"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.EnumAudioFormats where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+
+
+
+{- enum from Dep-cAudio/cAudio/include\EAudioFormats.h line:10 -}
+data EnumAudioFormats = Eaf8bitMono
+                      | Eaf8bitStereo
+                      | Eaf16bitMono
+                      | Eaf16bitStereo
+                      deriving (Enum,Eq)
+ HGamer3D/Bindings/CAudio/EnumDeviceType.hs view
@@ -0,0 +1,62 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\EnumDeviceType.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- EnumDeviceType.h
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "Dep-cAudio/cAudio/include\IAudioDeviceList.h"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.EnumDeviceType where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+
+
+
+{- enum from Dep-cAudio/cAudio/include\IAudioDeviceList.h line:11 -}
+data EnumDeviceType = DtPlayback
+                    | DtRecording
+                    deriving (Eq)
+instance Enum EnumDeviceType where
+  fromEnum DtPlayback = 0
+  fromEnum DtRecording = 2
+
+  toEnum 0 = DtPlayback
+  toEnum 2 = DtRecording
+  toEnum unmatched = error ("EnumDeviceType.toEnum: Cannot match " ++ show unmatched)
+ HGamer3D/Bindings/CAudio/TypeHG3DClass.hs view
@@ -0,0 +1,59 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\TypeHG3DClass.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- TypeHG3DClass.chs
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "<parsedfile>"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.TypeHG3DClass where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+
+
+import Data.Bits
+import HGamer3D.Data.HG3DClass
+
+type HG3DClassPtr = Ptr (HG3DClass)
+{-# LINE 51 "HGamer3D\\Bindings\\CAudio\\TypeHG3DClass.chs" #-}
+
+
+withHG3DClass :: HG3DClass -> (HG3DClassPtr -> IO b) -> IO b
+withHG3DClass = with
+ HGamer3D/Bindings/CAudio/TypeVector3.hs view
@@ -0,0 +1,73 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\TypeVector3.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+-- 
+-- (c) 2011 Peter Althainz
+-- 
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+-- 
+--     http://www.apache.org/licenses/LICENSE-2.0
+-- 
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+-- 
+-- TypeVector3.chs
+-- 
+-- 
+-- 
+-- 
+-- File for type, method, enum or function stubs  
+-- in: "<parsedfile>"
+-- 
+-- each stub combines the following files: 
+--     a C++ implementation file, transforming cpp calls into C-functions
+--     a C-header file, making this C-functions available for the C2HS parser
+--     a chs file, give instructions to the C2HS parser.
+-- 
+-- 
+
+module HGamer3D.Bindings.CAudio.TypeVector3 where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+
+
+import Data.Bits
+import HGamer3D.Data.Vector3
+
+instance Storable Vector3 where
+  alignment _ = alignment (undefined :: CDouble)
+  sizeOf _ = 12
+{-# LINE 53 "HGamer3D\\Bindings\\CAudio\\TypeVector3.chs" #-}
+  peek p = do
+	x <- (\ptr -> do {peekByteOff ptr 0 ::IO CFloat}) p
+	y <- (\ptr -> do {peekByteOff ptr 4 ::IO CFloat}) p
+	z <- (\ptr -> do {peekByteOff ptr 8 ::IO CFloat}) p
+	let v = vector3 (realToFrac x) (realToFrac y) (realToFrac z)
+	return v
+  poke p v3 = do
+    (\ptr val -> do {pokeByteOff ptr 0 (val::CFloat)}) p (realToFrac (v3X v3))
+    (\ptr val -> do {pokeByteOff ptr 4 (val::CFloat)}) p (realToFrac (v3Y v3))
+    (\ptr val -> do {pokeByteOff ptr 8 (val::CFloat)}) p (realToFrac (v3Z v3))
+    
+type Vector3Ptr = Ptr (Vector3)
+{-# LINE 65 "HGamer3D\\Bindings\\CAudio\\TypeVector3.chs" #-}
+
+withVector3 :: Vector3 -> (Vector3Ptr -> IO b) -> IO b
+withVector3 = with
+ HGamer3D/Bindings/CAudio/Utils.hs view
@@ -0,0 +1,159 @@+-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
+-- Edit the ORIGNAL .chs file instead!
+
+
+{-# LINE 1 "HGamer3D\\Bindings\\CAudio\\Utils.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+--
+-- (c) 2012 Peter Althainz
+--
+-- Licensed under the Apache License, Version 2.0 (the "Lic.ense");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+
+module HGamer3D.Bindings.CAudio.Utils where
+
+import C2HS
+import Foreign
+import Foreign.Ptr
+import Foreign.C
+import Monad         (liftM, liftM2)
+
+import HGamer3D.Data.HG3DClass
+import HGamer3D.Bindings.CAudio.EnumDeviceType
+
+import HGamer3D.Bindings.CAudio.ClassPtr
+{-# LINE 33 "HGamer3D\\Bindings\\CAudio\\Utils.chs" #-}
+import HGamer3D.Bindings.CAudio.TypeHG3DClass
+{-# LINE 34 "HGamer3D\\Bindings\\CAudio\\Utils.chs" #-}
+
+
+
+-- now here come different pieces of utilities
+--
+
+-- String Conversion functions
+--
+
+withCUString b f = withCWString b (f . castPtr)
+peekCUString = peekCWString . castPtr
+alloc64k = allocaBytes (1024 * 64)
+
+
+-- c2hs replacements of utility functions, to get rid of annoying c2hs
+-- deprecated messages
+
+-- Passing Enums
+
+cIntFromEnum :: Enum a => a -> CInt
+cIntFromEnum = cIntConv . fromEnum
+
+cIntToEnum :: Enum a => CInt -> a
+cIntToEnum = toEnum . cIntConv
+
+
+-- Passing Booleans by reference
+--
+
+withBoolUtil :: (Integral a, Storable a) => Bool -> (Ptr a -> IO b) -> IO b
+withBoolUtil  = with . fromBool
+
+peekBoolUtil :: (Integral a, Storable a) => Ptr a -> IO Bool
+peekBoolUtil  = liftM toBool . peek
+
+
+-- Passing enums by reference
+--
+
+withEnumUtil :: (Enum a, Integral b, Storable b) => a -> (Ptr b -> IO c) -> IO c
+withEnumUtil  = with . cFromEnum
+
+peekEnumUtil :: (Enum a, Integral b, Storable b) => Ptr b -> IO a
+peekEnumUtil  = liftM cToEnum . peek
+
+
+fUCreateAudioManager :: Bool -> IO (HG3DClass)
+fUCreateAudioManager a1 =
+  let {a1' = fromBool a1} in 
+  alloca $ \a2' -> 
+  fUCreateAudioManager'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 85 "HGamer3D\\Bindings\\CAudio\\Utils.chs" #-}
+;
+
+fUDestroyAudioManager :: HG3DClass -> IO ()
+fUDestroyAudioManager a1 =
+  withHG3DClass a1 $ \a1' -> 
+  fUDestroyAudioManager'_ a1' >>= \res ->
+  return ()
+{-# LINE 89 "HGamer3D\\Bindings\\CAudio\\Utils.chs" #-}
+;
+
+fUCreateAudioCapture :: Bool -> IO (HG3DClass)
+fUCreateAudioCapture a1 =
+  let {a1' = fromBool a1} in 
+  alloca $ \a2' -> 
+  fUCreateAudioCapture'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 95 "HGamer3D\\Bindings\\CAudio\\Utils.chs" #-}
+;
+
+fUDestroyAudioCapture :: HG3DClass -> IO ()
+fUDestroyAudioCapture a1 =
+  withHG3DClass a1 $ \a1' -> 
+  fUDestroyAudioCapture'_ a1' >>= \res ->
+  return ()
+{-# LINE 99 "HGamer3D\\Bindings\\CAudio\\Utils.chs" #-}
+;
+
+fUGetLogger :: IO (HG3DClass)
+fUGetLogger =
+  alloca $ \a1' -> 
+  fUGetLogger'_ a1' >>= \res ->
+  peek  a1'>>= \a1'' -> 
+  return (a1'')
+{-# LINE 105 "HGamer3D\\Bindings\\CAudio\\Utils.chs" #-}
+;
+
+fUCreateAudioDeviceList :: EnumDeviceType -> IO (HG3DClass)
+fUCreateAudioDeviceList a1 =
+  let {a1' = cIntFromEnum a1} in 
+  alloca $ \a2' -> 
+  fUCreateAudioDeviceList'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 111 "HGamer3D\\Bindings\\CAudio\\Utils.chs" #-}
+;
+
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\Utils.chs.h fU_createAudioManager_c"
+  fUCreateAudioManager'_ :: (CInt -> ((HG3DClassPtr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\Utils.chs.h fU_destroyAudioManager_c"
+  fUDestroyAudioManager'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\Utils.chs.h fU_createAudioCapture_c"
+  fUCreateAudioCapture'_ :: (CInt -> ((HG3DClassPtr) -> (IO ())))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\Utils.chs.h fU_destroyAudioCapture_c"
+  fUDestroyAudioCapture'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\Utils.chs.h fU_getLogger_c"
+  fUGetLogger'_ :: ((HG3DClassPtr) -> (IO ()))
+
+foreign import ccall safe "HGamer3D\\Bindings\\CAudio\\Utils.chs.h fU_createAudioDeviceList_c"
+  fUCreateAudioDeviceList'_ :: (CInt -> ((HG3DClassPtr) -> (IO ())))
+ LICENSE view
@@ -0,0 +1,13 @@+(c) 2011-2012 Peter Althainz
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+ Setup.hs view
@@ -0,0 +1,22 @@+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+--
+-- (c) 2011 Peter Althainz
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+
+-- Setup.hs
+
+import Distribution.Simple
+main = defaultMain
+ include/CAudioDllDefines.h view
@@ -0,0 +1,45 @@+/*
+This source file is part of HGamer3D
+(A project to enable 3D game development in Haskell)
+For the latest info, see http://www.althainz.de/HGamer3D.html
+
+(c) 2011 Peter Althainz
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// CAudioDllDefines.h
+
+#ifndef _HGamer3DCAudio015_DLLDEFINES_H_
+#define _HGamer3DCAudio015_DLLDEFINES_H_
+
+/* Cmake will define HGamer3DCAudio015_EXPORTS on Windows when it
+configures to build a shared library. If you are going to use
+another build system on windows or create the visual studio
+projects by hand you need to define MyLibrary_EXPORTS when
+building a DLL on windows.
+*/
+
+// We are using the Visual Studio Compiler and building Shared libraries
+
+#if (defined (_WIN32)) && !(defined (__GNUC__)) 
+  #if defined(HGamer3DCAudio015_EXPORTS)
+    #define  CAudio_LIB_EXPORT __declspec(dllexport)
+  #else
+    #define  CAudio_LIB_EXPORT __declspec(dllimport)
+  #endif /* HGamer3DCAudio015_EXPORTS */
+#else /* defined (_WIN32) */
+ #define CAudio_LIB_EXPORT
+#endif
+
+#endif /* _HGamer3DCAudio015_DLLDEFINES_H_ */
+ include/ClassIAudioCapture.h view
@@ -0,0 +1,75 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// ClassIAudioCapture.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "Dep-cAudio/cAudio/include\IAudioCapture.h"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+#include "ClassPtr.h"
+#include "Utils.h"
+#include "EnumAudioFormats.h"
+
+
+// original function: bool initialize(const char* deviceName, unsigned int frequency, AudioFormats format, unsigned int internalBufferSize);
+void cIAc_initialize_c(struct hg3dclass_struct *classptr_c, char* deviceName_c, unsigned int frequency_c, enum EnumAudioFormats format_c, unsigned int internalBufferSize_c, int * result_c);
+// original function: bool isReady();
+void cIAc_isReady_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: void updateCaptureBuffer(bool force);
+void cIAc_updateCaptureBuffer_c(struct hg3dclass_struct *classptr_c, int force_c);
+// original function: void shutdown();
+void cIAc_shutdown_c(struct hg3dclass_struct *classptr_c);
+// original function: bool isUpdateThreadRunning();
+void cIAc_isUpdateThreadRunning_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: const char* getDeviceName();
+void cIAc_getDeviceName_c(struct hg3dclass_struct *classptr_c, char* result_c);
+// original function: unsigned int getFrequency();
+void cIAc_getFrequency_c(struct hg3dclass_struct *classptr_c, unsigned int * result_c);
+// original function: AudioFormats getFormat();
+void cIAc_getFormat_c(struct hg3dclass_struct *classptr_c, enum EnumAudioFormats * result_c);
+// original function: unsigned int getInternalBufferSize();
+void cIAc_getInternalBufferSize_c(struct hg3dclass_struct *classptr_c, unsigned int * result_c);
+// original function: unsigned int getSampleSize();
+void cIAc_getSampleSize_c(struct hg3dclass_struct *classptr_c, unsigned int * result_c);
+// original function: bool setDevice(const char* deviceName);
+void cIAc_setDevice_c(struct hg3dclass_struct *classptr_c, char* deviceName_c, int * result_c);
+// original function: bool setFrequency(unsigned int frequency);
+void cIAc_setFrequency_c(struct hg3dclass_struct *classptr_c, unsigned int frequency_c, int * result_c);
+// original function: bool setFormat(AudioFormats format);
+void cIAc_setFormat_c(struct hg3dclass_struct *classptr_c, enum EnumAudioFormats format_c, int * result_c);
+// original function: bool setInternalBufferSize(unsigned int internalBufferSize);
+void cIAc_setInternalBufferSize_c(struct hg3dclass_struct *classptr_c, unsigned int internalBufferSize_c, int * result_c);
+// original function: bool beginCapture();
+void cIAc_beginCapture_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: void stopCapture();
+void cIAc_stopCapture_c(struct hg3dclass_struct *classptr_c);
+// original function: unsigned int getCurrentCapturedAudioSize();
+void cIAc_getCurrentCapturedAudioSize_c(struct hg3dclass_struct *classptr_c, unsigned int * result_c);
+// original function: void unRegisterAllEventHandlers();
+void cIAc_unRegisterAllEventHandlers_c(struct hg3dclass_struct *classptr_c);
+ include/ClassIAudioDeviceList.h view
@@ -0,0 +1,48 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// ClassIAudioDeviceList.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "Dep-cAudio/cAudio/include\IAudioDeviceList.h"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+#include "ClassPtr.h"
+#include "Utils.h"
+
+
+// original function: unsigned int getDeviceCount();
+void cIAdl_getDeviceCount_c(struct hg3dclass_struct *classptr_c, unsigned int * result_c);
+// original function: cAudioString getDeviceName(unsigned int idx);
+void cIAdl_getDeviceName_c(struct hg3dclass_struct *classptr_c, unsigned int idx_c, char * result_c);
+// original function: cAudioString getDeviceDescription(unsigned int idx);
+void cIAdl_getDeviceDescription_c(struct hg3dclass_struct *classptr_c, unsigned int idx_c, char * result_c);
+// original function: cAudioString getDefaultDeviceName();
+void cIAdl_getDefaultDeviceName_c(struct hg3dclass_struct *classptr_c, char * result_c);
+// original function: bool isSupported();
+void cIAdl_isSupported_c(struct hg3dclass_struct *classptr_c, int * result_c);
+ include/ClassIAudioManager.h view
@@ -0,0 +1,86 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// ClassIAudioManager.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "Dep-cAudio/cAudio/include\IAudioManager.h"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+#include "ClassPtr.h"
+#include "Utils.h"
+#include "TypeVector3.h"
+#include "EnumAudioFormats.h"
+
+
+// original function: bool initialize(const char* deviceName, int outputFrequency, int eaxEffectSlots);
+void cIAm_initialize_c(struct hg3dclass_struct *classptr_c, char* deviceName_c, int outputFrequency_c, int eaxEffectSlots_c, int * result_c);
+// original function: void shutDown();
+void cIAm_shutDown_c(struct hg3dclass_struct *classptr_c);
+// original function: void update();
+void cIAm_update_c(struct hg3dclass_struct *classptr_c);
+// original function: bool isUpdateThreadRunning();
+void cIAm_isUpdateThreadRunning_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: IAudioSource* getSoundByName(const char* name);
+void cIAm_getSoundByName_c(struct hg3dclass_struct *classptr_c, char* name_c, struct hg3dclass_struct * result_c);
+// original function: void releaseAllSources();
+void cIAm_releaseAllSources_c(struct hg3dclass_struct *classptr_c);
+// original function: void release(IAudioSource* source);
+void cIAm_release_c(struct hg3dclass_struct *classptr_c, struct hg3dclass_struct * source_c);
+// original function: IAudioSource* play2D(const char* filename, bool playLooped, bool startPaused);
+void cIAm_play2D_c(struct hg3dclass_struct *classptr_c, char* filename_c, int playLooped_c, int startPaused_c, struct hg3dclass_struct * result_c);
+// original function: IAudioSource* play3D(const char* filename, cVector3 position, bool playLooped, bool startPaused);
+void cIAm_play3D_c(struct hg3dclass_struct *classptr_c, char* filename_c, struct vector3_struct * position_c, int playLooped_c, int startPaused_c, struct hg3dclass_struct * result_c);
+// original function: void setMasterVolume(float vol);
+void cIAm_setMasterVolume_c(struct hg3dclass_struct *classptr_c, float vol_c);
+// original function: float getMasterVolume();
+void cIAm_getMasterVolume_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: void stopAllSounds();
+void cIAm_stopAllSounds_c(struct hg3dclass_struct *classptr_c);
+// original function: IAudioSource* create(const char* name, const char* filename, bool stream);
+void cIAm_create_c(struct hg3dclass_struct *classptr_c, char* name_c, char* filename_c, int stream_c, struct hg3dclass_struct * result_c);
+// original function: IAudioSource* createFromMemory(const char* name, const char* data, size_t length, const char* extension);
+void cIAm_createFromMemory_c(struct hg3dclass_struct *classptr_c, char* name_c, char* data_c, int length_c, char* extension_c, struct hg3dclass_struct * result_c);
+// original function: IAudioSource* createFromRaw(const char* name, const char* data, size_t length, unsigned int frequency, AudioFormats format);
+void cIAm_createFromRaw_c(struct hg3dclass_struct *classptr_c, char* name_c, char* data_c, int length_c, unsigned int frequency_c, enum EnumAudioFormats format_c, struct hg3dclass_struct * result_c);
+// original function: void unRegisterAudioDecoder(const char* extension);
+void cIAm_unRegisterAudioDecoder_c(struct hg3dclass_struct *classptr_c, char* extension_c);
+// original function: bool isAudioDecoderRegistered(const char* extension);
+void cIAm_isAudioDecoderRegistered_c(struct hg3dclass_struct *classptr_c, char* extension_c, int * result_c);
+// original function: void unRegisterAllAudioDecoders();
+void cIAm_unRegisterAllAudioDecoders_c(struct hg3dclass_struct *classptr_c);
+// original function: void unRegisterDataSource(const char* name);
+void cIAm_unRegisterDataSource_c(struct hg3dclass_struct *classptr_c, char* name_c);
+// original function: bool isDataSourceRegistered(const char* name);
+void cIAm_isDataSourceRegistered_c(struct hg3dclass_struct *classptr_c, char* name_c, int * result_c);
+// original function: void unRegisterAllDataSources();
+void cIAm_unRegisterAllDataSources_c(struct hg3dclass_struct *classptr_c);
+// original function: void unRegisterAllEventHandlers();
+void cIAm_unRegisterAllEventHandlers_c(struct hg3dclass_struct *classptr_c);
+// original function: IListener* getListener();
+void cIAm_getListener_c(struct hg3dclass_struct *classptr_c, struct hg3dclass_struct * result_c);
+ include/ClassIAudioSource.h view
@@ -0,0 +1,145 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// ClassIAudioSource.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "Dep-cAudio/cAudio/include\IAudioSource.h"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+#include "ClassPtr.h"
+#include "Utils.h"
+#include "TypeVector3.h"
+
+
+// original function: bool play();
+void cIAs_play_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: bool play2d(const bool& toLoop);
+void cIAs_play2d_c(struct hg3dclass_struct *classptr_c, int toLoop_c, int * result_c);
+// original function: bool play3d(const cVector3& position, const float& soundstr, const bool& toLoop);
+void cIAs_play3d_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * position_c, float soundstr_c, int toLoop_c, int * result_c);
+// original function: void pause();
+void cIAs_pause_c(struct hg3dclass_struct *classptr_c);
+// original function: void stop();
+void cIAs_stop_c(struct hg3dclass_struct *classptr_c);
+// original function: void loop(const bool& toLoop);
+void cIAs_loop_c(struct hg3dclass_struct *classptr_c, int toLoop_c);
+// original function: bool seek(const float& seconds, bool relative);
+void cIAs_seek_c(struct hg3dclass_struct *classptr_c, float seconds_c, int relative_c, int * result_c);
+// original function: float getTotalAudioTime();
+void cIAs_getTotalAudioTime_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: int getTotalAudioSize();
+void cIAs_getTotalAudioSize_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: int getCompressedAudioSize();
+void cIAs_getCompressedAudioSize_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: float getCurrentAudioTime();
+void cIAs_getCurrentAudioTime_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: int getCurrentAudioPosition();
+void cIAs_getCurrentAudioPosition_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: int getCurrentCompressedAudioPosition();
+void cIAs_getCurrentCompressedAudioPosition_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: bool update();
+void cIAs_update_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: const bool isValid();
+void cIAs_isValid_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: const bool isPlaying();
+void cIAs_isPlaying_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: const bool isPaused();
+void cIAs_isPaused_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: const bool isStopped();
+void cIAs_isStopped_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: const bool isLooping();
+void cIAs_isLooping_c(struct hg3dclass_struct *classptr_c, int * result_c);
+// original function: void setPosition(const cVector3& position);
+void cIAs_setPosition_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * position_c);
+// original function: void setVelocity(const cVector3& velocity);
+void cIAs_setVelocity_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * velocity_c);
+// original function: void setDirection(const cVector3& direction);
+void cIAs_setDirection_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * direction_c);
+// original function: void setRolloffFactor(const float& rolloff);
+void cIAs_setRolloffFactor_c(struct hg3dclass_struct *classptr_c, float rolloff_c);
+// original function: void setStrength(const float& soundstrength);
+void cIAs_setStrength_c(struct hg3dclass_struct *classptr_c, float soundstrength_c);
+// original function: void setMinDistance(const float& minDistance);
+void cIAs_setMinDistance_c(struct hg3dclass_struct *classptr_c, float minDistance_c);
+// original function: void setMaxDistance(const float& maxDistance);
+void cIAs_setMaxDistance_c(struct hg3dclass_struct *classptr_c, float maxDistance_c);
+// original function: void setPitch(const float& pitch);
+void cIAs_setPitch_c(struct hg3dclass_struct *classptr_c, float pitch_c);
+// original function: void setVolume(const float& volume);
+void cIAs_setVolume_c(struct hg3dclass_struct *classptr_c, float volume_c);
+// original function: void setMinVolume(const float& minVolume);
+void cIAs_setMinVolume_c(struct hg3dclass_struct *classptr_c, float minVolume_c);
+// original function: void setMaxVolume(const float& maxVolume);
+void cIAs_setMaxVolume_c(struct hg3dclass_struct *classptr_c, float maxVolume_c);
+// original function: void setInnerConeAngle(const float& innerAngle);
+void cIAs_setInnerConeAngle_c(struct hg3dclass_struct *classptr_c, float innerAngle_c);
+// original function: void setOuterConeAngle(const float& outerAngle);
+void cIAs_setOuterConeAngle_c(struct hg3dclass_struct *classptr_c, float outerAngle_c);
+// original function: void setOuterConeVolume(const float& outerVolume);
+void cIAs_setOuterConeVolume_c(struct hg3dclass_struct *classptr_c, float outerVolume_c);
+// original function: void setDopplerStrength(const float& dstrength);
+void cIAs_setDopplerStrength_c(struct hg3dclass_struct *classptr_c, float dstrength_c);
+// original function: void setDopplerVelocity(const cVector3& dvelocity);
+void cIAs_setDopplerVelocity_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * dvelocity_c);
+// original function: void move(const cVector3& position);
+void cIAs_move_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * position_c);
+// original function: const cVector3 getPosition();
+void cIAs_getPosition_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * result_c);
+// original function: const cVector3 getVelocity();
+void cIAs_getVelocity_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * result_c);
+// original function: const cVector3 getDirection();
+void cIAs_getDirection_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * result_c);
+// original function: const float getRolloffFactor();
+void cIAs_getRolloffFactor_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getStrength();
+void cIAs_getStrength_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getMinDistance();
+void cIAs_getMinDistance_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getMaxDistance();
+void cIAs_getMaxDistance_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getPitch();
+void cIAs_getPitch_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getVolume();
+void cIAs_getVolume_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getMinVolume();
+void cIAs_getMinVolume_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getMaxVolume();
+void cIAs_getMaxVolume_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getInnerConeAngle();
+void cIAs_getInnerConeAngle_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getOuterConeAngle();
+void cIAs_getOuterConeAngle_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getOuterConeVolume();
+void cIAs_getOuterConeVolume_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const float getDopplerStrength();
+void cIAs_getDopplerStrength_c(struct hg3dclass_struct *classptr_c, float * result_c);
+// original function: const cVector3 getDopplerVelocity();
+void cIAs_getDopplerVelocity_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * result_c);
+// original function: void unRegisterAllEventHandlers();
+void cIAs_unRegisterAllEventHandlers_c(struct hg3dclass_struct *classptr_c);
+ include/ClassIListener.h view
@@ -0,0 +1,61 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// ClassIListener.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "Dep-cAudio/cAudio/include\IListener.h"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+#include "ClassPtr.h"
+#include "Utils.h"
+#include "TypeVector3.h"
+
+
+// original function: void setPosition(const cVector3& pos);
+void cIL_setPosition_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * pos_c);
+// original function: void setDirection(const cVector3& dir);
+void cIL_setDirection_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * dir_c);
+// original function: void setUpVector(const cVector3& up);
+void cIL_setUpVector_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * up_c);
+// original function: void setVelocity(const cVector3& vel);
+void cIL_setVelocity_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * vel_c);
+// original function: void setMasterVolume(const float& volume);
+void cIL_setMasterVolume_c(struct hg3dclass_struct *classptr_c, float volume_c);
+// original function: void move(const cVector3& pos);
+void cIL_move_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * pos_c);
+// original function: cVector3 getPosition();
+void cIL_getPosition_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * result_c);
+// original function: cVector3 getDirection();
+void cIL_getDirection_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * result_c);
+// original function: cVector3 getUpVector();
+void cIL_getUpVector_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * result_c);
+// original function: cVector3 getVelocity();
+void cIL_getVelocity_c(struct hg3dclass_struct *classptr_c, struct vector3_struct * result_c);
+// original function: float getMasterVolume();
+void cIL_getMasterVolume_c(struct hg3dclass_struct *classptr_c, float * result_c);
+ include/ClassILogger.h view
@@ -0,0 +1,42 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// ClassILogger.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "Dep-cAudio/cAudio/include\ILogger.h"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+#include "ClassPtr.h"
+#include "Utils.h"
+
+
+// original function: void unRegisterLogReceiver(const char* name);
+void cIAl_unRegisterLogReceiver_c(struct hg3dclass_struct *classptr_c, char* name_c);
+// original function: bool isLogReceiverRegistered(const char* name);
+void cIAl_isLogReceiverRegistered_c(struct hg3dclass_struct *classptr_c, char* name_c, int * result_c);
+ include/ClassPtr.h view
@@ -0,0 +1,45 @@+/*
+This source file is part of HGamer3D
+(A project to enable 3D game development in Haskell)
+For the latest info, see http://www.althainz.de/HGamer3D.html
+
+(c) 2011 Peter Althainz
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+typedef struct hg3dclass_struct {
+	void *ptr;
+	void *fptr;
+} hg3dclass_struct;
+
+void *getCAudioClassPtr(hg3dclass_struct inSt, const char* className);
+
+typedef void ClassILogger; 
+hg3dclass_struct getCAudioClass_ILogger(void *ptrIn);
+
+typedef void ClassIAudioDeviceList; 
+hg3dclass_struct getCAudioClass_IAudioDeviceList(void *ptrIn);
+
+typedef void ClassIAudioSource; 
+hg3dclass_struct getCAudioClass_IAudioSource(void *ptrIn);
+
+typedef void ClassIAudioManager; 
+hg3dclass_struct getCAudioClass_IAudioManager(void *ptrIn);
+
+typedef void ClassIListener; 
+hg3dclass_struct getCAudioClass_IListener(void *ptrIn);
+
+typedef void ClassIAudioCapture; 
+hg3dclass_struct getCAudioClass_IAudioCapture(void *ptrIn);
+
+ include/EnumAudioFormats.h view
@@ -0,0 +1,45 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// EnumAudioFormats.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "Dep-cAudio/cAudio/include\EAudioFormats.h"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+
+
+
+//  enum from Dep-cAudio/cAudio/include\EEnumAudioFormats.h line:10
+	enum EnumAudioFormats
+	{
+	  EAF_8BIT_MONO, 
+	  EAF_8BIT_STEREO,
+	  EAF_16BIT_MONO,
+	  EAF_16BIT_STEREO
+	};
+ include/EnumDeviceType.h view
@@ -0,0 +1,43 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// EnumDeviceType.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "Dep-cAudio/cAudio/include\IAudioDeviceList.h"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+
+
+
+//  enum from Dep-cAudio/cAudio/include\IAudioDeviceList.h line:11
+	enum EnumDeviceType
+	{
+		DT_PLAYBACK = 0,
+		DT_RECORDING = 2
+	};
+ include/TypeHG3DClass.h view
@@ -0,0 +1,41 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// TypeHG3DClass.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "<parsedfile>"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+
+
+typedef struct hg3dclass_struct {
+	void *ptr;
+	void *fptr;
+} hg3dclass_struct;
+
+ include/TypeVector3.h view
@@ -0,0 +1,42 @@+// This source file is part of HGamer3D
+// (A project to enable 3D game development in Haskell)
+// For the latest info, see http://www.althainz.de/HGamer3D.html
+// 
+// (c) 2011 Peter Althainz
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// TypeVector3.h
+// 
+// 
+// 
+// 
+// File for type, method, enum or function stubs  
+// in: "<parsedfile>"
+// 
+// each stub combines the following files: 
+//     a C++ implementation file, transforming cpp calls into C-functions
+//     a C-header file, making this C-functions available for the C2HS parser
+//     a chs file, give instructions to the C2HS parser.
+// 
+// 
+
+#include "wchar.h"
+
+
+typedef struct vector3_struct {
+	float x;
+	float y;
+	float z;
+} vector3_struct;
+
+ include/Utils.h view
@@ -0,0 +1,28 @@+/*
+This source file is part of HGamer3D
+(A project to enable 3D game development in Haskell)
+For the latest info, see http://www.althainz.de/HGamer3D.html
+
+(c) 2011 Peter Althainz
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "EnumDeviceType.h"
+
+void fU_createAudioManager_c(int initializeDefault, struct hg3dclass_struct *iaudio);
+void fU_destroyAudioManager_c(struct hg3dclass_struct *iaudio);
+void fU_createAudioCapture_c(int initializeDefault, struct hg3dclass_struct * result_c);
+void fU_destroyAudioCapture_c(struct hg3dclass_struct *iaudiocapture);
+void fU_getLogger_c(struct hg3dclass_struct * result_c);
+void fU_createAudioDeviceList_c(enum EnumDeviceType deviceType, struct hg3dclass_struct * result_c);