data D3DXATTRIBUTERANGE = D3DXATTRIBUTERANGE{ d3DXATTRIBUTERANGE_AttribId :: !DWORD,d3DXATTRIBUTERANGE_FaceStart :: !DWORD,d3DXATTRIBUTERANGE_FaceCount :: !DWORD,d3DXATTRIBUTERANGE_VertexStart :: !DWORD,d3DXATTRIBUTERANGE_VertexCount :: !DWORD } deriving (Show,Eq,Ord)
type LPD3DXATTRIBUTERANGE = Ptr D3DXATTRIBUTERANGE
instance Storable D3DXATTRIBUTERANGE where
 sizeOf _ = (sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))
 alignment = const 1
 poke b (D3DXATTRIBUTERANGE p1 p2 p3 p4 p5)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  return (D3DXATTRIBUTERANGE p1 p2 p3 p4 p5)

data D3DXATTRIBUTEWEIGHTS = D3DXATTRIBUTEWEIGHTS{ d3DXATTRIBUTEWEIGHTS_Position :: !FLOAT,d3DXATTRIBUTEWEIGHTS_Boundary :: !FLOAT,d3DXATTRIBUTEWEIGHTS_Normal :: !FLOAT,d3DXATTRIBUTEWEIGHTS_Diffuse :: !FLOAT,d3DXATTRIBUTEWEIGHTS_Specular :: !FLOAT,d3DXATTRIBUTEWEIGHTS_Texcoord :: !(Ptr FLOAT),d3DXATTRIBUTEWEIGHTS_Tangent :: !FLOAT,d3DXATTRIBUTEWEIGHTS_Binormal :: !FLOAT } deriving (Show,Eq,Ord)
type LPD3DXATTRIBUTEWEIGHTS = Ptr D3DXATTRIBUTEWEIGHTS
instance Storable D3DXATTRIBUTEWEIGHTS where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(Ptr FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))
 alignment = const 1
 poke b (D3DXATTRIBUTEWEIGHTS p1 p2 p3 p4 p5 p6 p7 p8)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >>= pokeHelp p7 >>= pokeHelp p8 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p6)
  p7 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p7)
  p8 <- peekByteOff b 0
  return (D3DXATTRIBUTEWEIGHTS p1 p2 p3 p4 p5 p6 p7 p8)

data D3DXBONECOMBINATION = D3DXBONECOMBINATION{ d3DXBONECOMBINATION_AttribId :: !DWORD,d3DXBONECOMBINATION_FaceStart :: !DWORD,d3DXBONECOMBINATION_FaceCount :: !DWORD,d3DXBONECOMBINATION_VertexStart :: !DWORD,d3DXBONECOMBINATION_VertexCount :: !DWORD,d3DXBONECOMBINATION_BoneId :: !(Ptr DWORD) } deriving (Show,Eq,Ord)
type LPD3DXBONECOMBINATION = Ptr D3DXBONECOMBINATION
instance Storable D3DXBONECOMBINATION where
 sizeOf _ = (sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(Ptr DWORD)))
 alignment = const 1
 poke b (D3DXBONECOMBINATION p1 p2 p3 p4 p5 p6)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  return (D3DXBONECOMBINATION p1 p2 p3 p4 p5 p6)

data D3DXCOLOR = D3DXCOLOR{ d3DXCOLOR_r :: !FLOAT,d3DXCOLOR_g :: !FLOAT,d3DXCOLOR_b :: !FLOAT,d3DXCOLOR_a :: !FLOAT } deriving (Show,Eq,Ord)
type LPD3DXCOLOR = Ptr D3DXCOLOR
instance Storable D3DXCOLOR where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))
 alignment = const 1
 poke b (D3DXCOLOR p1 p2 p3 p4)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  return (D3DXCOLOR p1 p2 p3 p4)

data D3DXCONSTANT_DESC = D3DXCONSTANT_DESC{ d3DXCONSTANT_DESC_Name :: !LPCSTR,d3DXCONSTANT_DESC_RegisterSet :: !D3DXREGISTER_SET,d3DXCONSTANT_DESC_RegisterIndex :: !UINT,d3DXCONSTANT_DESC_RegisterCount :: !UINT,d3DXCONSTANT_DESC_Class :: !D3DXPARAMETER_CLASS,d3DXCONSTANT_DESC_Type :: !D3DXPARAMETER_TYPE,d3DXCONSTANT_DESC_Rows :: !UINT,d3DXCONSTANT_DESC_Columns :: !UINT,d3DXCONSTANT_DESC_Elements :: !UINT,d3DXCONSTANT_DESC_StructMembers :: !UINT,d3DXCONSTANT_DESC_Bytes :: !UINT,d3DXCONSTANT_DESC_DefaultValue :: !LPCVOID } deriving (Show,Eq,Ord)
type LPD3DXCONSTANT_DESC = Ptr D3DXCONSTANT_DESC
instance Storable D3DXCONSTANT_DESC where
 sizeOf _ = (sizeOf (undefined::(LPCSTR)))+(sizeOf (undefined::(D3DXREGISTER_SET)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(D3DXPARAMETER_CLASS)))+(sizeOf (undefined::(D3DXPARAMETER_TYPE)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(LPCVOID)))
 alignment = const 1
 poke b (D3DXCONSTANT_DESC p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >>= pokeHelp p7 >>= pokeHelp p8 >>= pokeHelp p9 >>= pokeHelp p10 >>= pokeHelp p11 >>= pokeHelp p12 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p6)
  p7 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p7)
  p8 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p8)
  p9 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p9)
  p10 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p10)
  p11 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p11)
  p12 <- peekByteOff b 0
  return (D3DXCONSTANT_DESC p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12)

data D3DXCONSTANTTABLE_DESC = D3DXCONSTANTTABLE_DESC{ d3DXCONSTANTTABLE_DESC_Creator :: !LPCSTR,d3DXCONSTANTTABLE_DESC_Version :: !DWORD,d3DXCONSTANTTABLE_DESC_Constants :: !UINT } deriving (Show,Eq,Ord)
type LPD3DXCONSTANTTABLE_DESC = Ptr D3DXCONSTANTTABLE_DESC
instance Storable D3DXCONSTANTTABLE_DESC where
 sizeOf _ = (sizeOf (undefined::(LPCSTR)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(UINT)))
 alignment = const 1
 poke b (D3DXCONSTANTTABLE_DESC p1 p2 p3)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  return (D3DXCONSTANTTABLE_DESC p1 p2 p3)

data D3DXEFFECTDEFAULT = D3DXEFFECTDEFAULT{ d3DXEFFECTDEFAULT_pParamName :: !LPSTR,d3DXEFFECTDEFAULT_Type :: !D3DXEFFECTDEFAULTTYPE,d3DXEFFECTDEFAULT_NumBytes :: !DWORD,d3DXEFFECTDEFAULT_pValue :: !LPVOID } deriving (Show,Eq,Ord)
type LPD3DXEFFECTDEFAULT = Ptr D3DXEFFECTDEFAULT
instance Storable D3DXEFFECTDEFAULT where
 sizeOf _ = (sizeOf (undefined::(LPSTR)))+(sizeOf (undefined::(D3DXEFFECTDEFAULTTYPE)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(LPVOID)))
 alignment = const 1
 poke b (D3DXEFFECTDEFAULT p1 p2 p3 p4)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  return (D3DXEFFECTDEFAULT p1 p2 p3 p4)

data D3DXEFFECTINSTANCE = D3DXEFFECTINSTANCE{ d3DXEFFECTINSTANCE_pEffectFilename :: !LPSTR,d3DXEFFECTINSTANCE_NumDefaults :: !DWORD,d3DXEFFECTINSTANCE_pDefaults :: !LPD3DXEFFECTDEFAULT } deriving (Show,Eq,Ord)
type LPD3DXEFFECTINSTANCE = Ptr D3DXEFFECTINSTANCE
instance Storable D3DXEFFECTINSTANCE where
 sizeOf _ = (sizeOf (undefined::(LPSTR)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(LPD3DXEFFECTDEFAULT)))
 alignment = const 1
 poke b (D3DXEFFECTINSTANCE p1 p2 p3)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  return (D3DXEFFECTINSTANCE p1 p2 p3)

data D3DXEFFECT_DESC = D3DXEFFECT_DESC{ d3DXEFFECT_DESC_Creator :: !LPCSTR,d3DXEFFECT_DESC_Parameters :: !UINT,d3DXEFFECT_DESC_Techniques :: !UINT,d3DXEFFECT_DESC_Functions :: !UINT } deriving (Show,Eq,Ord)
type LPD3DXEFFECT_DESC = Ptr D3DXEFFECT_DESC
instance Storable D3DXEFFECT_DESC where
 sizeOf _ = (sizeOf (undefined::(LPCSTR)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))
 alignment = const 1
 poke b (D3DXEFFECT_DESC p1 p2 p3 p4)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  return (D3DXEFFECT_DESC p1 p2 p3 p4)

data D3DXFLOAT16 = D3DXFLOAT16{ d3DXFLOAT16_Value :: !WORD } deriving (Show,Eq,Ord)
type LPD3DXFLOAT16 = Ptr D3DXFLOAT16
instance Storable D3DXFLOAT16 where
 sizeOf _ = (sizeOf (undefined::(WORD)))
 alignment = const 1
 poke b (D3DXFLOAT16 p1)
  = return b >>= pokeHelp p1 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  return (D3DXFLOAT16 p1)

data D3DXFONT_DESC = D3DXFONT_DESC{ d3DXFONT_DESC_Height :: !INT,d3DXFONT_DESC_Width :: !UINT,d3DXFONT_DESC_Weight :: !UINT,d3DXFONT_DESC_MipLevels :: !UINT,d3DXFONT_DESC_Italic :: !BOOL,d3DXFONT_DESC_CharSet :: !BYTE,d3DXFONT_DESC_OutputPrecision :: !BYTE,d3DXFONT_DESC_Quality :: !BYTE,d3DXFONT_DESC_PitchAndFamily :: !BYTE,d3DXFONT_DESC_FaceName :: !(Ptr TCHAR) } deriving (Show,Eq,Ord)
type LPD3DXFONT_DESC = Ptr D3DXFONT_DESC
instance Storable D3DXFONT_DESC where
 sizeOf _ = (sizeOf (undefined::(INT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(BOOL)))+(sizeOf (undefined::(BYTE)))+(sizeOf (undefined::(BYTE)))+(sizeOf (undefined::(BYTE)))+(sizeOf (undefined::(BYTE)))+(sizeOf (undefined::(Ptr TCHAR)))
 alignment = const 1
 poke b (D3DXFONT_DESC p1 p2 p3 p4 p5 p6 p7 p8 p9 p10)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >>= pokeHelp p7 >>= pokeHelp p8 >>= pokeHelp p9 >>= pokeHelp p10 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p6)
  p7 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p7)
  p8 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p8)
  p9 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p9)
  p10 <- peekByteOff b 0
  return (D3DXFONT_DESC p1 p2 p3 p4 p5 p6 p7 p8 p9 p10)

data D3DXFRAGMENT_DESC = D3DXFRAGMENT_DESC{ d3DXFRAGMENT_DESC_Name :: !LPCSTR,d3DXFRAGMENT_DESC_Target :: !DWORD } deriving (Show,Eq,Ord)
type LPD3DXFRAGMENT_DESC = Ptr D3DXFRAGMENT_DESC
instance Storable D3DXFRAGMENT_DESC where
 sizeOf _ = (sizeOf (undefined::(LPCSTR)))+(sizeOf (undefined::(DWORD)))
 alignment = const 1
 poke b (D3DXFRAGMENT_DESC p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXFRAGMENT_DESC p1 p2)

data D3DXFRAME = D3DXFRAME{ d3DXFRAME_Name :: !LPSTR,d3DXFRAME_ :: !D3DXMATRIX,d3DXFRAME_pMeshContainer :: !LPD3DXMESHCONTAINER,d3DXFRAME_pFrameSibling :: !(Ptr D3DXFRAME),d3DXFRAME_pFrameFirstChild :: !(Ptr D3DXFRAME) } deriving (Show,Eq,Ord)
type LPD3DXFRAME = Ptr D3DXFRAME
instance Storable D3DXFRAME where
 sizeOf _ = (sizeOf (undefined::(LPSTR)))+(sizeOf (undefined::(D3DXMATRIX)))+(sizeOf (undefined::(LPD3DXMESHCONTAINER)))+(sizeOf (undefined::(Ptr D3DXFRAME)))+(sizeOf (undefined::(Ptr D3DXFRAME)))
 alignment = const 1
 poke b (D3DXFRAME p1 p2 p3 p4 p5)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  return (D3DXFRAME p1 p2 p3 p4 p5)

data D3DXFUNCTION_DESC = D3DXFUNCTION_DESC{ d3DXFUNCTION_DESC_Name :: !LPCSTR,d3DXFUNCTION_DESC_Annotations :: !UINT } deriving (Show,Eq,Ord)
type LPD3DXFUNCTION_DESC = Ptr D3DXFUNCTION_DESC
instance Storable D3DXFUNCTION_DESC where
 sizeOf _ = (sizeOf (undefined::(LPCSTR)))+(sizeOf (undefined::(UINT)))
 alignment = const 1
 poke b (D3DXFUNCTION_DESC p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXFUNCTION_DESC p1 p2)

data D3DXIMAGE_INFO = D3DXIMAGE_INFO{ d3DXIMAGE_INFO_Width :: !UINT,d3DXIMAGE_INFO_Height :: !UINT,d3DXIMAGE_INFO_Depth :: !UINT,d3DXIMAGE_INFO_MipLevels :: !UINT,d3DXIMAGE_INFO_Format :: !D3DFORMAT,d3DXIMAGE_INFO_ResourceType :: !D3DRESOURCETYPE,d3DXIMAGE_INFO_ImageFileFormat :: !D3DXIMAGE_FILEFORMAT } deriving (Show,Eq,Ord)
type LPD3DXIMAGE_INFO = Ptr D3DXIMAGE_INFO
instance Storable D3DXIMAGE_INFO where
 sizeOf _ = (sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(D3DFORMAT)))+(sizeOf (undefined::(D3DRESOURCETYPE)))+(sizeOf (undefined::(D3DXIMAGE_FILEFORMAT)))
 alignment = const 1
 poke b (D3DXIMAGE_INFO p1 p2 p3 p4 p5 p6 p7)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >>= pokeHelp p7 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p6)
  p7 <- peekByteOff b 0
  return (D3DXIMAGE_INFO p1 p2 p3 p4 p5 p6 p7)

data D3DXINTERSECTINFO = D3DXINTERSECTINFO{ d3DXINTERSECTINFO_FaceIndex :: !DWORD,d3DXINTERSECTINFO_U :: !FLOAT,d3DXINTERSECTINFO_V :: !FLOAT,d3DXINTERSECTINFO_Dist :: !FLOAT } deriving (Show,Eq,Ord)
type LPD3DXINTERSECTINFO = Ptr D3DXINTERSECTINFO
instance Storable D3DXINTERSECTINFO where
 sizeOf _ = (sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))
 alignment = const 1
 poke b (D3DXINTERSECTINFO p1 p2 p3 p4)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  return (D3DXINTERSECTINFO p1 p2 p3 p4)

data D3DXKEY_CALLBACK = D3DXKEY_CALLBACK{ d3DXKEY_CALLBACK_Time :: !FLOAT,d3DXKEY_CALLBACK_pCallbackData :: !LPVOID } deriving (Show,Eq,Ord)
type LPD3DXKEY_CALLBACK = Ptr D3DXKEY_CALLBACK
instance Storable D3DXKEY_CALLBACK where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(LPVOID)))
 alignment = const 1
 poke b (D3DXKEY_CALLBACK p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXKEY_CALLBACK p1 p2)

data D3DXKEY_QUATERNION = D3DXKEY_QUATERNION{ d3DXKEY_QUATERNION_Time :: !FLOAT,d3DXKEY_QUATERNION_Value :: !D3DXQUATERNION } deriving (Show,Eq,Ord)
type LPD3DXKEY_QUATERNION = Ptr D3DXKEY_QUATERNION
instance Storable D3DXKEY_QUATERNION where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(D3DXQUATERNION)))
 alignment = const 1
 poke b (D3DXKEY_QUATERNION p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXKEY_QUATERNION p1 p2)

data D3DXKEY_VECTOR3 = D3DXKEY_VECTOR3{ d3DXKEY_VECTOR3_Time :: !FLOAT,d3DXKEY_VECTOR3_Value :: !D3DXVECTOR3 } deriving (Show,Eq,Ord)
type LPD3DXKEY_VECTOR3 = Ptr D3DXKEY_VECTOR3
instance Storable D3DXKEY_VECTOR3 where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(D3DXVECTOR3)))
 alignment = const 1
 poke b (D3DXKEY_VECTOR3 p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXKEY_VECTOR3 p1 p2)

data D3DXMACRO = D3DXMACRO{ d3DXMACRO_Name :: !LPCSTR,d3DXMACRO_Definition :: !LPCSTR } deriving (Show,Eq,Ord)
type LPD3DXMACRO = Ptr D3DXMACRO
instance Storable D3DXMACRO where
 sizeOf _ = (sizeOf (undefined::(LPCSTR)))+(sizeOf (undefined::(LPCSTR)))
 alignment = const 1
 poke b (D3DXMACRO p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXMACRO p1 p2)

data D3DXMATERIAL = D3DXMATERIAL{ d3DXMATERIAL_MatD3D :: !D3DMATERIAL9,d3DXMATERIAL_pTextureFilename :: !LPSTR } deriving (Show,Eq,Ord)
type LPD3DXMATERIAL = Ptr D3DXMATERIAL
instance Storable D3DXMATERIAL where
 sizeOf _ = (sizeOf (undefined::(D3DMATERIAL9)))+(sizeOf (undefined::(LPSTR)))
 alignment = const 1
 poke b (D3DXMATERIAL p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXMATERIAL p1 p2)

