{-# LANGUAGE ForeignFunctionInterface #-} module Irrlicht where import Foreign.GreenCard data MeshPtr = MeshPtr Int data NodePtr = NodePtr Int data TexturePtr = TexturePtr Int data IrrDevicePtr = IrrDevicePtr Int data IVideoDriverPtr = IVideoDriverPtr Int data ISceneManagerPtr = ISceneManagerPtr Int data IGUIEnvironmentPtr = IGUIEnvironmentPtr Int data ITriangleSelectorPtr = ITriangleSelectorPtr Int data ISceneNodeAnimatorPtr = ISceneNodeAnimatorPtr Int data IGUIFontPtr = IGUIFontPtr Int data IGUIStaticTextPtr = IGUIStaticTextPtr Int data SMeshBufferPtr = SMeshBufferPtr 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) 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) getLeftDown :: IO Int getLeftDown = prim_getLeftDown >>= \ result -> (return (result)) foreign import ccall unsafe "irrlicht_stub_ffi.h prim_getLeftDown" prim_getLeftDown :: IO (Int) 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 IrrDevicePtr 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_device gc_result >>= \ device -> 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 ((IrrDevicePtr device)))} 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_device :: Ptr a1 -> IO (Int) 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) guiAddStaticText :: String -> Int -> Int -> Int -> Int -> IO IGUIStaticTextPtr guiAddStaticText gc_arg1 topleftx toplefty lowrightx lowrighty = (marshall_string_ gc_arg1) >>= \ (text) -> prim_guiAddStaticText text topleftx toplefty lowrightx lowrighty >>= \ returnedText -> (return ((IGUIStaticTextPtr returnedText))) foreign import ccall unsafe "irrlicht_stub_ffi.h prim_guiAddStaticText" prim_guiAddStaticText :: Ptr a1 -> Int -> Int -> Int -> Int -> IO (Int) guiGetText :: IGUIStaticTextPtr -> IO String guiGetText gc_arg1 = case gc_arg1 of { (IGUIStaticTextPtr pElement) -> prim_guiGetText pElement >>= \ result -> (unmarshall_string_ result) >>= \ gc_res1 -> (return (gc_res1))} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_guiGetText" prim_guiGetText :: Int -> IO (Ptr r1) guiSetText :: String -> IGUIStaticTextPtr -> IO () guiSetText gc_arg1 gc_arg2 = (marshall_string_ gc_arg1) >>= \ (text) -> case gc_arg2 of { (IGUIStaticTextPtr pElement) -> prim_guiSetText text pElement >>= \ gc_result -> access_prim_guiSetText_gc_failed gc_result >>= \ gc_failed -> access_prim_guiSetText_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_guiSetText" prim_guiSetText :: Ptr a1 -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetText_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetText_gc_failstring :: Ptr a1 -> IO (Ptr r1) guiRemoveStaticText :: IGUIStaticTextPtr -> IO () guiRemoveStaticText gc_arg1 = case gc_arg1 of { (IGUIStaticTextPtr pText) -> prim_guiRemoveStaticText pText >>= \ gc_result -> access_prim_guiRemoveStaticText_gc_failed gc_result >>= \ gc_failed -> access_prim_guiRemoveStaticText_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_guiRemoveStaticText" prim_guiRemoveStaticText :: Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiRemoveStaticText_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiRemoveStaticText_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) 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) 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) sceneAddMeshSceneNode :: MeshPtr -> IO NodePtr sceneAddMeshSceneNode gc_arg1 = case gc_arg1 of { (MeshPtr pMesh) -> prim_sceneAddMeshSceneNode pMesh >>= \ pNode -> (return ((NodePtr pNode)))} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneAddMeshSceneNode" prim_sceneAddMeshSceneNode :: Int -> IO (Int) sceneAddCameraSceneNode :: (Int,Int,Int) -> (Int,Int,Int) -> IO NodePtr 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 >>= \ pNode -> (return ((NodePtr pNode)))}} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneAddCameraSceneNode" prim_sceneAddCameraSceneNode :: Int -> Int -> Int -> Int -> Int -> Int -> IO (Int) 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) sceneAddSphereSceneNode :: Int -> (Int,Int,Int) -> IO NodePtr sceneAddSphereSceneNode radius gc_arg1 = case gc_arg1 of { (posx,posy,posz) -> prim_sceneAddSphereSceneNode radius posx posy posz >>= \ pNode -> (return ((NodePtr pNode)))} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneAddSphereSceneNode" prim_sceneAddSphereSceneNode :: Int -> Int -> Int -> Int -> IO (Int) sceneAddCubeSceneNode :: IO NodePtr sceneAddCubeSceneNode = prim_sceneAddCubeSceneNode >>= \ pNode -> (return ((NodePtr pNode))) foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneAddCubeSceneNode" prim_sceneAddCubeSceneNode :: IO (Int) 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) sceneNodeGetPositionX :: NodePtr -> IO Int sceneNodeGetPositionX gc_arg1 = case gc_arg1 of { (NodePtr pNode) -> prim_sceneNodeGetPositionX pNode >>= \ x -> (return (x))} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneNodeGetPositionX" prim_sceneNodeGetPositionX :: Int -> IO (Int) sceneNodeGetPositionY :: NodePtr -> IO Int sceneNodeGetPositionY gc_arg1 = case gc_arg1 of { (NodePtr pNode) -> prim_sceneNodeGetPositionY pNode >>= \ y -> (return (y))} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneNodeGetPositionY" prim_sceneNodeGetPositionY :: Int -> IO (Int) sceneNodeGetPositionZ :: NodePtr -> IO Int sceneNodeGetPositionZ gc_arg1 = case gc_arg1 of { (NodePtr pNode) -> prim_sceneNodeGetPositionZ pNode >>= \ z -> (return (z))} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneNodeGetPositionZ" prim_sceneNodeGetPositionZ :: Int -> IO (Int) sceneNodeGetDistanceFrom :: NodePtr -> NodePtr -> Int sceneNodeGetDistanceFrom gc_arg1 gc_arg2 = unsafePerformIO( case gc_arg1 of { (NodePtr pStart) -> case gc_arg2 of { (NodePtr pEnd) -> prim_sceneNodeGetDistanceFrom pStart pEnd >>= \ distance -> (return (distance))}}) foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneNodeGetDistanceFrom" prim_sceneNodeGetDistanceFrom :: Int -> Int -> IO (Int) sceneNodeSetTarget :: (Int,Int,Int) -> NodePtr -> IO () sceneNodeSetTarget gc_arg1 gc_arg2 = case gc_arg1 of { (posx,posy,posz) -> case gc_arg2 of { (NodePtr pNode) -> prim_sceneNodeSetTarget posx posy posz pNode >>= \ gc_result -> access_prim_sceneNodeSetTarget_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneNodeSetTarget_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_sceneNodeSetTarget" prim_sceneNodeSetTarget :: Int -> Int -> Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetTarget_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetTarget_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneNodeSetRotation :: (Int,Int,Int) -> NodePtr -> IO () sceneNodeSetRotation gc_arg1 gc_arg2 = case gc_arg1 of { (x,y,z) -> case gc_arg2 of { (NodePtr pNode) -> prim_sceneNodeSetRotation x y z pNode >>= \ gc_result -> access_prim_sceneNodeSetRotation_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneNodeSetRotation_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_sceneNodeSetRotation" prim_sceneNodeSetRotation :: Int -> Int -> Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetRotation_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetRotation_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneNodeSetScale :: Int -> NodePtr -> IO () sceneNodeSetScale scale gc_arg1 = case gc_arg1 of { (NodePtr pNode) -> prim_sceneNodeSetScale scale pNode >>= \ gc_result -> access_prim_sceneNodeSetScale_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneNodeSetScale_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_sceneNodeSetScale" prim_sceneNodeSetScale :: Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetScale_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetScale_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneCreateCollisionResponseAnimator :: ITriangleSelectorPtr -> NodePtr -> (Int,Int,Int) -> (Int,Int,Int) -> (Int,Int,Int) -> IO ISceneNodeAnimatorPtr sceneCreateCollisionResponseAnimator gc_arg1 gc_arg2 gc_arg3 gc_arg4 gc_arg5 = case gc_arg1 of { (ITriangleSelectorPtr pSelector) -> case gc_arg2 of { (NodePtr pNode) -> case gc_arg3 of { (rx,ry,rz) -> case gc_arg4 of { (gx,gy,gz) -> case gc_arg5 of { (tx,ty,tz) -> prim_sceneCreateCollisionResponseAnimator pSelector pNode rx ry rz gx gy gz tx ty tz >>= \ anim -> (return ((ISceneNodeAnimatorPtr anim)))}}}}} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneCreateCollisionResponseAnimator" prim_sceneCreateCollisionResponseAnimator :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> IO (Int) sceneNodeAddAnimator :: NodePtr -> ISceneNodeAnimatorPtr -> IO () sceneNodeAddAnimator gc_arg1 gc_arg2 = case gc_arg1 of { (NodePtr node) -> case gc_arg2 of { (ISceneNodeAnimatorPtr pAnim) -> prim_sceneNodeAddAnimator node pAnim >>= \ gc_result -> access_prim_sceneNodeAddAnimator_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneNodeAddAnimator_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_sceneNodeAddAnimator" prim_sceneNodeAddAnimator :: Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeAddAnimator_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeAddAnimator_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneNodeAnimatorDrop :: ISceneNodeAnimatorPtr -> IO () sceneNodeAnimatorDrop gc_arg1 = case gc_arg1 of { (ISceneNodeAnimatorPtr pAnim) -> prim_sceneNodeAnimatorDrop pAnim >>= \ gc_result -> access_prim_sceneNodeAnimatorDrop_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneNodeAnimatorDrop_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_sceneNodeAnimatorDrop" prim_sceneNodeAnimatorDrop :: Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeAnimatorDrop_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeAnimatorDrop_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneTriangleSelectorDrop :: ITriangleSelectorPtr -> IO () sceneTriangleSelectorDrop gc_arg1 = case gc_arg1 of { (ITriangleSelectorPtr pSelector) -> prim_sceneTriangleSelectorDrop pSelector >>= \ gc_result -> access_prim_sceneTriangleSelectorDrop_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneTriangleSelectorDrop_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_sceneTriangleSelectorDrop" prim_sceneTriangleSelectorDrop :: Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneTriangleSelectorDrop_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneTriangleSelectorDrop_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneAddLightSceneNode :: IO () sceneAddLightSceneNode = prim_sceneAddLightSceneNode >>= \ gc_result -> access_prim_sceneAddLightSceneNode_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneAddLightSceneNode_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_sceneAddLightSceneNode" prim_sceneAddLightSceneNode :: IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddLightSceneNode_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddLightSceneNode_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneAddAmbientLight :: (Int,Int,Int,Int) -> IO () sceneAddAmbientLight gc_arg1 = case gc_arg1 of { (r,g,b,a) -> prim_sceneAddAmbientLight r g b a >>= \ gc_result -> access_prim_sceneAddAmbientLight_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneAddAmbientLight_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_sceneAddAmbientLight" prim_sceneAddAmbientLight :: Int -> Int -> Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddAmbientLight_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneAddAmbientLight_gc_failstring :: Ptr a1 -> IO (Ptr r1) guiGetFont :: String -> IO IGUIFontPtr guiGetFont gc_arg1 = (marshall_string_ gc_arg1) >>= \ (path) -> prim_guiGetFont path >>= \ font -> (return ((IGUIFontPtr font))) foreign import ccall unsafe "irrlicht_stub_ffi.h prim_guiGetFont" prim_guiGetFont :: Ptr a1 -> IO (Int) guiSetDrawBackground :: Bool -> IGUIStaticTextPtr -> IO () guiSetDrawBackground gc_arg1 gc_arg2 = (marshall_bool_ gc_arg1) >>= \ (visibility) -> case gc_arg2 of { (IGUIStaticTextPtr pText) -> prim_guiSetDrawBackground visibility pText >>= \ gc_result -> access_prim_guiSetDrawBackground_gc_failed gc_result >>= \ gc_failed -> access_prim_guiSetDrawBackground_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_guiSetDrawBackground" prim_guiSetDrawBackground :: Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetDrawBackground_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetDrawBackground_gc_failstring :: Ptr a1 -> IO (Ptr r1) guiSetDrawBorder :: Bool -> IGUIStaticTextPtr -> IO () guiSetDrawBorder gc_arg1 gc_arg2 = (marshall_bool_ gc_arg1) >>= \ (visibility) -> case gc_arg2 of { (IGUIStaticTextPtr pText) -> prim_guiSetDrawBorder visibility pText >>= \ gc_result -> access_prim_guiSetDrawBorder_gc_failed gc_result >>= \ gc_failed -> access_prim_guiSetDrawBorder_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_guiSetDrawBorder" prim_guiSetDrawBorder :: Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetDrawBorder_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetDrawBorder_gc_failstring :: Ptr a1 -> IO (Ptr r1) guiSetOverrideFont :: IGUIFontPtr -> IGUIStaticTextPtr -> IO () guiSetOverrideFont gc_arg1 gc_arg2 = case gc_arg1 of { (IGUIFontPtr pFont) -> case gc_arg2 of { (IGUIStaticTextPtr pText) -> prim_guiSetOverrideFont pFont pText >>= \ gc_result -> access_prim_guiSetOverrideFont_gc_failed gc_result >>= \ gc_failed -> access_prim_guiSetOverrideFont_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_guiSetOverrideFont" prim_guiSetOverrideFont :: Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetOverrideFont_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetOverrideFont_gc_failstring :: Ptr a1 -> IO (Ptr r1) guiSetBackgroundColor :: (Int,Int,Int,Int) -> IGUIStaticTextPtr -> IO () guiSetBackgroundColor gc_arg1 gc_arg2 = case gc_arg1 of { (alpha,red,green,blue) -> case gc_arg2 of { (IGUIStaticTextPtr pText) -> prim_guiSetBackgroundColor alpha red green blue pText >>= \ gc_result -> access_prim_guiSetBackgroundColor_gc_failed gc_result >>= \ gc_failed -> access_prim_guiSetBackgroundColor_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_guiSetBackgroundColor" prim_guiSetBackgroundColor :: Int -> Int -> Int -> Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetBackgroundColor_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_guiSetBackgroundColor_gc_failstring :: Ptr a1 -> IO (Ptr r1) deviceSetCursorVisibility :: Bool -> IO () deviceSetCursorVisibility gc_arg1 = (marshall_bool_ gc_arg1) >>= \ (visibility) -> prim_deviceSetCursorVisibility visibility >>= \ gc_result -> access_prim_deviceSetCursorVisibility_gc_failed gc_result >>= \ gc_failed -> access_prim_deviceSetCursorVisibility_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_deviceSetCursorVisibility" prim_deviceSetCursorVisibility :: Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceSetCursorVisibility_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_deviceSetCursorVisibility_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneCreateOctreeTriangleSelector :: MeshPtr -> NodePtr -> Int -> IO ITriangleSelectorPtr sceneCreateOctreeTriangleSelector gc_arg1 gc_arg2 poly = case gc_arg1 of { (MeshPtr pMesh) -> case gc_arg2 of { (NodePtr pNode) -> prim_sceneCreateOctreeTriangleSelector pMesh pNode poly >>= \ selector -> (return ((ITriangleSelectorPtr selector)))}} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneCreateOctreeTriangleSelector" prim_sceneCreateOctreeTriangleSelector :: Int -> Int -> Int -> IO (Int) sceneNodeSetTriangleSelector :: ITriangleSelectorPtr -> NodePtr -> IO () sceneNodeSetTriangleSelector gc_arg1 gc_arg2 = case gc_arg1 of { (ITriangleSelectorPtr pSelector) -> case gc_arg2 of { (NodePtr pNode) -> prim_sceneNodeSetTriangleSelector pSelector pNode >>= \ gc_result -> access_prim_sceneNodeSetTriangleSelector_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneNodeSetTriangleSelector_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_sceneNodeSetTriangleSelector" prim_sceneNodeSetTriangleSelector :: Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetTriangleSelector_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetTriangleSelector_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneNodeSetVisible :: NodePtr -> Bool -> IO () sceneNodeSetVisible gc_arg1 gc_arg2 = case gc_arg1 of { (NodePtr pNode) -> (marshall_bool_ gc_arg2) >>= \ (visible) -> prim_sceneNodeSetVisible pNode visible >>= \ gc_result -> access_prim_sceneNodeSetVisible_gc_failed gc_result >>= \ gc_failed -> access_prim_sceneNodeSetVisible_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_sceneNodeSetVisible" prim_sceneNodeSetVisible :: Int -> Int -> IO (Ptr r1) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetVisible_gc_failed :: Ptr a1 -> IO (Int) foreign import ccall unsafe "irrlicht_stub_ffi.h" access_prim_sceneNodeSetVisible_gc_failstring :: Ptr a1 -> IO (Ptr r1) sceneNodeIsVisible :: NodePtr -> Int sceneNodeIsVisible gc_arg1 = unsafePerformIO( case gc_arg1 of { (NodePtr pNode) -> prim_sceneNodeIsVisible pNode >>= \ visible -> (return (visible))}) foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneNodeIsVisible" prim_sceneNodeIsVisible :: Int -> IO (Int) sceneAddCameraSceneNodeFPS :: IO NodePtr sceneAddCameraSceneNodeFPS = prim_sceneAddCameraSceneNodeFPS >>= \ pNode -> (return ((NodePtr pNode))) foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneAddCameraSceneNodeFPS" prim_sceneAddCameraSceneNodeFPS :: IO (Int) 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) 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) getVirtualTime :: Int getVirtualTime = unsafePerformIO( prim_getVirtualTime >>= \ res1 -> (return (res1))) foreign import ccall unsafe "irrlicht_stub_ffi.h prim_getVirtualTime" prim_getVirtualTime :: IO (Int) sceneCreateMeshBuffer :: IO SMeshBufferPtr sceneCreateMeshBuffer = prim_sceneCreateMeshBuffer >>= \ pBuff -> (return ((SMeshBufferPtr pBuff))) foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneCreateMeshBuffer" prim_sceneCreateMeshBuffer :: IO (Int) scenePushBackVerticesOne :: SMeshBufferPtr -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> IO SMeshBufferPtr scenePushBackVerticesOne gc_arg1 numVert i vx vy vz ex ey ez = case gc_arg1 of { (SMeshBufferPtr buff) -> prim_scenePushBackVerticesOne buff numVert i vx vy vz ex ey ez >>= \ pBuff -> (return ((SMeshBufferPtr pBuff)))} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_scenePushBackVerticesOne" prim_scenePushBackVerticesOne :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> IO (Int) scenePushBackVerticesTwo :: SMeshBufferPtr -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> IO SMeshBufferPtr scenePushBackVerticesTwo gc_arg1 numVert i vx vy vz ex ey ez = case gc_arg1 of { (SMeshBufferPtr buff) -> prim_scenePushBackVerticesTwo buff numVert i vx vy vz ex ey ez >>= \ pBuff -> (return ((SMeshBufferPtr pBuff)))} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_scenePushBackVerticesTwo" prim_scenePushBackVerticesTwo :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> IO (Int) sceneGetMeshFromBuffer :: SMeshBufferPtr -> IO MeshPtr sceneGetMeshFromBuffer gc_arg1 = case gc_arg1 of { (SMeshBufferPtr buff) -> prim_sceneGetMeshFromBuffer buff >>= \ pMesh -> (return ((MeshPtr pMesh)))} foreign import ccall unsafe "irrlicht_stub_ffi.h prim_sceneGetMeshFromBuffer" prim_sceneGetMeshFromBuffer :: Int -> IO (Int)