IrrHaskell-0.1: irrlicht_interface_ffi.c

#include "irrlicht_interface.h" 
#include "irrlicht_interface_ffi.h"
 enum drivertype {EDT_NULL, EDT_SOFTWARE, EDT_BURNINGSVIDEO, EDT_DIRECT3D8, EDT_DIRECT3D9, EDT_OPENGL};
 enum materialflag {EMF_WIREFRAME = 0x1, EMF_POINTCLOUD = 0x2, EMF_GOURARD_SHADING = 0x4, EMF_LIGHTING = 0x8, EMF_ZBUFFER = 0x10, EMF_ZWRITE_ENABLE = 0x20, EMF_BACK_FACE_CULLING = 0x40, EMF_FRONT_FACE_CULLING = 0x80, EMF_BILINEAR_FILTER = 0x100, EMF_TRILINEAR_FILTER = 0x200, EMF_ANISOTROPIC_FILTER = 0x400, EMF_FOG_ENABLE = 0x800, EMF_NORMALIZE_NORMALS = 0x1000, EMF_TEXTURE_WRAP = 0x2000, EMF_ANTI_ALIASING = 0x4000, EMF_COLOR_MASK = 0x8000, EMF_COLOR_MATERIAL = 0x100000};
 enum md2animationtype {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};