data D3DXMESHCONTAINER = D3DXMESHCONTAINER{ d3DXMESHCONTAINER_Name :: !LPSTR,d3DXMESHCONTAINER_MeshData :: !D3DXMESHDATA,d3DXMESHCONTAINER_pMaterials :: !LPD3DXMATERIAL,d3DXMESHCONTAINER_pEffects :: !LPD3DXEFFECTINSTANCE,d3DXMESHCONTAINER_NumMaterials :: !DWORD,d3DXMESHCONTAINER_pAdjacency :: !(Ptr DWORD),d3DXMESHCONTAINER_pSkinInfo :: !LPD3DXSKININFO,d3DXMESHCONTAINER_pNextMeshContainer :: !(Ptr D3DXMESHCONTAINER) } deriving (Show,Eq,Ord)
type LPD3DXMESHCONTAINER = Ptr D3DXMESHCONTAINER
instance Storable D3DXMESHCONTAINER where
 sizeOf _ = (sizeOf (undefined::(LPSTR)))+(sizeOf (undefined::(D3DXMESHDATA)))+(sizeOf (undefined::(LPD3DXMATERIAL)))+(sizeOf (undefined::(LPD3DXEFFECTINSTANCE)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(Ptr DWORD)))+(sizeOf (undefined::(LPD3DXSKININFO)))+(sizeOf (undefined::(Ptr D3DXMESHCONTAINER)))
 alignment = const 1
 poke b (D3DXMESHCONTAINER p1 p2 p3 p4 p5 p6 p7 p8)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >>= pokeHelp p7 >>= pokeHelp p8 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p6)
  p7 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p7)
  p8 <- peekByteOff b 0
  return (D3DXMESHCONTAINER p1 p2 p3 p4 p5 p6 p7 p8)

data D3DXPASS_DESC = D3DXPASS_DESC{ d3DXPASS_DESC_Name :: !LPCSTR,d3DXPASS_DESC_Annotations :: !UINT,d3DXPASS_DESC_pVertexShaderFunction :: !(Ptr DWORD),d3DXPASS_DESC_pPixelShaderFunction :: !(Ptr DWORD) } deriving (Show,Eq,Ord)
type LPD3DXPASS_DESC = Ptr D3DXPASS_DESC
instance Storable D3DXPASS_DESC where
 sizeOf _ = (sizeOf (undefined::(LPCSTR)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(Ptr DWORD)))+(sizeOf (undefined::(Ptr DWORD)))
 alignment = const 1
 poke b (D3DXPASS_DESC p1 p2 p3 p4)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  return (D3DXPASS_DESC p1 p2 p3 p4)

data D3DXPATCHINFO = D3DXPATCHINFO{ d3DXPATCHINFO_PatchType :: !D3DXPATCHMESHTYPE,d3DXPATCHINFO_Degree :: !D3DDEGREETYPE,d3DXPATCHINFO_Basis :: !D3DBASISTYPE } deriving (Show,Eq,Ord)
type LPD3DXPATCHINFO = Ptr D3DXPATCHINFO
instance Storable D3DXPATCHINFO where
 sizeOf _ = (sizeOf (undefined::(D3DXPATCHMESHTYPE)))+(sizeOf (undefined::(D3DDEGREETYPE)))+(sizeOf (undefined::(D3DBASISTYPE)))
 alignment = const 1
 poke b (D3DXPATCHINFO p1 p2 p3)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  return (D3DXPATCHINFO p1 p2 p3)

data D3DXPLANE = D3DXPLANE{ d3DXPLANE_a :: !FLOAT,d3DXPLANE_b :: !FLOAT,d3DXPLANE_c :: !FLOAT,d3DXPLANE_d :: !FLOAT } deriving (Show,Eq,Ord)
type LPD3DXPLANE = Ptr D3DXPLANE
instance Storable D3DXPLANE where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))
 alignment = const 1
 poke b (D3DXPLANE p1 p2 p3 p4)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  return (D3DXPLANE p1 p2 p3 p4)

data D3DXQUATERNION = D3DXQUATERNION{ d3DXQUATERNION_x :: !FLOAT,d3DXQUATERNION_y :: !FLOAT,d3DXQUATERNION_z :: !FLOAT,d3DXQUATERNION_w :: !FLOAT } deriving (Show,Eq,Ord)
type LPD3DXQUATERNION = Ptr D3DXQUATERNION
instance Storable D3DXQUATERNION where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))
 alignment = const 1
 poke b (D3DXQUATERNION p1 p2 p3 p4)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  return (D3DXQUATERNION p1 p2 p3 p4)

data D3DXRTE_DESC = D3DXRTE_DESC{ d3DXRTE_DESC_Size :: !UINT,d3DXRTE_DESC_MipLevels :: !UINT,d3DXRTE_DESC_Format :: !D3DFORMAT,d3DXRTE_DESC_DepthStencil :: !BOOL,d3DXRTE_DESC_DepthStencilFormat :: !D3DFORMAT } deriving (Show,Eq,Ord)
type LPD3DXRTE_DESC = Ptr D3DXRTE_DESC
instance Storable D3DXRTE_DESC where
 sizeOf _ = (sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(D3DFORMAT)))+(sizeOf (undefined::(BOOL)))+(sizeOf (undefined::(D3DFORMAT)))
 alignment = const 1
 poke b (D3DXRTE_DESC p1 p2 p3 p4 p5)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  return (D3DXRTE_DESC p1 p2 p3 p4 p5)

data D3DXRTS_DESC = D3DXRTS_DESC{ d3DXRTS_DESC_Width :: !UINT,d3DXRTS_DESC_Height :: !UINT,d3DXRTS_DESC_Format :: !D3DFORMAT,d3DXRTS_DESC_DepthStencil :: !BOOL,d3DXRTS_DESC_DepthStencilFormat :: !D3DFORMAT } deriving (Show,Eq,Ord)
type LPD3DXRTS_DESC = Ptr D3DXRTS_DESC
instance Storable D3DXRTS_DESC where
 sizeOf _ = (sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(D3DFORMAT)))+(sizeOf (undefined::(BOOL)))+(sizeOf (undefined::(D3DFORMAT)))
 alignment = const 1
 poke b (D3DXRTS_DESC p1 p2 p3 p4 p5)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  return (D3DXRTS_DESC p1 p2 p3 p4 p5)

data D3DXSEMANTIC = D3DXSEMANTIC{ d3DXSEMANTIC_Usage :: !UINT,d3DXSEMANTIC_UsageIndex :: !UINT } deriving (Show,Eq,Ord)
type LPD3DXSEMANTIC = Ptr D3DXSEMANTIC
instance Storable D3DXSEMANTIC where
 sizeOf _ = (sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))
 alignment = const 1
 poke b (D3DXSEMANTIC p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXSEMANTIC p1 p2)

data D3DXSHADER_CONSTANTINFO = D3DXSHADER_CONSTANTINFO{ d3DXSHADER_CONSTANTINFO_Name :: !DWORD,d3DXSHADER_CONSTANTINFO_RegisterSet :: !WORD,d3DXSHADER_CONSTANTINFO_RegisterIndex :: !WORD,d3DXSHADER_CONSTANTINFO_RegisterCount :: !WORD,d3DXSHADER_CONSTANTINFO_Reserved :: !WORD,d3DXSHADER_CONSTANTINFO_TypeInfo :: !DWORD,d3DXSHADER_CONSTANTINFO_DefaultValue :: !DWORD } deriving (Show,Eq,Ord)
type LPD3DXSHADER_CONSTANTINFO = Ptr D3DXSHADER_CONSTANTINFO
instance Storable D3DXSHADER_CONSTANTINFO where
 sizeOf _ = (sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(WORD)))+(sizeOf (undefined::(WORD)))+(sizeOf (undefined::(WORD)))+(sizeOf (undefined::(WORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))
 alignment = const 1
 poke b (D3DXSHADER_CONSTANTINFO p1 p2 p3 p4 p5 p6 p7)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >>= pokeHelp p7 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p6)
  p7 <- peekByteOff b 0
  return (D3DXSHADER_CONSTANTINFO p1 p2 p3 p4 p5 p6 p7)

data D3DXSHADER_CONSTANTTABLE = D3DXSHADER_CONSTANTTABLE{ d3DXSHADER_CONSTANTTABLE_Size :: !DWORD,d3DXSHADER_CONSTANTTABLE_Creator :: !DWORD,d3DXSHADER_CONSTANTTABLE_Version :: !DWORD,d3DXSHADER_CONSTANTTABLE_Constants :: !DWORD,d3DXSHADER_CONSTANTTABLE_ConstantInfo :: !DWORD,d3DXSHADER_CONSTANTTABLE_Flags :: !DWORD,d3DXSHADER_CONSTANTTABLE_Target :: !DWORD } deriving (Show,Eq,Ord)
type LPD3DXSHADER_CONSTANTTABLE = Ptr D3DXSHADER_CONSTANTTABLE
instance Storable D3DXSHADER_CONSTANTTABLE where
 sizeOf _ = (sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))
 alignment = const 1
 poke b (D3DXSHADER_CONSTANTTABLE p1 p2 p3 p4 p5 p6 p7)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >>= pokeHelp p7 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p6)
  p7 <- peekByteOff b 0
  return (D3DXSHADER_CONSTANTTABLE p1 p2 p3 p4 p5 p6 p7)

data D3DXSHADER_STRUCTMEMBERINFO = D3DXSHADER_STRUCTMEMBERINFO{ d3DXSHADER_STRUCTMEMBERINFO_Name :: !DWORD,d3DXSHADER_STRUCTMEMBERINFO_TypeInfo :: !DWORD } deriving (Show,Eq,Ord)
type LPD3DXSHADER_STRUCTMEMBERINFO = Ptr D3DXSHADER_STRUCTMEMBERINFO
instance Storable D3DXSHADER_STRUCTMEMBERINFO where
 sizeOf _ = (sizeOf (undefined::(DWORD)))+(sizeOf (undefined::(DWORD)))
 alignment = const 1
 poke b (D3DXSHADER_STRUCTMEMBERINFO p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXSHADER_STRUCTMEMBERINFO p1 p2)

data D3DXSHADER_TYPEINFO = D3DXSHADER_TYPEINFO{ d3DXSHADER_TYPEINFO_Class :: !WORD,d3DXSHADER_TYPEINFO_Type :: !WORD,d3DXSHADER_TYPEINFO_Rows :: !WORD,d3DXSHADER_TYPEINFO_Columns :: !WORD,d3DXSHADER_TYPEINFO_Elements :: !WORD,d3DXSHADER_TYPEINFO_StructMembers :: !WORD,d3DXSHADER_TYPEINFO_StructMemberInfo :: !DWORD } deriving (Show,Eq,Ord)
type LPD3DXSHADER_TYPEINFO = Ptr D3DXSHADER_TYPEINFO
instance Storable D3DXSHADER_TYPEINFO where
 sizeOf _ = (sizeOf (undefined::(WORD)))+(sizeOf (undefined::(WORD)))+(sizeOf (undefined::(WORD)))+(sizeOf (undefined::(WORD)))+(sizeOf (undefined::(WORD)))+(sizeOf (undefined::(WORD)))+(sizeOf (undefined::(DWORD)))
 alignment = const 1
 poke b (D3DXSHADER_TYPEINFO p1 p2 p3 p4 p5 p6 p7)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >>= pokeHelp p7 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p6)
  p7 <- peekByteOff b 0
  return (D3DXSHADER_TYPEINFO p1 p2 p3 p4 p5 p6 p7)

data D3DXSHMATERIAL = D3DXSHMATERIAL{ d3DXSHMATERIAL_Diffuse :: !D3DCOLORVALUE,d3DXSHMATERIAL_bMirror :: !BOOL,d3DXSHMATERIAL_bSubSurf :: !BOOL,d3DXSHMATERIAL_RelativeIndexOfRefraction :: !FLOAT,d3DXSHMATERIAL_Absorption :: !D3DCOLORVALUE,d3DXSHMATERIAL_ReducedScattering :: !D3DCOLORVALUE } deriving (Show,Eq,Ord)
type LPD3DXSHMATERIAL = Ptr D3DXSHMATERIAL
instance Storable D3DXSHMATERIAL where
 sizeOf _ = (sizeOf (undefined::(D3DCOLORVALUE)))+(sizeOf (undefined::(BOOL)))+(sizeOf (undefined::(BOOL)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(D3DCOLORVALUE)))+(sizeOf (undefined::(D3DCOLORVALUE)))
 alignment = const 1
 poke b (D3DXSHMATERIAL p1 p2 p3 p4 p5 p6)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  return (D3DXSHMATERIAL p1 p2 p3 p4 p5 p6)

data D3DXSHPRTSPLITMESHCLUSTERDATA = D3DXSHPRTSPLITMESHCLUSTERDATA{ d3DXSHPRTSPLITMESHCLUSTERDATA_uVertStart :: !UINT,d3DXSHPRTSPLITMESHCLUSTERDATA_uVertLength :: !UINT,d3DXSHPRTSPLITMESHCLUSTERDATA_uFaceStart :: !UINT,d3DXSHPRTSPLITMESHCLUSTERDATA_uFaceLength :: !UINT,d3DXSHPRTSPLITMESHCLUSTERDATA_uClusterStart :: !UINT,d3DXSHPRTSPLITMESHCLUSTERDATA_uClusterLength :: !UINT } deriving (Show,Eq,Ord)
type LPD3DXSHPRTSPLITMESHCLUSTERDATA = Ptr D3DXSHPRTSPLITMESHCLUSTERDATA
instance Storable D3DXSHPRTSPLITMESHCLUSTERDATA where
 sizeOf _ = (sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))
 alignment = const 1
 poke b (D3DXSHPRTSPLITMESHCLUSTERDATA p1 p2 p3 p4 p5 p6)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >>= pokeHelp p6 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p5)
  p6 <- peekByteOff b 0
  return (D3DXSHPRTSPLITMESHCLUSTERDATA p1 p2 p3 p4 p5 p6)

data D3DXSHPRTSPLITMESHVERTDATA = D3DXSHPRTSPLITMESHVERTDATA{ d3DXSHPRTSPLITMESHVERTDATA_uVertRemap :: !UINT,d3DXSHPRTSPLITMESHVERTDATA_uSubCluster :: !UINT,d3DXSHPRTSPLITMESHVERTDATA_ucVertStatus :: !UINT } deriving (Show,Eq,Ord)
type LPD3DXSHPRTSPLITMESHVERTDATA = Ptr D3DXSHPRTSPLITMESHVERTDATA
instance Storable D3DXSHPRTSPLITMESHVERTDATA where
 sizeOf _ = (sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))
 alignment = const 1
 poke b (D3DXSHPRTSPLITMESHVERTDATA p1 p2 p3)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  return (D3DXSHPRTSPLITMESHVERTDATA p1 p2 p3)

data D3DXTRACK_DESC = D3DXTRACK_DESC{ d3DXTRACK_DESC_Priority :: !D3DXPRIORITY_TYPE,d3DXTRACK_DESC_Weight :: !FLOAT,d3DXTRACK_DESC_Speed :: !FLOAT,d3DXTRACK_DESC_Position :: !Double,d3DXTRACK_DESC_Enable :: !BOOL } deriving (Show,Eq,Ord)
type LPD3DXTRACK_DESC = Ptr D3DXTRACK_DESC
instance Storable D3DXTRACK_DESC where
 sizeOf _ = (sizeOf (undefined::(D3DXPRIORITY_TYPE)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(Double)))+(sizeOf (undefined::(BOOL)))
 alignment = const 1
 poke b (D3DXTRACK_DESC p1 p2 p3 p4 p5)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >>= pokeHelp p5 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p4)
  p5 <- peekByteOff b 0
  return (D3DXTRACK_DESC p1 p2 p3 p4 p5)

data D3DXTECHNIQUE_DESC = D3DXTECHNIQUE_DESC{ d3DXTECHNIQUE_DESC_Name :: !LPCSTR,d3DXTECHNIQUE_DESC_Passes :: !UINT,d3DXTECHNIQUE_DESC_Annotations :: !UINT } deriving (Show,Eq,Ord)
type LPD3DXTECHNIQUE_DESC = Ptr D3DXTECHNIQUE_DESC
instance Storable D3DXTECHNIQUE_DESC where
 sizeOf _ = (sizeOf (undefined::(LPCSTR)))+(sizeOf (undefined::(UINT)))+(sizeOf (undefined::(UINT)))
 alignment = const 1
 poke b (D3DXTECHNIQUE_DESC p1 p2 p3)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  return (D3DXTECHNIQUE_DESC p1 p2 p3)

data D3DXVECTOR2 = D3DXVECTOR2{ d3DXVECTOR2_x :: !FLOAT,d3DXVECTOR2_y :: !FLOAT } deriving (Show,Eq,Ord)
type LPD3DXVECTOR2 = Ptr D3DXVECTOR2
instance Storable D3DXVECTOR2 where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))
 alignment = const 1
 poke b (D3DXVECTOR2 p1 p2)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  return (D3DXVECTOR2 p1 p2)

data D3DXVECTOR3 = D3DXVECTOR3{ d3DXVECTOR3_x :: !FLOAT,d3DXVECTOR3_y :: !FLOAT,d3DXVECTOR3_z :: !FLOAT } deriving (Show,Eq,Ord)
type LPD3DXVECTOR3 = Ptr D3DXVECTOR3
instance Storable D3DXVECTOR3 where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))
 alignment = const 1
 poke b (D3DXVECTOR3 p1 p2 p3)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  return (D3DXVECTOR3 p1 p2 p3)

