diff --git a/HGamer3D-Ogre-Binding.cabal b/HGamer3D-Ogre-Binding.cabal
--- a/HGamer3D-Ogre-Binding.cabal
+++ b/HGamer3D-Ogre-Binding.cabal
@@ -1,5 +1,5 @@
 Name:                HGamer3D-Ogre-Binding
-Version:             0.1.9
+Version:             0.2.0
 Synopsis:            Windows Game Engine for the Haskell Programmer - Ogre Bindings
 Description:         
    HGamer3D is a game engine for developing 3D games in the programming 
@@ -15,13 +15,13 @@
 Author:              Peter Althainz
 Maintainer:          althainz@gmail.com
 Build-Type:          Simple
-Cabal-Version:       >=1.2
+Cabal-Version:       >=1.4
 Homepage:            http://www.hgamer3d.org
-Category:            Game
+Category:            Game Engine, Graphics
 Extra-source-files:  Setup.hs, include/ClassAnimation.h, include/ClassAnimationState.h, include/ClassAnimationStateSet.h, include/ClassAnimationTrack.h, include/ClassArchive.h, include/ClassArchiveManager.h, include/ClassBillboard.h, include/ClassBillboardChain.h, include/ClassBillboardChainFactory.h, include/ClassBillboardSet.h, include/ClassBillboardSetFactory.h, include/ClassBone.h, include/ClassCamera.h, include/ClassConfigFile.h, include/ClassControllerManager.h, include/ClassEntity.h, include/ClassEntityFactory.h, include/ClassException.h, include/ClassFrustum.h, include/ClassHG3DMessagePump.h, include/ClassLight.h, include/ClassLightFactory.h, include/ClassLog.h, include/ClassLogManager.h, include/ClassManualObject.h, include/ClassManualObjectFactory.h, include/ClassManualObjectSection.h, include/ClassMaterial.h, include/ClassMaterialManager.h, include/ClassMesh.h, include/ClassMeshManager.h, include/ClassMovableObject.h, include/ClassMovableObjectFactory.h, include/ClassMultiRenderTarget.h, include/ClassNode.h, include/ClassNodeAnimationTrack.h, include/ClassNumericAnimationTrack.h, include/ClassPtr.h, include/ClassRenderable.h, include/ClassRenderSystem.h, include/ClassRenderTarget.h, include/ClassRenderTexture.h, include/ClassRenderWindow.h, include/ClassResource.h, include/ClassResourceGroupManager.h, include/ClassResourceManager.h, include/ClassRoot.h, include/ClassSceneManager.h, include/ClassSceneManagerFactory.h, include/ClassSceneNode.h, include/ClassSkeleton.h, include/ClassSkeletonManager.h, include/ClassTextureManager.h, include/ClassTimeIndex.h, include/ClassVertexAnimationTrack.h, include/ClassViewport.h, include/ClassWindowEventUtilities.h, include/ClassWindowUtilsHG3D.h, include/EnumAnimationInterpolationMode.h, include/EnumAnimationRotationInterpolationMode.h, include/EnumAxisAlignedBoxCorner.h, include/EnumAxisAlignedBoxExtent.h, include/EnumBillboardChainTexCoordDirection.h, include/EnumBillboardOrigin.h, include/EnumBillboardRotationType.h, include/EnumBillboardType.h, include/EnumDataStreamAccessMode.h, include/EnumEntityVertexDataBindChoice.h, include/EnumExceptionCode.h, include/EnumFrustumPlane.h, include/EnumGpuProgramType.h, include/EnumLightType.h, include/EnumLoggingLevel.h, include/EnumLogMessageLevel.h, include/EnumMathAngleUnit.h, include/EnumMeshManagerMeshBuildType.h, include/EnumNodeTransformSpace.h, include/EnumOrientationMode.h, include/EnumProjectionType.h, include/EnumRenderOperationOperationType.h, include/EnumRenderTargetFrameBuffer.h, include/EnumRenderTargetStatFlags.h, include/EnumRootFrameEventTimeType.h, include/EnumSceneManagerBoxPlane.h, include/EnumSceneManagerIlluminationRenderStage.h, include/EnumSceneManagerPrefabType.h, include/EnumSceneManagerSpecialCaseRenderQueueMode.h, include/EnumSceneType.h, include/EnumSkeletonAnimationBlendMode.h, include/EnumStencilOperation.h, include/EnumTexCoordCalcMethod.h, include/EnumVertexAnimationTrackTargetMode.h, include/EnumVertexAnimationType.h, include/OgreDllDefines.h, include/StructColour.h, include/StructDegrees.h, include/StructHG3DClass.h, include/StructQuaternion.h, include/StructRadians.h, include/StructSharedPtr.h, include/StructVec2.h, include/StructVec3.h
 
 Library
-  Build-Depends:     base >= 3 && < 5,  HGamer3D-Data >= 0.1.9
+  Build-Depends:     base >= 3 && < 5,  HGamer3D-Data >= 0.2.0
 
   Exposed-modules:   HGamer3D.Bindings.Ogre.Utils, HGamer3D.Bindings.Ogre.ClassPtr, HGamer3D.Bindings.Ogre.StructHG3DClass, HGamer3D.Bindings.Ogre.EnumAnimationInterpolationMode, HGamer3D.Bindings.Ogre.EnumAnimationRotationInterpolationMode, HGamer3D.Bindings.Ogre.EnumAxisAlignedBoxCorner, HGamer3D.Bindings.Ogre.EnumAxisAlignedBoxExtent, HGamer3D.Bindings.Ogre.EnumBillboardChainTexCoordDirection, HGamer3D.Bindings.Ogre.EnumBillboardOrigin, HGamer3D.Bindings.Ogre.EnumBillboardRotationType, HGamer3D.Bindings.Ogre.EnumBillboardType, HGamer3D.Bindings.Ogre.EnumDataStreamAccessMode, HGamer3D.Bindings.Ogre.EnumEntityVertexDataBindChoice, HGamer3D.Bindings.Ogre.EnumExceptionCode, HGamer3D.Bindings.Ogre.EnumFrustumPlane, HGamer3D.Bindings.Ogre.EnumGpuProgramType, HGamer3D.Bindings.Ogre.EnumLightType, HGamer3D.Bindings.Ogre.EnumLoggingLevel, HGamer3D.Bindings.Ogre.EnumLogMessageLevel, HGamer3D.Bindings.Ogre.EnumMathAngleUnit, HGamer3D.Bindings.Ogre.EnumMeshManagerMeshBuildType, HGamer3D.Bindings.Ogre.EnumNodeTransformSpace, HGamer3D.Bindings.Ogre.EnumOrientationMode, HGamer3D.Bindings.Ogre.EnumProjectionType, HGamer3D.Bindings.Ogre.EnumRenderOperationOperationType, HGamer3D.Bindings.Ogre.EnumRenderTargetFrameBuffer, HGamer3D.Bindings.Ogre.EnumRenderTargetStatFlags, HGamer3D.Bindings.Ogre.EnumRootFrameEventTimeType, HGamer3D.Bindings.Ogre.EnumSceneManagerBoxPlane, HGamer3D.Bindings.Ogre.EnumSceneManagerIlluminationRenderStage, HGamer3D.Bindings.Ogre.EnumSceneManagerPrefabType, HGamer3D.Bindings.Ogre.EnumSceneManagerSpecialCaseRenderQueueMode, HGamer3D.Bindings.Ogre.EnumSceneType, HGamer3D.Bindings.Ogre.EnumSkeletonAnimationBlendMode, HGamer3D.Bindings.Ogre.EnumStencilOperation, HGamer3D.Bindings.Ogre.EnumTexCoordCalcMethod, HGamer3D.Bindings.Ogre.EnumVertexAnimationTrackTargetMode, HGamer3D.Bindings.Ogre.EnumVertexAnimationType, HGamer3D.Bindings.Ogre.StructColour, HGamer3D.Bindings.Ogre.StructDegrees, HGamer3D.Bindings.Ogre.StructQuaternion, HGamer3D.Bindings.Ogre.StructRadians, HGamer3D.Bindings.Ogre.StructSharedPtr, HGamer3D.Bindings.Ogre.StructVec2, HGamer3D.Bindings.Ogre.StructVec3, HGamer3D.Bindings.Ogre.ClassAnimation, HGamer3D.Bindings.Ogre.ClassAnimationState, HGamer3D.Bindings.Ogre.ClassAnimationStateSet, HGamer3D.Bindings.Ogre.ClassAnimationTrack, HGamer3D.Bindings.Ogre.ClassArchive, HGamer3D.Bindings.Ogre.ClassArchiveManager, HGamer3D.Bindings.Ogre.ClassBillboard, HGamer3D.Bindings.Ogre.ClassBillboardChain, HGamer3D.Bindings.Ogre.ClassBillboardChainFactory, HGamer3D.Bindings.Ogre.ClassBillboardSet, HGamer3D.Bindings.Ogre.ClassBillboardSetFactory, HGamer3D.Bindings.Ogre.ClassBone, HGamer3D.Bindings.Ogre.ClassCamera, HGamer3D.Bindings.Ogre.ClassConfigFile, HGamer3D.Bindings.Ogre.ClassControllerManager, HGamer3D.Bindings.Ogre.ClassEntity, HGamer3D.Bindings.Ogre.ClassEntityFactory, HGamer3D.Bindings.Ogre.ClassException, HGamer3D.Bindings.Ogre.ClassFrustum, HGamer3D.Bindings.Ogre.ClassHG3DMessagePump, HGamer3D.Bindings.Ogre.ClassLight, HGamer3D.Bindings.Ogre.ClassLightFactory, HGamer3D.Bindings.Ogre.ClassLog, HGamer3D.Bindings.Ogre.ClassLogManager, HGamer3D.Bindings.Ogre.ClassManualObject, HGamer3D.Bindings.Ogre.ClassManualObjectFactory, HGamer3D.Bindings.Ogre.ClassManualObjectSection, HGamer3D.Bindings.Ogre.ClassMaterial, HGamer3D.Bindings.Ogre.ClassMaterialManager, HGamer3D.Bindings.Ogre.ClassMesh, HGamer3D.Bindings.Ogre.ClassMeshManager, HGamer3D.Bindings.Ogre.ClassMovableObject, HGamer3D.Bindings.Ogre.ClassMovableObjectFactory, HGamer3D.Bindings.Ogre.ClassMultiRenderTarget, HGamer3D.Bindings.Ogre.ClassNode, HGamer3D.Bindings.Ogre.ClassNodeAnimationTrack, HGamer3D.Bindings.Ogre.ClassNumericAnimationTrack, HGamer3D.Bindings.Ogre.ClassRenderable, HGamer3D.Bindings.Ogre.ClassRenderSystem, HGamer3D.Bindings.Ogre.ClassRenderTarget, HGamer3D.Bindings.Ogre.ClassRenderTexture, HGamer3D.Bindings.Ogre.ClassRenderWindow, HGamer3D.Bindings.Ogre.ClassResource, HGamer3D.Bindings.Ogre.ClassResourceGroupManager, HGamer3D.Bindings.Ogre.ClassResourceManager, HGamer3D.Bindings.Ogre.ClassRoot, HGamer3D.Bindings.Ogre.ClassSceneManager, HGamer3D.Bindings.Ogre.ClassSceneManagerFactory, HGamer3D.Bindings.Ogre.ClassSceneNode, HGamer3D.Bindings.Ogre.ClassSkeleton, HGamer3D.Bindings.Ogre.ClassSkeletonManager, HGamer3D.Bindings.Ogre.ClassTextureManager, HGamer3D.Bindings.Ogre.ClassTimeIndex, HGamer3D.Bindings.Ogre.ClassVertexAnimationTrack, HGamer3D.Bindings.Ogre.ClassViewport, HGamer3D.Bindings.Ogre.ClassWindowEventUtilities, HGamer3D.Bindings.Ogre.ClassWindowUtilsHG3D
   Other-modules:     
diff --git a/HGamer3D/Bindings/Ogre/ClassAnimation.hs b/HGamer3D/Bindings/Ogre/ClassAnimation.hs
--- a/HGamer3D/Bindings/Ogre/ClassAnimation.hs
+++ b/HGamer3D/Bindings/Ogre/ClassAnimation.hs
@@ -54,20 +54,16 @@
 import HGamer3D.Bindings.Ogre.EnumAnimationRotationInterpolationMode
 {-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Animation -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 50 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets the name of this animation. 
-getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getName -}
+getName :: HG3DClass -> IO (String)
 getName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -76,10 +72,8 @@
   return (a2'')
 {-# LINE 55 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets the total length of the animation. 
-getLength :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getLength -}
+getLength :: HG3DClass -> IO (Float)
 getLength a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -88,12 +82,8 @@
   return (a2'')
 {-# LINE 60 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Sets the length of the animation. 
---Changing the length of an animation may invalidate existing AnimationState
-setLength :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ len
-  ->  IO ()
- -- ^ 
+{- function setLength -}
+setLength :: HG3DClass -> Float -> IO ()
 setLength a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -101,12 +91,8 @@
   return ()
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Creates a NodeAnimationTrack for animating a Node.
---
-createNodeTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle - Handle to give the track, used for accessing the track later. Must be unique within this Animation. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createNodeTrack -}
+createNodeTrack :: HG3DClass -> Int -> IO (HG3DClass)
 createNodeTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -116,12 +102,8 @@
   return (a3'')
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Creates a NumericAnimationTrack for animating any numeric value.
---
-createNumericTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle - Handle to give the track, used for accessing the track later. Must be unique within this Animation. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createNumericTrack -}
+createNumericTrack :: HG3DClass -> Int -> IO (HG3DClass)
 createNumericTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -131,13 +113,8 @@
   return (a3'')
 {-# LINE 77 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Creates a VertexAnimationTrack for animating vertex position data.
---
-createVertexTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle - Handle to give the track, used for accessing the track later. Must be unique within this Animation, and is used to identify the target. For example when applied to a Mesh, the handle must reference the index of the geometry being modified; 0 for the shared geometry, and 1+ for SubMesh geometry with the same index-1. 
-  ->  EnumVertexAnimationType  -- ^ animType - Either morph or pose animation, 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createVertexTrack -}
+createVertexTrack :: HG3DClass -> Int -> EnumVertexAnimationType -> IO (HG3DClass)
 createVertexTrack a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -148,13 +125,8 @@
   return (a4'')
 {-# LINE 84 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Creates a new AnimationTrack automatically associated with a Node. 
---This method creates a standard AnimationTrackNode
-createNodeTrack2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle - Numeric handle to give the track, used for accessing the track later. Must be unique within this Animation. 
-  ->  HG3DClass  -- ^ node - A pointer to the Node object which will be affected by this track 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createNodeTrack2 -}
+createNodeTrack2 :: HG3DClass -> Int -> HG3DClass -> IO (HG3DClass)
 createNodeTrack2 a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -165,10 +137,8 @@
   return (a4'')
 {-# LINE 91 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets the number of NodeAnimationTrack
-getNumNodeTracks :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumNodeTracks -}
+getNumNodeTracks :: HG3DClass -> IO (Int)
 getNumNodeTracks a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -177,11 +147,8 @@
   return (a2'')
 {-# LINE 96 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets a node track by it's handle. 
-getNodeTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getNodeTrack -}
+getNodeTrack :: HG3DClass -> Int -> IO (HG3DClass)
 getNodeTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -191,11 +158,8 @@
   return (a3'')
 {-# LINE 102 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Does a track exist with the given handle? 
-hasNodeTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO (Bool)
- -- ^ 
+{- function hasNodeTrack -}
+hasNodeTrack :: HG3DClass -> Int -> IO (Bool)
 hasNodeTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -205,10 +169,8 @@
   return (a3'')
 {-# LINE 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets the number of NumericAnimationTrack
-getNumNumericTracks :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumNumericTracks -}
+getNumNumericTracks :: HG3DClass -> IO (Int)
 getNumNumericTracks a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -217,11 +179,8 @@
   return (a2'')
 {-# LINE 113 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets a numeric track by it's handle. 
-getNumericTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getNumericTrack -}
+getNumericTrack :: HG3DClass -> Int -> IO (HG3DClass)
 getNumericTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -231,11 +190,8 @@
   return (a3'')
 {-# LINE 119 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Does a track exist with the given handle? 
-hasNumericTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO (Bool)
- -- ^ 
+{- function hasNumericTrack -}
+hasNumericTrack :: HG3DClass -> Int -> IO (Bool)
 hasNumericTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -245,10 +201,8 @@
   return (a3'')
 {-# LINE 125 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets the number of VertexAnimationTrack
-getNumVertexTracks :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumVertexTracks -}
+getNumVertexTracks :: HG3DClass -> IO (Int)
 getNumVertexTracks a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -257,11 +211,8 @@
   return (a2'')
 {-# LINE 130 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets a Vertex track by it's handle. 
-getVertexTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getVertexTrack -}
+getVertexTrack :: HG3DClass -> Int -> IO (HG3DClass)
 getVertexTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -271,11 +222,8 @@
   return (a3'')
 {-# LINE 136 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Does a track exist with the given handle? 
-hasVertexTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO (Bool)
- -- ^ 
+{- function hasVertexTrack -}
+hasVertexTrack :: HG3DClass -> Int -> IO (Bool)
 hasVertexTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -285,11 +233,8 @@
   return (a3'')
 {-# LINE 142 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Destroys the node track with the given handle. 
-destroyNodeTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO ()
- -- ^ 
+{- function destroyNodeTrack -}
+destroyNodeTrack :: HG3DClass -> Int -> IO ()
 destroyNodeTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -297,11 +242,8 @@
   return ()
 {-# LINE 147 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Destroys the numeric track with the given handle. 
-destroyNumericTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO ()
- -- ^ 
+{- function destroyNumericTrack -}
+destroyNumericTrack :: HG3DClass -> Int -> IO ()
 destroyNumericTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -309,11 +251,8 @@
   return ()
 {-# LINE 152 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Destroys the Vertex track with the given handle. 
-destroyVertexTrack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO ()
- -- ^ 
+{- function destroyVertexTrack -}
+destroyVertexTrack :: HG3DClass -> Int -> IO ()
 destroyVertexTrack a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -321,54 +260,40 @@
   return ()
 {-# LINE 157 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Removes and destroys all tracks making up this animation. 
-destroyAllTracks :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function destroyAllTracks -}
+destroyAllTracks :: HG3DClass -> IO ()
 destroyAllTracks a1 =
   withHG3DClass a1 $ \a1' -> 
   destroyAllTracks'_ a1' >>= \res ->
   return ()
 {-# LINE 161 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Removes and destroys all tracks making up this animation. 
-destroyAllNodeTracks :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function destroyAllNodeTracks -}
+destroyAllNodeTracks :: HG3DClass -> IO ()
 destroyAllNodeTracks a1 =
   withHG3DClass a1 $ \a1' -> 
   destroyAllNodeTracks'_ a1' >>= \res ->
   return ()
 {-# LINE 165 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Removes and destroys all tracks making up this animation. 
-destroyAllNumericTracks :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function destroyAllNumericTracks -}
+destroyAllNumericTracks :: HG3DClass -> IO ()
 destroyAllNumericTracks a1 =
   withHG3DClass a1 $ \a1' -> 
   destroyAllNumericTracks'_ a1' >>= \res ->
   return ()
 {-# LINE 169 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Removes and destroys all tracks making up this animation. 
-destroyAllVertexTracks :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function destroyAllVertexTracks -}
+destroyAllVertexTracks :: HG3DClass -> IO ()
 destroyAllVertexTracks a1 =
   withHG3DClass a1 $ \a1' -> 
   destroyAllVertexTracks'_ a1' >>= \res ->
   return ()
 {-# LINE 173 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Applies an animation given a specific time point and weight.
---Where you have associated animation tracks with objects, you can easily apply an animation to those objects by calling this method. 
-apply :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ timePos - The time position in the animation to apply. 
-  ->  Float  -- ^ weight - The influence to give to this track, 1.0 for full influence, less to blend with other animations. 
-  ->  Float  -- ^ scale - The scale to apply to translations and scalings, useful for adapting an animation to a different size target. 
-  ->  IO ()
- -- ^ 
+{- function apply -}
+apply :: HG3DClass -> Float -> Float -> Float -> IO ()
 apply a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -378,15 +303,8 @@
   return ()
 {-# LINE 180 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Applies all node tracks given a specific time point and weight to the specified node.
---It does not consider the actual node tracks are attached to. As such, it resembles the apply method for a given skeleton (see below). 
-applyToNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ node
-  ->  Float  -- ^ timePos - The time position in the animation to apply. 
-  ->  Float  -- ^ weight - The influence to give to this track, 1.0 for full influence, less to blend with other animations. 
-  ->  Float  -- ^ scale - The scale to apply to translations and scalings, useful for adapting an animation to a different size target. 
-  ->  IO ()
- -- ^ 
+{- function applyToNode -}
+applyToNode :: HG3DClass -> HG3DClass -> Float -> Float -> Float -> IO ()
 applyToNode a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -397,14 +315,8 @@
   return ()
 {-# LINE 188 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Applies all node tracks given a specific time point and weight to a given skeleton. Where you have associated animation tracks with Node
-apply2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ skeleton
-  ->  Float  -- ^ timePos - The time position in the animation to apply. 
-  ->  Float  -- ^ weight - The influence to give to this track, 1.0 for full influence, less to blend with other animations. 
-  ->  Float  -- ^ scale - The scale to apply to translations and scalings, useful for adapting an animation to a different size target. 
-  ->  IO ()
- -- ^ 
+{- function apply2 -}
+apply2 :: HG3DClass -> HG3DClass -> Float -> Float -> Float -> IO ()
 apply2 a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -415,16 +327,8 @@
   return ()
 {-# LINE 196 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Applies all vertex tracks given a specific time point and weight to a given entity.
---
-apply4 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ entity - The Entity to which this animation should be applied 
-  ->  Float  -- ^ timePos - The time position in the animation to apply. 
-  ->  Float  -- ^ weight - The weight at which the animation should be applied (only affects pose animation) 
-  ->  Bool  -- ^ software - Whether to populate the software morph vertex data 
-  ->  Bool  -- ^ hardware - Whether to populate the hardware morph vertex data 
-  ->  IO ()
- -- ^ 
+{- function apply4 -}
+apply4 :: HG3DClass -> HG3DClass -> Float -> Float -> Bool -> Bool -> IO ()
 apply4 a1 a2 a3 a4 a5 a6 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -436,12 +340,8 @@
   return ()
 {-# LINE 205 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Tells the animation how to interpolate between keyframes.
---By default, animations normally interpolate linearly between keyframes. This is fast, but when animations include quick changes in direction it can look a little unnatural because directions change instantly at keyframes. An alternative is to tell the animation to interpolate along a spline, which is more expensive in terms of calculation time, but looks smoother because major changes in direction are distributed around the keyframes rather than just at the keyframe. You can also change the default animation behaviour by calling Animation::setDefaultInterpolationMode
-setInterpolationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumAnimationInterpolationMode  -- ^ im
-  ->  IO ()
- -- ^ 
+{- function setInterpolationMode -}
+setInterpolationMode :: HG3DClass -> EnumAnimationInterpolationMode -> IO ()
 setInterpolationMode a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -449,11 +349,8 @@
   return ()
 {-# LINE 210 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets the current interpolation mode of this animation. 
---See setInterpolationMode for more info. 
-getInterpolationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumAnimationInterpolationMode)
- -- ^ 
+{- function getInterpolationMode -}
+getInterpolationMode :: HG3DClass -> IO (EnumAnimationInterpolationMode)
 getInterpolationMode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -462,12 +359,8 @@
   return (a2'')
 {-# LINE 215 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Tells the animation how to interpolate rotations.
---By default, animations interpolate linearly between rotations. This is fast but not necessarily completely accurate. If you want more accurate interpolation, use spherical interpolation, but be aware that it will incur a higher cost. You can also change the default rotation behaviour by calling Animation::setDefaultRotationInterpolationMode
-setRotationInterpolationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumAnimationRotationInterpolationMode  -- ^ im
-  ->  IO ()
- -- ^ 
+{- function setRotationInterpolationMode -}
+setRotationInterpolationMode :: HG3DClass -> EnumAnimationRotationInterpolationMode -> IO ()
 setRotationInterpolationMode a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -475,11 +368,8 @@
   return ()
 {-# LINE 220 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets the current rotation interpolation mode of this animation. 
---See setRotationInterpolationMode for more info. 
-getRotationInterpolationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumAnimationRotationInterpolationMode)
- -- ^ 
+{- function getRotationInterpolationMode -}
+getRotationInterpolationMode :: HG3DClass -> IO (EnumAnimationRotationInterpolationMode)
 getRotationInterpolationMode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -488,12 +378,8 @@
   return (a2'')
 {-# LINE 225 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Optimise an animation by removing unnecessary tracks and keyframes.
---When you export an animation, it is possible that certain tracks have been keyframed but actually don't include anything useful - the keyframes include no transformation. These tracks can be completely eliminated from the animation and thus speed up the animation. In addition, if several keyframes in a row have the same value, then they are just adding overhead and can be removed. Since track-less and identity track has difference behavior for accumulate animation blending if corresponding track presenting at other animation that is non-identity, and in normally this method didn't known about the situation of other animation, it can't deciding whether or not discards identity tracks. So there have a parameter allow you choose what you want, in case you aren't sure how to do that, you should use Skeleton::optimiseAllAnimations
-optimise :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ discardIdentityNodeTracks - If true, discard identity node tracks. 
-  ->  IO ()
- -- ^ 
+{- function optimise -}
+optimise :: HG3DClass -> Bool -> IO ()
 optimise a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -501,12 +387,8 @@
   return ()
 {-# LINE 230 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Clone this animation.
---The pointer returned from this method is the only one recorded, thus it is up to the caller to arrange for the deletion of this object. 
-clone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ newName
-  ->  IO (HG3DClass)
- -- ^ 
+{- function clone -}
+clone :: HG3DClass -> String -> IO (HG3DClass)
 clone a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -516,13 +398,8 @@
   return (a3'')
 {-# LINE 236 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Sets a base keyframe which for the skeletal / pose keyframes in this animation. Skeletal and pose animation keyframes are expressed as deltas from a given base state. By default, that is the binding setup of the skeleton, or the object space mesh positions for pose animation. However, sometimes it is useful for animators to create animations with a different starting pose, because that's more convenient, and the animation is designed to simply be added to the existing animation state and not globally averaged with other animations (this is always the case with pose animations, but is activated for skeletal animations via ANIMBLEND_CUMULATIVE). In order for this to work, the keyframes need to be 're-based' against this new starting state, for example by treating the first keyframe as the reference point (and therefore representing no change). This can be achieved by applying the inverse of this reference keyframe against all other keyframes. Since this fundamentally changes the animation, this method just marks the animation as requiring this rebase, which is performed at the next AnimationAnimation_applyBaseKeyFrame
-setUseBaseKeyFrame :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ useBaseKeyFrame - Whether a base keyframe should be used 
-  ->  Float  -- ^ keyframeTime - The time corresponding to the base keyframe, if any 
-  ->  String  -- ^ baseAnimName - Optionally a different base animation (must contain the same tracks) 
-  ->  IO ()
- -- ^ 
+{- function setUseBaseKeyFrame -}
+setUseBaseKeyFrame :: HG3DClass -> Bool -> Float -> String -> IO ()
 setUseBaseKeyFrame a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -532,10 +409,8 @@
   return ()
 {-# LINE 243 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Whether a base keyframe is being used for this Animation
-getUseBaseKeyFrame :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseBaseKeyFrame -}
+getUseBaseKeyFrame :: HG3DClass -> IO (Bool)
 getUseBaseKeyFrame a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -544,10 +419,8 @@
   return (a2'')
 {-# LINE 248 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | If a base keyframe is being used, the time of that keyframe. 
-getBaseKeyFrameTime :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBaseKeyFrameTime -}
+getBaseKeyFrameTime :: HG3DClass -> IO (Float)
 getBaseKeyFrameTime a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -556,10 +429,8 @@
   return (a2'')
 {-# LINE 253 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | If a base keyframe is being used, the Animation
-getBaseKeyFrameAnimationName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getBaseKeyFrameAnimationName -}
+getBaseKeyFrameAnimationName :: HG3DClass -> IO (String)
 getBaseKeyFrameAnimationName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -568,20 +439,16 @@
   return (a2'')
 {-# LINE 258 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Sets the default animation interpolation mode. 
---Every animation created after this option is set will have the new interpolation mode specified. You can also change the mode per animation by calling the setInterpolationMode method on the instance in question. 
-setDefaultInterpolationMode :: EnumAnimationInterpolationMode  -- ^ im
-  ->  IO ()
- -- ^ 
+{- function setDefaultInterpolationMode -}
+setDefaultInterpolationMode :: EnumAnimationInterpolationMode -> IO ()
 setDefaultInterpolationMode a1 =
   let {a1' = cIntFromEnum a1} in 
   setDefaultInterpolationMode'_ a1' >>= \res ->
   return ()
 {-# LINE 262 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets the default interpolation mode for all animations. 
+{- function getDefaultInterpolationMode -}
 getDefaultInterpolationMode :: IO (EnumAnimationInterpolationMode)
- -- ^ 
 getDefaultInterpolationMode =
   alloca $ \a1' -> 
   getDefaultInterpolationMode'_ a1' >>= \res ->
@@ -589,20 +456,16 @@
   return (a1'')
 {-# LINE 266 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Sets the default rotation interpolation mode. 
---Every animation created after this option is set will have the new interpolation mode specified. You can also change the mode per animation by calling the setInterpolationMode method on the instance in question. 
-setDefaultRotationInterpolationMode :: EnumAnimationRotationInterpolationMode  -- ^ im
-  ->  IO ()
- -- ^ 
+{- function setDefaultRotationInterpolationMode -}
+setDefaultRotationInterpolationMode :: EnumAnimationRotationInterpolationMode -> IO ()
 setDefaultRotationInterpolationMode a1 =
   let {a1' = cIntFromEnum a1} in 
   setDefaultRotationInterpolationMode'_ a1' >>= \res ->
   return ()
 {-# LINE 270 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimation.chs" #-}
 
--- | Gets the default rotation interpolation mode for all animations. 
+{- function getDefaultRotationInterpolationMode -}
 getDefaultRotationInterpolationMode :: IO (EnumAnimationRotationInterpolationMode)
- -- ^ 
 getDefaultRotationInterpolationMode =
   alloca $ \a1' -> 
   getDefaultRotationInterpolationMode'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassAnimationState.hs b/HGamer3D/Bindings/Ogre/ClassAnimationState.hs
--- a/HGamer3D/Bindings/Ogre/ClassAnimationState.hs
+++ b/HGamer3D/Bindings/Ogre/ClassAnimationState.hs
@@ -48,15 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Normal constructor with all params supplied 
-new :: String  -- ^ animName - The name of this state. 
-  ->  HG3DClass  -- ^ parent - The parent AnimationStateSet that this state will belong to. 
-  ->  Float  -- ^ timePos - The position, in seconds, where this state will begin. 
-  ->  Float  -- ^ length - The length, in seconds, of this animation state. 
-  ->  Float  -- ^ weight - Weight to apply the animation state with. 
-  ->  Bool  -- ^ enabled - Whether the animation state is enabled. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function AnimationState -}
+new :: String -> HG3DClass -> Float -> Float -> Float -> Bool -> IO (HG3DClass)
 new a1 a2 a3 a4 a5 a6 =
   withCString a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -70,20 +63,16 @@
   return (a7'')
 {-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~AnimationState -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Gets the name of the animation to which this state applies. 
-getAnimationName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getAnimationName -}
+getAnimationName :: HG3DClass -> IO (String)
 getAnimationName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -92,10 +81,8 @@
   return (a2'')
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Gets the time position for this animation. 
-getTimePosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getTimePosition -}
+getTimePosition :: HG3DClass -> IO (Float)
 getTimePosition a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -104,11 +91,8 @@
   return (a2'')
 {-# LINE 67 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Sets the time position for this animation. 
-setTimePosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ timePos
-  ->  IO ()
- -- ^ 
+{- function setTimePosition -}
+setTimePosition :: HG3DClass -> Float -> IO ()
 setTimePosition a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -116,10 +100,8 @@
   return ()
 {-# LINE 72 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Gets the total length of this animation (may be shorter than whole animation) 
-getLength :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getLength -}
+getLength :: HG3DClass -> IO (Float)
 getLength a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -128,11 +110,8 @@
   return (a2'')
 {-# LINE 77 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Sets the total length of this animation (may be shorter than whole animation) 
-setLength :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ len
-  ->  IO ()
- -- ^ 
+{- function setLength -}
+setLength :: HG3DClass -> Float -> IO ()
 setLength a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -140,10 +119,8 @@
   return ()
 {-# LINE 82 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Gets the weight (influence) of this animation. 
-getWeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getWeight -}
+getWeight :: HG3DClass -> IO (Float)
 getWeight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -152,11 +129,8 @@
   return (a2'')
 {-# LINE 87 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Sets the weight (influence) of this animation. 
-setWeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ weight
-  ->  IO ()
- -- ^ 
+{- function setWeight -}
+setWeight :: HG3DClass -> Float -> IO ()
 setWeight a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -164,12 +138,8 @@
   return ()
 {-# LINE 92 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Modifies the time position, adjusting for animation length
---This method loops at the edges if animation looping is enabled. 
-addTime :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ offset - The amount of time, in seconds, to extend the animation. 
-  ->  IO ()
- -- ^ 
+{- function addTime -}
+addTime :: HG3DClass -> Float -> IO ()
 addTime a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -177,10 +147,8 @@
   return ()
 {-# LINE 97 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Returns true if the animation has reached the end and is not looping. 
-hasEnded :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasEnded -}
+hasEnded :: HG3DClass -> IO (Bool)
 hasEnded a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -189,10 +157,8 @@
   return (a2'')
 {-# LINE 102 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Returns true if this animation is currently enabled. 
-getEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getEnabled -}
+getEnabled :: HG3DClass -> IO (Bool)
 getEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -201,11 +167,8 @@
   return (a2'')
 {-# LINE 107 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Sets whether this animation is enabled. 
-setEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setEnabled -}
+setEnabled :: HG3DClass -> Bool -> IO ()
 setEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -213,11 +176,8 @@
   return ()
 {-# LINE 112 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Sets whether or not an animation loops at the start and end of the animation if the time continues to be altered. 
-setLoop :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ loop
-  ->  IO ()
- -- ^ 
+{- function setLoop -}
+setLoop :: HG3DClass -> Bool -> IO ()
 setLoop a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -225,10 +185,8 @@
   return ()
 {-# LINE 117 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Gets whether or not this animation loops. 
-getLoop :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getLoop -}
+getLoop :: HG3DClass -> IO (Bool)
 getLoop a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -237,12 +195,8 @@
   return (a2'')
 {-# LINE 122 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Copies the states from another animation state, preserving the animation name
---
-copyStateFrom :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ animState - Reference to animation state which will use as source. 
-  ->  IO ()
- -- ^ 
+{- function copyStateFrom -}
+copyStateFrom :: HG3DClass -> HG3DClass -> IO ()
 copyStateFrom a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -250,10 +204,8 @@
   return ()
 {-# LINE 127 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Get the parent animation state set. 
-getParent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getParent -}
+getParent :: HG3DClass -> IO (HG3DClass)
 getParent a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -262,12 +214,8 @@
   return (a2'')
 {-# LINE 132 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Create a new blend mask with the given number of entries.  - Details: In addition to assigning a single weight value to a skeletal animation, it may be desirable to assign animation weights per bone using a 'blend mask'.
-createBlendMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ blendMaskSizeHint
-  ->  Float  -- ^ initialWeight
-  ->  IO ()
- -- ^ 
+{- function createBlendMask -}
+createBlendMask :: HG3DClass -> Int -> Float -> IO ()
 createBlendMask a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -276,20 +224,16 @@
   return ()
 {-# LINE 138 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Destroy the currently set blend mask. 
-destroyBlendMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function destroyBlendMask -}
+destroyBlendMask :: HG3DClass -> IO ()
 destroyBlendMask a1 =
   withHG3DClass a1 $ \a1' -> 
   destroyBlendMask'_ a1' >>= \res ->
   return ()
 {-# LINE 142 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Return whether there is currently a valid blend mask set. 
-hasBlendMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasBlendMask -}
+hasBlendMask :: HG3DClass -> IO (Bool)
 hasBlendMask a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -298,12 +242,8 @@
   return (a2'')
 {-# LINE 147 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Set the weight for the bone identified by the given handle. 
-setBlendMaskEntry :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ boneHandle
-  ->  Float  -- ^ weight
-  ->  IO ()
- -- ^ 
+{- function setBlendMaskEntry -}
+setBlendMaskEntry :: HG3DClass -> Int -> Float -> IO ()
 setBlendMaskEntry a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -312,11 +252,8 @@
   return ()
 {-# LINE 153 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationState.chs" #-}
 
--- | Get the weight for the bone identified by the given handle. 
-getBlendMaskEntry :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ boneHandle
-  ->  IO (Float)
- -- ^ 
+{- function getBlendMaskEntry -}
+getBlendMaskEntry :: HG3DClass -> Int -> IO (Float)
 getBlendMaskEntry a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
diff --git a/HGamer3D/Bindings/Ogre/ClassAnimationStateSet.hs b/HGamer3D/Bindings/Ogre/ClassAnimationStateSet.hs
--- a/HGamer3D/Bindings/Ogre/ClassAnimationStateSet.hs
+++ b/HGamer3D/Bindings/Ogre/ClassAnimationStateSet.hs
@@ -48,26 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationStateSet.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~AnimationStateSet -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationStateSet.chs" #-}
 
--- | Create a new AnimationState instance. 
---
-createAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ animName - The name of the animation 
-  ->  Float  -- ^ timePos - Starting time position 
-  ->  Float  -- ^ length - Length of the animation to play 
-  ->  Float  -- ^ weight - Weight to apply the animation with 
-  ->  Bool  -- ^ enabled - Whether the animation is enabled 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createAnimationState -}
+createAnimationState :: HG3DClass -> String -> Float -> Float -> Float -> Bool -> IO (HG3DClass)
 createAnimationState a1 a2 a3 a4 a5 a6 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -81,11 +71,8 @@
   return (a7'')
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationStateSet.chs" #-}
 
--- | Get an animation state by the name of the animation. 
-getAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAnimationState -}
+getAnimationState :: HG3DClass -> String -> IO (HG3DClass)
 getAnimationState a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -95,11 +82,8 @@
   return (a3'')
 {-# LINE 63 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationStateSet.chs" #-}
 
--- | Tests if state for the named animation is present. 
-hasAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
+{- function hasAnimationState -}
+hasAnimationState :: HG3DClass -> String -> IO (Bool)
 hasAnimationState a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -109,11 +93,8 @@
   return (a3'')
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationStateSet.chs" #-}
 
--- | Remove animation state with the given name. 
-removeAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function removeAnimationState -}
+removeAnimationState :: HG3DClass -> String -> IO ()
 removeAnimationState a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -121,21 +102,16 @@
   return ()
 {-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationStateSet.chs" #-}
 
--- | Remove all animation states. 
-removeAllAnimationStates :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAllAnimationStates -}
+removeAllAnimationStates :: HG3DClass -> IO ()
 removeAllAnimationStates a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAllAnimationStates'_ a1' >>= \res ->
   return ()
 {-# LINE 78 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationStateSet.chs" #-}
 
--- | Copy the state of any matching animation states from this to another. 
-copyMatchingState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ target
-  ->  IO ()
- -- ^ 
+{- function copyMatchingState -}
+copyMatchingState :: HG3DClass -> HG3DClass -> IO ()
 copyMatchingState a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -143,10 +119,8 @@
   return ()
 {-# LINE 83 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationStateSet.chs" #-}
 
--- | Tests if exists enabled animation state in this set. 
-hasEnabledAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasEnabledAnimationState -}
+hasEnabledAnimationState :: HG3DClass -> IO (Bool)
 hasEnabledAnimationState a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassAnimationTrack.hs b/HGamer3D/Bindings/Ogre/ClassAnimationTrack.hs
--- a/HGamer3D/Bindings/Ogre/ClassAnimationTrack.hs
+++ b/HGamer3D/Bindings/Ogre/ClassAnimationTrack.hs
@@ -48,20 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationTrack.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~AnimationTrack -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationTrack.chs" #-}
 
--- | Get the handle associated with this track. 
-getHandle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getHandle -}
+getHandle :: HG3DClass -> IO (Int)
 getHandle a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -70,10 +66,8 @@
   return (a2'')
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationTrack.chs" #-}
 
--- | Returns the number of keyframes in this animation. 
-getNumKeyFrames :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumKeyFrames -}
+getNumKeyFrames :: HG3DClass -> IO (Int)
 getNumKeyFrames a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -82,11 +76,8 @@
   return (a2'')
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationTrack.chs" #-}
 
--- | Removes a KeyFrame
-removeKeyFrame :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO ()
- -- ^ 
+{- function removeKeyFrame -}
+removeKeyFrame :: HG3DClass -> Int -> IO ()
 removeKeyFrame a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -94,24 +85,16 @@
   return ()
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationTrack.chs" #-}
 
--- | Removes all the KeyFrames from this track. 
-removeAllKeyFrames :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAllKeyFrames -}
+removeAllKeyFrames :: HG3DClass -> IO ()
 removeAllKeyFrames a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAllKeyFrames'_ a1' >>= \res ->
   return ()
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationTrack.chs" #-}
 
--- | Applies an animation track to the designated target.
---
-apply :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ timeIndex - The time position in the animation to apply. 
-  ->  Float  -- ^ weight - The influence to give to this track, 1.0 for full influence, less to blend with other animations. 
-  ->  Float  -- ^ scale - The scale to apply to translations and scalings, useful for adapting an animation to a different size target. 
-  ->  IO ()
- -- ^ 
+{- function apply -}
+apply :: HG3DClass -> HG3DClass -> Float -> Float -> IO ()
 apply a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -121,11 +104,8 @@
   return ()
 {-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationTrack.chs" #-}
 
--- | Method to determine if this track has any KeyFrames which are
---
-hasNonZeroKeyFrames :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasNonZeroKeyFrames -}
+hasNonZeroKeyFrames :: HG3DClass -> IO (Bool)
 hasNonZeroKeyFrames a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -134,20 +114,16 @@
   return (a2'')
 {-# LINE 78 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationTrack.chs" #-}
 
--- | Optimise the current track by removing any duplicate keyframes. 
-optimise :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function optimise -}
+optimise :: HG3DClass -> IO ()
 optimise a1 =
   withHG3DClass a1 $ \a1' -> 
   optimise'_ a1' >>= \res ->
   return ()
 {-# LINE 82 ".\\HGamer3D\\Bindings\\Ogre\\ClassAnimationTrack.chs" #-}
 
--- | Returns the parent Animation
-getParent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getParent -}
+getParent :: HG3DClass -> IO (HG3DClass)
 getParent a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassArchive.hs b/HGamer3D/Bindings/Ogre/ClassArchive.hs
--- a/HGamer3D/Bindings/Ogre/ClassArchive.hs
+++ b/HGamer3D/Bindings/Ogre/ClassArchive.hs
@@ -48,20 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchive.chs" #-}
 
--- | Default destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Archive -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchive.chs" #-}
 
--- | Get the name of this archive. 
-getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getName -}
+getName :: HG3DClass -> IO (String)
 getName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -70,10 +66,8 @@
   return (a2'')
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchive.chs" #-}
 
--- | Returns whether this archive is case sensitive in the way it matches files. 
-isCaseSensitive :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isCaseSensitive -}
+isCaseSensitive :: HG3DClass -> IO (Bool)
 isCaseSensitive a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -82,32 +76,24 @@
   return (a2'')
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchive.chs" #-}
 
--- | Loads the archive.
---This initializes all the internal data of the class. Do not call this function directly, it is meant to be used only by the ArchiveManager
-load :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function load -}
+load :: HG3DClass -> IO ()
 load a1 =
   withHG3DClass a1 $ \a1' -> 
   load'_ a1' >>= \res ->
   return ()
 {-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchive.chs" #-}
 
--- | Unloads the archive.
---Do not call this function directly, it is meant to be used only by the ArchiveManager
-unload :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function unload -}
+unload :: HG3DClass -> IO ()
 unload a1 =
   withHG3DClass a1 $ \a1' -> 
   unload'_ a1' >>= \res ->
   return ()
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchive.chs" #-}
 
--- | Reports whether this Archive
-isReadOnly :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isReadOnly -}
+isReadOnly :: HG3DClass -> IO (Bool)
 isReadOnly a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -116,12 +102,8 @@
   return (a2'')
 {-# LINE 70 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchive.chs" #-}
 
--- | Delete a named file.
---Not possible on read-only archives 
-remove :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename - The fully qualified name of the file 
-  ->  IO ()
- -- ^ 
+{- function remove -}
+remove :: HG3DClass -> String -> IO ()
 remove a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -129,11 +111,8 @@
   return ()
 {-# LINE 75 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchive.chs" #-}
 
--- | Find out if the named file exists (note: fully qualified filename required) 
-exists :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  IO (Bool)
- -- ^ 
+{- function exists -}
+exists :: HG3DClass -> String -> IO (Bool)
 exists a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -143,10 +122,8 @@
   return (a3'')
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchive.chs" #-}
 
--- | Return the type code of this Archive
-getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getType -}
+getType :: HG3DClass -> IO (String)
 getType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassArchiveManager.hs b/HGamer3D/Bindings/Ogre/ClassArchiveManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassArchiveManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassArchiveManager.hs
@@ -48,22 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchiveManager.chs" #-}
 
--- | Default destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~ArchiveManager -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchiveManager.chs" #-}
 
--- | Opens an archive for file reading. The archives are created using class factories within extension libraries. If the function fails, an exception is thrown. 
-load :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename - The filename that will be opened 
-  ->  String  -- ^ archiveType
-  ->  IO (HG3DClass)
- -- ^ return value - If the function succeeds, a valid pointer to an     
+{- function load -}
+load :: HG3DClass -> String -> String -> IO (HG3DClass)
 load a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -74,12 +68,8 @@
   return (a4'')
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchiveManager.chs" #-}
 
--- | Unloads an archive.
---You must ensure that this archive is not being used before removing it. 
-unload :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ arch
-  ->  IO ()
- -- ^ 
+{- function unload -}
+unload :: HG3DClass -> HG3DClass -> IO ()
 unload a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -87,12 +77,8 @@
   return ()
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchiveManager.chs" #-}
 
--- | Unloads an archive by name.
---You must ensure that this archive is not being used before removing it. 
-unload2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  IO ()
- -- ^ 
+{- function unload2 -}
+unload2 :: HG3DClass -> String -> IO ()
 unload2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -100,10 +86,8 @@
   return ()
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchiveManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingleton -}
 getSingleton :: IO (HG3DClass)
- -- ^ 
 getSingleton =
   alloca $ \a1' -> 
   getSingleton'_ a1' >>= \res ->
@@ -111,10 +95,8 @@
   return (a1'')
 {-# LINE 68 ".\\HGamer3D\\Bindings\\Ogre\\ClassArchiveManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingletonPtr -}
 getSingletonPtr :: IO (HG3DClass)
- -- ^ 
 getSingletonPtr =
   alloca $ \a1' -> 
   getSingletonPtr'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassBillboard.hs b/HGamer3D/Bindings/Ogre/ClassBillboard.hs
--- a/HGamer3D/Bindings/Ogre/ClassBillboard.hs
+++ b/HGamer3D/Bindings/Ogre/ClassBillboard.hs
@@ -54,9 +54,8 @@
 import HGamer3D.Bindings.Ogre.StructColour
 {-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Default constructor. 
+{- function Billboard -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -64,20 +63,16 @@
   return (a1'')
 {-# LINE 50 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Default destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Billboard -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Get the rotation of the billboard. This rotation is relative to the center of the billboard. 
-getRotation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Radians)
- -- ^ 
+{- function getRotation -}
+getRotation :: HG3DClass -> IO (Radians)
 getRotation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -86,11 +81,8 @@
   return (a2'')
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Set the rotation of the billboard. This rotation is relative to the center of the billboard. 
-setRotation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ rotation
-  ->  IO ()
- -- ^ 
+{- function setRotation -}
+setRotation :: HG3DClass -> Radians -> IO ()
 setRotation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -98,11 +90,8 @@
   return ()
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Set the position of the billboard. This position is relative to a point on the quad which is the billboard. Depending on the BillboardSetBillboardSet::setBillboardOrigin
-setPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ position
-  ->  IO ()
- -- ^ 
+{- function setPosition -}
+setPosition :: HG3DClass -> Vec3 -> IO ()
 setPosition a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -110,13 +99,8 @@
   return ()
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Set the position of the billboard. This position is relative to a point on the quad which is the billboard. Depending on the BillboardSetBillboardSet::setBillboardOrigin
-setPosition2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function setPosition2 -}
+setPosition2 :: HG3DClass -> Float -> Float -> Float -> IO ()
 setPosition2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -126,10 +110,8 @@
   return ()
 {-# LINE 76 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Get the position of the billboard. This position is relative to a point on the quad which is the billboard. Depending on the BillboardSetBillboardSet::setBillboardOrigin
-getPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getPosition -}
+getPosition :: HG3DClass -> IO (Vec3)
 getPosition a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -138,12 +120,8 @@
   return (a2'')
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Sets the width and height for this billboard. Note that it is most efficient for every billboard in a BillboardSetBillboardSet::setDefaultDimensions
-setDimensions :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ width
-  ->  Float  -- ^ height
-  ->  IO ()
- -- ^ 
+{- function setDimensions -}
+setDimensions :: HG3DClass -> Float -> Float -> IO ()
 setDimensions a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -152,21 +130,16 @@
   return ()
 {-# LINE 87 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Resets this BillboardBillboardSet
-resetDimensions :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function resetDimensions -}
+resetDimensions :: HG3DClass -> IO ()
 resetDimensions a1 =
   withHG3DClass a1 $ \a1' -> 
   resetDimensions'_ a1' >>= \res ->
   return ()
 {-# LINE 91 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Sets the colour of this billboard. Billboards can be tinted based on a base colour. This allows variations in colour irrespective of the base colour of the material allowing more varied billboards. The default colour is white. The tinting is effected using vertex colours. 
-setColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ colour
-  ->  IO ()
- -- ^ 
+{- function setColour -}
+setColour :: HG3DClass -> Colour -> IO ()
 setColour a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -174,10 +147,8 @@
   return ()
 {-# LINE 96 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Gets the colour of this billboard. 
-getColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Colour)
- -- ^ 
+{- function getColour -}
+getColour :: HG3DClass -> IO (Colour)
 getColour a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -186,10 +157,8 @@
   return (a2'')
 {-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Returns true if this billboard deviates from the BillboardSetBillboard::setDimensionsBillboard::setDimensions
-hasOwnDimensions :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasOwnDimensions -}
+hasOwnDimensions :: HG3DClass -> IO (Bool)
 hasOwnDimensions a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -198,10 +167,8 @@
   return (a2'')
 {-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Retrieves the billboard's personal width, if hasOwnDimensions is true. 
-getOwnWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getOwnWidth -}
+getOwnWidth :: HG3DClass -> IO (Float)
 getOwnWidth a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -210,10 +177,8 @@
   return (a2'')
 {-# LINE 111 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Retrieves the billboard's personal width, if hasOwnDimensions is true. 
-getOwnHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getOwnHeight -}
+getOwnHeight :: HG3DClass -> IO (Float)
 getOwnHeight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -222,10 +187,8 @@
   return (a2'')
 {-# LINE 116 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | Returns true if this billboard use individual texture coordinate rect (i.e. if the Billboard::setTexcoordRectBillboardSetBillboard::setTexcoordIndexBillboard::setTexcoordIndex()Billboard::setTexcoordRect()
-isUseTexcoordRect :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isUseTexcoordRect -}
+isUseTexcoordRect :: HG3DClass -> IO (Bool)
 isUseTexcoordRect a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -234,11 +197,8 @@
   return (a2'')
 {-# LINE 121 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | setTexcoordIndex()BillboardSet::setTextureCoords()
-setTexcoordIndex :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ texcoordIndex
-  ->  IO ()
- -- ^ 
+{- function setTexcoordIndex -}
+setTexcoordIndex :: HG3DClass -> Int -> IO ()
 setTexcoordIndex a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -246,10 +206,8 @@
   return ()
 {-# LINE 126 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | getTexcoordIndex()setTexcoordIndex()This value is useful only when isUseTexcoordRect return false. 
-getTexcoordIndex :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getTexcoordIndex -}
+getTexcoordIndex :: HG3DClass -> IO (Int)
 getTexcoordIndex a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -258,14 +216,8 @@
   return (a2'')
 {-# LINE 131 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboard.chs" #-}
 
--- | setTexcoordRect()
-setTexcoordRect2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ u0
-  ->  Float  -- ^ v0
-  ->  Float  -- ^ u1
-  ->  Float  -- ^ v1
-  ->  IO ()
- -- ^ 
+{- function setTexcoordRect2 -}
+setTexcoordRect2 :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 setTexcoordRect2 a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
diff --git a/HGamer3D/Bindings/Ogre/ClassBillboardChain.hs b/HGamer3D/Bindings/Ogre/ClassBillboardChain.hs
--- a/HGamer3D/Bindings/Ogre/ClassBillboardChain.hs
+++ b/HGamer3D/Bindings/Ogre/ClassBillboardChain.hs
@@ -54,21 +54,16 @@
 import HGamer3D.Bindings.Ogre.StructSharedPtr
 {-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | destructor 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~BillboardChain -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 50 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Set the maximum number of chain elements per chain 
-setMaxChainElements :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ maxElements
-  ->  IO ()
- -- ^ 
+{- function setMaxChainElements -}
+setMaxChainElements :: HG3DClass -> Int -> IO ()
 setMaxChainElements a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -76,10 +71,8 @@
   return ()
 {-# LINE 55 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Get the maximum number of chain elements per chain 
-getMaxChainElements :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getMaxChainElements -}
+getMaxChainElements :: HG3DClass -> IO (Int)
 getMaxChainElements a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -88,11 +81,8 @@
   return (a2'')
 {-# LINE 60 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Set the number of chain segments (this class can render multiple chains at once using the same material). 
-setNumberOfChains :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ numChains
-  ->  IO ()
- -- ^ 
+{- function setNumberOfChains -}
+setNumberOfChains :: HG3DClass -> Int -> IO ()
 setNumberOfChains a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -100,11 +90,8 @@
   return ()
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Get the number of chain segments (this class can render multiple chains
---
-getNumberOfChains :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumberOfChains -}
+getNumberOfChains :: HG3DClass -> IO (Int)
 getNumberOfChains a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -113,13 +100,8 @@
   return (a2'')
 {-# LINE 70 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Sets whether texture coordinate information should be included in the
---final buffers generated.
---You must use either texture coordinates or vertex colour since the vertices have no normals and without one of these there is no source of colour for the vertices. 
-setUseTextureCoords :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ use
-  ->  IO ()
- -- ^ 
+{- function setUseTextureCoords -}
+setUseTextureCoords :: HG3DClass -> Bool -> IO ()
 setUseTextureCoords a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -127,10 +109,8 @@
   return ()
 {-# LINE 75 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Gets whether texture coordinate information should be included in the final buffers generated. 
-getUseTextureCoords :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseTextureCoords -}
+getUseTextureCoords :: HG3DClass -> IO (Bool)
 getUseTextureCoords a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -139,13 +119,8 @@
   return (a2'')
 {-# LINE 80 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Sets the direction in which texture coords specified on each element
---are deemed to run along the length of the chain.
---
-setTextureCoordDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumBillboardChainTexCoordDirection  -- ^ dir - The direction, default is TCD_U. 
-  ->  IO ()
- -- ^ 
+{- function setTextureCoordDirection -}
+setTextureCoordDirection :: HG3DClass -> EnumBillboardChainTexCoordDirection -> IO ()
 setTextureCoordDirection a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -153,10 +128,8 @@
   return ()
 {-# LINE 85 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Gets the direction in which texture coords specified on each element are deemed to run. 
-getTextureCoordDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumBillboardChainTexCoordDirection)
- -- ^ 
+{- function getTextureCoordDirection -}
+getTextureCoordDirection :: HG3DClass -> IO (EnumBillboardChainTexCoordDirection)
 getTextureCoordDirection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -165,14 +138,8 @@
   return (a2'')
 {-# LINE 90 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Set the range of the texture coordinates generated across the width of
---the chain elements.
---
-setOtherTextureCoordRange :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ start - Start coordinate, default 0.0 
-  ->  Float  -- ^ end - End coordinate, default 1.0 
-  ->  IO ()
- -- ^ 
+{- function setOtherTextureCoordRange -}
+setOtherTextureCoordRange :: HG3DClass -> Float -> Float -> IO ()
 setOtherTextureCoordRange a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -181,13 +148,8 @@
   return ()
 {-# LINE 96 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Sets whether vertex colour information should be included in the
---final buffers generated.
---You must use either texture coordinates or vertex colour since the vertices have no normals and without one of these there is no source of colour for the vertices. 
-setUseVertexColours :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ use
-  ->  IO ()
- -- ^ 
+{- function setUseVertexColours -}
+setUseVertexColours :: HG3DClass -> Bool -> IO ()
 setUseVertexColours a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -195,10 +157,8 @@
   return ()
 {-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Gets whether vertex colour information should be included in the final buffers generated. 
-getUseVertexColours :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseVertexColours -}
+getUseVertexColours :: HG3DClass -> IO (Bool)
 getUseVertexColours a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -207,11 +167,8 @@
   return (a2'')
 {-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Sets whether or not the buffers created for this object are suitable for dynamic alteration. 
-setDynamic :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ dyn
-  ->  IO ()
- -- ^ 
+{- function setDynamic -}
+setDynamic :: HG3DClass -> Bool -> IO ()
 setDynamic a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -219,10 +176,8 @@
   return ()
 {-# LINE 111 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Gets whether or not the buffers created for this object are suitable for dynamic alteration. 
-getDynamic :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getDynamic -}
+getDynamic :: HG3DClass -> IO (Bool)
 getDynamic a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -231,12 +186,8 @@
   return (a2'')
 {-# LINE 116 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Remove an element from the 'tail' of a chain.
---
-removeChainElement :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ chainIndex - The index of the chain 
-  ->  IO ()
- -- ^ 
+{- function removeChainElement -}
+removeChainElement :: HG3DClass -> Int -> IO ()
 removeChainElement a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -244,11 +195,8 @@
   return ()
 {-# LINE 121 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Returns the number of chain elements. 
-getNumChainElements :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ chainIndex
-  ->  IO (Int)
- -- ^ 
+{- function getNumChainElements -}
+getNumChainElements :: HG3DClass -> Int -> IO (Int)
 getNumChainElements a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -258,11 +206,8 @@
   return (a3'')
 {-# LINE 127 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Remove all elements of a given chain (but leave the chain intact). 
-clearChain :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ chainIndex
-  ->  IO ()
- -- ^ 
+{- function clearChain -}
+clearChain :: HG3DClass -> Int -> IO ()
 clearChain a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -270,24 +215,16 @@
   return ()
 {-# LINE 132 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Remove all elements from all chains (but leave the chains themselves intact). 
-clearAllChains :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function clearAllChains -}
+clearAllChains :: HG3DClass -> IO ()
 clearAllChains a1 =
   withHG3DClass a1 $ \a1' -> 
   clearAllChains'_ a1' >>= \res ->
   return ()
 {-# LINE 136 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Sets whether the billboard should always be facing the camera or a custom direction
---set by each point element.
---Billboards facing the camera are useful for smoke trails, light beams, etc by simulating a cylinder. However, because of this property, wide trails can cause several artefacts unless the head is properly covered. Therefore, non-camera-facing billboards are much more convenient for leaving big trails of movement from thin objects, for example a sword swing as seen in many fighting games. 
-setFaceCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ faceCamera - True to be always facing the camera (Default value: True) 
-  ->  Vec3  -- ^ normalVector - Only used when faceCamera == false. Must be a non-zero vector. This vector is the "point of reference" for each point orientation. For example, if normalVector is Vector3::UNIT_Z, and the point's orientation is an identity matrix, the segment corresponding to that point will be facing towards UNIT_Z This vector is internally normalized. 
-  ->  IO ()
- -- ^ 
+{- function setFaceCamera -}
+setFaceCamera :: HG3DClass -> Bool -> Vec3 -> IO ()
 setFaceCamera a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -296,10 +233,8 @@
   return ()
 {-# LINE 142 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Get the material name in use. 
-getMaterialName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMaterialName -}
+getMaterialName :: HG3DClass -> IO (String)
 getMaterialName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -308,12 +243,8 @@
   return (a2'')
 {-# LINE 147 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Set the material name to use for rendering. 
-setMaterialName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  String  -- ^ groupName
-  ->  IO ()
- -- ^ 
+{- function setMaterialName -}
+setMaterialName :: HG3DClass -> String -> String -> IO ()
 setMaterialName a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -322,12 +253,8 @@
   return ()
 {-# LINE 153 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Returns the camera-relative squared depth of this renderable.
---Used to sort transparent objects. Squared depth is used rather than actual depth to avoid having to perform a square root on the result. 
-getSquaredViewDepth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ cam
-  ->  IO (Float)
- -- ^ 
+{- function getSquaredViewDepth -}
+getSquaredViewDepth :: HG3DClass -> HG3DClass -> IO (Float)
 getSquaredViewDepth a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -337,10 +264,8 @@
   return (a3'')
 {-# LINE 159 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Retrieves the radius of the origin-centered bounding sphere for this object. 
-getBoundingRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundingRadius -}
+getBoundingRadius :: HG3DClass -> IO (Float)
 getBoundingRadius a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -349,11 +274,8 @@
   return (a2'')
 {-# LINE 164 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Retrieves a weak reference to the material this renderable object uses.
---Note that the Renderable
-getMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (SharedPtr)
- -- ^ 
+{- function getMaterial -}
+getMaterial :: HG3DClass -> IO (SharedPtr)
 getMaterial a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -362,10 +284,8 @@
   return (a2'')
 {-# LINE 169 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Returns the type name of this object. 
-getMovableType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMovableType -}
+getMovableType :: HG3DClass -> IO (String)
 getMovableType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -374,13 +294,8 @@
   return (a2'')
 {-# LINE 174 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChain.chs" #-}
 
--- | Called just prior to the Renderable being rendered. 
---OGRE is a queued renderer, so the actual render commands are executed at a later time than the point at which an object is discovered to be visible. This allows ordering & grouping of renders without the discovery process having to be aware of it. It also means OGRE uses declarative render information rather than immediate mode rendering - this is very useful in that certain effects and processes can automatically be applied to a wide range of scenes, but the downside is that special cases are more difficult to handle, because there is not the declared state to cope with it. This method allows a RenderableRenderableRenderable
-preRender :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ sm
-  ->  HG3DClass  -- ^ rsys
-  ->  IO (Bool)
- -- ^ return value - true if the automatic render should proceed, false to skip it on the assumption that the     
+{- function preRender -}
+preRender :: HG3DClass -> HG3DClass -> HG3DClass -> IO (Bool)
 preRender a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassBillboardChainFactory.hs b/HGamer3D/Bindings/Ogre/ClassBillboardChainFactory.hs
--- a/HGamer3D/Bindings/Ogre/ClassBillboardChainFactory.hs
+++ b/HGamer3D/Bindings/Ogre/ClassBillboardChainFactory.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChainFactory.chs" #-}
 
--- | 
+{- function BillboardChainFactory -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,20 +57,16 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChainFactory.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~BillboardChainFactory -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChainFactory.chs" #-}
 
--- | Get the type of the object to be created. 
-getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getType -}
+getType :: HG3DClass -> IO (String)
 getType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -80,11 +75,8 @@
   return (a2'')
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardChainFactory.chs" #-}
 
--- | Destroy an instance of the object 
-destroyInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
+{- function destroyInstance -}
+destroyInstance :: HG3DClass -> HG3DClass -> IO ()
 destroyInstance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassBillboardSet.hs b/HGamer3D/Bindings/Ogre/ClassBillboardSet.hs
--- a/HGamer3D/Bindings/Ogre/ClassBillboardSet.hs
+++ b/HGamer3D/Bindings/Ogre/ClassBillboardSet.hs
@@ -60,12 +60,8 @@
 import HGamer3D.Bindings.Ogre.EnumBillboardType
 {-# LINE 48 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Usual constructor - this is called by the SceneManagerBillboardSet::setAutoextend
-new :: String  -- ^ name - The name to give the billboard set (must be unique) 
-  ->  Int  -- ^ poolSize - The initial size of the billboard pool. Estimate of the number of billboards which will be required, and pass it using this parameter. The set will preallocate this number to avoid memory fragmentation. The default behaviour once this pool has run out is to double it. 
-  ->  Bool  -- ^ externalDataSource - If true, the source of data for drawing the billboards will not be the internal billboard list, but external data. When driving the billboard from external data, you must call _notifyCurrentCamera to reorient the billboards, setPoolSize to set the maximum billboards you want to use, beginBillboards to start the update, and injectBillboard per billboard, followed by endBillboards. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function BillboardSet2 -}
+new :: String -> Int -> Bool -> IO (HG3DClass)
 new a1 a2 a3 =
   withCString a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -76,22 +72,16 @@
   return (a4'')
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~BillboardSet -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 60 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Creates a new billboard and adds it to this set. Behaviour once the billboard pool has been exhausted depends on the BillboardSet::setAutoextendPool option. On failiure (i.e. no more space and can't autoextend), NULLBillboardSet::setAutoextend
-createBillboard :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ position - The position of the new billboard realtive to the certer of the set 
-  ->  Colour  -- ^ colour - Optional base colour of the billboard. 
-  ->  IO (HG3DClass)
- -- ^ return value - On success, a pointer to a newly created     
+{- function createBillboard -}
+createBillboard :: HG3DClass -> Vec3 -> Colour -> IO (HG3DClass)
 createBillboard a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -102,14 +92,8 @@
   return (a4'')
 {-# LINE 67 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Creates a new billboard and adds it to this set. Behaviour once the billboard pool has been exhausted depends on the BillboardSet::setAutoextendPool option. On failure (i.e. no more space and can't autoextend), NULLBillboardSet::setAutoextend
-createBillboard2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z - The position of the new billboard relative to the center of the set 
-  ->  Colour  -- ^ colour - Optional base colour of the billboard. 
-  ->  IO (HG3DClass)
- -- ^ return value - On success, a pointer to a newly created     
+{- function createBillboard2 -}
+createBillboard2 :: HG3DClass -> Float -> Float -> Float -> Colour -> IO (HG3DClass)
 createBillboard2 a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -122,10 +106,8 @@
   return (a6'')
 {-# LINE 76 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Returns the number of active billboards which currently make up this set. 
-getNumBillboards :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumBillboards -}
+getNumBillboards :: HG3DClass -> IO (Int)
 getNumBillboards a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -134,11 +116,8 @@
   return (a2'')
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Tells the set whether to allow automatic extension of the pool of billboards. A BillboardSetThe default behaviour is to allow the pool to extend (typically this allocates double the current pool of billboards when the pool is expended), equivalent to calling this method with autoExtend = true. If you set the parameter to false however, any attempt to create a new billboard when the pool has expired will simply fail silently, returning a null pointer. 
-setAutoextend :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ autoextend - true to double the pool every time it runs out, false to fail silently. 
-  ->  IO ()
- -- ^ 
+{- function setAutoextend -}
+setAutoextend :: HG3DClass -> Bool -> IO ()
 setAutoextend a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -146,10 +125,8 @@
   return ()
 {-# LINE 86 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Returns true if the billboard pool automatically extends. BillboardSet::setAutoextend
-getAutoextend :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getAutoextend -}
+getAutoextend :: HG3DClass -> IO (Bool)
 getAutoextend a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -158,11 +135,8 @@
   return (a2'')
 {-# LINE 91 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Enables sorting for this BillboardSet
-setSortingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ sortenable - true to sort the billboards according to their distance to the camera 
-  ->  IO ()
- -- ^ 
+{- function setSortingEnabled -}
+setSortingEnabled :: HG3DClass -> Bool -> IO ()
 setSortingEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -170,10 +144,8 @@
   return ()
 {-# LINE 96 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Returns true if sorting of billboards is enabled based on their distance from the camera BillboardSet::setSortingEnabled
-getSortingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getSortingEnabled -}
+getSortingEnabled :: HG3DClass -> IO (Bool)
 getSortingEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -182,11 +154,8 @@
   return (a2'')
 {-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Adjusts the size of the pool of billboards available in this set. See the BillboardSet::setAutoextend
-setPoolSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ size - The new size for the pool. 
-  ->  IO ()
- -- ^ 
+{- function setPoolSize -}
+setPoolSize :: HG3DClass -> Int -> IO ()
 setPoolSize a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -194,10 +163,8 @@
   return ()
 {-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Returns the current size of the billboard pool. BillboardSet::setAutoextend
-getPoolSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ return value - The current size of the billboard pool.     
+{- function getPoolSize -}
+getPoolSize :: HG3DClass -> IO (Int)
 getPoolSize a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -206,21 +173,16 @@
   return (a2'')
 {-# LINE 111 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Empties this set of all billboards. 
-clear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function clear -}
+clear :: HG3DClass -> IO ()
 clear a1 =
   withHG3DClass a1 $ \a1' -> 
   clear'_ a1' >>= \res ->
   return ()
 {-# LINE 115 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Returns a pointer to the billboard at the supplied index. This method requires linear time since the billboard list is a linked list. On failure, NULL
-getBillboard :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index - The index of the billboard that is requested. 
-  ->  IO (HG3DClass)
- -- ^ return value - On success, a valid pointer to the requested billboard is returned.     
+{- function getBillboard -}
+getBillboard :: HG3DClass -> Int -> IO (HG3DClass)
 getBillboard a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -230,11 +192,8 @@
   return (a3'')
 {-# LINE 121 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Removes the billboard at the supplied index. This method requires linear time since the billboard list is a linked list. 
-removeBillboard :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO ()
- -- ^ 
+{- function removeBillboard -}
+removeBillboard :: HG3DClass -> Int -> IO ()
 removeBillboard a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -242,11 +201,8 @@
   return ()
 {-# LINE 126 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Removes a billboard from the set. This version is more efficient than removing by index. 
-removeBillboard2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ pBill
-  ->  IO ()
- -- ^ 
+{- function removeBillboard2 -}
+removeBillboard2 :: HG3DClass -> HG3DClass -> IO ()
 removeBillboard2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -254,11 +210,8 @@
   return ()
 {-# LINE 131 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets the point which acts as the origin point for all billboards in this set. This setting controls the fine tuning of where a billboard appears in relation to it's position. It could be that a billboard's position represents it's center (e.g. for fireballs), it could mean the center of the bottom edge (e.g. a tree which is positioned on the ground), the top-left corner (e.g. a cursor). The default setting is BBO_CENTER. 
-setBillboardOrigin :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumBillboardOrigin  -- ^ origin - A member of the BillboardOrigin enum specifying the origin for all the billboards in this set. 
-  ->  IO ()
- -- ^ 
+{- function setBillboardOrigin -}
+setBillboardOrigin :: HG3DClass -> EnumBillboardOrigin -> IO ()
 setBillboardOrigin a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -266,10 +219,8 @@
   return ()
 {-# LINE 136 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Gets the point which acts as the origin point for all billboards in this set. 
-getBillboardOrigin :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumBillboardOrigin)
- -- ^ return value - A member of the BillboardOrigin enum specifying the origin for all the billboards in this set.     
+{- function getBillboardOrigin -}
+getBillboardOrigin :: HG3DClass -> IO (EnumBillboardOrigin)
 getBillboardOrigin a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -278,11 +229,8 @@
   return (a2'')
 {-# LINE 141 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets billboard rotation type. This setting controls the billboard rotation type, you can deciding rotate the billboard's vertices around their facing direction or rotate the billboard's texture coordinates. The default settings is BBR_TEXCOORD. 
-setBillboardRotationType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumBillboardRotationType  -- ^ rotationType - A member of the BillboardRotationType enum specifying the rotation type for all the billboards in this set. 
-  ->  IO ()
- -- ^ 
+{- function setBillboardRotationType -}
+setBillboardRotationType :: HG3DClass -> EnumBillboardRotationType -> IO ()
 setBillboardRotationType a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -290,10 +238,8 @@
   return ()
 {-# LINE 146 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets billboard rotation type. 
-getBillboardRotationType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumBillboardRotationType)
- -- ^ return value - A member of the BillboardRotationType enum specifying the rotation type for all the billboards in this set.     
+{- function getBillboardRotationType -}
+getBillboardRotationType :: HG3DClass -> IO (EnumBillboardRotationType)
 getBillboardRotationType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -302,12 +248,8 @@
   return (a2'')
 {-# LINE 151 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets the default dimensions of the billboards in this set. All billboards in a set are created with these default dimensions. The set will render most efficiently if all the billboards in the set are the default size. It is possible to alter the size of individual billboards at the expense of extra calculation. See the Billboard
-setDefaultDimensions :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ width - The new default width for the billboards in this set. 
-  ->  Float  -- ^ height - The new default height for the billboards in this set. 
-  ->  IO ()
- -- ^ 
+{- function setDefaultDimensions -}
+setDefaultDimensions :: HG3DClass -> Float -> Float -> IO ()
 setDefaultDimensions a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -316,11 +258,8 @@
   return ()
 {-# LINE 157 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | See setDefaultDimensions - this sets 1 component individually. 
-setDefaultWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ width
-  ->  IO ()
- -- ^ 
+{- function setDefaultWidth -}
+setDefaultWidth :: HG3DClass -> Float -> IO ()
 setDefaultWidth a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -328,10 +267,8 @@
   return ()
 {-# LINE 162 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | See setDefaultDimensions - this gets 1 component individually. 
-getDefaultWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getDefaultWidth -}
+getDefaultWidth :: HG3DClass -> IO (Float)
 getDefaultWidth a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -340,11 +277,8 @@
   return (a2'')
 {-# LINE 167 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | See setDefaultDimensions - this sets 1 component individually. 
-setDefaultHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ height
-  ->  IO ()
- -- ^ 
+{- function setDefaultHeight -}
+setDefaultHeight :: HG3DClass -> Float -> IO ()
 setDefaultHeight a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -352,10 +286,8 @@
   return ()
 {-# LINE 172 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | See setDefaultDimensions - this gets 1 component individually. 
-getDefaultHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getDefaultHeight -}
+getDefaultHeight :: HG3DClass -> IO (Float)
 getDefaultHeight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -364,12 +296,8 @@
   return (a2'')
 {-# LINE 177 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets the name of the material to be used for this billboard set. 
-setMaterialName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The new name of the material to use for this set. 
-  ->  String  -- ^ groupName
-  ->  IO ()
- -- ^ 
+{- function setMaterialName -}
+setMaterialName :: HG3DClass -> String -> String -> IO ()
 setMaterialName a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -378,10 +306,8 @@
   return ()
 {-# LINE 183 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets the name of the material to be used for this billboard set. 
-getMaterialName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ return value - The name of the material that is used for this set.     
+{- function getMaterialName -}
+getMaterialName :: HG3DClass -> IO (String)
 getMaterialName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -390,13 +316,8 @@
   return (a2'')
 {-# LINE 188 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Begin injection of billboard data; applicable when 
---constructing the BillboardSet for external data use.
---
-beginBillboards :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ numBillboards - If you know the number of billboards you will be issuing, state it here to make the update more efficient. 
-  ->  IO ()
- -- ^ 
+{- function beginBillboards -}
+beginBillboards :: HG3DClass -> Int -> IO ()
 beginBillboards a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -404,11 +325,8 @@
   return ()
 {-# LINE 193 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Define a billboard. 
-injectBillboard :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ bb
-  ->  IO ()
- -- ^ 
+{- function injectBillboard -}
+injectBillboard :: HG3DClass -> HG3DClass -> IO ()
 injectBillboard a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -416,20 +334,16 @@
   return ()
 {-# LINE 198 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Finish defining billboards. 
-endBillboards :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function endBillboards -}
+endBillboards :: HG3DClass -> IO ()
 endBillboards a1 =
   withHG3DClass a1 $ \a1' -> 
   endBillboards'_ a1' >>= \res ->
   return ()
 {-# LINE 202 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Overridden from MovableObjectMovableObject
-getBoundingRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundingRadius -}
+getBoundingRadius :: HG3DClass -> IO (Float)
 getBoundingRadius a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -438,10 +352,8 @@
   return (a2'')
 {-# LINE 207 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Overridden from MovableObjectMovableObject
-getMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (SharedPtr)
- -- ^ 
+{- function getMaterial -}
+getMaterial :: HG3DClass -> IO (SharedPtr)
 getMaterial a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -450,11 +362,8 @@
   return (a2'')
 {-# LINE 212 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets the name of the material to be used for this billboard set. 
-setMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  SharedPtr  -- ^ material - The new material to use for this set. 
-  ->  IO ()
- -- ^ 
+{- function setMaterial -}
+setMaterial :: HG3DClass -> SharedPtr -> IO ()
 setMaterial a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withSharedPtr a2 $ \a2' -> 
@@ -462,10 +371,8 @@
   return ()
 {-# LINE 217 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Returns whether or not billboards in this are tested individually for culling. 
-getCullIndividually :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getCullIndividually -}
+getCullIndividually :: HG3DClass -> IO (Bool)
 getCullIndividually a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -474,12 +381,8 @@
   return (a2'')
 {-# LINE 222 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets whether culling tests billboards in this individually as well as in a group.
---BillboardThis is useful when you have a large, fairly distributed set of billboards, like maybe trees on a landscape. You probably still want to group them into more than one set (maybe one set per section of landscape), which will be culled coarsely, but you also want to cull the billboards individually because they are spread out. Whilst you could have lots of single-tree sets which are culled separately, this would be inefficient to render because each tree would be issued as it's own rendering operation. By calling this method with a parameter of true, you can have large billboard sets which are spaced out and so get the benefit of batch rendering and coarse culling, but also have fine-grained culling so unnecessary rendering is avoided. 
-setCullIndividually :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ cullIndividual - If true, each billboard is tested before being sent to the pipeline as well as the whole set having to pass the coarse group bounding test. 
-  ->  IO ()
- -- ^ 
+{- function setCullIndividually -}
+setCullIndividually :: HG3DClass -> Bool -> IO ()
 setCullIndividually a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -487,12 +390,8 @@
   return ()
 {-# LINE 227 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets the type of billboard to render.
---The default sort of billboard (BBT_POINT), always has both x and y axes parallel to the camera's local axes. This is fine for 'point' style billboards (e.g. flares, smoke, anything which is symmetrical about a central point) but does not look good for billboards which have an orientation (e.g. an elongated raindrop). In this case, the oriented billboards are more suitable (BBT_ORIENTED_COMMON or BBT_ORIENTED_SELF) since they retain an independent Y axis and only the X axis is generated, perpendicular to both the local Y and the camera Z. In some case you might want the billboard has fixed Z axis and doesn't need to face to camera (e.g. an aureola around the player and parallel to the ground). You can use BBT_PERPENDICULAR_SELF which the billboard plane perpendicular to the billboard own direction. Or BBT_PERPENDICULAR_COMMON which the billboard plane perpendicular to the common direction. BBT_PERPENDICULAR_SELF and BBT_PERPENDICULAR_COMMON can't guarantee counterclockwise, you might use double-side material (cull_hardware node
-setBillboardType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumBillboardType  -- ^ bbt - The type of billboard to render 
-  ->  IO ()
- -- ^ 
+{- function setBillboardType -}
+setBillboardType :: HG3DClass -> EnumBillboardType -> IO ()
 setBillboardType a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -500,10 +399,8 @@
   return ()
 {-# LINE 232 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Returns the billboard type in use. 
-getBillboardType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumBillboardType)
- -- ^ 
+{- function getBillboardType -}
+getBillboardType :: HG3DClass -> IO (EnumBillboardType)
 getBillboardType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -512,12 +409,8 @@
   return (a2'')
 {-# LINE 237 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Use this to specify the common direction given to billboards of type BBT_ORIENTED_COMMON or BBT_PERPENDICULAR_COMMON.
---Use BBT_ORIENTED_COMMON when you want oriented billboards but you know they are always going to be oriented the same way (e.g. rain in calm weather). It is faster for the system to calculate the billboard vertices if they have a common direction. The common direction also use in BBT_PERPENDICULAR_COMMON, in this case the common direction treat as Z axis, and an additional common up-vector was use to determine billboard X and Y axis. setCommonUpVectorThe direction are use as is, never normalised in internal, user are supposed to normalise it himself. 
-setCommonDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vec - The direction for all billboards. 
-  ->  IO ()
- -- ^ 
+{- function setCommonDirection -}
+setCommonDirection :: HG3DClass -> Vec3 -> IO ()
 setCommonDirection a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -525,10 +418,8 @@
   return ()
 {-# LINE 242 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Gets the common direction for all billboards (BBT_ORIENTED_COMMON) 
-getCommonDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getCommonDirection -}
+getCommonDirection :: HG3DClass -> IO (Vec3)
 getCommonDirection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -537,12 +428,8 @@
   return (a2'')
 {-# LINE 247 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Use this to specify the common up-vector given to billboards of type BBT_PERPENDICULAR_SELF or BBT_PERPENDICULAR_COMMON.
---Use BBT_PERPENDICULAR_SELF or BBT_PERPENDICULAR_COMMON when you want oriented billboards perpendicular to specify direction vector (or, Z axis), and doesn't face to camera. In this case, we need an additional up-vector to determine the billboard X and Y axis. The generated billboard plane and X-axis guarantee perpendicular to specify direction. setCommonDirectionThe specify direction is billboard own direction when billboard type is BBT_PERPENDICULAR_SELF, and it's shared common direction when billboard type is BBT_PERPENDICULAR_COMMON. The up-vector are use as is, never normalised in internal, user are supposed to normalise it himself. 
-setCommonUpVector :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vec - The up-vector for all billboards. 
-  ->  IO ()
- -- ^ 
+{- function setCommonUpVector -}
+setCommonUpVector :: HG3DClass -> Vec3 -> IO ()
 setCommonUpVector a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -550,10 +437,8 @@
   return ()
 {-# LINE 252 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Gets the common up-vector for all billboards (BBT_PERPENDICULAR_SELF and BBT_PERPENDICULAR_COMMON) 
-getCommonUpVector :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getCommonUpVector -}
+getCommonUpVector :: HG3DClass -> IO (Vec3)
 getCommonUpVector a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -562,14 +447,8 @@
   return (a2'')
 {-# LINE 257 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets whether or not billboards should use an 'accurate' facing model
---based on the vector from each billboard to the camera, rather than 
---an optimised version using just the camera direction.
---By default, the axes for all billboards are calculated using the camera's view direction, not the vector from the camera position to the billboard. The former is faster, and most of the time the difference is not noticeable. However for some purposes (e.g. very large, static billboards) the changing billboard orientation when rotating the camera can be off putting, therefore you can enable this option to use a more expensive, but more accurate version. 
-setUseAccurateFacing :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ acc - True to use the slower but more accurate model. Default is false. 
-  ->  IO ()
- -- ^ 
+{- function setUseAccurateFacing -}
+setUseAccurateFacing :: HG3DClass -> Bool -> IO ()
 setUseAccurateFacing a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -577,10 +456,8 @@
   return ()
 {-# LINE 262 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Gets whether or not billboards use an 'accurate' facing model based on the vector from each billboard to the camera, rather than an optimised version using just the camera direction. 
-getUseAccurateFacing :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseAccurateFacing -}
+getUseAccurateFacing :: HG3DClass -> IO (Bool)
 getUseAccurateFacing a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -589,10 +466,8 @@
   return (a2'')
 {-# LINE 267 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Overridden from MovableObject
-getMovableType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMovableType -}
+getMovableType :: HG3DClass -> IO (String)
 getMovableType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -601,11 +476,8 @@
   return (a2'')
 {-# LINE 272 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Overridden, see Renderable
-getSquaredViewDepth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ cam
-  ->  IO (Float)
- -- ^ 
+{- function getSquaredViewDepth -}
+getSquaredViewDepth :: HG3DClass -> HG3DClass -> IO (Float)
 getSquaredViewDepth a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -615,12 +487,8 @@
   return (a3'')
 {-# LINE 278 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Sets whether billboards should be treated as being in world space. 
---This is most useful when you are driving the billboard set from an external data source. 
-setBillboardsInWorldSpace :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ ws
-  ->  IO ()
- -- ^ 
+{- function setBillboardsInWorldSpace -}
+setBillboardsInWorldSpace :: HG3DClass -> Bool -> IO ()
 setBillboardsInWorldSpace a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -628,20 +496,8 @@
   return ()
 {-# LINE 283 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Set whether or not the BillboardSet will use point rendering
---rather than manually generated quads.
---By default a billboardset is rendered by generating geometry for a textured quad in memory, taking into account the size and orientation settings, and uploading it to the video card. The alternative is to use hardware point rendering, which means that only one position needs to be sent per billboard rather than 4 and the hardware sorts out how this is rendered based on the render state. Using point rendering is faster than generating quads manually, but is more restrictive. The following restrictions apply: 
---
---
---
---
---
---
---You will almost certainly want to enable in your material pass both point attenuation and point sprites if you use this option. 
-setPointRenderingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled - True to enable point rendering, false otherwise 
-  ->  IO ()
- -- ^ 
+{- function setPointRenderingEnabled -}
+setPointRenderingEnabled :: HG3DClass -> Bool -> IO ()
 setPointRenderingEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -649,10 +505,8 @@
   return ()
 {-# LINE 288 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Returns whether point rendering is enabled. 
-isPointRenderingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isPointRenderingEnabled -}
+isPointRenderingEnabled :: HG3DClass -> IO (Bool)
 isPointRenderingEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -661,10 +515,8 @@
   return (a2'')
 {-# LINE 293 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Override to return specific type flag. 
-getTypeFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getTypeFlags -}
+getTypeFlags :: HG3DClass -> IO (Int)
 getTypeFlags a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -673,12 +525,8 @@
   return (a2'')
 {-# LINE 298 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Set the auto update state of this billboard set.
---This methods controls the updating policy of the vertex buffer. By default auto update is true so the vertex buffer is being update every time this billboard set is about to be rendered. This behavior best fit when the billboards of this set changes frequently. When using static or semi-static billboards, it is recommended to set auto update to false. In that case one should call notifyBillboardDataChanged method to reflect changes made to the billboards data. 
-setAutoUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ autoUpdate
-  ->  IO ()
- -- ^ 
+{- function setAutoUpdate -}
+setAutoUpdate :: HG3DClass -> Bool -> IO ()
 setAutoUpdate a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -686,10 +534,8 @@
   return ()
 {-# LINE 303 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | Return the auto update state of this billboard set. 
-getAutoUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getAutoUpdate -}
+getAutoUpdate :: HG3DClass -> IO (Bool)
 getAutoUpdate a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -698,10 +544,8 @@
   return (a2'')
 {-# LINE 308 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSet.chs" #-}
 
--- | When billboard set is not auto updating its GPU buffer, the user is responsible to inform it about any billboard changes in order to reflect them at the rendering stage. Calling this method will cause GPU buffers update in the next render queue update. 
-notifyBillboardDataChanged :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function notifyBillboardDataChanged -}
+notifyBillboardDataChanged :: HG3DClass -> IO ()
 notifyBillboardDataChanged a1 =
   withHG3DClass a1 $ \a1' -> 
   notifyBillboardDataChanged'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassBillboardSetFactory.hs b/HGamer3D/Bindings/Ogre/ClassBillboardSetFactory.hs
--- a/HGamer3D/Bindings/Ogre/ClassBillboardSetFactory.hs
+++ b/HGamer3D/Bindings/Ogre/ClassBillboardSetFactory.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSetFactory.chs" #-}
 
--- | 
+{- function BillboardSetFactory -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,20 +57,16 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSetFactory.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~BillboardSetFactory -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSetFactory.chs" #-}
 
--- | Get the type of the object to be created. 
-getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getType -}
+getType :: HG3DClass -> IO (String)
 getType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -80,11 +75,8 @@
   return (a2'')
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassBillboardSetFactory.chs" #-}
 
--- | Destroy an instance of the object 
-destroyInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
+{- function destroyInstance -}
+destroyInstance :: HG3DClass -> HG3DClass -> IO ()
 destroyInstance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassBone.hs b/HGamer3D/Bindings/Ogre/ClassBone.hs
--- a/HGamer3D/Bindings/Ogre/ClassBone.hs
+++ b/HGamer3D/Bindings/Ogre/ClassBone.hs
@@ -52,24 +52,16 @@
 import HGamer3D.Bindings.Ogre.StructQuaternion
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassBone.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Bone -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassBone.chs" #-}
 
--- | Creates a new Bone as a child of this bone.
---This method creates a new bone which will inherit the transforms of this bone, with the handle specified. 
-createChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle - The numeric handle to give the new bone; must be unique within the Skeleton. 
-  ->  Vec3  -- ^ translate - Initial translation offset of child relative to parent 
-  ->  Quaternion  -- ^ rotate - Initial rotation relative to parent 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createChild -}
+createChild :: HG3DClass -> Int -> Vec3 -> Quaternion -> IO (HG3DClass)
 createChild a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -81,10 +73,8 @@
   return (a5'')
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassBone.chs" #-}
 
--- | Gets the numeric handle for this bone (unique within the skeleton). 
-getHandle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getHandle -}
+getHandle :: HG3DClass -> IO (Int)
 getHandle a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -93,33 +83,24 @@
   return (a2'')
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassBone.chs" #-}
 
--- | Sets the current position / orientation to be the 'binding pose' ie the layout in which bones were originally bound to a mesh. 
-setBindingPose :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function setBindingPose -}
+setBindingPose :: HG3DClass -> IO ()
 setBindingPose a1 =
   withHG3DClass a1 $ \a1' -> 
   setBindingPose'_ a1' >>= \res ->
   return ()
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassBone.chs" #-}
 
--- | Resets the position and orientation of this Bone to the original binding position.
---Bones are bound to the mesh in a binding pose. They are then modified from this position during animation. This method returns the bone to it's original position and orientation. 
-reset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function reset -}
+reset :: HG3DClass -> IO ()
 reset a1 =
   withHG3DClass a1 $ \a1' -> 
   reset'_ a1' >>= \res ->
   return ()
 {-# LINE 70 ".\\HGamer3D\\Bindings\\Ogre\\ClassBone.chs" #-}
 
--- | Sets whether or not this bone is manually controlled. 
---Manually controlled bones can be altered by the application at runtime, and their positions will not be reset by the animation routines. Note that you should also make sure that there are no AnimationTrackgetHandle()You can also use AnimationState::setBlendMask to mask out animation from chosen tracks if you want to prevent application of a scripted animation to a bone without altering the Animation
-setManuallyControlled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ manuallyControlled
-  ->  IO ()
- -- ^ 
+{- function setManuallyControlled -}
+setManuallyControlled :: HG3DClass -> Bool -> IO ()
 setManuallyControlled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -127,10 +108,8 @@
   return ()
 {-# LINE 75 ".\\HGamer3D\\Bindings\\Ogre\\ClassBone.chs" #-}
 
--- | Getter for mManuallyControlled Flag 
-isManuallyControlled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isManuallyControlled -}
+isManuallyControlled :: HG3DClass -> IO (Bool)
 isManuallyControlled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -139,11 +118,8 @@
   return (a2'')
 {-# LINE 80 ".\\HGamer3D\\Bindings\\Ogre\\ClassBone.chs" #-}
 
--- | Node::needUpdate
-needUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ forceParentUpdate
-  ->  IO ()
- -- ^ 
+{- function needUpdate -}
+needUpdate :: HG3DClass -> Bool -> IO ()
 needUpdate a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
diff --git a/HGamer3D/Bindings/Ogre/ClassCamera.hs b/HGamer3D/Bindings/Ogre/ClassCamera.hs
--- a/HGamer3D/Bindings/Ogre/ClassCamera.hs
+++ b/HGamer3D/Bindings/Ogre/ClassCamera.hs
@@ -56,11 +56,8 @@
 import HGamer3D.Bindings.Ogre.EnumFrustumPlane
 {-# LINE 46 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Standard constructor. 
-new :: String  -- ^ name
-  ->  HG3DClass  -- ^ sm
-  ->  IO (HG3DClass)
- -- ^ 
+{- function Camera -}
+new :: String -> HG3DClass -> IO (HG3DClass)
 new a1 a2 =
   withCString a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -70,20 +67,16 @@
   return (a3'')
 {-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Standard destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Camera -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Returns a pointer to the SceneManager
-getSceneManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getSceneManager -}
+getSceneManager :: HG3DClass -> IO (HG3DClass)
 getSceneManager a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -92,13 +85,8 @@
   return (a2'')
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Sets the camera's position. 
-setPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function setPosition -}
+setPosition :: HG3DClass -> Float -> Float -> Float -> IO ()
 setPosition a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -108,11 +96,8 @@
   return ()
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Sets the camera's position. 
-setPosition2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vec
-  ->  IO ()
- -- ^ 
+{- function setPosition2 -}
+setPosition2 :: HG3DClass -> Vec3 -> IO ()
 setPosition2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -120,10 +105,8 @@
   return ()
 {-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Retrieves the camera's position. 
-getPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getPosition -}
+getPosition :: HG3DClass -> IO (Vec3)
 getPosition a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -132,11 +115,8 @@
   return (a2'')
 {-# LINE 79 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Moves the camera's position by the vector offset provided along world axes. 
-move :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vec
-  ->  IO ()
- -- ^ 
+{- function move -}
+move :: HG3DClass -> Vec3 -> IO ()
 move a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -144,11 +124,8 @@
   return ()
 {-# LINE 84 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Moves the camera's position by the vector offset provided along it's own axes (relative to orientation). 
-moveRelative :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vec
-  ->  IO ()
- -- ^ 
+{- function moveRelative -}
+moveRelative :: HG3DClass -> Vec3 -> IO ()
 moveRelative a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -156,13 +133,8 @@
   return ()
 {-# LINE 89 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Sets the camera's direction vector. Note that the 'up' vector for the camera will automatically be recalculated based on the current 'up' vector (i.e. the roll will remain the same). 
-setDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function setDirection -}
+setDirection :: HG3DClass -> Float -> Float -> Float -> IO ()
 setDirection a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -172,11 +144,8 @@
   return ()
 {-# LINE 96 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Sets the camera's direction vector. 
-setDirection2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vec
-  ->  IO ()
- -- ^ 
+{- function setDirection2 -}
+setDirection2 :: HG3DClass -> Vec3 -> IO ()
 setDirection2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -184,10 +153,8 @@
   return ()
 {-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | 
-getDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getDirection -}
+getDirection :: HG3DClass -> IO (Vec3)
 getDirection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -196,10 +163,8 @@
   return (a2'')
 {-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the camera's up vector. 
-getUp :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getUp -}
+getUp :: HG3DClass -> IO (Vec3)
 getUp a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -208,10 +173,8 @@
   return (a2'')
 {-# LINE 111 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the camera's right vector. 
-getRight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getRight -}
+getRight :: HG3DClass -> IO (Vec3)
 getRight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -220,11 +183,8 @@
   return (a2'')
 {-# LINE 116 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Points the camera at a location in worldspace. This is a helper method to automatically generate the direction vector for the camera, based on it's current position and the supplied look-at point. 
-lookAt :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ targetPoint - A vector specifying the look at point. 
-  ->  IO ()
- -- ^ 
+{- function lookAt -}
+lookAt :: HG3DClass -> Vec3 -> IO ()
 lookAt a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -232,13 +192,8 @@
   return ()
 {-# LINE 121 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Points the camera at a location in worldspace. This is a helper method to automatically generate the direction vector for the camera, based on it's current position and the supplied look-at point. 
-lookAt2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z - Co-ordinates of the point to look at. 
-  ->  IO ()
- -- ^ 
+{- function lookAt2 -}
+lookAt2 :: HG3DClass -> Float -> Float -> Float -> IO ()
 lookAt2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -248,11 +203,8 @@
   return ()
 {-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Rolls the camera anticlockwise, around its local z axis. 
-roll :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ angle
-  ->  IO ()
- -- ^ 
+{- function roll -}
+roll :: HG3DClass -> Radians -> IO ()
 roll a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -260,11 +212,8 @@
   return ()
 {-# LINE 133 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Rotates the camera anticlockwise around it's local y axis. 
-yaw :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ angle
-  ->  IO ()
- -- ^ 
+{- function yaw -}
+yaw :: HG3DClass -> Radians -> IO ()
 yaw a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -272,11 +221,8 @@
   return ()
 {-# LINE 138 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Pitches the camera up/down anticlockwise around it's local z axis. 
-pitch :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ angle
-  ->  IO ()
- -- ^ 
+{- function pitch -}
+pitch :: HG3DClass -> Radians -> IO ()
 pitch a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -284,12 +230,8 @@
   return ()
 {-# LINE 143 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Rotate the camera around an arbitrary axis. 
-rotate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ axis
-  ->  Radians  -- ^ angle
-  ->  IO ()
- -- ^ 
+{- function rotate -}
+rotate :: HG3DClass -> Vec3 -> Radians -> IO ()
 rotate a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -298,11 +240,8 @@
   return ()
 {-# LINE 149 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Rotate the camera around an arbitrary axis using a Quaternion
-rotate2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Quaternion  -- ^ q
-  ->  IO ()
- -- ^ 
+{- function rotate2 -}
+rotate2 :: HG3DClass -> Quaternion -> IO ()
 rotate2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withQuaternion a2 $ \a2' -> 
@@ -310,13 +249,8 @@
   return ()
 {-# LINE 154 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Tells the camera whether to yaw around it's own local Y axis or a fixed axis of choice. This method allows you to change the yaw behaviour of the camera
---
-setFixedYawAxis :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ useFixed - If true, the axis passed in the second parameter will always be the yaw axis no matter what the camera orientation. If false, the camera yaws around the local Y. 
-  ->  Vec3  -- ^ fixedAxis - The axis to use if the first parameter is true. 
-  ->  IO ()
- -- ^ 
+{- function setFixedYawAxis -}
+setFixedYawAxis :: HG3DClass -> Bool -> Vec3 -> IO ()
 setFixedYawAxis a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -325,10 +259,8 @@
   return ()
 {-# LINE 160 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Returns the camera's current orientation. 
-getOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Quaternion)
- -- ^ 
+{- function getOrientation -}
+getOrientation :: HG3DClass -> IO (Quaternion)
 getOrientation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -337,11 +269,8 @@
   return (a2'')
 {-# LINE 165 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Sets the camera's orientation. 
-setOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Quaternion  -- ^ q
-  ->  IO ()
- -- ^ 
+{- function setOrientation -}
+setOrientation :: HG3DClass -> Quaternion -> IO ()
 setOrientation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withQuaternion a2 $ \a2' -> 
@@ -349,10 +278,8 @@
   return ()
 {-# LINE 170 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the derived orientation of the camera, including any rotation inherited from a node attachment and reflection matrix. 
-getDerivedOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Quaternion)
- -- ^ 
+{- function getDerivedOrientation -}
+getDerivedOrientation :: HG3DClass -> IO (Quaternion)
 getDerivedOrientation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -361,10 +288,8 @@
   return (a2'')
 {-# LINE 175 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the derived position of the camera, including any translation inherited from a node attachment and reflection matrix. 
-getDerivedPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getDerivedPosition -}
+getDerivedPosition :: HG3DClass -> IO (Vec3)
 getDerivedPosition a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -373,10 +298,8 @@
   return (a2'')
 {-# LINE 180 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the derived direction vector of the camera, including any rotation inherited from a node attachment and reflection matrix. 
-getDerivedDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getDerivedDirection -}
+getDerivedDirection :: HG3DClass -> IO (Vec3)
 getDerivedDirection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -385,10 +308,8 @@
   return (a2'')
 {-# LINE 185 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the derived up vector of the camera, including any rotation inherited from a node attachment and reflection matrix. 
-getDerivedUp :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getDerivedUp -}
+getDerivedUp :: HG3DClass -> IO (Vec3)
 getDerivedUp a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -397,10 +318,8 @@
   return (a2'')
 {-# LINE 190 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the derived right vector of the camera, including any rotation inherited from a node attachment and reflection matrix. 
-getDerivedRight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getDerivedRight -}
+getDerivedRight :: HG3DClass -> IO (Vec3)
 getDerivedRight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -409,10 +328,8 @@
   return (a2'')
 {-# LINE 195 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the real world orientation of the camera, including any rotation inherited from a node attachment 
-getRealOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Quaternion)
- -- ^ 
+{- function getRealOrientation -}
+getRealOrientation :: HG3DClass -> IO (Quaternion)
 getRealOrientation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -421,10 +338,8 @@
   return (a2'')
 {-# LINE 200 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the real world position of the camera, including any translation inherited from a node attachment. 
-getRealPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getRealPosition -}
+getRealPosition :: HG3DClass -> IO (Vec3)
 getRealPosition a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -433,10 +348,8 @@
   return (a2'')
 {-# LINE 205 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the real world direction vector of the camera, including any rotation inherited from a node attachment. 
-getRealDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getRealDirection -}
+getRealDirection :: HG3DClass -> IO (Vec3)
 getRealDirection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -445,10 +358,8 @@
   return (a2'')
 {-# LINE 210 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the real world up vector of the camera, including any rotation inherited from a node attachment. 
-getRealUp :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getRealUp -}
+getRealUp :: HG3DClass -> IO (Vec3)
 getRealUp a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -457,10 +368,8 @@
   return (a2'')
 {-# LINE 215 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the real world right vector of the camera, including any rotation inherited from a node attachment. 
-getRealRight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getRealRight -}
+getRealRight :: HG3DClass -> IO (Vec3)
 getRealRight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -469,10 +378,8 @@
   return (a2'')
 {-# LINE 220 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Overridden from MovableObject
-getMovableType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMovableType -}
+getMovableType :: HG3DClass -> IO (String)
 getMovableType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -481,12 +388,8 @@
   return (a2'')
 {-# LINE 225 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Sets the level-of-detail factor for this Camera.
---This method can be used to influence the overall level of detail of the scenes rendered using this camera. Various elements of the scene have level-of-detail reductions to improve rendering speed at distance; this method allows you to hint to those elements that you would like to adjust the level of detail that they would normally use (up or down). The most common use for this method is to reduce the overall level of detail used for a secondary camera used for sub viewports like rear-view mirrors etc. Note that scene elements are at liberty to ignore this setting if they choose, this is merely a hint. 
-setLodBias :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ factor - The factor to apply to the usual level of detail calculation. Higher values increase the detail, so 2.0 doubles the normal detail and 0.5 halves it. 
-  ->  IO ()
- -- ^ 
+{- function setLodBias -}
+setLodBias :: HG3DClass -> Float -> IO ()
 setLodBias a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -494,11 +397,8 @@
   return ()
 {-# LINE 230 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Returns the level-of-detail bias factor currently applied to this camera. 
---See Camera::setLodBias
-getLodBias :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getLodBias -}
+getLodBias :: HG3DClass -> IO (Float)
 getLodBias a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -507,13 +407,8 @@
   return (a2'')
 {-# LINE 235 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Get a pointer to the camera which should be used to determine 
---LOD settings. 
---Sometimes you don't want the LOD of a render to be based on the camera that's doing the rendering, you want it to be based on a different camera. A good example is when rendering shadow maps, since they will be viewed from the perspective of another camera. Therefore this method lets you associate a different camera instance to use to determine the LOD. To revert the camera to determining LOD based on itself, call this method with a pointer to itself. 
-setLodCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ lodCam
-  ->  IO ()
- -- ^ 
+{- function setLodCamera -}
+setLodCamera :: HG3DClass -> HG3DClass -> IO ()
 setLodCamera a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -521,12 +416,8 @@
   return ()
 {-# LINE 240 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Get a pointer to the camera which should be used to determine 
---LOD settings. 
---If setLodCamera hasn't been called with a different camera, this method will return 'this'. 
-getLodCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getLodCamera -}
+getLodCamera :: HG3DClass -> IO (HG3DClass)
 getLodCamera a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -535,15 +426,8 @@
   return (a2'')
 {-# LINE 245 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Sets the viewing window inside of viewport.
---This method can be used to set a subset of the viewport as the rendering target. 
-setWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ Left - Relative to Viewport - 0 corresponds to left edge, 1 - to right edge (default - 0). 
-  ->  Float  -- ^ Top - Relative to Viewport - 0 corresponds to top edge, 1 - to bottom edge (default - 0). 
-  ->  Float  -- ^ Right - Relative to Viewport - 0 corresponds to left edge, 1 - to right edge (default - 1). 
-  ->  Float  -- ^ Bottom - Relative to Viewport - 0 corresponds to top edge, 1 - to bottom edge (default - 1). 
-  ->  IO ()
- -- ^ 
+{- function setWindow -}
+setWindow :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 setWindow a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -554,20 +438,16 @@
   return ()
 {-# LINE 253 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Cancel view window. 
-resetWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function resetWindow -}
+resetWindow :: HG3DClass -> IO ()
 resetWindow a1 =
   withHG3DClass a1 $ \a1' -> 
   resetWindow'_ a1' >>= \res ->
   return ()
 {-# LINE 257 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Returns if a viewport window is being used. 
-isWindowSet :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isWindowSet -}
+isWindowSet :: HG3DClass -> IO (Bool)
 isWindowSet a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -576,10 +456,8 @@
   return (a2'')
 {-# LINE 262 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Overridden from MovableObject
-getBoundingRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundingRadius -}
+getBoundingRadius :: HG3DClass -> IO (Float)
 getBoundingRadius a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -588,10 +466,8 @@
   return (a2'')
 {-# LINE 267 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Get the auto tracking target for this camera, if any. 
-getAutoTrackTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAutoTrackTarget -}
+getAutoTrackTarget :: HG3DClass -> IO (HG3DClass)
 getAutoTrackTarget a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -600,10 +476,8 @@
   return (a2'')
 {-# LINE 272 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Get the auto tracking offset for this camera, if it is auto tracking. 
-getAutoTrackOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getAutoTrackOffset -}
+getAutoTrackOffset :: HG3DClass -> IO (Vec3)
 getAutoTrackOffset a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -612,11 +486,8 @@
   return (a2'')
 {-# LINE 277 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Get the last viewport which was attached to this camera. 
---This is not guaranteed to be the only viewport which is using this camera, just the last once which was created referring to it. 
-getViewport :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getViewport -}
+getViewport :: HG3DClass -> IO (HG3DClass)
 getViewport a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -625,13 +496,8 @@
   return (a2'')
 {-# LINE 282 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | If set to true a viewport that owns this frustum will be able to 
---recalculate the aspect ratio whenever the frustum is resized.
---You should set this to true only if the frustum / camera is used by one viewport at the same time. Otherwise the aspect ratio for other viewports may be wrong. 
-setAutoAspectRatio :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ autoratio
-  ->  IO ()
- -- ^ 
+{- function setAutoAspectRatio -}
+setAutoAspectRatio :: HG3DClass -> Bool -> IO ()
 setAutoAspectRatio a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -639,10 +505,8 @@
   return ()
 {-# LINE 287 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Retrieves if AutoAspectRatio is currently set or not 
-getAutoAspectRatio :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getAutoAspectRatio -}
+getAutoAspectRatio :: HG3DClass -> IO (Bool)
 getAutoAspectRatio a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -651,12 +515,8 @@
   return (a2'')
 {-# LINE 292 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Tells the camera to use a separate Frustum instance to perform culling.
---By calling this method, you can tell the camera to perform culling against a different frustum to it's own. This is mostly useful for debug cameras that allow you to show the culling behaviour of another camera, or a manual frustum instance. 
-setCullingFrustum :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ frustum - Pointer to a frustum to use; this can either be a manual Frustum instance (which you can attach to scene nodes like any other MovableObject), or another camera. If you pass 0 to this method it reverts the camera to normal behaviour. 
-  ->  IO ()
- -- ^ 
+{- function setCullingFrustum -}
+setCullingFrustum :: HG3DClass -> HG3DClass -> IO ()
 setCullingFrustum a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -664,10 +524,8 @@
   return ()
 {-# LINE 297 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Returns the custom culling frustum in use. 
-getCullingFrustum :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getCullingFrustum -}
+getCullingFrustum :: HG3DClass -> IO (HG3DClass)
 getCullingFrustum a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -676,11 +534,8 @@
   return (a2'')
 {-# LINE 302 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Tests whether the given container is visible in the FrustumOtherwise, false is returned. 
-isVisible3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vert
-  ->  IO (EnumFrustumPlane, Bool)
- -- ^ culledBy
+{- function isVisible3 -}
+isVisible3 :: HG3DClass -> Vec3 -> IO (EnumFrustumPlane, Bool)
 isVisible3 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -692,11 +547,8 @@
   return (a3'', a4'')
 {-# LINE 309 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Gets the world space corners of the frustum.
---The corners are ordered as follows: top-right near, top-left near, bottom-left near, bottom-right near, top-right far, top-left far, bottom-left far, bottom-right far. 
-getWorldSpaceCorners :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getWorldSpaceCorners -}
+getWorldSpaceCorners :: HG3DClass -> IO (Vec3)
 getWorldSpaceCorners a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -705,10 +557,8 @@
   return (a2'')
 {-# LINE 314 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Sets the position of the near clipping plane. 
-getNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getNearClipDistance -}
+getNearClipDistance :: HG3DClass -> IO (Float)
 getNearClipDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -717,10 +567,8 @@
   return (a2'')
 {-# LINE 319 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Retrieves the distance from the frustum to the far clipping plane. 
-getFarClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getFarClipDistance -}
+getFarClipDistance :: HG3DClass -> IO (Float)
 getFarClipDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -729,14 +577,8 @@
   return (a2'')
 {-# LINE 324 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Set whether this camera should use the 'rendering distance' on
---objects to exclude distant objects from the final image. The
---default behaviour is to use it.
---
-setUseRenderingDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ use - True to use the rendering distance, false not to. 
-  ->  IO ()
- -- ^ 
+{- function setUseRenderingDistance -}
+setUseRenderingDistance :: HG3DClass -> Bool -> IO ()
 setUseRenderingDistance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -744,10 +586,8 @@
   return ()
 {-# LINE 329 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Get whether this camera should use the 'rendering distance' on objects to exclude distant objects from the final image. 
-getUseRenderingDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseRenderingDistance -}
+getUseRenderingDistance :: HG3DClass -> IO (Bool)
 getUseRenderingDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -756,12 +596,8 @@
   return (a2'')
 {-# LINE 334 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Synchronise core camera settings with another. 
---Copies the position, orientation, clip distances, projection type, FOV, focal length and aspect ratio from another camera. Other settings like query flags, reflection etc are preserved. 
-synchroniseBaseSettingsWith :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ cam
-  ->  IO ()
- -- ^ 
+{- function synchroniseBaseSettingsWith -}
+synchroniseBaseSettingsWith :: HG3DClass -> HG3DClass -> IO ()
 synchroniseBaseSettingsWith a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -769,10 +605,8 @@
   return ()
 {-# LINE 339 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Get the derived position of this frustum. 
-getPositionForViewUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getPositionForViewUpdate -}
+getPositionForViewUpdate :: HG3DClass -> IO (Vec3)
 getPositionForViewUpdate a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -781,10 +615,8 @@
   return (a2'')
 {-# LINE 344 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Get the derived orientation of this frustum. 
-getOrientationForViewUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Quaternion)
- -- ^ 
+{- function getOrientationForViewUpdate -}
+getOrientationForViewUpdate :: HG3DClass -> IO (Quaternion)
 getOrientationForViewUpdate a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -793,12 +625,8 @@
   return (a2'')
 {-# LINE 349 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Sets whether to use min display size calculations 
---
-setUseMinPixelSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enable
-  ->  IO ()
- -- ^ 
+{- function setUseMinPixelSize -}
+setUseMinPixelSize :: HG3DClass -> Bool -> IO ()
 setUseMinPixelSize a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -806,10 +634,8 @@
   return ()
 {-# LINE 354 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Returns whether to use min display size calculations Camera::setUseMinDisplaySize 
-getUseMinPixelSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseMinPixelSize -}
+getUseMinPixelSize :: HG3DClass -> IO (Bool)
 getUseMinPixelSize a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -818,16 +644,8 @@
   return (a2'')
 {-# LINE 359 ".\\HGamer3D\\Bindings\\Ogre\\ClassCamera.chs" #-}
 
--- | Returns an estimated ratio between a pixel and the display area it represents.
---For orthographic cameras this function returns the amount of meters covered by
---a single pixel along the vertical axis. For perspective cameras the value
---returned is the amount of meters covered by a single pixel per meter distance 
---from the camera.
---This parameter is calculated just before the camera is rendered 
---This parameter is used in min display size calculations. 
-getPixelDisplayRatio :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getPixelDisplayRatio -}
+getPixelDisplayRatio :: HG3DClass -> IO (Float)
 getPixelDisplayRatio a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassConfigFile.hs b/HGamer3D/Bindings/Ogre/ClassConfigFile.hs
--- a/HGamer3D/Bindings/Ogre/ClassConfigFile.hs
+++ b/HGamer3D/Bindings/Ogre/ClassConfigFile.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassConfigFile.chs" #-}
 
--- | 
+{- function ConfigFile -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,23 +57,16 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassConfigFile.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~ConfigFile -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassConfigFile.chs" #-}
 
--- | load from a filename (not using resource group locations) 
-load :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  String  -- ^ separators
-  ->  Bool  -- ^ trimWhitespace
-  ->  IO ()
- -- ^ 
+{- function load -}
+load :: HG3DClass -> String -> String -> Bool -> IO ()
 load a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -84,14 +76,8 @@
   return ()
 {-# LINE 58 ".\\HGamer3D\\Bindings\\Ogre\\ClassConfigFile.chs" #-}
 
--- | load from a filename (using resource group locations) 
-load2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  String  -- ^ resourceGroup
-  ->  String  -- ^ separators
-  ->  Bool  -- ^ trimWhitespace
-  ->  IO ()
- -- ^ 
+{- function load2 -}
+load2 :: HG3DClass -> String -> String -> String -> Bool -> IO ()
 load2 a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -102,13 +88,8 @@
   return ()
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassConfigFile.chs" #-}
 
--- | load from a filename (not using resource group locations) 
-loadDirect :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  String  -- ^ separators
-  ->  Bool  -- ^ trimWhitespace
-  ->  IO ()
- -- ^ 
+{- function loadDirect -}
+loadDirect :: HG3DClass -> String -> String -> Bool -> IO ()
 loadDirect a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -118,14 +99,8 @@
   return ()
 {-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassConfigFile.chs" #-}
 
--- | load from a filename (using resource group locations) 
-loadFromResourceSystem :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  String  -- ^ resourceGroup
-  ->  String  -- ^ separators
-  ->  Bool  -- ^ trimWhitespace
-  ->  IO ()
- -- ^ 
+{- function loadFromResourceSystem -}
+loadFromResourceSystem :: HG3DClass -> String -> String -> String -> Bool -> IO ()
 loadFromResourceSystem a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -136,14 +111,8 @@
   return ()
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassConfigFile.chs" #-}
 
--- | Gets the first setting from the file with the named key. 
---
-getSetting :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ key - The name of the setting 
-  ->  String  -- ^ section - The name of the section it must be in (if any) 
-  ->  String  -- ^ defaultValue - The value to return if the setting is not found 
-  ->  IO (String)
- -- ^ 
+{- function getSetting -}
+getSetting :: HG3DClass -> String -> String -> String -> IO (String)
 getSetting a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -155,10 +124,8 @@
   return (a5'')
 {-# LINE 89 ".\\HGamer3D\\Bindings\\Ogre\\ClassConfigFile.chs" #-}
 
--- | Clear the settings 
-clear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function clear -}
+clear :: HG3DClass -> IO ()
 clear a1 =
   withHG3DClass a1 $ \a1' -> 
   clear'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassControllerManager.hs b/HGamer3D/Bindings/Ogre/ClassControllerManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassControllerManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassControllerManager.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | 
+{- function ControllerManager -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,41 +57,32 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~ControllerManager -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Destroys all the controllers in existence. 
-clearControllers :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function clearControllers -}
+clearControllers :: HG3DClass -> IO ()
 clearControllers a1 =
   withHG3DClass a1 $ \a1' -> 
   clearControllers'_ a1' >>= \res ->
   return ()
 {-# LINE 55 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Updates all the registered controllers. 
-updateAllControllers :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function updateAllControllers -}
+updateAllControllers :: HG3DClass -> IO ()
 updateAllControllers a1 =
   withHG3DClass a1 $ \a1' -> 
   updateAllControllers'_ a1' >>= \res ->
   return ()
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Return relative speed of time as perceived by time based controllers.
---See setTimeFactor for full information on the meaning of this value. 
-getTimeFactor :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getTimeFactor -}
+getTimeFactor :: HG3DClass -> IO (Float)
 getTimeFactor a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -101,12 +91,8 @@
   return (a2'')
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Set the relative speed to update frame time based controllers.
---Normally any controllers which use time as an input (FrameTimeController) are updated automatically in line with the real passage of time. This method allows you to change that, so that controllers are told that the time is passing slower or faster than it actually is. Use this to globally speed up / slow down the effect of time-based controllers. 
-setTimeFactor :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ tf - The virtual speed of time (1.0 is real time). 
-  ->  IO ()
- -- ^ 
+{- function setTimeFactor -}
+setTimeFactor :: HG3DClass -> Float -> IO ()
 setTimeFactor a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -114,11 +100,8 @@
   return ()
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Gets the constant that is added to time lapsed between each frame.
---See setFrameDelay for full information on the meaning of this value. 
-getFrameDelay :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getFrameDelay -}
+getFrameDelay :: HG3DClass -> IO (Float)
 getFrameDelay a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -127,12 +110,8 @@
   return (a2'')
 {-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Sets a constant frame rate.
---This function is useful when rendering a sequence to files that should create a film clip with constant frame rate. It will ensure that scrolling textures and animations move at a constant frame rate. 
-setFrameDelay :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ fd - The delay in seconds wanted between each frame (1.0f / 25.0f means a seconds worth of animation is done in 25 frames). 
-  ->  IO ()
- -- ^ 
+{- function setFrameDelay -}
+setFrameDelay :: HG3DClass -> Float -> IO ()
 setFrameDelay a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -140,11 +119,8 @@
   return ()
 {-# LINE 79 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Return the elapsed time.
---See setElapsedTime for full information on the meaning of this value. 
-getElapsedTime :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getElapsedTime -}
+getElapsedTime :: HG3DClass -> IO (Float)
 getElapsedTime a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -153,12 +129,8 @@
   return (a2'')
 {-# LINE 84 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Set the elapsed time.
---Normally elapsed time accumulated all frames time (which speed relative to time factor) since the rendering loop started. This method allows your to change that to special time, so some elapsed-time-based globally effect is repeatable. 
-setElapsedTime :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ elapsedTime - The new elapsed time 
-  ->  IO ()
- -- ^ 
+{- function setElapsedTime -}
+setElapsedTime :: HG3DClass -> Float -> IO ()
 setElapsedTime a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -166,10 +138,8 @@
   return ()
 {-# LINE 89 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingleton -}
 getSingleton :: IO (HG3DClass)
- -- ^ 
 getSingleton =
   alloca $ \a1' -> 
   getSingleton'_ a1' >>= \res ->
@@ -177,10 +147,8 @@
   return (a1'')
 {-# LINE 93 ".\\HGamer3D\\Bindings\\Ogre\\ClassControllerManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingletonPtr -}
 getSingletonPtr :: IO (HG3DClass)
- -- ^ 
 getSingletonPtr =
   alloca $ \a1' -> 
   getSingletonPtr'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassEntity.hs b/HGamer3D/Bindings/Ogre/ClassEntity.hs
--- a/HGamer3D/Bindings/Ogre/ClassEntity.hs
+++ b/HGamer3D/Bindings/Ogre/ClassEntity.hs
@@ -52,20 +52,16 @@
 import HGamer3D.Bindings.Ogre.EnumEntityVertexDataBindChoice
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Default destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Entity -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Gets the MeshEntity
-getMesh :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (SharedPtr)
- -- ^ 
+{- function getMesh -}
+getMesh :: HG3DClass -> IO (SharedPtr)
 getMesh a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -74,10 +70,8 @@
   return (a2'')
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Retrieves the number of SubEntity objects making up this entity. 
-getNumSubEntities :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumSubEntities -}
+getNumSubEntities :: HG3DClass -> IO (Int)
 getNumSubEntities a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -86,12 +80,8 @@
   return (a2'')
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Clones this entity and returns a pointer to the clone.
---Useful method for duplicating an entity. The new entity must be given a unique name, and is not attached to the scene in any way so must be attached to a SceneNodeSceneManager::createEntity
-clone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ newName - Name for the new entity. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function clone -}
+clone :: HG3DClass -> String -> IO (HG3DClass)
 clone a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -101,13 +91,8 @@
   return (a3'')
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Sets the material to use for the whole of this entity.
---This is a shortcut method to set all the materials for all subentities of this entity. Only use this method is you want to set the same material for all subentities or if you know there is only one. Otherwise call getSubEntity()
-setMaterialName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  String  -- ^ groupName
-  ->  IO ()
- -- ^ 
+{- function setMaterialName -}
+setMaterialName :: HG3DClass -> String -> String -> IO ()
 setMaterialName a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -116,11 +101,8 @@
   return ()
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Sets the material to use for the whole of this entity. This is a shortcut method to set all the materials for all subentities of this entity. Only use this method is you want to set the same material for all subentities or if you know there is only one. Otherwise call getSubEntity()
-setMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  SharedPtr  -- ^ material
-  ->  IO ()
- -- ^ 
+{- function setMaterial -}
+setMaterial :: HG3DClass -> SharedPtr -> IO ()
 setMaterial a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withSharedPtr a2 $ \a2' -> 
@@ -128,10 +110,8 @@
   return ()
 {-# LINE 76 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Overridden from MovableObject
-getMovableType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMovableType -}
+getMovableType :: HG3DClass -> IO (String)
 getMovableType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -140,12 +120,8 @@
   return (a2'')
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | For entities based on animated meshes, gets the AnimationState object for a single animation.
---You animate an entity by updating the animation state objects. Each of these represents the current state of each animation available to the entity. The AnimationStateMesh
-getAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAnimationState -}
+getAnimationState :: HG3DClass -> String -> IO (HG3DClass)
 getAnimationState a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -155,11 +131,8 @@
   return (a3'')
 {-# LINE 87 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Returns whether the AnimationState
-hasAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
+{- function hasAnimationState -}
+hasAnimationState :: HG3DClass -> String -> IO (Bool)
 hasAnimationState a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -169,11 +142,8 @@
   return (a3'')
 {-# LINE 93 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | For entities based on animated meshes, gets the AnimationState objects for all animations.
---You animate an entity by updating the animation state objects. Each of these represents the current state of each animation available to the entity. The AnimationStateMesh
-getAllAnimationStates :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ return value - In case the entity is animated, this functions returns the pointer to a     
+{- function getAllAnimationStates -}
+getAllAnimationStates :: HG3DClass -> IO (HG3DClass)
 getAllAnimationStates a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -182,11 +152,8 @@
   return (a2'')
 {-# LINE 98 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Tells the Entity
-setDisplaySkeleton :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ display
-  ->  IO ()
- -- ^ 
+{- function setDisplaySkeleton -}
+setDisplaySkeleton :: HG3DClass -> Bool -> IO ()
 setDisplaySkeleton a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -194,10 +161,8 @@
   return ()
 {-# LINE 103 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Returns whether or not the entity is currently displaying its skeleton. 
-getDisplaySkeleton :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getDisplaySkeleton -}
+getDisplaySkeleton :: HG3DClass -> IO (Bool)
 getDisplaySkeleton a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -206,12 +171,8 @@
   return (a2'')
 {-# LINE 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Gets a pointer to the entity representing the numbered manual level of detail.
---The zero-based index never includes the original entity, unlike Mesh::getLodLevel
-getManualLodLevel :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getManualLodLevel -}
+getManualLodLevel :: HG3DClass -> Int -> IO (HG3DClass)
 getManualLodLevel a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -221,11 +182,8 @@
   return (a3'')
 {-# LINE 114 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Returns the number of manual levels of detail that this entity supports.
---This number never includes the original entity, it is difference with Mesh::getNumLodLevels
-getNumManualLodLevels :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumManualLodLevels -}
+getNumManualLodLevels :: HG3DClass -> IO (Int)
 getNumManualLodLevels a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -234,12 +192,8 @@
   return (a2'')
 {-# LINE 119 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Sets whether the polygon mode of this entire entity may be
---
-setPolygonModeOverrideable :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ PolygonModeOverrideable
-  ->  IO ()
- -- ^ 
+{- function setPolygonModeOverrideable -}
+setPolygonModeOverrideable :: HG3DClass -> Bool -> IO ()
 setPolygonModeOverrideable a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -247,13 +201,8 @@
   return ()
 {-# LINE 124 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Detach a MovableObject previously attached using attachObjectToBone.
---If the movable object name is not found then an exception is raised.
---
-detachObjectFromBone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ movableName - is the name of the movable object to be detached. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function detachObjectFromBone -}
+detachObjectFromBone :: HG3DClass -> String -> IO (HG3DClass)
 detachObjectFromBone a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -263,12 +212,8 @@
   return (a3'')
 {-# LINE 130 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Detaches an object by pointer.
---Use this method to destroy a MovableObject
-detachObjectFromBone2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
+{- function detachObjectFromBone2 -}
+detachObjectFromBone2 :: HG3DClass -> HG3DClass -> IO ()
 detachObjectFromBone2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -276,20 +221,16 @@
   return ()
 {-# LINE 135 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Detach all MovableObjects previously attached using attachObjectToBone. 
-detachAllObjectsFromBone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function detachAllObjectsFromBone -}
+detachAllObjectsFromBone :: HG3DClass -> IO ()
 detachAllObjectsFromBone a1 =
   withHG3DClass a1 $ \a1' -> 
   detachAllObjectsFromBone'_ a1' >>= \res ->
   return ()
 {-# LINE 139 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | MovableObject::getBoundingRadius
-getBoundingRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundingRadius -}
+getBoundingRadius :: HG3DClass -> IO (Float)
 getBoundingRadius a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -298,10 +239,8 @@
   return (a2'')
 {-# LINE 144 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Overridden member from ShadowCaster. 
-hasEdgeList :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasEdgeList -}
+hasEdgeList :: HG3DClass -> IO (Bool)
 hasEdgeList a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -310,10 +249,8 @@
   return (a2'')
 {-# LINE 149 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Returns whether or not this entity is skeletally animated. 
-hasSkeleton :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasSkeleton -}
+hasSkeleton :: HG3DClass -> IO (Bool)
 hasSkeleton a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -322,11 +259,8 @@
   return (a2'')
 {-# LINE 154 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Returns whether or not hardware animation is enabled.
---Because fixed-function indexed vertex blending is rarely supported by existing graphics cards, hardware animation can only be done if the vertex programs in the materials used to render an entity support it. Therefore, this method will only return true if all the materials assigned to this entity have vertex programs assigned, and all those vertex programs must support 'includes_morph_animation true' if using morph animation, 'includes_pose_animation true' if using pose animation and 'includes_skeletal_animation true' if using skeletal animation.
-isHardwareAnimationEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isHardwareAnimationEnabled -}
+isHardwareAnimationEnabled :: HG3DClass -> IO (Bool)
 isHardwareAnimationEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -335,11 +269,8 @@
   return (a2'')
 {-# LINE 159 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Returns the number of requests that have been made for software animation
---If non-zero then software animation will be performed in updateAnimation regardless of the current setting of isHardwareAnimationEnabled or any internal optimise for eliminate software animation. Requests for software animation are made by calling the addSoftwareAnimationRequest()
-getSoftwareAnimationRequests :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getSoftwareAnimationRequests -}
+getSoftwareAnimationRequests :: HG3DClass -> IO (Int)
 getSoftwareAnimationRequests a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -348,11 +279,8 @@
   return (a2'')
 {-# LINE 164 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Returns the number of requests that have been made for software animation of normals
---If non-zero, and getSoftwareAnimationRequests()getSoftwareAnimationRequests()addSoftwareAnimationRequest()
-getSoftwareAnimationNormalsRequests :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getSoftwareAnimationNormalsRequests -}
+getSoftwareAnimationNormalsRequests :: HG3DClass -> IO (Int)
 getSoftwareAnimationNormalsRequests a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -361,12 +289,8 @@
   return (a2'')
 {-# LINE 169 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Add a request for software animation
---Tells the entity to perform animation calculations for skeletal/vertex animations in software, regardless of the current setting of isHardwareAnimationEnabled()removeSoftwareAnimationRequest()
-addSoftwareAnimationRequest :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ normalsAlso
-  ->  IO ()
- -- ^ 
+{- function addSoftwareAnimationRequest -}
+addSoftwareAnimationRequest :: HG3DClass -> Bool -> IO ()
 addSoftwareAnimationRequest a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -374,12 +298,8 @@
   return ()
 {-# LINE 174 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Removes a request for software animation
---Calling this decrements the entity's internal counter of the number of requests for software animation. If the counter is already zero then calling this method throws an exception. The 'normalsAlso' flag if set to 'true' will also decrement the internal counter of number of requests for software animation of normals. 
-removeSoftwareAnimationRequest :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ normalsAlso
-  ->  IO ()
- -- ^ 
+{- function removeSoftwareAnimationRequest -}
+removeSoftwareAnimationRequest :: HG3DClass -> Bool -> IO ()
 removeSoftwareAnimationRequest a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -387,11 +307,8 @@
   return ()
 {-# LINE 179 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Shares the SkeletonInstance with the supplied entity. Note that in order for this to work, both entities must have the same Skeleton
-shareSkeletonInstanceWith :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ entity
-  ->  IO ()
- -- ^ 
+{- function shareSkeletonInstanceWith -}
+shareSkeletonInstanceWith :: HG3DClass -> HG3DClass -> IO ()
 shareSkeletonInstanceWith a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -399,10 +316,8 @@
   return ()
 {-# LINE 184 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Returns whether or not this entity is either morph or pose animated. 
-hasVertexAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasVertexAnimation -}
+hasVertexAnimation :: HG3DClass -> IO (Bool)
 hasVertexAnimation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -411,20 +326,16 @@
   return (a2'')
 {-# LINE 189 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Stops sharing the SkeletonInstance with other entities. 
-stopSharingSkeletonInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function stopSharingSkeletonInstance -}
+stopSharingSkeletonInstance :: HG3DClass -> IO ()
 stopSharingSkeletonInstance a1 =
   withHG3DClass a1 $ \a1' -> 
   stopSharingSkeletonInstance'_ a1' >>= \res ->
   return ()
 {-# LINE 193 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Returns whether this entity shares it's SkeltonInstance with other entity instances. 
-sharesSkeletonInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function sharesSkeletonInstance -}
+sharesSkeletonInstance :: HG3DClass -> IO (Bool)
 sharesSkeletonInstance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -433,22 +344,16 @@
   return (a2'')
 {-# LINE 198 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Updates the internal animation state set to include the latest
---Use this method if you manually add animations to a skeleton, or have linked the skeleton to another for animation purposes since creating this entity. If you have called getAnimationState prior to calling this method, the pointers will still remain valid. 
-refreshAvailableAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function refreshAvailableAnimationState -}
+refreshAvailableAnimationState :: HG3DClass -> IO ()
 refreshAvailableAnimationState a1 =
   withHG3DClass a1 $ \a1' -> 
   refreshAvailableAnimationState'_ a1' >>= \res ->
   return ()
 {-# LINE 202 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Choose which vertex data to bind to the renderer. 
-chooseVertexDataForBinding :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ hasVertexAnim
-  ->  IO (EnumEntityVertexDataBindChoice)
- -- ^ 
+{- function chooseVertexDataForBinding -}
+chooseVertexDataForBinding :: HG3DClass -> Bool -> IO (EnumEntityVertexDataBindChoice)
 chooseVertexDataForBinding a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -458,11 +363,8 @@
   return (a3'')
 {-# LINE 208 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Has this Entity been initialised yet?
---If this returns false, it means this EntityMeshSkeletonEntity
-isInitialised :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isInitialised -}
+isInitialised :: HG3DClass -> IO (Bool)
 isInitialised a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -471,11 +373,8 @@
   return (a2'')
 {-# LINE 213 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | Resource::ListenerEntityMesh
-backgroundLoadingComplete :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ res
-  ->  IO ()
- -- ^ 
+{- function backgroundLoadingComplete -}
+backgroundLoadingComplete :: HG3DClass -> HG3DClass -> IO ()
 backgroundLoadingComplete a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -483,11 +382,8 @@
   return ()
 {-# LINE 218 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | EntityAnimationStateAnimationState
-setSkipAnimationStateUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ skip
-  ->  IO ()
- -- ^ 
+{- function setSkipAnimationStateUpdate -}
+setSkipAnimationStateUpdate :: HG3DClass -> Bool -> IO ()
 setSkipAnimationStateUpdate a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -495,10 +391,8 @@
   return ()
 {-# LINE 223 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | EntityAnimationStateAnimationState
-getSkipAnimationStateUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getSkipAnimationStateUpdate -}
+getSkipAnimationStateUpdate :: HG3DClass -> IO (Bool)
 getSkipAnimationStateUpdate a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -507,12 +401,8 @@
   return (a2'')
 {-# LINE 228 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | The skeleton of the main entity will be updated even if the an LOD entity is being displayed.
---
-setAlwaysUpdateMainSkeleton :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ update
-  ->  IO ()
- -- ^ 
+{- function setAlwaysUpdateMainSkeleton -}
+setAlwaysUpdateMainSkeleton :: HG3DClass -> Bool -> IO ()
 setAlwaysUpdateMainSkeleton a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -520,11 +410,8 @@
   return ()
 {-# LINE 233 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntity.chs" #-}
 
--- | The skeleton of the main entity will be updated even if the an LOD entity is being displayed.
---
-getAlwaysUpdateMainSkeleton :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getAlwaysUpdateMainSkeleton -}
+getAlwaysUpdateMainSkeleton :: HG3DClass -> IO (Bool)
 getAlwaysUpdateMainSkeleton a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassEntityFactory.hs b/HGamer3D/Bindings/Ogre/ClassEntityFactory.hs
--- a/HGamer3D/Bindings/Ogre/ClassEntityFactory.hs
+++ b/HGamer3D/Bindings/Ogre/ClassEntityFactory.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntityFactory.chs" #-}
 
--- | 
+{- function EntityFactory -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,20 +57,16 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntityFactory.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~EntityFactory -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntityFactory.chs" #-}
 
--- | Get the type of the object to be created. 
-getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getType -}
+getType :: HG3DClass -> IO (String)
 getType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -80,11 +75,8 @@
   return (a2'')
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassEntityFactory.chs" #-}
 
--- | Destroy an instance of the object 
-destroyInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
+{- function destroyInstance -}
+destroyInstance :: HG3DClass -> HG3DClass -> IO ()
 destroyInstance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassException.hs b/HGamer3D/Bindings/Ogre/ClassException.hs
--- a/HGamer3D/Bindings/Ogre/ClassException.hs
+++ b/HGamer3D/Bindings/Ogre/ClassException.hs
@@ -48,12 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassException.chs" #-}
 
--- | Default constructor. 
-new :: Int  -- ^ number
-  ->  String  -- ^ description
-  ->  String  -- ^ source
-  ->  IO (HG3DClass)
- -- ^ 
+{- function Exception -}
+new :: Int -> String -> String -> IO (HG3DClass)
 new a1 a2 a3 =
   let {a1' = fromIntegral a1} in 
   withCString a2 $ \a2' -> 
@@ -64,20 +60,16 @@
   return (a4'')
 {-# LINE 50 ".\\HGamer3D\\Bindings\\Ogre\\ClassException.chs" #-}
 
--- | Needed for compatibility with std::exception. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Exception -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassException.chs" #-}
 
--- | Returns a string with the full description of this error. The description contains the error number, the description supplied by the thrower, what routine threw the exception, and will also supply extra platform-specific information where applicable. For example - in the case of a rendering library error, the description of the error will include both the place in which OGRE found the problem, and a text description from the 3D rendering library, if available. 
-getFullDescription :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getFullDescription -}
+getFullDescription :: HG3DClass -> IO (String)
 getFullDescription a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -86,10 +78,8 @@
   return (a2'')
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassException.chs" #-}
 
--- | Gets the error code. 
-getNumber :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumber -}
+getNumber :: HG3DClass -> IO (Int)
 getNumber a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -98,10 +88,8 @@
   return (a2'')
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassException.chs" #-}
 
--- | Gets the source function. 
-getSource :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getSource -}
+getSource :: HG3DClass -> IO (String)
 getSource a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -110,10 +98,8 @@
   return (a2'')
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassException.chs" #-}
 
--- | Gets source file name. 
-getFile :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getFile -}
+getFile :: HG3DClass -> IO (String)
 getFile a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -122,10 +108,8 @@
   return (a2'')
 {-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassException.chs" #-}
 
--- | Gets line number. 
-getLine :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getLine -}
+getLine :: HG3DClass -> IO (Int)
 getLine a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -134,10 +118,8 @@
   return (a2'')
 {-# LINE 79 ".\\HGamer3D\\Bindings\\Ogre\\ClassException.chs" #-}
 
--- | Returns a string with only the 'description' field of this exception. Use getFullDescriptionto get a full description of the error including line number, error number and what function threw the exception. 
-getDescription :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getDescription -}
+getDescription :: HG3DClass -> IO (String)
 getDescription a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -146,10 +128,8 @@
   return (a2'')
 {-# LINE 84 ".\\HGamer3D\\Bindings\\Ogre\\ClassException.chs" #-}
 
--- | Override std::exception::what. 
-what :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function what -}
+what :: HG3DClass -> IO (String)
 what a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassFrustum.hs b/HGamer3D/Bindings/Ogre/ClassFrustum.hs
--- a/HGamer3D/Bindings/Ogre/ClassFrustum.hs
+++ b/HGamer3D/Bindings/Ogre/ClassFrustum.hs
@@ -64,10 +64,8 @@
 import HGamer3D.Bindings.Ogre.EnumOrientationMode
 {-# LINE 50 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Named constructor. 
-new :: String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function Frustum -}
+new :: String -> IO (HG3DClass)
 new a1 =
   withCString a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -76,21 +74,16 @@
   return (a2'')
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Frustum -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 60 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets the Y-dimension Field Of View (FOV) of the frustum. Field Of View (FOV) is the angle made between the frustum's position, and the edges of the 'screen' onto which the scene is projected. High values (90+ degrees) result in a wide-angle, fish-eye kind of view, low values (30- degrees) in a stretched, telescopic kind of view. Typical values are between 45 and 60 degrees. This value represents the VERTICAL field-of-view. The horizontal field of view is calculated from this depending on the dimensions of the viewport (they will only be the same if the viewport is square). Setting the FOV overrides the value supplied for frustum::setNearClipPlane. 
-setFOVy :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ fovy
-  ->  IO ()
- -- ^ 
+{- function setFOVy -}
+setFOVy :: HG3DClass -> Radians -> IO ()
 setFOVy a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -98,10 +91,8 @@
   return ()
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Retrieves the frustums Y-dimension Field Of View (FOV). 
-getFOVy :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Radians)
- -- ^ 
+{- function getFOVy -}
+getFOVy :: HG3DClass -> IO (Radians)
 getFOVy a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -110,11 +101,8 @@
   return (a2'')
 {-# LINE 70 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets the position of the near clipping plane. The position of the near clipping plane is the distance from the frustums position to the screen on which the world is projected. The near plane distance, combined with the field-of-view and the aspect ratio, determines the size of the viewport through which the world is viewed (in world co-ordinates). Note that this world viewport is different to a screen viewport, which has it's dimensions expressed in pixels. The frustums viewport should have the same aspect ratio as the screen viewport it renders into to avoid distortion. 
-setNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ nearDist
-  ->  IO ()
- -- ^ 
+{- function setNearClipDistance -}
+setNearClipDistance :: HG3DClass -> Float -> IO ()
 setNearClipDistance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -122,10 +110,8 @@
   return ()
 {-# LINE 75 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets the position of the near clipping plane. 
-getNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getNearClipDistance -}
+getNearClipDistance :: HG3DClass -> IO (Float)
 getNearClipDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -134,11 +120,8 @@
   return (a2'')
 {-# LINE 80 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets the distance to the far clipping plane. The view frustum is a pyramid created from the frustum position and the edges of the viewport. This method sets the distance for the far end of that pyramid. Different applications need different values: e.g. a flight sim needs a much further far clipping plane than a first-person shooter. An important point here is that the larger the ratio between near and far clipping planes, the lower the accuracy of the Z-buffer used to depth-cue pixels. This is because the Z-range is limited to the size of the Z buffer (16 or 32-bit) and the max values must be spread over the gap between near and far clip planes. As it happens, you can affect the accuracy far more by altering the near distance rather than the far distance, but keep this in mind. 
-setFarClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ farDist
-  ->  IO ()
- -- ^ 
+{- function setFarClipDistance -}
+setFarClipDistance :: HG3DClass -> Float -> IO ()
 setFarClipDistance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -146,10 +129,8 @@
   return ()
 {-# LINE 85 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Retrieves the distance from the frustum to the far clipping plane. 
-getFarClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getFarClipDistance -}
+getFarClipDistance :: HG3DClass -> IO (Float)
 getFarClipDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -158,11 +139,8 @@
   return (a2'')
 {-# LINE 90 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets the aspect ratio for the frustum viewport. The ratio between the x and y dimensions of the rectangular area visible through the frustum is known as aspect ratio: aspect = width / height . The default for most fullscreen windows is 1.3333 - this is also assumed by Ogre
-setAspectRatio :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ ratio
-  ->  IO ()
- -- ^ 
+{- function setAspectRatio -}
+setAspectRatio :: HG3DClass -> Float -> IO ()
 setAspectRatio a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -170,10 +148,8 @@
   return ()
 {-# LINE 95 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Retreives the current aspect ratio. 
-getAspectRatio :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getAspectRatio -}
+getAspectRatio :: HG3DClass -> IO (Float)
 getAspectRatio a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -182,11 +158,8 @@
   return (a2'')
 {-# LINE 100 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets frustum offsets, used in stereo rendering. You can set both horizontal and vertical plane offsets of "eye"; in stereo rendering frustum is moved in horizontal plane. To be able to render from two "eyes" you'll need two cameras rendering on two RenderTargets. The frustum offsets is in world coordinates, and default to (0, 0) - no offsets. 
-setFrustumOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec2  -- ^ offset - The horizontal and vertical plane offsets. 
-  ->  IO ()
- -- ^ 
+{- function setFrustumOffset -}
+setFrustumOffset :: HG3DClass -> Vec2 -> IO ()
 setFrustumOffset a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec2 a2 $ \a2' -> 
@@ -194,12 +167,8 @@
   return ()
 {-# LINE 105 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets frustum offsets, used in stereo rendering. You can set both horizontal and vertical plane offsets of "eye"; in stereo rendering frustum is moved in horizontal plane. To be able to render from two "eyes" you'll need two cameras rendering on two RenderTargets. The frustum offsets is in world coordinates, and default to (0, 0) - no offsets. 
-setFrustumOffset2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ horizontal - The horizontal plane offset. 
-  ->  Float  -- ^ vertical - The vertical plane offset. 
-  ->  IO ()
- -- ^ 
+{- function setFrustumOffset2 -}
+setFrustumOffset2 :: HG3DClass -> Float -> Float -> IO ()
 setFrustumOffset2 a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -208,10 +177,8 @@
   return ()
 {-# LINE 111 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Retrieves the frustum offsets. 
-getFrustumOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec2)
- -- ^ 
+{- function getFrustumOffset -}
+getFrustumOffset :: HG3DClass -> IO (Vec2)
 getFrustumOffset a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -220,11 +187,8 @@
   return (a2'')
 {-# LINE 116 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets frustum focal length (used in stereo rendering). 
-setFocalLength :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ focalLength - The distance to the focal plane from the frustum in world coordinates. 
-  ->  IO ()
- -- ^ 
+{- function setFocalLength -}
+setFocalLength :: HG3DClass -> Float -> IO ()
 setFocalLength a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -232,10 +196,8 @@
   return ()
 {-# LINE 121 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Returns focal length of frustum. 
-getFocalLength :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getFocalLength -}
+getFocalLength :: HG3DClass -> IO (Float)
 getFocalLength a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -244,15 +206,8 @@
   return (a2'')
 {-# LINE 126 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Manually set the extents of the frustum.
---
-setFrustumExtents :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ left - The position where the side clip planes intersect the near clip plane, in eye space 
-  ->  Float  -- ^ right
-  ->  Float  -- ^ top
-  ->  Float  -- ^ bottom
-  ->  IO ()
- -- ^ 
+{- function setFrustumExtents -}
+setFrustumExtents :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 setFrustumExtents a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -263,20 +218,16 @@
   return ()
 {-# LINE 134 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Reset the frustum extents to be automatically derived from other params. 
-resetFrustumExtents :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function resetFrustumExtents -}
+resetFrustumExtents :: HG3DClass -> IO ()
 resetFrustumExtents a1 =
   withHG3DClass a1 $ \a1' -> 
   resetFrustumExtents'_ a1' >>= \res ->
   return ()
 {-# LINE 138 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Get the extents of the frustum in view space. 
-getFrustumExtents :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float, Float, Float, Float)
- -- ^ outleft
+{- function getFrustumExtents -}
+getFrustumExtents :: HG3DClass -> IO (Float, Float, Float, Float)
 getFrustumExtents a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -291,10 +242,8 @@
   return (a2'', a3'', a4'', a5'')
 {-# LINE 146 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Returns whether a custom view matrix is in use. 
-isCustomViewMatrixEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isCustomViewMatrixEnabled -}
+isCustomViewMatrixEnabled :: HG3DClass -> IO (Bool)
 isCustomViewMatrixEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -303,10 +252,8 @@
   return (a2'')
 {-# LINE 151 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Returns whether a custom projection matrix is in use. 
-isCustomProjectionMatrixEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isCustomProjectionMatrixEnabled -}
+isCustomProjectionMatrixEnabled :: HG3DClass -> IO (Bool)
 isCustomProjectionMatrixEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -315,11 +262,8 @@
   return (a2'')
 {-# LINE 156 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Tests whether the given vertex is visible in the FrustumOtherwise, false is returned. 
-isVisible3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vert - Vertex to be checked (world space) 
-  ->  IO (EnumFrustumPlane, Bool)
- -- ^ culledBy - Optional pointer to an int which will be filled by the plane number which culled the box if the result was false; 
+{- function isVisible3 -}
+isVisible3 :: HG3DClass -> Vec3 -> IO (EnumFrustumPlane, Bool)
 isVisible3 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -331,10 +275,8 @@
   return (a3'', a4'')
 {-# LINE 163 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Overridden from MovableObject::getTypeFlags
-getTypeFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getTypeFlags -}
+getTypeFlags :: HG3DClass -> IO (Int)
 getTypeFlags a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -343,10 +285,8 @@
   return (a2'')
 {-# LINE 168 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Overridden from MovableObject
-getBoundingRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundingRadius -}
+getBoundingRadius :: HG3DClass -> IO (Float)
 getBoundingRadius a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -355,10 +295,8 @@
   return (a2'')
 {-# LINE 173 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Overridden from MovableObject
-getMovableType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMovableType -}
+getMovableType :: HG3DClass -> IO (String)
 getMovableType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -367,10 +305,8 @@
   return (a2'')
 {-# LINE 178 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Overridden from Renderable
-getMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (SharedPtr)
- -- ^ 
+{- function getMaterial -}
+getMaterial :: HG3DClass -> IO (SharedPtr)
 getMaterial a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -379,11 +315,8 @@
   return (a2'')
 {-# LINE 183 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Overridden from Renderable
-getSquaredViewDepth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ cam
-  ->  IO (Float)
- -- ^ 
+{- function getSquaredViewDepth -}
+getSquaredViewDepth :: HG3DClass -> HG3DClass -> IO (Float)
 getSquaredViewDepth a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -393,11 +326,8 @@
   return (a3'')
 {-# LINE 189 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Gets the world space corners of the frustum.
---The corners are ordered as follows: top-right near, top-left near, bottom-left near, bottom-right near, top-right far, top-left far, bottom-left far, bottom-right far. 
-getWorldSpaceCorners :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getWorldSpaceCorners -}
+getWorldSpaceCorners :: HG3DClass -> IO (Vec3)
 getWorldSpaceCorners a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -406,11 +336,8 @@
   return (a2'')
 {-# LINE 194 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets the type of projection to use (orthographic or perspective). Default is perspective. 
-setProjectionType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumProjectionType  -- ^ pt
-  ->  IO ()
- -- ^ 
+{- function setProjectionType -}
+setProjectionType :: HG3DClass -> EnumProjectionType -> IO ()
 setProjectionType a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -418,10 +345,8 @@
   return ()
 {-# LINE 199 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Retrieves info on the type of projection used (orthographic or perspective). 
-getProjectionType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumProjectionType)
- -- ^ 
+{- function getProjectionType -}
+getProjectionType :: HG3DClass -> IO (EnumProjectionType)
 getProjectionType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -430,13 +355,8 @@
   return (a2'')
 {-# LINE 204 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets the orthographic window settings, for use with orthographic rendering only. 
---Calling this method will recalculate the aspect ratio, use setOrthoWindowHeight or setOrthoWindowWidth alone if you wish to preserve the aspect ratio but just fit one or other dimension to a particular size. 
-setOrthoWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ w - The dimensions of the view window in world units 
-  ->  Float  -- ^ h
-  ->  IO ()
- -- ^ 
+{- function setOrthoWindow -}
+setOrthoWindow :: HG3DClass -> Float -> Float -> IO ()
 setOrthoWindow a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -445,12 +365,8 @@
   return ()
 {-# LINE 210 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets the orthographic window height, for use with orthographic rendering only. 
---The width of the window will be calculated from the aspect ratio. 
-setOrthoWindowHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ h - The height of the view window in world units 
-  ->  IO ()
- -- ^ 
+{- function setOrthoWindowHeight -}
+setOrthoWindowHeight :: HG3DClass -> Float -> IO ()
 setOrthoWindowHeight a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -458,12 +374,8 @@
   return ()
 {-# LINE 215 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Sets the orthographic window width, for use with orthographic rendering only. 
---The height of the window will be calculated from the aspect ratio. 
-setOrthoWindowWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ w - The width of the view window in world units 
-  ->  IO ()
- -- ^ 
+{- function setOrthoWindowWidth -}
+setOrthoWindowWidth :: HG3DClass -> Float -> IO ()
 setOrthoWindowWidth a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -471,10 +383,8 @@
   return ()
 {-# LINE 220 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Gets the orthographic window height, for use with orthographic rendering only. 
-getOrthoWindowHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getOrthoWindowHeight -}
+getOrthoWindowHeight :: HG3DClass -> IO (Float)
 getOrthoWindowHeight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -483,11 +393,8 @@
   return (a2'')
 {-# LINE 225 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Gets the orthographic window width, for use with orthographic rendering only. 
---This is calculated from the orthographic height and the aspect ratio 
-getOrthoWindowWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getOrthoWindowWidth -}
+getOrthoWindowWidth :: HG3DClass -> IO (Float)
 getOrthoWindowWidth a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -496,20 +403,16 @@
   return (a2'')
 {-# LINE 230 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Disables reflection modification previously turned on with enableReflection 
-disableReflection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function disableReflection -}
+disableReflection :: HG3DClass -> IO ()
 disableReflection a1 =
   withHG3DClass a1 $ \a1' -> 
   disableReflection'_ a1' >>= \res ->
   return ()
 {-# LINE 234 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Returns whether this frustum is being reflected. 
-isReflected :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isReflected -}
+isReflected :: HG3DClass -> IO (Bool)
 isReflected a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -518,20 +421,16 @@
   return (a2'')
 {-# LINE 239 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Disables any custom near clip plane. 
-disableCustomNearClipPlane :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function disableCustomNearClipPlane -}
+disableCustomNearClipPlane :: HG3DClass -> IO ()
 disableCustomNearClipPlane a1 =
   withHG3DClass a1 $ \a1' -> 
   disableCustomNearClipPlane'_ a1' >>= \res ->
   return ()
 {-# LINE 243 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Is a custom near clip plane in use? 
-isCustomNearClipPlaneEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isCustomNearClipPlaneEnabled -}
+isCustomNearClipPlaneEnabled :: HG3DClass -> IO (Bool)
 isCustomNearClipPlaneEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -540,10 +439,8 @@
   return (a2'')
 {-# LINE 248 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Get the derived position of this frustum. 
-getPositionForViewUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getPositionForViewUpdate -}
+getPositionForViewUpdate :: HG3DClass -> IO (Vec3)
 getPositionForViewUpdate a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -552,10 +449,8 @@
   return (a2'')
 {-# LINE 253 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Get the derived orientation of this frustum. 
-getOrientationForViewUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Quaternion)
- -- ^ 
+{- function getOrientationForViewUpdate -}
+getOrientationForViewUpdate :: HG3DClass -> IO (Quaternion)
 getOrientationForViewUpdate a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -564,11 +459,8 @@
   return (a2'')
 {-# LINE 258 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Set the orientation mode of the frustum. Default is OR_DEGREE_0 Setting the orientation of a frustum is only supported on iOS at this time. An exception is thrown on other platforms. 
-setOrientationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumOrientationMode  -- ^ orientationMode
-  ->  IO ()
- -- ^ 
+{- function setOrientationMode -}
+setOrientationMode :: HG3DClass -> EnumOrientationMode -> IO ()
 setOrientationMode a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -576,10 +468,8 @@
   return ()
 {-# LINE 263 ".\\HGamer3D\\Bindings\\Ogre\\ClassFrustum.chs" #-}
 
--- | Get the orientation mode of the frustum. Getting the orientation of a frustum is only supported on iOS at this time. An exception is thrown on other platforms. 
-getOrientationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumOrientationMode)
- -- ^ 
+{- function getOrientationMode -}
+getOrientationMode :: HG3DClass -> IO (EnumOrientationMode)
 getOrientationMode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassHG3DMessagePump.hs b/HGamer3D/Bindings/Ogre/ClassHG3DMessagePump.hs
--- a/HGamer3D/Bindings/Ogre/ClassHG3DMessagePump.hs
+++ b/HGamer3D/Bindings/Ogre/ClassHG3DMessagePump.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassHG3DMessagePump.chs" #-}
 
--- | 
+{- function HG3DMessagePump -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,30 +57,24 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassHG3DMessagePump.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~HG3DMessagePump -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassHG3DMessagePump.chs" #-}
 
--- | 
-messagePump :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function messagePump -}
+messagePump :: HG3DClass -> IO ()
 messagePump a1 =
   withHG3DClass a1 $ \a1' -> 
   messagePump'_ a1' >>= \res ->
   return ()
 {-# LINE 55 ".\\HGamer3D\\Bindings\\Ogre\\ClassHG3DMessagePump.chs" #-}
 
--- | 
-eventsPending :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function eventsPending -}
+eventsPending :: HG3DClass -> IO (Bool)
 eventsPending a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -90,10 +83,8 @@
   return (a2'')
 {-# LINE 60 ".\\HGamer3D\\Bindings\\Ogre\\ClassHG3DMessagePump.chs" #-}
 
--- | 
-getKeyUpEvent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getKeyUpEvent -}
+getKeyUpEvent :: HG3DClass -> IO (Int)
 getKeyUpEvent a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -102,10 +93,8 @@
   return (a2'')
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassHG3DMessagePump.chs" #-}
 
--- | 
-getKeyDownEvent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getKeyDownEvent -}
+getKeyDownEvent :: HG3DClass -> IO (Int)
 getKeyDownEvent a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -114,10 +103,8 @@
   return (a2'')
 {-# LINE 70 ".\\HGamer3D\\Bindings\\Ogre\\ClassHG3DMessagePump.chs" #-}
 
--- | 
-getCharEvent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getCharEvent -}
+getCharEvent :: HG3DClass -> IO (Int)
 getCharEvent a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassLight.hs b/HGamer3D/Bindings/Ogre/ClassLight.hs
--- a/HGamer3D/Bindings/Ogre/ClassLight.hs
+++ b/HGamer3D/Bindings/Ogre/ClassLight.hs
@@ -56,10 +56,8 @@
 import HGamer3D.Bindings.Ogre.StructRadians
 {-# LINE 46 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Normal constructor. Should not be called directly, but rather the SceneManager::createLight
-new :: String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function Light2 -}
+new :: String -> IO (HG3DClass)
 new a1 =
   withCString a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -68,21 +66,16 @@
   return (a2'')
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Standard destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Light -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the type of light - see LightTypes for more info. 
-setType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumLightType  -- ^ type
-  ->  IO ()
- -- ^ 
+{- function setType -}
+setType :: HG3DClass -> EnumLightType -> IO ()
 setType a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -90,10 +83,8 @@
   return ()
 {-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the light type. 
-getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumLightType)
- -- ^ 
+{- function getType -}
+getType :: HG3DClass -> IO (EnumLightType)
 getType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -102,13 +93,8 @@
   return (a2'')
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the colour of the diffuse light given off by this source. MaterialDiffuse light simulates the typical light emanating from light sources and affects the base colour of objects together with ambient light. 
-setDiffuseColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ red
-  ->  Float  -- ^ green
-  ->  Float  -- ^ blue
-  ->  IO ()
- -- ^ 
+{- function setDiffuseColour -}
+setDiffuseColour :: HG3DClass -> Float -> Float -> Float -> IO ()
 setDiffuseColour a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -118,11 +104,8 @@
   return ()
 {-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the colour of the diffuse light given off by this source. MaterialDiffuse light simulates the typical light emanating from light sources and affects the base colour of objects together with ambient light. 
-setDiffuseColour2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ colour
-  ->  IO ()
- -- ^ 
+{- function setDiffuseColour2 -}
+setDiffuseColour2 :: HG3DClass -> Colour -> IO ()
 setDiffuseColour2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -130,10 +113,8 @@
   return ()
 {-# LINE 78 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the colour of the diffuse light given off by this light source (see setDiffuseColour for more info). 
-getDiffuseColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Colour)
- -- ^ 
+{- function getDiffuseColour -}
+getDiffuseColour :: HG3DClass -> IO (Colour)
 getDiffuseColour a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -142,13 +123,8 @@
   return (a2'')
 {-# LINE 83 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the colour of the specular light given off by this source. MaterialSpecular light affects the appearance of shiny highlights on objects, and is also dependent on the 'shininess' Material
-setSpecularColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ red
-  ->  Float  -- ^ green
-  ->  Float  -- ^ blue
-  ->  IO ()
- -- ^ 
+{- function setSpecularColour -}
+setSpecularColour :: HG3DClass -> Float -> Float -> Float -> IO ()
 setSpecularColour a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -158,11 +134,8 @@
   return ()
 {-# LINE 90 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the colour of the specular light given off by this source. MaterialSpecular light affects the appearance of shiny highlights on objects, and is also dependent on the 'shininess' Material
-setSpecularColour2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ colour
-  ->  IO ()
- -- ^ 
+{- function setSpecularColour2 -}
+setSpecularColour2 :: HG3DClass -> Colour -> IO ()
 setSpecularColour2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -170,10 +143,8 @@
   return ()
 {-# LINE 95 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the colour of specular light given off by this light source. 
-getSpecularColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Colour)
- -- ^ 
+{- function getSpecularColour -}
+getSpecularColour :: HG3DClass -> IO (Colour)
 getSpecularColour a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -182,14 +153,8 @@
   return (a2'')
 {-# LINE 100 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the attenuation parameters of the light source i.e. how it diminishes with distance. Lights normally get fainter the further they are away. Also, each light is given a maximum range beyond which it cannot affect any objects. LightThis follows a standard attenuation approach - see any good 3D text for the details of what they mean since i don't have room here! 
-setAttenuation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ range - The absolute upper range of the light in world units 
-  ->  Float  -- ^ constant - The constant factor in the attenuation formula: 1.0 means never attenuate, 0.0 is complete attenuation 
-  ->  Float  -- ^ linear - The linear factor in the attenuation formula: 1 means attenuate evenly over the distance 
-  ->  Float  -- ^ quadratic - The quadratic factor in the attenuation formula: adds a curvature to the attenuation formula. 
-  ->  IO ()
- -- ^ 
+{- function setAttenuation -}
+setAttenuation :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 setAttenuation a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -200,10 +165,8 @@
   return ()
 {-# LINE 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the absolute upper range of the light. 
-getAttenuationRange :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getAttenuationRange -}
+getAttenuationRange :: HG3DClass -> IO (Float)
 getAttenuationRange a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -212,10 +175,8 @@
   return (a2'')
 {-# LINE 113 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the constant factor in the attenuation formula. 
-getAttenuationConstant :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getAttenuationConstant -}
+getAttenuationConstant :: HG3DClass -> IO (Float)
 getAttenuationConstant a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -224,10 +185,8 @@
   return (a2'')
 {-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the linear factor in the attenuation formula. 
-getAttenuationLinear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getAttenuationLinear -}
+getAttenuationLinear :: HG3DClass -> IO (Float)
 getAttenuationLinear a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -236,10 +195,8 @@
   return (a2'')
 {-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the quadric factor in the attenuation formula. 
-getAttenuationQuadric :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getAttenuationQuadric -}
+getAttenuationQuadric :: HG3DClass -> IO (Float)
 getAttenuationQuadric a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -248,13 +205,8 @@
   return (a2'')
 {-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the position of the light. Applicable to point lights and spotlights only. This will be overridden if the light is attached to a SceneNode
-setPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function setPosition -}
+setPosition :: HG3DClass -> Float -> Float -> Float -> IO ()
 setPosition a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -264,11 +216,8 @@
   return ()
 {-# LINE 135 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the position of the light. Applicable to point lights and spotlights only. This will be overridden if the light is attached to a SceneNode
-setPosition2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vec
-  ->  IO ()
- -- ^ 
+{- function setPosition2 -}
+setPosition2 :: HG3DClass -> Vec3 -> IO ()
 setPosition2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -276,10 +225,8 @@
   return ()
 {-# LINE 140 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the position of the light. Applicable to point lights and spotlights only. 
-getPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getPosition -}
+getPosition :: HG3DClass -> IO (Vec3)
 getPosition a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -288,13 +235,8 @@
   return (a2'')
 {-# LINE 145 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the direction in which a light points. Applicable only to the spotlight and directional light types. This will be overridden if the light is attached to a SceneNode
-setDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function setDirection -}
+setDirection :: HG3DClass -> Float -> Float -> Float -> IO ()
 setDirection a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -304,11 +246,8 @@
   return ()
 {-# LINE 152 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the direction in which a light points. Applicable only to the spotlight and directional light types. This will be overridden if the light is attached to a SceneNode
-setDirection2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ vec
-  ->  IO ()
- -- ^ 
+{- function setDirection2 -}
+setDirection2 :: HG3DClass -> Vec3 -> IO ()
 setDirection2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -316,10 +255,8 @@
   return ()
 {-# LINE 157 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the light's direction. Applicable only to the spotlight and directional light types. 
-getDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getDirection -}
+getDirection :: HG3DClass -> IO (Vec3)
 getDirection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -328,13 +265,8 @@
   return (a2'')
 {-# LINE 162 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the range of a spotlight, i.e. the angle of the inner and outer cones and the rate of falloff between them. 
-setSpotlightRange :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ innerAngle - Angle covered by the bright inner cone  The inner cone applicable only to Direct3D, it'll always treat as zero in OpenGL. 
-  ->  Radians  -- ^ outerAngle - Angle covered by the outer cone 
-  ->  Float  -- ^ falloff - The rate of falloff between the inner and outer cones. 1.0 means a linear falloff, less means slower falloff, higher means faster falloff. 
-  ->  IO ()
- -- ^ 
+{- function setSpotlightRange -}
+setSpotlightRange :: HG3DClass -> Radians -> Radians -> Float -> IO ()
 setSpotlightRange a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -344,10 +276,8 @@
   return ()
 {-# LINE 169 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the angle covered by the spotlights inner cone. 
-getSpotlightInnerAngle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Radians)
- -- ^ 
+{- function getSpotlightInnerAngle -}
+getSpotlightInnerAngle :: HG3DClass -> IO (Radians)
 getSpotlightInnerAngle a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -356,10 +286,8 @@
   return (a2'')
 {-# LINE 174 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the angle covered by the spotlights outer cone. 
-getSpotlightOuterAngle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Radians)
- -- ^ 
+{- function getSpotlightOuterAngle -}
+getSpotlightOuterAngle :: HG3DClass -> IO (Radians)
 getSpotlightOuterAngle a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -368,10 +296,8 @@
   return (a2'')
 {-# LINE 179 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Returns the falloff between the inner and outer cones of the spotlight. 
-getSpotlightFalloff :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getSpotlightFalloff -}
+getSpotlightFalloff :: HG3DClass -> IO (Float)
 getSpotlightFalloff a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -380,11 +306,8 @@
   return (a2'')
 {-# LINE 184 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the angle covered by the spotlights inner cone. 
-setSpotlightInnerAngle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ val
-  ->  IO ()
- -- ^ 
+{- function setSpotlightInnerAngle -}
+setSpotlightInnerAngle :: HG3DClass -> Radians -> IO ()
 setSpotlightInnerAngle a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -392,11 +315,8 @@
   return ()
 {-# LINE 189 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the angle covered by the spotlights outer cone. 
-setSpotlightOuterAngle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ val
-  ->  IO ()
- -- ^ 
+{- function setSpotlightOuterAngle -}
+setSpotlightOuterAngle :: HG3DClass -> Radians -> IO ()
 setSpotlightOuterAngle a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -404,11 +324,8 @@
   return ()
 {-# LINE 194 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the falloff between the inner and outer cones of the spotlight. 
-setSpotlightFalloff :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ val
-  ->  IO ()
- -- ^ 
+{- function setSpotlightFalloff -}
+setSpotlightFalloff :: HG3DClass -> Float -> IO ()
 setSpotlightFalloff a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -416,11 +333,8 @@
   return ()
 {-# LINE 199 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Set the near clip plane distance to be used by spotlights that use light clipping, allowing you to render spots as if they start from further down their frustum. 
-setSpotlightNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ nearClip
-  ->  IO ()
- -- ^ 
+{- function setSpotlightNearClipDistance -}
+setSpotlightNearClipDistance :: HG3DClass -> Float -> IO ()
 setSpotlightNearClipDistance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -428,10 +342,8 @@
   return ()
 {-# LINE 204 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Get the near clip plane distance to be used by spotlights that use light clipping. 
-getSpotlightNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getSpotlightNearClipDistance -}
+getSpotlightNearClipDistance :: HG3DClass -> IO (Float)
 getSpotlightNearClipDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -440,12 +352,8 @@
   return (a2'')
 {-# LINE 209 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Set a scaling factor to indicate the relative power of a light.
---This factor is only useful in High Dynamic Range (HDR) rendering. You can bind it to a shader variable to take it into account, GpuProgramParameters 
-setPowerScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ power - The power rating of this light, default is 1.0. 
-  ->  IO ()
- -- ^ 
+{- function setPowerScale -}
+setPowerScale :: HG3DClass -> Float -> IO ()
 setPowerScale a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -453,10 +361,8 @@
   return ()
 {-# LINE 214 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Set the scaling factor which indicates the relative power of a light. 
-getPowerScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getPowerScale -}
+getPowerScale :: HG3DClass -> IO (Float)
 getPowerScale a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -465,10 +371,8 @@
   return (a2'')
 {-# LINE 219 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Overridden from MovableObject
-getMovableType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMovableType -}
+getMovableType :: HG3DClass -> IO (String)
 getMovableType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -477,12 +381,8 @@
   return (a2'')
 {-# LINE 224 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Retrieves the position of the light including any transform from nodes it is attached to. 
---
-getDerivedPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ cameraRelativeIfSet - If set to true, returns data in camera-relative units if that's been set up (render use) 
-  ->  IO (Vec3)
- -- ^ 
+{- function getDerivedPosition -}
+getDerivedPosition :: HG3DClass -> Bool -> IO (Vec3)
 getDerivedPosition a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -492,10 +392,8 @@
   return (a3'')
 {-# LINE 230 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Retrieves the direction of the light including any transform from nodes it is attached to. 
-getDerivedDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getDerivedDirection -}
+getDerivedDirection :: HG3DClass -> IO (Vec3)
 getDerivedDirection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -504,12 +402,8 @@
   return (a2'')
 {-# LINE 235 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Overridden from MovableObject.
---Although lights themselves are not 'visible', setting a light to invisible means it no longer affects the scene. 
-setVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ visible
-  ->  IO ()
- -- ^ 
+{- function setVisible -}
+setVisible :: HG3DClass -> Bool -> IO ()
 setVisible a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -517,10 +411,8 @@
   return ()
 {-# LINE 240 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Overridden from MovableObject
-getBoundingRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundingRadius -}
+getBoundingRadius :: HG3DClass -> IO (Float)
 getBoundingRadius a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -529,10 +421,8 @@
   return (a2'')
 {-# LINE 245 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Override to return specific type flag. 
-getTypeFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getTypeFlags -}
+getTypeFlags :: HG3DClass -> IO (Int)
 getTypeFlags a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -541,23 +431,16 @@
   return (a2'')
 {-# LINE 250 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Reset the shadow camera setup to the default. 
---ShadowCameraSetup 
-resetCustomShadowCameraSetup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function resetCustomShadowCameraSetup -}
+resetCustomShadowCameraSetup :: HG3DClass -> IO ()
 resetCustomShadowCameraSetup a1 =
   withHG3DClass a1 $ \a1' -> 
   resetCustomShadowCameraSetup'_ a1' >>= \res ->
   return ()
 {-# LINE 254 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Sets the maximum distance away from the camera that shadows
---Shadow techniques can be expensive, therefore it is a good idea to limit them to being rendered close to the camera if possible, and to skip the expense of rendering shadows for distance objects. This method allows you to set the distance at which shadows will no longer be rendered. Each shadow technique can interpret this subtely differently. For example, one technique may use this to eliminate casters, another might use it to attenuate the shadows themselves. You should tweak this value to suit your chosen shadow technique and scene setup. 
-setShadowFarDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ distance
-  ->  IO ()
- -- ^ 
+{- function setShadowFarDistance -}
+setShadowFarDistance :: HG3DClass -> Float -> IO ()
 setShadowFarDistance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -565,21 +448,16 @@
   return ()
 {-# LINE 259 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Tells the light to use the shadow far distance of the SceneManager
-resetShadowFarDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function resetShadowFarDistance -}
+resetShadowFarDistance :: HG3DClass -> IO ()
 resetShadowFarDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   resetShadowFarDistance'_ a1' >>= \res ->
   return ()
 {-# LINE 263 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Gets the maximum distance away from the camera that shadows
---
-getShadowFarDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getShadowFarDistance -}
+getShadowFarDistance :: HG3DClass -> IO (Float)
 getShadowFarDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -588,10 +466,8 @@
   return (a2'')
 {-# LINE 268 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | 
-getShadowFarDistanceSquared :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getShadowFarDistanceSquared -}
+getShadowFarDistanceSquared :: HG3DClass -> IO (Float)
 getShadowFarDistanceSquared a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -600,12 +476,8 @@
   return (a2'')
 {-# LINE 273 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Set the near clip plane distance to be used by the shadow camera, if
---
-setShadowNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ nearClip
-  ->  IO ()
- -- ^ 
+{- function setShadowNearClipDistance -}
+setShadowNearClipDistance :: HG3DClass -> Float -> IO ()
 setShadowNearClipDistance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -613,11 +485,8 @@
   return ()
 {-# LINE 278 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Get the near clip plane distance to be used by the shadow camera, if
---May be zero if the light doesn't have it's own near distance set; use _deriveShadowNearDistance for a version guaranteed to give a result. 
-getShadowNearClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getShadowNearClipDistance -}
+getShadowNearClipDistance :: HG3DClass -> IO (Float)
 getShadowNearClipDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -626,12 +495,8 @@
   return (a2'')
 {-# LINE 283 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Set the far clip plane distance to be used by the shadow camera, if
---This is different from the 'shadow far distance', which is always measured from the main camera. This distance is the far clip plane of the light camera. 
-setShadowFarClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ farClip
-  ->  IO ()
- -- ^ 
+{- function setShadowFarClipDistance -}
+setShadowFarClipDistance :: HG3DClass -> Float -> IO ()
 setShadowFarClipDistance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -639,11 +504,8 @@
   return ()
 {-# LINE 288 ".\\HGamer3D\\Bindings\\Ogre\\ClassLight.chs" #-}
 
--- | Get the far clip plane distance to be used by the shadow camera, if
---May be zero if the light doesn't have it's own far distance set; use _deriveShadowfarDistance for a version guaranteed to give a result. 
-getShadowFarClipDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getShadowFarClipDistance -}
+getShadowFarClipDistance :: HG3DClass -> IO (Float)
 getShadowFarClipDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassLightFactory.hs b/HGamer3D/Bindings/Ogre/ClassLightFactory.hs
--- a/HGamer3D/Bindings/Ogre/ClassLightFactory.hs
+++ b/HGamer3D/Bindings/Ogre/ClassLightFactory.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassLightFactory.chs" #-}
 
--- | 
+{- function LightFactory -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,20 +57,16 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassLightFactory.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~LightFactory -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassLightFactory.chs" #-}
 
--- | Get the type of the object to be created. 
-getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getType -}
+getType :: HG3DClass -> IO (String)
 getType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -80,11 +75,8 @@
   return (a2'')
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassLightFactory.chs" #-}
 
--- | Destroy an instance of the object 
-destroyInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
+{- function destroyInstance -}
+destroyInstance :: HG3DClass -> HG3DClass -> IO ()
 destroyInstance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassLog.hs b/HGamer3D/Bindings/Ogre/ClassLog.hs
--- a/HGamer3D/Bindings/Ogre/ClassLog.hs
+++ b/HGamer3D/Bindings/Ogre/ClassLog.hs
@@ -52,20 +52,16 @@
 import HGamer3D.Bindings.Ogre.EnumLoggingLevel
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Default destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Log -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Return the name of the log. 
-getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getName -}
+getName :: HG3DClass -> IO (String)
 getName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -74,10 +70,8 @@
   return (a2'')
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Get whether debug output is enabled for this log. 
-isDebugOutputEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isDebugOutputEnabled -}
+isDebugOutputEnabled :: HG3DClass -> IO (Bool)
 isDebugOutputEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -86,10 +80,8 @@
   return (a2'')
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Get whether file output is suppressed for this log. 
-isFileOutputSuppressed :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isFileOutputSuppressed -}
+isFileOutputSuppressed :: HG3DClass -> IO (Bool)
 isFileOutputSuppressed a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -98,10 +90,8 @@
   return (a2'')
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Get whether time stamps are printed for this log. 
-isTimeStampEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isTimeStampEnabled -}
+isTimeStampEnabled :: HG3DClass -> IO (Bool)
 isTimeStampEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -110,13 +100,8 @@
   return (a2'')
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Log
-logMessage :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ message
-  ->  EnumLogMessageLevel  -- ^ lml
-  ->  Bool  -- ^ maskDebug
-  ->  IO ()
- -- ^ 
+{- function logMessage -}
+logMessage :: HG3DClass -> String -> EnumLogMessageLevel -> Bool -> IO ()
 logMessage a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -126,11 +111,8 @@
   return ()
 {-# LINE 76 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Enable or disable outputting log messages to the debugger. 
-setDebugOutputEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ debugOutput
-  ->  IO ()
- -- ^ 
+{- function setDebugOutputEnabled -}
+setDebugOutputEnabled :: HG3DClass -> Bool -> IO ()
 setDebugOutputEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -138,11 +120,8 @@
   return ()
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Sets the level of the log detail. 
-setLogDetail :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumLoggingLevel  -- ^ ll
-  ->  IO ()
- -- ^ 
+{- function setLogDetail -}
+setLogDetail :: HG3DClass -> EnumLoggingLevel -> IO ()
 setLogDetail a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -150,11 +129,8 @@
   return ()
 {-# LINE 86 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Enable or disable time stamps. 
-setTimeStampEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ timeStamp
-  ->  IO ()
- -- ^ 
+{- function setTimeStampEnabled -}
+setTimeStampEnabled :: HG3DClass -> Bool -> IO ()
 setTimeStampEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -162,10 +138,8 @@
   return ()
 {-# LINE 91 ".\\HGamer3D\\Bindings\\Ogre\\ClassLog.chs" #-}
 
--- | Gets the level of the log detail. 
-getLogDetail :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumLoggingLevel)
- -- ^ 
+{- function getLogDetail -}
+getLogDetail :: HG3DClass -> IO (EnumLoggingLevel)
 getLogDetail a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassLogManager.hs b/HGamer3D/Bindings/Ogre/ClassLogManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassLogManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassLogManager.hs
@@ -52,24 +52,16 @@
 import HGamer3D.Bindings.Ogre.EnumLoggingLevel
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~LogManager -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Creates a new log with the given name. 
-createLog :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to give the log e.g. 'Ogre.log' 
-  ->  Bool  -- ^ defaultLog - If true, this is the default log output will be sent to if the generic logging methods on this class are used. The first log created is always the default log unless this parameter is set. 
-  ->  Bool  -- ^ debuggerOutput - If true, output to this log will also be routed to the debugger's output window. 
-  ->  Bool  -- ^ suppressFileOutput - If true, this is a logical rather than a physical log and no file output will be written. If you do this you should register a LogListener so log output is not lost. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createLog -}
+createLog :: HG3DClass -> String -> Bool -> Bool -> Bool -> IO (HG3DClass)
 createLog a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -82,11 +74,8 @@
   return (a6'')
 {-# LINE 58 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Retrieves a log managed by this class. 
-getLog :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getLog -}
+getLog :: HG3DClass -> String -> IO (HG3DClass)
 getLog a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -96,10 +85,8 @@
   return (a3'')
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Returns a pointer to the default log. 
-getDefaultLog :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getDefaultLog -}
+getDefaultLog :: HG3DClass -> IO (HG3DClass)
 getDefaultLog a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -108,11 +95,8 @@
   return (a2'')
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Closes and removes a named log. 
-destroyLog :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function destroyLog -}
+destroyLog :: HG3DClass -> String -> IO ()
 destroyLog a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -120,11 +104,8 @@
   return ()
 {-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Closes and removes a log. 
-destroyLog2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ log
-  ->  IO ()
- -- ^ 
+{- function destroyLog2 -}
+destroyLog2 :: HG3DClass -> HG3DClass -> IO ()
 destroyLog2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -132,12 +113,8 @@
   return ()
 {-# LINE 79 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Sets the passed in log as the default log.
---
-setDefaultLog :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ newLog
-  ->  IO (HG3DClass)
- -- ^ return value - The previous default log.     
+{- function setDefaultLog -}
+setDefaultLog :: HG3DClass -> HG3DClass -> IO (HG3DClass)
 setDefaultLog a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -147,13 +124,8 @@
   return (a3'')
 {-# LINE 85 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Log
-logMessage :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ message
-  ->  EnumLogMessageLevel  -- ^ lml
-  ->  Bool  -- ^ maskDebug
-  ->  IO ()
- -- ^ 
+{- function logMessage -}
+logMessage :: HG3DClass -> String -> EnumLogMessageLevel -> Bool -> IO ()
 logMessage a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -163,13 +135,8 @@
   return ()
 {-# LINE 92 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Log
-logMessage2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumLogMessageLevel  -- ^ lml
-  ->  String  -- ^ message
-  ->  Bool  -- ^ maskDebug
-  ->  IO ()
- -- ^ 
+{- function logMessage2 -}
+logMessage2 :: HG3DClass -> EnumLogMessageLevel -> String -> Bool -> IO ()
 logMessage2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -179,11 +146,8 @@
   return ()
 {-# LINE 99 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Sets the level of detail of the default log. 
-setLogDetail :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumLoggingLevel  -- ^ ll
-  ->  IO ()
- -- ^ 
+{- function setLogDetail -}
+setLogDetail :: HG3DClass -> EnumLoggingLevel -> IO ()
 setLogDetail a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -191,10 +155,8 @@
   return ()
 {-# LINE 104 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingleton -}
 getSingleton :: IO (HG3DClass)
- -- ^ 
 getSingleton =
   alloca $ \a1' -> 
   getSingleton'_ a1' >>= \res ->
@@ -202,10 +164,8 @@
   return (a1'')
 {-# LINE 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassLogManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingletonPtr -}
 getSingletonPtr :: IO (HG3DClass)
- -- ^ 
 getSingletonPtr =
   alloca $ \a1' -> 
   getSingletonPtr'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassManualObject.hs b/HGamer3D/Bindings/Ogre/ClassManualObject.hs
--- a/HGamer3D/Bindings/Ogre/ClassManualObject.hs
+++ b/HGamer3D/Bindings/Ogre/ClassManualObject.hs
@@ -58,10 +58,8 @@
 import HGamer3D.Bindings.Ogre.StructSharedPtr
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | 
-new :: String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function ManualObject -}
+new :: String -> IO (HG3DClass)
 new a1 =
   withCString a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -70,33 +68,24 @@
   return (a2'')
 {-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~ManualObject -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Completely clear the contents of the object.
---Clearing the contents of this object and rebuilding from scratch is not the optimal way to manage dynamic vertex data, since the buffers are recreated. If you want to keep the same structure but update the content within that structure, use beginUpdate()clear()begin()
-clear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function clear -}
+clear :: HG3DClass -> IO ()
 clear a1 =
   withHG3DClass a1 $ \a1' -> 
   clear'_ a1' >>= \res ->
   return ()
 {-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Estimate the number of vertices ahead of time.
---Calling this helps to avoid memory reallocation when you define vertices. Also very handy when using beginUpdate()
-estimateVertexCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ vcount
-  ->  IO ()
- -- ^ 
+{- function estimateVertexCount -}
+estimateVertexCount :: HG3DClass -> Int -> IO ()
 estimateVertexCount a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -104,12 +93,8 @@
   return ()
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Estimate the number of indices ahead of time.
---Calling this helps to avoid memory reallocation when you define indices. Also very handy when using beginUpdate()
-estimateIndexCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ icount
-  ->  IO ()
- -- ^ 
+{- function estimateIndexCount -}
+estimateIndexCount :: HG3DClass -> Int -> IO ()
 estimateIndexCount a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -117,14 +102,8 @@
   return ()
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Start defining a part of the object.
---Each time you call this method, you start a new section of the object with its own material and potentially its own type of rendering operation (triangles, points or lines for example). 
-begin :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ materialName - The name of the material to render this part of the object with. 
-  ->  EnumRenderOperationOperationType  -- ^ opType - The type of operation to use to render. 
-  ->  String  -- ^ groupName
-  ->  IO ()
- -- ^ 
+{- function begin -}
+begin :: HG3DClass -> String -> EnumRenderOperationOperationType -> String -> IO ()
 begin a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -134,11 +113,8 @@
   return ()
 {-# LINE 78 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Use before defining geometry to indicate that you intend to update the geometry regularly and want the internal structure to reflect that. 
-setDynamic :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ dyn
-  ->  IO ()
- -- ^ 
+{- function setDynamic -}
+setDynamic :: HG3DClass -> Bool -> IO ()
 setDynamic a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -146,10 +122,8 @@
   return ()
 {-# LINE 83 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Gets whether this object is marked as dynamic 
-getDynamic :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getDynamic -}
+getDynamic :: HG3DClass -> IO (Bool)
 getDynamic a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -158,12 +132,8 @@
   return (a2'')
 {-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Start the definition of an update to a part of the object.
---Using this method, you can update an existing section of the object efficiently. You do not have the option of changing the operation type obviously, since it must match the one that was used before. If your sections are changing size, particularly growing, use estimateVertexCount and estimateIndexCount to pre-size the buffers a little larger than the initial needs to avoid buffer reconstruction. 
-beginUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ sectionIndex - The index of the section you want to update. The first call to begin() would have created section 0, the second section 1, etc. 
-  ->  IO ()
- -- ^ 
+{- function beginUpdate -}
+beginUpdate :: HG3DClass -> Int -> IO ()
 beginUpdate a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -171,12 +141,8 @@
   return ()
 {-# LINE 93 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a vertex position, starting a new vertex at the same time. 
---A vertex position is slightly special among the other vertex data methods like normal()textureCoord()position()
-position :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ pos
-  ->  IO ()
- -- ^ 
+{- function position -}
+position :: HG3DClass -> Vec3 -> IO ()
 position a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -184,14 +150,8 @@
   return ()
 {-# LINE 98 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a vertex position, starting a new vertex at the same time. 
---A vertex position is slightly special among the other vertex data methods like normal()textureCoord()position()
-position2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function position2 -}
+position2 :: HG3DClass -> Float -> Float -> Float -> IO ()
 position2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -201,12 +161,8 @@
   return ()
 {-# LINE 105 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a vertex normal to the current vertex.
---Vertex normals are most often used for dynamic lighting, and their components should be normalised. 
-normal :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ norm
-  ->  IO ()
- -- ^ 
+{- function normal -}
+normal :: HG3DClass -> Vec3 -> IO ()
 normal a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -214,14 +170,8 @@
   return ()
 {-# LINE 110 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a vertex normal to the current vertex.
---Vertex normals are most often used for dynamic lighting, and their components should be normalised. 
-normal2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function normal2 -}
+normal2 :: HG3DClass -> Float -> Float -> Float -> IO ()
 normal2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -231,12 +181,8 @@
   return ()
 {-# LINE 117 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a vertex tangent to the current vertex.
---Vertex tangents are most often used for dynamic lighting, and their components should be normalised. Also, using tangent()
-tangent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ tan
-  ->  IO ()
- -- ^ 
+{- function tangent -}
+tangent :: HG3DClass -> Vec3 -> IO ()
 tangent a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -244,14 +190,8 @@
   return ()
 {-# LINE 122 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a vertex tangent to the current vertex.
---Vertex tangents are most often used for dynamic lighting, and their components should be normalised. Also, using tangent()
-tangent2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function tangent2 -}
+tangent2 :: HG3DClass -> Float -> Float -> Float -> IO ()
 tangent2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -261,12 +201,8 @@
   return ()
 {-# LINE 129 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a texture coordinate to the current vertex.
---You can call this method multiple times between position()
-textureCoord :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ u
-  ->  IO ()
- -- ^ 
+{- function textureCoord -}
+textureCoord :: HG3DClass -> Float -> IO ()
 textureCoord a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -274,13 +210,8 @@
   return ()
 {-# LINE 134 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a texture coordinate to the current vertex.
---You can call this method multiple times between position()
-textureCoord2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ u
-  ->  Float  -- ^ v
-  ->  IO ()
- -- ^ 
+{- function textureCoord2 -}
+textureCoord2 :: HG3DClass -> Float -> Float -> IO ()
 textureCoord2 a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -289,14 +220,8 @@
   return ()
 {-# LINE 140 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a texture coordinate to the current vertex.
---You can call this method multiple times between position()
-textureCoord3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ u
-  ->  Float  -- ^ v
-  ->  Float  -- ^ w
-  ->  IO ()
- -- ^ 
+{- function textureCoord3 -}
+textureCoord3 :: HG3DClass -> Float -> Float -> Float -> IO ()
 textureCoord3 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -306,15 +231,8 @@
   return ()
 {-# LINE 147 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a texture coordinate to the current vertex.
---You can call this method multiple times between position()
-textureCoord4 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  Float  -- ^ w
-  ->  IO ()
- -- ^ 
+{- function textureCoord4 -}
+textureCoord4 :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 textureCoord4 a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -325,12 +243,8 @@
   return ()
 {-# LINE 155 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a texture coordinate to the current vertex.
---You can call this method multiple times between position()
-textureCoord5 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec2  -- ^ uv
-  ->  IO ()
- -- ^ 
+{- function textureCoord5 -}
+textureCoord5 :: HG3DClass -> Vec2 -> IO ()
 textureCoord5 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec2 a2 $ \a2' -> 
@@ -338,12 +252,8 @@
   return ()
 {-# LINE 160 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a texture coordinate to the current vertex.
---You can call this method multiple times between position()
-textureCoord6 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ uvw
-  ->  IO ()
- -- ^ 
+{- function textureCoord6 -}
+textureCoord6 :: HG3DClass -> Vec3 -> IO ()
 textureCoord6 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -351,11 +261,8 @@
   return ()
 {-# LINE 165 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a vertex colour to a vertex. 
-colour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ col
-  ->  IO ()
- -- ^ 
+{- function colour -}
+colour :: HG3DClass -> Colour -> IO ()
 colour a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -363,15 +270,8 @@
   return ()
 {-# LINE 170 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a vertex colour to a vertex.
---
-colour2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ r - Colour components expressed as floating point numbers from 0-1 
-  ->  Float  -- ^ g
-  ->  Float  -- ^ b
-  ->  Float  -- ^ a
-  ->  IO ()
- -- ^ 
+{- function colour2 -}
+colour2 :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 colour2 a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -382,13 +282,8 @@
   return ()
 {-# LINE 178 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a vertex index to construct faces / lines / points via indexing
---rather than just by a simple list of vertices. 
---You will have to call this 3 times for each face for a triangle list, or use the alternative 3-parameter version. Other operation types require different numbers of indexes, RenderOperation::OperationType32-bit indexes are not supported on all cards and will only be used when required, if an index is > 65535. 
-index :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ idx - A vertex index from 0 to 4294967295. 
-  ->  IO ()
- -- ^ 
+{- function index -}
+index :: HG3DClass -> Int -> IO ()
 index a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -396,16 +291,8 @@
   return ()
 {-# LINE 183 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a set of 3 vertex indices to construct a triangle; this is a
---shortcut to calling index() 3 times. It is only valid for triangle 
---lists.
---32-bit indexes are not supported on all cards and will only be used when required, if an index is > 65535. 
-triangle :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ i1 - 3 vertex indices from 0 to 4294967295 defining a face. 
-  ->  Int  -- ^ i2
-  ->  Int  -- ^ i3
-  ->  IO ()
- -- ^ 
+{- function triangle -}
+triangle :: HG3DClass -> Int -> Int -> Int -> IO ()
 triangle a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -415,17 +302,8 @@
   return ()
 {-# LINE 190 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Add a set of 4 vertex indices to construct a quad (out of 2 
---triangles); this is a shortcut to calling index() 6 times, 
---or triangle() twice. It's only valid for triangle list operations.
---32-bit indexes are not supported on all cards and will only be used when required, if an index is > 65535. 
-quad :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ i1 - 3 vertex indices from 0 to 4294967295 defining a face. 
-  ->  Int  -- ^ i2
-  ->  Int  -- ^ i3
-  ->  Int  -- ^ i4
-  ->  IO ()
- -- ^ 
+{- function quad -}
+quad :: HG3DClass -> Int -> Int -> Int -> Int -> IO ()
 quad a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -436,10 +314,8 @@
   return ()
 {-# LINE 198 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Get the number of vertices in the section currently being defined (returns 0 if no section is in progress). 
-getCurrentVertexCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getCurrentVertexCount -}
+getCurrentVertexCount :: HG3DClass -> IO (Int)
 getCurrentVertexCount a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -448,10 +324,8 @@
   return (a2'')
 {-# LINE 203 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Get the number of indices in the section currently being defined (returns 0 if no section is in progress). 
-getCurrentIndexCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getCurrentIndexCount -}
+getCurrentIndexCount :: HG3DClass -> IO (Int)
 getCurrentIndexCount a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -460,11 +334,8 @@
   return (a2'')
 {-# LINE 208 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Finish defining the object and compile the final renderable version. 
---Will return a pointer to the finished section or NULL if the section was discarded (i.e. has zero vertices/indices). 
-end :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function end -}
+end :: HG3DClass -> IO (HG3DClass)
 end a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -473,15 +344,8 @@
   return (a2'')
 {-# LINE 213 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Alter the material for a subsection of this object after it has been
---specified.
---You specify the material to use on a section of this object during the call to begin()
-setMaterialName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ subindex
-  ->  String  -- ^ name - The name of the new material to use 
-  ->  String  -- ^ group
-  ->  IO ()
- -- ^ 
+{- function setMaterialName -}
+setMaterialName :: HG3DClass -> Int -> String -> String -> IO ()
 setMaterialName a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -491,13 +355,8 @@
   return ()
 {-# LINE 220 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Convert this object to a Mesh. 
---After you've finished building this object, you may convert it to a MeshEntitySceneNodeOnly objects which use indexed geometry may be converted to a mesh. 
-convertToMesh :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ meshName - The name to give the mesh 
-  ->  String  -- ^ groupName - The resource group to create the mesh in 
-  ->  IO (SharedPtr)
- -- ^ 
+{- function convertToMesh -}
+convertToMesh :: HG3DClass -> String -> String -> IO (SharedPtr)
 convertToMesh a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -508,12 +367,8 @@
   return (a4'')
 {-# LINE 227 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Sets whether or not to use an 'identity' projection.
---Usually ManualObjects will use a projection matrix as determined by the active camera. However, if they want they can cancel this out and use an identity projection, which effectively projects in 2D using a {-1, 1} view space. Useful for overlay rendering. Normally you don't need to change this. The default is false. ManualObject::getUseIdentityProjection
-setUseIdentityProjection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ useIdentityProjection
-  ->  IO ()
- -- ^ 
+{- function setUseIdentityProjection -}
+setUseIdentityProjection :: HG3DClass -> Bool -> IO ()
 setUseIdentityProjection a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -521,11 +376,8 @@
   return ()
 {-# LINE 232 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Returns whether or not to use an 'identity' projection.
---Usually ManualObjects will use a projection matrix as determined by the active camera. However, if they want they can cancel this out and use an identity projection, which effectively projects in 2D using a {-1, 1} view space. Useful for overlay rendering. Normally you don't need to change this. ManualObject::setUseIdentityProjection
-getUseIdentityProjection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseIdentityProjection -}
+getUseIdentityProjection :: HG3DClass -> IO (Bool)
 getUseIdentityProjection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -534,12 +386,8 @@
   return (a2'')
 {-# LINE 237 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Sets whether or not to use an 'identity' view.
---Usually ManualObjects will use a view matrix as determined by the active camera. However, if they want they can cancel this out and use an identity matrix, which means all geometry is assumed to be relative to camera space already. Useful for overlay rendering. Normally you don't need to change this. The default is false. ManualObject::getUseIdentityView
-setUseIdentityView :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ useIdentityView
-  ->  IO ()
- -- ^ 
+{- function setUseIdentityView -}
+setUseIdentityView :: HG3DClass -> Bool -> IO ()
 setUseIdentityView a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -547,11 +395,8 @@
   return ()
 {-# LINE 242 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Returns whether or not to use an 'identity' view.
---Usually ManualObjects will use a view matrix as determined by the active camera. However, if they want they can cancel this out and use an identity matrix, which means all geometry is assumed to be relative to camera space already. Useful for overlay rendering. Normally you don't need to change this. ManualObject::setUseIdentityView
-getUseIdentityView :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseIdentityView -}
+getUseIdentityView :: HG3DClass -> IO (Bool)
 getUseIdentityView a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -560,11 +405,8 @@
   return (a2'')
 {-# LINE 247 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Gets a pointer to a ManualObjectSectionManualObject
-getSection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getSection -}
+getSection :: HG3DClass -> Int -> IO (HG3DClass)
 getSection a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -574,10 +416,8 @@
   return (a3'')
 {-# LINE 253 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Retrieves the number of ManualObjectSectionManualObject
-getNumSections :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumSections -}
+getNumSections :: HG3DClass -> IO (Int)
 getNumSections a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -586,13 +426,8 @@
   return (a2'')
 {-# LINE 258 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Sets whether or not to keep the original declaration order when 
---queuing the renderables.
---This overrides the default behavior of the rendering queue, specifically stating the desired order of rendering. Might result in a performance loss, but lets the user to have more direct control when creating geometry through this class. 
-setKeepDeclarationOrder :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ keepOrder - Whether to keep the declaration order or not. 
-  ->  IO ()
- -- ^ 
+{- function setKeepDeclarationOrder -}
+setKeepDeclarationOrder :: HG3DClass -> Bool -> IO ()
 setKeepDeclarationOrder a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -600,11 +435,8 @@
   return ()
 {-# LINE 263 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Gets whether or not the declaration order is to be kept or not.
---
-getKeepDeclarationOrder :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ return value - A flag indication if the declaration order will be kept when queuing the renderables.     
+{- function getKeepDeclarationOrder -}
+getKeepDeclarationOrder :: HG3DClass -> IO (Bool)
 getKeepDeclarationOrder a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -613,10 +445,8 @@
   return (a2'')
 {-# LINE 268 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | .  - Details: Returns the type name of this object. 
-getMovableType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMovableType -}
+getMovableType :: HG3DClass -> IO (String)
 getMovableType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -625,10 +455,8 @@
   return (a2'')
 {-# LINE 273 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | .  - Details: Retrieves the radius of the origin-centered bounding sphere for this object. 
-getBoundingRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundingRadius -}
+getBoundingRadius :: HG3DClass -> IO (Float)
 getBoundingRadius a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -637,10 +465,8 @@
   return (a2'')
 {-# LINE 278 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObject.chs" #-}
 
--- | Overridden member from ShadowCaster. 
-hasEdgeList :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasEdgeList -}
+hasEdgeList :: HG3DClass -> IO (Bool)
 hasEdgeList a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassManualObjectFactory.hs b/HGamer3D/Bindings/Ogre/ClassManualObjectFactory.hs
--- a/HGamer3D/Bindings/Ogre/ClassManualObjectFactory.hs
+++ b/HGamer3D/Bindings/Ogre/ClassManualObjectFactory.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectFactory.chs" #-}
 
--- | 
+{- function ManualObjectFactory -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,20 +57,16 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectFactory.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~ManualObjectFactory -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectFactory.chs" #-}
 
--- | Get the type of the object to be created. 
-getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getType -}
+getType :: HG3DClass -> IO (String)
 getType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -80,11 +75,8 @@
   return (a2'')
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectFactory.chs" #-}
 
--- | Destroy an instance of the object 
-destroyInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
+{- function destroyInstance -}
+destroyInstance :: HG3DClass -> HG3DClass -> IO ()
 destroyInstance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassManualObjectSection.hs b/HGamer3D/Bindings/Ogre/ClassManualObjectSection.hs
--- a/HGamer3D/Bindings/Ogre/ClassManualObjectSection.hs
+++ b/HGamer3D/Bindings/Ogre/ClassManualObjectSection.hs
@@ -52,13 +52,8 @@
 import HGamer3D.Bindings.Ogre.StructSharedPtr
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectSection.chs" #-}
 
--- | 
-new :: HG3DClass  -- ^ parent
-  ->  String  -- ^ materialName
-  ->  EnumRenderOperationOperationType  -- ^ opType
-  ->  String  -- ^ groupName
-  ->  IO (HG3DClass)
- -- ^ 
+{- function ManualObjectSection -}
+new :: HG3DClass -> String -> EnumRenderOperationOperationType -> String -> IO (HG3DClass)
 new a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -70,20 +65,16 @@
   return (a5'')
 {-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectSection.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~ManualObjectSection -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectSection.chs" #-}
 
--- | Retrieve the material name in use. 
-getMaterialName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMaterialName -}
+getMaterialName :: HG3DClass -> IO (String)
 getMaterialName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -92,10 +83,8 @@
   return (a2'')
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectSection.chs" #-}
 
--- | Retrieve the material group in use. 
-getMaterialGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMaterialGroup -}
+getMaterialGroup :: HG3DClass -> IO (String)
 getMaterialGroup a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -104,12 +93,8 @@
   return (a2'')
 {-# LINE 67 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectSection.chs" #-}
 
--- | update the material name in use 
-setMaterialName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  String  -- ^ groupName
-  ->  IO ()
- -- ^ 
+{- function setMaterialName -}
+setMaterialName :: HG3DClass -> String -> String -> IO ()
 setMaterialName a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -118,11 +103,8 @@
   return ()
 {-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectSection.chs" #-}
 
--- | Set whether we need 32-bit indices. 
-set32BitIndices :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ n32
-  ->  IO ()
- -- ^ 
+{- function set32BitIndices -}
+set32BitIndices :: HG3DClass -> Bool -> IO ()
 set32BitIndices a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -130,10 +112,8 @@
   return ()
 {-# LINE 78 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectSection.chs" #-}
 
--- | Get whether we need 32-bit indices. 
-get32BitIndices :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function get32BitIndices -}
+get32BitIndices :: HG3DClass -> IO (Bool)
 get32BitIndices a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -142,11 +122,8 @@
   return (a2'')
 {-# LINE 83 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectSection.chs" #-}
 
--- | .  - Details: Retrieves a weak reference to the material this renderable object uses.
---Note that the Renderable
-getMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (SharedPtr)
- -- ^ 
+{- function getMaterial -}
+getMaterial :: HG3DClass -> IO (SharedPtr)
 getMaterial a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -155,12 +132,8 @@
   return (a2'')
 {-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassManualObjectSection.chs" #-}
 
--- | .  - Details: Returns the camera-relative squared depth of this renderable.
---Used to sort transparent objects. Squared depth is used rather than actual depth to avoid having to perform a square root on the result. 
-getSquaredViewDepth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ 
-  ->  IO (Float)
- -- ^ 
+{- function getSquaredViewDepth -}
+getSquaredViewDepth :: HG3DClass -> HG3DClass -> IO (Float)
 getSquaredViewDepth a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassMaterial.hs b/HGamer3D/Bindings/Ogre/ClassMaterial.hs
--- a/HGamer3D/Bindings/Ogre/ClassMaterial.hs
+++ b/HGamer3D/Bindings/Ogre/ClassMaterial.hs
@@ -52,20 +52,16 @@
 import HGamer3D.Bindings.Ogre.StructColour
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Material -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Determines if the material has any transparency with the rest of the scene (derived from whether any Techniques say they involve transparency). 
-isTransparent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isTransparent -}
+isTransparent :: HG3DClass -> IO (Bool)
 isTransparent a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -74,12 +70,8 @@
   return (a2'')
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets whether objects using this material will receive shadows.
---This method allows a material to opt out of receiving shadows, if it would otherwise do so. Shadows will not be cast on any objects unless the scene is set up to support shadows (SceneManager::setShadowTechniqueTransparent materials never receive shadows despite this setting. The default is to receive shadows. 
-setReceiveShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setReceiveShadows -}
+setReceiveShadows :: HG3DClass -> Bool -> IO ()
 setReceiveShadows a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -87,10 +79,8 @@
   return ()
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Returns whether or not objects using this material will receive shadows. 
-getReceiveShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getReceiveShadows -}
+getReceiveShadows :: HG3DClass -> IO (Bool)
 getReceiveShadows a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -99,12 +89,8 @@
   return (a2'')
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets whether objects using this material be classified as opaque to the shadow caster system.
---This method allows a material to cast a shadow, even if it is transparent. By default, transparent materials neither cast nor receive shadows. Shadows will not be cast on any objects unless the scene is set up to support shadows (SceneManager::setShadowTechnique
-setTransparencyCastsShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setTransparencyCastsShadows -}
+setTransparencyCastsShadows :: HG3DClass -> Bool -> IO ()
 setTransparencyCastsShadows a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -112,10 +98,8 @@
   return ()
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Returns whether or not objects using this material be classified as opaque to the shadow caster system. 
-getTransparencyCastsShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getTransparencyCastsShadows -}
+getTransparencyCastsShadows :: HG3DClass -> IO (Bool)
 getTransparencyCastsShadows a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -124,10 +108,8 @@
   return (a2'')
 {-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Retrieves the number of techniques. 
-getNumTechniques :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumTechniques -}
+getNumTechniques :: HG3DClass -> IO (Int)
 getNumTechniques a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -136,11 +118,8 @@
   return (a2'')
 {-# LINE 79 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Removes the technique at the given index. 
-removeTechnique :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO ()
- -- ^ 
+{- function removeTechnique -}
+removeTechnique :: HG3DClass -> Int -> IO ()
 removeTechnique a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -148,20 +127,16 @@
   return ()
 {-# LINE 84 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Removes all the techniques in this Material
-removeAllTechniques :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAllTechniques -}
+removeAllTechniques :: HG3DClass -> IO ()
 removeAllTechniques a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAllTechniques'_ a1' >>= \res ->
   return ()
 {-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Retrieves the number of supported techniques. 
-getNumSupportedTechniques :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumSupportedTechniques -}
+getNumSupportedTechniques :: HG3DClass -> IO (Int)
 getNumSupportedTechniques a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -170,10 +145,8 @@
   return (a2'')
 {-# LINE 93 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Gets a string explaining why any techniques are not supported. 
-getUnsupportedTechniquesExplanation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getUnsupportedTechniquesExplanation -}
+getUnsupportedTechniquesExplanation :: HG3DClass -> IO (String)
 getUnsupportedTechniquesExplanation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -182,13 +155,8 @@
   return (a2'')
 {-# LINE 98 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Gets the number of levels-of-detail this material has in the 
---given scheme, based on Technique::setLodIndex. 
---Note that this will not be up to date until the material has been compiled. 
-getNumLodLevels :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ schemeIndex
-  ->  IO (Int)
- -- ^ 
+{- function getNumLodLevels -}
+getNumLodLevels :: HG3DClass -> Int -> IO (Int)
 getNumLodLevels a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -198,13 +166,8 @@
   return (a3'')
 {-# LINE 104 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Gets the number of levels-of-detail this material has in the 
---given scheme, based on Technique::setLodIndex. 
---Note that this will not be up to date until the material has been compiled. 
-getNumLodLevels2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ schemeName
-  ->  IO (Int)
- -- ^ 
+{- function getNumLodLevels2 -}
+getNumLodLevels2 :: HG3DClass -> String -> IO (Int)
 getNumLodLevels2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -214,14 +177,8 @@
   return (a3'')
 {-# LINE 110 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Creates a new copy of this material with the same settings but a new name.
---
-clone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ newName - The name for the cloned material 
-  ->  Bool  -- ^ changeGroup - If true, the resource group of the clone is changed 
-  ->  String  -- ^ newGroup - Only required if changeGroup is true; the new group to assign 
-  ->  IO (SharedPtr)
- -- ^ 
+{- function clone -}
+clone :: HG3DClass -> String -> Bool -> String -> IO (SharedPtr)
 clone a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -233,11 +190,8 @@
   return (a5'')
 {-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Copies the details of this material into another, preserving the target's handle and name
---
-copyDetailsTo :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (SharedPtr)
- -- ^ mat - Weak reference to material which will receive this material's settings. 
+{- function copyDetailsTo -}
+copyDetailsTo :: HG3DClass -> IO (SharedPtr)
 copyDetailsTo a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -246,12 +200,8 @@
   return (a2'')
 {-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | 'Compiles' this Material.
---Compiling a material involves determining which Techniques are supported on the card on which OGRE is currently running, and for fixed-function Passes within those Techniques, splitting the passes down where they contain more TextureUnitState instances than the current card has texture units. This process is automatically done when the Material
-compile :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ autoManageTextureUnits - If true, when a fixed function pass has too many TextureUnitState entries than the card has texture units, the Pass in question will be split into more than one Pass in order to emulate the Pass. If you set this to false and this situation arises, an Exception will be thrown. 
-  ->  IO ()
- -- ^ 
+{- function compile -}
+compile :: HG3DClass -> Bool -> IO ()
 compile a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -259,12 +209,8 @@
   return ()
 {-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the point size properties for every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setPointSize 
-setPointSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ ps
-  ->  IO ()
- -- ^ 
+{- function setPointSize -}
+setPointSize :: HG3DClass -> Float -> IO ()
 setPointSize a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -272,14 +218,8 @@
   return ()
 {-# LINE 133 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the ambient colour reflectance properties for every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setAmbient 
-setAmbient :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ red
-  ->  Float  -- ^ green
-  ->  Float  -- ^ blue
-  ->  IO ()
- -- ^ 
+{- function setAmbient -}
+setAmbient :: HG3DClass -> Float -> Float -> Float -> IO ()
 setAmbient a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -289,12 +229,8 @@
   return ()
 {-# LINE 140 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the ambient colour reflectance properties for every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setAmbient 
-setAmbient2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ ambient
-  ->  IO ()
- -- ^ 
+{- function setAmbient2 -}
+setAmbient2 :: HG3DClass -> Colour -> IO ()
 setAmbient2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -302,15 +238,8 @@
   return ()
 {-# LINE 145 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the diffuse colour reflectance properties of every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setDiffuse 
-setDiffuse :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ red
-  ->  Float  -- ^ green
-  ->  Float  -- ^ blue
-  ->  Float  -- ^ alpha
-  ->  IO ()
- -- ^ 
+{- function setDiffuse -}
+setDiffuse :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 setDiffuse a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -321,12 +250,8 @@
   return ()
 {-# LINE 153 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the diffuse colour reflectance properties of every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setDiffuse 
-setDiffuse2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ diffuse
-  ->  IO ()
- -- ^ 
+{- function setDiffuse2 -}
+setDiffuse2 :: HG3DClass -> Colour -> IO ()
 setDiffuse2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -334,15 +259,8 @@
   return ()
 {-# LINE 158 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the specular colour reflectance properties of every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setSpecular 
-setSpecular :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ red
-  ->  Float  -- ^ green
-  ->  Float  -- ^ blue
-  ->  Float  -- ^ alpha
-  ->  IO ()
- -- ^ 
+{- function setSpecular -}
+setSpecular :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 setSpecular a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -353,12 +271,8 @@
   return ()
 {-# LINE 166 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the specular colour reflectance properties of every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setSpecular 
-setSpecular2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ specular
-  ->  IO ()
- -- ^ 
+{- function setSpecular2 -}
+setSpecular2 :: HG3DClass -> Colour -> IO ()
 setSpecular2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -366,12 +280,8 @@
   return ()
 {-# LINE 171 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the shininess properties of every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setShininess 
-setShininess :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ val
-  ->  IO ()
- -- ^ 
+{- function setShininess -}
+setShininess :: HG3DClass -> Float -> IO ()
 setShininess a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -379,14 +289,8 @@
   return ()
 {-# LINE 176 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the amount of self-illumination of every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setSelfIllumination 
-setSelfIllumination :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ red
-  ->  Float  -- ^ green
-  ->  Float  -- ^ blue
-  ->  IO ()
- -- ^ 
+{- function setSelfIllumination -}
+setSelfIllumination :: HG3DClass -> Float -> Float -> Float -> IO ()
 setSelfIllumination a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -396,12 +300,8 @@
   return ()
 {-# LINE 183 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the amount of self-illumination of every Pass in every Technique.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setSelfIllumination 
-setSelfIllumination2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ selfIllum
-  ->  IO ()
- -- ^ 
+{- function setSelfIllumination2 -}
+setSelfIllumination2 :: HG3DClass -> Colour -> IO ()
 setSelfIllumination2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -409,12 +309,8 @@
   return ()
 {-# LINE 188 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets whether or not each Pass renders with depth-buffer checking on or not.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setDepthCheckEnabled 
-setDepthCheckEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setDepthCheckEnabled -}
+setDepthCheckEnabled :: HG3DClass -> Bool -> IO ()
 setDepthCheckEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -422,12 +318,8 @@
   return ()
 {-# LINE 193 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets whether or not each Pass renders with depth-buffer writing on or not.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setDepthWriteEnabled 
-setDepthWriteEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setDepthWriteEnabled -}
+setDepthWriteEnabled :: HG3DClass -> Bool -> IO ()
 setDepthWriteEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -435,12 +327,8 @@
   return ()
 {-# LINE 198 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets whether or not colour buffer writing is enabled for each Pass.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setColourWriteEnabled 
-setColourWriteEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setColourWriteEnabled -}
+setColourWriteEnabled :: HG3DClass -> Bool -> IO ()
 setColourWriteEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -448,12 +336,8 @@
   return ()
 {-# LINE 203 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets whether or not dynamic lighting is enabled for every Pass.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setLightingEnabled 
-setLightingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setLightingEnabled -}
+setLightingEnabled :: HG3DClass -> Bool -> IO ()
 setLightingEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -461,13 +345,8 @@
   return ()
 {-# LINE 208 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the depth bias to be used for each Pass.
---This property has been moved to the Pass class, which is accessible via the Technique. For simplicity, this method allows you to set these properties for every current Technique, and for every current Pass within those Techniques. If you need more precision, retrieve the Technique and Pass instances and set the property there. Pass::setDepthBias 
-setDepthBias :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ constantBias
-  ->  Float  -- ^ slopeScaleBias
-  ->  IO ()
- -- ^ 
+{- function setDepthBias -}
+setDepthBias :: HG3DClass -> Float -> Float -> IO ()
 setDepthBias a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -476,12 +355,8 @@
   return ()
 {-# LINE 214 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Sets the anisotropy level to be used for all textures.
---This property has been moved to the TextureUnitState class, which is accessible via the Technique and Pass. For simplicity, this method allows you to set these properties for every current TeextureUnitState, If you need more precision, retrieve the Technique, Pass and TextureUnitState instances and set the property there. TextureUnitState::setTextureAnisotropy 
-setTextureAnisotropy :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ maxAniso
-  ->  IO ()
- -- ^ 
+{- function setTextureAnisotropy -}
+setTextureAnisotropy :: HG3DClass -> Int -> IO ()
 setTextureAnisotropy a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -489,21 +364,16 @@
   return ()
 {-# LINE 219 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | 'Touches' the resource to indicate it has been used. 
-touch :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function touch -}
+touch :: HG3DClass -> IO ()
 touch a1 =
   withHG3DClass a1 $ \a1' -> 
   touch'_ a1' >>= \res ->
   return ()
 {-# LINE 223 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterial.chs" #-}
 
--- | Gets the compilation status of the material.
---
-getCompilationRequired :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ return value - True if the material needs recompilation.     
+{- function getCompilationRequired -}
+getCompilationRequired :: HG3DClass -> IO (Bool)
 getCompilationRequired a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassMaterialManager.hs b/HGamer3D/Bindings/Ogre/ClassMaterialManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassMaterialManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassMaterialManager.hs
@@ -50,9 +50,8 @@
 import HGamer3D.Bindings.Ogre.StructSharedPtr
 {-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Default constructor. 
+{- function MaterialManager -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -60,31 +59,24 @@
   return (a1'')
 {-# LINE 48 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Default destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~MaterialManager -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Initialises the material manager, which also triggers it to parse all available .program and .material scripts. 
-initialise :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function initialise -}
+initialise :: HG3DClass -> IO ()
 initialise a1 =
   withHG3DClass a1 $ \a1' -> 
   initialise'_ a1' >>= \res ->
   return ()
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Sets the default anisotropy level to be used for loaded textures, for when textures are loaded automatically (e.g. by MaterialThe default value is 1 (no anisotropy). 
-setDefaultAnisotropy :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ maxAniso
-  ->  IO ()
- -- ^ 
+{- function setDefaultAnisotropy -}
+setDefaultAnisotropy :: HG3DClass -> Int -> IO ()
 setDefaultAnisotropy a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -92,10 +84,8 @@
   return ()
 {-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Get the default maxAnisotropy. 
-getDefaultAnisotropy :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getDefaultAnisotropy -}
+getDefaultAnisotropy :: HG3DClass -> IO (Int)
 getDefaultAnisotropy a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -104,45 +94,8 @@
   return (a2'')
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Returns a pointer to the default MaterialOgreMaterialThe default settings begin as a single Technique with a single, non-programmable Pass: 
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
---
-getDefaultSettings :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (SharedPtr)
- -- ^ 
+{- function getDefaultSettings -}
+getDefaultSettings :: HG3DClass -> IO (SharedPtr)
 getDefaultSettings a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -151,11 +104,8 @@
   return (a2'')
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Returns the name of the active material scheme. 
---Technique::setSchemeName 
-getActiveScheme :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getActiveScheme -}
+getActiveScheme :: HG3DClass -> IO (String)
 getActiveScheme a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -164,12 +114,8 @@
   return (a2'')
 {-# LINE 76 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Sets the name of the active material scheme. 
---Technique::setSchemeName 
-setActiveScheme :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ schemeName
-  ->  IO ()
- -- ^ 
+{- function setActiveScheme -}
+setActiveScheme :: HG3DClass -> String -> IO ()
 setActiveScheme a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -177,10 +123,8 @@
   return ()
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingleton -}
 getSingleton :: IO (HG3DClass)
- -- ^ 
 getSingleton =
   alloca $ \a1' -> 
   getSingleton'_ a1' >>= \res ->
@@ -188,10 +132,8 @@
   return (a1'')
 {-# LINE 85 ".\\HGamer3D\\Bindings\\Ogre\\ClassMaterialManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingletonPtr -}
 getSingletonPtr :: IO (HG3DClass)
- -- ^ 
 getSingletonPtr =
   alloca $ \a1' -> 
   getSingletonPtr'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassMesh.hs b/HGamer3D/Bindings/Ogre/ClassMesh.hs
--- a/HGamer3D/Bindings/Ogre/ClassMesh.hs
+++ b/HGamer3D/Bindings/Ogre/ClassMesh.hs
@@ -52,21 +52,16 @@
 import HGamer3D.Bindings.Ogre.EnumVertexAnimationType
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Mesh -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Removes a name from a SubMesh 
-unnameSubMesh :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function unnameSubMesh -}
+unnameSubMesh :: HG3DClass -> String -> IO ()
 unnameSubMesh a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -74,10 +69,8 @@
   return ()
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Gets the number of sub meshes which comprise this mesh. 
-getNumSubMeshes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumSubMeshes -}
+getNumSubMeshes :: HG3DClass -> IO (Int)
 getNumSubMeshes a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -86,11 +79,8 @@
   return (a2'')
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Destroy a SubMesh with the given index. This will invalidate the contents of any existing EntityEntity
-destroySubMesh :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO ()
- -- ^ 
+{- function destroySubMesh -}
+destroySubMesh :: HG3DClass -> Int -> IO ()
 destroySubMesh a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -98,11 +88,8 @@
   return ()
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Destroy a SubMesh with the given name. This will invalidate the contents of any existing EntityEntity
-destroySubMesh2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function destroySubMesh2 -}
+destroySubMesh2 :: HG3DClass -> String -> IO ()
 destroySubMesh2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -110,12 +97,8 @@
   return ()
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Makes a copy of this mesh object and gives it a new name. This is useful if you want to tweak an existing mesh without affecting the original one. The newly cloned mesh is registered with the MeshManager
-clone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ newName - The name to give the clone 
-  ->  String  -- ^ newGroup - Optional name of the new group to assign the clone to; if you leave this blank, the clone will be assigned to the same group as this Mesh. 
-  ->  IO (SharedPtr)
- -- ^ 
+{- function clone -}
+clone :: HG3DClass -> String -> String -> IO (SharedPtr)
 clone a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -126,10 +109,8 @@
   return (a4'')
 {-# LINE 76 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Gets the radius of the bounding sphere surrounding this mesh. 
-getBoundingSphereRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundingSphereRadius -}
+getBoundingSphereRadius :: HG3DClass -> IO (Float)
 getBoundingSphereRadius a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -138,12 +119,8 @@
   return (a2'')
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Sets the name of the skeleton this Mesh uses for animation.
---Meshes can optionally be assigned a skeleton which can be used to animate the mesh through bone assignments. The default is for the MeshMesh
-setSkeletonName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ skelName - The name of the .skeleton file to use, or an empty string to use no skeleton 
-  ->  IO ()
- -- ^ 
+{- function setSkeletonName -}
+setSkeletonName :: HG3DClass -> String -> IO ()
 setSkeletonName a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -151,10 +128,8 @@
   return ()
 {-# LINE 86 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Returns true if this MeshSkeleton
-hasSkeleton :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasSkeleton -}
+hasSkeleton :: HG3DClass -> IO (Bool)
 hasSkeleton a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -163,10 +138,8 @@
   return (a2'')
 {-# LINE 91 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Returns whether or not this mesh has some kind of vertex animation. 
-hasVertexAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasVertexAnimation -}
+hasVertexAnimation :: HG3DClass -> IO (Bool)
 hasVertexAnimation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -175,11 +148,8 @@
   return (a2'')
 {-# LINE 96 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Gets a pointer to any linked Skeleton. 
---
-getSkeleton :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (SharedPtr)
- -- ^ return value - Weak reference to the skeleton - copy this if you want to hold a strong pointer.     
+{- function getSkeleton -}
+getSkeleton :: HG3DClass -> IO (SharedPtr)
 getSkeleton a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -188,10 +158,8 @@
   return (a2'')
 {-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Gets the name of any linked Skeleton
-getSkeletonName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getSkeletonName -}
+getSkeletonName :: HG3DClass -> IO (String)
 getSkeletonName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -200,25 +168,16 @@
   return (a2'')
 {-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Removes all bone assignments for this mesh. 
---This method is for modifying weights to the shared geometry of the Mesh
-clearBoneAssignments :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function clearBoneAssignments -}
+clearBoneAssignments :: HG3DClass -> IO ()
 clearBoneAssignments a1 =
   withHG3DClass a1 $ \a1' -> 
   clearBoneAssignments'_ a1' >>= \res ->
   return ()
 {-# LINE 110 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Adds a new manual level-of-detail entry to this Mesh.
---As an alternative to generating lower level of detail versions of a mesh, you can use your own manually modelled meshes as lower level versions. This lets you have complete control over the LOD, and in addition lets you scale down other aspects of the model which cannot be done using the generated method; for example, you could use less detailed materials and / or use less bones in the skeleton if this is an animated mesh. Therefore for complex models you are likely to be better off modelling your LODs yourself and using this method, whilst for models with fairly simple materials and no animation you can just use the generateLodLevels method. 
-createManualLodLevel :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ value - The value from which this Lod will apply. 
-  ->  String  -- ^ meshName - The name of the mesh which will be the lower level detail version. 
-  ->  String  -- ^ groupName
-  ->  IO ()
- -- ^ 
+{- function createManualLodLevel -}
+createManualLodLevel :: HG3DClass -> Float -> String -> String -> IO ()
 createManualLodLevel a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -228,11 +187,8 @@
   return ()
 {-# LINE 117 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Returns true if this mesh is using manual LOD.
---A mesh can either use automatically generated LOD, or it can use alternative meshes as provided by an artist. A mesh can only use either all manual LODs or all generated LODs, not a mixture of both. 
-isLodManual :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isLodManual -}
+isLodManual :: HG3DClass -> IO (Bool)
 isLodManual a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -241,20 +197,16 @@
   return (a2'')
 {-# LINE 122 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Removes all LOD data from this Mesh
-removeLodLevels :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeLodLevels -}
+removeLodLevels :: HG3DClass -> IO ()
 removeLodLevels a1 =
   withHG3DClass a1 $ \a1' -> 
   removeLodLevels'_ a1' >>= \res ->
   return ()
 {-# LINE 126 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Gets whether or not this meshes vertex buffers are shadowed. 
-isVertexBufferShadowed :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isVertexBufferShadowed -}
+isVertexBufferShadowed :: HG3DClass -> IO (Bool)
 isVertexBufferShadowed a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -263,10 +215,8 @@
   return (a2'')
 {-# LINE 131 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Gets whether or not this meshes index buffers are shadowed. 
-isIndexBufferShadowed :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isIndexBufferShadowed -}
+isIndexBufferShadowed :: HG3DClass -> IO (Bool)
 isIndexBufferShadowed a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -275,41 +225,32 @@
   return (a2'')
 {-# LINE 136 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Builds an edge list for this mesh, which can be used for generating a shadow volume among other things. 
-buildEdgeList :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function buildEdgeList -}
+buildEdgeList :: HG3DClass -> IO ()
 buildEdgeList a1 =
   withHG3DClass a1 $ \a1' -> 
   buildEdgeList'_ a1' >>= \res ->
   return ()
 {-# LINE 140 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Destroys and frees the edge lists this mesh has built. 
-freeEdgeList :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function freeEdgeList -}
+freeEdgeList :: HG3DClass -> IO ()
 freeEdgeList a1 =
   withHG3DClass a1 $ \a1' -> 
   freeEdgeList'_ a1' >>= \res ->
   return ()
 {-# LINE 144 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | This method prepares the mesh for generating a renderable shadow volume. 
---Preparing a mesh to generate a shadow volume involves firstly ensuring that the vertex buffer containing the positions for the mesh is a standalone vertex buffer, with no other components in it. This method will therefore break apart any existing vertex buffers this mesh holds if position is sharing a vertex buffer. Secondly, it will double the size of this vertex buffer so that there are 2 copies of the position data for the mesh. The first half is used for the original, and the second half is used for the 'extruded' version of the mesh. The vertex count of the main VertexData used to render the mesh will remain the same though, so as not to add any overhead to regular rendering of the object. Both copies of the position are required in one buffer because shadow volumes stretch from the original mesh to the extruded version. Because shadow volumes are rendered in turn, no additional index buffer space is allocated by this method, a shared index buffer allocated by the shadow rendering algorithm is used for addressing this extended vertex buffer. 
-prepareForShadowVolume :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function prepareForShadowVolume -}
+prepareForShadowVolume :: HG3DClass -> IO ()
 prepareForShadowVolume a1 =
   withHG3DClass a1 $ \a1' -> 
   prepareForShadowVolume'_ a1' >>= \res ->
   return ()
 {-# LINE 148 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Returns whether this mesh has already had it's geometry prepared for use in rendering shadow volumes. 
-isPreparedForShadowVolumes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isPreparedForShadowVolumes -}
+isPreparedForShadowVolumes :: HG3DClass -> IO (Bool)
 isPreparedForShadowVolumes a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -318,10 +259,8 @@
   return (a2'')
 {-# LINE 153 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Returns whether this mesh has an attached edge list. 
-isEdgeListBuilt :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isEdgeListBuilt -}
+isEdgeListBuilt :: HG3DClass -> IO (Bool)
 isEdgeListBuilt a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -330,14 +269,8 @@
   return (a2'')
 {-# LINE 158 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Sets whether or not this Mesh should automatically build edge lists
---when asked for them, or whether it should never build them if
---they are not already provided.
---This allows you to create meshes which do not have edge lists calculated, because you never want to use them. This value defaults to 'true' for mesh formats which did not include edge data, and 'false' for newer formats, where edge lists are expected to have been generated in advance. 
-setAutoBuildEdgeLists :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ autobuild
-  ->  IO ()
- -- ^ 
+{- function setAutoBuildEdgeLists -}
+setAutoBuildEdgeLists :: HG3DClass -> Bool -> IO ()
 setAutoBuildEdgeLists a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -345,10 +278,8 @@
   return ()
 {-# LINE 163 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Sets whether or not this Mesh
-getAutoBuildEdgeLists :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getAutoBuildEdgeLists -}
+getAutoBuildEdgeLists :: HG3DClass -> IO (Bool)
 getAutoBuildEdgeLists a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -357,10 +288,8 @@
   return (a2'')
 {-# LINE 168 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Gets the type of vertex animation the shared vertex data of this mesh supports. 
-getSharedVertexDataAnimationType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumVertexAnimationType)
- -- ^ 
+{- function getSharedVertexDataAnimationType -}
+getSharedVertexDataAnimationType :: HG3DClass -> IO (EnumVertexAnimationType)
 getSharedVertexDataAnimationType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -369,10 +298,8 @@
   return (a2'')
 {-# LINE 173 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Returns whether animation on shared vertex data includes normals. 
-getSharedVertexDataAnimationIncludesNormals :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getSharedVertexDataAnimationIncludesNormals -}
+getSharedVertexDataAnimationIncludesNormals :: HG3DClass -> IO (Bool)
 getSharedVertexDataAnimationIncludesNormals a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -381,13 +308,8 @@
   return (a2'')
 {-# LINE 178 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Creates a new Animation object for vertex animating this mesh. 
---
-createAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of this animation 
-  ->  Float  -- ^ length - The length of the animation in seconds 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createAnimation -}
+createAnimation :: HG3DClass -> String -> Float -> IO (HG3DClass)
 createAnimation a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -398,12 +320,8 @@
   return (a4'')
 {-# LINE 185 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Returns the named vertex Animation object. 
---
-getAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the animation 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAnimation -}
+getAnimation :: HG3DClass -> String -> IO (HG3DClass)
 getAnimation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -413,11 +331,8 @@
   return (a3'')
 {-# LINE 191 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Returns whether this mesh contains the named vertex animation. 
-hasAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
+{- function hasAnimation -}
+hasAnimation :: HG3DClass -> String -> IO (Bool)
 hasAnimation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -427,11 +342,8 @@
   return (a3'')
 {-# LINE 197 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Removes vertex Animation
-removeAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function removeAnimation -}
+removeAnimation :: HG3DClass -> String -> IO ()
 removeAnimation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -439,10 +351,8 @@
   return ()
 {-# LINE 202 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Gets the number of morph animations in this mesh. 
-getNumAnimations :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumAnimations -}
+getNumAnimations :: HG3DClass -> IO (Int)
 getNumAnimations a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -451,11 +361,8 @@
   return (a2'')
 {-# LINE 207 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Gets a single morph animation by index. 
-getAnimation2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAnimation2 -}
+getAnimation2 :: HG3DClass -> Int -> IO (HG3DClass)
 getAnimation2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -465,32 +372,24 @@
   return (a3'')
 {-# LINE 213 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Removes all morph Animations from this mesh. 
-removeAllAnimations :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAllAnimations -}
+removeAllAnimations :: HG3DClass -> IO ()
 removeAllAnimations a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAllAnimations'_ a1' >>= \res ->
   return ()
 {-# LINE 217 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Iterates through all submeshes and requests them 
---to apply their texture aliases to the material they use.
---The submesh will only apply texture aliases to the material if matching texture alias names are found in the material. If a match is found, the submesh will automatically clone the original material and then apply its texture to the new material. This method is normally called by the protected method loadImpl when a mesh if first loaded. 
-updateMaterialForAllSubMeshes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function updateMaterialForAllSubMeshes -}
+updateMaterialForAllSubMeshes :: HG3DClass -> IO ()
 updateMaterialForAllSubMeshes a1 =
   withHG3DClass a1 $ \a1' -> 
   updateMaterialForAllSubMeshes'_ a1' >>= \res ->
   return ()
 {-# LINE 221 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Get the number of poses. 
-getPoseCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getPoseCount -}
+getPoseCount :: HG3DClass -> IO (Int)
 getPoseCount a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -499,12 +398,8 @@
   return (a2'')
 {-# LINE 226 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Destroy a pose by name.
---This will invalidate any animation tracks referring to this pose or those after it. 
-removePose2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function removePose2 -}
+removePose2 :: HG3DClass -> String -> IO ()
 removePose2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -512,10 +407,8 @@
   return ()
 {-# LINE 231 ".\\HGamer3D\\Bindings\\Ogre\\ClassMesh.chs" #-}
 
--- | Destroy all poses 
-removeAllPoses :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAllPoses -}
+removeAllPoses :: HG3DClass -> IO ()
 removeAllPoses a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAllPoses'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassMeshManager.hs b/HGamer3D/Bindings/Ogre/ClassMeshManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassMeshManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassMeshManager.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassMeshManager.chs" #-}
 
--- | 
+{- function MeshManager -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,21 +57,16 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassMeshManager.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~MeshManager -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassMeshManager.chs" #-}
 
--- | Tells the mesh manager that all future meshes should prepare themselves for shadow volumes on loading. 
-setPrepareAllMeshesForShadowVolumes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enable
-  ->  IO ()
- -- ^ 
+{- function setPrepareAllMeshesForShadowVolumes -}
+setPrepareAllMeshesForShadowVolumes :: HG3DClass -> Bool -> IO ()
 setPrepareAllMeshesForShadowVolumes a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -80,10 +74,8 @@
   return ()
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassMeshManager.chs" #-}
 
--- | Retrieves whether all Meshes should prepare themselves for shadow volumes. 
-getPrepareAllMeshesForShadowVolumes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getPrepareAllMeshesForShadowVolumes -}
+getPrepareAllMeshesForShadowVolumes :: HG3DClass -> IO (Bool)
 getPrepareAllMeshesForShadowVolumes a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -92,10 +84,8 @@
   return (a2'')
 {-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassMeshManager.chs" #-}
 
--- | Gets the factor by which the bounding box of an entity is padded. Default is 0.01 
-getBoundsPaddingFactor :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundsPaddingFactor -}
+getBoundsPaddingFactor :: HG3DClass -> IO (Float)
 getBoundsPaddingFactor a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -104,11 +94,8 @@
   return (a2'')
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassMeshManager.chs" #-}
 
--- | Sets the factor by which the bounding box of an entity is padded 
-setBoundsPaddingFactor :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ paddingFactor
-  ->  IO ()
- -- ^ 
+{- function setBoundsPaddingFactor -}
+setBoundsPaddingFactor :: HG3DClass -> Float -> IO ()
 setBoundsPaddingFactor a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -116,11 +103,8 @@
   return ()
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassMeshManager.chs" #-}
 
--- | ManualResourceLoader::loadResource
-loadResource :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ res
-  ->  IO ()
- -- ^ 
+{- function loadResource -}
+loadResource :: HG3DClass -> HG3DClass -> IO ()
 loadResource a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -128,10 +112,8 @@
   return ()
 {-# LINE 76 ".\\HGamer3D\\Bindings\\Ogre\\ClassMeshManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingleton -}
 getSingleton :: IO (HG3DClass)
- -- ^ 
 getSingleton =
   alloca $ \a1' -> 
   getSingleton'_ a1' >>= \res ->
@@ -139,10 +121,8 @@
   return (a1'')
 {-# LINE 80 ".\\HGamer3D\\Bindings\\Ogre\\ClassMeshManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingletonPtr -}
 getSingletonPtr :: IO (HG3DClass)
- -- ^ 
 getSingletonPtr =
   alloca $ \a1' -> 
   getSingletonPtr'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassMovableObject.hs b/HGamer3D/Bindings/Ogre/ClassMovableObject.hs
--- a/HGamer3D/Bindings/Ogre/ClassMovableObject.hs
+++ b/HGamer3D/Bindings/Ogre/ClassMovableObject.hs
@@ -48,20 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Virtual destructor - read Scott Meyers if you don't know why this is needed. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~MovableObject -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns the name of this object. 
-getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getName -}
+getName :: HG3DClass -> IO (String)
 getName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -70,10 +66,8 @@
   return (a2'')
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns the type name of this object. 
-getMovableType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMovableType -}
+getMovableType :: HG3DClass -> IO (String)
 getMovableType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -82,11 +76,8 @@
   return (a2'')
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns the node to which this object is attached.
---A MovableObjectSceneNodeNode
-getParentNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getParentNode -}
+getParentNode :: HG3DClass -> IO (HG3DClass)
 getParentNode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -95,11 +86,8 @@
   return (a2'')
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns the scene node to which this object is attached.
---A MovableObjectSceneNode
-getParentSceneNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getParentSceneNode -}
+getParentSceneNode :: HG3DClass -> IO (HG3DClass)
 getParentSceneNode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -108,10 +96,8 @@
   return (a2'')
 {-# LINE 67 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Gets whether the parent node is a TagPoint (or a SceneNode
-isParentTagPoint :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isParentTagPoint -}
+isParentTagPoint :: HG3DClass -> IO (Bool)
 isParentTagPoint a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -120,10 +106,8 @@
   return (a2'')
 {-# LINE 72 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns true if this object is attached to a SceneNode
-isAttached :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isAttached -}
+isAttached :: HG3DClass -> IO (Bool)
 isAttached a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -132,20 +116,16 @@
   return (a2'')
 {-# LINE 77 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Detaches an object from a parent SceneNode
-detachFromParent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function detachFromParent -}
+detachFromParent :: HG3DClass -> IO ()
 detachFromParent a1 =
   withHG3DClass a1 $ \a1' -> 
   detachFromParent'_ a1' >>= \res ->
   return ()
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns true if this object is attached to a SceneNodeSceneNode
-isInScene :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isInScene -}
+isInScene :: HG3DClass -> IO (Bool)
 isInScene a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -154,10 +134,8 @@
   return (a2'')
 {-# LINE 86 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Retrieves the radius of the origin-centered bounding sphere for this object. 
-getBoundingRadius :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBoundingRadius -}
+getBoundingRadius :: HG3DClass -> IO (Float)
 getBoundingRadius a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -166,12 +144,8 @@
   return (a2'')
 {-# LINE 91 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Tells this object whether to be visible or not, if it has a renderable component. 
---An alternative approach of making an object invisible is to detach it from it's SceneNodeSceneNode
-setVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ visible
-  ->  IO ()
- -- ^ 
+{- function setVisible -}
+setVisible :: HG3DClass -> Bool -> IO ()
 setVisible a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -179,11 +153,8 @@
   return ()
 {-# LINE 96 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Gets this object whether to be visible or not, if it has a renderable component. 
---Returns the value set by MovableObject::setVisible
-getVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getVisible -}
+getVisible :: HG3DClass -> IO (Bool)
 getVisible a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -192,11 +163,8 @@
   return (a2'')
 {-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns whether or not this object is supposed to be visible or not. 
---Takes into account both upper rendering distance and visible flag. 
-isVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isVisible -}
+isVisible :: HG3DClass -> IO (Bool)
 isVisible a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -205,12 +173,8 @@
   return (a2'')
 {-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Sets the distance at which the object is no longer rendered.
---Camera::setUseRenderingDistance()
-setRenderingDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ dist - Distance beyond which the object will not be rendered (the default is 0, which means objects are always rendered). 
-  ->  IO ()
- -- ^ 
+{- function setRenderingDistance -}
+setRenderingDistance :: HG3DClass -> Float -> IO ()
 setRenderingDistance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -218,10 +182,8 @@
   return ()
 {-# LINE 111 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Gets the distance at which batches are no longer rendered. 
-getRenderingDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getRenderingDistance -}
+getRenderingDistance :: HG3DClass -> IO (Float)
 getRenderingDistance a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -230,12 +192,8 @@
   return (a2'')
 {-# LINE 116 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Sets the minimum pixel size an object needs to be in both screen axes in order to be rendered
---Camera::setUseMinPixelSize()
-setRenderingMinPixelSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ pixelSize - Number of minimum pixels (the default is 0, which means objects are always rendered). 
-  ->  IO ()
- -- ^ 
+{- function setRenderingMinPixelSize -}
+setRenderingMinPixelSize :: HG3DClass -> Float -> IO ()
 setRenderingMinPixelSize a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -243,10 +201,8 @@
   return ()
 {-# LINE 121 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns the minimum pixel size an object needs to be in both screen axes in order to be rendered 
-getRenderingMinPixelSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getRenderingMinPixelSize -}
+getRenderingMinPixelSize :: HG3DClass -> IO (Float)
 getRenderingMinPixelSize a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -255,12 +211,8 @@
   return (a2'')
 {-# LINE 126 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Sets the query flags for this object.
---When performing a scene query, this object will be included or excluded according to flags on the object and flags on the query. This is a bitwise value, so only when a bit on these flags is set, will it be included in a query asking for that flag. The meaning of the bits is application-specific. 
-setQueryFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ flags
-  ->  IO ()
- -- ^ 
+{- function setQueryFlags -}
+setQueryFlags :: HG3DClass -> Int -> IO ()
 setQueryFlags a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -268,12 +220,8 @@
   return ()
 {-# LINE 131 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | As setQueryFlags, except the flags passed as parameters are appended to the
---
-addQueryFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ flags
-  ->  IO ()
- -- ^ 
+{- function addQueryFlags -}
+addQueryFlags :: HG3DClass -> Int -> IO ()
 addQueryFlags a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -281,12 +229,8 @@
   return ()
 {-# LINE 136 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | As setQueryFlags, except the flags passed as parameters are removed from the
---
-removeQueryFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ flags
-  ->  IO ()
- -- ^ 
+{- function removeQueryFlags -}
+removeQueryFlags :: HG3DClass -> Int -> IO ()
 removeQueryFlags a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -294,10 +238,8 @@
   return ()
 {-# LINE 141 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns the query flags relevant for this object. 
-getQueryFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getQueryFlags -}
+getQueryFlags :: HG3DClass -> IO (Int)
 getQueryFlags a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -306,12 +248,8 @@
   return (a2'')
 {-# LINE 146 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Sets the visiblity flags for this object.
---As well as a simple true/false value for visibility (as seen in setVisible), you can also set visiblity flags which when 'and'ed with the SceneManager
-setVisibilityFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ flags
-  ->  IO ()
- -- ^ 
+{- function setVisibilityFlags -}
+setVisibilityFlags :: HG3DClass -> Int -> IO ()
 setVisibilityFlags a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -319,12 +257,8 @@
   return ()
 {-# LINE 151 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | As setVisibilityFlags, except the flags passed as parameters are appended to the
---
-addVisibilityFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ flags
-  ->  IO ()
- -- ^ 
+{- function addVisibilityFlags -}
+addVisibilityFlags :: HG3DClass -> Int -> IO ()
 addVisibilityFlags a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -332,12 +266,8 @@
   return ()
 {-# LINE 156 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | As setVisibilityFlags, except the flags passed as parameters are removed from the
---
-removeVisibilityFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ flags
-  ->  IO ()
- -- ^ 
+{- function removeVisibilityFlags -}
+removeVisibilityFlags :: HG3DClass -> Int -> IO ()
 removeVisibilityFlags a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -345,10 +275,8 @@
   return ()
 {-# LINE 161 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns the visibility flags relevant for this object. 
-getVisibilityFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getVisibilityFlags -}
+getVisibilityFlags :: HG3DClass -> IO (Int)
 getVisibilityFlags a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -357,11 +285,8 @@
   return (a2'')
 {-# LINE 166 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Get a bitwise mask which will filter the lights affecting this object
---By default, this mask is fully set meaning all lights will affect this object 
-getLightMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getLightMask -}
+getLightMask :: HG3DClass -> IO (Int)
 getLightMask a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -370,12 +295,8 @@
   return (a2'')
 {-# LINE 171 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Set a bitwise mask which will filter the lights affecting this object
---This mask will be compared against the mask held against Light
-setLightMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ lightMask
-  ->  IO ()
- -- ^ 
+{- function setLightMask -}
+setLightMask :: HG3DClass -> Int -> IO ()
 setLightMask a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -383,10 +304,8 @@
   return ()
 {-# LINE 176 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Define a default implementation of method from ShadowCaster which implements no shadows. 
-hasEdgeList :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasEdgeList -}
+hasEdgeList :: HG3DClass -> IO (Bool)
 hasEdgeList a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -395,12 +314,8 @@
   return (a2'')
 {-# LINE 181 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Sets whether or not this object will cast shadows.
---This setting simply allows you to turn on/off shadows for a given object. An object will not cast shadows unless the scene supports it in any case (see SceneManager::setShadowTechniqueThis method normally refers to objects which block the light, but since LightMovableObject
-setCastShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setCastShadows -}
+setCastShadows :: HG3DClass -> Bool -> IO ()
 setCastShadows a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -408,10 +323,8 @@
   return ()
 {-# LINE 186 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns whether shadow casting is enabled for this object. 
-getCastShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getCastShadows -}
+getCastShadows :: HG3DClass -> IO (Bool)
 getCastShadows a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -420,10 +333,8 @@
   return (a2'')
 {-# LINE 191 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Returns whether the MaterialRenderableMovableObject
-getReceivesShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getReceivesShadows -}
+getReceivesShadows :: HG3DClass -> IO (Bool)
 getReceivesShadows a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -432,11 +343,8 @@
   return (a2'')
 {-# LINE 196 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Get the distance to extrude for a point/spot light 
-getPointExtrusionDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ l
-  ->  IO (Float)
- -- ^ 
+{- function getPointExtrusionDistance -}
+getPointExtrusionDistance :: HG3DClass -> HG3DClass -> IO (Float)
 getPointExtrusionDistance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -446,11 +354,8 @@
   return (a3'')
 {-# LINE 202 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Get the 'type flags' for this MovableObject.
---A type flag identifies the type of the MovableObjectMovableObjectFactoryMovableObjectFactoryMovableObjectFactory
-getTypeFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getTypeFlags -}
+getTypeFlags :: HG3DClass -> IO (Int)
 getTypeFlags a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -459,12 +364,8 @@
   return (a2'')
 {-# LINE 207 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Sets whether or not the debug display of this object is enabled.
---Some objects aren't visible themselves but it can be useful to display a debug representation of them. Or, objects may have an additional debug display on top of their regular display. This option enables / disables that debug display. Objects that are not visible never display debug geometry regardless of this setting. 
-setDebugDisplayEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setDebugDisplayEnabled -}
+setDebugDisplayEnabled :: HG3DClass -> Bool -> IO ()
 setDebugDisplayEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -472,10 +373,8 @@
   return ()
 {-# LINE 212 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Gets whether debug display of this object is enabled. 
-isDebugDisplayEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isDebugDisplayEnabled -}
+isDebugDisplayEnabled :: HG3DClass -> IO (Bool)
 isDebugDisplayEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -484,19 +383,16 @@
   return (a2'')
 {-# LINE 217 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Set the default query flags for all future MovableObject
-setDefaultQueryFlags :: Int  -- ^ flags
-  ->  IO ()
- -- ^ 
+{- function setDefaultQueryFlags -}
+setDefaultQueryFlags :: Int -> IO ()
 setDefaultQueryFlags a1 =
   let {a1' = fromIntegral a1} in 
   setDefaultQueryFlags'_ a1' >>= \res ->
   return ()
 {-# LINE 221 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Get the default query flags for all future MovableObject
+{- function getDefaultQueryFlags -}
 getDefaultQueryFlags :: IO (Int)
- -- ^ 
 getDefaultQueryFlags =
   alloca $ \a1' -> 
   getDefaultQueryFlags'_ a1' >>= \res ->
@@ -504,19 +400,16 @@
   return (a1'')
 {-# LINE 225 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Set the default visibility flags for all future MovableObject
-setDefaultVisibilityFlags :: Int  -- ^ flags
-  ->  IO ()
- -- ^ 
+{- function setDefaultVisibilityFlags -}
+setDefaultVisibilityFlags :: Int -> IO ()
 setDefaultVisibilityFlags a1 =
   let {a1' = fromIntegral a1} in 
   setDefaultVisibilityFlags'_ a1' >>= \res ->
   return ()
 {-# LINE 229 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObject.chs" #-}
 
--- | Get the default visibility flags for all future MovableObject
+{- function getDefaultVisibilityFlags -}
 getDefaultVisibilityFlags :: IO (Int)
- -- ^ 
 getDefaultVisibilityFlags =
   alloca $ \a1' -> 
   getDefaultVisibilityFlags'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassMovableObjectFactory.hs b/HGamer3D/Bindings/Ogre/ClassMovableObjectFactory.hs
--- a/HGamer3D/Bindings/Ogre/ClassMovableObjectFactory.hs
+++ b/HGamer3D/Bindings/Ogre/ClassMovableObjectFactory.hs
@@ -48,20 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObjectFactory.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~MovableObjectFactory -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObjectFactory.chs" #-}
 
--- | Get the type of the object to be created. 
-getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getType -}
+getType :: HG3DClass -> IO (String)
 getType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -70,11 +66,8 @@
   return (a2'')
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObjectFactory.chs" #-}
 
--- | Destroy an instance of the object 
-destroyInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
+{- function destroyInstance -}
+destroyInstance :: HG3DClass -> HG3DClass -> IO ()
 destroyInstance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -82,12 +75,8 @@
   return ()
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObjectFactory.chs" #-}
 
--- | Does this factory require the allocation of a 'type flag', used to 
---selectively include / exclude this type from scene queries?
---The default implementation here is to return 'false', ie not to request a unique type mask from RootMovableObject::getTypeFlagsMovableObjectRoot
-requestTypeFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function requestTypeFlags -}
+requestTypeFlags :: HG3DClass -> IO (Bool)
 requestTypeFlags a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -96,11 +85,8 @@
   return (a2'')
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassMovableObjectFactory.chs" #-}
 
--- | Gets the type flag for this factory.
---A type flag is like a query flag, except that it applies to all instances of a certain type of object. 
-getTypeFlags :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getTypeFlags -}
+getTypeFlags :: HG3DClass -> IO (Int)
 getTypeFlags a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassMultiRenderTarget.hs b/HGamer3D/Bindings/Ogre/ClassMultiRenderTarget.hs
--- a/HGamer3D/Bindings/Ogre/ClassMultiRenderTarget.hs
+++ b/HGamer3D/Bindings/Ogre/ClassMultiRenderTarget.hs
@@ -48,13 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassMultiRenderTarget.chs" #-}
 
--- | Bind a surface to a certain attachment point. 
---
-bindSurface :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ attachment - 0 .. mCapabilities->getNumMultiRenderTargets()-1 
-  ->  HG3DClass  -- ^ target - RenderTexture to bind.
-  ->  IO ()
- -- ^ 
+{- function bindSurface -}
+bindSurface :: HG3DClass -> Int -> HG3DClass -> IO ()
 bindSurface a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -63,11 +58,8 @@
   return ()
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassMultiRenderTarget.chs" #-}
 
--- | Unbind attachment. 
-unbindSurface :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ attachment
-  ->  IO ()
- -- ^ 
+{- function unbindSurface -}
+unbindSurface :: HG3DClass -> Int -> IO ()
 unbindSurface a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -75,11 +67,8 @@
   return ()
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassMultiRenderTarget.chs" #-}
 
--- | Get a pointer to a bound surface 
-getBoundSurface :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getBoundSurface -}
+getBoundSurface :: HG3DClass -> Int -> IO (HG3DClass)
 getBoundSurface a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
diff --git a/HGamer3D/Bindings/Ogre/ClassNode.hs b/HGamer3D/Bindings/Ogre/ClassNode.hs
--- a/HGamer3D/Bindings/Ogre/ClassNode.hs
+++ b/HGamer3D/Bindings/Ogre/ClassNode.hs
@@ -56,20 +56,16 @@
 import HGamer3D.Bindings.Ogre.StructRadians
 {-# LINE 46 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Node -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Returns the name of the node. 
-getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getName -}
+getName :: HG3DClass -> IO (String)
 getName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -78,10 +74,8 @@
   return (a2'')
 {-# LINE 56 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets this node's parent (NULL if this is the root). 
-getParent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getParent -}
+getParent :: HG3DClass -> IO (HG3DClass)
 getParent a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -90,10 +84,8 @@
   return (a2'')
 {-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Returns a quaternion representing the nodes orientation. 
-getOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Quaternion)
- -- ^ 
+{- function getOrientation -}
+getOrientation :: HG3DClass -> IO (Quaternion)
 getOrientation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -102,12 +94,8 @@
   return (a2'')
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Sets the orientation of this node via a quaternion.
---Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. Note that rotations are oriented around the node's origin. 
-setOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Quaternion  -- ^ q
-  ->  IO ()
- -- ^ 
+{- function setOrientation -}
+setOrientation :: HG3DClass -> Quaternion -> IO ()
 setOrientation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withQuaternion a2 $ \a2' -> 
@@ -115,15 +103,8 @@
   return ()
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Sets the orientation of this node via quaternion parameters.
---Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. Note that rotations are oriented around the node's origin. 
-setOrientation2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ w
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function setOrientation2 -}
+setOrientation2 :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 setOrientation2 a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -134,22 +115,16 @@
   return ()
 {-# LINE 79 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Resets the nodes orientation (local axes as world axes, no rotation).
---Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. Note that rotations are oriented around the node's origin. 
-resetOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function resetOrientation -}
+resetOrientation :: HG3DClass -> IO ()
 resetOrientation a1 =
   withHG3DClass a1 $ \a1' -> 
   resetOrientation'_ a1' >>= \res ->
   return ()
 {-# LINE 83 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Sets the position of the node relative to it's parent. 
-setPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ pos
-  ->  IO ()
- -- ^ 
+{- function setPosition -}
+setPosition :: HG3DClass -> Vec3 -> IO ()
 setPosition a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -157,13 +132,8 @@
   return ()
 {-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Sets the position of the node relative to it's parent. 
-setPosition2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function setPosition2 -}
+setPosition2 :: HG3DClass -> Float -> Float -> Float -> IO ()
 setPosition2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -173,10 +143,8 @@
   return ()
 {-# LINE 95 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets the position of the node relative to it's parent. 
-getPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getPosition -}
+getPosition :: HG3DClass -> IO (Vec3)
 getPosition a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -185,12 +153,8 @@
   return (a2'')
 {-# LINE 100 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Sets the scaling factor applied to this node.
---Scaling factors, unlike other transforms, are not always inherited by child nodes. Whether or not scalings affect the size of the child nodes depends on the setInheritScale option of the child. In some cases you want a scaling factor of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative size based on the parent's size), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own size). The default is to inherit as with other transforms. Note that like rotations, scalings are oriented around the node's origin. 
-setScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ scale
-  ->  IO ()
- -- ^ 
+{- function setScale -}
+setScale :: HG3DClass -> Vec3 -> IO ()
 setScale a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -198,14 +162,8 @@
   return ()
 {-# LINE 105 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Sets the scaling factor applied to this node.
---Scaling factors, unlike other transforms, are not always inherited by child nodes. Whether or not scalings affect the size of the child nodes depends on the setInheritScale option of the child. In some cases you want a scaling factor of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative size based on the parent's size), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own size). The default is to inherit as with other transforms. Note that like rotations, scalings are oriented around the node's origin. 
-setScale2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function setScale2 -}
+setScale2 :: HG3DClass -> Float -> Float -> Float -> IO ()
 setScale2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -215,10 +173,8 @@
   return ()
 {-# LINE 112 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets the scaling factor of this node. 
-getScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getScale -}
+getScale :: HG3DClass -> IO (Vec3)
 getScale a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -227,12 +183,8 @@
   return (a2'')
 {-# LINE 117 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Tells the node whether it should inherit orientation from it's parent node.
---Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. 
-setInheritOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ inherit - If true, this node's orientation will be affected by its parent's orientation. If false, it will not be affected. 
-  ->  IO ()
- -- ^ 
+{- function setInheritOrientation -}
+setInheritOrientation :: HG3DClass -> Bool -> IO ()
 setInheritOrientation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -240,12 +192,8 @@
   return ()
 {-# LINE 122 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Returns true if this node is affected by orientation applied to the parent node. 
---Orientations, unlike other transforms, are not always inherited by child nodes. Whether or not orientations affect the orientation of the child nodes depends on the setInheritOrientation option of the child. In some cases you want a orientating of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative orientation based on the parent's orientation), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own orientation). The default is to inherit as with other transforms. 
---See setInheritOrientation for more info. 
-getInheritOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getInheritOrientation -}
+getInheritOrientation :: HG3DClass -> IO (Bool)
 getInheritOrientation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -254,12 +202,8 @@
   return (a2'')
 {-# LINE 127 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Tells the node whether it should inherit scaling factors from it's parent node.
---Scaling factors, unlike other transforms, are not always inherited by child nodes. Whether or not scalings affect the size of the child nodes depends on the setInheritScale option of the child. In some cases you want a scaling factor of a parent node to apply to a child node (e.g. where the child node is a part of the same object, so you want it to be the same relative size based on the parent's size), but not in other cases (e.g. where the child node is just for positioning another object, you want it to maintain it's own size). The default is to inherit as with other transforms. 
-setInheritScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ inherit - If true, this node's scale will be affected by its parent's scale. If false, it will not be affected. 
-  ->  IO ()
- -- ^ 
+{- function setInheritScale -}
+setInheritScale :: HG3DClass -> Bool -> IO ()
 setInheritScale a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -267,11 +211,8 @@
   return ()
 {-# LINE 132 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Returns true if this node is affected by scaling factors applied to the parent node. 
---See setInheritScale for more info. 
-getInheritScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getInheritScale -}
+getInheritScale :: HG3DClass -> IO (Bool)
 getInheritScale a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -280,12 +221,8 @@
   return (a2'')
 {-# LINE 137 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Scales the node, combining it's current scale with the passed in scaling factor. 
---This method applies an extra scaling factor to the node's existing scale, (unlike setScale which overwrites it) combining it's current scale with the new one. E.g. calling this method twice with Vector3(2,2,2) would have the same effect as setScale(Vector3(4,4,4)) if the existing scale was 1. Note that like rotations, scalings are oriented around the node's origin. 
-scale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ scale
-  ->  IO ()
- -- ^ 
+{- function scale -}
+scale :: HG3DClass -> Vec3 -> IO ()
 scale a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -293,14 +230,8 @@
   return ()
 {-# LINE 142 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Scales the node, combining it's current scale with the passed in scaling factor. 
---This method applies an extra scaling factor to the node's existing scale, (unlike setScale which overwrites it) combining it's current scale with the new one. E.g. calling this method twice with Vector3(2,2,2) would have the same effect as setScale(Vector3(4,4,4)) if the existing scale was 1. Note that like rotations, scalings are oriented around the node's origin. 
-scale2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z
-  ->  IO ()
- -- ^ 
+{- function scale2 -}
+scale2 :: HG3DClass -> Float -> Float -> Float -> IO ()
 scale2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -310,12 +241,8 @@
   return ()
 {-# LINE 149 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Moves the node along the Cartesian axes. This method moves the node by the supplied vector along the world Cartesian axes, i.e. along world x,y,z 
-translate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ d - Vector with x,y,z values representing the translation. 
-  ->  EnumNodeTransformSpace  -- ^ relativeTo - The space which this transform is relative to. 
-  ->  IO ()
- -- ^ 
+{- function translate -}
+translate :: HG3DClass -> Vec3 -> EnumNodeTransformSpace -> IO ()
 translate a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -324,14 +251,8 @@
   return ()
 {-# LINE 155 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Moves the node along the Cartesian axes. This method moves the node by the supplied vector along the world Cartesian axes, i.e. along world x,y,z 
-translate2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ x
-  ->  Float  -- ^ y
-  ->  Float  -- ^ z - Real x, y and z values representing the translation. 
-  ->  EnumNodeTransformSpace  -- ^ relativeTo - The space which this transform is relative to. 
-  ->  IO ()
- -- ^ 
+{- function translate2 -}
+translate2 :: HG3DClass -> Float -> Float -> Float -> EnumNodeTransformSpace -> IO ()
 translate2 a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -342,12 +263,8 @@
   return ()
 {-# LINE 163 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Rotate the node around the Z-axis. 
-roll :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ angle
-  ->  EnumNodeTransformSpace  -- ^ relativeTo
-  ->  IO ()
- -- ^ 
+{- function roll -}
+roll :: HG3DClass -> Radians -> EnumNodeTransformSpace -> IO ()
 roll a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -356,12 +273,8 @@
   return ()
 {-# LINE 169 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Rotate the node around the X-axis. 
-pitch :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ angle
-  ->  EnumNodeTransformSpace  -- ^ relativeTo
-  ->  IO ()
- -- ^ 
+{- function pitch -}
+pitch :: HG3DClass -> Radians -> EnumNodeTransformSpace -> IO ()
 pitch a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -370,12 +283,8 @@
   return ()
 {-# LINE 175 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Rotate the node around the Y-axis. 
-yaw :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Radians  -- ^ angle
-  ->  EnumNodeTransformSpace  -- ^ relativeTo
-  ->  IO ()
- -- ^ 
+{- function yaw -}
+yaw :: HG3DClass -> Radians -> EnumNodeTransformSpace -> IO ()
 yaw a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withRadians a2 $ \a2' -> 
@@ -384,13 +293,8 @@
   return ()
 {-# LINE 181 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Rotate the node around an arbitrary axis. 
-rotate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ axis
-  ->  Radians  -- ^ angle
-  ->  EnumNodeTransformSpace  -- ^ relativeTo
-  ->  IO ()
- -- ^ 
+{- function rotate -}
+rotate :: HG3DClass -> Vec3 -> Radians -> EnumNodeTransformSpace -> IO ()
 rotate a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -400,12 +304,8 @@
   return ()
 {-# LINE 188 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Rotate the node around an aritrary axis using a Quarternion. 
-rotate2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Quaternion  -- ^ q
-  ->  EnumNodeTransformSpace  -- ^ relativeTo
-  ->  IO ()
- -- ^ 
+{- function rotate2 -}
+rotate2 :: HG3DClass -> Quaternion -> EnumNodeTransformSpace -> IO ()
 rotate2 a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withQuaternion a2 $ \a2' -> 
@@ -414,13 +314,8 @@
   return ()
 {-# LINE 194 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Creates an unnamed new Node as a child of this node.
---
-createChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ translate - Initial translation offset of child relative to parent 
-  ->  Quaternion  -- ^ rotate - Initial rotation relative to parent 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createChild -}
+createChild :: HG3DClass -> Vec3 -> Quaternion -> IO (HG3DClass)
 createChild a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -431,14 +326,8 @@
   return (a4'')
 {-# LINE 201 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Creates a new named Node as a child of this node.
---This creates a child node with a given name, which allows you to look the node up from the parent which holds this collection of nodes. 
-createChild2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  Vec3  -- ^ translate - Initial translation offset of child relative to parent 
-  ->  Quaternion  -- ^ rotate - Initial rotation relative to parent 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createChild2 -}
+createChild2 :: HG3DClass -> String -> Vec3 -> Quaternion -> IO (HG3DClass)
 createChild2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -450,13 +339,8 @@
   return (a5'')
 {-# LINE 209 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Adds a (precreated) child scene node to this node. If it is attached to another node,
---it must be detached first.
---
-addChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ child - The Node which is to become a child node of this one 
-  ->  IO ()
- -- ^ 
+{- function addChild -}
+addChild :: HG3DClass -> HG3DClass -> IO ()
 addChild a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -464,10 +348,8 @@
   return ()
 {-# LINE 214 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Reports the number of child nodes under this one. 
-numChildren :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function numChildren -}
+numChildren :: HG3DClass -> IO (Int)
 numChildren a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -476,12 +358,8 @@
   return (a2'')
 {-# LINE 219 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets a pointer to a child node.
---There is an alternate getChild method which returns a named child. 
-getChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getChild -}
+getChild :: HG3DClass -> Int -> IO (HG3DClass)
 getChild a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -491,11 +369,8 @@
   return (a3'')
 {-# LINE 225 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets a pointer to a named child node. 
-getChild2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getChild2 -}
+getChild2 :: HG3DClass -> String -> IO (HG3DClass)
 getChild2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -505,12 +380,8 @@
   return (a3'')
 {-# LINE 231 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Drops the specified child from this node. 
---Does not delete the node, just detaches it from this parent, potentially to be reattached elsewhere. There is also an alternate version which drops a named child from this node. 
-removeChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function removeChild -}
+removeChild :: HG3DClass -> Int -> IO (HG3DClass)
 removeChild a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -520,12 +391,8 @@
   return (a3'')
 {-# LINE 237 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Drops the specified child from this node. 
---Does not delete the node, just detaches it from this parent, potentially to be reattached elsewhere. There is also an alternate version which drops a named child from this node. 
-removeChild2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ child
-  ->  IO (HG3DClass)
- -- ^ 
+{- function removeChild2 -}
+removeChild2 :: HG3DClass -> HG3DClass -> IO (HG3DClass)
 removeChild2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -535,12 +402,8 @@
   return (a3'')
 {-# LINE 243 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Drops the named child from this node. 
---Does not delete the node, just detaches it from this parent, potentially to be reattached elsewhere. 
-removeChild3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function removeChild3 -}
+removeChild3 :: HG3DClass -> String -> IO (HG3DClass)
 removeChild3 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -550,44 +413,32 @@
   return (a3'')
 {-# LINE 249 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Removes all child Nodes attached to this node. Does not delete the nodes, just detaches them from this parent, potentially to be reattached elsewhere. 
-removeAllChildren :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAllChildren -}
+removeAllChildren :: HG3DClass -> IO ()
 removeAllChildren a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAllChildren'_ a1' >>= \res ->
   return ()
 {-# LINE 253 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Sets the current transform of this node to be the 'initial state' ie that
---position / orientation / scale to be used as a basis for delta values used
---in keyframe animation.
---You never need to call this method unless you plan to animate this node. If you do plan to animate it, call this method once you've loaded the node with it's base state, ie the state on which all keyframes are based. If you never call this method, the initial state is the identity transform, ie do nothing. 
-setInitialState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function setInitialState -}
+setInitialState :: HG3DClass -> IO ()
 setInitialState a1 =
   withHG3DClass a1 $ \a1' -> 
   setInitialState'_ a1' >>= \res ->
   return ()
 {-# LINE 257 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Resets the position / orientation / scale of this node to it's initial state, see setInitialState for more info. 
-resetToInitialState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function resetToInitialState -}
+resetToInitialState :: HG3DClass -> IO ()
 resetToInitialState a1 =
   withHG3DClass a1 $ \a1' -> 
   resetToInitialState'_ a1' >>= \res ->
   return ()
 {-# LINE 261 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets the initial position of this node, see setInitialState for more info. 
---Also resets the cumulative animation weight used for blending. 
-getInitialPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getInitialPosition -}
+getInitialPosition :: HG3DClass -> IO (Vec3)
 getInitialPosition a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -596,11 +447,8 @@
   return (a2'')
 {-# LINE 266 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets the local position, relative to this node, of the given world-space position 
-convertWorldToLocalPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ worldPos
-  ->  IO (Vec3)
- -- ^ 
+{- function convertWorldToLocalPosition -}
+convertWorldToLocalPosition :: HG3DClass -> Vec3 -> IO (Vec3)
 convertWorldToLocalPosition a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -610,11 +458,8 @@
   return (a3'')
 {-# LINE 272 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets the world position of a point in the node local space useful for simple transforms that don't require a child node. 
-convertLocalToWorldPosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ localPos
-  ->  IO (Vec3)
- -- ^ 
+{- function convertLocalToWorldPosition -}
+convertLocalToWorldPosition :: HG3DClass -> Vec3 -> IO (Vec3)
 convertLocalToWorldPosition a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -624,11 +469,8 @@
   return (a3'')
 {-# LINE 278 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets the local orientation, relative to this node, of the given world-space orientation 
-convertWorldToLocalOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Quaternion  -- ^ worldOrientation
-  ->  IO (Quaternion)
- -- ^ 
+{- function convertWorldToLocalOrientation -}
+convertWorldToLocalOrientation :: HG3DClass -> Quaternion -> IO (Quaternion)
 convertWorldToLocalOrientation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withQuaternion a2 $ \a2' -> 
@@ -638,11 +480,8 @@
   return (a3'')
 {-# LINE 284 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets the world orientation of an orientation in the node local space useful for simple transforms that don't require a child node. 
-convertLocalToWorldOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Quaternion  -- ^ localOrientation
-  ->  IO (Quaternion)
- -- ^ 
+{- function convertLocalToWorldOrientation -}
+convertLocalToWorldOrientation :: HG3DClass -> Quaternion -> IO (Quaternion)
 convertLocalToWorldOrientation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withQuaternion a2 $ \a2' -> 
@@ -652,10 +491,8 @@
   return (a3'')
 {-# LINE 290 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets the initial orientation of this node, see setInitialState for more info. 
-getInitialOrientation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Quaternion)
- -- ^ 
+{- function getInitialOrientation -}
+getInitialOrientation :: HG3DClass -> IO (Quaternion)
 getInitialOrientation a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -664,10 +501,8 @@
   return (a2'')
 {-# LINE 295 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Gets the initial position of this node, see setInitialState for more info. 
-getInitialScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getInitialScale -}
+getInitialScale :: HG3DClass -> IO (Vec3)
 getInitialScale a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -676,11 +511,8 @@
   return (a2'')
 {-# LINE 300 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Helper function, get the squared view depth. 
-getSquaredViewDepth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ cam
-  ->  IO (Float)
- -- ^ 
+{- function getSquaredViewDepth -}
+getSquaredViewDepth :: HG3DClass -> HG3DClass -> IO (Float)
 getSquaredViewDepth a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -690,12 +522,8 @@
   return (a3'')
 {-# LINE 306 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | To be called in the event of transform changes to this node that require it's recalculation.
---This not only tags the node state as being 'dirty', it also requests it's parent to know about it's dirtiness so it will get an update next time. 
-needUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ forceParentUpdate - Even if the node thinks it has already told it's parent, tell it anyway 
-  ->  IO ()
- -- ^ 
+{- function needUpdate -}
+needUpdate :: HG3DClass -> Bool -> IO ()
 needUpdate a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -703,13 +531,8 @@
   return ()
 {-# LINE 311 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Called by children to notify their parent that they need an update. 
---
-requestUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ child
-  ->  Bool  -- ^ forceParentUpdate - Even if the node thinks it has already told it's parent, tell it anyway 
-  ->  IO ()
- -- ^ 
+{- function requestUpdate -}
+requestUpdate :: HG3DClass -> HG3DClass -> Bool -> IO ()
 requestUpdate a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -718,11 +541,8 @@
   return ()
 {-# LINE 317 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Called by children to notify their parent that they no longer need an update. 
-cancelUpdate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ child
-  ->  IO ()
- -- ^ 
+{- function cancelUpdate -}
+cancelUpdate :: HG3DClass -> HG3DClass -> IO ()
 cancelUpdate a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -730,20 +550,16 @@
   return ()
 {-# LINE 322 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Queue a 'needUpdate' call to a node safely.
---You can't call needUpdate()Node::Listener
-queueNeedUpdate :: HG3DClass  -- ^ n
-  ->  IO ()
- -- ^ 
+{- function queueNeedUpdate -}
+queueNeedUpdate :: HG3DClass -> IO ()
 queueNeedUpdate a1 =
   withHG3DClass a1 $ \a1' -> 
   queueNeedUpdate'_ a1' >>= \res ->
   return ()
 {-# LINE 326 ".\\HGamer3D\\Bindings\\Ogre\\ClassNode.chs" #-}
 
--- | Process queued 'needUpdate' calls. 
+{- function processQueuedUpdates -}
 processQueuedUpdates :: IO ()
- -- ^ 
 processQueuedUpdates =
   processQueuedUpdates'_ >>= \res ->
   return ()
diff --git a/HGamer3D/Bindings/Ogre/ClassNodeAnimationTrack.hs b/HGamer3D/Bindings/Ogre/ClassNodeAnimationTrack.hs
--- a/HGamer3D/Bindings/Ogre/ClassNodeAnimationTrack.hs
+++ b/HGamer3D/Bindings/Ogre/ClassNodeAnimationTrack.hs
@@ -48,11 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | Constructor. 
-new :: HG3DClass  -- ^ parent
-  ->  Int  -- ^ handle
-  ->  IO (HG3DClass)
- -- ^ 
+{- function NodeAnimationTrack -}
+new :: HG3DClass -> Int -> IO (HG3DClass)
 new a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -62,20 +59,16 @@
   return (a3'')
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | Destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~NodeAnimationTrack -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | Returns a pointer to the associated Node
-getAssociatedNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAssociatedNode -}
+getAssociatedNode :: HG3DClass -> IO (HG3DClass)
 getAssociatedNode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -84,11 +77,8 @@
   return (a2'')
 {-# LINE 58 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | Sets the associated Node
-setAssociatedNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ node
-  ->  IO ()
- -- ^ 
+{- function setAssociatedNode -}
+setAssociatedNode :: HG3DClass -> HG3DClass -> IO ()
 setAssociatedNode a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -96,14 +86,8 @@
   return ()
 {-# LINE 63 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | As the 'apply' method but applies to a specified Node
-applyToNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ node
-  ->  HG3DClass  -- ^ timeIndex
-  ->  Float  -- ^ weight
-  ->  Float  -- ^ scale
-  ->  IO ()
- -- ^ 
+{- function applyToNode -}
+applyToNode :: HG3DClass -> HG3DClass -> HG3DClass -> Float -> Float -> IO ()
 applyToNode a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -114,11 +98,8 @@
   return ()
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | Sets the method of rotation calculation 
-setUseShortestRotationPath :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ useShortestPath
-  ->  IO ()
- -- ^ 
+{- function setUseShortestRotationPath -}
+setUseShortestRotationPath :: HG3DClass -> Bool -> IO ()
 setUseShortestRotationPath a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -126,10 +107,8 @@
   return ()
 {-# LINE 76 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | Gets the method of rotation calculation 
-getUseShortestRotationPath :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseShortestRotationPath -}
+getUseShortestRotationPath :: HG3DClass -> IO (Bool)
 getUseShortestRotationPath a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -138,14 +117,8 @@
   return (a2'')
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | Applies an animation track to the designated target.
---
-apply :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ timeIndex
-  ->  Float  -- ^ weight
-  ->  Float  -- ^ scale
-  ->  IO ()
- -- ^ 
+{- function apply -}
+apply :: HG3DClass -> HG3DClass -> Float -> Float -> IO ()
 apply a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -155,10 +128,8 @@
   return ()
 {-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | Method to determine if this track has any KeyFrames which are doing anything useful - can be used to determine if this track can be optimised out. 
-hasNonZeroKeyFrames :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasNonZeroKeyFrames -}
+hasNonZeroKeyFrames :: HG3DClass -> IO (Bool)
 hasNonZeroKeyFrames a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -167,10 +138,8 @@
   return (a2'')
 {-# LINE 93 ".\\HGamer3D\\Bindings\\Ogre\\ClassNodeAnimationTrack.chs" #-}
 
--- | Optimise the current track by removing any duplicate keyframes. 
-optimise :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function optimise -}
+optimise :: HG3DClass -> IO ()
 optimise a1 =
   withHG3DClass a1 $ \a1' -> 
   optimise'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassNumericAnimationTrack.hs b/HGamer3D/Bindings/Ogre/ClassNumericAnimationTrack.hs
--- a/HGamer3D/Bindings/Ogre/ClassNumericAnimationTrack.hs
+++ b/HGamer3D/Bindings/Ogre/ClassNumericAnimationTrack.hs
@@ -48,11 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassNumericAnimationTrack.chs" #-}
 
--- | Constructor. 
-new :: HG3DClass  -- ^ parent
-  ->  Int  -- ^ handle
-  ->  IO (HG3DClass)
- -- ^ 
+{- function NumericAnimationTrack -}
+new :: HG3DClass -> Int -> IO (HG3DClass)
 new a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -62,14 +59,8 @@
   return (a3'')
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassNumericAnimationTrack.chs" #-}
 
--- | Applies an animation track to the designated target.
---
-apply :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ timeIndex
-  ->  Float  -- ^ weight
-  ->  Float  -- ^ scale
-  ->  IO ()
- -- ^ 
+{- function apply -}
+apply :: HG3DClass -> HG3DClass -> Float -> Float -> IO ()
 apply a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassRenderSystem.hs b/HGamer3D/Bindings/Ogre/ClassRenderSystem.hs
--- a/HGamer3D/Bindings/Ogre/ClassRenderSystem.hs
+++ b/HGamer3D/Bindings/Ogre/ClassRenderSystem.hs
@@ -52,20 +52,16 @@
 import HGamer3D.Bindings.Ogre.EnumGpuProgramType
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~RenderSystem -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Returns the name of the rendering system. 
-getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getName -}
+getName :: HG3DClass -> IO (String)
 getName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -74,13 +70,8 @@
   return (a2'')
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Sets an option for this API
---Used to confirm the settings (normally chosen by the user) in order to make the renderer able to initialise with the settings as required. This may be video mode, D3D driver, full screen / windowed etc. Called automatically by the default configuration dialog, and by the restoration of saved settings. These settings are stored and only activated when RenderSystem::initialise or RenderSystem::reinitialiseIf using a custom configuration dialog, it is advised that the caller calls RenderSystem::getConfigOptions
-setConfigOption :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the option to alter. 
-  ->  String  -- ^ value - The value to set the option to. 
-  ->  IO ()
- -- ^ 
+{- function setConfigOption -}
+setConfigOption :: HG3DClass -> String -> String -> IO ()
 setConfigOption a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -89,11 +80,8 @@
   return ()
 {-# LINE 60 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Validates the options set for the rendering system, returning a message if there are problems.
---If the returned string is empty, there are no problems. 
-validateConfigOptions :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function validateConfigOptions -}
+validateConfigOptions :: HG3DClass -> IO (String)
 validateConfigOptions a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -102,33 +90,24 @@
   return (a2'')
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Restart the renderer (normally following a change in settings). 
-reinitialise :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function reinitialise -}
+reinitialise :: HG3DClass -> IO ()
 reinitialise a1 =
   withHG3DClass a1 $ \a1' -> 
   reinitialise'_ a1' >>= \res ->
   return ()
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Shutdown the renderer and cleanup resources. 
-shutdown :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function shutdown -}
+shutdown :: HG3DClass -> IO ()
 shutdown a1 =
   withHG3DClass a1 $ \a1' -> 
   shutdown'_ a1' >>= \res ->
   return ()
 {-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Sets the colour & strength of the ambient (global directionless) light in the world. 
-setAmbientLight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ r
-  ->  Float  -- ^ g
-  ->  Float  -- ^ b
-  ->  IO ()
- -- ^ 
+{- function setAmbientLight -}
+setAmbientLight :: HG3DClass -> Float -> Float -> Float -> IO ()
 setAmbientLight a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -138,12 +117,8 @@
   return ()
 {-# LINE 80 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Sets whether or not dynamic lighting is enabled.
---
-setLightingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled - If true, dynamic lighting is performed on geometry with normals supplied, geometry without normals will not be displayed. If false, no lighting is applied and all geometry will be full brightness. 
-  ->  IO ()
- -- ^ 
+{- function setLightingEnabled -}
+setLightingEnabled :: HG3DClass -> Bool -> IO ()
 setLightingEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -151,12 +126,8 @@
   return ()
 {-# LINE 85 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Sets whether or not W-buffers are enabled if they are available for this renderer.
---
-setWBufferEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled - If true and the renderer supports them W-buffers will be used. If false W-buffers will not be used even if available. W-buffers are enabled by default for 16bit depth buffers and disabled for all other depths. 
-  ->  IO ()
- -- ^ 
+{- function setWBufferEnabled -}
+setWBufferEnabled :: HG3DClass -> Bool -> IO ()
 setWBufferEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -164,10 +135,8 @@
   return ()
 {-# LINE 90 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Returns true if the renderer will try to use W-buffers when avalible. 
-getWBufferEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getWBufferEnabled -}
+getWBufferEnabled :: HG3DClass -> IO (Bool)
 getWBufferEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -176,12 +145,8 @@
   return (a2'')
 {-# LINE 95 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Create a MultiRenderTarget, which is a render target that renders to multiple RenderTextures
---
-createMultiRenderTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createMultiRenderTarget -}
+createMultiRenderTarget :: HG3DClass -> String -> IO (HG3DClass)
 createMultiRenderTarget a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -191,11 +156,8 @@
   return (a3'')
 {-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Destroys a render window 
-destroyRenderWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function destroyRenderWindow -}
+destroyRenderWindow :: HG3DClass -> String -> IO ()
 destroyRenderWindow a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -203,11 +165,8 @@
   return ()
 {-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Destroys a render texture 
-destroyRenderTexture :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function destroyRenderTexture -}
+destroyRenderTexture :: HG3DClass -> String -> IO ()
 destroyRenderTexture a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -215,11 +174,8 @@
   return ()
 {-# LINE 111 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Destroys a render target of any sort 
-destroyRenderTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function destroyRenderTarget -}
+destroyRenderTarget :: HG3DClass -> String -> IO ()
 destroyRenderTarget a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -227,11 +183,8 @@
   return ()
 {-# LINE 116 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Attaches the passed render target to the render system. 
-attachRenderTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ target
-  ->  IO ()
- -- ^ 
+{- function attachRenderTarget -}
+attachRenderTarget :: HG3DClass -> HG3DClass -> IO ()
 attachRenderTarget a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -239,12 +192,8 @@
   return ()
 {-# LINE 121 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Returns a pointer to the render target with the passed name, or NULL if that
---
-getRenderTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getRenderTarget -}
+getRenderTarget :: HG3DClass -> String -> IO (HG3DClass)
 getRenderTarget a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -254,12 +203,8 @@
   return (a3'')
 {-# LINE 127 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Detaches the render target with the passed name from the render system and
---If the render target cannot be found, NULL is returned. 
-detachRenderTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function detachRenderTarget -}
+detachRenderTarget :: HG3DClass -> String -> IO (HG3DClass)
 detachRenderTarget a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -269,11 +214,8 @@
   return (a3'')
 {-# LINE 133 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Returns a description of an error code. 
-getErrorDescription :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ errorNumber
-  ->  IO (String)
- -- ^ 
+{- function getErrorDescription -}
+getErrorDescription :: HG3DClass -> Int -> IO (String)
 getErrorDescription a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -283,12 +225,8 @@
   return (a3'')
 {-# LINE 139 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Defines whether or now fullscreen render windows wait for the vertical blank before flipping buffers.
---By default, all rendering windows wait for a vertical blank (when the CRT beam turns off briefly to move from the bottom right of the screen back to the top left) before flipping the screen buffers. This ensures that the image you see on the screen is steady. However it restricts the frame rate to the refresh rate of the monitor, and can slow the frame rate down. You can speed this up by not waiting for the blank, but this has the downside of introducing 'tearing' artefacts where part of the previous frame is still displayed as the buffers are switched. Speed vs quality, you choose. Has NO effect on windowed mode render targets. Only affects fullscreen mode. 
-setWaitForVerticalBlank :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled - If true, the system waits for vertical blanks - quality over speed. If false it doesn't - speed over quality. 
-  ->  IO ()
- -- ^ 
+{- function setWaitForVerticalBlank -}
+setWaitForVerticalBlank :: HG3DClass -> Bool -> IO ()
 setWaitForVerticalBlank a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -296,10 +234,8 @@
   return ()
 {-# LINE 144 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Returns true if the system is synchronising frames with the monitor vertical blank. 
-getWaitForVerticalBlank :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getWaitForVerticalBlank -}
+getWaitForVerticalBlank :: HG3DClass -> IO (Bool)
 getWaitForVerticalBlank a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -308,10 +244,8 @@
   return (a2'')
 {-# LINE 149 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Gets the global number of instances. 
-getGlobalNumberOfInstances :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getGlobalNumberOfInstances -}
+getGlobalNumberOfInstances :: HG3DClass -> IO (Int)
 getGlobalNumberOfInstances a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -320,11 +254,8 @@
   return (a2'')
 {-# LINE 154 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Sets the global number of instances. 
-setGlobalNumberOfInstances :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ val
-  ->  IO ()
- -- ^ 
+{- function setGlobalNumberOfInstances -}
+setGlobalNumberOfInstances :: HG3DClass -> Int -> IO ()
 setGlobalNumberOfInstances a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -332,11 +263,8 @@
   return ()
 {-# LINE 159 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Sets if fixed pipeline rendering is enabled on the system. 
-setFixedPipelineEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setFixedPipelineEnabled -}
+setFixedPipelineEnabled :: HG3DClass -> Bool -> IO ()
 setFixedPipelineEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -344,10 +272,8 @@
   return ()
 {-# LINE 164 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Returns true if fixed pipeline rendering is enabled on the system. 
-getFixedPipelineEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getFixedPipelineEnabled -}
+getFixedPipelineEnabled :: HG3DClass -> IO (Bool)
 getFixedPipelineEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -356,11 +282,8 @@
   return (a2'')
 {-# LINE 169 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Retrieves an existing DepthBuffer or creates a new one suited for the given RenderTargetRenderTargetRenderTarget::setDepthBufferPool()
-setDepthBufferFor :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ renderTarget
-  ->  IO ()
- -- ^ 
+{- function setDepthBufferFor -}
+setDepthBufferFor :: HG3DClass -> HG3DClass -> IO ()
 setDepthBufferFor a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -368,10 +291,8 @@
   return ()
 {-# LINE 174 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Are fixed-function lights provided in view space? Affects optimisation. 
-areFixedFunctionLightsInViewSpace :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function areFixedFunctionLightsInViewSpace -}
+areFixedFunctionLightsInViewSpace :: HG3DClass -> IO (Bool)
 areFixedFunctionLightsInViewSpace a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -380,12 +301,8 @@
   return (a2'')
 {-# LINE 179 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Generates a packed data version of the passed in ColourValue suitable for
---RenderSystemSince different render systems have different colour data formats (eg RGBA for GL, ARGB for D3D) this method allows you to use 1 method for all. 
-convertColourValue :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ colour - The colour to convert 
-  ->  IO (Int)
- -- ^ pDest - Pointer to location to put the result. 
+{- function convertColourValue -}
+convertColourValue :: HG3DClass -> Colour -> IO (Int)
 convertColourValue a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -395,12 +312,8 @@
   return (a3'')
 {-# LINE 185 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Turns stencil buffer checking on or off. 
---Stencilling (masking off areas of the rendering target based on the stencil buffer) can be turned on or off using this method. By default, stencilling is disabled. 
-setStencilCheckEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
+{- function setStencilCheckEnabled -}
+setStencilCheckEnabled :: HG3DClass -> Bool -> IO ()
 setStencilCheckEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -408,12 +321,8 @@
   return ()
 {-# LINE 190 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Sets whether or not normals are to be automatically normalised.
---This is useful when, for example, you are scaling SceneNodes such that normals may not be unit-length anymore. Note though that this has an overhead so should not be turn on unless you really need it. You should not normally call this direct unless you are rendering world geometry; set it on the Renderable
-setNormaliseNormals :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ normalise
-  ->  IO ()
- -- ^ 
+{- function setNormaliseNormals -}
+setNormaliseNormals :: HG3DClass -> Bool -> IO ()
 setNormaliseNormals a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -421,11 +330,8 @@
   return ()
 {-# LINE 195 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Only binds Gpu program parameters used for passes that have more than one iteration rendering 
-bindGpuProgramPassIterationParameters :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumGpuProgramType  -- ^ gptype
-  ->  IO ()
- -- ^ 
+{- function bindGpuProgramPassIterationParameters -}
+bindGpuProgramPassIterationParameters :: HG3DClass -> EnumGpuProgramType -> IO ()
 bindGpuProgramPassIterationParameters a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -433,12 +339,8 @@
   return ()
 {-# LINE 200 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Unbinds GpuPrograms of a given GpuProgramType.
---This returns the pipeline to fixed-function processing for this type. 
-unbindGpuProgram :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumGpuProgramType  -- ^ gptype
-  ->  IO ()
- -- ^ 
+{- function unbindGpuProgram -}
+unbindGpuProgram :: HG3DClass -> EnumGpuProgramType -> IO ()
 unbindGpuProgram a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -446,11 +348,8 @@
   return ()
 {-# LINE 205 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Returns whether or not a Gpu program of the given type is currently bound. 
-isGpuProgramBound :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumGpuProgramType  -- ^ gptype
-  ->  IO (Bool)
- -- ^ 
+{- function isGpuProgramBound -}
+isGpuProgramBound :: HG3DClass -> EnumGpuProgramType -> IO (Bool)
 isGpuProgramBound a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -460,14 +359,8 @@
   return (a3'')
 {-# LINE 211 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Add a user clipping plane. 
-addClipPlane2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ A
-  ->  Float  -- ^ B
-  ->  Float  -- ^ C
-  ->  Float  -- ^ D
-  ->  IO ()
- -- ^ 
+{- function addClipPlane2 -}
+addClipPlane2 :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 addClipPlane2 a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -478,22 +371,16 @@
   return ()
 {-# LINE 219 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Clears the user clipping region. 
-resetClipPlanes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function resetClipPlanes -}
+resetClipPlanes :: HG3DClass -> IO ()
 resetClipPlanes a1 =
   withHG3DClass a1 $ \a1' -> 
   resetClipPlanes'_ a1' >>= \res ->
   return ()
 {-# LINE 223 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Sets whether or not vertex windings set should be inverted; this can be important
---
-setInvertVertexWinding :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ invert
-  ->  IO ()
- -- ^ 
+{- function setInvertVertexWinding -}
+setInvertVertexWinding :: HG3DClass -> Bool -> IO ()
 setInvertVertexWinding a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -501,11 +388,8 @@
   return ()
 {-# LINE 228 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Indicates whether or not the vertex windings set will be inverted for the current render (e.g. reflections)
---RenderSystem::setInvertVertexWinding
-getInvertVertexWinding :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getInvertVertexWinding -}
+getInvertVertexWinding :: HG3DClass -> IO (Bool)
 getInvertVertexWinding a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -514,16 +398,8 @@
   return (a2'')
 {-# LINE 233 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Sets the 'scissor region' ie the region of the target in which rendering can take place.
---This method allows you to 'mask off' rendering in all but a given rectangular area as identified by the parameters to this method. Not all systems support this method. Check the RenderSystemCapabilities for the RSC_SCISSOR_TEST capability to see if it is supported. 
-setScissorTest :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled - True to enable the scissor test, false to disable it. 
-  ->  Int  -- ^ left - The location of the corners of the rectangle, expressed in pixels. 
-  ->  Int  -- ^ top
-  ->  Int  -- ^ right
-  ->  Int  -- ^ bottom
-  ->  IO ()
- -- ^ 
+{- function setScissorTest -}
+setScissorTest :: HG3DClass -> Bool -> Int -> Int -> Int -> Int -> IO ()
 setScissorTest a1 a2 a3 a4 a5 a6 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -535,15 +411,8 @@
   return ()
 {-# LINE 242 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Clears one or more frame buffers on the active render target. 
---
-clearFrameBuffer :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ buffers - Combination of one or more elements of FrameBufferType denoting which buffers are to be cleared 
-  ->  Colour  -- ^ colour - The colour to clear the colour buffer with, if enabled 
-  ->  Float  -- ^ depth - The value to initialise the depth buffer with, if enabled 
-  ->  Int  -- ^ stencil - The value to initialise the stencil buffer with, if enabled. 
-  ->  IO ()
- -- ^ 
+{- function clearFrameBuffer -}
+clearFrameBuffer :: HG3DClass -> Int -> Colour -> Float -> Int -> IO ()
 clearFrameBuffer a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -554,11 +423,8 @@
   return ()
 {-# LINE 250 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Returns the horizontal texel offset value required for mapping 
---Since rendersystems sometimes disagree on the origin of a texel, mapping from texels to pixels can sometimes be problematic to implement generically. This method allows you to retrieve the offset required to map the origin of a texel to the origin of a pixel in the horizontal direction. 
-getHorizontalTexelOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getHorizontalTexelOffset -}
+getHorizontalTexelOffset :: HG3DClass -> IO (Float)
 getHorizontalTexelOffset a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -567,11 +433,8 @@
   return (a2'')
 {-# LINE 255 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Returns the vertical texel offset value required for mapping 
---Since rendersystems sometimes disagree on the origin of a texel, mapping from texels to pixels can sometimes be problematic to implement generically. This method allows you to retrieve the offset required to map the origin of a texel to the origin of a pixel in the vertical direction. 
-getVerticalTexelOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getVerticalTexelOffset -}
+getVerticalTexelOffset :: HG3DClass -> IO (Float)
 getVerticalTexelOffset a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -580,11 +443,8 @@
   return (a2'')
 {-# LINE 260 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Gets the minimum (closest) depth value to be used when rendering
---When using identity transforms you can manually set the depth of a vertex; however the input values required differ per rendersystem. This method lets you retrieve the correct value. Renderable::getUseIdentityViewRenderable::getUseIdentityProjection
-getMinimumDepthInputValue :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getMinimumDepthInputValue -}
+getMinimumDepthInputValue :: HG3DClass -> IO (Float)
 getMinimumDepthInputValue a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -593,11 +453,8 @@
   return (a2'')
 {-# LINE 265 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Gets the maximum (farthest) depth value to be used when rendering
---When using identity transforms you can manually set the depth of a vertex; however the input values required differ per rendersystem. This method lets you retrieve the correct value. Renderable::getUseIdentityViewRenderable::getUseIdentityProjection
-getMaximumDepthInputValue :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getMaximumDepthInputValue -}
+getMaximumDepthInputValue :: HG3DClass -> IO (Float)
 getMaximumDepthInputValue a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -606,12 +463,8 @@
   return (a2'')
 {-# LINE 270 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | set the current multi pass count value.  This must be set prior to 
---_render()
-setCurrentPassIterationCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ count - Number of times to render the current state. 
-  ->  IO ()
- -- ^ 
+{- function setCurrentPassIterationCount -}
+setCurrentPassIterationCount :: HG3DClass -> Int -> IO ()
 setCurrentPassIterationCount a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -619,15 +472,8 @@
   return ()
 {-# LINE 275 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Tell the render system whether to derive a depth bias on its own based on 
---
-setDeriveDepthBias :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ derive - True to tell the RS to derive this automatically 
-  ->  Float  -- ^ baseValue - The base value to which the multiplier should be added 
-  ->  Float  -- ^ multiplier - The amount of depth bias to apply per iteration 
-  ->  Float  -- ^ slopeScale - The constant slope scale bias for completeness 
-  ->  IO ()
- -- ^ 
+{- function setDeriveDepthBias -}
+setDeriveDepthBias :: HG3DClass -> Bool -> Float -> Float -> Float -> IO ()
 setDeriveDepthBias a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -638,62 +484,40 @@
   return ()
 {-# LINE 283 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Tell the rendersystem to perform any prep tasks it needs to directly
---Call this from your main thread before starting your other threads (which themselves should call registerThread()
---
---
---
---
---
---
---
---
---
-preExtraThreadsStarted :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function preExtraThreadsStarted -}
+preExtraThreadsStarted :: HG3DClass -> IO ()
 preExtraThreadsStarted a1 =
   withHG3DClass a1 $ \a1' -> 
   preExtraThreadsStarted'_ a1' >>= \res ->
   return ()
 {-# LINE 287 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | 
-postExtraThreadsStarted :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function postExtraThreadsStarted -}
+postExtraThreadsStarted :: HG3DClass -> IO ()
 postExtraThreadsStarted a1 =
   withHG3DClass a1 $ \a1' -> 
   postExtraThreadsStarted'_ a1' >>= \res ->
   return ()
 {-# LINE 291 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Register the an additional thread which may make calls to rendersystem-related 
---This method should only be called by additional threads during their initialisation. If they intend to use hardware rendering system resources they should call this method before doing anything related to the render system. Some rendering APIs require a per-thread setup and this method will sort that out. It is also necessary to call unregisterThread before the thread shuts down. This method takes no parameters - it must be called from the thread being registered and that context is enough. 
-registerThread :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function registerThread -}
+registerThread :: HG3DClass -> IO ()
 registerThread a1 =
   withHG3DClass a1 $ \a1' -> 
   registerThread'_ a1' >>= \res ->
   return ()
 {-# LINE 295 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Unregister an additional thread which may make calls to rendersystem-related objects.
---RenderSystem::registerThread
-unregisterThread :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function unregisterThread -}
+unregisterThread :: HG3DClass -> IO ()
 unregisterThread a1 =
   withHG3DClass a1 $ \a1' -> 
   unregisterThread'_ a1' >>= \res ->
   return ()
 {-# LINE 299 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Gets the number of display monitors. Root::getDisplayMonitorCount
-getDisplayMonitorCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getDisplayMonitorCount -}
+getDisplayMonitorCount :: HG3DClass -> IO (Int)
 getDisplayMonitorCount a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -702,11 +526,8 @@
   return (a2'')
 {-# LINE 304 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | This marks the beginning of an event for GPU profiling. 
-beginProfileEvent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ eventName
-  ->  IO ()
- -- ^ 
+{- function beginProfileEvent -}
+beginProfileEvent :: HG3DClass -> String -> IO ()
 beginProfileEvent a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -714,22 +535,16 @@
   return ()
 {-# LINE 309 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Ends the currently active GPU profiling event. 
-endProfileEvent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function endProfileEvent -}
+endProfileEvent :: HG3DClass -> IO ()
 endProfileEvent a1 =
   withHG3DClass a1 $ \a1' -> 
   endProfileEvent'_ a1' >>= \res ->
   return ()
 {-# LINE 313 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderSystem.chs" #-}
 
--- | Marks an instantaneous event for graphics profilers. This is equivalent to calling beginProfileEvent
---endProfileEvent
-markProfileEvent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ event
-  ->  IO ()
- -- ^ 
+{- function markProfileEvent -}
+markProfileEvent :: HG3DClass -> String -> IO ()
 markProfileEvent a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassRenderTarget.hs b/HGamer3D/Bindings/Ogre/ClassRenderTarget.hs
--- a/HGamer3D/Bindings/Ogre/ClassRenderTarget.hs
+++ b/HGamer3D/Bindings/Ogre/ClassRenderTarget.hs
@@ -48,20 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~RenderTarget -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Retrieve target's name. 
-getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getName -}
+getName :: HG3DClass -> IO (String)
 getName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -70,10 +66,8 @@
   return (a2'')
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Retrieve information about the render target. 
-getMetrics :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int, Int, Int)
- -- ^ width
+{- function getMetrics -}
+getMetrics :: HG3DClass -> IO (Int, Int, Int)
 getMetrics a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -86,10 +80,8 @@
   return (a2'', a3'', a4'')
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | 
-getWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getWidth -}
+getWidth :: HG3DClass -> IO (Int)
 getWidth a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -98,10 +90,8 @@
   return (a2'')
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | 
-getHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getHeight -}
+getHeight :: HG3DClass -> IO (Int)
 getHeight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -110,10 +100,8 @@
   return (a2'')
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | 
-getColourDepth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getColourDepth -}
+getColourDepth :: HG3DClass -> IO (Int)
 getColourDepth a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -122,11 +110,8 @@
   return (a2'')
 {-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Sets the pool ID this RenderTargetDepthBuffer Changing the pool Id will cause the current depth buffer to be detached unless the old id and the new one are the same 
-setDepthBufferPool :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ poolId
-  ->  IO ()
- -- ^ 
+{- function setDepthBufferPool -}
+setDepthBufferPool :: HG3DClass -> Int -> IO ()
 setDepthBufferPool a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -134,10 +119,8 @@
   return ()
 {-# LINE 79 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | 
-getDepthBufferPool :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getDepthBufferPool -}
+getDepthBufferPool :: HG3DClass -> IO (Int)
 getDepthBufferPool a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -146,21 +129,16 @@
   return (a2'')
 {-# LINE 84 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | 
-detachDepthBuffer :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function detachDepthBuffer -}
+detachDepthBuffer :: HG3DClass -> IO ()
 detachDepthBuffer a1 =
   withHG3DClass a1 $ \a1' -> 
   detachDepthBuffer'_ a1' >>= \res ->
   return ()
 {-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Tells the target to update it's contents. If OGRE is not running in an automatic rendering loop (started using Root::startRenderingThis allows OGRE to be used in multi-windowed utilities and for contents to be refreshed only when required, rather than constantly as with the automatic rendering loop. 
-update :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ swapBuffers - For targets that support double-buffering, if set to true, the target will immediately swap it's buffers after update. Otherwise, the buffers are not swapped, and you have to call swapBuffers yourself sometime later. You might want to do this on some rendersystems which pause for queued rendering commands to complete before accepting swap buffers calls - so you could do other CPU tasks whilst the queued commands complete. Or, you might do this if you want custom control over your windows, such as for externally created windows. 
-  ->  IO ()
- -- ^ 
+{- function update -}
+update :: HG3DClass -> Bool -> IO ()
 update a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -168,11 +146,8 @@
   return ()
 {-# LINE 93 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Swaps the frame buffers to display the next frame. For targets that are double-buffered so that no 'in-progress' versions of the scene are displayed during rendering. Once rendering has completed (to an off-screen version of the window) the buffers are swapped to display the new frame.
-swapBuffers :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ waitForVSync - If true, the system waits for the next vertical blank period (when the CRT beam turns off as it travels from bottom-right to top-left at the end of the pass) before flipping. If false, flipping occurs no matter what the beam position. Waiting for a vertical blank can be slower (and limits the framerate to the monitor refresh rate) but results in a steadier image with no 'tearing' (a flicker resulting from flipping buffers when the beam is in the progress of drawing the last frame). 
-  ->  IO ()
- -- ^ 
+{- function swapBuffers -}
+swapBuffers :: HG3DClass -> Bool -> IO ()
 swapBuffers a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -180,16 +155,8 @@
   return ()
 {-# LINE 98 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Adds a viewport to the rendering target. A viewport is the rectangle into which rendering output is sent. This method adds a viewport to the render target, rendering from the supplied camera. The rest of the parameters are only required if you wish to add more than one viewport to a single rendering target. Note that size information passed to this method is passed as a parametric, i.e. it is relative rather than absolute. This is to allow viewports to automatically resize along with the target. 
-addViewport :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ cam - The camera from which the viewport contents will be rendered (mandatory) 
-  ->  Int  -- ^ ZOrder - The relative order of the viewport with others on the target (allows overlapping viewports i.e. picture-in-picture). Higher ZOrders are on top of lower ones. The actual number is irrelevant, only the relative ZOrder matters (you can leave gaps in the numbering) 
-  ->  Float  -- ^ left - The relative position of the left of the viewport on the target, as a value between 0 and 1. 
-  ->  Float  -- ^ top - The relative position of the top of the viewport on the target, as a value between 0 and 1. 
-  ->  Float  -- ^ width - The relative width of the viewport on the target, as a value between 0 and 1. 
-  ->  Float  -- ^ height - The relative height of the viewport on the target, as a value between 0 and 1. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function addViewport -}
+addViewport :: HG3DClass -> HG3DClass -> Int -> Float -> Float -> Float -> Float -> IO (HG3DClass)
 addViewport a1 a2 a3 a4 a5 a6 a7 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -204,10 +171,8 @@
   return (a8'')
 {-# LINE 109 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Returns the number of viewports attached to this target. 
-getNumViewports :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumViewports -}
+getNumViewports :: HG3DClass -> IO (Int)
 getNumViewports a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -216,11 +181,8 @@
   return (a2'')
 {-# LINE 114 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Retrieves a pointer to the viewport with the given index. 
-getViewport :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getViewport -}
+getViewport :: HG3DClass -> Int -> IO (HG3DClass)
 getViewport a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -230,11 +192,8 @@
   return (a3'')
 {-# LINE 120 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Retrieves a pointer to the viewport with the given zorder. throws if not found. 
-getViewportByZOrder :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ ZOrder
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getViewportByZOrder -}
+getViewportByZOrder :: HG3DClass -> Int -> IO (HG3DClass)
 getViewportByZOrder a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -244,11 +203,8 @@
   return (a3'')
 {-# LINE 126 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Returns true if and only if a viewport exists at the given ZOrder. 
-hasViewportWithZOrder :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ ZOrder
-  ->  IO (Bool)
- -- ^ 
+{- function hasViewportWithZOrder -}
+hasViewportWithZOrder :: HG3DClass -> Int -> IO (Bool)
 hasViewportWithZOrder a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -258,11 +214,8 @@
   return (a3'')
 {-# LINE 132 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Removes a viewport at a given ZOrder. 
-removeViewport :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ ZOrder
-  ->  IO ()
- -- ^ 
+{- function removeViewport -}
+removeViewport :: HG3DClass -> Int -> IO ()
 removeViewport a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -270,20 +223,16 @@
   return ()
 {-# LINE 137 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Removes all viewports on this target. 
-removeAllViewports :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAllViewports -}
+removeAllViewports :: HG3DClass -> IO ()
 removeAllViewports a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAllViewports'_ a1' >>= \res ->
   return ()
 {-# LINE 141 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Retieves details of current rendering performance. If the user application wishes to do it's own performance display, or use performance for some other means, this method allows it to retrieve the statistics. 
-getStatistics :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float, Float, Float, Float)
- -- ^ lastFPS - Pointer to a float to receive the number of frames per second (FPS) based on the last frame rendered. 
+{- function getStatistics -}
+getStatistics :: HG3DClass -> IO (Float, Float, Float, Float)
 getStatistics a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -298,10 +247,8 @@
   return (a2'', a3'', a4'', a5'')
 {-# LINE 149 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Individual stats access - gets the number of frames per second (FPS) based on the last frame rendered. 
-getLastFPS :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getLastFPS -}
+getLastFPS :: HG3DClass -> IO (Float)
 getLastFPS a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -310,10 +257,8 @@
   return (a2'')
 {-# LINE 154 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Individual stats access - gets the average frames per second (FPS) since call to Root::startRendering
-getAverageFPS :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getAverageFPS -}
+getAverageFPS :: HG3DClass -> IO (Float)
 getAverageFPS a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -322,10 +267,8 @@
   return (a2'')
 {-# LINE 159 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Individual stats access - gets the best frames per second (FPS) since call to Root::startRendering
-getBestFPS :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBestFPS -}
+getBestFPS :: HG3DClass -> IO (Float)
 getBestFPS a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -334,10 +277,8 @@
   return (a2'')
 {-# LINE 164 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Individual stats access - gets the worst frames per second (FPS) since call to Root::startRendering
-getWorstFPS :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getWorstFPS -}
+getWorstFPS :: HG3DClass -> IO (Float)
 getWorstFPS a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -346,10 +287,8 @@
   return (a2'')
 {-# LINE 169 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Individual stats access - gets the best frame time 
-getBestFrameTime :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getBestFrameTime -}
+getBestFrameTime :: HG3DClass -> IO (Float)
 getBestFrameTime a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -358,10 +297,8 @@
   return (a2'')
 {-# LINE 174 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Individual stats access - gets the worst frame time 
-getWorstFrameTime :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getWorstFrameTime -}
+getWorstFrameTime :: HG3DClass -> IO (Float)
 getWorstFrameTime a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -370,30 +307,24 @@
   return (a2'')
 {-# LINE 179 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Resets saved frame-rate statistices. 
-resetStatistics :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function resetStatistics -}
+resetStatistics :: HG3DClass -> IO ()
 resetStatistics a1 =
   withHG3DClass a1 $ \a1' -> 
   resetStatistics'_ a1' >>= \res ->
   return ()
 {-# LINE 183 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Removes all listeners from this instance. 
-removeAllListeners :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAllListeners -}
+removeAllListeners :: HG3DClass -> IO ()
 removeAllListeners a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAllListeners'_ a1' >>= \res ->
   return ()
 {-# LINE 187 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Used to retrieve or set the active state of the render target. 
-isActive :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isActive -}
+isActive :: HG3DClass -> IO (Bool)
 isActive a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -402,11 +333,8 @@
   return (a2'')
 {-# LINE 192 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Used to set the active state of the render target. 
-setActive :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ state
-  ->  IO ()
- -- ^ 
+{- function setActive -}
+setActive :: HG3DClass -> Bool -> IO ()
 setActive a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -414,13 +342,8 @@
   return ()
 {-# LINE 197 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Sets whether this target should be automatically updated if Ogre's rendering
---loop or Root::_updateAllRenderTargets is being used.
---By default, if you use OgreRoot::startRenderingRoot::_updateAllRenderTargets
-setAutoUpdated :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ autoupdate - If true, the render target is updated during the automatic render loop or when Root::_updateAllRenderTargets is called. If false, the target is only updated when its update() method is called explicitly. 
-  ->  IO ()
- -- ^ 
+{- function setAutoUpdated -}
+setAutoUpdated :: HG3DClass -> Bool -> IO ()
 setAutoUpdated a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -428,10 +351,8 @@
   return ()
 {-# LINE 202 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Gets whether this target is automatically updated if OgreRoot::_updateAllRenderTargets
-isAutoUpdated :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isAutoUpdated -}
+isAutoUpdated :: HG3DClass -> IO (Bool)
 isAutoUpdated a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -440,11 +361,8 @@
   return (a2'')
 {-# LINE 207 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Writes the current contents of the render target to the named file. 
-writeContentsToFile :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  IO ()
- -- ^ 
+{- function writeContentsToFile -}
+writeContentsToFile :: HG3DClass -> String -> IO ()
 writeContentsToFile a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -452,12 +370,8 @@
   return ()
 {-# LINE 212 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Writes the current contents of the render target to the (PREFIX)(time-stamp)(SUFFIX) file. 
-writeContentsToTimestampedFile :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filenamePrefix
-  ->  String  -- ^ filenameSuffix
-  ->  IO (String)
- -- ^ return value - the name of the file used.     
+{- function writeContentsToTimestampedFile -}
+writeContentsToTimestampedFile :: HG3DClass -> String -> String -> IO (String)
 writeContentsToTimestampedFile a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -468,10 +382,8 @@
   return (a4'')
 {-# LINE 219 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | 
-requiresTextureFlipping :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function requiresTextureFlipping -}
+requiresTextureFlipping :: HG3DClass -> IO (Bool)
 requiresTextureFlipping a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -480,10 +392,8 @@
   return (a2'')
 {-# LINE 224 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Gets the number of triangles rendered in the last update()
-getTriangleCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getTriangleCount -}
+getTriangleCount :: HG3DClass -> IO (Int)
 getTriangleCount a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -492,10 +402,8 @@
   return (a2'')
 {-# LINE 229 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Gets the number of batches rendered in the last update()
-getBatchCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getBatchCount -}
+getBatchCount :: HG3DClass -> IO (Int)
 getBatchCount a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -504,10 +412,8 @@
   return (a2'')
 {-# LINE 234 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Indicates whether this target is the primary window. The primary window is special in that it is destroyed when ogre is shut down, and cannot be destroyed directly. This is the case because it holds the context for vertex, index buffers and textures. 
-isPrimary :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isPrimary -}
+isPrimary :: HG3DClass -> IO (Bool)
 isPrimary a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -516,10 +422,8 @@
   return (a2'')
 {-# LINE 239 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Indicates whether on rendering, linear colour space is converted to sRGB gamma colour space. This is the exact opposite conversion of what is indicated by Texture::isHardwareGammaEnabled, and can only be enabled on creation of the render target. For render windows, it's enabled through the 'gamma' creation misc parameter. For textures, it is enabled through the hwGamma parameter to the create call. 
-isHardwareGammaEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isHardwareGammaEnabled -}
+isHardwareGammaEnabled :: HG3DClass -> IO (Bool)
 isHardwareGammaEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -528,10 +432,8 @@
   return (a2'')
 {-# LINE 244 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Indicates whether multisampling is performed on rendering and at what level. 
-getFSAA :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getFSAA -}
+getFSAA :: HG3DClass -> IO (Int)
 getFSAA a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -540,10 +442,8 @@
   return (a2'')
 {-# LINE 249 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTarget.chs" #-}
 
--- | Gets the FSAA hint (Root::createRenderWindow
-getFSAAHint :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getFSAAHint -}
+getFSAAHint :: HG3DClass -> IO (String)
 getFSAAHint a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassRenderTexture.hs b/HGamer3D/Bindings/Ogre/ClassRenderTexture.hs
--- a/HGamer3D/Bindings/Ogre/ClassRenderTexture.hs
+++ b/HGamer3D/Bindings/Ogre/ClassRenderTexture.hs
@@ -48,10 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderTexture.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~RenderTexture -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassRenderWindow.hs b/HGamer3D/Bindings/Ogre/ClassRenderWindow.hs
--- a/HGamer3D/Bindings/Ogre/ClassRenderWindow.hs
+++ b/HGamer3D/Bindings/Ogre/ClassRenderWindow.hs
@@ -48,14 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Alter fullscreen mode options. 
---Nothing will happen unless the settings here are different from the current settings. 
-setFullscreen :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ fullScreen - Whether to use fullscreen mode or not. 
-  ->  Int  -- ^ width - The new width to use 
-  ->  Int  -- ^ height - The new height to use 
-  ->  IO ()
- -- ^ 
+{- function setFullscreen -}
+setFullscreen :: HG3DClass -> Bool -> Int -> Int -> IO ()
 setFullscreen a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -65,22 +59,16 @@
   return ()
 {-# LINE 50 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Destroys the window. 
-destroy :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function destroy -}
+destroy :: HG3DClass -> IO ()
 destroy a1 =
   withHG3DClass a1 $ \a1' -> 
   destroy'_ a1' >>= \res ->
   return ()
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Alter the size of the window. 
-resize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ width
-  ->  Int  -- ^ height
-  ->  IO ()
- -- ^ 
+{- function resize -}
+resize :: HG3DClass -> Int -> Int -> IO ()
 resize a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -89,23 +77,16 @@
   return ()
 {-# LINE 60 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Notify that the window has been resized
---You don't need to call this unless you created the window externally. 
-windowMovedOrResized :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function windowMovedOrResized -}
+windowMovedOrResized :: HG3DClass -> IO ()
 windowMovedOrResized a1 =
   withHG3DClass a1 $ \a1' -> 
   windowMovedOrResized'_ a1' >>= \res ->
   return ()
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Reposition the window. 
-reposition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ left
-  ->  Int  -- ^ top
-  ->  IO ()
- -- ^ 
+{- function reposition -}
+reposition :: HG3DClass -> Int -> Int -> IO ()
 reposition a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -114,10 +95,8 @@
   return ()
 {-# LINE 70 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Indicates whether the window is visible (not minimized or obscured) 
-isVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isVisible -}
+isVisible :: HG3DClass -> IO (Bool)
 isVisible a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -126,11 +105,8 @@
   return (a2'')
 {-# LINE 75 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Set the visibility state 
-setVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ visible
-  ->  IO ()
- -- ^ 
+{- function setVisible -}
+setVisible :: HG3DClass -> Bool -> IO ()
 setVisible a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -138,10 +114,8 @@
   return ()
 {-# LINE 80 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Indicates whether the window was set to hidden (not displayed) 
-isHidden :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isHidden -}
+isHidden :: HG3DClass -> IO (Bool)
 isHidden a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -150,13 +124,8 @@
   return (a2'')
 {-# LINE 85 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Hide (or show) the window. If called with hidden=true, this
---will make the window completely invisible to the user.
---Setting a window to hidden is useful to create a dummy primary RenderWindow
-setHidden :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ hidden
-  ->  IO ()
- -- ^ 
+{- function setHidden -}
+setHidden :: HG3DClass -> Bool -> IO ()
 setHidden a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -164,11 +133,8 @@
   return ()
 {-# LINE 90 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Enable or disable vertical sync for the RenderWindow
-setVSyncEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ vsync
-  ->  IO ()
- -- ^ 
+{- function setVSyncEnabled -}
+setVSyncEnabled :: HG3DClass -> Bool -> IO ()
 setVSyncEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -176,10 +142,8 @@
   return ()
 {-# LINE 95 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Indicates whether vertical sync is activated for the window. 
-isVSyncEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isVSyncEnabled -}
+isVSyncEnabled :: HG3DClass -> IO (Bool)
 isVSyncEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -188,11 +152,8 @@
   return (a2'')
 {-# LINE 100 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Set the vertical sync interval. This indicates the number of vertical retraces to wait for before swapping buffers. A value of 1 is the default. 
-setVSyncInterval :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ interval
-  ->  IO ()
- -- ^ 
+{- function setVSyncInterval -}
+setVSyncInterval :: HG3DClass -> Int -> IO ()
 setVSyncInterval a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -200,10 +161,8 @@
   return ()
 {-# LINE 105 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Returns the vertical sync interval. 
-getVSyncInterval :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getVSyncInterval -}
+getVSyncInterval :: HG3DClass -> IO (Int)
 getVSyncInterval a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -212,10 +171,8 @@
   return (a2'')
 {-# LINE 110 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Overridden from RenderTarget
-isActive :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isActive -}
+isActive :: HG3DClass -> IO (Bool)
 isActive a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -224,10 +181,8 @@
   return (a2'')
 {-# LINE 115 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Indicates whether the window has been closed by the user. 
-isClosed :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isClosed -}
+isClosed :: HG3DClass -> IO (Bool)
 isClosed a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -236,10 +191,8 @@
   return (a2'')
 {-# LINE 120 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Indicates whether the window is the primary window. The primary window is special in that it is destroyed when ogre is shut down, and cannot be destroyed directly. This is the case because it holds the context for vertex, index buffers and textures. 
-isPrimary :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isPrimary -}
+isPrimary :: HG3DClass -> IO (Bool)
 isPrimary a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -248,10 +201,8 @@
   return (a2'')
 {-# LINE 125 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Returns true if window is running in fullscreen mode. 
-isFullScreen :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isFullScreen -}
+isFullScreen :: HG3DClass -> IO (Bool)
 isFullScreen a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -260,10 +211,8 @@
   return (a2'')
 {-# LINE 130 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Overloaded version of getMetrics from RenderTarget
-getMetrics :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int, Int, Int, Int, Int)
- -- ^ width
+{- function getMetrics -}
+getMetrics :: HG3DClass -> IO (Int, Int, Int, Int, Int)
 getMetrics a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -280,10 +229,8 @@
   return (a2'', a3'', a4'', a5'', a6'')
 {-# LINE 139 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Returns true if the window will automatically de-activate itself when it loses focus. 
-isDeactivatedOnFocusChange :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isDeactivatedOnFocusChange -}
+isDeactivatedOnFocusChange :: HG3DClass -> IO (Bool)
 isDeactivatedOnFocusChange a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -292,11 +239,8 @@
   return (a2'')
 {-# LINE 144 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderWindow.chs" #-}
 
--- | Indicates whether the window will automatically deactivate itself when it loses focus. 'true' is the default behavior. 
-setDeactivateOnFocusChange :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ deactivate - a value of 'true' will cause the window to deactivate itself when it loses focus. 'false' will allow it to continue to render even when window focus is lost. 
-  ->  IO ()
- -- ^ 
+{- function setDeactivateOnFocusChange -}
+setDeactivateOnFocusChange :: HG3DClass -> Bool -> IO ()
 setDeactivateOnFocusChange a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
diff --git a/HGamer3D/Bindings/Ogre/ClassRenderable.hs b/HGamer3D/Bindings/Ogre/ClassRenderable.hs
--- a/HGamer3D/Bindings/Ogre/ClassRenderable.hs
+++ b/HGamer3D/Bindings/Ogre/ClassRenderable.hs
@@ -50,21 +50,16 @@
 import HGamer3D.Bindings.Ogre.StructSharedPtr
 {-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Virtual destructor needed as class has virtual methods. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Renderable -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 48 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Retrieves a weak reference to the material this renderable object uses.
---Note that the Renderable
-getMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (SharedPtr)
- -- ^ 
+{- function getMaterial -}
+getMaterial :: HG3DClass -> IO (SharedPtr)
 getMaterial a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -73,13 +68,8 @@
   return (a2'')
 {-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Called just prior to the Renderable being rendered. 
---OGRE is a queued renderer, so the actual render commands are executed at a later time than the point at which an object is discovered to be visible. This allows ordering & grouping of renders without the discovery process having to be aware of it. It also means OGRE uses declarative render information rather than immediate mode rendering - this is very useful in that certain effects and processes can automatically be applied to a wide range of scenes, but the downside is that special cases are more difficult to handle, because there is not the declared state to cope with it. This method allows a RenderableRenderableRenderable
-preRender :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ sm
-  ->  HG3DClass  -- ^ rsys
-  ->  IO (Bool)
- -- ^ return value - true if the automatic render should proceed, false to skip it on the assumption that the     
+{- function preRender -}
+preRender :: HG3DClass -> HG3DClass -> HG3DClass -> IO (Bool)
 preRender a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -90,12 +80,8 @@
   return (a4'')
 {-# LINE 60 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Called immediately after the Renderable
-postRender :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ sm
-  ->  HG3DClass  -- ^ rsys
-  ->  IO ()
- -- ^ 
+{- function postRender -}
+postRender :: HG3DClass -> HG3DClass -> HG3DClass -> IO ()
 postRender a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -104,11 +90,8 @@
   return ()
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Returns the number of world transform matrices this renderable requires.
---When a renderable uses vertex blending, it uses multiple world matrices instead of a single one. Each vertex sent to the pipeline can reference one or more matrices in this list with given weights. If a renderable does not use vertex blending this method returns 1, which is the default for simplicity. 
-getNumWorldTransforms :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumWorldTransforms -}
+getNumWorldTransforms :: HG3DClass -> IO (Int)
 getNumWorldTransforms a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -117,12 +100,8 @@
   return (a2'')
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Sets whether or not to use an 'identity' projection.
---Usually RenderableRenderable::getUseIdentityProjection
-setUseIdentityProjection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ useIdentityProjection
-  ->  IO ()
- -- ^ 
+{- function setUseIdentityProjection -}
+setUseIdentityProjection :: HG3DClass -> Bool -> IO ()
 setUseIdentityProjection a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -130,11 +109,8 @@
   return ()
 {-# LINE 76 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Returns whether or not to use an 'identity' projection.
---Usually RenderableRenderable::setUseIdentityProjection
-getUseIdentityProjection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseIdentityProjection -}
+getUseIdentityProjection :: HG3DClass -> IO (Bool)
 getUseIdentityProjection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -143,12 +119,8 @@
   return (a2'')
 {-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Sets whether or not to use an 'identity' view.
---Usually RenderableRenderable::getUseIdentityView
-setUseIdentityView :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ useIdentityView
-  ->  IO ()
- -- ^ 
+{- function setUseIdentityView -}
+setUseIdentityView :: HG3DClass -> Bool -> IO ()
 setUseIdentityView a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -156,11 +128,8 @@
   return ()
 {-# LINE 86 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Returns whether or not to use an 'identity' view.
---Usually RenderableRenderable::setUseIdentityView
-getUseIdentityView :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getUseIdentityView -}
+getUseIdentityView :: HG3DClass -> IO (Bool)
 getUseIdentityView a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -169,12 +138,8 @@
   return (a2'')
 {-# LINE 91 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Returns the camera-relative squared depth of this renderable.
---Used to sort transparent objects. Squared depth is used rather than actual depth to avoid having to perform a square root on the result. 
-getSquaredViewDepth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ cam
-  ->  IO (Float)
- -- ^ 
+{- function getSquaredViewDepth -}
+getSquaredViewDepth :: HG3DClass -> HG3DClass -> IO (Float)
 getSquaredViewDepth a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -184,12 +149,8 @@
   return (a3'')
 {-# LINE 97 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Method which reports whether this renderable would normally cast a
---shadow. 
---Subclasses should override this if they could have been used to generate a shadow. 
-getCastsShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getCastsShadows -}
+getCastsShadows :: HG3DClass -> IO (Bool)
 getCastsShadows a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -198,12 +159,8 @@
   return (a2'')
 {-# LINE 102 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Removes a custom value which is associated with this Renderable at the given index.
---
-removeCustomParameter :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO ()
- -- ^ 
+{- function removeCustomParameter -}
+removeCustomParameter :: HG3DClass -> Int -> IO ()
 removeCustomParameter a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -211,12 +168,8 @@
   return ()
 {-# LINE 107 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Checks whether a custom value is associated with this Renderable at the given index.
---
-hasCustomParameter :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (Bool)
- -- ^ 
+{- function hasCustomParameter -}
+hasCustomParameter :: HG3DClass -> Int -> IO (Bool)
 hasCustomParameter a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -226,13 +179,8 @@
   return (a3'')
 {-# LINE 113 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Sets whether this renderable's chosen detail level can be
---overridden (downgraded) by the camera setting. 
---
-setPolygonModeOverrideable :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ override - true means that a lower camera detail will override this renderables detail level, false means it won't. 
-  ->  IO ()
- -- ^ 
+{- function setPolygonModeOverrideable -}
+setPolygonModeOverrideable :: HG3DClass -> Bool -> IO ()
 setPolygonModeOverrideable a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -240,10 +188,8 @@
   return ()
 {-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassRenderable.chs" #-}
 
--- | Gets whether this renderable's chosen detail level can be overridden (downgraded) by the camera setting. 
-getPolygonModeOverrideable :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getPolygonModeOverrideable -}
+getPolygonModeOverrideable :: HG3DClass -> IO (Bool)
 getPolygonModeOverrideable a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassResource.hs b/HGamer3D/Bindings/Ogre/ClassResource.hs
--- a/HGamer3D/Bindings/Ogre/ClassResource.hs
+++ b/HGamer3D/Bindings/Ogre/ClassResource.hs
@@ -48,21 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Virtual destructor. Shouldn't need to be overloaded, as the resource deallocation code should reside in unload()Resource::unload()
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Resource -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Prepares the resource for load, if it is not already. One can call prepare()load()load()prepare()load()prepare()prepare()prepare()load()prepare()load()prepare()prepare()
-prepare :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ backgroundThread - Whether this is occurring in a background thread 
-  ->  IO ()
- -- ^ 
+{- function prepare -}
+prepare :: HG3DClass -> Bool -> IO ()
 prepare a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -70,11 +65,8 @@
   return ()
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Loads the resource, if it is not already. If the resource is loaded from a file, loading is automatic. If not, if for example this resource gained it's data from procedural calls rather than loading from a file, then this resource will not reload on it's own. 
-load :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ backgroundThread - Indicates whether the caller of this method is the background resource loading thread. 
-  ->  IO ()
- -- ^ 
+{- function load -}
+load :: HG3DClass -> Bool -> IO ()
 load a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -82,21 +74,16 @@
   return ()
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Reloads the resource, if it is already loaded.
---Calls unload()load()
-reload :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function reload -}
+reload :: HG3DClass -> IO ()
 reload a1 =
   withHG3DClass a1 $ \a1' -> 
   reload'_ a1' >>= \res ->
   return ()
 {-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Returns true if the Resource
-isReloadable :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isReloadable -}
+isReloadable :: HG3DClass -> IO (Bool)
 isReloadable a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -105,10 +92,8 @@
   return (a2'')
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Is this resource manually loaded? 
-isManuallyLoaded :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isManuallyLoaded -}
+isManuallyLoaded :: HG3DClass -> IO (Bool)
 isManuallyLoaded a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -117,20 +102,16 @@
   return (a2'')
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Unloads the resource; this is not permanent, the resource can be reloaded later if required. 
-unload :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function unload -}
+unload :: HG3DClass -> IO ()
 unload a1 =
   withHG3DClass a1 $ \a1' -> 
   unload'_ a1' >>= \res ->
   return ()
 {-# LINE 75 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Retrieves info about the size of the resource. 
-getSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getSize -}
+getSize :: HG3DClass -> IO (Int)
 getSize a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -139,20 +120,16 @@
   return (a2'')
 {-# LINE 80 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | 'Touches' the resource to indicate it has been used. 
-touch :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function touch -}
+touch :: HG3DClass -> IO ()
 touch a1 =
   withHG3DClass a1 $ \a1' -> 
   touch'_ a1' >>= \res ->
   return ()
 {-# LINE 84 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Gets resource name. 
-getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getName -}
+getName :: HG3DClass -> IO (String)
 getName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -161,10 +138,8 @@
   return (a2'')
 {-# LINE 89 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Returns true if the Resource
-isPrepared :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isPrepared -}
+isPrepared :: HG3DClass -> IO (Bool)
 isPrepared a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -173,10 +148,8 @@
   return (a2'')
 {-# LINE 94 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Returns true if the Resource
-isLoaded :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isLoaded -}
+isLoaded :: HG3DClass -> IO (Bool)
 isLoaded a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -185,10 +158,8 @@
   return (a2'')
 {-# LINE 99 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Returns whether the resource is currently in the process of background loading. 
-isLoading :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isLoading -}
+isLoading :: HG3DClass -> IO (Bool)
 isLoading a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -197,11 +168,8 @@
   return (a2'')
 {-# LINE 104 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Returns whether this Resource has been earmarked for background loading.
---This option only makes sense when you have built Ogreload()load()isLoaded()
-isBackgroundLoaded :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isBackgroundLoaded -}
+isBackgroundLoaded :: HG3DClass -> IO (Bool)
 isBackgroundLoaded a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -210,12 +178,8 @@
   return (a2'')
 {-# LINE 109 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Tells the resource whether it is background loaded or not.
---Resource::isBackgroundLoaded
-setBackgroundLoaded :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ bl
-  ->  IO ()
- -- ^ 
+{- function setBackgroundLoaded -}
+setBackgroundLoaded :: HG3DClass -> Bool -> IO ()
 setBackgroundLoaded a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -223,21 +187,16 @@
   return ()
 {-# LINE 114 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Escalates the loading of a background loaded resource. 
---If a resource is set to load in the background, but something needs it before it's been loaded, there could be a problem. If the user of this resource really can't wait, they can escalate the loading which basically pulls the loading into the current thread immediately. If the resource is already being loaded but just hasn't quite finished then this method will simply wait until the background load is complete. 
-escalateLoading :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function escalateLoading -}
+escalateLoading :: HG3DClass -> IO ()
 escalateLoading a1 =
   withHG3DClass a1 $ \a1' -> 
   escalateLoading'_ a1' >>= \res ->
   return ()
 {-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Gets the group which this resource is a member of. 
-getGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getGroup -}
+getGroup :: HG3DClass -> IO (String)
 getGroup a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -246,12 +205,8 @@
   return (a2'')
 {-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Change the resource group ownership of a Resource.
---This method is generally reserved for internal use, although if you really know what you're doing you can use it to move this resource from one group to another. 
-changeGroupOwnership :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ newGroup - Name of the new group 
-  ->  IO ()
- -- ^ 
+{- function changeGroupOwnership -}
+changeGroupOwnership :: HG3DClass -> String -> IO ()
 changeGroupOwnership a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -259,10 +214,8 @@
   return ()
 {-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Gets the manager which created this resource. 
-getCreator :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getCreator -}
+getCreator :: HG3DClass -> IO (HG3DClass)
 getCreator a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -271,11 +224,8 @@
   return (a2'')
 {-# LINE 133 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Get the origin of this resource, e.g. a script file name.
---This property will only contain something if the creator of this resource chose to populate it. Script loaders are advised to populate it. 
-getOrigin :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getOrigin -}
+getOrigin :: HG3DClass -> IO (String)
 getOrigin a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -284,10 +234,8 @@
   return (a2'')
 {-# LINE 138 ".\\HGamer3D\\Bindings\\Ogre\\ClassResource.chs" #-}
 
--- | Returns the number of times this resource has changed state, which generally means the number of times it has been loaded. Objects that build derived data based on the resource can check this value against a copy they kept last time they built this derived data, in order to know whether it needs rebuilding. This is a nice way of monitoring changes without having a tightly-bound callback. 
-getStateCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getStateCount -}
+getStateCount :: HG3DClass -> IO (Int)
 getStateCount a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassResourceGroupManager.hs b/HGamer3D/Bindings/Ogre/ClassResourceGroupManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassResourceGroupManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassResourceGroupManager.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | 
+{- function ResourceGroupManager -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,30 +57,16 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~ResourceGroupManager -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Create a resource group.
---A resource group allows you to define a set of resources that can be loaded / unloaded as a unit. For example, it might be all the resources used for the level of a game. There is always one predefined resource group called ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAMEResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAMEResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAMEOnce you have defined a resource group, resources which will be loaded as part of it are defined in one of 3 ways: 
---
---
---
---
---
---
---
-createResourceGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to give the resource group. 
-  ->  Bool  -- ^ inGlobalPool - if true the resource will be loaded even a different group was requested in the load method as a parameter. 
-  ->  IO ()
- -- ^ 
+{- function createResourceGroup -}
+createResourceGroup :: HG3DClass -> String -> Bool -> IO ()
 createResourceGroup a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -90,17 +75,8 @@
   return ()
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Initialises a resource group.
---After creating a resource group, adding some resource locations, and perhaps pre-declaring some resources using declareResource()
---
---
---
---
---ResourceFailure to call this method means that loadResourceGroup will do nothing, and any resources you define in scripts will not be found. Similarly, once you have called this method you won't be able to pick up any new scripts or pre-declared resources, unless you call clearResourceGroup, set up declared resources, and call this method again. When you call Root::initialiseRoot::initialise
-initialiseResourceGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the resource group to initialise 
-  ->  IO ()
- -- ^ 
+{- function initialiseResourceGroup -}
+initialiseResourceGroup :: HG3DClass -> String -> IO ()
 initialiseResourceGroup a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -108,25 +84,16 @@
   return ()
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Initialise all resource groups which are yet to be initialised.
---ResourceGroupManager::intialiseResourceGroup 
-initialiseAllResourceGroups :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function initialiseAllResourceGroups -}
+initialiseAllResourceGroups :: HG3DClass -> IO ()
 initialiseAllResourceGroups a1 =
   withHG3DClass a1 $ \a1' -> 
   initialiseAllResourceGroups'_ a1' >>= \res ->
   return ()
 {-# LINE 66 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Prepares a resource group.
---Prepares any created resources which are part of the named group. Note that resources must have already been created by calling ResourceManager::createdeclareResource()ResourceGroupManager::linkWorldGeometryToResourceGroup
-prepareResourceGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the resource group to prepare. 
-  ->  Bool  -- ^ prepareMainResources - If true, prepares normal resources associated with the group (you might want to set this to false if you wanted to just prepare world geometry in bulk) 
-  ->  Bool  -- ^ prepareWorldGeom - If true, prepares any linked world geometry 
-  ->  IO ()
- -- ^ 
+{- function prepareResourceGroup -}
+prepareResourceGroup :: HG3DClass -> String -> Bool -> Bool -> IO ()
 prepareResourceGroup a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -136,14 +103,8 @@
   return ()
 {-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Loads a resource group.
---Loads any created resources which are part of the named group. Note that resources must have already been created by calling ResourceManager::createdeclareResource()ResourceGroupManager::linkWorldGeometryToResourceGroup
-loadResourceGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the resource group to load. 
-  ->  Bool  -- ^ loadMainResources - If true, loads normal resources associated with the group (you might want to set this to false if you wanted to just load world geometry in bulk) 
-  ->  Bool  -- ^ loadWorldGeom - If true, loads any linked world geometry 
-  ->  IO ()
- -- ^ 
+{- function loadResourceGroup -}
+loadResourceGroup :: HG3DClass -> String -> Bool -> Bool -> IO ()
 loadResourceGroup a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -153,13 +114,8 @@
   return ()
 {-# LINE 80 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Unloads a resource group.
---This method unloads all the resources that have been declared as being part of the named resource group. Note that these resources will still exist in their respective ResourceManagerResource::isReloadable
-unloadResourceGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to of the resource group to unload. 
-  ->  Bool  -- ^ reloadableOnly - If set to true, only unload the resource that is reloadable. Because some resources isn't reloadable, they will be unloaded but can't load them later. Thus, you might not want to them unloaded. Or, you might unload all of them, and then populate them manually later. 
-  ->  IO ()
- -- ^ 
+{- function unloadResourceGroup -}
+unloadResourceGroup :: HG3DClass -> String -> Bool -> IO ()
 unloadResourceGroup a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -168,13 +124,8 @@
   return ()
 {-# LINE 86 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Unload all resources which are not referenced by any other object.
---This method behaves like unloadResourceGroup, except that it only unloads resources in the group which are not in use, ie not referenced by other objects. This allows you to free up some memory selectively whilst still keeping the group around (and the resources present, just not using much memory). 
-unloadUnreferencedResourcesInGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the group to check for unreferenced resources 
-  ->  Bool  -- ^ reloadableOnly - If true (the default), only unloads resources which can be subsequently automatically reloaded 
-  ->  IO ()
- -- ^ 
+{- function unloadUnreferencedResourcesInGroup -}
+unloadUnreferencedResourcesInGroup :: HG3DClass -> String -> Bool -> IO ()
 unloadUnreferencedResourcesInGroup a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -183,12 +134,8 @@
   return ()
 {-# LINE 92 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Clears a resource group. 
---This method unloads all resources in the group, but in addition it removes all those resources from their ResourceManagers, and then clears all the members from the list. That means after calling this method, there are no resources declared as part of the named group any more. Resource
-clearResourceGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to of the resource group to clear. 
-  ->  IO ()
- -- ^ 
+{- function clearResourceGroup -}
+clearResourceGroup :: HG3DClass -> String -> IO ()
 clearResourceGroup a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -196,14 +143,8 @@
   return ()
 {-# LINE 97 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Destroys a resource group, clearing it first, destroying the resources
---which are part of it, and then removing it from
---the list of resource groups. 
---
-destroyResourceGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the resource group to destroy. 
-  ->  IO ()
- -- ^ 
+{- function destroyResourceGroup -}
+destroyResourceGroup :: HG3DClass -> String -> IO ()
 destroyResourceGroup a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -211,12 +152,8 @@
   return ()
 {-# LINE 102 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Checks the status of a resource group.
---Looks at the state of a resource group. If initialiseResourceGroup has been called for the resource group return true, otherwise return false. 
-isResourceGroupInitialised :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to of the resource group to access. 
-  ->  IO (Bool)
- -- ^ 
+{- function isResourceGroupInitialised -}
+isResourceGroupInitialised :: HG3DClass -> String -> IO (Bool)
 isResourceGroupInitialised a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -226,12 +163,8 @@
   return (a3'')
 {-# LINE 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Checks the status of a resource group.
---Looks at the state of a resource group. If loadResourceGroup has been called for the resource group return true, otherwise return false. 
-isResourceGroupLoaded :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to of the resource group to access. 
-  ->  IO (Bool)
- -- ^ 
+{- function isResourceGroupLoaded -}
+isResourceGroupLoaded :: HG3DClass -> String -> IO (Bool)
 isResourceGroupLoaded a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -241,11 +174,8 @@
   return (a3'')
 {-# LINE 114 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | 
-resourceGroupExists :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
+{- function resourceGroupExists -}
+resourceGroupExists :: HG3DClass -> String -> IO (Bool)
 resourceGroupExists a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -255,15 +185,8 @@
   return (a3'')
 {-# LINE 120 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Method to add a resource location to for a given resource group. 
---Resource
-addResourceLocation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the resource location; probably a directory, zip file, URL etc. 
-  ->  String  -- ^ locType - The codename for the resource type, which must correspond to the Archive factory which is providing the implementation. 
-  ->  String  -- ^ resGroup - The name of the resource group for which this location is to apply. ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME is the default group which always exists, and can be used for resources which are unlikely to be unloaded until application shutdown. Otherwise it must be the name of a group; if it has not already been created with createResourceGroup then it is created automatically. 
-  ->  Bool  -- ^ recursive - Whether subdirectories will be searched for files when using a pattern match (such as *.material), and whether subdirectories will be indexed. This can slow down initial loading of the archive and searches. When opening a resource you still need to use the fully qualified name, this allows duplicate names in alternate paths. 
-  ->  IO ()
- -- ^ 
+{- function addResourceLocation -}
+addResourceLocation :: HG3DClass -> String -> String -> String -> Bool -> IO ()
 addResourceLocation a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -274,12 +197,8 @@
   return ()
 {-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Removes a resource location from the search path. 
-removeResourceLocation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  String  -- ^ resGroup
-  ->  IO ()
- -- ^ 
+{- function removeResourceLocation -}
+removeResourceLocation :: HG3DClass -> String -> String -> IO ()
 removeResourceLocation a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -288,12 +207,8 @@
   return ()
 {-# LINE 134 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Verify if a resource location exists for the given group. 
-resourceLocationExists :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  String  -- ^ resGroup
-  ->  IO (Bool)
- -- ^ 
+{- function resourceLocationExists -}
+resourceLocationExists :: HG3DClass -> String -> String -> IO (Bool)
 resourceLocationExists a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -304,13 +219,8 @@
   return (a4'')
 {-# LINE 141 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Undeclare a resource.
---Note that this will not cause it to be unloaded if it is already loaded, nor will it destroy a resource which has already been created if initialiseResourceGroup has been called already. Only unloadResourceGroup / clearResourceGroup / destroyResourceGroup will do that. 
-undeclareResource :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the resource. 
-  ->  String  -- ^ groupName - The name of the group this resource was declared in. 
-  ->  IO ()
- -- ^ 
+{- function undeclareResource -}
+undeclareResource :: HG3DClass -> String -> String -> IO ()
 undeclareResource a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -319,13 +229,8 @@
   return ()
 {-# LINE 147 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Find out if the named file exists in a group. 
---
-resourceExists :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ group - The name of the resource group 
-  ->  String  -- ^ filename - Fully qualified name of the file to test for 
-  ->  IO (Bool)
- -- ^ 
+{- function resourceExists -}
+resourceExists :: HG3DClass -> String -> String -> IO (Bool)
 resourceExists a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -336,12 +241,8 @@
   return (a4'')
 {-# LINE 154 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Find out if the named file exists in any group. 
---
-resourceExistsInAnyGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename - Fully qualified name of the file to test for 
-  ->  IO (Bool)
- -- ^ 
+{- function resourceExistsInAnyGroup -}
+resourceExistsInAnyGroup :: HG3DClass -> String -> IO (Bool)
 resourceExistsInAnyGroup a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -351,12 +252,8 @@
   return (a3'')
 {-# LINE 160 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Find the group in which a resource exists.
---
-findGroupContainingResource :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename - Fully qualified name of the file the resource should be found as 
-  ->  IO (String)
- -- ^ return value - Name of the resource group the resource was found in. An exception is thrown if the group could not be determined.     
+{- function findGroupContainingResource -}
+findGroupContainingResource :: HG3DClass -> String -> IO (String)
 findGroupContainingResource a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -366,14 +263,8 @@
   return (a3'')
 {-# LINE 166 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Delete a single resource file.
---
-deleteResource :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename - The name of the file to delete. 
-  ->  String  -- ^ groupName - The name of the group in which to search 
-  ->  String  -- ^ locationPattern - If the resource group contains multiple locations, then usually first matching file found in any location will be deleted. If you want to be more specific, you can include a location pattern here and only locations which match that pattern (as determined by StringUtil::match) will be considered candidates for deletion. 
-  ->  IO ()
- -- ^ 
+{- function deleteResource -}
+deleteResource :: HG3DClass -> String -> String -> String -> IO ()
 deleteResource a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -383,14 +274,8 @@
   return ()
 {-# LINE 173 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Delete all matching resource files.
---
-deleteMatchingResources :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filePattern - The pattern (see StringUtil::match) of the files to delete. 
-  ->  String  -- ^ groupName - The name of the group in which to search 
-  ->  String  -- ^ locationPattern - If the resource group contains multiple locations, then usually all matching files in any location will be deleted. If you want to be more specific, you can include a location pattern here and only locations which match that pattern (as determined by StringUtil::match) will be considered candidates for deletion. 
-  ->  IO ()
- -- ^ 
+{- function deleteMatchingResources -}
+deleteMatchingResources :: HG3DClass -> String -> String -> String -> IO ()
 deleteMatchingResources a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -400,12 +285,8 @@
   return ()
 {-# LINE 180 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Sets the resource group that 'world' resources will use.
---This is the group which should be used by SceneManagers implementing world geometry when looking for their resources. Defaults to the DEFAULT_RESOURCE_GROUP_NAME but this can be altered. 
-setWorldResourceGroupName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ groupName
-  ->  IO ()
- -- ^ 
+{- function setWorldResourceGroupName -}
+setWorldResourceGroupName :: HG3DClass -> String -> IO ()
 setWorldResourceGroupName a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -413,10 +294,8 @@
   return ()
 {-# LINE 185 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Gets the resource group that 'world' resources will use. 
-getWorldResourceGroupName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getWorldResourceGroupName -}
+getWorldResourceGroupName :: HG3DClass -> IO (String)
 getWorldResourceGroupName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -425,15 +304,8 @@
   return (a2'')
 {-# LINE 190 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Associates some world geometry with a resource group, causing it to 
---be loaded / unloaded with the resource group.
---You would use this method to essentially defer a call to SceneManager::setWorldGeometry
-linkWorldGeometryToResourceGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ group - The name of the resource group 
-  ->  String  -- ^ worldGeometry - The parameter which should be passed to setWorldGeometry 
-  ->  HG3DClass  -- ^ sceneManager - The SceneManager which should be called 
-  ->  IO ()
- -- ^ 
+{- function linkWorldGeometryToResourceGroup -}
+linkWorldGeometryToResourceGroup :: HG3DClass -> String -> String -> HG3DClass -> IO ()
 linkWorldGeometryToResourceGroup a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -443,12 +315,8 @@
   return ()
 {-# LINE 197 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Clear any link to world geometry from a resource group.
---Basically undoes a previous call to linkWorldGeometryToResourceGroup. 
-unlinkWorldGeometryFromResourceGroup :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ group
-  ->  IO ()
- -- ^ 
+{- function unlinkWorldGeometryFromResourceGroup -}
+unlinkWorldGeometryFromResourceGroup :: HG3DClass -> String -> IO ()
 unlinkWorldGeometryFromResourceGroup a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -456,12 +324,8 @@
   return ()
 {-# LINE 202 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- |     Checks the status of a resource group.
---Looks at the state of a resource group. If loadResourceGroup has been called for the resource group return true, otherwise return false. 
-isResourceGroupInGlobalPool :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to of the resource group to access. 
-  ->  IO (Bool)
- -- ^ 
+{- function isResourceGroupInGlobalPool -}
+isResourceGroupInGlobalPool :: HG3DClass -> String -> IO (Bool)
 isResourceGroupInGlobalPool a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -471,20 +335,16 @@
   return (a3'')
 {-# LINE 208 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Shutdown all ResourceManagers, performed as part of clean-up. 
-shutdownAll :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function shutdownAll -}
+shutdownAll :: HG3DClass -> IO ()
 shutdownAll a1 =
   withHG3DClass a1 $ \a1' -> 
   shutdownAll'_ a1' >>= \res ->
   return ()
 {-# LINE 212 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingleton -}
 getSingleton :: IO (HG3DClass)
- -- ^ 
 getSingleton =
   alloca $ \a1' -> 
   getSingleton'_ a1' >>= \res ->
@@ -492,10 +352,8 @@
   return (a1'')
 {-# LINE 216 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceGroupManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingletonPtr -}
 getSingletonPtr :: IO (HG3DClass)
- -- ^ 
 getSingletonPtr =
   alloca $ \a1' -> 
   getSingletonPtr'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassResourceManager.hs b/HGamer3D/Bindings/Ogre/ClassResourceManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassResourceManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassResourceManager.hs
@@ -48,21 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~ResourceManager -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Set a limit on the amount of memory this resource handler may use. If, when asked to load a new resource, the manager believes it will exceed this memory budget, it will temporarily unload a resource to make room for the new one. This unloading is not permanent and the Resource
-setMemoryBudget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ bytes
-  ->  IO ()
- -- ^ 
+{- function setMemoryBudget -}
+setMemoryBudget :: HG3DClass -> Int -> IO ()
 setMemoryBudget a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -70,10 +65,8 @@
   return ()
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Get the limit on the amount of memory this resource handler may use. 
-getMemoryBudget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getMemoryBudget -}
+getMemoryBudget :: HG3DClass -> IO (Int)
 getMemoryBudget a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -82,10 +75,8 @@
   return (a2'')
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Gets the current memory usage, in bytes. 
-getMemoryUsage :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getMemoryUsage -}
+getMemoryUsage :: HG3DClass -> IO (Int)
 getMemoryUsage a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -94,12 +85,8 @@
   return (a2'')
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Unloads a single resource by name.
---Unloaded resources are not removed, they simply free up their memory as much as they can and wait to be reloaded. ResourceGroupManager
-unload :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function unload -}
+unload :: HG3DClass -> String -> IO ()
 unload a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -107,12 +94,8 @@
   return ()
 {-# LINE 67 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Unloads all resources.
---Unloaded resources are not removed, they simply free up their memory as much as they can and wait to be reloaded. ResourceGroupManagerResource::isReloadable
-unloadAll :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ reloadableOnly - If true (the default), only unload the resource that is reloadable. Because some resources isn't reloadable, they will be unloaded but can't load them later. Thus, you might not want to them unloaded. Or, you might unload all of them, and then populate them manually later. 
-  ->  IO ()
- -- ^ 
+{- function unloadAll -}
+unloadAll :: HG3DClass -> Bool -> IO ()
 unloadAll a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -120,12 +103,8 @@
   return ()
 {-# LINE 72 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Caused all currently loaded resources to be reloaded.
---All resources currently being held in this manager which are also marked as currently loaded will be unloaded, then loaded again. Resource::isReloadable
-reloadAll :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ reloadableOnly - If true (the default), only reload the resource that is reloadable. Because some resources isn't reloadable, they will be unloaded but can't loaded again. Thus, you might not want to them unloaded. Or, you might unload all of them, and then populate them manually later. 
-  ->  IO ()
- -- ^ 
+{- function reloadAll -}
+reloadAll :: HG3DClass -> Bool -> IO ()
 reloadAll a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -133,12 +112,8 @@
   return ()
 {-# LINE 77 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Unload all resources which are not referenced by any other object.
---This method behaves like unloadAll, except that it only unloads resources which are not in use, ie not referenced by other objects. This allows you to free up some memory selectively whilst still keeping the group around (and the resources present, just not using much memory). Some referenced resource may exists 'weak' pointer to their sub-components (e.g. Entity
-unloadUnreferencedResources :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ reloadableOnly - If true (the default), only unloads resources which can be subsequently automatically reloaded. 
-  ->  IO ()
- -- ^ 
+{- function unloadUnreferencedResources -}
+unloadUnreferencedResources :: HG3DClass -> Bool -> IO ()
 unloadUnreferencedResources a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -146,13 +121,8 @@
   return ()
 {-# LINE 82 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Caused all currently loaded but not referenced by any other object
---resources to be reloaded.
---This method behaves like reloadAll, except that it only reloads resources which are not in use, i.e. not referenced by other objects. Some referenced resource may exists 'weak' pointer to their sub-components (e.g. Entity
-reloadUnreferencedResources :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ reloadableOnly - If true (the default), only reloads resources which can be subsequently automatically reloaded. 
-  ->  IO ()
- -- ^ 
+{- function reloadUnreferencedResources -}
+reloadUnreferencedResources :: HG3DClass -> Bool -> IO ()
 reloadUnreferencedResources a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -160,13 +130,8 @@
   return ()
 {-# LINE 87 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Remove a single resource by name.
---Removes a single resource, meaning it will be removed from the list of valid resources in this manager, also causing it to be unloaded. The word 'Destroy' is not used here, since if any other pointers are referring to this resource, it will persist until they have finished with it; however to all intents and purposes it no longer exists and will likely get destroyed imminently. 
---If you do have shared pointers to resources hanging around after the ResourceManager
-remove2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function remove2 -}
+remove2 :: HG3DClass -> String -> IO ()
 remove2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -174,24 +139,16 @@
   return ()
 {-# LINE 92 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Removes all resources.
---The word 'Destroy' is not used here, since if any other pointers are referring to these resources, they will persist until they have been finished with; however to all intents and purposes the resources no longer exist and will get destroyed imminently. 
---If you do have shared pointers to resources hanging around after the ResourceManager
-removeAll :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAll -}
+removeAll :: HG3DClass -> IO ()
 removeAll a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAll'_ a1' >>= \res ->
   return ()
 {-# LINE 96 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Remove all resources which are not referenced by any other object.
---This method behaves like removeAll, except that it only removes resources which are not in use, ie not referenced by other objects. This allows you to free up some memory selectively whilst still keeping the group around (and the resources present, just not using much memory). Some referenced resource may exists 'weak' pointer to their sub-components (e.g. Entity
-removeUnreferencedResources :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ reloadableOnly - If true (the default), only removes resources which can be subsequently automatically reloaded. 
-  ->  IO ()
- -- ^ 
+{- function removeUnreferencedResources -}
+removeUnreferencedResources :: HG3DClass -> Bool -> IO ()
 removeUnreferencedResources a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -199,11 +156,8 @@
   return ()
 {-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Returns whether the named resource exists in this manager. 
-resourceExists :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
+{- function resourceExists -}
+resourceExists :: HG3DClass -> String -> IO (Bool)
 resourceExists a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -213,11 +167,8 @@
   return (a3'')
 {-# LINE 107 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Gets the relative loading order of resources of this type.
---There are dependencies between some kinds of resource in terms of loading order, and this value enumerates that. Higher values load later during bulk loading tasks. 
-getLoadingOrder :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getLoadingOrder -}
+getLoadingOrder :: HG3DClass -> IO (Float)
 getLoadingOrder a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -226,10 +177,8 @@
   return (a2'')
 {-# LINE 112 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Gets a string identifying the type of resource this manager handles. 
-getResourceType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getResourceType -}
+getResourceType :: HG3DClass -> IO (String)
 getResourceType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -238,11 +187,8 @@
   return (a2'')
 {-# LINE 117 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Sets whether this manager and its resources habitually produce log output 
-setVerbose :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ v
-  ->  IO ()
- -- ^ 
+{- function setVerbose -}
+setVerbose :: HG3DClass -> Bool -> IO ()
 setVerbose a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -250,10 +196,8 @@
   return ()
 {-# LINE 122 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Gets whether this manager and its resources habitually produce log output 
-getVerbose :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getVerbose -}
+getVerbose :: HG3DClass -> IO (Bool)
 getVerbose a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -262,11 +206,8 @@
   return (a2'')
 {-# LINE 127 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | Destroy a resource pool. 
-destroyResourcePool2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function destroyResourcePool2 -}
+destroyResourcePool2 :: HG3DClass -> String -> IO ()
 destroyResourcePool2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -274,10 +215,8 @@
   return ()
 {-# LINE 132 ".\\HGamer3D\\Bindings\\Ogre\\ClassResourceManager.chs" #-}
 
--- | destroy all pools 
-destroyAllResourcePools :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function destroyAllResourcePools -}
+destroyAllResourcePools :: HG3DClass -> IO ()
 destroyAllResourcePools a1 =
   withHG3DClass a1 $ \a1' -> 
   destroyAllResourcePools'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassRoot.hs b/HGamer3D/Bindings/Ogre/ClassRoot.hs
--- a/HGamer3D/Bindings/Ogre/ClassRoot.hs
+++ b/HGamer3D/Bindings/Ogre/ClassRoot.hs
@@ -50,13 +50,8 @@
 import HGamer3D.Bindings.Ogre.StructColour
 {-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Constructor
---
-new :: String  -- ^ pluginFileName - The file that contains plugins information. Defaults to "plugins.cfg", may be left blank to ignore. 
-  ->  String  -- ^ configFileName - The file that contains the configuration to be loaded. Defaults to "ogre.cfg", may be left blank to load nothing. 
-  ->  String  -- ^ logFileName - The logfile to create, defaults to Ogre.log, may be left blank if you've already set up LogManager & Log yourself 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function Root -}
+new :: String -> String -> String -> IO (HG3DClass)
 new a1 a2 a3 =
   withCString a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -67,30 +62,24 @@
   return (a4'')
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Root -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 55 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Saves the details of the current configuration Stores details of the current configuration so it may be restored later on. 
-saveConfig :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function saveConfig -}
+saveConfig :: HG3DClass -> IO ()
 saveConfig a1 =
   withHG3DClass a1 $ \a1' -> 
   saveConfig'_ a1' >>= \res ->
   return ()
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Checks for saved video/sound/etc settings This method checks to see if there is a valid saved configuration from a previous run. If there is, the state of the system will be restored to that configuration.If there is no saved configuration, or if the system failed with the last config settings, false
-restoreConfig :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ return value - If a valid configuration was found,     
+{- function restoreConfig -}
+restoreConfig :: HG3DClass -> IO (Bool)
 restoreConfig a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -99,10 +88,8 @@
   return (a2'')
 {-# LINE 64 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Displays a dialog asking the user to choose system settings. This method displays the default dialog allowing the user to choose the rendering system, video mode etc. If there is are any settings saved already, they will be restored automatically before displaying the dialogue. When the user accepts a group of settings, this will automatically call Root::setRenderSystemRenderSystem::setConfigOptionRoot::saveConfigIf they clicked 'Cancel' (in which case the app should strongly consider terminating), false
-showConfigDialog :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ return value - If the user clicked 'Ok',     
+{- function showConfigDialog -}
+showConfigDialog :: HG3DClass -> IO (Bool)
 showConfigDialog a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -111,12 +98,8 @@
   return (a2'')
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Adds a new rendering subsystem to the list of available renderers. Intended for use by advanced users and plugin writers only! Calling this method with a pointer to a valid RenderSystem
---
-addRenderSystem :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ newRend
-  ->  IO ()
- -- ^ 
+{- function addRenderSystem -}
+addRenderSystem :: HG3DClass -> HG3DClass -> IO ()
 addRenderSystem a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -124,11 +107,8 @@
   return ()
 {-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Retrieve a pointer to the render system by the given name 
-getRenderSystemByName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - Name of the render system intend to retrieve. 
-  ->  IO (HG3DClass)
- -- ^ return value - A pointer to the render system,     
+{- function getRenderSystemByName -}
+getRenderSystemByName :: HG3DClass -> String -> IO (HG3DClass)
 getRenderSystemByName a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -138,11 +118,8 @@
   return (a3'')
 {-# LINE 80 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Sets the rendering subsystem to be used. This method indicates to OGRE which rendering system is to be used (e.g. Direct3D, OpenGL etc). This is called automatically by the default config dialog, and when settings are restored from a previous configuraion. If used manually it could be used to set the renderer from a custom settings dialog. Once this has been done, the renderer can be initialised using Root::initialiseThis method is also called by render systems if they are initialised directly. RenderSystem
-setRenderSystem :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ system - Pointer to the render system to use. 
-  ->  IO ()
- -- ^ 
+{- function setRenderSystem -}
+setRenderSystem :: HG3DClass -> HG3DClass -> IO ()
 setRenderSystem a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -150,10 +127,8 @@
   return ()
 {-# LINE 85 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Retrieve a pointer to the currently selected render system. 
-getRenderSystem :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getRenderSystem -}
+getRenderSystem :: HG3DClass -> IO (HG3DClass)
 getRenderSystem a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -162,13 +137,8 @@
   return (a2'')
 {-# LINE 90 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Initialises the renderer. This method can only be called after a renderer has been selected with Root::setRenderSystem
-initialise :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ autoCreateWindow - If true, a rendering window will automatically be created (saving a call to Root::createRenderWindow). The window will be created based on the options currently set on the render system. 
-  ->  String  -- ^ windowTitle
-  ->  String  -- ^ customCapabilitiesConfig
-  ->  IO (HG3DClass)
- -- ^ return value - A pointer to the automatically created window, if requested, otherwise     
+{- function initialise -}
+initialise :: HG3DClass -> Bool -> String -> String -> IO (HG3DClass)
 initialise a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -180,10 +150,8 @@
   return (a5'')
 {-# LINE 98 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Returns whether the system is initialised or not. 
-isInitialised :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isInitialised -}
+isInitialised :: HG3DClass -> IO (Bool)
 isInitialised a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -192,10 +160,8 @@
   return (a2'')
 {-# LINE 103 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Get whether the entire render queue structure should be emptied on clearing, or whether just the objects themselves should be cleared. 
-getRemoveRenderQueueStructuresOnClear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getRemoveRenderQueueStructuresOnClear -}
+getRemoveRenderQueueStructuresOnClear :: HG3DClass -> IO (Bool)
 getRemoveRenderQueueStructuresOnClear a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -204,12 +170,8 @@
   return (a2'')
 {-# LINE 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Set whether the entire render queue structure should be emptied on clearing, 
---
-setRemoveRenderQueueStructuresOnClear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ r
-  ->  IO ()
- -- ^ 
+{- function setRemoveRenderQueueStructuresOnClear -}
+setRemoveRenderQueueStructuresOnClear :: HG3DClass -> Bool -> IO ()
 setRemoveRenderQueueStructuresOnClear a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -217,13 +179,8 @@
   return ()
 {-# LINE 113 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Register a new SceneManagerFactory, a factory object for creating instances
---of specific SceneManagers. 
---Plugins should call this to register as new SceneManager
-addSceneManagerFactory :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ fact
-  ->  IO ()
- -- ^ 
+{- function addSceneManagerFactory -}
+addSceneManagerFactory :: HG3DClass -> HG3DClass -> IO ()
 addSceneManagerFactory a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -231,11 +188,8 @@
   return ()
 {-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Unregister a SceneManagerFactory
-removeSceneManagerFactory :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ fact
-  ->  IO ()
- -- ^ 
+{- function removeSceneManagerFactory -}
+removeSceneManagerFactory :: HG3DClass -> HG3DClass -> IO ()
 removeSceneManagerFactory a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -243,13 +197,8 @@
   return ()
 {-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Create a SceneManager instance of a given type.
---You can use this method to create a SceneManagerThis method throws an exception if the named type is not found. 
-createSceneManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ typeName - String identifying a unique SceneManager type 
-  ->  String  -- ^ instanceName - Optional name to given the new instance that is created. If you leave this blank, an auto name will be assigned. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createSceneManager -}
+createSceneManager :: HG3DClass -> String -> String -> IO (HG3DClass)
 createSceneManager a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -260,11 +209,8 @@
   return (a4'')
 {-# LINE 130 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Destroy an instance of a SceneManager
-destroySceneManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ sm
-  ->  IO ()
- -- ^ 
+{- function destroySceneManager -}
+destroySceneManager :: HG3DClass -> HG3DClass -> IO ()
 destroySceneManager a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -272,13 +218,8 @@
   return ()
 {-# LINE 135 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Get an existing SceneManager instance that has already been created,
---identified by the instance name.
---
-getSceneManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ instanceName - The name of the instance to retrieve. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getSceneManager -}
+getSceneManager :: HG3DClass -> String -> IO (HG3DClass)
 getSceneManager a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -288,12 +229,8 @@
   return (a3'')
 {-# LINE 141 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Determines if a given SceneManager already exists
---
-hasSceneManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ instanceName - The name of the instance to retrieve. 
-  ->  IO (Bool)
- -- ^ 
+{- function hasSceneManager -}
+hasSceneManager :: HG3DClass -> String -> IO (Bool)
 hasSceneManager a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -303,10 +240,8 @@
   return (a3'')
 {-# LINE 147 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Retrieves a reference to the current TextureManagerThis performs the same function as TextureManager::getSingletonNote that a TextureManagerOgreRenderSystemRoot::initialise
-getTextureManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getTextureManager -}
+getTextureManager :: HG3DClass -> IO (HG3DClass)
 getTextureManager a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -315,10 +250,8 @@
   return (a2'')
 {-# LINE 152 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Retrieves a reference to the current MeshManagerThis performs the same function as MeshManager::getSingleton
-getMeshManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getMeshManager -}
+getMeshManager :: HG3DClass -> IO (HG3DClass)
 getMeshManager a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -327,11 +260,8 @@
   return (a2'')
 {-# LINE 157 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Utility function for getting a better description of an error code. 
-getErrorDescription :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ errorNumber
-  ->  IO (String)
- -- ^ 
+{- function getErrorDescription -}
+getErrorDescription :: HG3DClass -> Int -> IO (String)
 getErrorDescription a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -341,34 +271,24 @@
   return (a3'')
 {-# LINE 163 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Queues the end of rendering. This method will do nothing unless startRendering()RootRoot::startRendering
-queueEndRendering :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function queueEndRendering -}
+queueEndRendering :: HG3DClass -> IO ()
 queueEndRendering a1 =
   withHG3DClass a1 $ \a1' -> 
   queueEndRendering'_ a1' >>= \res ->
   return ()
 {-# LINE 167 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Starts / restarts the automatic rendering cycle. This method begins the automatic rendering of the scene. It will NOTDuring rendering, any FrameListener classes registered using addFrameListener will be called back for each frame that is to be rendered, These classes can tell OGRE to halt the rendering if required, which will cause this method to return. 
---RenderTarget::updateRoot::renderOneFrame
---This frees up the CPU to do other things in between refreshes, since in this case frame rate is less important. 
---This method can only be called after Root::initialise
-startRendering :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function startRendering -}
+startRendering :: HG3DClass -> IO ()
 startRendering a1 =
   withHG3DClass a1 $ \a1' -> 
   startRendering'_ a1' >>= \res ->
   return ()
 {-# LINE 171 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Render one frame. 
---Updates all the render targets automatically and then returns, raising frame events before and after. 
-renderOneFrame :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function renderOneFrame -}
+renderOneFrame :: HG3DClass -> IO (Bool)
 renderOneFrame a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -377,12 +297,8 @@
   return (a2'')
 {-# LINE 176 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Render one frame, with custom frame time information. 
---Updates all the render targets automatically and then returns, raising frame events before and after - all per-frame times are based on the time value you pass in. 
-renderOneFrame2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ timeSinceLastFrame
-  ->  IO (Bool)
- -- ^ 
+{- function renderOneFrame2 -}
+renderOneFrame2 :: HG3DClass -> Float -> IO (Bool)
 renderOneFrame2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -392,24 +308,16 @@
   return (a3'')
 {-# LINE 182 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Shuts down the system manually. This is normally done by OgreOgre
-shutdown :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function shutdown -}
+shutdown :: HG3DClass -> IO ()
 shutdown a1 =
   withHG3DClass a1 $ \a1' -> 
   shutdown'_ a1' >>= \res ->
   return ()
 {-# LINE 186 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Adds a location to the list of searchable locations for a ResourceResourceLocations can be folders, compressed archives, even perhaps remote locations. Facilities for loading from different locations are provided by plugins which provide implementations of the ArchiveOgreYou can also supply the name of a resource group which should have this location applied to it. The ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAMEArchive
-addResourceLocation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the location, e.g. './data' or '/compressed/gamedata.zip' 
-  ->  String  -- ^ locType - A string identifying the location type, e.g. 'FileSystem' (for folders), 'Zip' etc. Must map to a registered plugin which deals with this type (FileSystem and Zip should always be available) 
-  ->  String  -- ^ groupName - Type of name of the resource group which this location should apply to; defaults to the General group which applies to all non-specific resources. 
-  ->  Bool  -- ^ recursive - If the resource location has a concept of recursive directory traversal, enabling this option will mean you can load resources in subdirectories using only their unqualified name. The default is to disable this so that resources in subdirectories with the same name are still unique. 
-  ->  IO ()
- -- ^ 
+{- function addResourceLocation -}
+addResourceLocation :: HG3DClass -> String -> String -> String -> Bool -> IO ()
 addResourceLocation a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -420,13 +328,8 @@
   return ()
 {-# LINE 194 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Removes a resource location from the list.
---addResourceLocation
-removeResourceLocation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the resource location as specified in addResourceLocation 
-  ->  String  -- ^ groupName - The name of the resource group to which this location was assigned. 
-  ->  IO ()
- -- ^ 
+{- function removeResourceLocation -}
+removeResourceLocation :: HG3DClass -> String -> String -> IO ()
 removeResourceLocation a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -435,13 +338,8 @@
   return ()
 {-# LINE 200 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Generates a packed data version of the passed in ColourValue suitable for
---use with the current RenderSystem.
---Since different render systems have different colour data formats (eg RGBA for GL, ARGB for D3D) this method allows you to use 1 method for all. 
-convertColourValue :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ colour - The colour to convert 
-  ->  IO (Int)
- -- ^ pDest - Pointer to location to put the result. 
+{- function convertColourValue -}
+convertColourValue :: HG3DClass -> Colour -> IO (Int)
 convertColourValue a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -451,10 +349,8 @@
   return (a3'')
 {-# LINE 206 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Retrieves a pointer to the window that was created automatically When Rootreturns a null pointer when Root
-getAutoCreatedWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAutoCreatedWindow -}
+getAutoCreatedWindow :: HG3DClass -> IO (HG3DClass)
 getAutoCreatedWindow a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -463,12 +359,8 @@
   return (a2'')
 {-# LINE 211 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Detaches a RenderTarget from the active render system
---If the render target cannot be found, NULL is returned. 
-detachRenderTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ pWin
-  ->  IO (HG3DClass)
- -- ^ 
+{- function detachRenderTarget -}
+detachRenderTarget :: HG3DClass -> HG3DClass -> IO (HG3DClass)
 detachRenderTarget a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -478,12 +370,8 @@
   return (a3'')
 {-# LINE 217 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Detaches a named RenderTarget from the active render system
---If the render target cannot be found, NULL is returned. 
-detachRenderTarget2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function detachRenderTarget2 -}
+detachRenderTarget2 :: HG3DClass -> String -> IO (HG3DClass)
 detachRenderTarget2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -493,11 +381,8 @@
   return (a3'')
 {-# LINE 223 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Destroys the given RenderTarget
-destroyRenderTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ target
-  ->  IO ()
- -- ^ 
+{- function destroyRenderTarget -}
+destroyRenderTarget :: HG3DClass -> HG3DClass -> IO ()
 destroyRenderTarget a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -505,11 +390,8 @@
   return ()
 {-# LINE 228 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Destroys the given named RenderTarget
-destroyRenderTarget2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function destroyRenderTarget2 -}
+destroyRenderTarget2 :: HG3DClass -> String -> IO ()
 destroyRenderTarget2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -517,11 +399,8 @@
   return ()
 {-# LINE 233 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Retrieves a pointer to a named render target. 
-getRenderTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getRenderTarget -}
+getRenderTarget :: HG3DClass -> String -> IO (HG3DClass)
 getRenderTarget a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -531,12 +410,8 @@
   return (a3'')
 {-# LINE 239 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Manually load a Plugin contained in a DLL / DSO.
---Plugins embedded in DLLs can be loaded at startup using the plugin configuration file specified when you create RootRoot::installPluginRoot::unloadPlugin
-loadPlugin :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ pluginName - Name of the plugin library to load 
-  ->  IO ()
- -- ^ 
+{- function loadPlugin -}
+loadPlugin :: HG3DClass -> String -> IO ()
 loadPlugin a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -544,12 +419,8 @@
   return ()
 {-# LINE 244 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Manually unloads a Plugin contained in a DLL / DSO.
---Plugin DLLs are unloaded at shutdown automatically. This method allows you to unload plugins in code, but make sure their dependencies are decoupled first. This method will call the dllStopPlugin method defined in the DLL, which in turn should call Root::uninstallPlugin
-unloadPlugin :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ pluginName - Name of the plugin library to unload 
-  ->  IO ()
- -- ^ 
+{- function unloadPlugin -}
+unloadPlugin :: HG3DClass -> String -> IO ()
 unloadPlugin a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -557,12 +428,8 @@
   return ()
 {-# LINE 249 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Destroy a RenderQueueInvocationSequence. 
---You must ensure that no Viewports are using this sequence. 
-destroyRenderQueueInvocationSequence :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to identify the sequence 
-  ->  IO ()
- -- ^ 
+{- function destroyRenderQueueInvocationSequence -}
+destroyRenderQueueInvocationSequence :: HG3DClass -> String -> IO ()
 destroyRenderQueueInvocationSequence a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -570,34 +437,24 @@
   return ()
 {-# LINE 254 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Destroy all RenderQueueInvocationSequences. 
---You must ensure that no Viewports are using custom sequences. 
-destroyAllRenderQueueInvocationSequences :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function destroyAllRenderQueueInvocationSequences -}
+destroyAllRenderQueueInvocationSequences :: HG3DClass -> IO ()
 destroyAllRenderQueueInvocationSequences a1 =
   withHG3DClass a1 $ \a1' -> 
   destroyAllRenderQueueInvocationSequences'_ a1' >>= \res ->
   return ()
 {-# LINE 258 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Clears the history of all event times. 
---OGRE stores a history of the last few event times in order to smooth out any inaccuracies and temporary fluctuations. However, if you pause or don't render for a little while this can cause a lurch, so if you're resuming rendering after a break, call this method to reset the stored times 
-clearEventTimes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function clearEventTimes -}
+clearEventTimes :: HG3DClass -> IO ()
 clearEventTimes a1 =
   withHG3DClass a1 $ \a1' -> 
   clearEventTimes'_ a1' >>= \res ->
   return ()
 {-# LINE 262 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Sets the period over which OGRE smooths out fluctuations in frame times.
---OGRE by default gives you the raw frame time, but can optionally smooths it out over several frames, in order to reduce the noticeable effect of occasional hiccups in framerate. These smoothed values are passed back as parameters to FrameListener calls. This method allow you to tweak the smoothing period, and is expressed in seconds. Setting it to 0 will result in completely unsmoothed frame times (the default). 
-setFrameSmoothingPeriod :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ period
-  ->  IO ()
- -- ^ 
+{- function setFrameSmoothingPeriod -}
+setFrameSmoothingPeriod :: HG3DClass -> Float -> IO ()
 setFrameSmoothingPeriod a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -605,10 +462,8 @@
   return ()
 {-# LINE 267 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Gets the period over which OGRE smooths out fluctuations in frame times. 
-getFrameSmoothingPeriod :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getFrameSmoothingPeriod -}
+getFrameSmoothingPeriod :: HG3DClass -> IO (Float)
 getFrameSmoothingPeriod a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -617,14 +472,8 @@
   return (a2'')
 {-# LINE 272 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Register a new MovableObjectFactory which will create new MovableObject
---instances of a particular type, as identified by the getType() method.
---Plugin creators can create subclasses of MovableObjectFactoryMovableObject
-addMovableObjectFactory :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ fact - Pointer to the factory instance 
-  ->  Bool  -- ^ overrideExisting - Set this to true to override any existing factories which are registered for the same type. You should only change this if you are very sure you know what you're doing. 
-  ->  IO ()
- -- ^ 
+{- function addMovableObjectFactory -}
+addMovableObjectFactory :: HG3DClass -> HG3DClass -> Bool -> IO ()
 addMovableObjectFactory a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -633,12 +482,8 @@
   return ()
 {-# LINE 278 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Removes a previously registered MovableObjectFactory.
---All instances of objects created by this factory will be destroyed before removing the factory (by calling back the factories 'destroyInstance' method). The plugin writer is responsible for actually destroying the factory. 
-removeMovableObjectFactory :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ fact
-  ->  IO ()
- -- ^ 
+{- function removeMovableObjectFactory -}
+removeMovableObjectFactory :: HG3DClass -> HG3DClass -> IO ()
 removeMovableObjectFactory a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -646,11 +491,8 @@
   return ()
 {-# LINE 283 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Checks whether a factory is registered for a given MovableObject
-hasMovableObjectFactory :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ typeName
-  ->  IO (Bool)
- -- ^ 
+{- function hasMovableObjectFactory -}
+hasMovableObjectFactory :: HG3DClass -> String -> IO (Bool)
 hasMovableObjectFactory a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -660,11 +502,8 @@
   return (a3'')
 {-# LINE 289 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Get a MovableObjectFactory
-getMovableObjectFactory :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ typeName
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getMovableObjectFactory -}
+getMovableObjectFactory :: HG3DClass -> String -> IO (HG3DClass)
 getMovableObjectFactory a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -674,10 +513,8 @@
   return (a3'')
 {-# LINE 295 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Gets the number of display monitors. 
-getDisplayMonitorCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getDisplayMonitorCount -}
+getDisplayMonitorCount :: HG3DClass -> IO (Int)
 getDisplayMonitorCount a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -686,15 +523,8 @@
   return (a2'')
 {-# LINE 300 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Sets whether blend indices information needs to be passed to the GPU.
---When entities use software animation they remove blend information such as
---indices and weights from the vertex buffers sent to the graphic card. This function
---can be used to limit which information is removed.
---
-setBlendIndicesGpuRedundant :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ redundant - Set to true to remove blend indices information. 
-  ->  IO ()
- -- ^ 
+{- function setBlendIndicesGpuRedundant -}
+setBlendIndicesGpuRedundant :: HG3DClass -> Bool -> IO ()
 setBlendIndicesGpuRedundant a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -702,11 +532,8 @@
   return ()
 {-# LINE 305 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Returns whether blend indices information needs to be passed to the GPU
---setBlendIndicesGpuRedundant()
-isBlendIndicesGpuRedundant :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isBlendIndicesGpuRedundant -}
+isBlendIndicesGpuRedundant :: HG3DClass -> IO (Bool)
 isBlendIndicesGpuRedundant a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -715,12 +542,8 @@
   return (a2'')
 {-# LINE 310 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Sets whether blend weights information needs to be passed to the GPU.
---
-setBlendWeightsGpuRedundant :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ redundant - Set to true to remove blend weights information. 
-  ->  IO ()
- -- ^ 
+{- function setBlendWeightsGpuRedundant -}
+setBlendWeightsGpuRedundant :: HG3DClass -> Bool -> IO ()
 setBlendWeightsGpuRedundant a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -728,11 +551,8 @@
   return ()
 {-# LINE 315 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Returns whether blend weights information needs to be passed to the GPU
---setBlendWeightsGpuRedundant()
-isBlendWeightsGpuRedundant :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isBlendWeightsGpuRedundant -}
+isBlendWeightsGpuRedundant :: HG3DClass -> IO (Bool)
 isBlendWeightsGpuRedundant a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -741,12 +561,8 @@
   return (a2'')
 {-# LINE 320 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Set the default minimum pixel size for object to be rendered by
---To use this feature see Camera::setUseMinPixelSize()
-setDefaultMinPixelSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ pixelSize
-  ->  IO ()
- -- ^ 
+{- function setDefaultMinPixelSize -}
+setDefaultMinPixelSize :: HG3DClass -> Float -> IO ()
 setDefaultMinPixelSize a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -754,10 +570,8 @@
   return ()
 {-# LINE 325 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Get the default minimum pixel size for object to be rendered by 
-getDefaultMinPixelSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getDefaultMinPixelSize -}
+getDefaultMinPixelSize :: HG3DClass -> IO (Float)
 getDefaultMinPixelSize a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -766,9 +580,8 @@
   return (a2'')
 {-# LINE 330 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Override standard Singleton retrieval. Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingleton -}
 getSingleton :: IO (HG3DClass)
- -- ^ 
 getSingleton =
   alloca $ \a1' -> 
   getSingleton'_ a1' >>= \res ->
@@ -776,9 +589,8 @@
   return (a1'')
 {-# LINE 334 ".\\HGamer3D\\Bindings\\Ogre\\ClassRoot.chs" #-}
 
--- | Override standard Singleton retrieval. Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingletonPtr -}
 getSingletonPtr :: IO (HG3DClass)
- -- ^ 
 getSingletonPtr =
   alloca $ \a1' -> 
   getSingletonPtr'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassSceneManager.hs b/HGamer3D/Bindings/Ogre/ClassSceneManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassSceneManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassSceneManager.hs
@@ -60,2216 +60,1660 @@
 import HGamer3D.Bindings.Ogre.EnumLightType
 {-# LINE 48 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
 
--- | Default destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
-delete a1 =
-  withHG3DClass a1 $ \a1' -> 
-  delete'_ a1' >>= \res ->
-  return ()
-{-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Mutex to protect the scene graph from simultaneous access from
---multiple threads.
---If you are updating the scene in a separate thread from the rendering thread, then you should lock this mutex before making any changes to the scene graph - that means creating, modifying or deleting a scene node, or attaching / detaching objects. It is yourNote that locking this mutex will prevent the scene being rendered until it is unlocked again. Therefore you should do this sparingly. Try to create any objects you need separately and fully prepare them before doing all your scene graph work in one go, thus keeping this lock for the shortest time possible. A single global lock is used rather than a per-node lock since it keeps the number of locks required during rendering down to a minimum. Obtaining a lock, even if there is no contention, is not free so for performance it is good to do it as little as possible. Since modifying the scene in a separate thread is a fairly rare occurrence (relative to rendering), it is better to keep the locking required during rendering lower than to make update locks more granular.Return the instance name of this SceneManager
-getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
-getName a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloc64k $ \a2' -> 
-  getName'_ a1' a2' >>= \res ->
-  peekCString  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 58 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Retrieve the type name of this scene manager.
---This method has to be implemented by subclasses. It should return the type name of this SceneManagerSceneManagerFactory
-getTypeName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
-getTypeName a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloc64k $ \a2' -> 
-  getTypeName'_ a1' a2' >>= \res ->
-  peekCString  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 63 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Creates a camera to be managed by this scene manager. This camera must be added to the scene at a later time using the attachObject method of the SceneNode
-createCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - Name to give the new camera. 
-  ->  IO (HG3DClass)
- -- ^ 
-createCamera a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  createCamera'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Retrieves a pointer to the named camera.
---Throws an exception if the named instance does not exist 
-getCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
-getCamera a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  getCamera'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 75 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a camera with the given name exists. 
-hasCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasCamera a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasCamera'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes a camera from the scene. This method removes a previously added camera from the scene. The camera is deleted so the caller must ensure no references to it's previous instance (e.g. in a SceneNode
-destroyCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ cam - Pointer to the camera to remove 
-  ->  IO ()
- -- ^ 
-destroyCamera a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  destroyCamera'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 86 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes a camera from the scene. This method removes an camera from the scene based on the camera's name rather than a pointer. 
-destroyCamera2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyCamera2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyCamera2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 91 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes (and destroys) all cameras from the scene. Some cameras are internal created to dealing with texture shadow, their aren't supposed to destroy outside. So, while you are using texture shadow, don't call this method, or you can set the shadow technique other than texture-based, which will destroy all internal created shadow cameras and textures. 
-destroyAllCameras :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllCameras a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllCameras'_ a1' >>= \res ->
-  return ()
-{-# LINE 95 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Creates a light for use in the scene. Lights can either be in a fixed position and independent of the scene graph, or they can be attached to SceneNodes so they derive their position from the parent node. Either way, they are created using this method so that the SceneManager
-createLight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the new light, to identify it later. 
-  ->  IO (HG3DClass)
- -- ^ 
-createLight a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  createLight'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Creates a light with a generated name. 
-createLight2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-createLight2 a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  createLight2'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns a pointer to the named Light which has previously been added to the scene.
---Throws an exception if the named instance does not exist 
-getLight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
-getLight a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  getLight'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 112 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a light with the given name exists. 
-hasLight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasLight a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasLight'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes the named light from the scene and destroys it. Any pointers held to this light after calling this method will be invalid. 
-destroyLight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyLight a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyLight'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes the light from the scene and destroys it based on a pointer. Any pointers held to this light after calling this method will be invalid. 
-destroyLight2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ light
-  ->  IO ()
- -- ^ 
-destroyLight2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  destroyLight2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes and destroys all lights in the scene. 
-destroyAllLights :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllLights a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllLights'_ a1' >>= \res ->
-  return ()
-{-# LINE 132 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Creates an instance of a SceneNodeNote that this does not add the SceneNodeSceneManagerTo include the returned SceneNodeSceneNodeNote that this method takes no parameters, and the node created is unnamed (it is actually given a generated name, which you can retrieve if you want). If you wish to create a node with a specific name, call the alternative method which takes a name parameter. 
-createSceneNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-createSceneNode a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  createSceneNode'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 137 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Creates an instance of a SceneNodeNote that this does not add the SceneNodeSceneManagerTo include the returned SceneNodeSceneNodeNote that this method takes a name parameter, which makes the node easier to retrieve directly again later. 
-createSceneNode2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
-createSceneNode2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  createSceneNode2'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 143 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Destroys a SceneNode with a given name.
---This allows you to physically delete an individual SceneNodeSceneManager
-destroySceneNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroySceneNode a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroySceneNode'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 148 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Destroys a SceneNode.
---This allows you to physically delete an individual SceneNodeSceneManager
-destroySceneNode2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ sn
-  ->  IO ()
- -- ^ 
-destroySceneNode2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  destroySceneNode2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 153 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets the SceneNodeThe entire scene is held as a hierarchy of nodes, which allows things like relative transforms, general changes in rendering state etc (See the SceneNodeSceneManagerOgreHowever, in all cases there is only ever one root node of the hierarchy, and this method returns a pointer to it. 
-getRootSceneNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-getRootSceneNode a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getRootSceneNode'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 158 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Retrieves a named SceneNode from the scene graph.
---If you chose to name a SceneNodeThrows an exception if the named instance does not exist 
-getSceneNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
-getSceneNode a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  getSceneNode'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 164 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a scene node with the given name exists. 
-hasSceneNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasSceneNode a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasSceneNode'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 170 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create an Entity
-createEntity :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ entityName - The name to be given to the entity (must be unique). 
-  ->  String  -- ^ meshName - The name of the Mesh it is to be based on (e.g. 'knot.oof'). The mesh will be loaded if it is not already. 
-  ->  String  -- ^ groupName
-  ->  IO (HG3DClass)
- -- ^ 
-createEntity a1 a2 a3 a4 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  withCString a3 $ \a3' -> 
-  withCString a4 $ \a4' -> 
-  alloca $ \a5' -> 
-  createEntity'_ a1' a2' a3' a4' a5' >>= \res ->
-  peek  a5'>>= \a5'' -> 
-  return (a5'')
-{-# LINE 178 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create an Entity
-createEntity2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ entityName - The name to be given to the entity (must be unique). 
-  ->  SharedPtr  -- ^ pMesh - The pointer to the Mesh it is to be based on. 
-  ->  IO (HG3DClass)
- -- ^ 
-createEntity2 a1 a2 a3 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  withSharedPtr a3 $ \a3' -> 
-  alloca $ \a4' -> 
-  createEntity2'_ a1' a2' a3' a4' >>= \res ->
-  peek  a4'>>= \a4'' -> 
-  return (a4'')
-{-# LINE 185 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create an Entity
-createEntity3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ meshName - The name of the Mesh it is to be based on (e.g. 'knot.oof'). The mesh will be loaded if it is not already. 
-  ->  IO (HG3DClass)
- -- ^ 
-createEntity3 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  createEntity3'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 191 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create an Entity
-createEntity4 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  SharedPtr  -- ^ pMesh - The pointer to the Mesh it is to be based on. 
-  ->  IO (HG3DClass)
- -- ^ 
-createEntity4 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withSharedPtr a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  createEntity4'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 197 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create an Entity
-createEntity5 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ entityName - The name to be given to the entity (must be unique). 
-  ->  EnumSceneManagerPrefabType  -- ^ ptype - The prefab type. 
-  ->  IO (HG3DClass)
- -- ^ 
-createEntity5 a1 a2 a3 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  let {a3' = cIntFromEnum a3} in 
-  alloca $ \a4' -> 
-  createEntity5'_ a1' a2' a3' a4' >>= \res ->
-  peek  a4'>>= \a4'' -> 
-  return (a4'')
-{-# LINE 204 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create an Entity
-createEntity6 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumSceneManagerPrefabType  -- ^ ptype - The prefab type. 
-  ->  IO (HG3DClass)
- -- ^ 
-createEntity6 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = cIntFromEnum a2} in 
-  alloca $ \a3' -> 
-  createEntity6'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 210 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Retrieves a pointer to the named Entity. 
---Throws an exception if the named instance does not exist 
-getEntity :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
-getEntity a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  getEntity'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 216 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether an entity with the given name exists. 
-hasEntity :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasEntity a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasEntity'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 222 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys an EntitySceneManagerMust only be done if the EntitySceneNodeSceneManager::clearScene
-destroyEntity :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ ent
-  ->  IO ()
- -- ^ 
-destroyEntity a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  destroyEntity'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 227 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys an EntitySceneManagerMust only be done if the EntitySceneNodeSceneManager::clearScene
-destroyEntity2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyEntity2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyEntity2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 232 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys all Entities. Again, use caution since no EntitySceneNodeSceneNodeSceneManager::clearScene
-destroyAllEntities :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllEntities a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllEntities'_ a1' >>= \res ->
-  return ()
-{-# LINE 236 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create a ManualObject, an object which you populate with geometry
---manually through a GL immediate-mode style interface.
---
-createManualObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to be given to the object (must be unique). 
-  ->  IO (HG3DClass)
- -- ^ 
-createManualObject a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  createManualObject'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 242 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create a ManualObject, an object which you populate with geometry
---
-createManualObject2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-createManualObject2 a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  createManualObject2'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 247 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Retrieves a pointer to the named ManualObject. 
---Throws an exception if the named instance does not exist 
-getManualObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
-getManualObject a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  getManualObject'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 253 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a manual object with the given name exists. 
-hasManualObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasManualObject a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasManualObject'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 259 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys a ManualObjectSceneManager
-destroyManualObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
-destroyManualObject a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  destroyManualObject'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 264 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys a ManualObjectSceneManager
-destroyManualObject2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyManualObject2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyManualObject2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 269 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys all ManualObjects from the SceneManager
-destroyAllManualObjects :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllManualObjects a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllManualObjects'_ a1' >>= \res ->
-  return ()
-{-# LINE 273 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create a BillboardChain, an object which you can use to render
---a linked chain of billboards.
---
-createBillboardChain :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to be given to the object (must be unique). 
-  ->  IO (HG3DClass)
- -- ^ 
-createBillboardChain a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  createBillboardChain'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 279 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create a BillboardChain, an object which you can use to render
---
-createBillboardChain2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-createBillboardChain2 a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  createBillboardChain2'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 284 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Retrieves a pointer to the named BillboardChain. 
---Throws an exception if the named instance does not exist 
-getBillboardChain :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
-getBillboardChain a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  getBillboardChain'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 290 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a billboard chain with the given name exists. 
-hasBillboardChain :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasBillboardChain a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasBillboardChain'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 296 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys a BillboardChainSceneManager
-destroyBillboardChain :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
-destroyBillboardChain a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  destroyBillboardChain'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 301 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys a BillboardChainSceneManager
-destroyBillboardChain2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyBillboardChain2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyBillboardChain2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 306 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys all BillboardChains from the SceneManager
-destroyAllBillboardChains :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllBillboardChains a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllBillboardChains'_ a1' >>= \res ->
-  return ()
-{-# LINE 310 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a ribbon trail with the given name exists. 
-hasRibbonTrail :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasRibbonTrail a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasRibbonTrail'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 316 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys a RibbonTrail from the SceneManager
-destroyRibbonTrail2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyRibbonTrail2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyRibbonTrail2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 321 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys all RibbonTrails from the SceneManager
-destroyAllRibbonTrails :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllRibbonTrails a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllRibbonTrails'_ a1' >>= \res ->
-  return ()
-{-# LINE 325 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a particle system with the given name exists. 
-hasParticleSystem :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasParticleSystem a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasParticleSystem'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 331 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys a ParticleSystem from the SceneManager
-destroyParticleSystem2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyParticleSystem2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyParticleSystem2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 336 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys all ParticleSystems from the SceneManager
-destroyAllParticleSystems :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllParticleSystems a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllParticleSystems'_ a1' >>= \res ->
-  return ()
-{-# LINE 340 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Empties the entire scene, inluding all SceneNodes, Entities, Lights, BillboardSets etc. Cameras are not deleted at this stage since they are still referenced by viewports, which are not destroyed during this process. 
-clearScene :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-clearScene a1 =
-  withHG3DClass a1 $ \a1' -> 
-  clearScene'_ a1' >>= \res ->
-  return ()
-{-# LINE 344 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the ambient light level to be used for the scene. This sets the colour and intensity of the ambient light in the scene, i.e. the light which is 'sourceless' and illuminates all objects equally. The colour of an object is affected by a combination of the light in the scene, and the amount of light that object reflects (in this case based on the Material::ambient property). 
---By default the ambient light in the scene is ColourValue::Black, i.e. no ambient light. This means that any objects rendered with a MaterialMaterial::setLightingEnabled
-setAmbientLight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ colour
-  ->  IO ()
- -- ^ 
-setAmbientLight a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withColour a2 $ \a2' -> 
-  setAmbientLight'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 349 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns the ambient light level to be used for the scene. 
-getAmbientLight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Colour)
- -- ^ 
-getAmbientLight a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getAmbientLight'_ a1' a2' >>= \res ->
-  peekColour  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 354 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the source of the 'world' geometry, i.e. the large, mainly static geometry making up the world e.g. rooms, landscape etc. This function can be called before setWorldGeometry in a background thread, do to some slow tasks (e.g. IO) that do not involve the backend render system. Depending on the type of SceneManagerRootSceneManager
-prepareWorldGeometry :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  IO ()
- -- ^ 
-prepareWorldGeometry a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  prepareWorldGeometry'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 359 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the source of the 'world' geometry, i.e. the large, mainly static geometry making up the world e.g. rooms, landscape etc. Depending on the type of SceneManagerRootSceneManager
-setWorldGeometry :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  IO ()
- -- ^ 
-setWorldGeometry a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  setWorldGeometry'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 364 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Estimate the number of loading stages required to load the named
---world geometry. 
---This method should be overridden by SceneManagers that provide custom world geometry that can take some time to load. They should return from this method a count of the number of stages of progress they can report on whilst loading. During real loading (setWorldGeometry), they should call ResourceGroupManager::_notifyWorldGeometryProgress exactly that number of times when loading the geometry for real. The default is to return 0, ie to not report progress. 
-estimateWorldGeometry :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ filename
-  ->  IO (Int)
- -- ^ 
-estimateWorldGeometry a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  estimateWorldGeometry'_ a1' a2' a3' >>= \res ->
-  peekIntConv  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 370 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Method for verifying wether the scene manager has an implementation-specific option. If it does not, false is returned. 
-hasOption :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ strKey - The name of the option to check for. 
-  ->  IO (Bool)
- -- ^ return value - If the scene manager contains the given option, true is returned.     
-hasOption a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasOption'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 376 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Enables / disables a 'sky plane' 
-setSkyPlaneEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enable
-  ->  IO ()
- -- ^ 
-setSkyPlaneEnabled a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setSkyPlaneEnabled'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 381 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Return whether a key plane is enabled 
-isSkyPlaneEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isSkyPlaneEnabled a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isSkyPlaneEnabled'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 386 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get the sky plane node, if enabled. 
-getSkyPlaneNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-getSkyPlaneNode a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getSkyPlaneNode'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 391 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Enables / disables a 'sky box' i.e. a 6-sided box at constant distance from the camera representing the sky. You could create a sky box yourself using the standard mesh and entity methods, but this creates a plane which the camera can never get closer or further away from - it moves with the camera. (NB you could create this effect by creating a world box which was attached to the same SceneNodeCameraThe material you use for the skybox can either contain layers which are single textures, or they can be cubic textures, i.e. made up of 6 images, one for each plane of the cube. See the TextureUnitState class for more information. 
-setSkyBox :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enable - True to enable the skybox, false to disable it 
-  ->  String  -- ^ materialName - The name of the material the box will use 
-  ->  Float  -- ^ distance - Distance in world coorinates from the camera to each plane of the box. The default is normally OK. 
-  ->  Bool  -- ^ drawFirst - If true, the box is drawn before all other geometry in the scene, without updating the depth buffer. This is the safest rendering method since all other objects will always appear in front of the sky. However this is not the most efficient way if most of the sky is often occluded by other objects. If this is the case, you can set this parameter to false meaning it draws after all other geometry which can be an optimisation - however you must ensure that the distance value is large enough that no objects will 'poke through' the sky box when it is rendered. 
-  ->  Quaternion  -- ^ orientation - Optional parameter to specify the orientation of the box. By default the 'top' of the box is deemed to be in the +y direction, and the 'front' at the -z direction. You can use this parameter to rotate the sky if you want. 
-  ->  String  -- ^ groupName - The name of the resource group to which to assign the plane mesh. 
-  ->  IO ()
- -- ^ 
-setSkyBox a1 a2 a3 a4 a5 a6 a7 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  withCString a3 $ \a3' -> 
-  let {a4' = realToFrac a4} in 
-  let {a5' = fromBool a5} in 
-  withQuaternion a6 $ \a6' -> 
-  withCString a7 $ \a7' -> 
-  setSkyBox'_ a1' a2' a3' a4' a5' a6' a7' >>= \res ->
-  return ()
-{-# LINE 401 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Enables / disables a 'sky box' 
-setSkyBoxEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enable
-  ->  IO ()
- -- ^ 
-setSkyBoxEnabled a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setSkyBoxEnabled'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 406 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Return whether a skybox is enabled 
-isSkyBoxEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isSkyBoxEnabled a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isSkyBoxEnabled'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 411 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get the skybox node, if enabled. 
-getSkyBoxNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-getSkyBoxNode a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getSkyBoxNode'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 416 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Enables / disables a 'sky dome' i.e. an illusion of a curved sky. A sky dome is actually formed by 5 sides of a cube, but with texture coordinates generated such that the surface appears curved like a dome. Sky domes are appropriate where you need a realistic looking sky where the scene is not going to be 'fogged', and there is always a 'floor' of some sort to prevent the viewer looking below the horizon (the distortion effect below the horizon can be pretty horrible, and there is never anyhting directly below the viewer). If you need a complete wrap-around background, use the setSkyBox method instead. You can actually combine a sky box and a sky dome if you want, to give a positional backdrop with an overlayed curved cloud layer. Sky domes work well with 2D repeating textures like clouds. You can change the apparent 'curvature' of the sky depending on how your scene is viewed - lower curvatures are better for 'open' scenes like landscapes, whilst higher curvatures are better for say FPS levels where you don't see a lot of the sky at once and the exaggerated curve looks good. 
-setSkyDome :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enable - True to enable the skydome, false to disable it 
-  ->  String  -- ^ materialName - The name of the material the dome will use 
-  ->  Float  -- ^ curvature - The curvature of the dome. Good values are between 2 and 65. Higher values are more curved leading to a smoother effect, lower values are less curved meaning more distortion at the horizons but a better distance effect. 
-  ->  Float  -- ^ tiling - How many times to tile the texture(s) across the dome. 
-  ->  Float  -- ^ distance - Distance in world coorinates from the camera to each plane of the box the dome is rendered on. The default is normally OK. 
-  ->  Bool  -- ^ drawFirst - If true, the dome is drawn before all other geometry in the scene, without updating the depth buffer. This is the safest rendering method since all other objects will always appear in front of the sky. However this is not the most efficient way if most of the sky is often occluded by other objects. If this is the case, you can set this parameter to false meaning it draws after all other geometry which can be an optimisation - however you must ensure that the distance value is large enough that no objects will 'poke through' the sky when it is rendered. 
-  ->  Quaternion  -- ^ orientation - Optional parameter to specify the orientation of the dome. By default the 'top' of the dome is deemed to be in the +y direction, and the 'front' at the -z direction. You can use this parameter to rotate the sky if you want. 
-  ->  Int  -- ^ xsegments
-  ->  Int  -- ^ ysegments
-  ->  Int  -- ^ ysegments_keep
-  ->  String  -- ^ groupName - The name of the resource group to which to assign the plane mesh. 
-  ->  IO ()
- -- ^ 
-setSkyDome a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  withCString a3 $ \a3' -> 
-  let {a4' = realToFrac a4} in 
-  let {a5' = realToFrac a5} in 
-  let {a6' = realToFrac a6} in 
-  let {a7' = fromBool a7} in 
-  withQuaternion a8 $ \a8' -> 
-  let {a9' = fromIntegral a9} in 
-  let {a10' = fromIntegral a10} in 
-  let {a11' = fromIntegral a11} in 
-  withCString a12 $ \a12' -> 
-  setSkyDome'_ a1' a2' a3' a4' a5' a6' a7' a8' a9' a10' a11' a12' >>= \res ->
-  return ()
-{-# LINE 431 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Enables / disables a 'sky dome' 
-setSkyDomeEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enable
-  ->  IO ()
- -- ^ 
-setSkyDomeEnabled a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setSkyDomeEnabled'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 436 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Return whether a skydome is enabled 
-isSkyDomeEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isSkyDomeEnabled a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isSkyDomeEnabled'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 441 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get the sky dome node, if enabled. 
-getSkyDomeNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-getSkyDomeNode a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getSkyDomeNode'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 446 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns the fog colour for the scene. 
-getFogColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Colour)
- -- ^ 
-getFogColour a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getFogColour'_ a1' a2' >>= \res ->
-  peekColour  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 451 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns the fog start distance for the scene. 
-getFogStart :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
-getFogStart a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getFogStart'_ a1' a2' >>= \res ->
-  peekFloatConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 456 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns the fog end distance for the scene. 
-getFogEnd :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
-getFogEnd a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getFogEnd'_ a1' a2' >>= \res ->
-  peekFloatConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 461 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns the fog density for the scene. 
-getFogDensity :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
-getFogDensity a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getFogDensity'_ a1' a2' >>= \res ->
-  peekFloatConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 466 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Creates a new BillboardSetThis method creates a new BillboardSetSceneManagerSceneManagerSceneManager::clearSceneSee the BillboardSetBillboardSet
-createBillboardSet :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to give to this billboard set. Must be unique. 
-  ->  Int  -- ^ poolSize - The initial size of the pool of billboards (see BillboardSet for more information) 
-  ->  IO (HG3DClass)
- -- ^ 
-createBillboardSet a1 a2 a3 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  let {a3' = fromIntegral a3} in 
-  alloca $ \a4' -> 
-  createBillboardSet'_ a1' a2' a3' a4' >>= \res ->
-  peek  a4'>>= \a4'' -> 
-  return (a4'')
-{-# LINE 473 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Creates a new BillboardSetBillboardSet
-createBillboardSet2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ poolSize - The initial size of the pool of billboards (see BillboardSet for more information) 
-  ->  IO (HG3DClass)
- -- ^ 
-createBillboardSet2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromIntegral a2} in 
-  alloca $ \a3' -> 
-  createBillboardSet2'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 479 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Retrieves a pointer to the named BillboardSet.
---Throws an exception if the named instance does not exist 
-getBillboardSet :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
-getBillboardSet a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  getBillboardSet'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 485 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a billboardset with the given name exists. 
-hasBillboardSet :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasBillboardSet a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasBillboardSet'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 491 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys an BillboardSetSceneManagerMust only be done if the BillboardSetSceneNode
-destroyBillboardSet :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ set
-  ->  IO ()
- -- ^ 
-destroyBillboardSet a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  destroyBillboardSet'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 496 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys an BillboardSetSceneManagerMust only be done if the BillboardSetSceneNode
-destroyBillboardSet2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyBillboardSet2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyBillboardSet2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 501 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes & destroys all BillboardSets.
---Again, use caution since no BillboardSetSceneNodeSceneNodeSceneManager::clearScene
-destroyAllBillboardSets :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllBillboardSets a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllBillboardSets'_ a1' >>= \res ->
-  return ()
-{-# LINE 505 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Tells the SceneManager whether it should render the SceneNodes which 
---make up the scene as well as the objects in the scene.
---This method is mainly for debugging purposes. If you set this to 'true', each node will be rendered as a set of 3 axes to allow you to easily see the orientation of the nodes. 
-setDisplaySceneNodes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ display
-  ->  IO ()
- -- ^ 
-setDisplaySceneNodes a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setDisplaySceneNodes'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 510 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns true if all scene nodes axis are to be displayed 
-getDisplaySceneNodes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-getDisplaySceneNodes a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getDisplaySceneNodes'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 515 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Creates an animation which can be used to animate scene nodes.
---An animation is a collection of 'tracks' which over time change the position / orientation of NodeSceneNodeYou don't need to use an AnimationNodeA single animation can affect multiple NodeAnimationTrackNodeNodeSkeleton::createAnimationNote that whilst it uses the same classes, the animations created here are kept separate from the skeletal animations of meshes (each Skeleton
-createAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the animation, must be unique within this SceneManager. 
-  ->  Float  -- ^ length - The total length of the animation. 
-  ->  IO (HG3DClass)
- -- ^ 
-createAnimation a1 a2 a3 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  let {a3' = realToFrac a3} in 
-  alloca $ \a4' -> 
-  createAnimation'_ a1' a2' a3' a4' >>= \res ->
-  peek  a4'>>= \a4'' -> 
-  return (a4'')
-{-# LINE 522 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Looks up an Animation object previously created with createAnimation. 
---Throws an exception if the named instance does not exist 
-getAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
-getAnimation a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  getAnimation'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 528 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether an animation with the given name exists. 
-hasAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasAnimation a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasAnimation'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 534 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Destroys an Animation. 
---You should ensure that none of your code is referencing this animation objects since the memory will be freed. 
-destroyAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyAnimation a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyAnimation'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 539 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes all animations created using this SceneManager
-destroyAllAnimations :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllAnimations a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllAnimations'_ a1' >>= \res ->
-  return ()
-{-# LINE 543 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Create an AnimationState object for managing application of animations.
---You can create AnimationSceneNodeNodeAnimationNode::resetToInitialStateAnimation::applyAnimationStateSceneManagerRemember, AnimationStateNote that any SceneNodeNode::setInitialStateNodeSceneNodeIf the target of your animation is to be a generic AnimableValueAnimableValue::setAsBaseValue
-createAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ animName - The name of an animation created already with createAnimation. 
-  ->  IO (HG3DClass)
- -- ^ 
-createAnimationState a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  createAnimationState'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 549 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Retrieves animation state as previously created using createAnimationState. 
---Throws an exception if the named instance does not exist 
-getAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ animName
-  ->  IO (HG3DClass)
- -- ^ 
-getAnimationState a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  getAnimationState'_ a1' a2' a3' >>= \res ->
-  peek  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 555 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether an animation state with the given name exists. 
-hasAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasAnimationState a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasAnimationState'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 561 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Destroys an AnimationState. 
---You should ensure that none of your code is referencing this animation state object since the memory will be freed. 
-destroyAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyAnimationState a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyAnimationState'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 566 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Removes all animation states created using this SceneManager
-destroyAllAnimationStates :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllAnimationStates a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllAnimationStates'_ a1' >>= \res ->
-  return ()
-{-# LINE 570 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Clears the 'special case' render queue list.
---SceneManager::addSpecialCaseRenderQueue
-clearSpecialCaseRenderQueues :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-clearSpecialCaseRenderQueues a1 =
-  withHG3DClass a1 $ \a1' -> 
-  clearSpecialCaseRenderQueues'_ a1' >>= \res ->
-  return ()
-{-# LINE 574 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the way the special case render queue list is processed.
---SceneManager::addSpecialCaseRenderQueue
-setSpecialCaseRenderQueueMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumSceneManagerSpecialCaseRenderQueueMode  -- ^ mode - The mode of processing 
-  ->  IO ()
- -- ^ 
-setSpecialCaseRenderQueueMode a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = cIntFromEnum a2} in 
-  setSpecialCaseRenderQueueMode'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 579 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets the way the special case render queue list is processed. 
-getSpecialCaseRenderQueueMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumSceneManagerSpecialCaseRenderQueueMode)
- -- ^ 
-getSpecialCaseRenderQueueMode a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getSpecialCaseRenderQueueMode'_ a1' a2' >>= \res ->
-  peekEnumUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 584 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Allows all bounding boxes of scene nodes to be displayed. 
-showBoundingBoxes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ bShow
-  ->  IO ()
- -- ^ 
-showBoundingBoxes a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  showBoundingBoxes'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 589 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns if all bounding boxes of scene nodes are to be displayed 
-getShowBoundingBoxes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-getShowBoundingBoxes a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShowBoundingBoxes'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 594 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Enables / disables the rendering of debug information for shadows. 
-setShowDebugShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ debug
-  ->  IO ()
- -- ^ 
-setShowDebugShadows a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setShowDebugShadows'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 599 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Are debug shadows shown? 
-getShowDebugShadows :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-getShowDebugShadows a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShowDebugShadows'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 604 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Set the colour used to modulate areas in shadow. 
---This is only applicable for shadow techniques which involve darkening the area in shadow, as opposed to masking out the light. This colour provided is used as a modulative value to darken the areas. 
-setShadowColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ colour
-  ->  IO ()
- -- ^ 
-setShadowColour a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withColour a2 $ \a2' -> 
-  setShadowColour'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 609 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get the colour used to modulate areas in shadow. 
---This is only applicable for shadow techniques which involve darkening the area in shadow, as opposed to masking out the light. This colour provided is used as a modulative value to darken the areas. 
-getShadowColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Colour)
- -- ^ 
-getShadowColour a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowColour'_ a1' a2' >>= \res ->
-  peekColour  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 614 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the distance a shadow volume is extruded for a directional light.
---Although directional lights are essentially infinite, there are many reasons to limit the shadow extrusion distance to a finite number, not least of which is compatibility with older cards (which do not support infinite positions), and shadow caster elimination. The default value is 10,000 world units. This does not apply to point lights or spotlights, since they extrude up to their attenuation range. 
-setShadowDirectionalLightExtrusionDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ dist
-  ->  IO ()
- -- ^ 
-setShadowDirectionalLightExtrusionDistance a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = realToFrac a2} in 
-  setShadowDirectionalLightExtrusionDistance'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 619 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets the distance a shadow volume is extruded for a directional light. 
-getShadowDirectionalLightExtrusionDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
-getShadowDirectionalLightExtrusionDistance a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowDirectionalLightExtrusionDistance'_ a1' a2' >>= \res ->
-  peekFloatConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 624 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the default maximum distance away from the camera that shadows
---Shadow techniques can be expensive, therefore it is a good idea to limit them to being rendered close to the camera if possible, and to skip the expense of rendering shadows for distance objects. This method allows you to set the distance at which shadows will no longer be rendered. Each shadow technique can interpret this subtely differently. For example, one technique may use this to eliminate casters, another might use it to attenuate the shadows themselves. You should tweak this value to suit your chosen shadow technique and scene setup. 
-setShadowFarDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ distance
-  ->  IO ()
- -- ^ 
-setShadowFarDistance a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = realToFrac a2} in 
-  setShadowFarDistance'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 629 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets the default maximum distance away from the camera that shadows
---
-getShadowFarDistance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
-getShadowFarDistance a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowFarDistance'_ a1' a2' >>= \res ->
-  peekFloatConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 634 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | 
-getShadowFarDistanceSquared :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
-getShadowFarDistanceSquared a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowFarDistanceSquared'_ a1' a2' >>= \res ->
-  peekFloatConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 639 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the maximum size of the index buffer used to render shadow
---primitives.
---This method allows you to tweak the size of the index buffer used to render shadow primitives (including stencil shadow volumes). The default size is 51,200 entries, which is 100k of GPU memory, or enough to render approximately 17,000 triangles. You can reduce this as long as you do not have any models / world geometry chunks which could require more than the amount you set. The maximum number of triangles required to render a single shadow volume (including light and dark caps when needed) will be 3x the number of edges on the light silhouette, plus the number of light-facing triangles. On average, half the triangles will be facing toward the light, but the number of triangles in the silhouette entirely depends on the mesh - angular meshes will have a higher silhouette tris/mesh tris ratio than a smooth mesh. You can estimate the requirements for your particular mesh by rendering it alone in a scene with shadows enabled and a single light - rotate it or the light and make a note of how high the triangle count goes (remembering to subtract the mesh triangle count) 
-setShadowIndexBufferSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ size - The number of indexes; divide this by 3 to determine the number of triangles. 
-  ->  IO ()
- -- ^ 
-setShadowIndexBufferSize a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromIntegral a2} in 
-  setShadowIndexBufferSize'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 644 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get the size of the shadow index buffer. 
-getShadowIndexBufferSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
-getShadowIndexBufferSize a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowIndexBufferSize'_ a1' a2' >>= \res ->
-  peekIntConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 649 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Set the size of the texture used for all texture-based shadows.
---The larger the shadow texture, the better the detail on texture based shadows, but obviously this takes more memory. The default size is 512. Sizes must be a power of 2. This is the simple form, see setShadowTextureConfig for the more complex form. 
-setShadowTextureSize :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ size
-  ->  IO ()
- -- ^ 
-setShadowTextureSize a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromIntegral a2} in 
-  setShadowTextureSize'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 654 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Set the level of multisample AA of the textures used for texture-based shadows.
---By default, the level of multisample AA is zero. This is the simple form, see setShadowTextureConfig for the more complex form. 
-setShadowTextureFSAA :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ fsaa
-  ->  IO ()
- -- ^ 
-setShadowTextureFSAA a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromIntegral a2} in 
-  setShadowTextureFSAA'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 659 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Set the number of textures allocated for texture-based shadows.
---The default number of textures assigned to deal with texture based shadows is 1; however this means you can only have one light casting shadows at the same time. You can increase this number in order to make this more flexible, but be aware of the texture memory it will use. 
-setShadowTextureCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ count
-  ->  IO ()
- -- ^ 
-setShadowTextureCount a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromIntegral a2} in 
-  setShadowTextureCount'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 664 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get the number of the textures allocated for texture based shadows. 
-getShadowTextureCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
-getShadowTextureCount a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowTextureCount'_ a1' a2' >>= \res ->
-  peekIntConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 669 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Set the number of shadow textures a light type uses.
---The default for all light types is 1. This means that each light uses only 1 shadow texture. Call this if you need more than 1 shadow texture per light, E.G. PSSM. This feature only works with the Integrated shadow technique. Also remember to increase the total number of shadow textures you request appropriately (e.g. via setShadowTextureCount)!! 
-setShadowTextureCountPerLightType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumLightType  -- ^ type
-  ->  Int  -- ^ count
-  ->  IO ()
- -- ^ 
-setShadowTextureCountPerLightType a1 a2 a3 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = cIntFromEnum a2} in 
-  let {a3' = fromIntegral a3} in 
-  setShadowTextureCountPerLightType'_ a1' a2' a3' >>= \res ->
-  return ()
-{-# LINE 675 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get the number of shadow textures is assigned for the given light type. 
-getShadowTextureCountPerLightType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumLightType  -- ^ type
-  ->  IO (Int)
- -- ^ 
-getShadowTextureCountPerLightType a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = cIntFromEnum a2} in 
-  alloca $ \a3' -> 
-  getShadowTextureCountPerLightType'_ a1' a2' a3' >>= \res ->
-  peekIntConv  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 681 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get a reference to the shadow texture currently in use at the given index.
---If you change shadow settings, this reference may no longer be correct, so be sure not to hold the returned reference over texture shadow configuration changes. 
-getShadowTexture :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ shadowIndex
-  ->  IO (SharedPtr)
- -- ^ 
-getShadowTexture a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromIntegral a2} in 
-  alloca $ \a3' -> 
-  getShadowTexture'_ a1' a2' a3' >>= \res ->
-  peekSharedPtr  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 687 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the proportional distance which a texture shadow which is generated from a
---directional light will be offset into the camera view to make best use of texture space.
---When generating a shadow texture from a directional light, an approximation is used since it is not possible to render the entire scene to one texture. The texture is projected onto an area centred on the camera, and is the shadow far distance * 2 in length (it is square). This wastes a lot of texture space outside the frustum though, so this offset allows you to move the texture in front of the camera more. However, be aware that this can cause a little shadow 'jittering' during rotation, and that if you move it too far then you'll start to get artefacts close to the camera. The value is represented as a proportion of the shadow far distance, and the default is 0.6. 
-setShadowDirLightTextureOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ offset
-  ->  IO ()
- -- ^ 
-setShadowDirLightTextureOffset a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = realToFrac a2} in 
-  setShadowDirLightTextureOffset'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 692 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets the proportional distance which a texture shadow which is generated from a
---
-getShadowDirLightTextureOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
-getShadowDirLightTextureOffset a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowDirLightTextureOffset'_ a1' a2' >>= \res ->
-  peekFloatConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 697 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the proportional distance at which texture shadows begin to fade out.
---To hide the edges where texture shadows end (in directional lights) Ogre
-setShadowTextureFadeStart :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ fadeStart
-  ->  IO ()
- -- ^ 
-setShadowTextureFadeStart a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = realToFrac a2} in 
-  setShadowTextureFadeStart'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 702 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the proportional distance at which texture shadows finish to fading out.
---To hide the edges where texture shadows end (in directional lights) Ogre
-setShadowTextureFadeEnd :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ fadeEnd
-  ->  IO ()
- -- ^ 
-setShadowTextureFadeEnd a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = realToFrac a2} in 
-  setShadowTextureFadeEnd'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 707 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets whether or not texture shadows should attempt to self-shadow.
---The default implementation of texture shadows uses a fixed-function colour texture projection approach for maximum compatibility, and as such cannot support self-shadowing. However, if you decide to implement a more complex shadowing technique using the setShadowTextureCasterMaterial and setShadowTextureReceiverMaterial there is a possibility you may be able to support self-shadowing (e.g by implementing a shader-based shadow map). In this case you might want to enable this option. 
-setShadowTextureSelfShadow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ selfShadow - Whether to attempt self-shadowing with texture shadows 
-  ->  IO ()
- -- ^ 
-setShadowTextureSelfShadow a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setShadowTextureSelfShadow'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 712 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets whether or not texture shadows attempt to self-shadow. 
-getShadowTextureSelfShadow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-getShadowTextureSelfShadow a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowTextureSelfShadow'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 717 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the default material to use for rendering shadow casters.
---By default shadow casters are rendered into the shadow texture using an automatically generated fixed-function pass. This allows basic projective texture shadows, but it's possible to use more advanced shadow techniques by overriding the caster and receiver materials, for example providing vertex and fragment programs to implement shadow maps. You can rely on the ambient light in the scene being set to the requested texture shadow colour, if that's useful. Individual objects may also override the vertex program in your default material if their materials include shadow_caster_vertex_program_ref, shadow_receiver_vertex_program_ref shadow_caster_material entries, so if you use both make sure they are compatible. 
---Only a single pass is allowed in your material, although multiple techniques may be used for hardware fallback. 
-setShadowTextureCasterMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-setShadowTextureCasterMaterial a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  setShadowTextureCasterMaterial'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 722 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets the default material to use for rendering shadow receivers.
---By default shadow receivers are rendered as a post-pass using basic modulation. This allows basic projective texture shadows, but it's possible to use more advanced shadow techniques by overriding the caster and receiver materials, for example providing vertex and fragment programs to implement shadow maps. You can rely on texture unit 0 containing the shadow texture, and for the unit to be set to use projective texturing from the light (only useful if you're using fixed-function, which is unlikely; otherwise you should rely on the texture_viewproj_matrix auto binding) Individual objects may also override the vertex program in your default material if their materials include shadow_caster_vertex_program_ref shadow_receiver_vertex_program_ref shadow_receiver_material entries, so if you use both make sure they are compatible. 
---Only a single pass is allowed in your material, although multiple techniques may be used for hardware fallback. 
-setShadowTextureReceiverMaterial :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-setShadowTextureReceiverMaterial a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  setShadowTextureReceiverMaterial'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 727 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets whether or not shadow casters should be rendered into shadow
---textures using their back faces rather than their front faces. 
---Rendering back faces rather than front faces into a shadow texture can help minimise depth comparison issues, if you're using depth shadowmapping. You will probably still need some biasing but you won't need as much. For solid objects the result is the same anyway, if you have objects with holes you may want to turn this option off. The default is to enable this option. 
-setShadowCasterRenderBackFaces :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ bf
-  ->  IO ()
- -- ^ 
-setShadowCasterRenderBackFaces a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setShadowCasterRenderBackFaces'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 732 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets whether or not shadow casters should be rendered into shadow textures using their back faces rather than their front faces. 
-getShadowCasterRenderBackFaces :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-getShadowCasterRenderBackFaces a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowCasterRenderBackFaces'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 737 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets whether we should use an inifinite camera far plane
---when rendering stencil shadows.
---Stencil shadow coherency is very reliant on the shadow volume not being clipped by the far plane. If this clipping happens, you get a kind of 'negative' shadow effect. The best way to achieve coherency is to move the far plane of the camera out to infinity, thus preventing the far plane from clipping the shadow volumes. When combined with vertex program extrusion of the volume to infinity, which OgreOgreIf you disable infinite projection, or it is not available, you need to be far more careful with your light attenuation / directional light extrusion distances to avoid clipping artefacts at the far plane. Recent cards will generally support infinite far plane projection. However, we have found some cases where they do not, especially on Direct3D. There is no standard capability we can check to validate this, so we use some heuristics based on experience: 
---
---
---
---
---
---
---
---
---RenderSystem
-setShadowUseInfiniteFarPlane :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enable
-  ->  IO ()
- -- ^ 
-setShadowUseInfiniteFarPlane a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setShadowUseInfiniteFarPlane'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 742 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Is there a stencil shadow based shadowing technique in use? 
-isShadowTechniqueStencilBased :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isShadowTechniqueStencilBased a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isShadowTechniqueStencilBased'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 747 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Is there a texture shadow based shadowing technique in use? 
-isShadowTechniqueTextureBased :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isShadowTechniqueTextureBased a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isShadowTechniqueTextureBased'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 752 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Is there a modulative shadowing technique in use? 
-isShadowTechniqueModulative :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isShadowTechniqueModulative a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isShadowTechniqueModulative'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 757 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Is there an additive shadowing technique in use? 
-isShadowTechniqueAdditive :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isShadowTechniqueAdditive a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isShadowTechniqueAdditive'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 762 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Is the shadow technique integrated into primary materials? 
-isShadowTechniqueIntegrated :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isShadowTechniqueIntegrated a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isShadowTechniqueIntegrated'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 767 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Is there any shadowing technique in use? 
-isShadowTechniqueInUse :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isShadowTechniqueInUse a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isShadowTechniqueInUse'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 772 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets whether when using a built-in additive shadow mode, user clip planes should be used to restrict light rendering. 
-setShadowUseLightClipPlanes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled
-  ->  IO ()
- -- ^ 
-setShadowUseLightClipPlanes a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setShadowUseLightClipPlanes'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 777 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets whether when using a built-in additive shadow mode, user clip
---
-getShadowUseLightClipPlanes :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-getShadowUseLightClipPlanes a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getShadowUseLightClipPlanes'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 782 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets whether to use late material resolving or not. If set, materials will be resolved from the materials at the pass-setting stage and not at the render queue building stage. This is useful when the active material scheme during the render queue building stage is different from the one during the rendering stage. 
-setLateMaterialResolving :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ isLate
-  ->  IO ()
- -- ^ 
-setLateMaterialResolving a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setLateMaterialResolving'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 787 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets whether using late material resolving or not. setLateMaterialResolving
-isLateMaterialResolving :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-isLateMaterialResolving a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  isLateMaterialResolving'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 792 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a static geometry instance with the given name exists. 
-hasStaticGeometry :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
-hasStaticGeometry a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasStaticGeometry'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 798 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Remove & destroy a StaticGeometry instance. 
-destroyStaticGeometry2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyStaticGeometry2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyStaticGeometry2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 803 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Remove & destroy all StaticGeometry instances. 
-destroyAllStaticGeometry :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllStaticGeometry a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllStaticGeometry'_ a1' >>= \res ->
-  return ()
-{-# LINE 807 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Remove & destroy a InstancedGeometry instance. 
-destroyInstancedGeometry2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyInstancedGeometry2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyInstancedGeometry2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 812 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Remove & destroy all InstancedGeometry instances. 
-destroyAllInstancedGeometry :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllInstancedGeometry a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllInstancedGeometry'_ a1' >>= \res ->
-  return ()
-{-# LINE 816 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether an InstanceManager with the given name exists. 
-hasInstanceManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ managerName
-  ->  IO (Bool)
- -- ^ 
-hasInstanceManager a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  alloca $ \a3' -> 
-  hasInstanceManager'_ a1' a2' a3' >>= \res ->
-  peekBoolUtil  a3'>>= \a3'' -> 
-  return (a3'')
-{-# LINE 822 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Destroys an InstanceManager <b>if</b> it was created with createInstanceManager()
---Be sure you don't have any InstancedEntity referenced somewhere which was created with this manager, since it will become a dangling pointer. 
-destroyInstanceManager :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
-destroyInstanceManager a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyInstanceManager'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 827 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | 
-destroyAllInstanceManagers :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllInstanceManagers a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllInstanceManagers'_ a1' >>= \res ->
-  return ()
-{-# LINE 831 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Destroys a MovableObject with the name specified, of the type specified.
---The MovableObject
-destroyMovableObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  String  -- ^ typeName
-  ->  IO ()
- -- ^ 
-destroyMovableObject a1 a2 a3 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  withCString a3 $ \a3' -> 
-  destroyMovableObject'_ a1' a2' a3' >>= \res ->
-  return ()
-{-# LINE 837 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Destroys a MovableObject.
---The MovableObject
-destroyMovableObject2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ m
-  ->  IO ()
- -- ^ 
-destroyMovableObject2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  destroyMovableObject2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 842 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Destroy all MovableObjects of a given type. 
-destroyAllMovableObjectsByType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ typeName
-  ->  IO ()
- -- ^ 
-destroyAllMovableObjectsByType a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  destroyAllMovableObjectsByType'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 847 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Destroy all MovableObjects. 
-destroyAllMovableObjects :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
-destroyAllMovableObjects a1 =
-  withHG3DClass a1 $ \a1' -> 
-  destroyAllMovableObjects'_ a1' >>= \res ->
-  return ()
-{-# LINE 851 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get a reference to a previously created MovableObject. 
---Throws an exception if the named instance does not exist 
-getMovableObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  String  -- ^ typeName
-  ->  IO (HG3DClass)
- -- ^ 
-getMovableObject a1 a2 a3 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  withCString a3 $ \a3' -> 
-  alloca $ \a4' -> 
-  getMovableObject'_ a1' a2' a3' a4' >>= \res ->
-  peek  a4'>>= \a4'' -> 
-  return (a4'')
-{-# LINE 858 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Returns whether a movable object instance with the given name exists. 
-hasMovableObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  String  -- ^ typeName
-  ->  IO (Bool)
- -- ^ 
-hasMovableObject a1 a2 a3 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  withCString a3 $ \a3' -> 
-  alloca $ \a4' -> 
-  hasMovableObject'_ a1' a2' a3' a4' >>= \res ->
-  peekBoolUtil  a4'>>= \a4'' -> 
-  return (a4'')
-{-# LINE 865 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Inject a MovableObject instance created externally.
---This method 'injects' a MovableObjectMovableObjectSceneManagerMovableObjectMovableObjectIt is important that the MovableObject
-injectMovableObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ m
-  ->  IO ()
- -- ^ 
-injectMovableObject a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  injectMovableObject'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 870 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Extract a previously injected MovableObject.
---Essentially this does the same as destroyMovableObject, but only removes the instance from the internal lists, it does not attempt to destroy it. 
-extractMovableObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  String  -- ^ typeName
-  ->  IO ()
- -- ^ 
-extractMovableObject a1 a2 a3 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  withCString a3 $ \a3' -> 
-  extractMovableObject'_ a1' a2' a3' >>= \res ->
-  return ()
-{-# LINE 876 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Extract a previously injected MovableObject.
---Essentially this does the same as destroyMovableObject, but only removes the instance from the internal lists, it does not attempt to destroy it. 
-extractMovableObject2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ m
-  ->  IO ()
- -- ^ 
-extractMovableObject2 a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withHG3DClass a2 $ \a2' -> 
-  extractMovableObject2'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 881 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Extract all injected MovableObjects of a given type.
---Essentially this does the same as destroyAllMovableObjectsByType, but only removes the instances from the internal lists, it does not attempt to destroy them. 
-extractAllMovableObjectsByType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ typeName
-  ->  IO ()
- -- ^ 
-extractAllMovableObjectsByType a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  withCString a2 $ \a2' -> 
-  extractAllMovableObjectsByType'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 886 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets a mask which is bitwise 'and'ed with objects own visibility masks
---to determine if the object is visible.
---Note that this is combined with any per-viewport visibility mask through an 'and' operation. Viewport::setVisibilityMask
-setVisibilityMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ vmask
-  ->  IO ()
- -- ^ 
-setVisibilityMask a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromIntegral a2} in 
-  setVisibilityMask'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 891 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets a mask which is bitwise 'and'ed with objects own visibility masks to determine if the object is visible. 
-getVisibilityMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
-getVisibilityMask a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getVisibilityMask'_ a1' a2' >>= \res ->
-  peekIntConv  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 896 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Sets whether the SceneManager should search for visible objects, or
---whether they are being manually handled.
---This is an advanced function, you should not use this unless you know what you are doing. 
-setFindVisibleObjects :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ find
-  ->  IO ()
- -- ^ 
-setFindVisibleObjects a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setFindVisibleObjects'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 901 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets whether the SceneManager
-getFindVisibleObjects :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-getFindVisibleObjects a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getFindVisibleObjects'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 906 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Set whether to automatically normalise normals on objects whenever they
---are scaled.
---Scaling can distort normals so the default behaviour is to compensate for this, but it has a cost. If you would prefer to manually manage this, set this option to 'false' and use Pass::setNormaliseNormals only when needed. 
-setNormaliseNormalsOnScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ n
-  ->  IO ()
- -- ^ 
-setNormaliseNormalsOnScale a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setNormaliseNormalsOnScale'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 911 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get whether to automatically normalise normals on objects whenever they are scaled. 
-getNormaliseNormalsOnScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-getNormaliseNormalsOnScale a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getNormaliseNormalsOnScale'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 916 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Set whether to automatically flip the culling mode on objects whenever they
---are negatively scaled.
---Negativelyl scaling an object has the effect of flipping the triangles, so the culling mode should probably be inverted to deal with this. If you would prefer to manually manage this, set this option to 'false' and use different materials with Pass::setCullingMode set manually as needed. 
-setFlipCullingOnNegativeScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ n
-  ->  IO ()
- -- ^ 
-setFlipCullingOnNegativeScale a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setFlipCullingOnNegativeScale'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 921 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get whether to automatically flip the culling mode on objects whenever they are negatively scaled. 
-getFlipCullingOnNegativeScale :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
-getFlipCullingOnNegativeScale a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getFlipCullingOnNegativeScale'_ a1' a2' >>= \res ->
-  peekBoolUtil  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 926 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get the rendersystem subclass to which the output of this Scene Manager gets sent 
-getDestinationRenderSystem :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-getDestinationRenderSystem a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getDestinationRenderSystem'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 931 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Gets the current viewport being rendered (advanced use only, only valid during viewport update. 
-getCurrentViewport :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
-getCurrentViewport a1 =
-  withHG3DClass a1 $ \a1' -> 
-  alloca $ \a2' -> 
-  getCurrentViewport'_ a1' a2' >>= \res ->
-  peek  a2'>>= \a2'' -> 
-  return (a2'')
-{-# LINE 936 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Set whether to use camera-relative co-ordinates when rendering, ie
---to always place the camera at the origin and move the world around it.
---This is a technique to alleviate some of the precision issues associated with rendering far from the origin, where single-precision floats as used in most GPUs begin to lose their precision. Instead of including the camera translation in the view matrix, it only includes the rotation, and the world matrices of objects must be expressed relative to this. If you need this option, you will probably also need to enable double-precision mode in Ogre
-setCameraRelativeRendering :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ rel
-  ->  IO ()
- -- ^ 
-setCameraRelativeRendering a1 a2 =
-  withHG3DClass a1 $ \a1' -> 
-  let {a2' = fromBool a2} in 
-  setCameraRelativeRendering'_ a1' a2' >>= \res ->
-  return ()
-{-# LINE 941 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
-
--- | Get whether to use camera-relative co-ordinates when rendering, ie to always place the camera at the origin and move the world around it. 
-getCameraRelativeRendering :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function ~SceneManager -}
+delete :: HG3DClass -> IO ()
+delete a1 =
+  withHG3DClass a1 $ \a1' -> 
+  delete'_ a1' >>= \res ->
+  return ()
+{-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getName -}
+getName :: HG3DClass -> IO (String)
+getName a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloc64k $ \a2' -> 
+  getName'_ a1' a2' >>= \res ->
+  peekCString  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 58 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getTypeName -}
+getTypeName :: HG3DClass -> IO (String)
+getTypeName a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloc64k $ \a2' -> 
+  getTypeName'_ a1' a2' >>= \res ->
+  peekCString  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 63 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createCamera -}
+createCamera :: HG3DClass -> String -> IO (HG3DClass)
+createCamera a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  createCamera'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getCamera -}
+getCamera :: HG3DClass -> String -> IO (HG3DClass)
+getCamera a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  getCamera'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 75 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasCamera -}
+hasCamera :: HG3DClass -> String -> IO (Bool)
+hasCamera a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasCamera'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 81 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyCamera -}
+destroyCamera :: HG3DClass -> HG3DClass -> IO ()
+destroyCamera a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  destroyCamera'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 86 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyCamera2 -}
+destroyCamera2 :: HG3DClass -> String -> IO ()
+destroyCamera2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyCamera2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 91 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllCameras -}
+destroyAllCameras :: HG3DClass -> IO ()
+destroyAllCameras a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllCameras'_ a1' >>= \res ->
+  return ()
+{-# LINE 95 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createLight -}
+createLight :: HG3DClass -> String -> IO (HG3DClass)
+createLight a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  createLight'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 101 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createLight2 -}
+createLight2 :: HG3DClass -> IO (HG3DClass)
+createLight2 a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  createLight2'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 106 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getLight -}
+getLight :: HG3DClass -> String -> IO (HG3DClass)
+getLight a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  getLight'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 112 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasLight -}
+hasLight :: HG3DClass -> String -> IO (Bool)
+hasLight a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasLight'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyLight -}
+destroyLight :: HG3DClass -> String -> IO ()
+destroyLight a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyLight'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyLight2 -}
+destroyLight2 :: HG3DClass -> HG3DClass -> IO ()
+destroyLight2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  destroyLight2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllLights -}
+destroyAllLights :: HG3DClass -> IO ()
+destroyAllLights a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllLights'_ a1' >>= \res ->
+  return ()
+{-# LINE 132 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createSceneNode -}
+createSceneNode :: HG3DClass -> IO (HG3DClass)
+createSceneNode a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  createSceneNode'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 137 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createSceneNode2 -}
+createSceneNode2 :: HG3DClass -> String -> IO (HG3DClass)
+createSceneNode2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  createSceneNode2'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 143 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroySceneNode -}
+destroySceneNode :: HG3DClass -> String -> IO ()
+destroySceneNode a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroySceneNode'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 148 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroySceneNode2 -}
+destroySceneNode2 :: HG3DClass -> HG3DClass -> IO ()
+destroySceneNode2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  destroySceneNode2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 153 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getRootSceneNode -}
+getRootSceneNode :: HG3DClass -> IO (HG3DClass)
+getRootSceneNode a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getRootSceneNode'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 158 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getSceneNode -}
+getSceneNode :: HG3DClass -> String -> IO (HG3DClass)
+getSceneNode a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  getSceneNode'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 164 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasSceneNode -}
+hasSceneNode :: HG3DClass -> String -> IO (Bool)
+hasSceneNode a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasSceneNode'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 170 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createEntity -}
+createEntity :: HG3DClass -> String -> String -> String -> IO (HG3DClass)
+createEntity a1 a2 a3 a4 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withCString a3 $ \a3' -> 
+  withCString a4 $ \a4' -> 
+  alloca $ \a5' -> 
+  createEntity'_ a1' a2' a3' a4' a5' >>= \res ->
+  peek  a5'>>= \a5'' -> 
+  return (a5'')
+{-# LINE 178 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createEntity2 -}
+createEntity2 :: HG3DClass -> String -> SharedPtr -> IO (HG3DClass)
+createEntity2 a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withSharedPtr a3 $ \a3' -> 
+  alloca $ \a4' -> 
+  createEntity2'_ a1' a2' a3' a4' >>= \res ->
+  peek  a4'>>= \a4'' -> 
+  return (a4'')
+{-# LINE 185 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createEntity3 -}
+createEntity3 :: HG3DClass -> String -> IO (HG3DClass)
+createEntity3 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  createEntity3'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 191 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createEntity4 -}
+createEntity4 :: HG3DClass -> SharedPtr -> IO (HG3DClass)
+createEntity4 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withSharedPtr a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  createEntity4'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 197 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createEntity5 -}
+createEntity5 :: HG3DClass -> String -> EnumSceneManagerPrefabType -> IO (HG3DClass)
+createEntity5 a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  let {a3' = cIntFromEnum a3} in 
+  alloca $ \a4' -> 
+  createEntity5'_ a1' a2' a3' a4' >>= \res ->
+  peek  a4'>>= \a4'' -> 
+  return (a4'')
+{-# LINE 204 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createEntity6 -}
+createEntity6 :: HG3DClass -> EnumSceneManagerPrefabType -> IO (HG3DClass)
+createEntity6 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = cIntFromEnum a2} in 
+  alloca $ \a3' -> 
+  createEntity6'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 210 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getEntity -}
+getEntity :: HG3DClass -> String -> IO (HG3DClass)
+getEntity a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  getEntity'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 216 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasEntity -}
+hasEntity :: HG3DClass -> String -> IO (Bool)
+hasEntity a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasEntity'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 222 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyEntity -}
+destroyEntity :: HG3DClass -> HG3DClass -> IO ()
+destroyEntity a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  destroyEntity'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 227 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyEntity2 -}
+destroyEntity2 :: HG3DClass -> String -> IO ()
+destroyEntity2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyEntity2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 232 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllEntities -}
+destroyAllEntities :: HG3DClass -> IO ()
+destroyAllEntities a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllEntities'_ a1' >>= \res ->
+  return ()
+{-# LINE 236 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createManualObject -}
+createManualObject :: HG3DClass -> String -> IO (HG3DClass)
+createManualObject a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  createManualObject'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 242 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createManualObject2 -}
+createManualObject2 :: HG3DClass -> IO (HG3DClass)
+createManualObject2 a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  createManualObject2'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 247 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getManualObject -}
+getManualObject :: HG3DClass -> String -> IO (HG3DClass)
+getManualObject a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  getManualObject'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 253 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasManualObject -}
+hasManualObject :: HG3DClass -> String -> IO (Bool)
+hasManualObject a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasManualObject'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 259 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyManualObject -}
+destroyManualObject :: HG3DClass -> HG3DClass -> IO ()
+destroyManualObject a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  destroyManualObject'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 264 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyManualObject2 -}
+destroyManualObject2 :: HG3DClass -> String -> IO ()
+destroyManualObject2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyManualObject2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 269 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllManualObjects -}
+destroyAllManualObjects :: HG3DClass -> IO ()
+destroyAllManualObjects a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllManualObjects'_ a1' >>= \res ->
+  return ()
+{-# LINE 273 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createBillboardChain -}
+createBillboardChain :: HG3DClass -> String -> IO (HG3DClass)
+createBillboardChain a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  createBillboardChain'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 279 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createBillboardChain2 -}
+createBillboardChain2 :: HG3DClass -> IO (HG3DClass)
+createBillboardChain2 a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  createBillboardChain2'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 284 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getBillboardChain -}
+getBillboardChain :: HG3DClass -> String -> IO (HG3DClass)
+getBillboardChain a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  getBillboardChain'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 290 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasBillboardChain -}
+hasBillboardChain :: HG3DClass -> String -> IO (Bool)
+hasBillboardChain a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasBillboardChain'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 296 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyBillboardChain -}
+destroyBillboardChain :: HG3DClass -> HG3DClass -> IO ()
+destroyBillboardChain a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  destroyBillboardChain'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 301 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyBillboardChain2 -}
+destroyBillboardChain2 :: HG3DClass -> String -> IO ()
+destroyBillboardChain2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyBillboardChain2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 306 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllBillboardChains -}
+destroyAllBillboardChains :: HG3DClass -> IO ()
+destroyAllBillboardChains a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllBillboardChains'_ a1' >>= \res ->
+  return ()
+{-# LINE 310 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasRibbonTrail -}
+hasRibbonTrail :: HG3DClass -> String -> IO (Bool)
+hasRibbonTrail a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasRibbonTrail'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 316 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyRibbonTrail2 -}
+destroyRibbonTrail2 :: HG3DClass -> String -> IO ()
+destroyRibbonTrail2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyRibbonTrail2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 321 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllRibbonTrails -}
+destroyAllRibbonTrails :: HG3DClass -> IO ()
+destroyAllRibbonTrails a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllRibbonTrails'_ a1' >>= \res ->
+  return ()
+{-# LINE 325 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasParticleSystem -}
+hasParticleSystem :: HG3DClass -> String -> IO (Bool)
+hasParticleSystem a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasParticleSystem'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 331 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyParticleSystem2 -}
+destroyParticleSystem2 :: HG3DClass -> String -> IO ()
+destroyParticleSystem2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyParticleSystem2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 336 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllParticleSystems -}
+destroyAllParticleSystems :: HG3DClass -> IO ()
+destroyAllParticleSystems a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllParticleSystems'_ a1' >>= \res ->
+  return ()
+{-# LINE 340 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function clearScene -}
+clearScene :: HG3DClass -> IO ()
+clearScene a1 =
+  withHG3DClass a1 $ \a1' -> 
+  clearScene'_ a1' >>= \res ->
+  return ()
+{-# LINE 344 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setAmbientLight -}
+setAmbientLight :: HG3DClass -> Colour -> IO ()
+setAmbientLight a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withColour a2 $ \a2' -> 
+  setAmbientLight'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 349 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getAmbientLight -}
+getAmbientLight :: HG3DClass -> IO (Colour)
+getAmbientLight a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getAmbientLight'_ a1' a2' >>= \res ->
+  peekColour  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 354 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function prepareWorldGeometry -}
+prepareWorldGeometry :: HG3DClass -> String -> IO ()
+prepareWorldGeometry a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  prepareWorldGeometry'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 359 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setWorldGeometry -}
+setWorldGeometry :: HG3DClass -> String -> IO ()
+setWorldGeometry a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  setWorldGeometry'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 364 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function estimateWorldGeometry -}
+estimateWorldGeometry :: HG3DClass -> String -> IO (Int)
+estimateWorldGeometry a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  estimateWorldGeometry'_ a1' a2' a3' >>= \res ->
+  peekIntConv  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 370 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasOption -}
+hasOption :: HG3DClass -> String -> IO (Bool)
+hasOption a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasOption'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 376 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setSkyPlaneEnabled -}
+setSkyPlaneEnabled :: HG3DClass -> Bool -> IO ()
+setSkyPlaneEnabled a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setSkyPlaneEnabled'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 381 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isSkyPlaneEnabled -}
+isSkyPlaneEnabled :: HG3DClass -> IO (Bool)
+isSkyPlaneEnabled a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isSkyPlaneEnabled'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 386 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getSkyPlaneNode -}
+getSkyPlaneNode :: HG3DClass -> IO (HG3DClass)
+getSkyPlaneNode a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getSkyPlaneNode'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 391 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setSkyBox -}
+setSkyBox :: HG3DClass -> Bool -> String -> Float -> Bool -> Quaternion -> String -> IO ()
+setSkyBox a1 a2 a3 a4 a5 a6 a7 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  withCString a3 $ \a3' -> 
+  let {a4' = realToFrac a4} in 
+  let {a5' = fromBool a5} in 
+  withQuaternion a6 $ \a6' -> 
+  withCString a7 $ \a7' -> 
+  setSkyBox'_ a1' a2' a3' a4' a5' a6' a7' >>= \res ->
+  return ()
+{-# LINE 401 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setSkyBoxEnabled -}
+setSkyBoxEnabled :: HG3DClass -> Bool -> IO ()
+setSkyBoxEnabled a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setSkyBoxEnabled'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 406 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isSkyBoxEnabled -}
+isSkyBoxEnabled :: HG3DClass -> IO (Bool)
+isSkyBoxEnabled a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isSkyBoxEnabled'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 411 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getSkyBoxNode -}
+getSkyBoxNode :: HG3DClass -> IO (HG3DClass)
+getSkyBoxNode a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getSkyBoxNode'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 416 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setSkyDome -}
+setSkyDome :: HG3DClass -> Bool -> String -> Float -> Float -> Float -> Bool -> Quaternion -> Int -> Int -> Int -> String -> IO ()
+setSkyDome a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  withCString a3 $ \a3' -> 
+  let {a4' = realToFrac a4} in 
+  let {a5' = realToFrac a5} in 
+  let {a6' = realToFrac a6} in 
+  let {a7' = fromBool a7} in 
+  withQuaternion a8 $ \a8' -> 
+  let {a9' = fromIntegral a9} in 
+  let {a10' = fromIntegral a10} in 
+  let {a11' = fromIntegral a11} in 
+  withCString a12 $ \a12' -> 
+  setSkyDome'_ a1' a2' a3' a4' a5' a6' a7' a8' a9' a10' a11' a12' >>= \res ->
+  return ()
+{-# LINE 431 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setSkyDomeEnabled -}
+setSkyDomeEnabled :: HG3DClass -> Bool -> IO ()
+setSkyDomeEnabled a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setSkyDomeEnabled'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 436 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isSkyDomeEnabled -}
+isSkyDomeEnabled :: HG3DClass -> IO (Bool)
+isSkyDomeEnabled a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isSkyDomeEnabled'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 441 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getSkyDomeNode -}
+getSkyDomeNode :: HG3DClass -> IO (HG3DClass)
+getSkyDomeNode a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getSkyDomeNode'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 446 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getFogColour -}
+getFogColour :: HG3DClass -> IO (Colour)
+getFogColour a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getFogColour'_ a1' a2' >>= \res ->
+  peekColour  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 451 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getFogStart -}
+getFogStart :: HG3DClass -> IO (Float)
+getFogStart a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getFogStart'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 456 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getFogEnd -}
+getFogEnd :: HG3DClass -> IO (Float)
+getFogEnd a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getFogEnd'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 461 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getFogDensity -}
+getFogDensity :: HG3DClass -> IO (Float)
+getFogDensity a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getFogDensity'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 466 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createBillboardSet -}
+createBillboardSet :: HG3DClass -> String -> Int -> IO (HG3DClass)
+createBillboardSet a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  let {a3' = fromIntegral a3} in 
+  alloca $ \a4' -> 
+  createBillboardSet'_ a1' a2' a3' a4' >>= \res ->
+  peek  a4'>>= \a4'' -> 
+  return (a4'')
+{-# LINE 473 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createBillboardSet2 -}
+createBillboardSet2 :: HG3DClass -> Int -> IO (HG3DClass)
+createBillboardSet2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  alloca $ \a3' -> 
+  createBillboardSet2'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 479 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getBillboardSet -}
+getBillboardSet :: HG3DClass -> String -> IO (HG3DClass)
+getBillboardSet a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  getBillboardSet'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 485 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasBillboardSet -}
+hasBillboardSet :: HG3DClass -> String -> IO (Bool)
+hasBillboardSet a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasBillboardSet'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 491 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyBillboardSet -}
+destroyBillboardSet :: HG3DClass -> HG3DClass -> IO ()
+destroyBillboardSet a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  destroyBillboardSet'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 496 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyBillboardSet2 -}
+destroyBillboardSet2 :: HG3DClass -> String -> IO ()
+destroyBillboardSet2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyBillboardSet2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 501 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllBillboardSets -}
+destroyAllBillboardSets :: HG3DClass -> IO ()
+destroyAllBillboardSets a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllBillboardSets'_ a1' >>= \res ->
+  return ()
+{-# LINE 505 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setDisplaySceneNodes -}
+setDisplaySceneNodes :: HG3DClass -> Bool -> IO ()
+setDisplaySceneNodes a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setDisplaySceneNodes'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 510 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getDisplaySceneNodes -}
+getDisplaySceneNodes :: HG3DClass -> IO (Bool)
+getDisplaySceneNodes a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getDisplaySceneNodes'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 515 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createAnimation -}
+createAnimation :: HG3DClass -> String -> Float -> IO (HG3DClass)
+createAnimation a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  let {a3' = realToFrac a3} in 
+  alloca $ \a4' -> 
+  createAnimation'_ a1' a2' a3' a4' >>= \res ->
+  peek  a4'>>= \a4'' -> 
+  return (a4'')
+{-# LINE 522 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getAnimation -}
+getAnimation :: HG3DClass -> String -> IO (HG3DClass)
+getAnimation a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  getAnimation'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 528 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasAnimation -}
+hasAnimation :: HG3DClass -> String -> IO (Bool)
+hasAnimation a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasAnimation'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 534 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAnimation -}
+destroyAnimation :: HG3DClass -> String -> IO ()
+destroyAnimation a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyAnimation'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 539 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllAnimations -}
+destroyAllAnimations :: HG3DClass -> IO ()
+destroyAllAnimations a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllAnimations'_ a1' >>= \res ->
+  return ()
+{-# LINE 543 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function createAnimationState -}
+createAnimationState :: HG3DClass -> String -> IO (HG3DClass)
+createAnimationState a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  createAnimationState'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 549 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getAnimationState -}
+getAnimationState :: HG3DClass -> String -> IO (HG3DClass)
+getAnimationState a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  getAnimationState'_ a1' a2' a3' >>= \res ->
+  peek  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 555 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasAnimationState -}
+hasAnimationState :: HG3DClass -> String -> IO (Bool)
+hasAnimationState a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasAnimationState'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 561 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAnimationState -}
+destroyAnimationState :: HG3DClass -> String -> IO ()
+destroyAnimationState a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyAnimationState'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 566 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllAnimationStates -}
+destroyAllAnimationStates :: HG3DClass -> IO ()
+destroyAllAnimationStates a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllAnimationStates'_ a1' >>= \res ->
+  return ()
+{-# LINE 570 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function clearSpecialCaseRenderQueues -}
+clearSpecialCaseRenderQueues :: HG3DClass -> IO ()
+clearSpecialCaseRenderQueues a1 =
+  withHG3DClass a1 $ \a1' -> 
+  clearSpecialCaseRenderQueues'_ a1' >>= \res ->
+  return ()
+{-# LINE 574 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setSpecialCaseRenderQueueMode -}
+setSpecialCaseRenderQueueMode :: HG3DClass -> EnumSceneManagerSpecialCaseRenderQueueMode -> IO ()
+setSpecialCaseRenderQueueMode a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = cIntFromEnum a2} in 
+  setSpecialCaseRenderQueueMode'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 579 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getSpecialCaseRenderQueueMode -}
+getSpecialCaseRenderQueueMode :: HG3DClass -> IO (EnumSceneManagerSpecialCaseRenderQueueMode)
+getSpecialCaseRenderQueueMode a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getSpecialCaseRenderQueueMode'_ a1' a2' >>= \res ->
+  peekEnumUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 584 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function showBoundingBoxes -}
+showBoundingBoxes :: HG3DClass -> Bool -> IO ()
+showBoundingBoxes a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  showBoundingBoxes'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 589 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShowBoundingBoxes -}
+getShowBoundingBoxes :: HG3DClass -> IO (Bool)
+getShowBoundingBoxes a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShowBoundingBoxes'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 594 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShowDebugShadows -}
+setShowDebugShadows :: HG3DClass -> Bool -> IO ()
+setShowDebugShadows a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setShowDebugShadows'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 599 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShowDebugShadows -}
+getShowDebugShadows :: HG3DClass -> IO (Bool)
+getShowDebugShadows a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShowDebugShadows'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 604 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowColour -}
+setShadowColour :: HG3DClass -> Colour -> IO ()
+setShadowColour a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withColour a2 $ \a2' -> 
+  setShadowColour'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 609 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowColour -}
+getShadowColour :: HG3DClass -> IO (Colour)
+getShadowColour a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowColour'_ a1' a2' >>= \res ->
+  peekColour  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 614 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowDirectionalLightExtrusionDistance -}
+setShadowDirectionalLightExtrusionDistance :: HG3DClass -> Float -> IO ()
+setShadowDirectionalLightExtrusionDistance a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  setShadowDirectionalLightExtrusionDistance'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 619 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowDirectionalLightExtrusionDistance -}
+getShadowDirectionalLightExtrusionDistance :: HG3DClass -> IO (Float)
+getShadowDirectionalLightExtrusionDistance a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowDirectionalLightExtrusionDistance'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 624 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowFarDistance -}
+setShadowFarDistance :: HG3DClass -> Float -> IO ()
+setShadowFarDistance a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  setShadowFarDistance'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 629 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowFarDistance -}
+getShadowFarDistance :: HG3DClass -> IO (Float)
+getShadowFarDistance a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowFarDistance'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 634 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowFarDistanceSquared -}
+getShadowFarDistanceSquared :: HG3DClass -> IO (Float)
+getShadowFarDistanceSquared a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowFarDistanceSquared'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 639 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowIndexBufferSize -}
+setShadowIndexBufferSize :: HG3DClass -> Int -> IO ()
+setShadowIndexBufferSize a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  setShadowIndexBufferSize'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 644 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowIndexBufferSize -}
+getShadowIndexBufferSize :: HG3DClass -> IO (Int)
+getShadowIndexBufferSize a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowIndexBufferSize'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 649 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowTextureSize -}
+setShadowTextureSize :: HG3DClass -> Int -> IO ()
+setShadowTextureSize a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  setShadowTextureSize'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 654 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowTextureFSAA -}
+setShadowTextureFSAA :: HG3DClass -> Int -> IO ()
+setShadowTextureFSAA a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  setShadowTextureFSAA'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 659 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowTextureCount -}
+setShadowTextureCount :: HG3DClass -> Int -> IO ()
+setShadowTextureCount a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  setShadowTextureCount'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 664 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowTextureCount -}
+getShadowTextureCount :: HG3DClass -> IO (Int)
+getShadowTextureCount a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowTextureCount'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 669 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowTextureCountPerLightType -}
+setShadowTextureCountPerLightType :: HG3DClass -> EnumLightType -> Int -> IO ()
+setShadowTextureCountPerLightType a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = cIntFromEnum a2} in 
+  let {a3' = fromIntegral a3} in 
+  setShadowTextureCountPerLightType'_ a1' a2' a3' >>= \res ->
+  return ()
+{-# LINE 675 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowTextureCountPerLightType -}
+getShadowTextureCountPerLightType :: HG3DClass -> EnumLightType -> IO (Int)
+getShadowTextureCountPerLightType a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = cIntFromEnum a2} in 
+  alloca $ \a3' -> 
+  getShadowTextureCountPerLightType'_ a1' a2' a3' >>= \res ->
+  peekIntConv  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 681 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowTexture -}
+getShadowTexture :: HG3DClass -> Int -> IO (SharedPtr)
+getShadowTexture a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  alloca $ \a3' -> 
+  getShadowTexture'_ a1' a2' a3' >>= \res ->
+  peekSharedPtr  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 687 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowDirLightTextureOffset -}
+setShadowDirLightTextureOffset :: HG3DClass -> Float -> IO ()
+setShadowDirLightTextureOffset a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  setShadowDirLightTextureOffset'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 692 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowDirLightTextureOffset -}
+getShadowDirLightTextureOffset :: HG3DClass -> IO (Float)
+getShadowDirLightTextureOffset a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowDirLightTextureOffset'_ a1' a2' >>= \res ->
+  peekFloatConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 697 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowTextureFadeStart -}
+setShadowTextureFadeStart :: HG3DClass -> Float -> IO ()
+setShadowTextureFadeStart a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  setShadowTextureFadeStart'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 702 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowTextureFadeEnd -}
+setShadowTextureFadeEnd :: HG3DClass -> Float -> IO ()
+setShadowTextureFadeEnd a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = realToFrac a2} in 
+  setShadowTextureFadeEnd'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 707 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowTextureSelfShadow -}
+setShadowTextureSelfShadow :: HG3DClass -> Bool -> IO ()
+setShadowTextureSelfShadow a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setShadowTextureSelfShadow'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 712 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowTextureSelfShadow -}
+getShadowTextureSelfShadow :: HG3DClass -> IO (Bool)
+getShadowTextureSelfShadow a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowTextureSelfShadow'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 717 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowTextureCasterMaterial -}
+setShadowTextureCasterMaterial :: HG3DClass -> String -> IO ()
+setShadowTextureCasterMaterial a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  setShadowTextureCasterMaterial'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 722 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowTextureReceiverMaterial -}
+setShadowTextureReceiverMaterial :: HG3DClass -> String -> IO ()
+setShadowTextureReceiverMaterial a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  setShadowTextureReceiverMaterial'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 727 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowCasterRenderBackFaces -}
+setShadowCasterRenderBackFaces :: HG3DClass -> Bool -> IO ()
+setShadowCasterRenderBackFaces a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setShadowCasterRenderBackFaces'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 732 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowCasterRenderBackFaces -}
+getShadowCasterRenderBackFaces :: HG3DClass -> IO (Bool)
+getShadowCasterRenderBackFaces a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowCasterRenderBackFaces'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 737 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowUseInfiniteFarPlane -}
+setShadowUseInfiniteFarPlane :: HG3DClass -> Bool -> IO ()
+setShadowUseInfiniteFarPlane a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setShadowUseInfiniteFarPlane'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 742 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isShadowTechniqueStencilBased -}
+isShadowTechniqueStencilBased :: HG3DClass -> IO (Bool)
+isShadowTechniqueStencilBased a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isShadowTechniqueStencilBased'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 747 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isShadowTechniqueTextureBased -}
+isShadowTechniqueTextureBased :: HG3DClass -> IO (Bool)
+isShadowTechniqueTextureBased a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isShadowTechniqueTextureBased'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 752 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isShadowTechniqueModulative -}
+isShadowTechniqueModulative :: HG3DClass -> IO (Bool)
+isShadowTechniqueModulative a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isShadowTechniqueModulative'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 757 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isShadowTechniqueAdditive -}
+isShadowTechniqueAdditive :: HG3DClass -> IO (Bool)
+isShadowTechniqueAdditive a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isShadowTechniqueAdditive'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 762 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isShadowTechniqueIntegrated -}
+isShadowTechniqueIntegrated :: HG3DClass -> IO (Bool)
+isShadowTechniqueIntegrated a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isShadowTechniqueIntegrated'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 767 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isShadowTechniqueInUse -}
+isShadowTechniqueInUse :: HG3DClass -> IO (Bool)
+isShadowTechniqueInUse a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isShadowTechniqueInUse'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 772 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setShadowUseLightClipPlanes -}
+setShadowUseLightClipPlanes :: HG3DClass -> Bool -> IO ()
+setShadowUseLightClipPlanes a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setShadowUseLightClipPlanes'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 777 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getShadowUseLightClipPlanes -}
+getShadowUseLightClipPlanes :: HG3DClass -> IO (Bool)
+getShadowUseLightClipPlanes a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getShadowUseLightClipPlanes'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 782 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setLateMaterialResolving -}
+setLateMaterialResolving :: HG3DClass -> Bool -> IO ()
+setLateMaterialResolving a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setLateMaterialResolving'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 787 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function isLateMaterialResolving -}
+isLateMaterialResolving :: HG3DClass -> IO (Bool)
+isLateMaterialResolving a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  isLateMaterialResolving'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 792 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasStaticGeometry -}
+hasStaticGeometry :: HG3DClass -> String -> IO (Bool)
+hasStaticGeometry a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasStaticGeometry'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 798 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyStaticGeometry2 -}
+destroyStaticGeometry2 :: HG3DClass -> String -> IO ()
+destroyStaticGeometry2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyStaticGeometry2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 803 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllStaticGeometry -}
+destroyAllStaticGeometry :: HG3DClass -> IO ()
+destroyAllStaticGeometry a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllStaticGeometry'_ a1' >>= \res ->
+  return ()
+{-# LINE 807 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyInstancedGeometry2 -}
+destroyInstancedGeometry2 :: HG3DClass -> String -> IO ()
+destroyInstancedGeometry2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyInstancedGeometry2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 812 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllInstancedGeometry -}
+destroyAllInstancedGeometry :: HG3DClass -> IO ()
+destroyAllInstancedGeometry a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllInstancedGeometry'_ a1' >>= \res ->
+  return ()
+{-# LINE 816 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasInstanceManager -}
+hasInstanceManager :: HG3DClass -> String -> IO (Bool)
+hasInstanceManager a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  alloca $ \a3' -> 
+  hasInstanceManager'_ a1' a2' a3' >>= \res ->
+  peekBoolUtil  a3'>>= \a3'' -> 
+  return (a3'')
+{-# LINE 822 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyInstanceManager -}
+destroyInstanceManager :: HG3DClass -> String -> IO ()
+destroyInstanceManager a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyInstanceManager'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 827 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllInstanceManagers -}
+destroyAllInstanceManagers :: HG3DClass -> IO ()
+destroyAllInstanceManagers a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllInstanceManagers'_ a1' >>= \res ->
+  return ()
+{-# LINE 831 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyMovableObject -}
+destroyMovableObject :: HG3DClass -> String -> String -> IO ()
+destroyMovableObject a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withCString a3 $ \a3' -> 
+  destroyMovableObject'_ a1' a2' a3' >>= \res ->
+  return ()
+{-# LINE 837 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyMovableObject2 -}
+destroyMovableObject2 :: HG3DClass -> HG3DClass -> IO ()
+destroyMovableObject2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  destroyMovableObject2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 842 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllMovableObjectsByType -}
+destroyAllMovableObjectsByType :: HG3DClass -> String -> IO ()
+destroyAllMovableObjectsByType a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  destroyAllMovableObjectsByType'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 847 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function destroyAllMovableObjects -}
+destroyAllMovableObjects :: HG3DClass -> IO ()
+destroyAllMovableObjects a1 =
+  withHG3DClass a1 $ \a1' -> 
+  destroyAllMovableObjects'_ a1' >>= \res ->
+  return ()
+{-# LINE 851 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getMovableObject -}
+getMovableObject :: HG3DClass -> String -> String -> IO (HG3DClass)
+getMovableObject a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withCString a3 $ \a3' -> 
+  alloca $ \a4' -> 
+  getMovableObject'_ a1' a2' a3' a4' >>= \res ->
+  peek  a4'>>= \a4'' -> 
+  return (a4'')
+{-# LINE 858 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function hasMovableObject -}
+hasMovableObject :: HG3DClass -> String -> String -> IO (Bool)
+hasMovableObject a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withCString a3 $ \a3' -> 
+  alloca $ \a4' -> 
+  hasMovableObject'_ a1' a2' a3' a4' >>= \res ->
+  peekBoolUtil  a4'>>= \a4'' -> 
+  return (a4'')
+{-# LINE 865 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function injectMovableObject -}
+injectMovableObject :: HG3DClass -> HG3DClass -> IO ()
+injectMovableObject a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  injectMovableObject'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 870 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function extractMovableObject -}
+extractMovableObject :: HG3DClass -> String -> String -> IO ()
+extractMovableObject a1 a2 a3 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  withCString a3 $ \a3' -> 
+  extractMovableObject'_ a1' a2' a3' >>= \res ->
+  return ()
+{-# LINE 876 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function extractMovableObject2 -}
+extractMovableObject2 :: HG3DClass -> HG3DClass -> IO ()
+extractMovableObject2 a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withHG3DClass a2 $ \a2' -> 
+  extractMovableObject2'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 881 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function extractAllMovableObjectsByType -}
+extractAllMovableObjectsByType :: HG3DClass -> String -> IO ()
+extractAllMovableObjectsByType a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  withCString a2 $ \a2' -> 
+  extractAllMovableObjectsByType'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 886 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setVisibilityMask -}
+setVisibilityMask :: HG3DClass -> Int -> IO ()
+setVisibilityMask a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromIntegral a2} in 
+  setVisibilityMask'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 891 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getVisibilityMask -}
+getVisibilityMask :: HG3DClass -> IO (Int)
+getVisibilityMask a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getVisibilityMask'_ a1' a2' >>= \res ->
+  peekIntConv  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 896 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setFindVisibleObjects -}
+setFindVisibleObjects :: HG3DClass -> Bool -> IO ()
+setFindVisibleObjects a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setFindVisibleObjects'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 901 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getFindVisibleObjects -}
+getFindVisibleObjects :: HG3DClass -> IO (Bool)
+getFindVisibleObjects a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getFindVisibleObjects'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 906 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setNormaliseNormalsOnScale -}
+setNormaliseNormalsOnScale :: HG3DClass -> Bool -> IO ()
+setNormaliseNormalsOnScale a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setNormaliseNormalsOnScale'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 911 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getNormaliseNormalsOnScale -}
+getNormaliseNormalsOnScale :: HG3DClass -> IO (Bool)
+getNormaliseNormalsOnScale a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getNormaliseNormalsOnScale'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 916 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setFlipCullingOnNegativeScale -}
+setFlipCullingOnNegativeScale :: HG3DClass -> Bool -> IO ()
+setFlipCullingOnNegativeScale a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setFlipCullingOnNegativeScale'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 921 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getFlipCullingOnNegativeScale -}
+getFlipCullingOnNegativeScale :: HG3DClass -> IO (Bool)
+getFlipCullingOnNegativeScale a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getFlipCullingOnNegativeScale'_ a1' a2' >>= \res ->
+  peekBoolUtil  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 926 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getDestinationRenderSystem -}
+getDestinationRenderSystem :: HG3DClass -> IO (HG3DClass)
+getDestinationRenderSystem a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getDestinationRenderSystem'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 931 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getCurrentViewport -}
+getCurrentViewport :: HG3DClass -> IO (HG3DClass)
+getCurrentViewport a1 =
+  withHG3DClass a1 $ \a1' -> 
+  alloca $ \a2' -> 
+  getCurrentViewport'_ a1' a2' >>= \res ->
+  peek  a2'>>= \a2'' -> 
+  return (a2'')
+{-# LINE 936 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function setCameraRelativeRendering -}
+setCameraRelativeRendering :: HG3DClass -> Bool -> IO ()
+setCameraRelativeRendering a1 a2 =
+  withHG3DClass a1 $ \a1' -> 
+  let {a2' = fromBool a2} in 
+  setCameraRelativeRendering'_ a1' a2' >>= \res ->
+  return ()
+{-# LINE 941 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManager.chs" #-}
+
+{- function getCameraRelativeRendering -}
+getCameraRelativeRendering :: HG3DClass -> IO (Bool)
 getCameraRelativeRendering a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassSceneManagerFactory.hs b/HGamer3D/Bindings/Ogre/ClassSceneManagerFactory.hs
--- a/HGamer3D/Bindings/Ogre/ClassSceneManagerFactory.hs
+++ b/HGamer3D/Bindings/Ogre/ClassSceneManagerFactory.hs
@@ -48,22 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManagerFactory.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~SceneManagerFactory -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManagerFactory.chs" #-}
 
--- | Create a new instance of a SceneManager.
---Don't call directly, use SceneManagerEnumerator::createSceneManager. 
-createInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ instanceName
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createInstance -}
+createInstance :: HG3DClass -> String -> IO (HG3DClass)
 createInstance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -73,11 +67,8 @@
   return (a3'')
 {-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneManagerFactory.chs" #-}
 
--- | Destroy an instance of a SceneManager
-destroyInstance :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ instance
-  ->  IO ()
- -- ^ 
+{- function destroyInstance -}
+destroyInstance :: HG3DClass -> HG3DClass -> IO ()
 destroyInstance a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassSceneNode.hs b/HGamer3D/Bindings/Ogre/ClassSceneNode.hs
--- a/HGamer3D/Bindings/Ogre/ClassSceneNode.hs
+++ b/HGamer3D/Bindings/Ogre/ClassSceneNode.hs
@@ -52,22 +52,16 @@
 import HGamer3D.Bindings.Ogre.StructQuaternion
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~SceneNode -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 49 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Adds an instance of a scene object to this node.
---Scene objects can include EntityCameraLightMovableObject
-attachObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
+{- function attachObject -}
+attachObject :: HG3DClass -> HG3DClass -> IO ()
 attachObject a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -75,10 +69,8 @@
   return ()
 {-# LINE 54 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Reports the number of objects attached to this node. 
-numAttachedObjects :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function numAttachedObjects -}
+numAttachedObjects :: HG3DClass -> IO (Int)
 numAttachedObjects a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -87,12 +79,8 @@
   return (a2'')
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Retrieves a pointer to an attached object.
---Retrieves by index, see alternate version to retrieve by name. The index of an object may change as other objects are added / removed. 
-getAttachedObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAttachedObject -}
+getAttachedObject :: HG3DClass -> Int -> IO (HG3DClass)
 getAttachedObject a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -102,12 +90,8 @@
   return (a3'')
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Retrieves a pointer to an attached object.
---Retrieves by object name, see alternate version to retrieve by index. 
-getAttachedObject2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAttachedObject2 -}
+getAttachedObject2 :: HG3DClass -> String -> IO (HG3DClass)
 getAttachedObject2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -117,12 +101,8 @@
   return (a3'')
 {-# LINE 71 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Detaches the indexed object from this scene node.
---Detaches by index, see the alternate version to detach by name. Object indexes may change as other objects are added / removed. 
-detachObject :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function detachObject -}
+detachObject :: HG3DClass -> Int -> IO (HG3DClass)
 detachObject a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -132,11 +112,8 @@
   return (a3'')
 {-# LINE 77 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Detaches an object by pointer. 
-detachObject2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ obj
-  ->  IO ()
- -- ^ 
+{- function detachObject2 -}
+detachObject2 :: HG3DClass -> HG3DClass -> IO ()
 detachObject2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -144,11 +121,8 @@
   return ()
 {-# LINE 82 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Detaches the named object from this node and returns a pointer to it. 
-detachObject3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function detachObject3 -}
+detachObject3 :: HG3DClass -> String -> IO (HG3DClass)
 detachObject3 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -158,20 +132,16 @@
   return (a3'')
 {-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Detaches all objects attached to this node. 
-detachAllObjects :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function detachAllObjects -}
+detachAllObjects :: HG3DClass -> IO ()
 detachAllObjects a1 =
   withHG3DClass a1 $ \a1' -> 
   detachAllObjects'_ a1' >>= \res ->
   return ()
 {-# LINE 92 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Determines whether this node is in the scene graph, i.e. whether it's ultimate ancestor is the root scene node. 
-isInSceneGraph :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isInSceneGraph -}
+isInSceneGraph :: HG3DClass -> IO (Bool)
 isInSceneGraph a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -180,11 +150,8 @@
   return (a2'')
 {-# LINE 97 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Gets the creator of this scene node. 
---This method returns the SceneManager
-getCreator :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getCreator -}
+getCreator :: HG3DClass -> IO (HG3DClass)
 getCreator a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -193,12 +160,8 @@
   return (a2'')
 {-# LINE 102 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | This method removes and destroys the named child and all of its children.
---Unlike removeChild, which removes a single named child from this node but does not destroy it, this method destroys the child and all of it's children. Use this if you wish to recursively destroy a node as well as detaching it from it's parent. Note that any objects attached to the nodes will be detached but will not themselves be destroyed. 
-removeAndDestroyChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function removeAndDestroyChild -}
+removeAndDestroyChild :: HG3DClass -> String -> IO ()
 removeAndDestroyChild a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -206,12 +169,8 @@
   return ()
 {-# LINE 107 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | This method removes and destroys the child and all of its children.
---Unlike removeChild, which removes a single named child from this node but does not destroy it, this method destroys the child and all of it's children. Use this if you wish to recursively destroy a node as well as detaching it from it's parent. Note that any objects attached to the nodes will be detached but will not themselves be destroyed. 
-removeAndDestroyChild2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO ()
- -- ^ 
+{- function removeAndDestroyChild2 -}
+removeAndDestroyChild2 :: HG3DClass -> Int -> IO ()
 removeAndDestroyChild2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -219,23 +178,16 @@
   return ()
 {-# LINE 112 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Removes and destroys all children of this node.
---Use this to destroy all child nodes of this node and remove them from the scene graph. Note that all objects attached to this node will be detached but will not be destroyed. 
-removeAndDestroyAllChildren :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAndDestroyAllChildren -}
+removeAndDestroyAllChildren :: HG3DClass -> IO ()
 removeAndDestroyAllChildren a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAndDestroyAllChildren'_ a1' >>= \res ->
   return ()
 {-# LINE 116 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Allows the showing of the node's bounding box.
---Use this to show or hide the bounding box of the node. 
-showBoundingBox :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ bShow
-  ->  IO ()
- -- ^ 
+{- function showBoundingBox -}
+showBoundingBox :: HG3DClass -> Bool -> IO ()
 showBoundingBox a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -243,13 +195,8 @@
   return ()
 {-# LINE 121 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Allows the overriding of the node's bounding box
---over the SceneManager's bounding box setting.
---Use this to override the bounding box setting of the node. 
-hideBoundingBox :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ bHide
-  ->  IO ()
- -- ^ 
+{- function hideBoundingBox -}
+hideBoundingBox :: HG3DClass -> Bool -> IO ()
 hideBoundingBox a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -257,12 +204,8 @@
   return ()
 {-# LINE 126 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | This allows scene managers to determine if the node's bounding box
---should be added to the rendering queue.
---Scene Managers that implement their own _findVisibleObjects will have to check this flag and then use _addBoundingBoxToQueue to add the bounding box wireframe. 
-getShowBoundingBox :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getShowBoundingBox -}
+getShowBoundingBox :: HG3DClass -> IO (Bool)
 getShowBoundingBox a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -271,13 +214,8 @@
   return (a2'')
 {-# LINE 131 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Creates an unnamed new SceneNode as a child of this node.
---
-createChildSceneNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec3  -- ^ translate - Initial translation offset of child relative to parent 
-  ->  Quaternion  -- ^ rotate - Initial rotation relative to parent 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createChildSceneNode -}
+createChildSceneNode :: HG3DClass -> Vec3 -> Quaternion -> IO (HG3DClass)
 createChildSceneNode a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withVec3 a2 $ \a2' -> 
@@ -288,14 +226,8 @@
   return (a4'')
 {-# LINE 138 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Creates a new named SceneNode as a child of this node.
---This creates a child node with a given name, which allows you to look the node up from the parent which holds this collection of nodes. 
-createChildSceneNode2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  Vec3  -- ^ translate - Initial translation offset of child relative to parent 
-  ->  Quaternion  -- ^ rotate - Initial rotation relative to parent 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createChildSceneNode2 -}
+createChildSceneNode2 :: HG3DClass -> String -> Vec3 -> Quaternion -> IO (HG3DClass)
 createChildSceneNode2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -307,13 +239,8 @@
   return (a5'')
 {-# LINE 146 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Tells the node whether to yaw around it's own local Y axis or a fixed axis of choice.
---This method allows you to change the yaw behaviour of the node - by default, it yaws around it's own local Y axis when told to yaw with TS_LOCAL, this makes it yaw around a fixed axis. You only really need this when you're using auto tracking (see setAutoTracking, because when you're manually rotating a node you can specify the TransformSpace in which you wish to work anyway. 
-setFixedYawAxis :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ useFixed - If true, the axis passed in the second parameter will always be the yaw axis no matter what the node orientation. If false, the node returns to it's default behaviour. 
-  ->  Vec3  -- ^ fixedAxis - The axis to use if the first parameter is true. 
-  ->  IO ()
- -- ^ 
+{- function setFixedYawAxis -}
+setFixedYawAxis :: HG3DClass -> Bool -> Vec3 -> IO ()
 setFixedYawAxis a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -322,10 +249,8 @@
   return ()
 {-# LINE 152 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Get the auto tracking target for this node, if any. 
-getAutoTrackTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAutoTrackTarget -}
+getAutoTrackTarget :: HG3DClass -> IO (HG3DClass)
 getAutoTrackTarget a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -334,10 +259,8 @@
   return (a2'')
 {-# LINE 157 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Get the auto tracking offset for this node, if the node is auto tracking. 
-getAutoTrackOffset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getAutoTrackOffset -}
+getAutoTrackOffset :: HG3DClass -> IO (Vec3)
 getAutoTrackOffset a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -346,10 +269,8 @@
   return (a2'')
 {-# LINE 162 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Get the auto tracking local direction for this node, if it is auto tracking. 
-getAutoTrackLocalDirection :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Vec3)
- -- ^ 
+{- function getAutoTrackLocalDirection -}
+getAutoTrackLocalDirection :: HG3DClass -> IO (Vec3)
 getAutoTrackLocalDirection a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -358,10 +279,8 @@
   return (a2'')
 {-# LINE 167 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Gets the parent of this SceneNode
-getParentSceneNode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getParentSceneNode -}
+getParentSceneNode :: HG3DClass -> IO (HG3DClass)
 getParentSceneNode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -370,13 +289,8 @@
   return (a2'')
 {-# LINE 172 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Makes all objects attached to this node become visible / invisible.
---This is a shortcut to calling setVisible()
-setVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ visible - Whether the objects are to be made visible or invisible 
-  ->  Bool  -- ^ cascade - If true, this setting cascades into child nodes too. 
-  ->  IO ()
- -- ^ 
+{- function setVisible -}
+setVisible :: HG3DClass -> Bool -> Bool -> IO ()
 setVisible a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -385,12 +299,8 @@
   return ()
 {-# LINE 178 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Inverts the visibility of all objects attached to this node.
---This is a shortcut to calling setVisible(!isVisible()) on the objects attached to this node, and optionally to all objects attached to child nodes. 
-flipVisibility :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ cascade - If true, this setting cascades into child nodes too. 
-  ->  IO ()
- -- ^ 
+{- function flipVisibility -}
+flipVisibility :: HG3DClass -> Bool -> IO ()
 flipVisibility a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -398,14 +308,8 @@
   return ()
 {-# LINE 183 ".\\HGamer3D\\Bindings\\Ogre\\ClassSceneNode.chs" #-}
 
--- | Tells all objects attached to this node whether to display their
---debug information or not.
---This is a shortcut to calling setDebugDisplayEnabled()
-setDebugDisplayEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled - Whether the objects are to display debug info or not 
-  ->  Bool  -- ^ cascade - If true, this setting cascades into child nodes too. 
-  ->  IO ()
- -- ^ 
+{- function setDebugDisplayEnabled -}
+setDebugDisplayEnabled :: HG3DClass -> Bool -> Bool -> IO ()
 setDebugDisplayEnabled a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
diff --git a/HGamer3D/Bindings/Ogre/ClassSkeleton.hs b/HGamer3D/Bindings/Ogre/ClassSkeleton.hs
--- a/HGamer3D/Bindings/Ogre/ClassSkeleton.hs
+++ b/HGamer3D/Bindings/Ogre/ClassSkeleton.hs
@@ -50,21 +50,16 @@
 import HGamer3D.Bindings.Ogre.EnumSkeletonAnimationBlendMode
 {-# LINE 43 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Skeleton -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 48 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Creates a brand new Bone owned by this Skeleton. 
---This method creates an unattached new BoneBoneBone::createChildNote that this method automatically generates a handle for the bone, which you can retrieve using Bone::getHandleBone
-createBone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createBone -}
+createBone :: HG3DClass -> IO (HG3DClass)
 createBone a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -73,12 +68,8 @@
   return (a2'')
 {-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Creates a brand new Bone owned by this Skeleton. 
---This method creates an unattached new BoneBoneBone::createChild
-createBone2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle - The handle to give to this new bone - must be unique within this skeleton. You should also ensure that all bone handles are eventually contiguous (this is to simplify their compilation into an indexed array of transformation matrices). For this reason it is advised that you use the simpler createBone method which automatically assigns a sequential handle starting from 0. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createBone2 -}
+createBone2 :: HG3DClass -> Int -> IO (HG3DClass)
 createBone2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -88,12 +79,8 @@
   return (a3'')
 {-# LINE 59 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Creates a brand new Bone owned by this Skeleton. 
---This method creates an unattached new BoneBoneBone::createChild
-createBone3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to give to this new bone - must be unique within this skeleton. Note that the way OGRE looks up bones is via a numeric handle, so if you name a Bone this way it will be given an automatic sequential handle. The name is just for your convenience, although it is recommended that you only use the handle to retrieve the bone in performance-critical code. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createBone3 -}
+createBone3 :: HG3DClass -> String -> IO (HG3DClass)
 createBone3 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -103,13 +90,8 @@
   return (a3'')
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Creates a brand new Bone owned by this Skeleton. 
---This method creates an unattached new BoneBoneBone::createChild
-createBone4 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name to give to this new bone - must be unique within this skeleton. 
-  ->  Int  -- ^ handle - The handle to give to this new bone - must be unique within this skeleton. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createBone4 -}
+createBone4 :: HG3DClass -> String -> Int -> IO (HG3DClass)
 createBone4 a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -120,10 +102,8 @@
   return (a4'')
 {-# LINE 72 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Returns the number of bones in this skeleton. 
-getNumBones :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumBones -}
+getNumBones :: HG3DClass -> IO (Int)
 getNumBones a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -132,11 +112,8 @@
   return (a2'')
 {-# LINE 77 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Gets the root bone of the skeleton: deprecated in favour of getRootBoneIterator. 
---The system derives the root bone the first time you ask for it. The root bone is the only bone in the skeleton which has no parent. The system locates it by taking the first bone in the list and going up the bone tree until there are no more parents, and saves this top bone as the root. If you are building the skeleton manually using createBone then you must ensure there is only one bone which is not a child of another bone, otherwise your skeleton will not work properly. If you use createBone only once, and then use Bone::createChild
-getRootBone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getRootBone -}
+getRootBone :: HG3DClass -> IO (HG3DClass)
 getRootBone a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -145,11 +122,8 @@
   return (a2'')
 {-# LINE 82 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Gets a bone by it's handle. 
-getBone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ handle
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getBone -}
+getBone :: HG3DClass -> Int -> IO (HG3DClass)
 getBone a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -159,11 +133,8 @@
   return (a3'')
 {-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Gets a bone by it's name. 
-getBone2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getBone2 -}
+getBone2 :: HG3DClass -> String -> IO (HG3DClass)
 getBone2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -173,11 +144,8 @@
   return (a3'')
 {-# LINE 94 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Returns whether this skeleton contains the named bone. 
-hasBone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
+{- function hasBone -}
+hasBone :: HG3DClass -> String -> IO (Bool)
 hasBone a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -187,22 +155,16 @@
   return (a3'')
 {-# LINE 100 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Sets the current position / orientation to be the 'binding pose' i.e. the layout in which bones were originally bound to a mesh. 
-setBindingPose :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function setBindingPose -}
+setBindingPose :: HG3DClass -> IO ()
 setBindingPose a1 =
   withHG3DClass a1 $ \a1' -> 
   setBindingPose'_ a1' >>= \res ->
   return ()
 {-# LINE 104 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Resets the position and orientation of all bones in this skeleton to their original binding position.
---A skeleton is bound to a mesh in a binding pose. Bone
-reset :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ resetManualBones - If set to true, causes the state of manual bones to be reset too, which is normally not done to allow the manual state to persist even when keyframe animation is applied. 
-  ->  IO ()
- -- ^ 
+{- function reset -}
+reset :: HG3DClass -> Bool -> IO ()
 reset a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -210,13 +172,8 @@
   return ()
 {-# LINE 109 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Creates a new Animation object for animating this skeleton. 
---
-createAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of this animation 
-  ->  Float  -- ^ length - The length of the animation in seconds 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function createAnimation -}
+createAnimation :: HG3DClass -> String -> Float -> IO (HG3DClass)
 createAnimation a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -227,11 +184,8 @@
   return (a4'')
 {-# LINE 116 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Returns the named AnimationWill pick up animations in linked skeletons (addLinkedSkeletonAnimationSource
-getAnimation2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name - The name of the animation 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAnimation2 -}
+getAnimation2 :: HG3DClass -> String -> IO (HG3DClass)
 getAnimation2 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -241,11 +195,8 @@
   return (a3'')
 {-# LINE 122 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Returns whether this skeleton contains the named animation. 
-hasAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO (Bool)
- -- ^ 
+{- function hasAnimation -}
+hasAnimation :: HG3DClass -> String -> IO (Bool)
 hasAnimation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -255,11 +206,8 @@
   return (a3'')
 {-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Removes an Animation
-removeAnimation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ name
-  ->  IO ()
- -- ^ 
+{- function removeAnimation -}
+removeAnimation :: HG3DClass -> String -> IO ()
 removeAnimation a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -267,12 +215,8 @@
   return ()
 {-# LINE 133 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Changes the state of the skeleton to reflect the application of the passed in collection of animations.
---Animating a skeleton involves both interpolating between keyframes of a specific animation, and blending between the animations themselves. Calling this method sets the state of the skeleton so that it reflects the combination of all the passed in animations, at the time index specified for each, using the weights specified. Note that the weights between animations do not have to sum to 1.0, because some animations may affect only subsets of the skeleton. If the weights exceed 1.0 for the same area of the skeleton, the movement will just be exaggerated. 
-setAnimationState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ animSet
-  ->  IO ()
- -- ^ 
+{- function setAnimationState -}
+setAnimationState :: HG3DClass -> HG3DClass -> IO ()
 setAnimationState a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -280,10 +224,8 @@
   return ()
 {-# LINE 138 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Gets the number of animations on this skeleton. 
-getNumAnimations :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getNumAnimations -}
+getNumAnimations :: HG3DClass -> IO (Int)
 getNumAnimations a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -292,12 +234,8 @@
   return (a2'')
 {-# LINE 143 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Gets a single animation by index. 
---Will NOT pick up animations in linked skeletons (addLinkedSkeletonAnimationSource
-getAnimation3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ index
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getAnimation3 -}
+getAnimation3 :: HG3DClass -> Int -> IO (HG3DClass)
 getAnimation3 a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -307,10 +245,8 @@
   return (a3'')
 {-# LINE 149 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Gets the animation blending mode which this skeleton will use. 
-getBlendMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumSkeletonAnimationBlendMode)
- -- ^ 
+{- function getBlendMode -}
+getBlendMode :: HG3DClass -> IO (EnumSkeletonAnimationBlendMode)
 getBlendMode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -319,11 +255,8 @@
   return (a2'')
 {-# LINE 154 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Sets the animation blending mode this skeleton will use. 
-setBlendMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumSkeletonAnimationBlendMode  -- ^ state
-  ->  IO ()
- -- ^ 
+{- function setBlendMode -}
+setBlendMode :: HG3DClass -> EnumSkeletonAnimationBlendMode -> IO ()
 setBlendMode a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -331,12 +264,8 @@
   return ()
 {-# LINE 159 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Optimise all of this skeleton's animations.
---Animation::optimise
-optimiseAllAnimations :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ preservingIdentityNodeTracks - If true, don't destroy identity node tracks. 
-  ->  IO ()
- -- ^ 
+{- function optimiseAllAnimations -}
+optimiseAllAnimations :: HG3DClass -> Bool -> IO ()
 optimiseAllAnimations a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -344,14 +273,8 @@
   return ()
 {-# LINE 164 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Allows you to use the animations from another Skeleton object to animate
---this skeleton.
---If you have skeletons of identical structure (that means identically named bones with identical handles, and with the same hierarchy), but slightly different proportions or binding poses, you can re-use animations from one in the other. Because animations are actually stored as changes to bones from their bind positions, it's possible to use the same animation data for different skeletons, provided the skeletal structure matches and the 'deltas' stored in the keyframes apply equally well to the other skeletons bind position (so they must be roughly similar, but don't have to be identical). You can use the 'scale' option to adjust the translation and scale keyframes where there are large differences in size between the skeletons. This method takes a skeleton name, rather than a more specific animation name, for two reasons; firstly it allows some validation of compatibility of skeletal structure, and secondly skeletons are the unit of loading. Linking a skeleton to another in this way means that the linkee will be prevented from being destroyed until the linker is destroyed.
-addLinkedSkeletonAnimationSource :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ skelName - Name of the skeleton to link animations from. This skeleton will be loaded immediately if this skeleton is already loaded, otherwise it will be loaded when this skeleton is. 
-  ->  Float  -- ^ scale - A scale factor to apply to translation and scaling elements of the keyframes in the other skeleton when applying the animations to this one. Compensates for skeleton size differences. 
-  ->  IO ()
- -- ^ 
+{- function addLinkedSkeletonAnimationSource -}
+addLinkedSkeletonAnimationSource :: HG3DClass -> String -> Float -> IO ()
 addLinkedSkeletonAnimationSource a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -360,20 +283,16 @@
   return ()
 {-# LINE 170 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Remove all links to other skeletons for the purposes of sharing animation. 
-removeAllLinkedSkeletonAnimationSources :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function removeAllLinkedSkeletonAnimationSources -}
+removeAllLinkedSkeletonAnimationSources :: HG3DClass -> IO ()
 removeAllLinkedSkeletonAnimationSources a1 =
   withHG3DClass a1 $ \a1' -> 
   removeAllLinkedSkeletonAnimationSources'_ a1' >>= \res ->
   return ()
 {-# LINE 174 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Have manual bones been modified since the skeleton was last updated? 
-getManualBonesDirty :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getManualBonesDirty -}
+getManualBonesDirty :: HG3DClass -> IO (Bool)
 getManualBonesDirty a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -382,10 +301,8 @@
   return (a2'')
 {-# LINE 179 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeleton.chs" #-}
 
--- | Are there any manually controlled bones? 
-hasManualBones :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasManualBones -}
+hasManualBones :: HG3DClass -> IO (Bool)
 hasManualBones a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassSkeletonManager.hs b/HGamer3D/Bindings/Ogre/ClassSkeletonManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassSkeletonManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassSkeletonManager.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeletonManager.chs" #-}
 
--- | Constructor. 
+{- function SkeletonManager -}
 new :: IO (HG3DClass)
- -- ^ 
 new =
   alloca $ \a1' -> 
   new'_ a1' >>= \res ->
@@ -58,20 +57,16 @@
   return (a1'')
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeletonManager.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~SkeletonManager -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeletonManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingleton -}
 getSingleton :: IO (HG3DClass)
- -- ^ 
 getSingleton =
   alloca $ \a1' -> 
   getSingleton'_ a1' >>= \res ->
@@ -79,10 +74,8 @@
   return (a1'')
 {-# LINE 55 ".\\HGamer3D\\Bindings\\Ogre\\ClassSkeletonManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingletonPtr -}
 getSingletonPtr :: IO (HG3DClass)
- -- ^ 
 getSingletonPtr =
   alloca $ \a1' -> 
   getSingletonPtr'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassTextureManager.hs b/HGamer3D/Bindings/Ogre/ClassTextureManager.hs
--- a/HGamer3D/Bindings/Ogre/ClassTextureManager.hs
+++ b/HGamer3D/Bindings/Ogre/ClassTextureManager.hs
@@ -48,21 +48,16 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassTextureManager.chs" #-}
 
--- | 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~TextureManager -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 47 ".\\HGamer3D\\Bindings\\Ogre\\ClassTextureManager.chs" #-}
 
--- | Sets the default number of mipmaps to be used for loaded textures, for when textures are loaded automatically (e.g. by MaterialThe default value is 0. 
-setDefaultNumMipmaps :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ num
-  ->  IO ()
- -- ^ 
+{- function setDefaultNumMipmaps -}
+setDefaultNumMipmaps :: HG3DClass -> Int -> IO ()
 setDefaultNumMipmaps a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -70,10 +65,8 @@
   return ()
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassTextureManager.chs" #-}
 
--- | Gets the default number of mipmaps to be used for loaded textures. 
-getDefaultNumMipmaps :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getDefaultNumMipmaps -}
+getDefaultNumMipmaps :: HG3DClass -> IO (Int)
 getDefaultNumMipmaps a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -82,10 +75,8 @@
   return (a2'')
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassTextureManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingleton -}
 getSingleton :: IO (HG3DClass)
- -- ^ 
 getSingleton =
   alloca $ \a1' -> 
   getSingleton'_ a1' >>= \res ->
@@ -93,10 +84,8 @@
   return (a1'')
 {-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassTextureManager.chs" #-}
 
--- | Override standard Singleton retrieval.
---Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll. This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors. 
+{- function getSingletonPtr -}
 getSingletonPtr :: IO (HG3DClass)
- -- ^ 
 getSingletonPtr =
   alloca $ \a1' -> 
   getSingletonPtr'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassTimeIndex.hs b/HGamer3D/Bindings/Ogre/ClassTimeIndex.hs
--- a/HGamer3D/Bindings/Ogre/ClassTimeIndex.hs
+++ b/HGamer3D/Bindings/Ogre/ClassTimeIndex.hs
@@ -48,10 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassTimeIndex.chs" #-}
 
--- | Construct time index object by the given time position. 
-new :: Float  -- ^ timePos
-  ->  IO (HG3DClass)
- -- ^ 
+{- function TimeIndex -}
+new :: Float -> IO (HG3DClass)
 new a1 =
   let {a1' = realToFrac a1} in 
   alloca $ \a2' -> 
@@ -60,10 +58,8 @@
   return (a2'')
 {-# LINE 48 ".\\HGamer3D\\Bindings\\Ogre\\ClassTimeIndex.chs" #-}
 
--- | 
-hasKeyIndex :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasKeyIndex -}
+hasKeyIndex :: HG3DClass -> IO (Bool)
 hasKeyIndex a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -72,10 +68,8 @@
   return (a2'')
 {-# LINE 53 ".\\HGamer3D\\Bindings\\Ogre\\ClassTimeIndex.chs" #-}
 
--- | 
-getTimePos :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getTimePos -}
+getTimePos :: HG3DClass -> IO (Float)
 getTimePos a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -84,10 +78,8 @@
   return (a2'')
 {-# LINE 58 ".\\HGamer3D\\Bindings\\Ogre\\ClassTimeIndex.chs" #-}
 
--- | 
-getKeyIndex :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getKeyIndex -}
+getKeyIndex :: HG3DClass -> IO (Int)
 getKeyIndex a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
diff --git a/HGamer3D/Bindings/Ogre/ClassVertexAnimationTrack.hs b/HGamer3D/Bindings/Ogre/ClassVertexAnimationTrack.hs
--- a/HGamer3D/Bindings/Ogre/ClassVertexAnimationTrack.hs
+++ b/HGamer3D/Bindings/Ogre/ClassVertexAnimationTrack.hs
@@ -52,12 +52,8 @@
 import HGamer3D.Bindings.Ogre.EnumVertexAnimationTrackTargetMode
 {-# LINE 44 ".\\HGamer3D\\Bindings\\Ogre\\ClassVertexAnimationTrack.chs" #-}
 
--- | Constructor. 
-new :: HG3DClass  -- ^ parent
-  ->  Int  -- ^ handle
-  ->  EnumVertexAnimationType  -- ^ animType
-  ->  IO (HG3DClass)
- -- ^ 
+{- function VertexAnimationTrack -}
+new :: HG3DClass -> Int -> EnumVertexAnimationType -> IO (HG3DClass)
 new a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -68,10 +64,8 @@
   return (a4'')
 {-# LINE 52 ".\\HGamer3D\\Bindings\\Ogre\\ClassVertexAnimationTrack.chs" #-}
 
--- | Get the type of vertex animation we're performing. 
-getAnimationType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumVertexAnimationType)
- -- ^ 
+{- function getAnimationType -}
+getAnimationType :: HG3DClass -> IO (EnumVertexAnimationType)
 getAnimationType a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -80,10 +74,8 @@
   return (a2'')
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassVertexAnimationTrack.chs" #-}
 
--- | Whether the vertex animation (if present) includes normals 
-getVertexAnimationIncludesNormals :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getVertexAnimationIncludesNormals -}
+getVertexAnimationIncludesNormals :: HG3DClass -> IO (Bool)
 getVertexAnimationIncludesNormals a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -92,14 +84,8 @@
   return (a2'')
 {-# LINE 62 ".\\HGamer3D\\Bindings\\Ogre\\ClassVertexAnimationTrack.chs" #-}
 
--- | Applies an animation track to the designated target.
---
-apply :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ timeIndex
-  ->  Float  -- ^ weight
-  ->  Float  -- ^ scale
-  ->  IO ()
- -- ^ 
+{- function apply -}
+apply :: HG3DClass -> HG3DClass -> Float -> Float -> IO ()
 apply a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -109,11 +95,8 @@
   return ()
 {-# LINE 69 ".\\HGamer3D\\Bindings\\Ogre\\ClassVertexAnimationTrack.chs" #-}
 
--- | Set the target mode. 
-setTargetMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumVertexAnimationTrackTargetMode  -- ^ m
-  ->  IO ()
- -- ^ 
+{- function setTargetMode -}
+setTargetMode :: HG3DClass -> EnumVertexAnimationTrackTargetMode -> IO ()
 setTargetMode a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -121,10 +104,8 @@
   return ()
 {-# LINE 74 ".\\HGamer3D\\Bindings\\Ogre\\ClassVertexAnimationTrack.chs" #-}
 
--- | Get the target mode. 
-getTargetMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumVertexAnimationTrackTargetMode)
- -- ^ 
+{- function getTargetMode -}
+getTargetMode :: HG3DClass -> IO (EnumVertexAnimationTrackTargetMode)
 getTargetMode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -133,11 +114,8 @@
   return (a2'')
 {-# LINE 79 ".\\HGamer3D\\Bindings\\Ogre\\ClassVertexAnimationTrack.chs" #-}
 
--- | Method to determine if this track has any KeyFrames which are
---
-hasNonZeroKeyFrames :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function hasNonZeroKeyFrames -}
+hasNonZeroKeyFrames :: HG3DClass -> IO (Bool)
 hasNonZeroKeyFrames a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -146,10 +124,8 @@
   return (a2'')
 {-# LINE 84 ".\\HGamer3D\\Bindings\\Ogre\\ClassVertexAnimationTrack.chs" #-}
 
--- | Optimise the current track by removing any duplicate keyframes. 
-optimise :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function optimise -}
+optimise :: HG3DClass -> IO ()
 optimise a1 =
   withHG3DClass a1 $ \a1' -> 
   optimise'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassViewport.hs b/HGamer3D/Bindings/Ogre/ClassViewport.hs
--- a/HGamer3D/Bindings/Ogre/ClassViewport.hs
+++ b/HGamer3D/Bindings/Ogre/ClassViewport.hs
@@ -54,16 +54,8 @@
 import HGamer3D.Bindings.Ogre.StructVec2
 {-# LINE 45 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | The usual constructor. 
-new :: HG3DClass  -- ^ camera
-  ->  HG3DClass  -- ^ target - Pointer to the render target to be the destination for the rendering. 
-  ->  Float  -- ^ left
-  ->  Float  -- ^ top
-  ->  Float  -- ^ width
-  ->  Float  -- ^ height - Dimensions of the viewport, expressed as a value between 0 and 1. This allows the dimensions to apply irrespective of changes in the target's size: e.g. to fill the whole area, values of 0,0,1,1 are appropriate. 
-  ->  Int  -- ^ ZOrder - Relative Z-order on the target. Lower = further to the front. 
-  ->  IO (HG3DClass)
- -- ^ 
+{- function Viewport -}
+new :: HG3DClass -> HG3DClass -> Float -> Float -> Float -> Float -> Int -> IO (HG3DClass)
 new a1 a2 a3 a4 a5 a6 a7 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -78,34 +70,24 @@
   return (a8'')
 {-# LINE 57 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Default destructor. 
-delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
-  ->  IO ()
- -- ^ 
+{- function ~Viewport -}
+delete :: HG3DClass -> IO ()
 delete a1 =
   withHG3DClass a1 $ \a1' -> 
   delete'_ a1' >>= \res ->
   return ()
 {-# LINE 61 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Instructs the viewport to updates its contents. 
-update :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO ()
- -- ^ 
+{- function update -}
+update :: HG3DClass -> IO ()
 update a1 =
   withHG3DClass a1 $ \a1' -> 
   update'_ a1' >>= \res ->
   return ()
 {-# LINE 65 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Instructs the viewport to clear itself, without performing an update. You would not normally call this method when updating the viewport, since the viewport usually clears itself when updating anyway (Viewport::setClearEveryFrame
-clear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ buffers - Bitmask identifying which buffer elements to clear 
-  ->  Colour  -- ^ colour - The colour value to clear to, if FBT_COLOUR is included 
-  ->  Float  -- ^ depth - The depth value to clear to, if FBT_DEPTH is included 
-  ->  Int  -- ^ stencil - The stencil value to clear to, if FBT_STENCIL is included 
-  ->  IO ()
- -- ^ 
+{- function clear -}
+clear :: HG3DClass -> Int -> Colour -> Float -> Int -> IO ()
 clear a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -116,10 +98,8 @@
   return ()
 {-# LINE 73 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Retrieves a pointer to the render target for this viewport. 
-getTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getTarget -}
+getTarget :: HG3DClass -> IO (HG3DClass)
 getTarget a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -128,10 +108,8 @@
   return (a2'')
 {-# LINE 78 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Retrieves a pointer to the camera for this viewport. 
-getCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (HG3DClass)
- -- ^ 
+{- function getCamera -}
+getCamera :: HG3DClass -> IO (HG3DClass)
 getCamera a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -140,11 +118,8 @@
   return (a2'')
 {-# LINE 83 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Sets the camera to use for rendering to this viewport. 
-setCamera :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  HG3DClass  -- ^ cam
-  ->  IO ()
- -- ^ 
+{- function setCamera -}
+setCamera :: HG3DClass -> HG3DClass -> IO ()
 setCamera a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withHG3DClass a2 $ \a2' -> 
@@ -152,10 +127,8 @@
   return ()
 {-# LINE 88 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets the Z-Order of this viewport. 
-getZOrder :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getZOrder -}
+getZOrder :: HG3DClass -> IO (Int)
 getZOrder a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -164,10 +137,8 @@
   return (a2'')
 {-# LINE 93 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets one of the relative dimensions of the viewport, a value between 0.0 and 1.0. 
-getLeft :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getLeft -}
+getLeft :: HG3DClass -> IO (Float)
 getLeft a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -176,10 +147,8 @@
   return (a2'')
 {-# LINE 98 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets one of the relative dimensions of the viewport, a value between 0.0 and 1.0. 
-getTop :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getTop -}
+getTop :: HG3DClass -> IO (Float)
 getTop a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -188,10 +157,8 @@
   return (a2'')
 {-# LINE 103 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets one of the relative dimensions of the viewport, a value between 0.0 and 1.0. 
-getWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getWidth -}
+getWidth :: HG3DClass -> IO (Float)
 getWidth a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -200,10 +167,8 @@
   return (a2'')
 {-# LINE 108 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets one of the relative dimensions of the viewport, a value between 0.0 and 1.0. 
-getHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getHeight -}
+getHeight :: HG3DClass -> IO (Float)
 getHeight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -212,10 +177,8 @@
   return (a2'')
 {-# LINE 113 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets one of the actual dimensions of the viewport, a value in pixels. 
-getActualLeft :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getActualLeft -}
+getActualLeft :: HG3DClass -> IO (Int)
 getActualLeft a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -224,10 +187,8 @@
   return (a2'')
 {-# LINE 118 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets one of the actual dimensions of the viewport, a value in pixels. 
-getActualTop :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getActualTop -}
+getActualTop :: HG3DClass -> IO (Int)
 getActualTop a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -236,10 +197,8 @@
   return (a2'')
 {-# LINE 123 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets one of the actual dimensions of the viewport, a value in pixels. 
-getActualWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getActualWidth -}
+getActualWidth :: HG3DClass -> IO (Int)
 getActualWidth a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -248,10 +207,8 @@
   return (a2'')
 {-# LINE 128 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets one of the actual dimensions of the viewport, a value in pixels. 
-getActualHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getActualHeight -}
+getActualHeight :: HG3DClass -> IO (Int)
 getActualHeight a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -260,14 +217,8 @@
   return (a2'')
 {-# LINE 133 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Sets the dimensions (after creation). 
-setDimensions :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ left
-  ->  Float  -- ^ top
-  ->  Float  -- ^ width
-  ->  Float  -- ^ height - Dimensions relative to the size of the target, represented as real values between 0 and 1. i.e. the full target area is 0, 0, 1, 1. 
-  ->  IO ()
- -- ^ 
+{- function setDimensions -}
+setDimensions :: HG3DClass -> Float -> Float -> Float -> Float -> IO ()
 setDimensions a1 a2 a3 a4 a5 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -278,12 +229,8 @@
   return ()
 {-# LINE 141 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Set the orientation mode of the viewport. 
-setOrientationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  EnumOrientationMode  -- ^ orientationMode
-  ->  Bool  -- ^ setDefault
-  ->  IO ()
- -- ^ 
+{- function setOrientationMode -}
+setOrientationMode :: HG3DClass -> EnumOrientationMode -> Bool -> IO ()
 setOrientationMode a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = cIntFromEnum a2} in 
@@ -292,10 +239,8 @@
   return ()
 {-# LINE 147 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Get the orientation mode of the viewport. 
-getOrientationMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (EnumOrientationMode)
- -- ^ 
+{- function getOrientationMode -}
+getOrientationMode :: HG3DClass -> IO (EnumOrientationMode)
 getOrientationMode a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -304,11 +249,8 @@
   return (a2'')
 {-# LINE 152 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Sets the initial background colour of the viewport (before rendering). 
-setBackgroundColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Colour  -- ^ colour
-  ->  IO ()
- -- ^ 
+{- function setBackgroundColour -}
+setBackgroundColour :: HG3DClass -> Colour -> IO ()
 setBackgroundColour a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withColour a2 $ \a2' -> 
@@ -316,10 +258,8 @@
   return ()
 {-# LINE 157 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets the background colour. 
-getBackgroundColour :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Colour)
- -- ^ 
+{- function getBackgroundColour -}
+getBackgroundColour :: HG3DClass -> IO (Colour)
 getBackgroundColour a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -328,11 +268,8 @@
   return (a2'')
 {-# LINE 162 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Sets the initial depth buffer value of the viewport (before rendering). Default is 1 
-setDepthClear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ depth
-  ->  IO ()
- -- ^ 
+{- function setDepthClear -}
+setDepthClear :: HG3DClass -> Float -> IO ()
 setDepthClear a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -340,10 +277,8 @@
   return ()
 {-# LINE 167 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets the default depth buffer value to which the viewport is cleared. 
-getDepthClear :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Float)
- -- ^ 
+{- function getDepthClear -}
+getDepthClear :: HG3DClass -> IO (Float)
 getDepthClear a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -352,13 +287,8 @@
   return (a2'')
 {-# LINE 172 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Determines whether to clear the viewport before rendering.
---You can use this method to set which buffers are cleared (if any) before rendering every frame. 
-setClearEveryFrame :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ clear - Whether or not to clear any buffers 
-  ->  Int  -- ^ buffers - One or more values from FrameBufferType denoting which buffers to clear, if clear is set to true. Note you should not clear the stencil buffer here unless you know what you're doing. 
-  ->  IO ()
- -- ^ 
+{- function setClearEveryFrame -}
+setClearEveryFrame :: HG3DClass -> Bool -> Int -> IO ()
 setClearEveryFrame a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -367,10 +297,8 @@
   return ()
 {-# LINE 178 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Determines if the viewport is cleared before every frame. 
-getClearEveryFrame :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getClearEveryFrame -}
+getClearEveryFrame :: HG3DClass -> IO (Bool)
 getClearEveryFrame a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -379,10 +307,8 @@
   return (a2'')
 {-# LINE 183 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets which buffers are to be cleared each frame. 
-getClearBuffers :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getClearBuffers -}
+getClearBuffers :: HG3DClass -> IO (Int)
 getClearBuffers a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -391,13 +317,8 @@
   return (a2'')
 {-# LINE 188 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Sets whether this viewport should be automatically updated 
---if Ogre's rendering loop or RenderTarget::update is being used.
---By default, if you use OgreRoot::startRenderingRenderTarget::update
-setAutoUpdated :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ autoupdate - If true, the viewport is updated during the automatic render loop or when RenderTarget::update() is called. If false, the viewport is only updated when its update() method is called explicitly. 
-  ->  IO ()
- -- ^ 
+{- function setAutoUpdated -}
+setAutoUpdated :: HG3DClass -> Bool -> IO ()
 setAutoUpdated a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -405,10 +326,8 @@
   return ()
 {-# LINE 193 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets whether this viewport is automatically updated if OgreRenderTarget::update
-isAutoUpdated :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function isAutoUpdated -}
+isAutoUpdated :: HG3DClass -> IO (Bool)
 isAutoUpdated a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -417,12 +336,8 @@
   return (a2'')
 {-# LINE 198 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Set the material scheme which the viewport should use.
---This allows you to tell the system to use a particular material scheme when rendering this viewport, which can involve using different techniques to render your materials. Technique::setSchemeName 
-setMaterialScheme :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ schemeName
-  ->  IO ()
- -- ^ 
+{- function setMaterialScheme -}
+setMaterialScheme :: HG3DClass -> String -> IO ()
 setMaterialScheme a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -430,10 +345,8 @@
   return ()
 {-# LINE 203 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Get the material scheme which the viewport should use. 
-getMaterialScheme :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getMaterialScheme -}
+getMaterialScheme :: HG3DClass -> IO (String)
 getMaterialScheme a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -442,10 +355,8 @@
   return (a2'')
 {-# LINE 208 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Access to actual dimensions (based on target size). 
-getActualDimensions :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int, Int, Int, Int)
- -- ^ left
+{- function getActualDimensions -}
+getActualDimensions :: HG3DClass -> IO (Int, Int, Int, Int)
 getActualDimensions a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -460,12 +371,8 @@
   return (a2'', a3'', a4'', a5'')
 {-# LINE 216 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Tells this viewport whether it should display Overlay objects.
---Overlay objects are layers which appear on top of the scene. They are created via SceneManager::createOverlay and every viewport displays these by default. However, you probably don't want this if you're using multiple viewports, because one of them is probably a picture-in-picture which is not supposed to have overlays of it's own. In this case you can turn off overlays on this viewport by calling this method. 
-setOverlaysEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled - If true, any overlays are displayed, if false they are not. 
-  ->  IO ()
- -- ^ 
+{- function setOverlaysEnabled -}
+setOverlaysEnabled :: HG3DClass -> Bool -> IO ()
 setOverlaysEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -473,10 +380,8 @@
   return ()
 {-# LINE 221 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Returns whether or not Overlay objects (created in the SceneManager
-getOverlaysEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getOverlaysEnabled -}
+getOverlaysEnabled :: HG3DClass -> IO (Bool)
 getOverlaysEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -485,12 +390,8 @@
   return (a2'')
 {-# LINE 226 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Tells this viewport whether it should display skies.
---Skies are layers which appear on background of the scene. They are created via SceneManager::setSkyBoxSceneManager::setSkyPlaneSceneManager::setSkyDome
-setSkiesEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled - If true, any skies are displayed, if false they are not. 
-  ->  IO ()
- -- ^ 
+{- function setSkiesEnabled -}
+setSkiesEnabled :: HG3DClass -> Bool -> IO ()
 setSkiesEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -498,10 +399,8 @@
   return ()
 {-# LINE 231 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Returns whether or not skies (created in the SceneManager
-getSkiesEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getSkiesEnabled -}
+getSkiesEnabled :: HG3DClass -> IO (Bool)
 getSkiesEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -510,12 +409,8 @@
   return (a2'')
 {-# LINE 236 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Tells this viewport whether it should display shadows.
---This setting enables you to disable shadow rendering for a given viewport. The global shadow technique set on SceneManager
-setShadowsEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Bool  -- ^ enabled - If true, any shadows are displayed, if false they are not. 
-  ->  IO ()
- -- ^ 
+{- function setShadowsEnabled -}
+setShadowsEnabled :: HG3DClass -> Bool -> IO ()
 setShadowsEnabled a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromBool a2} in 
@@ -523,10 +418,8 @@
   return ()
 {-# LINE 241 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Returns whether or not shadows (defined in the SceneManager
-getShadowsEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Bool)
- -- ^ 
+{- function getShadowsEnabled -}
+getShadowsEnabled :: HG3DClass -> IO (Bool)
 getShadowsEnabled a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -535,12 +428,8 @@
   return (a2'')
 {-# LINE 246 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Sets a per-viewport visibility mask.
---The visibility mask is a way to exclude objects from rendering for a given viewport. For each object in the frustum, a check is made between this mask and the objects visibility flags (MovableObject::setVisibilityFlags
-setVisibilityMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Int  -- ^ mask
-  ->  IO ()
- -- ^ 
+{- function setVisibilityMask -}
+setVisibilityMask :: HG3DClass -> Int -> IO ()
 setVisibilityMask a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = fromIntegral a2} in 
@@ -548,11 +437,8 @@
   return ()
 {-# LINE 251 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets a per-viewport visibility mask.
---Viewport::setVisibilityMask
-getVisibilityMask :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (Int)
- -- ^ 
+{- function getVisibilityMask -}
+getVisibilityMask :: HG3DClass -> IO (Int)
 getVisibilityMask a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -561,13 +447,8 @@
   return (a2'')
 {-# LINE 256 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Sets the use of a custom RenderQueueInvocationSequence for
---rendering this target.
---RenderQueueInvocationSequence instances are managed through RootRenderTargetRoot
-setRenderQueueInvocationSequenceName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  String  -- ^ sequenceName
-  ->  IO ()
- -- ^ 
+{- function setRenderQueueInvocationSequenceName -}
+setRenderQueueInvocationSequenceName :: HG3DClass -> String -> IO ()
 setRenderQueueInvocationSequenceName a1 a2 =
   withHG3DClass a1 $ \a1' -> 
   withCString a2 $ \a2' -> 
@@ -575,10 +456,8 @@
   return ()
 {-# LINE 261 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Gets the name of the render queue invocation sequence for this target. 
-getRenderQueueInvocationSequenceName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  IO (String)
- -- ^ 
+{- function getRenderQueueInvocationSequenceName -}
+getRenderQueueInvocationSequenceName :: HG3DClass -> IO (String)
 getRenderQueueInvocationSequenceName a1 =
   withHG3DClass a1 $ \a1' -> 
   alloc64k $ \a2' -> 
@@ -587,12 +466,8 @@
   return (a2'')
 {-# LINE 266 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Convert oriented input point coordinates to screen coordinates. 
-pointOrientedToScreen :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Vec2  -- ^ v
-  ->  Int  -- ^ orientationMode
-  ->  IO (Vec2)
- -- ^ outv
+{- function pointOrientedToScreen -}
+pointOrientedToScreen :: HG3DClass -> Vec2 -> Int -> IO (Vec2)
 pointOrientedToScreen a1 a2 a3 =
   withHG3DClass a1 $ \a1' -> 
   withVec2 a2 $ \a2' -> 
@@ -603,13 +478,8 @@
   return (a4'')
 {-# LINE 273 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | 
-pointOrientedToScreen2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
-  ->  Float  -- ^ orientedX
-  ->  Float  -- ^ orientedY
-  ->  Int  -- ^ orientationMode
-  ->  IO (Float, Float)
- -- ^ screenX
+{- function pointOrientedToScreen2 -}
+pointOrientedToScreen2 :: HG3DClass -> Float -> Float -> Int -> IO (Float, Float)
 pointOrientedToScreen2 a1 a2 a3 a4 =
   withHG3DClass a1 $ \a1' -> 
   let {a2' = realToFrac a2} in 
@@ -623,19 +493,16 @@
   return (a5'', a6'')
 {-# LINE 282 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Set the initial orientation mode of viewports. 
-setDefaultOrientationMode :: EnumOrientationMode  -- ^ orientationMode
-  ->  IO ()
- -- ^ 
+{- function setDefaultOrientationMode -}
+setDefaultOrientationMode :: EnumOrientationMode -> IO ()
 setDefaultOrientationMode a1 =
   let {a1' = cIntFromEnum a1} in 
   setDefaultOrientationMode'_ a1' >>= \res ->
   return ()
 {-# LINE 286 ".\\HGamer3D\\Bindings\\Ogre\\ClassViewport.chs" #-}
 
--- | Get the initial orientation mode of viewports. 
+{- function getDefaultOrientationMode -}
 getDefaultOrientationMode :: IO (EnumOrientationMode)
- -- ^ 
 getDefaultOrientationMode =
   alloca $ \a1' -> 
   getDefaultOrientationMode'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/ClassWindowEventUtilities.hs b/HGamer3D/Bindings/Ogre/ClassWindowEventUtilities.hs
--- a/HGamer3D/Bindings/Ogre/ClassWindowEventUtilities.hs
+++ b/HGamer3D/Bindings/Ogre/ClassWindowEventUtilities.hs
@@ -48,9 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassWindowEventUtilities.chs" #-}
 
--- | Call this once per frame if not using Root
+{- function messagePump -}
 messagePump :: IO ()
- -- ^ 
 messagePump =
   messagePump'_ >>= \res ->
   return ()
diff --git a/HGamer3D/Bindings/Ogre/ClassWindowUtilsHG3D.hs b/HGamer3D/Bindings/Ogre/ClassWindowUtilsHG3D.hs
--- a/HGamer3D/Bindings/Ogre/ClassWindowUtilsHG3D.hs
+++ b/HGamer3D/Bindings/Ogre/ClassWindowUtilsHG3D.hs
@@ -48,10 +48,8 @@
 import HGamer3D.Bindings.Ogre.StructHG3DClass
 {-# LINE 42 ".\\HGamer3D\\Bindings\\Ogre\\ClassWindowUtilsHG3D.chs" #-}
 
--- | 
-getWindowTopLeft :: HG3DClass  -- ^ rwind
-  ->  IO (Int, Int, Int, Int)
- -- ^ top
+{- function getWindowTopLeft -}
+getWindowTopLeft :: HG3DClass -> IO (Int, Int, Int, Int)
 getWindowTopLeft a1 =
   withHG3DClass a1 $ \a1' -> 
   alloca $ \a2' -> 
@@ -66,10 +64,8 @@
   return (a2'', a3'', a4'', a5'')
 {-# LINE 51 ".\\HGamer3D\\Bindings\\Ogre\\ClassWindowUtilsHG3D.chs" #-}
 
--- | 
-showCursor :: Bool  -- ^ fShow
-  ->  IO ()
- -- ^ 
+{- function showCursor -}
+showCursor :: Bool -> IO ()
 showCursor a1 =
   let {a1' = fromBool a1} in 
   showCursor'_ a1' >>= \res ->
diff --git a/HGamer3D/Bindings/Ogre/EnumAnimationInterpolationMode.hs b/HGamer3D/Bindings/Ogre/EnumAnimationInterpolationMode.hs
--- a/HGamer3D/Bindings/Ogre/EnumAnimationInterpolationMode.hs
+++ b/HGamer3D/Bindings/Ogre/EnumAnimationInterpolationMode.hs
@@ -42,9 +42,6 @@
 import HGamer3D.Data.Angle
 
 
-data EnumAnimationInterpolationMode =
-   -- |  Values are interpolated along straight lines. 
-    IM_LINEAR
-   -- |  Values are interpolated along a spline, resulting in smoother changes in direction. 
-                                       | IM_SPLINE
+data EnumAnimationInterpolationMode = IM_LINEAR
+                                    | IM_SPLINE
                                     deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumAnimationRotationInterpolationMode.hs b/HGamer3D/Bindings/Ogre/EnumAnimationRotationInterpolationMode.hs
--- a/HGamer3D/Bindings/Ogre/EnumAnimationRotationInterpolationMode.hs
+++ b/HGamer3D/Bindings/Ogre/EnumAnimationRotationInterpolationMode.hs
@@ -42,9 +42,6 @@
 import HGamer3D.Data.Angle
 
 
-data EnumAnimationRotationInterpolationMode =
-   -- |  Values are interpolated linearly. This is faster but does not necessarily give a completely accurate result. 
-    RIM_LINEAR
-   -- |  Values are interpolated spherically. This is more accurate but has a higher cost. 
-                                               | RIM_SPHERICAL
+data EnumAnimationRotationInterpolationMode = RIM_LINEAR
+                                            | RIM_SPHERICAL
                                             deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumAxisAlignedBoxCorner.hs b/HGamer3D/Bindings/Ogre/EnumAxisAlignedBoxCorner.hs
--- a/HGamer3D/Bindings/Ogre/EnumAxisAlignedBoxCorner.hs
+++ b/HGamer3D/Bindings/Ogre/EnumAxisAlignedBoxCorner.hs
@@ -42,23 +42,14 @@
 import HGamer3D.Data.Angle
 
 
-data EnumAxisAlignedBoxCorner =
-   -- | 
-    CE_FAR_LEFT_BOTTOM
-   -- | 
-                                 | CE_FAR_LEFT_TOP
-   -- | 
-                                 | CE_FAR_RIGHT_TOP
-   -- | 
-                                 | CE_FAR_RIGHT_BOTTOM
-   -- | 
-                                 | CE_NEAR_RIGHT_BOTTOM
-   -- | 
-                                 | CE_NEAR_LEFT_BOTTOM
-   -- | 
-                                 | CE_NEAR_LEFT_TOP
-   -- | 
-                                 | CE_NEAR_RIGHT_TOP
+data EnumAxisAlignedBoxCorner = CE_FAR_LEFT_BOTTOM
+                              | CE_FAR_LEFT_TOP
+                              | CE_FAR_RIGHT_TOP
+                              | CE_FAR_RIGHT_BOTTOM
+                              | CE_NEAR_RIGHT_BOTTOM
+                              | CE_NEAR_LEFT_BOTTOM
+                              | CE_NEAR_LEFT_TOP
+                              | CE_NEAR_RIGHT_TOP
                               deriving (Eq)
 instance Enum EnumAxisAlignedBoxCorner where
   fromEnum CE_FAR_LEFT_BOTTOM = 0
diff --git a/HGamer3D/Bindings/Ogre/EnumAxisAlignedBoxExtent.hs b/HGamer3D/Bindings/Ogre/EnumAxisAlignedBoxExtent.hs
--- a/HGamer3D/Bindings/Ogre/EnumAxisAlignedBoxExtent.hs
+++ b/HGamer3D/Bindings/Ogre/EnumAxisAlignedBoxExtent.hs
@@ -42,11 +42,7 @@
 import HGamer3D.Data.Angle
 
 
-data EnumAxisAlignedBoxExtent =
-   -- | 
-    EXTENT_NULL
-   -- | 
-                                 | EXTENT_FINITE
-   -- | 
-                                 | EXTENT_INFINITE
+data EnumAxisAlignedBoxExtent = EXTENT_NULL
+                              | EXTENT_FINITE
+                              | EXTENT_INFINITE
                               deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumBillboardChainTexCoordDirection.hs b/HGamer3D/Bindings/Ogre/EnumBillboardChainTexCoordDirection.hs
--- a/HGamer3D/Bindings/Ogre/EnumBillboardChainTexCoordDirection.hs
+++ b/HGamer3D/Bindings/Ogre/EnumBillboardChainTexCoordDirection.hs
@@ -42,9 +42,6 @@
 import HGamer3D.Data.Angle
 
 
-data EnumBillboardChainTexCoordDirection =
-   -- | Tex coord in elements is treated as the 'u' texture coordinate. 
-    TCD_U
-   -- | Tex coord in elements is treated as the 'v' texture coordinate. 
-                                            | TCD_V
+data EnumBillboardChainTexCoordDirection = TCD_U
+                                         | TCD_V
                                          deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumBillboardOrigin.hs b/HGamer3D/Bindings/Ogre/EnumBillboardOrigin.hs
--- a/HGamer3D/Bindings/Ogre/EnumBillboardOrigin.hs
+++ b/HGamer3D/Bindings/Ogre/EnumBillboardOrigin.hs
@@ -42,23 +42,13 @@
 import HGamer3D.Data.Angle
 
 
-data EnumBillboardOrigin =
-   -- | 
-    BBO_TOP_LEFT
-   -- | 
-                            | BBO_TOP_CENTER
-   -- | 
-                            | BBO_TOP_RIGHT
-   -- | 
-                            | BBO_CENTER_LEFT
-   -- | 
-                            | BBO_CENTER
-   -- | 
-                            | BBO_CENTER_RIGHT
-   -- | 
-                            | BBO_BOTTOM_LEFT
-   -- | 
-                            | BBO_BOTTOM_CENTER
-   -- | 
-                            | BBO_BOTTOM_RIGHT
+data EnumBillboardOrigin = BBO_TOP_LEFT
+                         | BBO_TOP_CENTER
+                         | BBO_TOP_RIGHT
+                         | BBO_CENTER_LEFT
+                         | BBO_CENTER
+                         | BBO_CENTER_RIGHT
+                         | BBO_BOTTOM_LEFT
+                         | BBO_BOTTOM_CENTER
+                         | BBO_BOTTOM_RIGHT
                          deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumBillboardRotationType.hs b/HGamer3D/Bindings/Ogre/EnumBillboardRotationType.hs
--- a/HGamer3D/Bindings/Ogre/EnumBillboardRotationType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumBillboardRotationType.hs
@@ -42,9 +42,6 @@
 import HGamer3D.Data.Angle
 
 
-data EnumBillboardRotationType =
-   -- | Rotate the billboard's vertices around their facing direction. 
-    BBR_VERTEX
-   -- | Rotate the billboard's texture coordinates. 
-                                  | BBR_TEXCOORD
+data EnumBillboardRotationType = BBR_VERTEX
+                               | BBR_TEXCOORD
                                deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumBillboardType.hs b/HGamer3D/Bindings/Ogre/EnumBillboardType.hs
--- a/HGamer3D/Bindings/Ogre/EnumBillboardType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumBillboardType.hs
@@ -42,15 +42,9 @@
 import HGamer3D.Data.Angle
 
 
-data EnumBillboardType =
-   -- | Standard point billboard (default), always faces the camera completely and is always upright. 
-    BBT_POINT
-   -- | Billboards are oriented around a shared direction vector (used as Y axis) and only rotate around this to face the camera. 
-                          | BBT_ORIENTED_COMMON
-   -- | Billboards are oriented around their own direction vector (their own Y axis) and only rotate around this to face the camera. 
-                          | BBT_ORIENTED_SELF
-   -- | Billboards are perpendicular to a shared direction vector (used as Z axis, the facing direction) and X, Y axis are determined by a shared up-vertor. 
-                          | BBT_PERPENDICULAR_COMMON
-   -- | Billboards are perpendicular to their own direction vector (their own Z axis, the facing direction) and X, Y axis are determined by a shared up-vertor. 
-                          | BBT_PERPENDICULAR_SELF
+data EnumBillboardType = BBT_POINT
+                       | BBT_ORIENTED_COMMON
+                       | BBT_ORIENTED_SELF
+                       | BBT_PERPENDICULAR_COMMON
+                       | BBT_PERPENDICULAR_SELF
                        deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumDataStreamAccessMode.hs b/HGamer3D/Bindings/Ogre/EnumDataStreamAccessMode.hs
--- a/HGamer3D/Bindings/Ogre/EnumDataStreamAccessMode.hs
+++ b/HGamer3D/Bindings/Ogre/EnumDataStreamAccessMode.hs
@@ -42,11 +42,8 @@
 import HGamer3D.Data.Angle
 
 
-data EnumDataStreamAccessMode =
-   -- | 
-    AM_READ
-   -- | 
-                                 | AM_WRITE
+data EnumDataStreamAccessMode = AM_READ
+                              | AM_WRITE
                               deriving (Eq)
 instance Enum EnumDataStreamAccessMode where
   fromEnum AM_READ = 1
diff --git a/HGamer3D/Bindings/Ogre/EnumEntityVertexDataBindChoice.hs b/HGamer3D/Bindings/Ogre/EnumEntityVertexDataBindChoice.hs
--- a/HGamer3D/Bindings/Ogre/EnumEntityVertexDataBindChoice.hs
+++ b/HGamer3D/Bindings/Ogre/EnumEntityVertexDataBindChoice.hs
@@ -42,13 +42,8 @@
 import HGamer3D.Data.Angle
 
 
-data EnumEntityVertexDataBindChoice =
-   -- | 
-    BIND_ORIGINAL
-   -- | 
-                                       | BIND_SOFTWARE_SKELETAL
-   -- | 
-                                       | BIND_SOFTWARE_MORPH
-   -- | 
-                                       | BIND_HARDWARE_MORPH
+data EnumEntityVertexDataBindChoice = BIND_ORIGINAL
+                                    | BIND_SOFTWARE_SKELETAL
+                                    | BIND_SOFTWARE_MORPH
+                                    | BIND_HARDWARE_MORPH
                                     deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumExceptionCode.hs b/HGamer3D/Bindings/Ogre/EnumExceptionCode.hs
--- a/HGamer3D/Bindings/Ogre/EnumExceptionCode.hs
+++ b/HGamer3D/Bindings/Ogre/EnumExceptionCode.hs
@@ -42,25 +42,14 @@
 import HGamer3D.Data.Angle
 
 
-data EnumExceptionCode =
-   -- | 
-    ERR_CANNOT_WRITE_TO_FILE
-   -- | 
-                          | ERR_INVALID_STATE
-   -- | 
-                          | ERR_INVALIDPARAMS
-   -- | 
-                          | ERR_RENDERINGAPI_ERROR
-   -- | 
-                          | ERR_DUPLICATE_ITEM
-   -- | 
-                          | ERR_ITEM_NOT_FOUND
-   -- | 
-                          | ERR_FILE_NOT_FOUND
-   -- | 
-                          | ERR_INTERNAL_ERROR
-   -- | 
-                          | ERR_RT_ASSERTION_FAILED
-   -- | 
-                          | ERR_NOT_IMPLEMENTED
+data EnumExceptionCode = ERR_CANNOT_WRITE_TO_FILE
+                       | ERR_INVALID_STATE
+                       | ERR_INVALIDPARAMS
+                       | ERR_RENDERINGAPI_ERROR
+                       | ERR_DUPLICATE_ITEM
+                       | ERR_ITEM_NOT_FOUND
+                       | ERR_FILE_NOT_FOUND
+                       | ERR_INTERNAL_ERROR
+                       | ERR_RT_ASSERTION_FAILED
+                       | ERR_NOT_IMPLEMENTED
                        deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumFrustumPlane.hs b/HGamer3D/Bindings/Ogre/EnumFrustumPlane.hs
--- a/HGamer3D/Bindings/Ogre/EnumFrustumPlane.hs
+++ b/HGamer3D/Bindings/Ogre/EnumFrustumPlane.hs
@@ -42,19 +42,12 @@
 import HGamer3D.Data.Angle
 
 
-data EnumFrustumPlane =
-   -- | 
-    FRUSTUM_PLANE_NEAR
-   -- | 
-                         | FRUSTUM_PLANE_FAR
-   -- | 
-                         | FRUSTUM_PLANE_LEFT
-   -- | 
-                         | FRUSTUM_PLANE_RIGHT
-   -- | 
-                         | FRUSTUM_PLANE_TOP
-   -- | 
-                         | FRUSTUM_PLANE_BOTTOM
+data EnumFrustumPlane = FRUSTUM_PLANE_NEAR
+                      | FRUSTUM_PLANE_FAR
+                      | FRUSTUM_PLANE_LEFT
+                      | FRUSTUM_PLANE_RIGHT
+                      | FRUSTUM_PLANE_TOP
+                      | FRUSTUM_PLANE_BOTTOM
                       deriving (Eq)
 instance Enum EnumFrustumPlane where
   fromEnum FRUSTUM_PLANE_NEAR = 0
diff --git a/HGamer3D/Bindings/Ogre/EnumGpuProgramType.hs b/HGamer3D/Bindings/Ogre/EnumGpuProgramType.hs
--- a/HGamer3D/Bindings/Ogre/EnumGpuProgramType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumGpuProgramType.hs
@@ -42,11 +42,7 @@
 import HGamer3D.Data.Angle
 
 
-data EnumGpuProgramType =
-   -- | 
-    GPT_VERTEX_PROGRAM
-   -- | 
-                           | GPT_FRAGMENT_PROGRAM
-   -- | 
-                           | GPT_GEOMETRY_PROGRAM
+data EnumGpuProgramType = GPT_VERTEX_PROGRAM
+                        | GPT_FRAGMENT_PROGRAM
+                        | GPT_GEOMETRY_PROGRAM
                         deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumLightType.hs b/HGamer3D/Bindings/Ogre/EnumLightType.hs
--- a/HGamer3D/Bindings/Ogre/EnumLightType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumLightType.hs
@@ -42,13 +42,9 @@
 import HGamer3D.Data.Angle
 
 
-data EnumLightType =
-   -- | Point light sources give off light equally in all directions, so require only position not direction. 
-    LT_POINT
-   -- | Directional lights simulate parallel light beams from a distant source, hence have direction but no position. 
-                      | LT_DIRECTIONAL
-   -- | Spotlights simulate a cone of light from a source so require position and direction, plus extra values for falloff. 
-                      | LT_SPOTLIGHT
+data EnumLightType = LT_POINT
+                   | LT_DIRECTIONAL
+                   | LT_SPOTLIGHT
                    deriving (Eq)
 instance Enum EnumLightType where
   fromEnum LT_POINT = 0
diff --git a/HGamer3D/Bindings/Ogre/EnumLogMessageLevel.hs b/HGamer3D/Bindings/Ogre/EnumLogMessageLevel.hs
--- a/HGamer3D/Bindings/Ogre/EnumLogMessageLevel.hs
+++ b/HGamer3D/Bindings/Ogre/EnumLogMessageLevel.hs
@@ -42,13 +42,9 @@
 import HGamer3D.Data.Angle
 
 
-data EnumLogMessageLevel =
-   -- | 
-    LML_TRIVIAL
-   -- | 
-                            | LML_NORMAL
-   -- | 
-                            | LML_CRITICAL
+data EnumLogMessageLevel = LML_TRIVIAL
+                         | LML_NORMAL
+                         | LML_CRITICAL
                          deriving (Eq)
 instance Enum EnumLogMessageLevel where
   fromEnum LML_TRIVIAL = 1
diff --git a/HGamer3D/Bindings/Ogre/EnumLoggingLevel.hs b/HGamer3D/Bindings/Ogre/EnumLoggingLevel.hs
--- a/HGamer3D/Bindings/Ogre/EnumLoggingLevel.hs
+++ b/HGamer3D/Bindings/Ogre/EnumLoggingLevel.hs
@@ -42,13 +42,9 @@
 import HGamer3D.Data.Angle
 
 
-data EnumLoggingLevel =
-   -- | 
-    LL_LOW
-   -- | 
-                         | LL_NORMAL
-   -- | 
-                         | LL_BOREME
+data EnumLoggingLevel = LL_LOW
+                      | LL_NORMAL
+                      | LL_BOREME
                       deriving (Eq)
 instance Enum EnumLoggingLevel where
   fromEnum LL_LOW = 1
diff --git a/HGamer3D/Bindings/Ogre/EnumMathAngleUnit.hs b/HGamer3D/Bindings/Ogre/EnumMathAngleUnit.hs
--- a/HGamer3D/Bindings/Ogre/EnumMathAngleUnit.hs
+++ b/HGamer3D/Bindings/Ogre/EnumMathAngleUnit.hs
@@ -42,9 +42,6 @@
 import HGamer3D.Data.Angle
 
 
-data EnumMathAngleUnit =
-   -- | 
-    AU_DEGREE
-   -- | 
-                          | AU_RADIAN
+data EnumMathAngleUnit = AU_DEGREE
+                       | AU_RADIAN
                        deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumMeshManagerMeshBuildType.hs b/HGamer3D/Bindings/Ogre/EnumMeshManagerMeshBuildType.hs
--- a/HGamer3D/Bindings/Ogre/EnumMeshManagerMeshBuildType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumMeshManagerMeshBuildType.hs
@@ -42,11 +42,7 @@
 import HGamer3D.Data.Angle
 
 
-data EnumMeshManagerMeshBuildType =
-   -- | 
-    MBT_PLANE
-   -- | 
-                                     | MBT_CURVED_ILLUSION_PLANE
-   -- | 
-                                     | MBT_CURVED_PLANE
+data EnumMeshManagerMeshBuildType = MBT_PLANE
+                                  | MBT_CURVED_ILLUSION_PLANE
+                                  | MBT_CURVED_PLANE
                                   deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumNodeTransformSpace.hs b/HGamer3D/Bindings/Ogre/EnumNodeTransformSpace.hs
--- a/HGamer3D/Bindings/Ogre/EnumNodeTransformSpace.hs
+++ b/HGamer3D/Bindings/Ogre/EnumNodeTransformSpace.hs
@@ -42,11 +42,7 @@
 import HGamer3D.Data.Angle
 
 
-data EnumNodeTransformSpace =
-   -- | Transform is relative to the local space. 
-    TS_LOCAL
-   -- | Transform is relative to the space of the parent node. 
-                               | TS_PARENT
-   -- | Transform is relative to world space. 
-                               | TS_WORLD
+data EnumNodeTransformSpace = TS_LOCAL
+                            | TS_PARENT
+                            | TS_WORLD
                             deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumOrientationMode.hs b/HGamer3D/Bindings/Ogre/EnumOrientationMode.hs
--- a/HGamer3D/Bindings/Ogre/EnumOrientationMode.hs
+++ b/HGamer3D/Bindings/Ogre/EnumOrientationMode.hs
@@ -42,21 +42,13 @@
 import HGamer3D.Data.Angle
 
 
-data EnumOrientationMode =
-   -- | 
-    OR_DEGREE_0
-   -- | 
-                            | OR_DEGREE_90
-   -- | 
-                            | OR_DEGREE_180
-   -- | 
-                            | OR_DEGREE_270
-   -- | 
-                            | OR_PORTRAIT
-   -- | 
-                            | OR_LANDSCAPERIGHT
-   -- | 
-                            | OR_LANDSCAPELEFT
+data EnumOrientationMode = OR_DEGREE_0
+                         | OR_DEGREE_90
+                         | OR_DEGREE_180
+                         | OR_DEGREE_270
+                         | OR_PORTRAIT
+                         | OR_LANDSCAPERIGHT
+                         | OR_LANDSCAPELEFT
                          deriving (Eq)
 instance Enum EnumOrientationMode where
   fromEnum OR_DEGREE_0 = 0
diff --git a/HGamer3D/Bindings/Ogre/EnumProjectionType.hs b/HGamer3D/Bindings/Ogre/EnumProjectionType.hs
--- a/HGamer3D/Bindings/Ogre/EnumProjectionType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumProjectionType.hs
@@ -42,9 +42,6 @@
 import HGamer3D.Data.Angle
 
 
-data EnumProjectionType =
-   -- | 
-    PT_ORTHOGRAPHIC
-   -- | 
-                           | PT_PERSPECTIVE
+data EnumProjectionType = PT_ORTHOGRAPHIC
+                        | PT_PERSPECTIVE
                         deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumRenderOperationOperationType.hs b/HGamer3D/Bindings/Ogre/EnumRenderOperationOperationType.hs
--- a/HGamer3D/Bindings/Ogre/EnumRenderOperationOperationType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumRenderOperationOperationType.hs
@@ -42,19 +42,12 @@
 import HGamer3D.Data.Angle
 
 
-data EnumRenderOperationOperationType =
-   -- | A list of points, 1 vertex per point. 
-    OT_POINT_LIST
-   -- | A list of lines, 2 vertices per line. 
-                                         | OT_LINE_LIST
-   -- | A strip of connected lines, 1 vertex per line plus 1 start vertex. 
-                                         | OT_LINE_STRIP
-   -- | A list of triangles, 3 vertices per triangle. 
-                                         | OT_TRIANGLE_LIST
-   -- | A strip of triangles, 3 vertices for the first triangle, and 1 per triangle after that. 
-                                         | OT_TRIANGLE_STRIP
-   -- | A fan of triangles, 3 vertices for the first triangle, and 1 per triangle after that. 
-                                         | OT_TRIANGLE_FAN
+data EnumRenderOperationOperationType = OT_POINT_LIST
+                                      | OT_LINE_LIST
+                                      | OT_LINE_STRIP
+                                      | OT_TRIANGLE_LIST
+                                      | OT_TRIANGLE_STRIP
+                                      | OT_TRIANGLE_FAN
                                       deriving (Eq)
 instance Enum EnumRenderOperationOperationType where
   fromEnum OT_POINT_LIST = 1
diff --git a/HGamer3D/Bindings/Ogre/EnumRenderTargetFrameBuffer.hs b/HGamer3D/Bindings/Ogre/EnumRenderTargetFrameBuffer.hs
--- a/HGamer3D/Bindings/Ogre/EnumRenderTargetFrameBuffer.hs
+++ b/HGamer3D/Bindings/Ogre/EnumRenderTargetFrameBuffer.hs
@@ -42,11 +42,7 @@
 import HGamer3D.Data.Angle
 
 
-data EnumRenderTargetFrameBuffer =
-   -- | 
-    FB_FRONT
-   -- | 
-                                    | FB_BACK
-   -- | 
-                                    | FB_AUTO
+data EnumRenderTargetFrameBuffer = FB_FRONT
+                                 | FB_BACK
+                                 | FB_AUTO
                                  deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumRenderTargetStatFlags.hs b/HGamer3D/Bindings/Ogre/EnumRenderTargetStatFlags.hs
--- a/HGamer3D/Bindings/Ogre/EnumRenderTargetStatFlags.hs
+++ b/HGamer3D/Bindings/Ogre/EnumRenderTargetStatFlags.hs
@@ -42,21 +42,13 @@
 import HGamer3D.Data.Angle
 
 
-data EnumRenderTargetStatFlags =
-   -- | 
-    SF_NONE
-   -- | 
-                                  | SF_FPS
-   -- | 
-                                  | SF_AVG_FPS
-   -- | 
-                                  | SF_BEST_FPS
-   -- | 
-                                  | SF_WORST_FPS
-   -- | 
-                                  | SF_TRIANGLE_COUNT
-   -- | 
-                                  | SF_ALL
+data EnumRenderTargetStatFlags = SF_NONE
+                               | SF_FPS
+                               | SF_AVG_FPS
+                               | SF_BEST_FPS
+                               | SF_WORST_FPS
+                               | SF_TRIANGLE_COUNT
+                               | SF_ALL
                                deriving (Eq)
 instance Enum EnumRenderTargetStatFlags where
   fromEnum SF_NONE = 0
diff --git a/HGamer3D/Bindings/Ogre/EnumRootFrameEventTimeType.hs b/HGamer3D/Bindings/Ogre/EnumRootFrameEventTimeType.hs
--- a/HGamer3D/Bindings/Ogre/EnumRootFrameEventTimeType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumRootFrameEventTimeType.hs
@@ -42,17 +42,11 @@
 import HGamer3D.Data.Angle
 
 
-data EnumRootFrameEventTimeType =
-   -- | 
-    FETT_ANY
-   -- | 
-                                   | FETT_STARTED
-   -- | 
-                                   | FETT_QUEUED
-   -- | 
-                                   | FETT_ENDED
-   -- | 
-                                   | FETT_COUNT
+data EnumRootFrameEventTimeType = FETT_ANY
+                                | FETT_STARTED
+                                | FETT_QUEUED
+                                | FETT_ENDED
+                                | FETT_COUNT
                                 deriving (Eq)
 instance Enum EnumRootFrameEventTimeType where
   fromEnum FETT_ANY = 0
diff --git a/HGamer3D/Bindings/Ogre/EnumSceneManagerBoxPlane.hs b/HGamer3D/Bindings/Ogre/EnumSceneManagerBoxPlane.hs
--- a/HGamer3D/Bindings/Ogre/EnumSceneManagerBoxPlane.hs
+++ b/HGamer3D/Bindings/Ogre/EnumSceneManagerBoxPlane.hs
@@ -42,19 +42,12 @@
 import HGamer3D.Data.Angle
 
 
-data EnumSceneManagerBoxPlane =
-   -- | 
-    BP_FRONT
-   -- | 
-                                 | BP_BACK
-   -- | 
-                                 | BP_LEFT
-   -- | 
-                                 | BP_RIGHT
-   -- | 
-                                 | BP_UP
-   -- | 
-                                 | BP_DOWN
+data EnumSceneManagerBoxPlane = BP_FRONT
+                              | BP_BACK
+                              | BP_LEFT
+                              | BP_RIGHT
+                              | BP_UP
+                              | BP_DOWN
                               deriving (Eq)
 instance Enum EnumSceneManagerBoxPlane where
   fromEnum BP_FRONT = 0
diff --git a/HGamer3D/Bindings/Ogre/EnumSceneManagerIlluminationRenderStage.hs b/HGamer3D/Bindings/Ogre/EnumSceneManagerIlluminationRenderStage.hs
--- a/HGamer3D/Bindings/Ogre/EnumSceneManagerIlluminationRenderStage.hs
+++ b/HGamer3D/Bindings/Ogre/EnumSceneManagerIlluminationRenderStage.hs
@@ -42,11 +42,7 @@
 import HGamer3D.Data.Angle
 
 
-data EnumSceneManagerIlluminationRenderStage =
-   -- | No special illumination stage. 
-    IRS_NONE
-   -- | Render to texture stage, used for texture based shadows. 
-                                                | IRS_RENDER_TO_TEXTURE
-   -- | Render from shadow texture to receivers stage. 
-                                                | IRS_RENDER_RECEIVER_PASS
+data EnumSceneManagerIlluminationRenderStage = IRS_NONE
+                                             | IRS_RENDER_TO_TEXTURE
+                                             | IRS_RENDER_RECEIVER_PASS
                                              deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumSceneManagerPrefabType.hs b/HGamer3D/Bindings/Ogre/EnumSceneManagerPrefabType.hs
--- a/HGamer3D/Bindings/Ogre/EnumSceneManagerPrefabType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumSceneManagerPrefabType.hs
@@ -42,11 +42,7 @@
 import HGamer3D.Data.Angle
 
 
-data EnumSceneManagerPrefabType =
-   -- | 
-    PT_PLANE
-   -- | 
-                                   | PT_CUBE
-   -- | 
-                                   | PT_SPHERE
+data EnumSceneManagerPrefabType = PT_PLANE
+                                | PT_CUBE
+                                | PT_SPHERE
                                 deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumSceneManagerSpecialCaseRenderQueueMode.hs b/HGamer3D/Bindings/Ogre/EnumSceneManagerSpecialCaseRenderQueueMode.hs
--- a/HGamer3D/Bindings/Ogre/EnumSceneManagerSpecialCaseRenderQueueMode.hs
+++ b/HGamer3D/Bindings/Ogre/EnumSceneManagerSpecialCaseRenderQueueMode.hs
@@ -42,9 +42,6 @@
 import HGamer3D.Data.Angle
 
 
-data EnumSceneManagerSpecialCaseRenderQueueMode =
-   -- | Render only the queues in the special case list. 
-    SCRQM_INCLUDE
-   -- | Render all except the queues in the special case list. 
-                                                   | SCRQM_EXCLUDE
+data EnumSceneManagerSpecialCaseRenderQueueMode = SCRQM_INCLUDE
+                                                | SCRQM_EXCLUDE
                                                 deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumSceneType.hs b/HGamer3D/Bindings/Ogre/EnumSceneType.hs
--- a/HGamer3D/Bindings/Ogre/EnumSceneType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumSceneType.hs
@@ -42,17 +42,11 @@
 import HGamer3D.Data.Angle
 
 
-data EnumSceneType =
-   -- | 
-    ST_GENERIC
-   -- | 
-                      | ST_EXTERIOR_CLOSE
-   -- | 
-                      | ST_EXTERIOR_FAR
-   -- | 
-                      | ST_EXTERIOR_REAL_FAR
-   -- | 
-                      | ST_INTERIOR
+data EnumSceneType = ST_GENERIC
+                   | ST_EXTERIOR_CLOSE
+                   | ST_EXTERIOR_FAR
+                   | ST_EXTERIOR_REAL_FAR
+                   | ST_INTERIOR
                    deriving (Eq)
 instance Enum EnumSceneType where
   fromEnum ST_GENERIC = 1
diff --git a/HGamer3D/Bindings/Ogre/EnumSkeletonAnimationBlendMode.hs b/HGamer3D/Bindings/Ogre/EnumSkeletonAnimationBlendMode.hs
--- a/HGamer3D/Bindings/Ogre/EnumSkeletonAnimationBlendMode.hs
+++ b/HGamer3D/Bindings/Ogre/EnumSkeletonAnimationBlendMode.hs
@@ -42,11 +42,8 @@
 import HGamer3D.Data.Angle
 
 
-data EnumSkeletonAnimationBlendMode =
-   -- | Animations are applied by calculating a weighted average of all animations. 
-    ANIMBLEND_AVERAGE
-   -- | Animations are applied by calculating a weighted cumulative total. 
-                                       | ANIMBLEND_CUMULATIVE
+data EnumSkeletonAnimationBlendMode = ANIMBLEND_AVERAGE
+                                    | ANIMBLEND_CUMULATIVE
                                     deriving (Eq)
 instance Enum EnumSkeletonAnimationBlendMode where
   fromEnum ANIMBLEND_AVERAGE = 0
diff --git a/HGamer3D/Bindings/Ogre/EnumStencilOperation.hs b/HGamer3D/Bindings/Ogre/EnumStencilOperation.hs
--- a/HGamer3D/Bindings/Ogre/EnumStencilOperation.hs
+++ b/HGamer3D/Bindings/Ogre/EnumStencilOperation.hs
@@ -42,21 +42,12 @@
 import HGamer3D.Data.Angle
 
 
-data EnumStencilOperation =
-   -- | Leave the stencil buffer unchanged. 
-    SOP_KEEP
-   -- | Set the stencil value to zero. 
-                             | SOP_ZERO
-   -- | Set the stencil value to the reference value. 
-                             | SOP_REPLACE
-   -- | Increase the stencil value by 1, clamping at the maximum value. 
-                             | SOP_INCREMENT
-   -- | Decrease the stencil value by 1, clamping at 0. 
-                             | SOP_DECREMENT
-   -- | Increase the stencil value by 1, wrapping back to 0 when incrementing the maximum value. 
-                             | SOP_INCREMENT_WRAP
-   -- | Decrease the stencil value by 1, wrapping when decrementing 0. 
-                             | SOP_DECREMENT_WRAP
-   -- | Invert the bits of the stencil buffer. 
-                             | SOP_INVERT
+data EnumStencilOperation = SOP_KEEP
+                          | SOP_ZERO
+                          | SOP_REPLACE
+                          | SOP_INCREMENT
+                          | SOP_DECREMENT
+                          | SOP_INCREMENT_WRAP
+                          | SOP_DECREMENT_WRAP
+                          | SOP_INVERT
                           deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumTexCoordCalcMethod.hs b/HGamer3D/Bindings/Ogre/EnumTexCoordCalcMethod.hs
--- a/HGamer3D/Bindings/Ogre/EnumTexCoordCalcMethod.hs
+++ b/HGamer3D/Bindings/Ogre/EnumTexCoordCalcMethod.hs
@@ -42,17 +42,10 @@
 import HGamer3D.Data.Angle
 
 
-data EnumTexCoordCalcMethod =
-   -- | No calculated texture coordinates. 
-    TEXCALC_NONE
-   -- | Environment map based on vertex normals. 
-                               | TEXCALC_ENVIRONMENT_MAP
-   -- | Environment map based on vertex positions. 
-                               | TEXCALC_ENVIRONMENT_MAP_PLANAR
-   -- | 
-                               | TEXCALC_ENVIRONMENT_MAP_REFLECTION
-   -- | 
-                               | TEXCALC_ENVIRONMENT_MAP_NORMAL
-   -- | Projective texture. 
-                               | TEXCALC_PROJECTIVE_TEXTURE
+data EnumTexCoordCalcMethod = TEXCALC_NONE
+                            | TEXCALC_ENVIRONMENT_MAP
+                            | TEXCALC_ENVIRONMENT_MAP_PLANAR
+                            | TEXCALC_ENVIRONMENT_MAP_REFLECTION
+                            | TEXCALC_ENVIRONMENT_MAP_NORMAL
+                            | TEXCALC_PROJECTIVE_TEXTURE
                             deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumVertexAnimationTrackTargetMode.hs b/HGamer3D/Bindings/Ogre/EnumVertexAnimationTrackTargetMode.hs
--- a/HGamer3D/Bindings/Ogre/EnumVertexAnimationTrackTargetMode.hs
+++ b/HGamer3D/Bindings/Ogre/EnumVertexAnimationTrackTargetMode.hs
@@ -42,9 +42,6 @@
 import HGamer3D.Data.Angle
 
 
-data EnumVertexAnimationTrackTargetMode =
-   -- | Interpolate vertex positions in software. 
-    TM_SOFTWARE
-   -- |  Bind keyframe 1 to position, and keyframe 2 to a texture coordinate for interpolation in hardware 
-                                           | TM_HARDWARE
+data EnumVertexAnimationTrackTargetMode = TM_SOFTWARE
+                                        | TM_HARDWARE
                                         deriving (Enum,Eq)
diff --git a/HGamer3D/Bindings/Ogre/EnumVertexAnimationType.hs b/HGamer3D/Bindings/Ogre/EnumVertexAnimationType.hs
--- a/HGamer3D/Bindings/Ogre/EnumVertexAnimationType.hs
+++ b/HGamer3D/Bindings/Ogre/EnumVertexAnimationType.hs
@@ -42,13 +42,9 @@
 import HGamer3D.Data.Angle
 
 
-data EnumVertexAnimationType =
-   -- | No animation. 
-    VAT_NONE
-   -- | Morph animation is made up of many interpolated snapshot keyframes. 
-                                | VAT_MORPH
-   -- | Pose animation is made up of a single delta pose keyframe. 
-                                | VAT_POSE
+data EnumVertexAnimationType = VAT_NONE
+                             | VAT_MORPH
+                             | VAT_POSE
                              deriving (Eq)
 instance Enum EnumVertexAnimationType where
   fromEnum VAT_NONE = 0
diff --git a/include/OgreDllDefines.h b/include/OgreDllDefines.h
--- a/include/OgreDllDefines.h
+++ b/include/OgreDllDefines.h
@@ -16,10 +16,10 @@
 
 // OgreDllDefines.h
 
-#ifndef _HGamer3DOgre019_DLLDEFINES_H_
-#define _HGamer3DOgre019_DLLDEFINES_H_
+#ifndef _HGamer3DOgre020_DLLDEFINES_H_
+#define _HGamer3DOgre020_DLLDEFINES_H_
 
-/* Cmake will define HGamer3DOgre019_EXPORTS on Windows when it
+/* Cmake will define HGamer3DOgre020_EXPORTS on Windows when it
 configures to build a shared library. If you are going to use
 another build system on windows or create the visual studio
 projects by hand you need to define MyLibrary_EXPORTS when
@@ -29,13 +29,13 @@
 // We are using the Visual Studio Compiler and building Shared libraries
 
 #if (defined (_WIN32)) && !(defined (__GNUC__)) 
-  #if defined(HGamer3DOgre019_EXPORTS)
+  #if defined(HGamer3DOgre020_EXPORTS)
     #define  Ogre_LIB_EXPORT __declspec(dllexport)
   #else
     #define  Ogre_LIB_EXPORT __declspec(dllimport)
-  #endif /* HGamer3DOgre019_EXPORTS */
+  #endif /* HGamer3DOgre020_EXPORTS */
 #else /* defined (_WIN32) */
  #define Ogre_LIB_EXPORT
 #endif
 
-#endif /* _HGamer3DOgre019_DLLDEFINES_H_ */
+#endif /* _HGamer3DOgre020_DLLDEFINES_H_ */