{-# LANGUAGE ForeignFunctionInterface #-}

module Irrlicht where

import Foreign.GreenCard

data MeshPtr = MeshPtr Int
data NodePtr = NodePtr Int
data TexturePtr = TexturePtr Int






data VideoDriverType
  = EDT_NULL
  | EDT_SOFTWARE
  | EDT_BURNINGSVIDEO
  | EDT_DIRECT3D8
  | EDT_DIRECT3D9
  | EDT_OPENGL
  deriving ()
marshall_VideoDriverType :: VideoDriverType -> Int
marshall_VideoDriverType arg1 = 
  case arg1 of {
     EDT_NULL -> eDT_NULL;
     EDT_SOFTWARE -> eDT_SOFTWARE;
     EDT_BURNINGSVIDEO -> eDT_BURNINGSVIDEO;
     EDT_DIRECT3D8 -> eDT_DIRECT3D8;
     EDT_DIRECT3D9 -> eDT_DIRECT3D9;
     EDT_OPENGL -> eDT_OPENGL
  }
unmarshall_VideoDriverType :: Int -> VideoDriverType
unmarshall_VideoDriverType arg1 = 
  if arg1 == eDT_NULL
  then EDT_NULL
  else if arg1 == eDT_SOFTWARE
       then EDT_SOFTWARE
       else if arg1 == eDT_BURNINGSVIDEO
            then EDT_BURNINGSVIDEO
            else if arg1 == eDT_DIRECT3D8
                 then EDT_DIRECT3D8
                 else if arg1 == eDT_DIRECT3D9
                      then EDT_DIRECT3D9
                      else if arg1 == eDT_OPENGL
                           then EDT_OPENGL
                           else error ("unmarshall_VideoDriverType: unknown value ("++show arg1++")\n")
eDT_NULL :: Int
eDT_NULL =
  unsafePerformIO(
    prim_eDT_NULL
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eDT_NULL" prim_eDT_NULL :: IO (Int)
eDT_SOFTWARE :: Int
eDT_SOFTWARE =
  unsafePerformIO(
    prim_eDT_SOFTWARE
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eDT_SOFTWARE" prim_eDT_SOFTWARE :: IO (Int)
eDT_BURNINGSVIDEO :: Int
eDT_BURNINGSVIDEO =
  unsafePerformIO(
    prim_eDT_BURNINGSVIDEO
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eDT_BURNINGSVIDEO" prim_eDT_BURNINGSVIDEO :: IO (Int)
eDT_DIRECT3D8 :: Int
eDT_DIRECT3D8 =
  unsafePerformIO(
    prim_eDT_DIRECT3D8
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eDT_DIRECT3D8" prim_eDT_DIRECT3D8 :: IO (Int)
eDT_DIRECT3D9 :: Int
eDT_DIRECT3D9 =
  unsafePerformIO(
    prim_eDT_DIRECT3D9
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eDT_DIRECT3D9" prim_eDT_DIRECT3D9 :: IO (Int)
eDT_OPENGL :: Int
eDT_OPENGL =
  unsafePerformIO(
    prim_eDT_OPENGL
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eDT_OPENGL" prim_eDT_OPENGL :: IO (Int)

data VideoMaterialFlag
  = EMF_WIREFRAME
  | EMF_POINTCLOUD
  | EMF_GOURARD_SHADING
  | EMF_LIGHTING
  | EMF_ZBUFFER
  | EMF_ZWRITE_ENABLE
  | EMF_BACK_FACE_CULLING
  | EMF_FRONT_FACE_CULLING
  | EMF_BILINEAR_FILTER
  | EMF_TRILINEAR_FILTER
  | EMF_ANISOTROPIC_FILTER
  | EMF_FOG_ENABLE
  | EMF_NORMALIZE_NORMALS
  | EMF_TEXTURE_WRAP
  | EMF_ANTI_ALIASING
  | EMF_COLOR_MASK
  | EMF_COLOR_MATERIAL
  deriving ()
marshall_VideoMaterialFlag :: VideoMaterialFlag -> Int
marshall_VideoMaterialFlag arg1 = 
  case arg1 of {
     EMF_WIREFRAME -> eMF_WIREFRAME;
     EMF_POINTCLOUD -> eMF_POINTCLOUD;
     EMF_GOURARD_SHADING -> eMF_GOURARD_SHADING;
     EMF_LIGHTING -> eMF_LIGHTING;
     EMF_ZBUFFER -> eMF_ZBUFFER;
     EMF_ZWRITE_ENABLE -> eMF_ZWRITE_ENABLE;
     EMF_BACK_FACE_CULLING -> eMF_BACK_FACE_CULLING;
     EMF_FRONT_FACE_CULLING -> eMF_FRONT_FACE_CULLING;
     EMF_BILINEAR_FILTER -> eMF_BILINEAR_FILTER;
     EMF_TRILINEAR_FILTER -> eMF_TRILINEAR_FILTER;
     EMF_ANISOTROPIC_FILTER -> eMF_ANISOTROPIC_FILTER;
     EMF_FOG_ENABLE -> eMF_FOG_ENABLE;
     EMF_NORMALIZE_NORMALS -> eMF_NORMALIZE_NORMALS;
     EMF_TEXTURE_WRAP -> eMF_TEXTURE_WRAP;
     EMF_ANTI_ALIASING -> eMF_ANTI_ALIASING;
     EMF_COLOR_MASK -> eMF_COLOR_MASK;
     EMF_COLOR_MATERIAL -> eMF_COLOR_MATERIAL
  }
unmarshall_VideoMaterialFlag :: Int -> VideoMaterialFlag
unmarshall_VideoMaterialFlag arg1 = 
  if arg1 == eMF_WIREFRAME
  then EMF_WIREFRAME
  else if arg1 == eMF_POINTCLOUD
       then EMF_POINTCLOUD
       else if arg1 == eMF_GOURARD_SHADING
            then EMF_GOURARD_SHADING
            else if arg1 == eMF_LIGHTING
                 then EMF_LIGHTING
                 else if arg1 == eMF_ZBUFFER
                      then EMF_ZBUFFER
                      else if arg1 == eMF_ZWRITE_ENABLE
                           then EMF_ZWRITE_ENABLE
                           else if arg1 == eMF_BACK_FACE_CULLING
                                then EMF_BACK_FACE_CULLING
                                else if arg1 == eMF_FRONT_FACE_CULLING
                                     then EMF_FRONT_FACE_CULLING
                                     else if arg1 == eMF_BILINEAR_FILTER
                                          then EMF_BILINEAR_FILTER
                                          else if arg1 == eMF_TRILINEAR_FILTER
                                               then EMF_TRILINEAR_FILTER
                                               else if arg1 == eMF_ANISOTROPIC_FILTER
                                                    then EMF_ANISOTROPIC_FILTER
                                                    else if arg1 == eMF_FOG_ENABLE
                                                         then EMF_FOG_ENABLE
                                                         else if arg1 == eMF_NORMALIZE_NORMALS
                                                              then EMF_NORMALIZE_NORMALS
                                                              else if arg1 == eMF_TEXTURE_WRAP
                                                                   then EMF_TEXTURE_WRAP
                                                                   else if arg1 == eMF_ANTI_ALIASING
                                                                        then EMF_ANTI_ALIASING
                                                                        else if arg1 == eMF_COLOR_MASK
                                                                             then EMF_COLOR_MASK
                                                                             else if arg1 == eMF_COLOR_MATERIAL
                                                                                  then EMF_COLOR_MATERIAL
                                                                                  else error ("unmarshall_VideoMaterialFlag: unknown value ("++show arg1++")\n")
eMF_WIREFRAME :: Int
eMF_WIREFRAME =
  unsafePerformIO(
    prim_eMF_WIREFRAME
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_WIREFRAME" prim_eMF_WIREFRAME :: IO (Int)
eMF_POINTCLOUD :: Int
eMF_POINTCLOUD =
  unsafePerformIO(
    prim_eMF_POINTCLOUD
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_POINTCLOUD" prim_eMF_POINTCLOUD :: IO (Int)
eMF_GOURARD_SHADING :: Int
eMF_GOURARD_SHADING =
  unsafePerformIO(
    prim_eMF_GOURARD_SHADING
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_GOURARD_SHADING" prim_eMF_GOURARD_SHADING :: IO (Int)
eMF_LIGHTING :: Int
eMF_LIGHTING =
  unsafePerformIO(
    prim_eMF_LIGHTING
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_LIGHTING" prim_eMF_LIGHTING :: IO (Int)
eMF_ZBUFFER :: Int
eMF_ZBUFFER =
  unsafePerformIO(
    prim_eMF_ZBUFFER
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_ZBUFFER" prim_eMF_ZBUFFER :: IO (Int)
eMF_ZWRITE_ENABLE :: Int
eMF_ZWRITE_ENABLE =
  unsafePerformIO(
    prim_eMF_ZWRITE_ENABLE
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_ZWRITE_ENABLE" prim_eMF_ZWRITE_ENABLE :: IO (Int)
eMF_BACK_FACE_CULLING :: Int
eMF_BACK_FACE_CULLING =
  unsafePerformIO(
    prim_eMF_BACK_FACE_CULLING
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_BACK_FACE_CULLING" prim_eMF_BACK_FACE_CULLING :: IO (Int)
eMF_FRONT_FACE_CULLING :: Int
eMF_FRONT_FACE_CULLING =
  unsafePerformIO(
    prim_eMF_FRONT_FACE_CULLING
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_FRONT_FACE_CULLING" prim_eMF_FRONT_FACE_CULLING :: IO (Int)
eMF_BILINEAR_FILTER :: Int
eMF_BILINEAR_FILTER =
  unsafePerformIO(
    prim_eMF_BILINEAR_FILTER
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_BILINEAR_FILTER" prim_eMF_BILINEAR_FILTER :: IO (Int)
eMF_TRILINEAR_FILTER :: Int
eMF_TRILINEAR_FILTER =
  unsafePerformIO(
    prim_eMF_TRILINEAR_FILTER
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_TRILINEAR_FILTER" prim_eMF_TRILINEAR_FILTER :: IO (Int)
eMF_ANISOTROPIC_FILTER :: Int
eMF_ANISOTROPIC_FILTER =
  unsafePerformIO(
    prim_eMF_ANISOTROPIC_FILTER
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_ANISOTROPIC_FILTER" prim_eMF_ANISOTROPIC_FILTER :: IO (Int)
eMF_FOG_ENABLE :: Int
eMF_FOG_ENABLE =
  unsafePerformIO(
    prim_eMF_FOG_ENABLE
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_FOG_ENABLE" prim_eMF_FOG_ENABLE :: IO (Int)
eMF_NORMALIZE_NORMALS :: Int
eMF_NORMALIZE_NORMALS =
  unsafePerformIO(
    prim_eMF_NORMALIZE_NORMALS
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_NORMALIZE_NORMALS" prim_eMF_NORMALIZE_NORMALS :: IO (Int)
eMF_TEXTURE_WRAP :: Int
eMF_TEXTURE_WRAP =
  unsafePerformIO(
    prim_eMF_TEXTURE_WRAP
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_TEXTURE_WRAP" prim_eMF_TEXTURE_WRAP :: IO (Int)
eMF_ANTI_ALIASING :: Int
eMF_ANTI_ALIASING =
  unsafePerformIO(
    prim_eMF_ANTI_ALIASING
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_ANTI_ALIASING" prim_eMF_ANTI_ALIASING :: IO (Int)
eMF_COLOR_MASK :: Int
eMF_COLOR_MASK =
  unsafePerformIO(
    prim_eMF_COLOR_MASK
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_COLOR_MASK" prim_eMF_COLOR_MASK :: IO (Int)
eMF_COLOR_MATERIAL :: Int
eMF_COLOR_MATERIAL =
  unsafePerformIO(
    prim_eMF_COLOR_MATERIAL
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMF_COLOR_MATERIAL" prim_eMF_COLOR_MATERIAL :: IO (Int)

data SceneMd2AnimationType
  = EMAT_STAND
  | EMAT_RUN
  | EMAT_ATTACK
  | EMAT_PAIN_A
  | EMAT_PAIN_B
  | EMAT_PAIN_C
  | EMAT_JUMP
  | EMAT_FLIP
  | EMAT_SALUTE
  | EMAT_FALLBACK
  | EMAT_WAVE
  | EMAT_POINT
  | EMAT_CROUCH_STAND
  | EMAT_CROUCH_WALK
  | EMAT_CROUCH_ATTACK
  | EMAT_CROUCH_PAIN
  | EMAT_CROUCH_DEATH
  | EMAT_DEATH_FALLBACK
  | EMAT_DEATH_FALLFORWARD
  | EMAT_DEATH_FALLBACKSLOW
  | EMAT_BOOM
  | EMAT_COUNT
  deriving ()
marshall_SceneMd2AnimationType :: SceneMd2AnimationType -> Int
marshall_SceneMd2AnimationType arg1 = 
  case arg1 of {
     EMAT_STAND -> eMAT_STAND;
     EMAT_RUN -> eMAT_RUN;
     EMAT_ATTACK -> eMAT_ATTACK;
     EMAT_PAIN_A -> eMAT_PAIN_A;
     EMAT_PAIN_B -> eMAT_PAIN_B;
     EMAT_PAIN_C -> eMAT_PAIN_C;
     EMAT_JUMP -> eMAT_JUMP;
     EMAT_FLIP -> eMAT_FLIP;
     EMAT_SALUTE -> eMAT_SALUTE;
     EMAT_FALLBACK -> eMAT_FALLBACK;
     EMAT_WAVE -> eMAT_WAVE;
     EMAT_POINT -> eMAT_POINT;
     EMAT_CROUCH_STAND -> eMAT_CROUCH_STAND;
     EMAT_CROUCH_WALK -> eMAT_CROUCH_WALK;
     EMAT_CROUCH_ATTACK -> eMAT_CROUCH_ATTACK;
     EMAT_CROUCH_PAIN -> eMAT_CROUCH_PAIN;
     EMAT_CROUCH_DEATH -> eMAT_CROUCH_DEATH;
     EMAT_DEATH_FALLBACK -> eMAT_DEATH_FALLBACK;
     EMAT_DEATH_FALLFORWARD -> eMAT_DEATH_FALLFORWARD;
     EMAT_DEATH_FALLBACKSLOW -> eMAT_DEATH_FALLBACKSLOW;
     EMAT_BOOM -> eMAT_BOOM;
     EMAT_COUNT -> eMAT_COUNT
  }
unmarshall_SceneMd2AnimationType :: Int -> SceneMd2AnimationType
unmarshall_SceneMd2AnimationType arg1 = 
  if arg1 == eMAT_STAND
  then EMAT_STAND
  else if arg1 == eMAT_RUN
       then EMAT_RUN
       else if arg1 == eMAT_ATTACK
            then EMAT_ATTACK
            else if arg1 == eMAT_PAIN_A
                 then EMAT_PAIN_A
                 else if arg1 == eMAT_PAIN_B
                      then EMAT_PAIN_B
                      else if arg1 == eMAT_PAIN_C
                           then EMAT_PAIN_C
                           else if arg1 == eMAT_JUMP
                                then EMAT_JUMP
                                else if arg1 == eMAT_FLIP
                                     then EMAT_FLIP
                                     else if arg1 == eMAT_SALUTE
                                          then EMAT_SALUTE
                                          else if arg1 == eMAT_FALLBACK
                                               then EMAT_FALLBACK
                                               else if arg1 == eMAT_WAVE
                                                    then EMAT_WAVE
                                                    else if arg1 == eMAT_POINT
                                                         then EMAT_POINT
                                                         else if arg1 == eMAT_CROUCH_STAND
                                                              then EMAT_CROUCH_STAND
                                                              else if arg1 == eMAT_CROUCH_WALK
                                                                   then EMAT_CROUCH_WALK
                                                                   else if arg1 == eMAT_CROUCH_ATTACK
                                                                        then EMAT_CROUCH_ATTACK
                                                                        else if arg1 == eMAT_CROUCH_PAIN
                                                                             then EMAT_CROUCH_PAIN
                                                                             else if arg1 == eMAT_CROUCH_DEATH
                                                                                  then EMAT_CROUCH_DEATH
                                                                                  else if arg1 == eMAT_DEATH_FALLBACK
                                                                                       then EMAT_DEATH_FALLBACK
                                                                                       else if arg1 == eMAT_DEATH_FALLFORWARD
                                                                                            then EMAT_DEATH_FALLFORWARD
                                                                                            else if arg1 == eMAT_DEATH_FALLBACKSLOW
                                                                                                 then EMAT_DEATH_FALLBACKSLOW
                                                                                                 else if arg1 == eMAT_BOOM
                                                                                                      then EMAT_BOOM
                                                                                                      else if arg1 == eMAT_COUNT
                                                                                                           then EMAT_COUNT
                                                                                                           else error ("unmarshall_SceneMd2AnimationType: unknown value ("++show arg1++")\n")
eMAT_STAND :: Int
eMAT_STAND =
  unsafePerformIO(
    prim_eMAT_STAND
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_STAND" prim_eMAT_STAND :: IO (Int)
eMAT_RUN :: Int
eMAT_RUN =
  unsafePerformIO(
    prim_eMAT_RUN
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_RUN" prim_eMAT_RUN :: IO (Int)
eMAT_ATTACK :: Int
eMAT_ATTACK =
  unsafePerformIO(
    prim_eMAT_ATTACK
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_ATTACK" prim_eMAT_ATTACK :: IO (Int)
eMAT_PAIN_A :: Int
eMAT_PAIN_A =
  unsafePerformIO(
    prim_eMAT_PAIN_A
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_PAIN_A" prim_eMAT_PAIN_A :: IO (Int)
eMAT_PAIN_B :: Int
eMAT_PAIN_B =
  unsafePerformIO(
    prim_eMAT_PAIN_B
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_PAIN_B" prim_eMAT_PAIN_B :: IO (Int)
eMAT_PAIN_C :: Int
eMAT_PAIN_C =
  unsafePerformIO(
    prim_eMAT_PAIN_C
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_PAIN_C" prim_eMAT_PAIN_C :: IO (Int)
eMAT_JUMP :: Int
eMAT_JUMP =
  unsafePerformIO(
    prim_eMAT_JUMP
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_JUMP" prim_eMAT_JUMP :: IO (Int)
eMAT_FLIP :: Int
eMAT_FLIP =
  unsafePerformIO(
    prim_eMAT_FLIP
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_FLIP" prim_eMAT_FLIP :: IO (Int)
eMAT_SALUTE :: Int
eMAT_SALUTE =
  unsafePerformIO(
    prim_eMAT_SALUTE
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_SALUTE" prim_eMAT_SALUTE :: IO (Int)
eMAT_FALLBACK :: Int
eMAT_FALLBACK =
  unsafePerformIO(
    prim_eMAT_FALLBACK
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_FALLBACK" prim_eMAT_FALLBACK :: IO (Int)
eMAT_WAVE :: Int
eMAT_WAVE =
  unsafePerformIO(
    prim_eMAT_WAVE
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_WAVE" prim_eMAT_WAVE :: IO (Int)
eMAT_POINT :: Int
eMAT_POINT =
  unsafePerformIO(
    prim_eMAT_POINT
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_POINT" prim_eMAT_POINT :: IO (Int)
eMAT_CROUCH_STAND :: Int
eMAT_CROUCH_STAND =
  unsafePerformIO(
    prim_eMAT_CROUCH_STAND
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_CROUCH_STAND" prim_eMAT_CROUCH_STAND :: IO (Int)
eMAT_CROUCH_WALK :: Int
eMAT_CROUCH_WALK =
  unsafePerformIO(
    prim_eMAT_CROUCH_WALK
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_CROUCH_WALK" prim_eMAT_CROUCH_WALK :: IO (Int)
eMAT_CROUCH_ATTACK :: Int
eMAT_CROUCH_ATTACK =
  unsafePerformIO(
    prim_eMAT_CROUCH_ATTACK
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_CROUCH_ATTACK" prim_eMAT_CROUCH_ATTACK :: IO (Int)
eMAT_CROUCH_PAIN :: Int
eMAT_CROUCH_PAIN =
  unsafePerformIO(
    prim_eMAT_CROUCH_PAIN
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_CROUCH_PAIN" prim_eMAT_CROUCH_PAIN :: IO (Int)
eMAT_CROUCH_DEATH :: Int
eMAT_CROUCH_DEATH =
  unsafePerformIO(
    prim_eMAT_CROUCH_DEATH
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_CROUCH_DEATH" prim_eMAT_CROUCH_DEATH :: IO (Int)
eMAT_DEATH_FALLBACK :: Int
eMAT_DEATH_FALLBACK =
  unsafePerformIO(
    prim_eMAT_DEATH_FALLBACK
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_DEATH_FALLBACK" prim_eMAT_DEATH_FALLBACK :: IO (Int)
eMAT_DEATH_FALLFORWARD :: Int
eMAT_DEATH_FALLFORWARD =
  unsafePerformIO(
    prim_eMAT_DEATH_FALLFORWARD
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_DEATH_FALLFORWARD" prim_eMAT_DEATH_FALLFORWARD :: IO (Int)
eMAT_DEATH_FALLBACKSLOW :: Int
eMAT_DEATH_FALLBACKSLOW =
  unsafePerformIO(
    prim_eMAT_DEATH_FALLBACKSLOW
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_DEATH_FALLBACKSLOW" prim_eMAT_DEATH_FALLBACKSLOW :: IO (Int)
eMAT_BOOM :: Int
eMAT_BOOM =
  unsafePerformIO(
    prim_eMAT_BOOM
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_BOOM" prim_eMAT_BOOM :: IO (Int)
eMAT_COUNT :: Int
eMAT_COUNT =
  unsafePerformIO(
    prim_eMAT_COUNT
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_eMAT_COUNT" prim_eMAT_COUNT :: IO (Int)

{- Device -}

getEvent :: IO Int
getEvent =
  prim_getEvent
  >>= \  result  ->
  (return (result))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_getEvent" prim_getEvent :: IO (Int)

getCharEvent :: IO Char
getCharEvent =
  prim_getCharEvent
  >>= \  result  ->
  (return (result))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_getCharEvent" prim_getCharEvent :: IO (Char)

deviceSetEventReceiver :: Int -> IO ()
deviceSetEventReceiver control =
  prim_deviceSetEventReceiver control
  >>= \ gc_result ->
  access_prim_deviceSetEventReceiver_gc_failed gc_result >>= \ gc_failed ->
  access_prim_deviceSetEventReceiver_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_deviceSetEventReceiver" prim_deviceSetEventReceiver :: Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceSetEventReceiver_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceSetEventReceiver_gc_failstring :: Ptr a1 -> IO (Ptr r1)

deviceSetWindowCaption :: String -> IO ()
deviceSetWindowCaption gc_arg1 =
  (marshall_string_ gc_arg1) >>= \ (caption) ->
  prim_deviceSetWindowCaption caption
  >>= \ gc_result ->
  access_prim_deviceSetWindowCaption_gc_failed gc_result >>= \ gc_failed ->
  access_prim_deviceSetWindowCaption_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_deviceSetWindowCaption" prim_deviceSetWindowCaption :: Ptr a1 -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceSetWindowCaption_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceSetWindowCaption_gc_failstring :: Ptr a1 -> IO (Ptr r1)

deviceRun :: IO Int
deviceRun =
  prim_deviceRun
  >>= \ gc_result ->
  access_prim_deviceRun_result gc_result >>= \ result ->
  access_prim_deviceRun_gc_failed gc_result >>= \ gc_failed ->
  access_prim_deviceRun_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (result))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_deviceRun" prim_deviceRun :: IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceRun_result :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceRun_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceRun_gc_failstring :: Ptr a1 -> IO (Ptr r1)

deviceDrop :: IO ()
deviceDrop =
  prim_deviceDrop
  >>= \ gc_result ->
  access_prim_deviceDrop_gc_failed gc_result >>= \ gc_failed ->
  access_prim_deviceDrop_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_deviceDrop" prim_deviceDrop :: IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceDrop_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceDrop_gc_failstring :: Ptr a1 -> IO (Ptr r1)

irrCreateDevice :: VideoDriverType -> Int -> Int -> Bool -> Bool -> Bool -> IO ()
irrCreateDevice gc_arg1 sizex sizey gc_arg2 gc_arg3 gc_arg4 =
  case (marshall_VideoDriverType gc_arg1) of { dtype ->
  (marshall_bool_ gc_arg2) >>= \ (fullscreen) ->
  (marshall_bool_ gc_arg3) >>= \ (stencilbuffer) ->
  (marshall_bool_ gc_arg4) >>= \ (vsync) ->
  prim_irrCreateDevice dtype sizex sizey fullscreen stencilbuffer vsync
  >>= \ gc_result ->
  access_prim_irrCreateDevice_gc_failed gc_result >>= \ gc_failed ->
  access_prim_irrCreateDevice_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))}
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_irrCreateDevice" prim_irrCreateDevice :: Int -> Int -> Int -> Int -> Int -> Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_irrCreateDevice_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_irrCreateDevice_gc_failstring :: Ptr a1 -> IO (Ptr r1)

{- Gui -}

guiAddStaticText :: String -> Int -> Int -> Int -> Int -> IO ()
guiAddStaticText gc_arg1 topleftx toplefty lowrightx lowrighty =
  (marshall_string_ gc_arg1) >>= \ (text) ->
  prim_guiAddStaticText text topleftx toplefty lowrightx lowrighty
  >>= \ gc_result ->
  access_prim_guiAddStaticText_gc_failed gc_result >>= \ gc_failed ->
  access_prim_guiAddStaticText_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_guiAddStaticText" prim_guiAddStaticText :: Ptr a1 -> Int -> Int -> Int -> Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiAddStaticText_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiAddStaticText_gc_failstring :: Ptr a1 -> IO (Ptr r1)

guiDrawAll :: IO ()
guiDrawAll =
  prim_guiDrawAll
  >>= \ gc_result ->
  access_prim_guiDrawAll_gc_failed gc_result >>= \ gc_failed ->
  access_prim_guiDrawAll_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_guiDrawAll" prim_guiDrawAll :: IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiDrawAll_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiDrawAll_gc_failstring :: Ptr a1 -> IO (Ptr r1)


{- VideoDriver -}

videoBeginScene :: Bool -> Bool -> Int -> Int -> Int -> Int -> IO ()
videoBeginScene gc_arg1 gc_arg2 colr colg colb colt =
  (marshall_bool_ gc_arg1) >>= \ (a) ->
  (marshall_bool_ gc_arg2) >>= \ (b) ->
  prim_videoBeginScene a b colr colg colb colt
  >>= \ gc_result ->
  access_prim_videoBeginScene_gc_failed gc_result >>= \ gc_failed ->
  access_prim_videoBeginScene_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_videoBeginScene" prim_videoBeginScene :: Int -> Int -> Int -> Int -> Int -> Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_videoBeginScene_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_videoBeginScene_gc_failstring :: Ptr a1 -> IO (Ptr r1)

videoEndScene :: IO ()
videoEndScene =
  prim_videoEndScene
  >>= \ gc_result ->
  access_prim_videoEndScene_gc_failed gc_result >>= \ gc_failed ->
  access_prim_videoEndScene_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_videoEndScene" prim_videoEndScene :: IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_videoEndScene_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_videoEndScene_gc_failstring :: Ptr a1 -> IO (Ptr r1)

videoGetTexture :: String -> IO TexturePtr
videoGetTexture gc_arg1 =
  (marshall_string_ gc_arg1) >>= \ (texture) ->
  prim_videoGetTexture texture
  >>= \ gc_result ->
  access_prim_videoGetTexture_pTexture gc_result >>= \ pTexture ->
  access_prim_videoGetTexture_gc_failed gc_result >>= \ gc_failed ->
  access_prim_videoGetTexture_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return ((TexturePtr pTexture)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_videoGetTexture" prim_videoGetTexture :: Ptr a1 -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_videoGetTexture_pTexture :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_videoGetTexture_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_videoGetTexture_gc_failstring :: Ptr a1 -> IO (Ptr r1)

{- Scene -}

sceneDrawAll :: IO ()
sceneDrawAll =
  prim_sceneDrawAll
  >>= \ gc_result ->
  access_prim_sceneDrawAll_gc_failed gc_result >>= \ gc_failed ->
  access_prim_sceneDrawAll_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_sceneDrawAll" prim_sceneDrawAll :: IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneDrawAll_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneDrawAll_gc_failstring :: Ptr a1 -> IO (Ptr r1)

sceneGetMesh :: String -> IO MeshPtr
sceneGetMesh gc_arg1 =
  (marshall_string_ gc_arg1) >>= \ (mesh) ->
  prim_sceneGetMesh mesh
  >>= \ gc_result ->
  access_prim_sceneGetMesh_pMesh gc_result >>= \ pMesh ->
  access_prim_sceneGetMesh_gc_failed gc_result >>= \ gc_failed ->
  access_prim_sceneGetMesh_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return ((MeshPtr pMesh)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_sceneGetMesh" prim_sceneGetMesh :: Ptr a1 -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneGetMesh_pMesh :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneGetMesh_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneGetMesh_gc_failstring :: Ptr a1 -> IO (Ptr r1)

sceneAddAnimatedMeshSceneNode :: MeshPtr -> IO NodePtr
sceneAddAnimatedMeshSceneNode gc_arg1 =
  case gc_arg1 of { (MeshPtr pMesh) ->
  prim_sceneAddAnimatedMeshSceneNode pMesh
  >>= \ gc_result ->
  access_prim_sceneAddAnimatedMeshSceneNode_pNode gc_result >>= \ pNode ->
  access_prim_sceneAddAnimatedMeshSceneNode_gc_failed gc_result >>= \ gc_failed ->
  access_prim_sceneAddAnimatedMeshSceneNode_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return ((NodePtr pNode)))}
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_sceneAddAnimatedMeshSceneNode" prim_sceneAddAnimatedMeshSceneNode :: Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddAnimatedMeshSceneNode_pNode :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddAnimatedMeshSceneNode_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddAnimatedMeshSceneNode_gc_failstring :: Ptr a1 -> IO (Ptr r1)

sceneAddCameraSceneNode :: (Int,Int,Int) -> (Int,Int,Int) -> IO ()
sceneAddCameraSceneNode gc_arg1 gc_arg2 =
  case gc_arg1 of { (posx,posy,posz) ->
  case gc_arg2 of { (tox,toy,toz) ->
  prim_sceneAddCameraSceneNode posx posy posz tox toy toz
  >>= \ gc_result ->
  access_prim_sceneAddCameraSceneNode_gc_failed gc_result >>= \ gc_failed ->
  access_prim_sceneAddCameraSceneNode_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))}}
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_sceneAddCameraSceneNode" prim_sceneAddCameraSceneNode :: Int -> Int -> Int -> Int -> Int -> Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddCameraSceneNode_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddCameraSceneNode_gc_failstring :: Ptr a1 -> IO (Ptr r1)

sceneAddOctTreeSceneNode :: MeshPtr -> IO NodePtr
sceneAddOctTreeSceneNode gc_arg1 =
  case gc_arg1 of { (MeshPtr pMesh) ->
  prim_sceneAddOctTreeSceneNode pMesh
  >>= \ gc_result ->
  access_prim_sceneAddOctTreeSceneNode_pNode gc_result >>= \ pNode ->
  access_prim_sceneAddOctTreeSceneNode_gc_failed gc_result >>= \ gc_failed ->
  access_prim_sceneAddOctTreeSceneNode_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return ((NodePtr pNode)))}
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_sceneAddOctTreeSceneNode" prim_sceneAddOctTreeSceneNode :: Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddOctTreeSceneNode_pNode :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddOctTreeSceneNode_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddOctTreeSceneNode_gc_failstring :: Ptr a1 -> IO (Ptr r1)

sceneNodeSetPosition :: (Int,Int,Int) -> NodePtr -> IO ()
sceneNodeSetPosition gc_arg1 gc_arg2 =
  case gc_arg1 of { (posx,posy,posz) ->
  case gc_arg2 of { (NodePtr pNode) ->
  prim_sceneNodeSetPosition posx posy posz pNode
  >>= \ gc_result ->
  access_prim_sceneNodeSetPosition_gc_failed gc_result >>= \ gc_failed ->
  access_prim_sceneNodeSetPosition_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))}}
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_sceneNodeSetPosition" prim_sceneNodeSetPosition :: Int -> Int -> Int -> Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetPosition_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetPosition_gc_failstring :: Ptr a1 -> IO (Ptr r1)

sceneAddCameraSceneNodeFPS :: IO ()
sceneAddCameraSceneNodeFPS =
  prim_sceneAddCameraSceneNodeFPS
  >>= \ gc_result ->
  access_prim_sceneAddCameraSceneNodeFPS_gc_failed gc_result >>= \ gc_failed ->
  access_prim_sceneAddCameraSceneNodeFPS_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_sceneAddCameraSceneNodeFPS" prim_sceneAddCameraSceneNodeFPS :: IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddCameraSceneNodeFPS_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddCameraSceneNodeFPS_gc_failstring :: Ptr a1 -> IO (Ptr r1)

{- Node -}

nodeSetMaterialTexture :: NodePtr -> TexturePtr -> IO ()
nodeSetMaterialTexture gc_arg1 gc_arg2 =
  case gc_arg1 of { (NodePtr pNode) ->
  case gc_arg2 of { (TexturePtr pTexture) ->
  prim_nodeSetMaterialTexture pNode pTexture
  >>= \ gc_result ->
  access_prim_nodeSetMaterialTexture_gc_failed gc_result >>= \ gc_failed ->
  access_prim_nodeSetMaterialTexture_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))}}
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_nodeSetMaterialTexture" prim_nodeSetMaterialTexture :: Int -> Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_nodeSetMaterialTexture_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_nodeSetMaterialTexture_gc_failstring :: Ptr a1 -> IO (Ptr r1)

nodeSetMaterialFlag :: NodePtr -> VideoMaterialFlag -> Bool -> IO ()
nodeSetMaterialFlag gc_arg1 gc_arg2 gc_arg3 =
  case gc_arg1 of { (NodePtr pNode) ->
  case (marshall_VideoMaterialFlag gc_arg2) of { mflag ->
  (marshall_bool_ gc_arg3) >>= \ (value) ->
  prim_nodeSetMaterialFlag pNode mflag value
  >>= \ gc_result ->
  access_prim_nodeSetMaterialFlag_gc_failed gc_result >>= \ gc_failed ->
  access_prim_nodeSetMaterialFlag_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))}}
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_nodeSetMaterialFlag" prim_nodeSetMaterialFlag :: Int -> Int -> Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_nodeSetMaterialFlag_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_nodeSetMaterialFlag_gc_failstring :: Ptr a1 -> IO (Ptr r1)

nodeSetMd2Animation :: NodePtr -> SceneMd2AnimationType -> IO ()
nodeSetMd2Animation gc_arg1 gc_arg2 =
  case gc_arg1 of { (NodePtr pNode) ->
  case (marshall_SceneMd2AnimationType gc_arg2) of { atype ->
  prim_nodeSetMd2Animation pNode atype
  >>= \ gc_result ->
  access_prim_nodeSetMd2Animation_gc_failed gc_result >>= \ gc_failed ->
  access_prim_nodeSetMd2Animation_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))}}
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_nodeSetMd2Animation" prim_nodeSetMd2Animation :: Int -> Int -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_nodeSetMd2Animation_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_nodeSetMd2Animation_gc_failstring :: Ptr a1 -> IO (Ptr r1)

{- Files -}
fileSystemAddZipFileArchive :: String -> IO ()
fileSystemAddZipFileArchive gc_arg1 =
  (marshall_string_ gc_arg1) >>= \ (file) ->
  prim_fileSystemAddZipFileArchive file
  >>= \ gc_result ->
  access_prim_fileSystemAddZipFileArchive_gc_failed gc_result >>= \ gc_failed ->
  access_prim_fileSystemAddZipFileArchive_gc_failstring gc_result >>= \ gc_failstring ->
  if ( gc_failed /= (0::Int))
  then unmarshall_string_ gc_failstring >>=  ioError  . userError
  else (return (()))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_fileSystemAddZipFileArchive" prim_fileSystemAddZipFileArchive :: Ptr a1 -> IO (Ptr r1)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_fileSystemAddZipFileArchive_gc_failed :: Ptr a1 -> IO (Int)
foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_fileSystemAddZipFileArchive_gc_failstring :: Ptr a1 -> IO (Ptr r1)

{- Timer -}
getVirtualTime :: Int
getVirtualTime =
  unsafePerformIO(
    prim_getVirtualTime
    >>= \  res1  ->
    (return (res1)))
foreign import  ccall unsafe "irrlicht_stub_ffi.h prim_getVirtualTime" prim_getVirtualTime :: IO (Int)