data D3DXVECTOR4 = D3DXVECTOR4{ d3DXVECTOR4_x :: !FLOAT,d3DXVECTOR4_y :: !FLOAT,d3DXVECTOR4_z :: !FLOAT,d3DXVECTOR4_w :: !FLOAT } deriving (Show,Eq,Ord)
type LPD3DXVECTOR4 = Ptr D3DXVECTOR4
instance Storable D3DXVECTOR4 where
 sizeOf _ = (sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))+(sizeOf (undefined::(FLOAT)))
 alignment = const 1
 poke b (D3DXVECTOR4 p1 p2 p3 p4)
  = return b >>= pokeHelp p1 >>= pokeHelp p2 >>= pokeHelp p3 >>= pokeHelp p4 >> return()
 peek b = do
  p1 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p1)
  p2 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p2)
  p3 <- peekByteOff b 0
  b <- return $ plusPtr b (sizeOf p3)
  p4 <- peekByteOff b 0
  return (D3DXVECTOR4 p1 p2 p3 p4)

data ID3DXAllocateHierarchy = ID3DXAllocateHierarchy deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXAllocateHierarchy_CreateFrame"
  c_ID3DXAllocateHierarchy_CreateFrame::Ptr ID3DXAllocateHierarchy -> LPCSTR -> Ptr LPD3DXFRAME -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAllocateHierarchy_CreateMeshContainer"
  c_ID3DXAllocateHierarchy_CreateMeshContainer::Ptr ID3DXAllocateHierarchy -> LPCSTR -> Ptr D3DXMESHDATA -> Ptr D3DXMATERIAL -> Ptr D3DXEFFECTINSTANCE -> DWORD -> Ptr DWORD -> LPD3DXSKININFO -> Ptr LPD3DXMESHCONTAINER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAllocateHierarchy_DestroyFrame"
  c_ID3DXAllocateHierarchy_DestroyFrame::Ptr ID3DXAllocateHierarchy -> LPD3DXFRAME -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAllocateHierarchy_DestroyMeshContainer"
  c_ID3DXAllocateHierarchy_DestroyMeshContainer::Ptr ID3DXAllocateHierarchy -> LPD3DXMESHCONTAINER -> IO HRESULT
type LPID3DXAllocateHierarchy = Ptr ID3DXAllocateHierarchy
type LPD3DXALLOCATEHIERARCHY = Ptr ID3DXAllocateHierarchy


data ID3DXAnimationCallbackHandler = ID3DXAnimationCallbackHandler deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXAnimationCallbackHandler_HandleCallback"
  c_ID3DXAnimationCallbackHandler_HandleCallback::Ptr ID3DXAnimationCallbackHandler -> UINT -> LPVOID -> IO HRESULT
type LPID3DXAnimationCallbackHandler = Ptr ID3DXAnimationCallbackHandler
type LPD3DXANIMATIONCALLBACKHANDLER = Ptr ID3DXAnimationCallbackHandler


data ID3DXAnimationController = ID3DXAnimationController deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_AdvanceTime"
  c_ID3DXAnimationController_AdvanceTime::Ptr ID3DXAnimationController -> Double -> LPD3DXANIMATIONCALLBACKHANDLER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_CloneAnimationController"
  c_ID3DXAnimationController_CloneAnimationController::Ptr ID3DXAnimationController -> UINT -> UINT -> UINT -> UINT -> Ptr LPD3DXANIMATIONCONTROLLER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetAnimationSet"
  c_ID3DXAnimationController_GetAnimationSet::Ptr ID3DXAnimationController -> UINT -> Ptr LPD3DXANIMATIONSET -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetAnimationSetByName"
  c_ID3DXAnimationController_GetAnimationSetByName::Ptr ID3DXAnimationController -> LPCSTR -> Ptr LPD3DXANIMATIONSET -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetCurrentPriorityBlend"
  c_ID3DXAnimationController_GetCurrentPriorityBlend::Ptr ID3DXAnimationController -> IO D3DXEVENTHANDLE
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetCurrentTrackEvent"
  c_ID3DXAnimationController_GetCurrentTrackEvent::Ptr ID3DXAnimationController -> UINT -> D3DXEVENT_TYPE -> IO D3DXEVENTHANDLE
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetEventDesc"
  c_ID3DXAnimationController_GetEventDesc::Ptr ID3DXAnimationController -> D3DXEVENTHANDLE -> LPD3DXEVENT_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetMaxNumAnimationOutputs"
  c_ID3DXAnimationController_GetMaxNumAnimationOutputs::Ptr ID3DXAnimationController -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetMaxNumAnimationSets"
  c_ID3DXAnimationController_GetMaxNumAnimationSets::Ptr ID3DXAnimationController -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetMaxNumEvents"
  c_ID3DXAnimationController_GetMaxNumEvents::Ptr ID3DXAnimationController -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetMaxNumTracks"
  c_ID3DXAnimationController_GetMaxNumTracks::Ptr ID3DXAnimationController -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetNumAnimationSets"
  c_ID3DXAnimationController_GetNumAnimationSets::Ptr ID3DXAnimationController -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetPriorityBlend"
  c_ID3DXAnimationController_GetPriorityBlend::Ptr ID3DXAnimationController -> IO FLOAT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetTime"
  c_ID3DXAnimationController_GetTime::Ptr ID3DXAnimationController -> IO Double
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetTrackAnimationSet"
  c_ID3DXAnimationController_GetTrackAnimationSet::Ptr ID3DXAnimationController -> UINT -> Ptr LPD3DXANIMATIONSET -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetTrackDesc"
  c_ID3DXAnimationController_GetTrackDesc::Ptr ID3DXAnimationController -> UINT -> LPD3DXTRACK_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetUpcomingPriorityBlend"
  c_ID3DXAnimationController_GetUpcomingPriorityBlend::Ptr ID3DXAnimationController -> D3DXEVENTHANDLE -> IO D3DXEVENTHANDLE
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_GetUpcomingTrackEvent"
  c_ID3DXAnimationController_GetUpcomingTrackEvent::Ptr ID3DXAnimationController -> UINT -> D3DXEVENTHANDLE -> IO D3DXEVENTHANDLE
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_KeyPriorityBlend"
  c_ID3DXAnimationController_KeyPriorityBlend::Ptr ID3DXAnimationController -> FLOAT -> Double -> Double -> D3DXTRANSITION_TYPE -> IO D3DXEVENTHANDLE
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_KeyTrackEnable"
  c_ID3DXAnimationController_KeyTrackEnable::Ptr ID3DXAnimationController -> UINT -> BOOL -> Double -> IO D3DXEVENTHANDLE
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_KeyTrackPosition"
  c_ID3DXAnimationController_KeyTrackPosition::Ptr ID3DXAnimationController -> UINT -> Double -> Double -> IO D3DXEVENTHANDLE
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_KeyTrackSpeed"
  c_ID3DXAnimationController_KeyTrackSpeed::Ptr ID3DXAnimationController -> UINT -> FLOAT -> Double -> Double -> D3DXTRANSITION_TYPE -> IO D3DXEVENTHANDLE
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_KeyTrackWeight"
  c_ID3DXAnimationController_KeyTrackWeight::Ptr ID3DXAnimationController -> UINT -> FLOAT -> Double -> Double -> D3DXTRANSITION_TYPE -> IO D3DXEVENTHANDLE
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_RegisterAnimationOutput"
  c_ID3DXAnimationController_RegisterAnimationOutput::Ptr ID3DXAnimationController -> LPCSTR -> Ptr D3DXMATRIX -> Ptr D3DXVECTOR3 -> Ptr D3DXQUATERNION -> Ptr D3DXVECTOR3 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_RegisterAnimationSet"
  c_ID3DXAnimationController_RegisterAnimationSet::Ptr ID3DXAnimationController -> LPD3DXANIMATIONSET -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_ResetTime"
  c_ID3DXAnimationController_ResetTime::Ptr ID3DXAnimationController -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_SetPriorityBlend"
  c_ID3DXAnimationController_SetPriorityBlend::Ptr ID3DXAnimationController -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_SetTrackAnimationSet"
  c_ID3DXAnimationController_SetTrackAnimationSet::Ptr ID3DXAnimationController -> UINT -> LPD3DXANIMATIONSET -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_SetTrackDesc"
  c_ID3DXAnimationController_SetTrackDesc::Ptr ID3DXAnimationController -> UINT -> LPD3DXTRACK_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_SetTrackEnable"
  c_ID3DXAnimationController_SetTrackEnable::Ptr ID3DXAnimationController -> UINT -> BOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_SetTrackPosition"
  c_ID3DXAnimationController_SetTrackPosition::Ptr ID3DXAnimationController -> UINT -> Double -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_SetTrackPriority"
  c_ID3DXAnimationController_SetTrackPriority::Ptr ID3DXAnimationController -> UINT -> D3DXPRIORITY_TYPE -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_SetTrackSpeed"
  c_ID3DXAnimationController_SetTrackSpeed::Ptr ID3DXAnimationController -> UINT -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_SetTrackWeight"
  c_ID3DXAnimationController_SetTrackWeight::Ptr ID3DXAnimationController -> UINT -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_UnkeyAllPriorityBlends"
  c_ID3DXAnimationController_UnkeyAllPriorityBlends::Ptr ID3DXAnimationController -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_UnkeyAllTrackEvents"
  c_ID3DXAnimationController_UnkeyAllTrackEvents::Ptr ID3DXAnimationController -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_UnkeyEvent"
  c_ID3DXAnimationController_UnkeyEvent::Ptr ID3DXAnimationController -> D3DXEVENTHANDLE -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_UnregisterAnimationSet"
  c_ID3DXAnimationController_UnregisterAnimationSet::Ptr ID3DXAnimationController -> LPD3DXANIMATIONSET -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationController_ValidateEvent"
  c_ID3DXAnimationController_ValidateEvent::Ptr ID3DXAnimationController -> D3DXEVENTHANDLE -> IO HRESULT
type LPID3DXAnimationController = Ptr ID3DXAnimationController
type LPD3DXANIMATIONCONTROLLER = Ptr ID3DXAnimationController


data ID3DXAnimationSet = ID3DXAnimationSet deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXAnimationSet_GetAnimationIndexByName"
  c_ID3DXAnimationSet_GetAnimationIndexByName::Ptr ID3DXAnimationSet -> LPCSTR -> Ptr UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationSet_GetAnimationNameByIndex"
  c_ID3DXAnimationSet_GetAnimationNameByIndex::Ptr ID3DXAnimationSet -> UINT -> Ptr LPCSTR -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationSet_GetCallback"
  c_ID3DXAnimationSet_GetCallback::Ptr ID3DXAnimationSet -> Double -> DWORD -> Ptr Double -> Ptr LPVOID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXAnimationSet_GetName"
  c_ID3DXAnimationSet_GetName::Ptr ID3DXAnimationSet -> IO LPCSTR
foreign import ccall unsafe "fake.h c_ID3DXAnimationSet_GetNumAnimations"
  c_ID3DXAnimationSet_GetNumAnimations::Ptr ID3DXAnimationSet -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXAnimationSet_GetPeriod"
  c_ID3DXAnimationSet_GetPeriod::Ptr ID3DXAnimationSet -> IO Double
foreign import ccall unsafe "fake.h c_ID3DXAnimationSet_GetPeriodicPosition"
  c_ID3DXAnimationSet_GetPeriodicPosition::Ptr ID3DXAnimationSet -> Double -> IO Double
foreign import ccall unsafe "fake.h c_ID3DXAnimationSet_GetSRT"
  c_ID3DXAnimationSet_GetSRT::Ptr ID3DXAnimationSet -> Double -> UINT -> Ptr D3DXVECTOR3 -> Ptr D3DXQUATERNION -> Ptr D3DXVECTOR3 -> IO HRESULT
type LPID3DXAnimationSet = Ptr ID3DXAnimationSet
type LPD3DXANIMATIONSET = Ptr ID3DXAnimationSet


data ID3DXBaseEffect = ID3DXBaseEffect deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetAnnotation"
  c_ID3DXBaseEffect_GetAnnotation::Ptr ID3DXBaseEffect -> D3DXHANDLE -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetAnnotationByName"
  c_ID3DXBaseEffect_GetAnnotationByName::Ptr ID3DXBaseEffect -> D3DXHANDLE -> LPCSTR -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetBool"
  c_ID3DXBaseEffect_GetBool::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr BOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetBoolArray"
  c_ID3DXBaseEffect_GetBoolArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr BOOL -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetDesc"
  c_ID3DXBaseEffect_GetDesc::Ptr ID3DXBaseEffect -> Ptr D3DXEFFECT_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetFloat"
  c_ID3DXBaseEffect_GetFloat::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetFloatArray"
  c_ID3DXBaseEffect_GetFloatArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr FLOAT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetFunction"
  c_ID3DXBaseEffect_GetFunction::Ptr ID3DXBaseEffect -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetFunctionByName"
  c_ID3DXBaseEffect_GetFunctionByName::Ptr ID3DXBaseEffect -> LPCSTR -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetFunctionDesc"
  c_ID3DXBaseEffect_GetFunctionDesc::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXFUNCTION_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetInt"
  c_ID3DXBaseEffect_GetInt::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr INT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetIntArray"
  c_ID3DXBaseEffect_GetIntArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr INT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetMatrix"
  c_ID3DXBaseEffect_GetMatrix::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetMatrixArray"
  c_ID3DXBaseEffect_GetMatrixArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXMATRIX -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetMatrixPointerArray"
  c_ID3DXBaseEffect_GetMatrixPointerArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr (Ptr D3DXMATRIX) -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetMatrixTranspose"
  c_ID3DXBaseEffect_GetMatrixTranspose::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetMatrixTransposeArray"
  c_ID3DXBaseEffect_GetMatrixTransposeArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXMATRIX -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetMatrixTransposePointerArray"
  c_ID3DXBaseEffect_GetMatrixTransposePointerArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr (Ptr D3DXMATRIX) -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetParameter"
  c_ID3DXBaseEffect_GetParameter::Ptr ID3DXBaseEffect -> D3DXHANDLE -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetParameterByName"
  c_ID3DXBaseEffect_GetParameterByName::Ptr ID3DXBaseEffect -> D3DXHANDLE -> LPCSTR -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetParameterBySemantic"
  c_ID3DXBaseEffect_GetParameterBySemantic::Ptr ID3DXBaseEffect -> D3DXHANDLE -> LPCSTR -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetParameterDesc"
  c_ID3DXBaseEffect_GetParameterDesc::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXPARAMETER_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetParameterElement"
  c_ID3DXBaseEffect_GetParameterElement::Ptr ID3DXBaseEffect -> D3DXHANDLE -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetPass"
  c_ID3DXBaseEffect_GetPass::Ptr ID3DXBaseEffect -> D3DXHANDLE -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetPassByName"
  c_ID3DXBaseEffect_GetPassByName::Ptr ID3DXBaseEffect -> D3DXHANDLE -> LPCSTR -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetPassDesc"
  c_ID3DXBaseEffect_GetPassDesc::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXPASS_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetPixelShader"
  c_ID3DXBaseEffect_GetPixelShader::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr LPDIRECT3DPIXELSHADER9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetString"
  c_ID3DXBaseEffect_GetString::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr LPCSTR -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetTechnique"
  c_ID3DXBaseEffect_GetTechnique::Ptr ID3DXBaseEffect -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetTechniqueByName"
  c_ID3DXBaseEffect_GetTechniqueByName::Ptr ID3DXBaseEffect -> LPCSTR -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetTechniqueDesc"
  c_ID3DXBaseEffect_GetTechniqueDesc::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXTECHNIQUE_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetTexture"
  c_ID3DXBaseEffect_GetTexture::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr LPDIRECT3DBASETEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetValue"
  c_ID3DXBaseEffect_GetValue::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr () -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetVector"
  c_ID3DXBaseEffect_GetVector::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXVECTOR4 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetVectorArray"
  c_ID3DXBaseEffect_GetVectorArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXVECTOR4 -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_GetVertexShader"
  c_ID3DXBaseEffect_GetVertexShader::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr LPDIRECT3DVERTEXSHADER9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetArrayRange"
  c_ID3DXBaseEffect_SetArrayRange::Ptr ID3DXBaseEffect -> D3DXHANDLE -> UINT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetBool"
  c_ID3DXBaseEffect_SetBool::Ptr ID3DXBaseEffect -> D3DXHANDLE -> BOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetBoolArray"
  c_ID3DXBaseEffect_SetBoolArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr BOOL -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetFloat"
  c_ID3DXBaseEffect_SetFloat::Ptr ID3DXBaseEffect -> D3DXHANDLE -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetFloatArray"
  c_ID3DXBaseEffect_SetFloatArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr FLOAT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetInt"
  c_ID3DXBaseEffect_SetInt::Ptr ID3DXBaseEffect -> D3DXHANDLE -> INT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetIntArray"
  c_ID3DXBaseEffect_SetIntArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr INT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetMatrix"
  c_ID3DXBaseEffect_SetMatrix::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetMatrixArray"
  c_ID3DXBaseEffect_SetMatrixArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXMATRIX -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetMatrixPointerArray"
  c_ID3DXBaseEffect_SetMatrixPointerArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr (Ptr D3DXMATRIX) -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetMatrixTranspose"
  c_ID3DXBaseEffect_SetMatrixTranspose::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetMatrixTransposeArray"
  c_ID3DXBaseEffect_SetMatrixTransposeArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXMATRIX -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetMatrixTransposePointerArray"
  c_ID3DXBaseEffect_SetMatrixTransposePointerArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr (Ptr D3DXMATRIX) -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetString"
  c_ID3DXBaseEffect_SetString::Ptr ID3DXBaseEffect -> D3DXHANDLE -> LPCSTR -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetTexture"
  c_ID3DXBaseEffect_SetTexture::Ptr ID3DXBaseEffect -> D3DXHANDLE -> LPDIRECT3DBASETEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetValue"
  c_ID3DXBaseEffect_SetValue::Ptr ID3DXBaseEffect -> D3DXHANDLE -> LPCVOID -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetVector"
  c_ID3DXBaseEffect_SetVector::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXVECTOR4 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseEffect_SetVectorArray"
  c_ID3DXBaseEffect_SetVectorArray::Ptr ID3DXBaseEffect -> D3DXHANDLE -> Ptr D3DXVECTOR4 -> UINT -> IO HRESULT