HsInt prim_eDT_NULL()
{ HsInt res1;
  do {res1=EDT_NULL;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eDT_SOFTWARE()
{ HsInt res1;
  do {res1=EDT_SOFTWARE;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eDT_BURNINGSVIDEO()
{ HsInt res1;
  do {res1=EDT_BURNINGSVIDEO;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eDT_DIRECT3D8()
{ HsInt res1;
  do {res1=EDT_DIRECT3D8;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eDT_DIRECT3D9()
{ HsInt res1;
  do {res1=EDT_DIRECT3D9;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eDT_OPENGL()
{ HsInt res1;
  do {res1=EDT_OPENGL;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_WIREFRAME()
{ HsInt res1;
  do {res1=EMF_WIREFRAME;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_POINTCLOUD()
{ HsInt res1;
  do {res1=EMF_POINTCLOUD;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_GOURARD_SHADING()
{ HsInt res1;
  do {res1=EMF_GOURARD_SHADING;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_LIGHTING()
{ HsInt res1;
  do {res1=EMF_LIGHTING;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_ZBUFFER()
{ HsInt res1;
  do {res1=EMF_ZBUFFER;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_ZWRITE_ENABLE()
{ HsInt res1;
  do {res1=EMF_ZWRITE_ENABLE;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_BACK_FACE_CULLING()
{ HsInt res1;
  do {res1=EMF_BACK_FACE_CULLING;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_FRONT_FACE_CULLING()
{ HsInt res1;
  do {res1=EMF_FRONT_FACE_CULLING;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_BILINEAR_FILTER()
{ HsInt res1;
  do {res1=EMF_BILINEAR_FILTER;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_TRILINEAR_FILTER()
{ HsInt res1;
  do {res1=EMF_TRILINEAR_FILTER;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_ANISOTROPIC_FILTER()
{ HsInt res1;
  do {res1=EMF_ANISOTROPIC_FILTER;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_FOG_ENABLE()
{ HsInt res1;
  do {res1=EMF_FOG_ENABLE;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_NORMALIZE_NORMALS()
{ HsInt res1;
  do {res1=EMF_NORMALIZE_NORMALS;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_TEXTURE_WRAP()
{ HsInt res1;
  do {res1=EMF_TEXTURE_WRAP;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_ANTI_ALIASING()
{ HsInt res1;
  do {res1=EMF_ANTI_ALIASING;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_COLOR_MASK()
{ HsInt res1;
  do {res1=EMF_COLOR_MASK;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMF_COLOR_MATERIAL()
{ HsInt res1;
  do {res1=EMF_COLOR_MATERIAL;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_STAND()
{ HsInt res1;
  do {res1=EMAT_STAND;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_RUN()
{ HsInt res1;
  do {res1=EMAT_RUN;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_ATTACK()
{ HsInt res1;
  do {res1=EMAT_ATTACK;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_PAIN_A()
{ HsInt res1;
  do {res1=EMAT_PAIN_A;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_PAIN_B()
{ HsInt res1;
  do {res1=EMAT_PAIN_B;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_PAIN_C()
{ HsInt res1;
  do {res1=EMAT_PAIN_C;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_JUMP()
{ HsInt res1;
  do {res1=EMAT_JUMP;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_FLIP()
{ HsInt res1;
  do {res1=EMAT_FLIP;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_SALUTE()
{ HsInt res1;
  do {res1=EMAT_SALUTE;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_FALLBACK()
{ HsInt res1;
  do {res1=EMAT_FALLBACK;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_WAVE()
{ HsInt res1;
  do {res1=EMAT_WAVE;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_POINT()
{ HsInt res1;
  do {res1=EMAT_POINT;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_CROUCH_STAND()
{ HsInt res1;
  do {res1=EMAT_CROUCH_STAND;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_CROUCH_WALK()
{ HsInt res1;
  do {res1=EMAT_CROUCH_WALK;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_CROUCH_ATTACK()
{ HsInt res1;
  do {res1=EMAT_CROUCH_ATTACK;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_CROUCH_PAIN()
{ HsInt res1;
  do {res1=EMAT_CROUCH_PAIN;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_CROUCH_DEATH()
{ HsInt res1;
  do {res1=EMAT_CROUCH_DEATH;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_DEATH_FALLBACK()
{ HsInt res1;
  do {res1=EMAT_DEATH_FALLBACK;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_DEATH_FALLFORWARD()
{ HsInt res1;
  do {res1=EMAT_DEATH_FALLFORWARD;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_DEATH_FALLBACKSLOW()
{ HsInt res1;
  do {res1=EMAT_DEATH_FALLBACKSLOW;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_BOOM()
{ HsInt res1;
  do {res1=EMAT_BOOM;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_eMAT_COUNT()
{ HsInt res1;
  do {res1=EMAT_COUNT;
      
      return((HsInt)(res1));} while(0);
}
HsInt prim_getEvent()
{ HsInt result;
  do { int result = GetEvent();
      
      return((HsInt)(result));} while(0);
}
HsChar prim_getCharEvent()
{ HsChar result;
  do { char result = GetCharEvent();
      
      return((HsChar)(result));} while(0);
}
void* prim_deviceSetEventReceiver(HsInt control)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = DeviceSetEventReceiver(control);
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_deviceSetEventReceiver_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_deviceSetEventReceiver_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_deviceSetWindowCaption(char * caption)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = DeviceSetWindowCaption(caption);
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_deviceSetWindowCaption_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_deviceSetWindowCaption_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_deviceRun()
{ static struct {HsInt result;HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  HsInt result;int gc_failed;
               char* gc_failstring;
  do { int result = DeviceRun();
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.result = (HsInt)(result);
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
HsInt access_prim_deviceRun_result(void *ptr){ return(((struct {HsInt result;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->result);}
int access_prim_deviceRun_gc_failed(void *ptr){ return(((struct {HsInt result;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_deviceRun_gc_failstring(void *ptr){ return(((struct {HsInt result;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_deviceDrop()
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = DeviceDrop();
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_deviceDrop_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_deviceDrop_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_irrCreateDevice(HsInt dtype,HsInt sizex,HsInt sizey,HsInt fullscreen,HsInt stencilbuffer,HsInt vsync)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = IrrCreateDevice(dtype, sizex, sizey, fullscreen, stencilbuffer, vsync);
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_irrCreateDevice_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_irrCreateDevice_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_guiAddStaticText(char * text,HsInt topleftx,HsInt toplefty,HsInt lowrightx,HsInt lowrighty)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = GuiAddStaticText(text, topleftx, toplefty, lowrightx, lowrighty);
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_guiAddStaticText_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_guiAddStaticText_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_guiDrawAll()
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = GuiDrawAll();
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_guiDrawAll_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_guiDrawAll_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_videoBeginScene(HsInt a,HsInt b,HsInt colr,HsInt colg,HsInt colb,HsInt colt)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = VideoBeginScene(a, b, colr, colg, colb, colt);
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_videoBeginScene_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_videoBeginScene_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_videoEndScene()
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = VideoEndScene();
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_videoEndScene_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_videoEndScene_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_videoGetTexture(char * texture)
{ static struct {HsInt pTexture;HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  HsInt pTexture;int gc_failed;
                 char* gc_failstring;
  do { int pTexture = VideoGetTexture(texture);
;
      if ((gc_failed = ( pTexture == 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.pTexture = (HsInt)(pTexture);
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
HsInt access_prim_videoGetTexture_pTexture(void *ptr){ return(((struct {HsInt pTexture;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->pTexture);}
int access_prim_videoGetTexture_gc_failed(void *ptr){ return(((struct {HsInt pTexture;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_videoGetTexture_gc_failstring(void *ptr){ return(((struct {HsInt pTexture;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_sceneDrawAll()
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = SceneDrawAll();
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_sceneDrawAll_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_sceneDrawAll_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_sceneGetMesh(char * mesh)
{ static struct {HsInt pMesh;HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  HsInt pMesh;int gc_failed;
              char* gc_failstring;
  do { int pMesh = SceneGetMesh(mesh);
;
      if ((gc_failed = ( pMesh == 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.pMesh = (HsInt)(pMesh);
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
HsInt access_prim_sceneGetMesh_pMesh(void *ptr){ return(((struct {HsInt pMesh;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->pMesh);}
int access_prim_sceneGetMesh_gc_failed(void *ptr){ return(((struct {HsInt pMesh;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_sceneGetMesh_gc_failstring(void *ptr){ return(((struct {HsInt pMesh;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_sceneAddAnimatedMeshSceneNode(HsInt pMesh)
{ static struct {HsInt pNode;HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  HsInt pNode;int gc_failed;
              char* gc_failstring;
  do { int pNode = SceneAddAnimatedMeshSceneNode(pMesh);
;
      if ((gc_failed = ( pNode == 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.pNode = (HsInt)(pNode);
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
HsInt access_prim_sceneAddAnimatedMeshSceneNode_pNode(void *ptr){ return(((struct {HsInt pNode;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->pNode);}
int access_prim_sceneAddAnimatedMeshSceneNode_gc_failed(void *ptr){ return(((struct {HsInt pNode;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_sceneAddAnimatedMeshSceneNode_gc_failstring(void *ptr){ return(((struct {HsInt pNode;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_sceneAddCameraSceneNode(HsInt posx,HsInt posy,HsInt posz,HsInt tox,HsInt toy,HsInt toz)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = SceneAddCameraSceneNode(posx, posy, posz, tox, toy, toz);
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_sceneAddCameraSceneNode_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_sceneAddCameraSceneNode_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_sceneAddOctTreeSceneNode(HsInt pMesh)
{ static struct {HsInt pNode;HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  HsInt pNode;int gc_failed;
              char* gc_failstring;
  do { int pNode = SceneAddOctTreeSceneNode(pMesh);
      if ((gc_failed = ( pNode == 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.pNode = (HsInt)(pNode);
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
HsInt access_prim_sceneAddOctTreeSceneNode_pNode(void *ptr){ return(((struct {HsInt pNode;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->pNode);}
int access_prim_sceneAddOctTreeSceneNode_gc_failed(void *ptr){ return(((struct {HsInt pNode;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_sceneAddOctTreeSceneNode_gc_failstring(void *ptr){ return(((struct {HsInt pNode;HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_sceneNodeSetPosition(HsInt posx,HsInt posy,HsInt posz,HsInt pNode)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = SceneNodeSetPosition( posx, posy,posz, pNode);
      if ((gc_failed = ( result <0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_sceneNodeSetPosition_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_sceneNodeSetPosition_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_sceneAddCameraSceneNodeFPS()
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = SceneAddCameraSceneNodeFPS();
      if ((gc_failed = ( result <0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_sceneAddCameraSceneNodeFPS_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_sceneAddCameraSceneNodeFPS_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_nodeSetMaterialTexture(HsInt pNode,HsInt pTexture)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = NodeSetMaterialTexture(pNode, pTexture);
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_nodeSetMaterialTexture_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_nodeSetMaterialTexture_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_nodeSetMaterialFlag(HsInt pNode,HsInt mflag,HsInt value)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = NodeSetMaterialFlag(pNode, mflag, value);
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_nodeSetMaterialFlag_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_nodeSetMaterialFlag_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_nodeSetMd2Animation(HsInt pNode,HsInt atype)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = NodeSetMd2Animation(pNode, atype);
;
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_nodeSetMd2Animation_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_nodeSetMd2Animation_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
void* prim_fileSystemAddZipFileArchive(char * file)
{ static struct {HsInt gc_failed;HsPtr gc_failstring;} gc_result;
  int gc_failed;
  char* gc_failstring;
  do { int result = FileSystemAddZipFileArchive(file);
      if ((gc_failed = ( result < 0 ))) {gc_failstring = getError(); ;}
      else {gc_failed = 0;}
      gc_result.gc_failed = gc_failed;
      gc_result.gc_failstring = gc_failstring;
      
      return(&gc_result);} while(0);
}
int access_prim_fileSystemAddZipFileArchive_gc_failed(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failed);}
void* access_prim_fileSystemAddZipFileArchive_gc_failstring(void *ptr){ return(((struct {HsInt gc_failed;HsPtr gc_failstring;}*) ptr)->gc_failstring);}
HsInt prim_getVirtualTime()
{ HsInt res1;
  do { int result = GetVirtualTime();
      
      return((HsInt)(res1));} while(0);
}