type LPID3DXBaseEffect = Ptr ID3DXBaseEffect
type LPD3DXBASEEFFECT = Ptr ID3DXBaseEffect


data ID3DXBaseMesh = ID3DXBaseMesh deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_CloneMesh"
  c_ID3DXBaseMesh_CloneMesh::Ptr ID3DXBaseMesh -> DWORD -> Ptr D3DVERTEXELEMENT9 -> LPDIRECT3DDEVICE9 -> Ptr LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_CloneMeshFVF"
  c_ID3DXBaseMesh_CloneMeshFVF::Ptr ID3DXBaseMesh -> DWORD -> DWORD -> LPDIRECT3DDEVICE9 -> Ptr LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_ConvertAdjacencyToPointReps"
  c_ID3DXBaseMesh_ConvertAdjacencyToPointReps::Ptr ID3DXBaseMesh -> Ptr DWORD -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_ConvertPointRepsToAdjacency"
  c_ID3DXBaseMesh_ConvertPointRepsToAdjacency::Ptr ID3DXBaseMesh -> Ptr DWORD -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_DrawSubset"
  c_ID3DXBaseMesh_DrawSubset::Ptr ID3DXBaseMesh -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GenerateAdjacency"
  c_ID3DXBaseMesh_GenerateAdjacency::Ptr ID3DXBaseMesh -> FLOAT -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetAttributeTable"
  c_ID3DXBaseMesh_GetAttributeTable::Ptr ID3DXBaseMesh -> Ptr D3DXATTRIBUTERANGE -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetDeclaration"
  c_ID3DXBaseMesh_GetDeclaration::Ptr ID3DXBaseMesh -> Ptr D3DVERTEXELEMENT9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetDevice"
  c_ID3DXBaseMesh_GetDevice::Ptr ID3DXBaseMesh -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetFVF"
  c_ID3DXBaseMesh_GetFVF::Ptr ID3DXBaseMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetIndexBuffer"
  c_ID3DXBaseMesh_GetIndexBuffer::Ptr ID3DXBaseMesh -> Ptr LPDIRECT3DINDEXBUFFER9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetNumBytesPerVertex"
  c_ID3DXBaseMesh_GetNumBytesPerVertex::Ptr ID3DXBaseMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetNumFaces"
  c_ID3DXBaseMesh_GetNumFaces::Ptr ID3DXBaseMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetNumVertices"
  c_ID3DXBaseMesh_GetNumVertices::Ptr ID3DXBaseMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetOptions"
  c_ID3DXBaseMesh_GetOptions::Ptr ID3DXBaseMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_GetVertexBuffer"
  c_ID3DXBaseMesh_GetVertexBuffer::Ptr ID3DXBaseMesh -> Ptr LPDIRECT3DVERTEXBUFFER9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_LockIndexBuffer"
  c_ID3DXBaseMesh_LockIndexBuffer::Ptr ID3DXBaseMesh -> DWORD -> Ptr LPVOID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_LockVertexBuffer"
  c_ID3DXBaseMesh_LockVertexBuffer::Ptr ID3DXBaseMesh -> DWORD -> Ptr LPVOID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_UnlockIndexBuffer"
  c_ID3DXBaseMesh_UnlockIndexBuffer::Ptr ID3DXBaseMesh -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_UnlockVertexBuffer"
  c_ID3DXBaseMesh_UnlockVertexBuffer::Ptr ID3DXBaseMesh -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXBaseMesh_UpdateSemantics"
  c_ID3DXBaseMesh_UpdateSemantics::Ptr ID3DXBaseMesh -> Ptr D3DVERTEXELEMENT9 -> IO HRESULT
type LPID3DXBaseMesh = Ptr ID3DXBaseMesh
type LPD3DXBASEMESH = Ptr ID3DXBaseMesh


data ID3DXBuffer = ID3DXBuffer deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXBuffer_GetBufferPointer"
  c_ID3DXBuffer_GetBufferPointer::Ptr ID3DXBuffer -> IO LPVOID
foreign import ccall unsafe "fake.h c_ID3DXBuffer_GetBufferSize"
  c_ID3DXBuffer_GetBufferSize::Ptr ID3DXBuffer -> IO DWORD
type LPID3DXBuffer = Ptr ID3DXBuffer
type LPD3DXBUFFER = Ptr ID3DXBuffer


data ID3DXCompressedAnimationSet = ID3DXCompressedAnimationSet deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXCompressedAnimationSet_GetCallbackKeys"
  c_ID3DXCompressedAnimationSet_GetCallbackKeys::Ptr ID3DXCompressedAnimationSet -> LPD3DXKEY_CALLBACK -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXCompressedAnimationSet_GetCompressedData"
  c_ID3DXCompressedAnimationSet_GetCompressedData::Ptr ID3DXCompressedAnimationSet -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXCompressedAnimationSet_GetNumCallbackKeys"
  c_ID3DXCompressedAnimationSet_GetNumCallbackKeys::Ptr ID3DXCompressedAnimationSet -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXCompressedAnimationSet_GetPlaybackType"
  c_ID3DXCompressedAnimationSet_GetPlaybackType::Ptr ID3DXCompressedAnimationSet -> IO D3DXPLAYBACK_TYPE
foreign import ccall unsafe "fake.h c_ID3DXCompressedAnimationSet_GetSourceTicksPerSecond"
  c_ID3DXCompressedAnimationSet_GetSourceTicksPerSecond::Ptr ID3DXCompressedAnimationSet -> IO Double
type LPID3DXCompressedAnimationSet = Ptr ID3DXCompressedAnimationSet
type LPD3DXCOMPRESSEDANIMATIONSET = Ptr ID3DXCompressedAnimationSet


data ID3DXConstantTable = ID3DXConstantTable deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_GetBufferPointer"
  c_ID3DXConstantTable_GetBufferPointer::Ptr ID3DXConstantTable -> IO LPVOID
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_GetBufferSize"
  c_ID3DXConstantTable_GetBufferSize::Ptr ID3DXConstantTable -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_GetConstant"
  c_ID3DXConstantTable_GetConstant::Ptr ID3DXConstantTable -> D3DXHANDLE -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_GetConstantByName"
  c_ID3DXConstantTable_GetConstantByName::Ptr ID3DXConstantTable -> D3DXHANDLE -> LPCSTR -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_GetConstantDesc"
  c_ID3DXConstantTable_GetConstantDesc::Ptr ID3DXConstantTable -> D3DXHANDLE -> Ptr D3DXCONSTANT_DESC -> Ptr UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_GetConstantElement"
  c_ID3DXConstantTable_GetConstantElement::Ptr ID3DXConstantTable -> D3DXHANDLE -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_GetDesc"
  c_ID3DXConstantTable_GetDesc::Ptr ID3DXConstantTable -> Ptr D3DXCONSTANTTABLE_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_GetSamplerIndex"
  c_ID3DXConstantTable_GetSamplerIndex::Ptr ID3DXConstantTable -> D3DXHANDLE -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetBool"
  c_ID3DXConstantTable_SetBool::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> BOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetBoolArray"
  c_ID3DXConstantTable_SetBoolArray::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr BOOL -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetDefaults"
  c_ID3DXConstantTable_SetDefaults::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetFloat"
  c_ID3DXConstantTable_SetFloat::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetFloatArray"
  c_ID3DXConstantTable_SetFloatArray::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr FLOAT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetInt"
  c_ID3DXConstantTable_SetInt::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> INT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetIntArray"
  c_ID3DXConstantTable_SetIntArray::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr INT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetMatrix"
  c_ID3DXConstantTable_SetMatrix::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetMatrixArray"
  c_ID3DXConstantTable_SetMatrixArray::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr D3DXMATRIX -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetMatrixPointerArray"
  c_ID3DXConstantTable_SetMatrixPointerArray::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr (Ptr D3DXMATRIX) -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetMatrixTranspose"
  c_ID3DXConstantTable_SetMatrixTranspose::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetMatrixTransposeArray"
  c_ID3DXConstantTable_SetMatrixTransposeArray::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr D3DXMATRIX -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetMatrixTransposePointerArray"
  c_ID3DXConstantTable_SetMatrixTransposePointerArray::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr (Ptr D3DXMATRIX) -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetValue"
  c_ID3DXConstantTable_SetValue::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> LPCVOID -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetVector"
  c_ID3DXConstantTable_SetVector::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr D3DXVECTOR4 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXConstantTable_SetVectorArray"
  c_ID3DXConstantTable_SetVectorArray::Ptr ID3DXConstantTable -> LPDIRECT3DDEVICE9 -> D3DXHANDLE -> Ptr D3DXVECTOR4 -> UINT -> IO HRESULT
type LPID3DXConstantTable = Ptr ID3DXConstantTable
type LPD3DXCONSTANTTABLE = Ptr ID3DXConstantTable


data ID3DXEffect = ID3DXEffect deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXEffect_ApplyParameterBlock"
  c_ID3DXEffect_ApplyParameterBlock::Ptr ID3DXEffect -> D3DXHANDLE -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_Begin"
  c_ID3DXEffect_Begin::Ptr ID3DXEffect -> Ptr UINT -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_BeginParameterBlock"
  c_ID3DXEffect_BeginParameterBlock::Ptr ID3DXEffect -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_BeginPass"
  c_ID3DXEffect_BeginPass::Ptr ID3DXEffect -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_CloneEffect"
  c_ID3DXEffect_CloneEffect::Ptr ID3DXEffect -> LPDIRECT3DDEVICE9 -> Ptr LPD3DXEFFECT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_CommitChanges"
  c_ID3DXEffect_CommitChanges::Ptr ID3DXEffect -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_DeleteParameterBlock"
  c_ID3DXEffect_DeleteParameterBlock::Ptr ID3DXEffect -> D3DXHANDLE -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_End"
  c_ID3DXEffect_End::Ptr ID3DXEffect -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_EndParameterBlock"
  c_ID3DXEffect_EndParameterBlock::Ptr ID3DXEffect -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXEffect_EndPass"
  c_ID3DXEffect_EndPass::Ptr ID3DXEffect -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_FindNextValidTechnique"
  c_ID3DXEffect_FindNextValidTechnique::Ptr ID3DXEffect -> D3DXHANDLE -> Ptr D3DXHANDLE -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_GetCurrentTechnique"
  c_ID3DXEffect_GetCurrentTechnique::Ptr ID3DXEffect -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXEffect_GetDevice"
  c_ID3DXEffect_GetDevice::Ptr ID3DXEffect -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_GetPool"
  c_ID3DXEffect_GetPool::Ptr ID3DXEffect -> Ptr LPD3DXEFFECTPOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_GetStateManager"
  c_ID3DXEffect_GetStateManager::Ptr ID3DXEffect -> Ptr LPD3DXEFFECTSTATEMANAGER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_IsParameterUsed"
  c_ID3DXEffect_IsParameterUsed::Ptr ID3DXEffect -> D3DXHANDLE -> D3DXHANDLE -> IO BOOL
foreign import ccall unsafe "fake.h c_ID3DXEffect_OnLostDevice"
  c_ID3DXEffect_OnLostDevice::Ptr ID3DXEffect -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_OnResetDevice"
  c_ID3DXEffect_OnResetDevice::Ptr ID3DXEffect -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_SetRawValue"
  c_ID3DXEffect_SetRawValue::Ptr ID3DXEffect -> D3DXHANDLE -> Ptr () -> DWORD -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_SetStateManager"
  c_ID3DXEffect_SetStateManager::Ptr ID3DXEffect -> LPD3DXEFFECTSTATEMANAGER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_SetTechnique"
  c_ID3DXEffect_SetTechnique::Ptr ID3DXEffect -> D3DXHANDLE -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffect_ValidateTechnique"
  c_ID3DXEffect_ValidateTechnique::Ptr ID3DXEffect -> D3DXHANDLE -> IO HRESULT
type LPID3DXEffect = Ptr ID3DXEffect
type LPD3DXEFFECT = Ptr ID3DXEffect


data ID3DXEffectCompiler = ID3DXEffectCompiler deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXEffectCompiler_CompileEffect"
  c_ID3DXEffectCompiler_CompileEffect::Ptr ID3DXEffectCompiler -> DWORD -> Ptr LPD3DXBUFFER -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectCompiler_CompileShader"
  c_ID3DXEffectCompiler_CompileShader::Ptr ID3DXEffectCompiler -> D3DXHANDLE -> LPCSTR -> DWORD -> Ptr LPD3DXBUFFER -> Ptr LPD3DXBUFFER -> Ptr LPD3DXCONSTANTTABLE -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectCompiler_GetLiteral"
  c_ID3DXEffectCompiler_GetLiteral::Ptr ID3DXEffectCompiler -> D3DXHANDLE -> Ptr BOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectCompiler_SetLiteral"
  c_ID3DXEffectCompiler_SetLiteral::Ptr ID3DXEffectCompiler -> D3DXHANDLE -> BOOL -> IO HRESULT
type LPID3DXEffectCompiler = Ptr ID3DXEffectCompiler
type LPD3DXEFFECTCOMPILER = Ptr ID3DXEffectCompiler


data ID3DXEffectStateManager = ID3DXEffectStateManager deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_LightEnable"
  c_ID3DXEffectStateManager_LightEnable::Ptr ID3DXEffectStateManager -> DWORD -> BOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetFVF"
  c_ID3DXEffectStateManager_SetFVF::Ptr ID3DXEffectStateManager -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetLight"
  c_ID3DXEffectStateManager_SetLight::Ptr ID3DXEffectStateManager -> DWORD -> Ptr D3DLIGHT9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetMaterial"
  c_ID3DXEffectStateManager_SetMaterial::Ptr ID3DXEffectStateManager -> Ptr D3DMATERIAL9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetNPatchMode"
  c_ID3DXEffectStateManager_SetNPatchMode::Ptr ID3DXEffectStateManager -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetPixelShader"
  c_ID3DXEffectStateManager_SetPixelShader::Ptr ID3DXEffectStateManager -> LPDIRECT3DPIXELSHADER9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetPixelShaderConstantB"
  c_ID3DXEffectStateManager_SetPixelShaderConstantB::Ptr ID3DXEffectStateManager -> UINT -> Ptr BOOL -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetPixelShaderConstantF"
  c_ID3DXEffectStateManager_SetPixelShaderConstantF::Ptr ID3DXEffectStateManager -> UINT -> Ptr FLOAT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetPixelShaderConstantI"
  c_ID3DXEffectStateManager_SetPixelShaderConstantI::Ptr ID3DXEffectStateManager -> UINT -> Ptr INT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetRenderState"
  c_ID3DXEffectStateManager_SetRenderState::Ptr ID3DXEffectStateManager -> D3DRENDERSTATETYPE -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetSamplerState"
  c_ID3DXEffectStateManager_SetSamplerState::Ptr ID3DXEffectStateManager -> DWORD -> D3DSAMPLERSTATETYPE -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetTexture"
  c_ID3DXEffectStateManager_SetTexture::Ptr ID3DXEffectStateManager -> DWORD -> LPDIRECT3DBASETEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetTextureStageState"
  c_ID3DXEffectStateManager_SetTextureStageState::Ptr ID3DXEffectStateManager -> DWORD -> D3DTEXTURESTAGESTATETYPE -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetTransform"
  c_ID3DXEffectStateManager_SetTransform::Ptr ID3DXEffectStateManager -> D3DTRANSFORMSTATETYPE -> Ptr D3DMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetVertexShader"
  c_ID3DXEffectStateManager_SetVertexShader::Ptr ID3DXEffectStateManager -> LPDIRECT3DVERTEXSHADER9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetVertexShaderConstantB"
  c_ID3DXEffectStateManager_SetVertexShaderConstantB::Ptr ID3DXEffectStateManager -> UINT -> Ptr BOOL -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetVertexShaderConstantF"
  c_ID3DXEffectStateManager_SetVertexShaderConstantF::Ptr ID3DXEffectStateManager -> UINT -> Ptr FLOAT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXEffectStateManager_SetVertexShaderConstantI"
  c_ID3DXEffectStateManager_SetVertexShaderConstantI::Ptr ID3DXEffectStateManager -> UINT -> Ptr INT -> UINT -> IO HRESULT
type LPID3DXEffectStateManager = Ptr ID3DXEffectStateManager
type LPD3DXEFFECTSTATEMANAGER = Ptr ID3DXEffectStateManager


data ID3DXFont = ID3DXFont deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXFont_DrawText"
  c_ID3DXFont_DrawText::Ptr ID3DXFont -> LPD3DXSPRITE -> LPCTSTR -> INT -> LPRECT -> DWORD -> D3DCOLOR -> IO INT
foreign import ccall unsafe "fake.h c_ID3DXFont_GetDC"
  c_ID3DXFont_GetDC::Ptr ID3DXFont -> IO HDC
foreign import ccall unsafe "fake.h c_ID3DXFont_GetDescW"
  c_ID3DXFont_GetDescW::Ptr ID3DXFont -> Ptr D3DXFONT_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFont_GetDevice"
  c_ID3DXFont_GetDevice::Ptr ID3DXFont -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFont_GetGlyphData"
  c_ID3DXFont_GetGlyphData::Ptr ID3DXFont -> UINT -> Ptr LPDIRECT3DTEXTURE9 -> Ptr RECT -> Ptr POINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFont_GetTextMetrics"
  c_ID3DXFont_GetTextMetrics::Ptr ID3DXFont -> Ptr TEXTMETRIC -> IO BOOL
foreign import ccall unsafe "fake.h c_ID3DXFont_OnLostDevice"
  c_ID3DXFont_OnLostDevice::Ptr ID3DXFont -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFont_OnResetDevice"
  c_ID3DXFont_OnResetDevice::Ptr ID3DXFont -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFont_PreloadCharacters"
  c_ID3DXFont_PreloadCharacters::Ptr ID3DXFont -> UINT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFont_PreloadGlyphs"
  c_ID3DXFont_PreloadGlyphs::Ptr ID3DXFont -> UINT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFont_PreloadTextW"
  c_ID3DXFont_PreloadTextW::Ptr ID3DXFont -> Ptr LPCTSTR -> INT -> IO HRESULT
type LPID3DXFont = Ptr ID3DXFont
type LPD3DXFONT = Ptr ID3DXFont


data ID3DXFile = ID3DXFile deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXFile_CreateEnumObject"
  c_ID3DXFile_CreateEnumObject::Ptr ID3DXFile -> LPCVOID -> D3DXF_FILELOADOPTIONS -> Ptr (Ptr ID3DXFileEnumObject) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFile_CreateSaveObject"
  c_ID3DXFile_CreateSaveObject::Ptr ID3DXFile -> LPCVOID -> D3DXF_FILESAVEOPTIONS -> D3DXF_FILEFORMAT -> Ptr (Ptr ID3DXFileSaveObject) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFile_RegisterEnumTemplates"
  c_ID3DXFile_RegisterEnumTemplates::Ptr ID3DXFile -> Ptr ID3DXFileEnumObject -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFile_RegisterTemplates"
  c_ID3DXFile_RegisterTemplates::Ptr ID3DXFile -> LPCVOID -> SIZE_T -> IO HRESULT
type LPID3DXFile = Ptr ID3DXFile
type LPD3DXFILE = Ptr ID3DXFile


data ID3DXFileData = ID3DXFileData deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXFileData_GetChild"
  c_ID3DXFileData_GetChild::Ptr ID3DXFileData -> SIZE_T -> Ptr (Ptr ID3DXFileData) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileData_GetChildren"
  c_ID3DXFileData_GetChildren::Ptr ID3DXFileData -> Ptr SIZE_T -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileData_GetEnum"
  c_ID3DXFileData_GetEnum::Ptr ID3DXFileData -> Ptr (Ptr ID3DXFileEnumObject) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileData_GetId"
  c_ID3DXFileData_GetId::Ptr ID3DXFileData -> LPGUID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileData_GetName"
  c_ID3DXFileData_GetName::Ptr ID3DXFileData -> LPSTR -> Ptr SIZE_T -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileData_GetType"
  c_ID3DXFileData_GetType::Ptr ID3DXFileData -> Ptr GUID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileData_IsReference"
  c_ID3DXFileData_IsReference::Ptr ID3DXFileData -> IO BOOL
foreign import ccall unsafe "fake.h c_ID3DXFileData_Lock"
  c_ID3DXFileData_Lock::Ptr ID3DXFileData -> Ptr SIZE_T -> Ptr (Ptr ()) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileData_Unlock"
  c_ID3DXFileData_Unlock::Ptr ID3DXFileData -> IO BOOL
type LPID3DXFileData = Ptr ID3DXFileData
type LPD3DXFILEDATA = Ptr ID3DXFileData


data ID3DXFileEnumObject = ID3DXFileEnumObject deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXFileEnumObject_GetChild"
  c_ID3DXFileEnumObject_GetChild::Ptr ID3DXFileEnumObject -> SIZE_T -> Ptr (Ptr ID3DXFileData) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileEnumObject_GetChildren"
  c_ID3DXFileEnumObject_GetChildren::Ptr ID3DXFileEnumObject -> Ptr SIZE_T -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileEnumObject_GetDataObjectById"
  c_ID3DXFileEnumObject_GetDataObjectById::Ptr ID3DXFileEnumObject -> REFGUID -> Ptr LPD3DXFILEDATA -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileEnumObject_GetDataObjectByName"
  c_ID3DXFileEnumObject_GetDataObjectByName::Ptr ID3DXFileEnumObject -> LPCSTR -> Ptr (Ptr ID3DXFileData) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileEnumObject_GetFile"
  c_ID3DXFileEnumObject_GetFile::Ptr ID3DXFileEnumObject -> Ptr (Ptr ID3DXFile) -> IO HRESULT
type LPID3DXFileEnumObject = Ptr ID3DXFileEnumObject
type LPD3DXFILEENUMOBJECT = Ptr ID3DXFileEnumObject


data ID3DXFileSaveData = ID3DXFileSaveData deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXFileSaveData_AddDataObject"
  c_ID3DXFileSaveData_AddDataObject::Ptr ID3DXFileSaveData -> REFGUID -> LPCSTR -> Ptr GUID -> SIZE_T -> LPCVOID -> Ptr (Ptr ID3DXFileSaveData) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileSaveData_AddDataReference"
  c_ID3DXFileSaveData_AddDataReference::Ptr ID3DXFileSaveData -> LPCSTR -> Ptr GUID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileSaveData_GetId"
  c_ID3DXFileSaveData_GetId::Ptr ID3DXFileSaveData -> LPGUID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileSaveData_GetName"
  c_ID3DXFileSaveData_GetName::Ptr ID3DXFileSaveData -> LPSTR -> Ptr SIZE_T -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileSaveData_GetSave"
  c_ID3DXFileSaveData_GetSave::Ptr ID3DXFileSaveData -> Ptr (Ptr ID3DXFileSaveObject) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileSaveData_GetType"
  c_ID3DXFileSaveData_GetType::Ptr ID3DXFileSaveData -> Ptr GUID -> IO HRESULT
type LPID3DXFileSaveData = Ptr ID3DXFileSaveData
type LPD3DXFILESAVEDATA = Ptr ID3DXFileSaveData


data ID3DXFileSaveObject = ID3DXFileSaveObject deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXFileSaveObject_AddDataObject"
  c_ID3DXFileSaveObject_AddDataObject::Ptr ID3DXFileSaveObject -> REFGUID -> LPCSTR -> Ptr GUID -> SIZE_T -> LPCVOID -> Ptr (Ptr ID3DXFileSaveData) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileSaveObject_GetFile"
  c_ID3DXFileSaveObject_GetFile::Ptr ID3DXFileSaveObject -> Ptr (Ptr ID3DXFile) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFileSaveObject_Save"
  c_ID3DXFileSaveObject_Save::Ptr ID3DXFileSaveObject -> IO HRESULT
type LPID3DXFileSaveObject = Ptr ID3DXFileSaveObject
type LPD3DXFILESAVEOBJECT = Ptr ID3DXFileSaveObject


data ID3DXFragmentLinker = ID3DXFragmentLinker deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_AddFragments"
  c_ID3DXFragmentLinker_AddFragments::Ptr ID3DXFragmentLinker -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_ClearCache"
  c_ID3DXFragmentLinker_ClearCache::Ptr ID3DXFragmentLinker -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_GetAllFragments"
  c_ID3DXFragmentLinker_GetAllFragments::Ptr ID3DXFragmentLinker -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_GetDevice"
  c_ID3DXFragmentLinker_GetDevice::Ptr ID3DXFragmentLinker -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_GetFragment"
  c_ID3DXFragmentLinker_GetFragment::Ptr ID3DXFragmentLinker -> D3DXHANDLE -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_GetFragmentDesc"
  c_ID3DXFragmentLinker_GetFragmentDesc::Ptr ID3DXFragmentLinker -> D3DXHANDLE -> LPD3DXFRAGMENT_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_GetFragmentHandleByIndex"
  c_ID3DXFragmentLinker_GetFragmentHandleByIndex::Ptr ID3DXFragmentLinker -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_GetFragmentHandleByName"
  c_ID3DXFragmentLinker_GetFragmentHandleByName::Ptr ID3DXFragmentLinker -> LPCSTR -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_GetNumberOfFragments"
  c_ID3DXFragmentLinker_GetNumberOfFragments::Ptr ID3DXFragmentLinker -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_LinkPixelShader"
  c_ID3DXFragmentLinker_LinkPixelShader::Ptr ID3DXFragmentLinker -> LPCSTR -> DWORD -> Ptr D3DXHANDLE -> UINT -> Ptr LPDIRECT3DPIXELSHADER9 -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_LinkShader"
  c_ID3DXFragmentLinker_LinkShader::Ptr ID3DXFragmentLinker -> LPCSTR -> DWORD -> Ptr D3DXHANDLE -> UINT -> Ptr LPD3DXBUFFER -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXFragmentLinker_LinkVertexShader"
  c_ID3DXFragmentLinker_LinkVertexShader::Ptr ID3DXFragmentLinker -> LPCSTR -> DWORD -> Ptr D3DXHANDLE -> UINT -> Ptr LPDIRECT3DVERTEXSHADER9 -> Ptr LPD3DXBUFFER -> IO HRESULT
type LPID3DXFragmentLinker = Ptr ID3DXFragmentLinker
type LPD3DXFRAGMENTLINKER = Ptr ID3DXFragmentLinker


data ID3DXInclude = ID3DXInclude deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXInclude_Close"
  c_ID3DXInclude_Close::Ptr ID3DXInclude -> LPCVOID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXInclude_Open"
  c_ID3DXInclude_Open::Ptr ID3DXInclude -> D3DXINCLUDE_TYPE -> LPCSTR -> LPCVOID -> Ptr LPCVOID -> Ptr UINT -> IO HRESULT
type LPID3DXInclude = Ptr ID3DXInclude
type LPD3DXINCLUDE = Ptr ID3DXInclude


data ID3DXKeyframedAnimationSet = ID3DXKeyframedAnimationSet deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_Compress"
  c_ID3DXKeyframedAnimationSet_Compress::Ptr ID3DXKeyframedAnimationSet -> DWORD -> FLOAT -> LPD3DXFRAME -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetCallbackKey"
  c_ID3DXKeyframedAnimationSet_GetCallbackKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> LPD3DXKEY_CALLBACK -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetCallbackKeys"
  c_ID3DXKeyframedAnimationSet_GetCallbackKeys::Ptr ID3DXKeyframedAnimationSet -> LPD3DXKEY_CALLBACK -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetNumCallbackKeys"
  c_ID3DXKeyframedAnimationSet_GetNumCallbackKeys::Ptr ID3DXKeyframedAnimationSet -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetNumRotationKeys"
  c_ID3DXKeyframedAnimationSet_GetNumRotationKeys::Ptr ID3DXKeyframedAnimationSet -> UINT -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetNumScaleKeys"
  c_ID3DXKeyframedAnimationSet_GetNumScaleKeys::Ptr ID3DXKeyframedAnimationSet -> UINT -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetNumTranslationKeys"
  c_ID3DXKeyframedAnimationSet_GetNumTranslationKeys::Ptr ID3DXKeyframedAnimationSet -> UINT -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetPlaybackType"
  c_ID3DXKeyframedAnimationSet_GetPlaybackType::Ptr ID3DXKeyframedAnimationSet -> IO D3DXPLAYBACK_TYPE
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetRotationKey"
  c_ID3DXKeyframedAnimationSet_GetRotationKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> UINT -> LPD3DXKEY_QUATERNION -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetRotationKeys"
  c_ID3DXKeyframedAnimationSet_GetRotationKeys::Ptr ID3DXKeyframedAnimationSet -> UINT -> LPD3DXKEY_QUATERNION -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetScaleKey"
  c_ID3DXKeyframedAnimationSet_GetScaleKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> UINT -> LPD3DXKEY_VECTOR3 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetScaleKeys"
  c_ID3DXKeyframedAnimationSet_GetScaleKeys::Ptr ID3DXKeyframedAnimationSet -> UINT -> LPD3DXKEY_VECTOR3 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetSourceTicksPerSecond"
  c_ID3DXKeyframedAnimationSet_GetSourceTicksPerSecond::Ptr ID3DXKeyframedAnimationSet -> IO Double
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetTranslationKey"
  c_ID3DXKeyframedAnimationSet_GetTranslationKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> UINT -> LPD3DXKEY_VECTOR3 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_GetTranslationKeys"
  c_ID3DXKeyframedAnimationSet_GetTranslationKeys::Ptr ID3DXKeyframedAnimationSet -> UINT -> LPD3DXKEY_VECTOR3 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_RegisterAnimationSRTKeys"
  c_ID3DXKeyframedAnimationSet_RegisterAnimationSRTKeys::Ptr ID3DXKeyframedAnimationSet -> LPCSTR -> UINT -> UINT -> UINT -> Ptr LPD3DXKEY_VECTOR3 -> Ptr LPD3DXKEY_QUATERNION -> Ptr LPD3DXKEY_VECTOR3 -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_SetCallbackKey"
  c_ID3DXKeyframedAnimationSet_SetCallbackKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> LPD3DXKEY_CALLBACK -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_SetRotationKey"
  c_ID3DXKeyframedAnimationSet_SetRotationKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> UINT -> LPD3DXKEY_QUATERNION -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_SetScaleKey"
  c_ID3DXKeyframedAnimationSet_SetScaleKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> UINT -> LPD3DXKEY_VECTOR3 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_SetTranslationKey"
  c_ID3DXKeyframedAnimationSet_SetTranslationKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> UINT -> LPD3DXKEY_VECTOR3 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_UnregisterAnimation"
  c_ID3DXKeyframedAnimationSet_UnregisterAnimation::Ptr ID3DXKeyframedAnimationSet -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_UnregisterRotationKey"
  c_ID3DXKeyframedAnimationSet_UnregisterRotationKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_UnregisterScaleKey"
  c_ID3DXKeyframedAnimationSet_UnregisterScaleKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXKeyframedAnimationSet_UnregisterTranslationKey"
  c_ID3DXKeyframedAnimationSet_UnregisterTranslationKey::Ptr ID3DXKeyframedAnimationSet -> UINT -> UINT -> IO HRESULT
type LPID3DXKeyframedAnimationSet = Ptr ID3DXKeyframedAnimationSet
type LPD3DXKEYFRAMEDANIMATIONSET = Ptr ID3DXKeyframedAnimationSet


data ID3DXLine = ID3DXLine deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXLine_Begin"
  c_ID3DXLine_Begin::Ptr ID3DXLine -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_Draw"
  c_ID3DXLine_Draw::Ptr ID3DXLine -> Ptr D3DXVECTOR2 -> DWORD -> D3DCOLOR -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_DrawTransform"
  c_ID3DXLine_DrawTransform::Ptr ID3DXLine -> Ptr D3DXVECTOR3 -> DWORD -> Ptr D3DXMATRIX -> D3DCOLOR -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_End"
  c_ID3DXLine_End::Ptr ID3DXLine -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_GetAntialias"
  c_ID3DXLine_GetAntialias::Ptr ID3DXLine -> IO BOOL
foreign import ccall unsafe "fake.h c_ID3DXLine_GetDevice"
  c_ID3DXLine_GetDevice::Ptr ID3DXLine -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_GetGLLines"
  c_ID3DXLine_GetGLLines::Ptr ID3DXLine -> IO BOOL
foreign import ccall unsafe "fake.h c_ID3DXLine_GetPattern"
  c_ID3DXLine_GetPattern::Ptr ID3DXLine -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXLine_GetPatternScale"
  c_ID3DXLine_GetPatternScale::Ptr ID3DXLine -> IO FLOAT
foreign import ccall unsafe "fake.h c_ID3DXLine_GetWidth"
  c_ID3DXLine_GetWidth::Ptr ID3DXLine -> IO FLOAT
foreign import ccall unsafe "fake.h c_ID3DXLine_OnLostDevice"
  c_ID3DXLine_OnLostDevice::Ptr ID3DXLine -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_OnResetDevice"
  c_ID3DXLine_OnResetDevice::Ptr ID3DXLine -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_SetAntialias"
  c_ID3DXLine_SetAntialias::Ptr ID3DXLine -> BOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_SetGLLines"
  c_ID3DXLine_SetGLLines::Ptr ID3DXLine -> BOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_SetPattern"
  c_ID3DXLine_SetPattern::Ptr ID3DXLine -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_SetPatternScale"
  c_ID3DXLine_SetPatternScale::Ptr ID3DXLine -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXLine_SetWidth"
  c_ID3DXLine_SetWidth::Ptr ID3DXLine -> FLOAT -> IO HRESULT
type LPID3DXLine = Ptr ID3DXLine
type LPD3DXLINE = Ptr ID3DXLine


data ID3DXMesh = ID3DXMesh deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXMesh_LockAttributeBuffer"
  c_ID3DXMesh_LockAttributeBuffer::Ptr ID3DXMesh -> DWORD -> Ptr (Ptr DWORD) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXMesh_Optimize"
  c_ID3DXMesh_Optimize::Ptr ID3DXMesh -> DWORD -> Ptr DWORD -> Ptr DWORD -> Ptr DWORD -> Ptr LPD3DXBUFFER -> Ptr LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXMesh_OptimizeInplace"
  c_ID3DXMesh_OptimizeInplace::Ptr ID3DXMesh -> DWORD -> Ptr DWORD -> Ptr DWORD -> Ptr DWORD -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXMesh_SetAttributeTable"
  c_ID3DXMesh_SetAttributeTable::Ptr ID3DXMesh -> Ptr D3DXATTRIBUTERANGE -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXMesh_UnlockAttributeBuffer"
  c_ID3DXMesh_UnlockAttributeBuffer::Ptr ID3DXMesh -> IO HRESULT
type LPID3DXMesh = Ptr ID3DXMesh
type LPD3DXMESH = Ptr ID3DXMesh


data ID3DXPatchMesh = ID3DXPatchMesh deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_CloneMesh"
  c_ID3DXPatchMesh_CloneMesh::Ptr ID3DXPatchMesh -> DWORD -> Ptr D3DVERTEXELEMENT9 -> Ptr LPD3DXPATCHMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GenerateAdjacency"
  c_ID3DXPatchMesh_GenerateAdjacency::Ptr ID3DXPatchMesh -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetControlVerticesPerPatch"
  c_ID3DXPatchMesh_GetControlVerticesPerPatch::Ptr ID3DXPatchMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetDeclaration"
  c_ID3DXPatchMesh_GetDeclaration::Ptr ID3DXPatchMesh -> Ptr LPD3DVERTEXELEMENT9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetDevice"
  c_ID3DXPatchMesh_GetDevice::Ptr ID3DXPatchMesh -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetDisplaceParam"
  c_ID3DXPatchMesh_GetDisplaceParam::Ptr ID3DXPatchMesh -> Ptr LPDIRECT3DBASETEXTURE9 -> Ptr D3DTEXTUREFILTERTYPE -> Ptr D3DTEXTUREFILTERTYPE -> Ptr D3DTEXTUREFILTERTYPE -> Ptr D3DTEXTUREADDRESS -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetIndexBuffer"
  c_ID3DXPatchMesh_GetIndexBuffer::Ptr ID3DXPatchMesh -> Ptr LPDIRECT3DINDEXBUFFER9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetNumPatches"
  c_ID3DXPatchMesh_GetNumPatches::Ptr ID3DXPatchMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetNumVertices"
  c_ID3DXPatchMesh_GetNumVertices::Ptr ID3DXPatchMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetOptions"
  c_ID3DXPatchMesh_GetOptions::Ptr ID3DXPatchMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetPatchInfo"
  c_ID3DXPatchMesh_GetPatchInfo::Ptr ID3DXPatchMesh -> LPD3DXPATCHINFO -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetTessSize"
  c_ID3DXPatchMesh_GetTessSize::Ptr ID3DXPatchMesh -> FLOAT -> DWORD -> Ptr DWORD -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_GetVertexBuffer"
  c_ID3DXPatchMesh_GetVertexBuffer::Ptr ID3DXPatchMesh -> Ptr LPDIRECT3DVERTEXBUFFER9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_LockAttributeBuffer"
  c_ID3DXPatchMesh_LockAttributeBuffer::Ptr ID3DXPatchMesh -> DWORD -> Ptr (Ptr DWORD) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_LockIndexBuffer"
  c_ID3DXPatchMesh_LockIndexBuffer::Ptr ID3DXPatchMesh -> DWORD -> Ptr LPVOID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_LockVertexBuffer"
  c_ID3DXPatchMesh_LockVertexBuffer::Ptr ID3DXPatchMesh -> DWORD -> Ptr LPVOID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_Optimize"
  c_ID3DXPatchMesh_Optimize::Ptr ID3DXPatchMesh -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_SetDisplaceParam"
  c_ID3DXPatchMesh_SetDisplaceParam::Ptr ID3DXPatchMesh -> LPDIRECT3DBASETEXTURE9 -> D3DTEXTUREFILTERTYPE -> D3DTEXTUREFILTERTYPE -> D3DTEXTUREFILTERTYPE -> D3DTEXTUREADDRESS -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_Tessellate"
  c_ID3DXPatchMesh_Tessellate::Ptr ID3DXPatchMesh -> FLOAT -> LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_TessellateAdaptive"
  c_ID3DXPatchMesh_TessellateAdaptive::Ptr ID3DXPatchMesh -> Ptr D3DXVECTOR4 -> DWORD -> DWORD -> LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_UnlockAttributeBuffer"
  c_ID3DXPatchMesh_UnlockAttributeBuffer::Ptr ID3DXPatchMesh -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_UnlockIndexBuffer"
  c_ID3DXPatchMesh_UnlockIndexBuffer::Ptr ID3DXPatchMesh -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPatchMesh_UnlockVertexBuffer"
  c_ID3DXPatchMesh_UnlockVertexBuffer::Ptr ID3DXPatchMesh -> IO HRESULT
type LPID3DXPatchMesh = Ptr ID3DXPatchMesh
type LPD3DXPATCHMESH = Ptr ID3DXPatchMesh


data ID3DXPMesh = ID3DXPMesh deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXPMesh_ClonePMesh"
  c_ID3DXPMesh_ClonePMesh::Ptr ID3DXPMesh -> DWORD -> Ptr D3DVERTEXELEMENT9 -> LPDIRECT3DDEVICE9 -> Ptr (Ptr ID3DXPMesh) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_ClonePMeshFVF"
  c_ID3DXPMesh_ClonePMeshFVF::Ptr ID3DXPMesh -> DWORD -> DWORD -> LPDIRECT3DDEVICE9 -> Ptr LPD3DXPMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_GenerateVertexHistory"
  c_ID3DXPMesh_GenerateVertexHistory::Ptr ID3DXPMesh -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_GetAdjacency"
  c_ID3DXPMesh_GetAdjacency::Ptr ID3DXPMesh -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_GetMaxFaces"
  c_ID3DXPMesh_GetMaxFaces::Ptr ID3DXPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXPMesh_GetMaxVertices"
  c_ID3DXPMesh_GetMaxVertices::Ptr ID3DXPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXPMesh_GetMinFaces"
  c_ID3DXPMesh_GetMinFaces::Ptr ID3DXPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXPMesh_GetMinVertices"
  c_ID3DXPMesh_GetMinVertices::Ptr ID3DXPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXPMesh_Optimize"
  c_ID3DXPMesh_Optimize::Ptr ID3DXPMesh -> DWORD -> Ptr DWORD -> Ptr DWORD -> Ptr LPD3DXBUFFER -> Ptr LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_OptimizeBaseLOD"
  c_ID3DXPMesh_OptimizeBaseLOD::Ptr ID3DXPMesh -> DWORD -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_Save"
  c_ID3DXPMesh_Save::Ptr ID3DXPMesh -> Ptr IStream -> Ptr D3DXMATERIAL -> Ptr D3DXEFFECTINSTANCE -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_SetNumFaces"
  c_ID3DXPMesh_SetNumFaces::Ptr ID3DXPMesh -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_SetNumVertices"
  c_ID3DXPMesh_SetNumVertices::Ptr ID3DXPMesh -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_TrimByFaces"
  c_ID3DXPMesh_TrimByFaces::Ptr ID3DXPMesh -> DWORD -> DWORD -> Ptr DWORD -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPMesh_TrimByVertices"
  c_ID3DXPMesh_TrimByVertices::Ptr ID3DXPMesh -> DWORD -> DWORD -> Ptr DWORD -> Ptr DWORD -> IO HRESULT
type LPID3DXPMesh = Ptr ID3DXPMesh
type LPD3DXPMESH = Ptr ID3DXPMesh


data ID3DXPRTBuffer = ID3DXPRTBuffer deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_AddBuffer"
  c_ID3DXPRTBuffer_AddBuffer::Ptr ID3DXPRTBuffer -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_AttachGH"
  c_ID3DXPRTBuffer_AttachGH::Ptr ID3DXPRTBuffer -> LPD3DXTEXTUREGUTTERHELPER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_EvalGH"
  c_ID3DXPRTBuffer_EvalGH::Ptr ID3DXPRTBuffer -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_ExtractTexture"
  c_ID3DXPRTBuffer_ExtractTexture::Ptr ID3DXPRTBuffer -> UINT -> UINT -> UINT -> LPDIRECT3DTEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_ExtractToMesh"
  c_ID3DXPRTBuffer_ExtractToMesh::Ptr ID3DXPRTBuffer -> UINT -> D3DDECLUSAGE -> UINT -> LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_GetHeight"
  c_ID3DXPRTBuffer_GetHeight::Ptr ID3DXPRTBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_GetNumChannels"
  c_ID3DXPRTBuffer_GetNumChannels::Ptr ID3DXPRTBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_GetNumCoeffs"
  c_ID3DXPRTBuffer_GetNumCoeffs::Ptr ID3DXPRTBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_GetNumSamples"
  c_ID3DXPRTBuffer_GetNumSamples::Ptr ID3DXPRTBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_GetWidth"
  c_ID3DXPRTBuffer_GetWidth::Ptr ID3DXPRTBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_IsTexture"
  c_ID3DXPRTBuffer_IsTexture::Ptr ID3DXPRTBuffer -> IO BOOL
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_LockBuffer"
  c_ID3DXPRTBuffer_LockBuffer::Ptr ID3DXPRTBuffer -> UINT -> UINT -> Ptr (Ptr FLOAT) -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_ReleaseGH"
  c_ID3DXPRTBuffer_ReleaseGH::Ptr ID3DXPRTBuffer -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_Resize"
  c_ID3DXPRTBuffer_Resize::Ptr ID3DXPRTBuffer -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_ScaleBuffer"
  c_ID3DXPRTBuffer_ScaleBuffer::Ptr ID3DXPRTBuffer -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTBuffer_UnlockBuffer"
  c_ID3DXPRTBuffer_UnlockBuffer::Ptr ID3DXPRTBuffer -> IO HRESULT
type LPID3DXPRTBuffer = Ptr ID3DXPRTBuffer
type LPD3DXPRTBUFFER = Ptr ID3DXPRTBuffer


data ID3DXPRTCompBuffer = ID3DXPRTCompBuffer deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_ExtractBasis"
  c_ID3DXPRTCompBuffer_ExtractBasis::Ptr ID3DXPRTCompBuffer -> UINT -> Ptr FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_ExtractClusterIDs"
  c_ID3DXPRTCompBuffer_ExtractClusterIDs::Ptr ID3DXPRTCompBuffer -> Ptr UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_ExtractPCA"
  c_ID3DXPRTCompBuffer_ExtractPCA::Ptr ID3DXPRTCompBuffer -> UINT -> UINT -> Ptr FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_ExtractTexture"
  c_ID3DXPRTCompBuffer_ExtractTexture::Ptr ID3DXPRTCompBuffer -> UINT -> UINT -> LPDIRECT3DTEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_ExtractToMesh"
  c_ID3DXPRTCompBuffer_ExtractToMesh::Ptr ID3DXPRTCompBuffer -> UINT -> D3DDECLUSAGE -> UINT -> LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_GetHeight"
  c_ID3DXPRTCompBuffer_GetHeight::Ptr ID3DXPRTCompBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_GetNumChannels"
  c_ID3DXPRTCompBuffer_GetNumChannels::Ptr ID3DXPRTCompBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_GetNumClusters"
  c_ID3DXPRTCompBuffer_GetNumClusters::Ptr ID3DXPRTCompBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_GetNumCoeffs"
  c_ID3DXPRTCompBuffer_GetNumCoeffs::Ptr ID3DXPRTCompBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_GetNumPCA"
  c_ID3DXPRTCompBuffer_GetNumPCA::Ptr ID3DXPRTCompBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_GetNumSamples"
  c_ID3DXPRTCompBuffer_GetNumSamples::Ptr ID3DXPRTCompBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_GetWidth"
  c_ID3DXPRTCompBuffer_GetWidth::Ptr ID3DXPRTCompBuffer -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_IsTexture"
  c_ID3DXPRTCompBuffer_IsTexture::Ptr ID3DXPRTCompBuffer -> IO BOOL
foreign import ccall unsafe "fake.h c_ID3DXPRTCompBuffer_NormalizeData"
  c_ID3DXPRTCompBuffer_NormalizeData::Ptr ID3DXPRTCompBuffer -> IO HRESULT
type LPID3DXPRTCompBuffer = Ptr ID3DXPRTCompBuffer
type LPD3DXPRTCOMPBUFFER = Ptr ID3DXPRTCompBuffer


data ID3DXPRTEngine = ID3DXPRTEngine deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ClosestRayIntersects"
  c_ID3DXPRTEngine_ClosestRayIntersects::Ptr ID3DXPRTEngine -> Ptr D3DXVECTOR3 -> Ptr D3DXVECTOR3 -> Ptr DWORD -> Ptr FLOAT -> Ptr FLOAT -> Ptr FLOAT -> IO BOOL
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeBounce"
  c_ID3DXPRTEngine_ComputeBounce::Ptr ID3DXPRTEngine -> LPD3DXPRTBUFFER -> LPD3DXPRTBUFFER -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeBounceAdaptive"
  c_ID3DXPRTEngine_ComputeBounceAdaptive::Ptr ID3DXPRTEngine -> LPD3DXPRTBUFFER -> FLOAT -> FLOAT -> UINT -> LPD3DXPRTBUFFER -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeDirectLightingSH"
  c_ID3DXPRTEngine_ComputeDirectLightingSH::Ptr ID3DXPRTEngine -> UINT -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeDirectLightingSHAdaptive"
  c_ID3DXPRTEngine_ComputeDirectLightingSHAdaptive::Ptr ID3DXPRTEngine -> UINT -> FLOAT -> FLOAT -> UINT -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeDirectLightingSHGPU"
  c_ID3DXPRTEngine_ComputeDirectLightingSHGPU::Ptr ID3DXPRTEngine -> LPDIRECT3DDEVICE9 -> UINT -> UINT -> FLOAT -> FLOAT -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeLDPRTCoeffs"
  c_ID3DXPRTEngine_ComputeLDPRTCoeffs::Ptr ID3DXPRTEngine -> LPD3DXPRTBUFFER -> UINT -> Ptr D3DXVECTOR3 -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeSS"
  c_ID3DXPRTEngine_ComputeSS::Ptr ID3DXPRTEngine -> LPD3DXPRTBUFFER -> LPD3DXPRTBUFFER -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeSSAdaptive"
  c_ID3DXPRTEngine_ComputeSSAdaptive::Ptr ID3DXPRTEngine -> LPD3DXPRTBUFFER -> FLOAT -> FLOAT -> UINT -> LPD3DXPRTBUFFER -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeSurfSamplesBounce"
  c_ID3DXPRTEngine_ComputeSurfSamplesBounce::Ptr ID3DXPRTEngine -> LPD3DXPRTBUFFER -> UINT -> Ptr D3DXVECTOR3 -> Ptr D3DXVECTOR3 -> LPD3DXPRTBUFFER -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeSurfSamplesDirectSH"
  c_ID3DXPRTEngine_ComputeSurfSamplesDirectSH::Ptr ID3DXPRTEngine -> UINT -> UINT -> Ptr D3DXVECTOR3 -> Ptr D3DXVECTOR3 -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeVolumeSamples"
  c_ID3DXPRTEngine_ComputeVolumeSamples::Ptr ID3DXPRTEngine -> LPD3DXPRTBUFFER -> UINT -> UINT -> Ptr D3DXVECTOR3 -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ComputeVolumeSamplesDirectSH"
  c_ID3DXPRTEngine_ComputeVolumeSamplesDirectSH::Ptr ID3DXPRTEngine -> UINT -> UINT -> UINT -> Ptr D3DXVECTOR3 -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ExtractPerVertexAlbedo"
  c_ID3DXPRTEngine_ExtractPerVertexAlbedo::Ptr ID3DXPRTEngine -> LPD3DXMESH -> D3DDECLUSAGE -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_FreeBounceData"
  c_ID3DXPRTEngine_FreeBounceData::Ptr ID3DXPRTEngine -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_FreeSSData"
  c_ID3DXPRTEngine_FreeSSData::Ptr ID3DXPRTEngine -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_GetAdaptedMesh"
  c_ID3DXPRTEngine_GetAdaptedMesh::Ptr ID3DXPRTEngine -> LPDIRECT3DDEVICE9 -> Ptr UINT -> Ptr UINT -> Ptr FLOAT -> Ptr LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_GetNumFaces"
  c_ID3DXPRTEngine_GetNumFaces::Ptr ID3DXPRTEngine -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_GetNumVerts"
  c_ID3DXPRTEngine_GetNumVerts::Ptr ID3DXPRTEngine -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_GetVertexAlbedo"
  c_ID3DXPRTEngine_GetVertexAlbedo::Ptr ID3DXPRTEngine -> Ptr D3DXCOLOR -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_MultiplyAlbedo"
  c_ID3DXPRTEngine_MultiplyAlbedo::Ptr ID3DXPRTEngine -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ResampleBuffer"
  c_ID3DXPRTEngine_ResampleBuffer::Ptr ID3DXPRTEngine -> LPD3DXPRTBUFFER -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_RobustMeshRefine"
  c_ID3DXPRTEngine_RobustMeshRefine::Ptr ID3DXPRTEngine -> FLOAT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ScaleMeshChunk"
  c_ID3DXPRTEngine_ScaleMeshChunk::Ptr ID3DXPRTEngine -> UINT -> FLOAT -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_SetCallBack"
  c_ID3DXPRTEngine_SetCallBack::Ptr ID3DXPRTEngine -> LPD3DXSHPRTSIMCB -> FLOAT -> LPVOID -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_SetMinMaxIntersection"
  c_ID3DXPRTEngine_SetMinMaxIntersection::Ptr ID3DXPRTEngine -> FLOAT -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_SetPerTexelAlbedo"
  c_ID3DXPRTEngine_SetPerTexelAlbedo::Ptr ID3DXPRTEngine -> LPDIRECT3DTEXTURE9 -> UINT -> LPD3DXTEXTUREGUTTERHELPER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_SetPerTexelNormal"
  c_ID3DXPRTEngine_SetPerTexelNormal::Ptr ID3DXPRTEngine -> LPDIRECT3DTEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_SetPerVertexAlbedo"
  c_ID3DXPRTEngine_SetPerVertexAlbedo::Ptr ID3DXPRTEngine -> Ptr () -> UINT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_SetSamplingInfo"
  c_ID3DXPRTEngine_SetSamplingInfo::Ptr ID3DXPRTEngine -> UINT -> BOOL -> BOOL -> BOOL -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXPRTEngine_ShadowRayIntersects"
  c_ID3DXPRTEngine_ShadowRayIntersects::Ptr ID3DXPRTEngine -> Ptr D3DXVECTOR3 -> Ptr D3DXVECTOR3 -> IO BOOL
type LPID3DXPRTEngine = Ptr ID3DXPRTEngine
type LPD3DXPRTENGINE = Ptr ID3DXPRTEngine


data ID3DXRenderToEnvMap = ID3DXRenderToEnvMap deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_BeginCube"
  c_ID3DXRenderToEnvMap_BeginCube::Ptr ID3DXRenderToEnvMap -> LPDIRECT3DCUBETEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_BeginHemisphere"
  c_ID3DXRenderToEnvMap_BeginHemisphere::Ptr ID3DXRenderToEnvMap -> LPDIRECT3DTEXTURE9 -> LPDIRECT3DTEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_BeginParabolic"
  c_ID3DXRenderToEnvMap_BeginParabolic::Ptr ID3DXRenderToEnvMap -> LPDIRECT3DTEXTURE9 -> LPDIRECT3DTEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_BeginSphere"
  c_ID3DXRenderToEnvMap_BeginSphere::Ptr ID3DXRenderToEnvMap -> LPDIRECT3DTEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_End"
  c_ID3DXRenderToEnvMap_End::Ptr ID3DXRenderToEnvMap -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_Face"
  c_ID3DXRenderToEnvMap_Face::Ptr ID3DXRenderToEnvMap -> D3DCUBEMAP_FACES -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_GetDesc"
  c_ID3DXRenderToEnvMap_GetDesc::Ptr ID3DXRenderToEnvMap -> Ptr D3DXRTE_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_GetDevice"
  c_ID3DXRenderToEnvMap_GetDevice::Ptr ID3DXRenderToEnvMap -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_OnLostDevice"
  c_ID3DXRenderToEnvMap_OnLostDevice::Ptr ID3DXRenderToEnvMap -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToEnvMap_OnResetDevice"
  c_ID3DXRenderToEnvMap_OnResetDevice::Ptr ID3DXRenderToEnvMap -> IO HRESULT
type LPID3DXRenderToEnvMap = Ptr ID3DXRenderToEnvMap
type LPD3DXRENDERTOENVMAP = Ptr ID3DXRenderToEnvMap


data ID3DXRenderToSurface = ID3DXRenderToSurface deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXRenderToSurface_BeginScene"
  c_ID3DXRenderToSurface_BeginScene::Ptr ID3DXRenderToSurface -> LPDIRECT3DSURFACE9 -> Ptr D3DVIEWPORT9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToSurface_EndScene"
  c_ID3DXRenderToSurface_EndScene::Ptr ID3DXRenderToSurface -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToSurface_GetDesc"
  c_ID3DXRenderToSurface_GetDesc::Ptr ID3DXRenderToSurface -> Ptr D3DXRTS_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToSurface_GetDevice"
  c_ID3DXRenderToSurface_GetDevice::Ptr ID3DXRenderToSurface -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToSurface_OnLostDevice"
  c_ID3DXRenderToSurface_OnLostDevice::Ptr ID3DXRenderToSurface -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXRenderToSurface_OnResetDevice"
  c_ID3DXRenderToSurface_OnResetDevice::Ptr ID3DXRenderToSurface -> IO HRESULT
type LPID3DXRenderToSurface = Ptr ID3DXRenderToSurface
type LPD3DXRENDERTOSURFACE = Ptr ID3DXRenderToSurface


data ID3DXSkinInfo = ID3DXSkinInfo deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_Clone"
  c_ID3DXSkinInfo_Clone::Ptr ID3DXSkinInfo -> Ptr LPD3DXSKININFO -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_ConvertToBlendedMesh"
  c_ID3DXSkinInfo_ConvertToBlendedMesh::Ptr ID3DXSkinInfo -> LPD3DXMESH -> DWORD -> Ptr DWORD -> LPDWORD -> Ptr DWORD -> Ptr LPD3DXBUFFER -> Ptr DWORD -> Ptr DWORD -> Ptr LPD3DXBUFFER -> Ptr LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_ConvertToIndexedBlendedMesh"
  c_ID3DXSkinInfo_ConvertToIndexedBlendedMesh::Ptr ID3DXSkinInfo -> LPD3DXMESH -> DWORD -> DWORD -> Ptr DWORD -> LPDWORD -> Ptr DWORD -> Ptr LPD3DXBUFFER -> Ptr DWORD -> Ptr DWORD -> Ptr LPD3DXBUFFER -> Ptr LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_FindBoneVertexInfluenceIndex"
  c_ID3DXSkinInfo_FindBoneVertexInfluenceIndex::Ptr ID3DXSkinInfo -> DWORD -> DWORD -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetBoneInfluence"
  c_ID3DXSkinInfo_GetBoneInfluence::Ptr ID3DXSkinInfo -> DWORD -> Ptr DWORD -> Ptr FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetBoneName"
  c_ID3DXSkinInfo_GetBoneName::Ptr ID3DXSkinInfo -> DWORD -> IO LPCSTR
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetBoneOffsetMatrix"
  c_ID3DXSkinInfo_GetBoneOffsetMatrix::Ptr ID3DXSkinInfo -> DWORD -> IO LPD3DXMATRIX
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetBoneVertexInfluence"
  c_ID3DXSkinInfo_GetBoneVertexInfluence::Ptr ID3DXSkinInfo -> DWORD -> DWORD -> Ptr FLOAT -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetDeclaration"
  c_ID3DXSkinInfo_GetDeclaration::Ptr ID3DXSkinInfo -> Ptr D3DVERTEXELEMENT9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetFVF"
  c_ID3DXSkinInfo_GetFVF::Ptr ID3DXSkinInfo -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetMaxFaceInfluences"
  c_ID3DXSkinInfo_GetMaxFaceInfluences::Ptr ID3DXSkinInfo -> LPDIRECT3DINDEXBUFFER9 -> DWORD -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetMaxVertexInfluences"
  c_ID3DXSkinInfo_GetMaxVertexInfluences::Ptr ID3DXSkinInfo -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetMinBoneInfluence"
  c_ID3DXSkinInfo_GetMinBoneInfluence::Ptr ID3DXSkinInfo -> IO FLOAT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetNumBoneInfluences"
  c_ID3DXSkinInfo_GetNumBoneInfluences::Ptr ID3DXSkinInfo -> DWORD -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_GetNumBones"
  c_ID3DXSkinInfo_GetNumBones::Ptr ID3DXSkinInfo -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_Remap"
  c_ID3DXSkinInfo_Remap::Ptr ID3DXSkinInfo -> DWORD -> Ptr DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_SetBoneInfluence"
  c_ID3DXSkinInfo_SetBoneInfluence::Ptr ID3DXSkinInfo -> DWORD -> DWORD -> Ptr DWORD -> Ptr FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_SetBoneName"
  c_ID3DXSkinInfo_SetBoneName::Ptr ID3DXSkinInfo -> DWORD -> LPCSTR -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_SetBoneOffsetMatrix"
  c_ID3DXSkinInfo_SetBoneOffsetMatrix::Ptr ID3DXSkinInfo -> DWORD -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_SetBoneVertexInfluence"
  c_ID3DXSkinInfo_SetBoneVertexInfluence::Ptr ID3DXSkinInfo -> DWORD -> DWORD -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_SetDeclaration"
  c_ID3DXSkinInfo_SetDeclaration::Ptr ID3DXSkinInfo -> Ptr D3DVERTEXELEMENT9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_SetFVF"
  c_ID3DXSkinInfo_SetFVF::Ptr ID3DXSkinInfo -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_SetMinBoneInfluence"
  c_ID3DXSkinInfo_SetMinBoneInfluence::Ptr ID3DXSkinInfo -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSkinInfo_UpdateSkinnedMesh"
  c_ID3DXSkinInfo_UpdateSkinnedMesh::Ptr ID3DXSkinInfo -> Ptr D3DXMATRIX -> Ptr D3DXMATRIX -> LPCVOID -> PVOID -> IO HRESULT
type LPID3DXSkinInfo = Ptr ID3DXSkinInfo
type LPD3DXSKININFO = Ptr ID3DXSkinInfo


data ID3DXSPMesh = ID3DXSPMesh deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_CloneMesh"
  c_ID3DXSPMesh_CloneMesh::Ptr ID3DXSPMesh -> DWORD -> Ptr D3DVERTEXELEMENT9 -> LPDIRECT3DDEVICE9 -> Ptr DWORD -> Ptr DWORD -> Ptr LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_CloneMeshFVF"
  c_ID3DXSPMesh_CloneMeshFVF::Ptr ID3DXSPMesh -> DWORD -> DWORD -> LPDIRECT3DDEVICE9 -> Ptr DWORD -> Ptr DWORD -> Ptr LPD3DXMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_ClonePMesh"
  c_ID3DXSPMesh_ClonePMesh::Ptr ID3DXSPMesh -> DWORD -> Ptr D3DVERTEXELEMENT9 -> LPDIRECT3DDEVICE9 -> Ptr DWORD -> Ptr FLOAT -> Ptr LPD3DXPMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_ClonePMeshFVF"
  c_ID3DXSPMesh_ClonePMeshFVF::Ptr ID3DXSPMesh -> DWORD -> DWORD -> LPDIRECT3DDEVICE9 -> Ptr DWORD -> Ptr FLOAT -> Ptr LPD3DXPMESH -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetDeclaration"
  c_ID3DXSPMesh_GetDeclaration::Ptr ID3DXSPMesh -> Ptr D3DVERTEXELEMENT9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetDevice"
  c_ID3DXSPMesh_GetDevice::Ptr ID3DXSPMesh -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetFVF"
  c_ID3DXSPMesh_GetFVF::Ptr ID3DXSPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetMaxFaces"
  c_ID3DXSPMesh_GetMaxFaces::Ptr ID3DXSPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetMaxVertices"
  c_ID3DXSPMesh_GetMaxVertices::Ptr ID3DXSPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetNumFaces"
  c_ID3DXSPMesh_GetNumFaces::Ptr ID3DXSPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetNumVertices"
  c_ID3DXSPMesh_GetNumVertices::Ptr ID3DXSPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetOptions"
  c_ID3DXSPMesh_GetOptions::Ptr ID3DXSPMesh -> IO DWORD
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetVertexAttributeWeights"
  c_ID3DXSPMesh_GetVertexAttributeWeights::Ptr ID3DXSPMesh -> LPD3DXATTRIBUTEWEIGHTS -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_GetVertexWeights"
  c_ID3DXSPMesh_GetVertexWeights::Ptr ID3DXSPMesh -> Ptr FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_ReduceFaces"
  c_ID3DXSPMesh_ReduceFaces::Ptr ID3DXSPMesh -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSPMesh_ReduceVertices"
  c_ID3DXSPMesh_ReduceVertices::Ptr ID3DXSPMesh -> DWORD -> IO HRESULT
type LPID3DXSPMesh = Ptr ID3DXSPMesh
type LPD3DXSPMESH = Ptr ID3DXSPMesh


data ID3DXSprite = ID3DXSprite deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXSprite_Begin"
  c_ID3DXSprite_Begin::Ptr ID3DXSprite -> DWORD -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSprite_Draw"
  c_ID3DXSprite_Draw::Ptr ID3DXSprite -> LPDIRECT3DTEXTURE9 -> Ptr RECT -> Ptr D3DXVECTOR3 -> Ptr D3DXVECTOR3 -> D3DCOLOR -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSprite_End"
  c_ID3DXSprite_End::Ptr ID3DXSprite -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSprite_GetDevice"
  c_ID3DXSprite_GetDevice::Ptr ID3DXSprite -> Ptr LPDIRECT3DDEVICE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSprite_GetTransform"
  c_ID3DXSprite_GetTransform::Ptr ID3DXSprite -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSprite_OnLostDevice"
  c_ID3DXSprite_OnLostDevice::Ptr ID3DXSprite -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSprite_OnResetDevice"
  c_ID3DXSprite_OnResetDevice::Ptr ID3DXSprite -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSprite_SetTransform"
  c_ID3DXSprite_SetTransform::Ptr ID3DXSprite -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSprite_SetWorldViewLH"
  c_ID3DXSprite_SetWorldViewLH::Ptr ID3DXSprite -> Ptr D3DXMATRIX -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXSprite_SetWorldViewRH"
  c_ID3DXSprite_SetWorldViewRH::Ptr ID3DXSprite -> Ptr D3DXMATRIX -> Ptr D3DXMATRIX -> IO HRESULT
type LPID3DXSprite = Ptr ID3DXSprite
type LPD3DXSPRITE = Ptr ID3DXSprite


data ID3DXTextureGutterHelper = ID3DXTextureGutterHelper deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_ApplyGuttersFloat"
  c_ID3DXTextureGutterHelper_ApplyGuttersFloat::Ptr ID3DXTextureGutterHelper -> Ptr FLOAT -> Ptr UINT -> Ptr UINT -> Ptr UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_ApplyGuttersPRT"
  c_ID3DXTextureGutterHelper_ApplyGuttersPRT::Ptr ID3DXTextureGutterHelper -> LPD3DXPRTBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_ApplyGuttersTex"
  c_ID3DXTextureGutterHelper_ApplyGuttersTex::Ptr ID3DXTextureGutterHelper -> LPDIRECT3DTEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_GetBaryMap"
  c_ID3DXTextureGutterHelper_GetBaryMap::Ptr ID3DXTextureGutterHelper -> Ptr D3DXVECTOR2 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_GetFaceMap"
  c_ID3DXTextureGutterHelper_GetFaceMap::Ptr ID3DXTextureGutterHelper -> Ptr UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_GetGutterMap"
  c_ID3DXTextureGutterHelper_GetGutterMap::Ptr ID3DXTextureGutterHelper -> Ptr BYTE -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_GetHeight"
  c_ID3DXTextureGutterHelper_GetHeight::Ptr ID3DXTextureGutterHelper -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_GetTexelMap"
  c_ID3DXTextureGutterHelper_GetTexelMap::Ptr ID3DXTextureGutterHelper -> Ptr D3DXVECTOR2 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_GetWidth"
  c_ID3DXTextureGutterHelper_GetWidth::Ptr ID3DXTextureGutterHelper -> IO UINT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_ResampleTex"
  c_ID3DXTextureGutterHelper_ResampleTex::Ptr ID3DXTextureGutterHelper -> LPDIRECT3DTEXTURE9 -> LPD3DXMESH -> D3DDECLUSAGE -> UINT -> LPDIRECT3DTEXTURE9 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_SetBaryMap"
  c_ID3DXTextureGutterHelper_SetBaryMap::Ptr ID3DXTextureGutterHelper -> Ptr D3DXVECTOR2 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_SetFaceMap"
  c_ID3DXTextureGutterHelper_SetFaceMap::Ptr ID3DXTextureGutterHelper -> Ptr UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_SetGutterMap"
  c_ID3DXTextureGutterHelper_SetGutterMap::Ptr ID3DXTextureGutterHelper -> Ptr BYTE -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureGutterHelper_SetTexelMap"
  c_ID3DXTextureGutterHelper_SetTexelMap::Ptr ID3DXTextureGutterHelper -> Ptr D3DXVECTOR2 -> IO HRESULT
type LPID3DXTextureGutterHelper = Ptr ID3DXTextureGutterHelper
type LPD3DXTEXTUREGUTTERHELPER = Ptr ID3DXTextureGutterHelper


data ID3DXTextureShader = ID3DXTextureShader deriving (Show)
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_GetConstant"
  c_ID3DXTextureShader_GetConstant::Ptr ID3DXTextureShader -> D3DXHANDLE -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_GetConstantBuffer"
  c_ID3DXTextureShader_GetConstantBuffer::Ptr ID3DXTextureShader -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_GetConstantByName"
  c_ID3DXTextureShader_GetConstantByName::Ptr ID3DXTextureShader -> D3DXHANDLE -> LPCSTR -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_GetConstantDesc"
  c_ID3DXTextureShader_GetConstantDesc::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr D3DXCONSTANT_DESC -> Ptr UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_GetConstantElement"
  c_ID3DXTextureShader_GetConstantElement::Ptr ID3DXTextureShader -> D3DXHANDLE -> UINT -> IO D3DXHANDLE
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_GetDesc"
  c_ID3DXTextureShader_GetDesc::Ptr ID3DXTextureShader -> Ptr D3DXCONSTANTTABLE_DESC -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_GetFunction"
  c_ID3DXTextureShader_GetFunction::Ptr ID3DXTextureShader -> Ptr LPD3DXBUFFER -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetBool"
  c_ID3DXTextureShader_SetBool::Ptr ID3DXTextureShader -> D3DXHANDLE -> BOOL -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetBoolArray"
  c_ID3DXTextureShader_SetBoolArray::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr BOOL -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetDefaults"
  c_ID3DXTextureShader_SetDefaults::Ptr ID3DXTextureShader -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetFloat"
  c_ID3DXTextureShader_SetFloat::Ptr ID3DXTextureShader -> D3DXHANDLE -> FLOAT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetFloatArray"
  c_ID3DXTextureShader_SetFloatArray::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr FLOAT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetInt"
  c_ID3DXTextureShader_SetInt::Ptr ID3DXTextureShader -> D3DXHANDLE -> INT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetIntArray"
  c_ID3DXTextureShader_SetIntArray::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr INT -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetMatrix"
  c_ID3DXTextureShader_SetMatrix::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetMatrixArray"
  c_ID3DXTextureShader_SetMatrixArray::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr D3DXMATRIX -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetMatrixPointerArray"
  c_ID3DXTextureShader_SetMatrixPointerArray::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr (Ptr D3DXMATRIX) -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetMatrixTranspose"
  c_ID3DXTextureShader_SetMatrixTranspose::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr D3DXMATRIX -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetMatrixTransposeArray"
  c_ID3DXTextureShader_SetMatrixTransposeArray::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr D3DXMATRIX -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetMatrixTransposePointerArray"
  c_ID3DXTextureShader_SetMatrixTransposePointerArray::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr (Ptr D3DXMATRIX) -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetValue"
  c_ID3DXTextureShader_SetValue::Ptr ID3DXTextureShader -> D3DXHANDLE -> LPCVOID -> UINT -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetVector"
  c_ID3DXTextureShader_SetVector::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr D3DXVECTOR4 -> IO HRESULT
foreign import ccall unsafe "fake.h c_ID3DXTextureShader_SetVectorArray"
  c_ID3DXTextureShader_SetVectorArray::Ptr ID3DXTextureShader -> D3DXHANDLE -> Ptr D3DXVECTOR4 -> UINT -> IO HRESULT
type LPID3DXTextureShader = Ptr ID3DXTextureShader
type LPD3DXTEXTURESHADER = Ptr ID3DXTextureShader


type D3DXCALLBACK_SEARCH_FLAGS = DWORD
d3DXCALLBACK_SEARCH_BEHIND_INITIAL_POSITION::D3DXCALLBACK_SEARCH_FLAGS
d3DXCALLBACK_SEARCH_BEHIND_INITIAL_POSITION=2
d3DXCALLBACK_SEARCH_EXCLUDING_INITIAL_POSITION::D3DXCALLBACK_SEARCH_FLAGS
d3DXCALLBACK_SEARCH_EXCLUDING_INITIAL_POSITION=1

type D3DXCLEANTYPE = DWORD
d3DXCLEAN_BOWTIES::D3DXCLEANTYPE
d3DXCLEAN_BOWTIES=2
d3DXCLEAN_BACKFACING::D3DXCLEANTYPE
d3DXCLEAN_BACKFACING=1

type D3DXCOMPRESSION_FLAGS = DWORD
d3DXCOMPRESS_STRONG::D3DXCOMPRESSION_FLAGS
d3DXCOMPRESS_STRONG=1
d3DXCOMPRESS_DEFAULT::D3DXCOMPRESSION_FLAGS
d3DXCOMPRESS_DEFAULT=0

type D3DXEFFECTDEFAULTTYPE = DWORD
d3DXEDT_DWORD::D3DXEFFECTDEFAULTTYPE
d3DXEDT_DWORD=3
d3DXEDT_FLOATS::D3DXEFFECTDEFAULTTYPE
d3DXEDT_FLOATS=2
d3DXEDT_STRING::D3DXEFFECTDEFAULTTYPE
d3DXEDT_STRING=1

type D3DXEVENT_TYPE = DWORD
d3DXEVENT_PRIORITYBLEND::D3DXEVENT_TYPE
d3DXEVENT_PRIORITYBLEND=4
d3DXEVENT_TRACKENABLE::D3DXEVENT_TYPE
d3DXEVENT_TRACKENABLE=3
d3DXEVENT_TRACKPOSITION::D3DXEVENT_TYPE
d3DXEVENT_TRACKPOSITION=2
d3DXEVENT_TRACKWEIGHT::D3DXEVENT_TYPE
d3DXEVENT_TRACKWEIGHT=1
d3DXEVENT_TRACKSPEED::D3DXEVENT_TYPE
d3DXEVENT_TRACKSPEED=0

type D3DXIMAGE_FILEFORMAT = DWORD
d3DXIFF_PFM::D3DXIMAGE_FILEFORMAT
d3DXIFF_PFM=8
d3DXIFF_HDR::D3DXIMAGE_FILEFORMAT
d3DXIFF_HDR=7
d3DXIFF_DIB::D3DXIMAGE_FILEFORMAT
d3DXIFF_DIB=6
d3DXIFF_PPM::D3DXIMAGE_FILEFORMAT
d3DXIFF_PPM=5
d3DXIFF_DDS::D3DXIMAGE_FILEFORMAT
d3DXIFF_DDS=4
d3DXIFF_PNG::D3DXIMAGE_FILEFORMAT
d3DXIFF_PNG=3
d3DXIFF_TGA::D3DXIMAGE_FILEFORMAT
d3DXIFF_TGA=2
d3DXIFF_JPG::D3DXIMAGE_FILEFORMAT
d3DXIFF_JPG=1
d3DXIFF_BMP::D3DXIMAGE_FILEFORMAT
d3DXIFF_BMP=0

type D3DXIMT_FLAGS = DWORD
d3DXIMT_WRAP_UV::D3DXIMT_FLAGS
d3DXIMT_WRAP_UV=3
d3DXIMT_WRAP_V::D3DXIMT_FLAGS
d3DXIMT_WRAP_V=2
d3DXIMT_WRAP_U::D3DXIMT_FLAGS
d3DXIMT_WRAP_U=1

type D3DXINCLUDE_TYPE = DWORD
d3DXINC_SYSTEM::D3DXINCLUDE_TYPE
d3DXINC_SYSTEM=1
d3DXINC_LOCAL::D3DXINCLUDE_TYPE
d3DXINC_LOCAL=0

type D3DXMESH = DWORD
d3DXMESH_SOFTWAREPROCESSING::D3DXMESH
d3DXMESH_SOFTWAREPROCESSING=0x18000
d3DXMESH_DYNAMIC::D3DXMESH
d3DXMESH_DYNAMIC=0x880
d3DXMESH_WRITEONLY::D3DXMESH
d3DXMESH_WRITEONLY=0x440
d3DXMESH_MANAGED::D3DXMESH
d3DXMESH_MANAGED=0x220
d3DXMESH_SYSTEMMEM::D3DXMESH
d3DXMESH_SYSTEMMEM=0x110
d3DXMESH_USEHWONLY::D3DXMESH
d3DXMESH_USEHWONLY=0x2000
d3DXMESH_VB_SHARE::D3DXMESH
d3DXMESH_VB_SHARE=0x1000
d3DXMESH_IB_SOFTWAREPROCESSING::D3DXMESH
d3DXMESH_IB_SOFTWAREPROCESSING=0x10000
d3DXMESH_IB_DYNAMIC::D3DXMESH
d3DXMESH_IB_DYNAMIC=0x800
d3DXMESH_IB_WRITEONLY::D3DXMESH
d3DXMESH_IB_WRITEONLY=0x400
d3DXMESH_IB_MANAGED::D3DXMESH
d3DXMESH_IB_MANAGED=0x200
d3DXMESH_IB_SYSTEMMEM::D3DXMESH
d3DXMESH_IB_SYSTEMMEM=0x100
d3DXMESH_VB_SOFTWAREPROCESSING::D3DXMESH
d3DXMESH_VB_SOFTWAREPROCESSING=0x8000
d3DXMESH_VB_DYNAMIC::D3DXMESH
d3DXMESH_VB_DYNAMIC=0x080
d3DXMESH_VB_WRITEONLY::D3DXMESH
d3DXMESH_VB_WRITEONLY=0x040
d3DXMESH_VB_MANAGED::D3DXMESH
d3DXMESH_VB_MANAGED=0x020
d3DXMESH_VB_SYSTEMMEM::D3DXMESH
d3DXMESH_VB_SYSTEMMEM=0x010
d3DXMESH_NPATCHES::D3DXMESH
d3DXMESH_NPATCHES=0x4000
d3DXMESH_RTPATCHES::D3DXMESH
d3DXMESH_RTPATCHES=0x008
d3DXMESH_POINTS::D3DXMESH
d3DXMESH_POINTS=0x004
d3DXMESH_DONOTCLIP::D3DXMESH
d3DXMESH_DONOTCLIP=0x002
d3DXMESH_32BIT::D3DXMESH
d3DXMESH_32BIT=0x001

type D3DXMESHDATATYPE = DWORD
d3DXMESHTYPE_PATCHMESH::D3DXMESHDATATYPE
d3DXMESHTYPE_PATCHMESH=0x003
d3DXMESHTYPE_PMESH::D3DXMESHDATATYPE
d3DXMESHTYPE_PMESH=0x002
d3DXMESHTYPE_MESH::D3DXMESHDATATYPE
d3DXMESHTYPE_MESH=0x001

type D3DXMESHOPT = DWORD
d3DXMESHOPT_DEVICEINDEPENDENT::D3DXMESHOPT
d3DXMESHOPT_DEVICEINDEPENDENT=0x40000000
d3DXMESHOPT_DONOTSPLIT::D3DXMESHOPT
d3DXMESHOPT_DONOTSPLIT=0x20000000
d3DXMESHOPT_IGNOREVERTS::D3DXMESHOPT
d3DXMESHOPT_IGNOREVERTS=0x10000000
d3DXMESHOPT_STRIPREORDER::D3DXMESHOPT
d3DXMESHOPT_STRIPREORDER=0x08000000
d3DXMESHOPT_VERTEXCACHE::D3DXMESHOPT
d3DXMESHOPT_VERTEXCACHE=0x04000000
d3DXMESHOPT_ATTRSORT::D3DXMESHOPT
d3DXMESHOPT_ATTRSORT=0x02000000
d3DXMESHOPT_COMPACT::D3DXMESHOPT
d3DXMESHOPT_COMPACT=0x01000000

type D3DXMESHSIMP = DWORD
d3DXMESHSIMP_FACE::D3DXMESHSIMP
d3DXMESHSIMP_FACE=2
d3DXMESHSIMP_VERTEX::D3DXMESHSIMP
d3DXMESHSIMP_VERTEX=1

type D3DXPARAMETER_CLASS = DWORD
d3DXPC_STRUCT::D3DXPARAMETER_CLASS
d3DXPC_STRUCT=5
d3DXPC_OBJECT::D3DXPARAMETER_CLASS
d3DXPC_OBJECT=4
d3DXPC_MATRIX_COLUMNS::D3DXPARAMETER_CLASS
d3DXPC_MATRIX_COLUMNS=3
d3DXPC_MATRIX_ROWS::D3DXPARAMETER_CLASS
d3DXPC_MATRIX_ROWS=2
d3DXPC_VECTOR::D3DXPARAMETER_CLASS
d3DXPC_VECTOR=1
d3DXPC_SCALAR::D3DXPARAMETER_CLASS
d3DXPC_SCALAR=0

type D3DXPARAMETER_TYPE = DWORD
d3DXPT_VERTEXFRAGMENT::D3DXPARAMETER_TYPE
d3DXPT_VERTEXFRAGMENT=18
d3DXPT_PIXELFRAGMENT::D3DXPARAMETER_TYPE
d3DXPT_PIXELFRAGMENT=17
d3DXPT_VERTEXSHADER::D3DXPARAMETER_TYPE
d3DXPT_VERTEXSHADER=16
d3DXPT_PIXELSHADER::D3DXPARAMETER_TYPE
d3DXPT_PIXELSHADER=15
d3DXPT_SAMPLERCUBE::D3DXPARAMETER_TYPE
d3DXPT_SAMPLERCUBE=14
d3DXPT_SAMPLER3D::D3DXPARAMETER_TYPE
d3DXPT_SAMPLER3D=13
d3DXPT_SAMPLER2D::D3DXPARAMETER_TYPE
d3DXPT_SAMPLER2D=12
d3DXPT_SAMPLER1D::D3DXPARAMETER_TYPE
d3DXPT_SAMPLER1D=11
d3DXPT_SAMPLER::D3DXPARAMETER_TYPE
d3DXPT_SAMPLER=10
d3DXPT_TEXTURECUBE::D3DXPARAMETER_TYPE
d3DXPT_TEXTURECUBE=9
d3DXPT_TEXTURE3D::D3DXPARAMETER_TYPE
d3DXPT_TEXTURE3D=8
d3DXPT_TEXTURE2D::D3DXPARAMETER_TYPE
d3DXPT_TEXTURE2D=7
d3DXPT_TEXTURE1D::D3DXPARAMETER_TYPE
d3DXPT_TEXTURE1D=6
d3DXPT_TEXTURE::D3DXPARAMETER_TYPE
d3DXPT_TEXTURE=5
d3DXPT_STRING::D3DXPARAMETER_TYPE
d3DXPT_STRING=4
d3DXPT_FLOAT::D3DXPARAMETER_TYPE
d3DXPT_FLOAT=3
d3DXPT_INT::D3DXPARAMETER_TYPE
d3DXPT_INT=2
d3DXPT_BOOL::D3DXPARAMETER_TYPE
d3DXPT_BOOL=1
d3DXPT_VOID::D3DXPARAMETER_TYPE
d3DXPT_VOID=0

type D3DXPATCHMESH = DWORD
d3DXPATCHMESH_DEFAULT::D3DXPATCHMESH
d3DXPATCHMESH_DEFAULT=0

type D3DXPATCHMESHTYPE = DWORD
d3DXPATCHMESH_NPATCH::D3DXPATCHMESHTYPE
d3DXPATCHMESH_NPATCH=0x003
d3DXPATCHMESH_TRI::D3DXPATCHMESHTYPE
d3DXPATCHMESH_TRI=0x002
d3DXPATCHMESH_RECT::D3DXPATCHMESHTYPE
d3DXPATCHMESH_RECT=0x001

type D3DXPLAYBACK_TYPE = DWORD
d3DXPLAY_PINGPONG::D3DXPLAYBACK_TYPE
d3DXPLAY_PINGPONG=2
d3DXPLAY_ONCE::D3DXPLAYBACK_TYPE
d3DXPLAY_ONCE=1
d3DXPLAY_LOOP::D3DXPLAYBACK_TYPE
d3DXPLAY_LOOP=0

type D3DXPRIORITY_TYPE = DWORD
d3DXPRIORITY_HIGH::D3DXPRIORITY_TYPE
d3DXPRIORITY_HIGH=1
d3DXPRIORITY_LOW::D3DXPRIORITY_TYPE
d3DXPRIORITY_LOW=0

type D3DXREGISTER_SET = DWORD
d3DXRS_SAMPLER::D3DXREGISTER_SET
d3DXRS_SAMPLER=3
d3DXRS_FLOAT4::D3DXREGISTER_SET
d3DXRS_FLOAT4=2
d3DXRS_INT4::D3DXREGISTER_SET
d3DXRS_INT4=1
d3DXRS_BOOL::D3DXREGISTER_SET
d3DXRS_BOOL=0

type D3DXSHCOMPRESSQUALITYTYPE = DWORD
d3DXSHCQUAL_SLOWHIGHQUALITY::D3DXSHCOMPRESSQUALITYTYPE
d3DXSHCQUAL_SLOWHIGHQUALITY=2
d3DXSHCQUAL_FASTLOWQUALITY::D3DXSHCOMPRESSQUALITYTYPE
d3DXSHCQUAL_FASTLOWQUALITY=1
d3DXSHCQUAL_UNCOMPRESSED::D3DXSHCOMPRESSQUALITYTYPE
d3DXSHCQUAL_UNCOMPRESSED=1

type D3DXSHGPUSIMOPT = DWORD
d3DXSHGPUSIMOPT_HIGHQUALITY::D3DXSHGPUSIMOPT
d3DXSHGPUSIMOPT_HIGHQUALITY=4
d3DXSHGPUSIMOPT_SHADOWRES2048::D3DXSHGPUSIMOPT
d3DXSHGPUSIMOPT_SHADOWRES2048=3
d3DXSHGPUSIMOPT_SHADOWRES1024::D3DXSHGPUSIMOPT
d3DXSHGPUSIMOPT_SHADOWRES1024=2
d3DXSHGPUSIMOPT_SHADOWRES512::D3DXSHGPUSIMOPT
d3DXSHGPUSIMOPT_SHADOWRES512=0
d3DXSHGPUSIMOPT_SHADOWRES256::D3DXSHGPUSIMOPT
d3DXSHGPUSIMOPT_SHADOWRES256=1

type D3DXTANGENT = DWORD
d3DXTANGENT_GENERATE_IN_PLACE::D3DXTANGENT
d3DXTANGENT_GENERATE_IN_PLACE=0x0400
d3DXTANGENT_CALCULATE_NORMALS::D3DXTANGENT
d3DXTANGENT_CALCULATE_NORMALS=0x0200
d3DXTANGENT_WIND_CW::D3DXTANGENT
d3DXTANGENT_WIND_CW=0x0100
d3DXTANGENT_WEIGHT_EQUAL::D3DXTANGENT
d3DXTANGENT_WEIGHT_EQUAL=0x080
d3DXTANGENT_WEIGHT_BY_AREA::D3DXTANGENT
d3DXTANGENT_WEIGHT_BY_AREA=0x040
d3DXTANGENT_ORTHOGONALIZE_FROM_U::D3DXTANGENT
d3DXTANGENT_ORTHOGONALIZE_FROM_U=0x020
d3DXTANGENT_ORTHOGONALIZE_FROM_V::D3DXTANGENT
d3DXTANGENT_ORTHOGONALIZE_FROM_V=0x010
d3DXTANGENT_DONT_ORTHOGONALIZE::D3DXTANGENT
d3DXTANGENT_DONT_ORTHOGONALIZE=0x08
d3DXTANGENT_DONT_NORMALIZE_PARTIALS::D3DXTANGENT
d3DXTANGENT_DONT_NORMALIZE_PARTIALS=0x04
d3DXTANGENT_WRAP_UV::D3DXTANGENT
d3DXTANGENT_WRAP_UV=0x03
d3DXTANGENT_WRAP_V::D3DXTANGENT
d3DXTANGENT_WRAP_V=0x02
d3DXTANGENT_WRAP_U::D3DXTANGENT
d3DXTANGENT_WRAP_U=0x01

type D3DXTRANSITION_TYPE = DWORD
d3DXTRANSITION_EASEINEASEOUT::D3DXTRANSITION_TYPE
d3DXTRANSITION_EASEINEASEOUT=0x001
d3DXTRANSITION_LINEAR::D3DXTRANSITION_TYPE
d3DXTRANSITION_LINEAR=0x000

type D3DXWeldEpsilonsFLAGS = DWORD
d3DXWeldEpsilons_DONOTSPLIT::D3DXWeldEpsilonsFLAGS
d3DXWeldEpsilons_DONOTSPLIT=8
d3DXWeldEpsilons_DONOTREMOVEVERTICES::D3DXWeldEpsilonsFLAGS
d3DXWeldEpsilons_DONOTREMOVEVERTICES=4
d3DXWeldEpsilons_WELDPARTIALMATCHES::D3DXWeldEpsilonsFLAGS
d3DXWeldEpsilons_WELDPARTIALMATCHES=2
d3DXWeldEpsilons_WELDALL::D3DXWeldEpsilonsFLAGS
d3DXWeldEpsilons_WELDALL=1